// FIXME: KstPlugin should not know about fit scalars!!
void KstPlugin::createFitScalars() {
if (_plugin->data()._isFit && _outputVectors.contains("Parameters")) {
KstVectorPtr vectorParam = _outputVectors["Parameters"];
if (vectorParam) {
QString paramName;
int i = 0;
int length = vectorParam->length();
for (paramName = _plugin->parameterName(i);
!paramName.isEmpty() && i < length;
paramName = _plugin->parameterName(++i)) {
double scalarValue = vectorParam->value(i);
if (!_outputScalars.contains(paramName)) {
QString scalarName = i18n("%1-%2").arg(tagName()).arg(paramName);
KstScalarPtr s = new KstScalar(scalarName, scalarValue);
s->writeLock();
s->setProvider(this);
s->writeUnlock();
_outputScalars.insert(paramName, s);
} else {
_outputScalars[paramName]->setValue(scalarValue);
}
}
}
}
}
QString CrossPowerSpectrum::sampleTag() const {
KstScalarPtr s = sample();
if (s) {
return s->tagName();
}
return QString::null;
}
const QString& KstIfaceImpl::generateScalar(const QString& name, double value) {
KstScalarPtr s = new KstScalar(name, 0L, value);
KstReadLocker rl(s);
s->setOrphan(true);
s->setEditable(true);
return s->tagName();
}
void KstPluginDialogI::generateEntries(bool input, int& cnt, QWidget *parent, QGridLayout *grid, const QValueList<Plugin::Data::IOValue>& table) {
QString scalarLabelTemplate, vectorLabelTemplate;
if (input) {
scalarLabelTemplate = i18n("Input Scalar - %1:");
vectorLabelTemplate = i18n("Input Vector - %1:");
} else {
scalarLabelTemplate = i18n("Output Scalar - %1:");
vectorLabelTemplate = i18n("Output Vector - %1:");
}
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = table.begin(); it != table.end(); ++it) {
QString labellabel;
bool scalar = false;
switch ((*it)._type) {
case Plugin::Data::IOValue::FloatType:
labellabel = scalarLabelTemplate.arg((*it)._name);
scalar = true;
break;
case Plugin::Data::IOValue::TableType:
if ((*it)._subType == Plugin::Data::IOValue::FloatSubType) {
labellabel = vectorLabelTemplate.arg((*it)._name);
} else {
// unsupported
continue;
}
break;
default:
// unsupported
continue;
}
QLabel *label = new QLabel(labellabel, parent, input ? "Input label" : "Output label");
QWidget *widget = 0L;
if (input) {
if (scalar) {
ScalarSelector *w = new ScalarSelector(parent, (*it)._name.latin1());
widget = w;
connect(w->_scalar, SIGNAL(activated(const QString&)), this, SLOT(updateScalarTooltip(const QString&)));
connect(widget, SIGNAL(newScalarCreated()), this, SIGNAL(modified()));
KstScalarPtr p = *KST::scalarList.findTag(w->_scalar->currentText());
if (p) {
QToolTip::add(w->_scalar, QString::number(p->value()));
}
} else {
widget = new VectorSelector(parent, (*it)._name.latin1());
connect(widget, SIGNAL(newVectorCreated(const QString&)), this, SIGNAL(modified()));
}
} else {
KstDataObjectPtr KstPlugin::makeDuplicate(KstDataObjectDataObjectMap& duplicatedMap) {
KstPluginPtr plugin = new KstPlugin;
// use same inputs
for (KstVectorMap::ConstIterator iter = _inputVectors.begin(); iter != _inputVectors.end(); ++iter) {
plugin->inputVectors().insert(iter.key(), iter.data());
}
for (KstScalarMap::ConstIterator iter = _inputScalars.begin(); iter != _inputScalars.end(); ++iter) {
plugin->inputScalars().insert(iter.key(), iter.data());
}
for (KstStringMap::ConstIterator iter = _inputStrings.begin(); iter != _inputStrings.end(); ++iter) {
plugin->inputStrings().insert(iter.key(), iter.data());
}
// create new outputs
for (KstVectorMap::ConstIterator iter = outputVectors().begin(); iter != outputVectors().end(); ++iter) {
KstVectorPtr v = new KstVector;
v->writeLock();
plugin->outputVectors().insert(iter.key(), v);
v->setTagName(iter.data()->tagName() + "'");
v->setProvider(plugin.data());
KST::addVectorToList(v);
v->writeUnlock();
}
for (KstScalarMap::ConstIterator iter = outputScalars().begin(); iter != outputScalars().end(); ++iter) {
KstScalarPtr s = new KstScalar;
s->writeLock();
plugin->outputScalars().insert(iter.key(), s);
s->setTagName(iter.data()->tagName() + "'");
s->setProvider(plugin.data());
s->writeUnlock();
}
for (KstStringMap::ConstIterator iter = outputStrings().begin(); iter != outputStrings().end(); ++iter) {
KstStringPtr s = new KstString;
s->writeLock();
plugin->outputStrings().insert(iter.key(), s);
s->setTagName(iter.data()->tagName() + "'");
s->setProvider(plugin.data());
s->writeUnlock();
}
// set the same plugin
plugin->setPlugin(_plugin);
plugin->setTagName(tagName() + "'");
duplicatedMap.insert(this, KstDataObjectPtr(plugin));
return KstDataObjectPtr(plugin);
}
// Remove some elements from the vector starting from vector[0]
bool Trim::algorithm() {
KstVectorPtr input = inputVector(INPUT);
KstScalarPtr remove = inputScalar(REMOVE);
KstVectorPtr cut = outputVector(CUT);
bool rc = false;
if (input->length() > remove->value()) {
int cutSize = (int)input->length() - (int)remove->value();
cut->resize( cutSize, false );
for (int j=0; j<cutSize; j++) {
cut->value()[j] = input->value()[(int)remove->value()+j];
}
rc = true;
}
return rc;
}
QString KstCPlugin::label(int precision) const {
QString label;
label = i18n("%1: %2").arg(plugin()->data()._readableName).arg(tagName());
if ((outputVectors())["Parameters"]) {
QString strParamName;
QString strValue;
int length = (outputVectors())["Parameters"]->length();
int i = 0;
for (strParamName = plugin()->parameterName(0);
!strParamName.isEmpty() && i < length;
strParamName = plugin()->parameterName(++i)) {
KstScalarPtr scalar = outputScalars()[strParamName];
if (scalar) {
strValue = QString::number(scalar->value(), 'g', precision);
label += i18n("\n%1: %2").arg(strParamName).arg(strValue);
}
}
}
return label;
}
bool NoiseAddition::algorithm() {
KstVectorPtr array = inputVector(ARRAY);
KstScalarPtr sigma = inputScalar(SIGMA);
KstVectorPtr output = outputVector(OUTPUT);
const gsl_rng_type* pGeneratorType;
gsl_rng* pRandomNumberGenerator;
double* pResult[1];
int iRetVal = false;
int iLength = array->length();
pResult[0] = 0L;
if (iLength > 0) {
if (output->length() != iLength) {
output->resize(iLength, false);
pResult[0] = (double*)realloc( output->value(), iLength * sizeof( double ) );
} else {
pResult[0] = output->value();
}
}
pGeneratorType = gsl_rng_default;
pRandomNumberGenerator = gsl_rng_alloc( pGeneratorType );
if (pRandomNumberGenerator != NULL) {
if (pResult[0] != NULL) {
for (int i=0; i<iLength; i++) {
output->value()[i] = array->value()[i] + gsl_ran_gaussian( pRandomNumberGenerator, sigma->value() );
}
iRetVal = true;
}
gsl_rng_free( pRandomNumberGenerator );
}
return iRetVal;
}
bool Phase::algorithm() {
KstVectorPtr time = inputVector(TIME);
KstVectorPtr data_i = inputVector(DATA_I);
KstScalarPtr period = inputScalar(PERIOD);
KstScalarPtr zero = inputScalar(ZERO);
KstVectorPtr phase = outputVector(PHASE);
KstVectorPtr data_o = outputVector(DATA_O);
double* pResult[2];
double dPhasePeriod = period->value();
double dPhaseZero = zero->value();
int iLength;
bool iRetVal = false;
if (dPhasePeriod > 0.0) {
if (time->length() == data_i->length()) {
iLength = time->length();
if (phase->length() != iLength) {
phase->resize(iLength, true);
pResult[0] = (double*)realloc( phase->value(), iLength * sizeof( double ) );
} else {
pResult[0] = phase->value();
}
if (data_o->length() != iLength) {
data_o->resize(iLength, true);
pResult[1] = (double*)realloc( data_o->value(), iLength * sizeof( double ) );
} else {
pResult[1] = data_o->value();
}
if (pResult[0] != NULL && pResult[1] != NULL) {
for (int i = 0; i < phase->length(); ++i) {
phase->value()[i] = pResult[0][i];
}
for (int i = 0; i < data_o->length(); ++i) {
data_o->value()[i] = pResult[1][i];
}
/*
determine the phase...
*/
for (int i=0; i<iLength; i++) {
phase->value()[i] = fmod( ( time->value()[i] - dPhaseZero ) / dPhasePeriod, 1.0 );
}
/*
sort by phase...
*/
memcpy( data_o->value(), data_i->value(), iLength * sizeof( double ) );
double* sort[2];
sort[0] = phase->value();
sort[1] = data_o->value();
quicksort( sort, 0, iLength-1 );
iRetVal = true;
}
}
}
return iRetVal;
}
KstObject::UpdateType KstCPlugin::update(int update_counter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (!isValid()) {
return setLastUpdateResult(NO_CHANGE);
}
if (recursed()) {
return setLastUpdateResult(NO_CHANGE);
}
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(update_counter) && !force) {
return lastUpdateResult();
}
#define CLEANUP() do {\
for (unsigned i = 0; i < _outStringCnt; ++i) { \
if (_outStrings[i]) { \
free(_outStrings[i]); \
_outStrings[i] = 0L; \
} \
} \
for (unsigned i = 0; i < _inStringCnt; ++i) { \
if (_inStrings[i]) { \
free(_inStrings[i]); \
_inStrings[i] = 0L; \
} \
} \
} while(0)
writeLockInputsAndOutputs();
const QValueList<Plugin::Data::IOValue>& itable = _plugin->data()._inputs;
const QValueList<Plugin::Data::IOValue>& otable = _plugin->data()._outputs;
int itcnt = 0, vitcnt = 0, sitcnt = 0;
bool doUpdate = force;
// Populate the input scalars and vectors
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = itable.begin(); it != itable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
if (!_inputVectors.contains((*it)._name)) {
KstDebug::self()->log(i18n("Input vector [%1] for plugin %2 not found. Unable to continue.").arg((*it)._name).arg(tagName()), KstDebug::Error);
CLEANUP();
return setLastUpdateResult(NO_CHANGE);
}
KstVectorPtr iv = _inputVectors[(*it)._name];
if (!iv) {
kstdFatal() << "Input vector \"" << (*it)._name << "\" for plugin " << tag().displayString() << " is invalid." << endl;
}
doUpdate = (UPDATE == iv->update(update_counter)) || doUpdate;
_inVectors[vitcnt] = iv->value();
_inArrayLens[vitcnt++] = iv->length();
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
KstScalarPtr is = _inputScalars[(*it)._name];
if (!is) {
kstdFatal() << "Input scalar \"" << (*it)._name << "\" for plugin " << tag().displayString() << " is invalid." << endl;
}
doUpdate = (UPDATE == is->update(update_counter)) || doUpdate;
_inScalars[itcnt++] = is->value();
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
KstStringPtr is = _inputStrings[(*it)._name];
if (!is) {
kstdFatal() << "Input string \"" << (*it)._name << "\" for plugin " << tag().displayString() << " is invalid." << endl;
}
doUpdate = (UPDATE == is->update(update_counter)) || doUpdate;
// Maybe we should use UTF-8 instead?
_inStrings[sitcnt++] = strdup(is->value().latin1());
} else if ((*it)._type == Plugin::Data::IOValue::PidType) {
_inScalars[itcnt++] = getpid();
}
}
if (!doUpdate) {
CLEANUP();
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
vitcnt = 0;
// Populate the output vectors
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin();
it != otable.end();
++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
if (!_outputVectors.contains((*it)._name)) {
KstDebug::self()->log(i18n("Output vector [%1] for plugin %2 not found. Unable to continue.").arg((*it)._name).arg(tagName()), KstDebug::Error);
CLEANUP();
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
_outVectors[vitcnt] = _outputVectors[(*it)._name]->value();
_outArrayLens[vitcnt++] = _outputVectors[(*it)._name]->length();
}
}
if (_outStringCnt > 0) {
memset(_outStrings, 0, _outStringCnt*sizeof(char *));
}
int rc;
if (_inStringCnt > 0 || _outStringCnt > 0) {
if (_plugin->data()._localdata) {
rc = _plugin->call(_inVectors, _inArrayLens, _inScalars,
_outVectors, _outArrayLens, _outScalars,
const_cast<const char**>(_inStrings), _outStrings, &_localData);
} else {
rc = _plugin->call(_inVectors, _inArrayLens, _inScalars,
_outVectors, _outArrayLens, _outScalars,
const_cast<const char**>(_inStrings), _outStrings);
}
} else {
if (_plugin->data()._localdata) {
rc = _plugin->call(_inVectors, _inArrayLens, _inScalars,
_outVectors, _outArrayLens, _outScalars, &_localData);
} else {
rc = _plugin->call(_inVectors, _inArrayLens, _inScalars,
_outVectors, _outArrayLens, _outScalars);
}
}
if (rc == 0) {
itcnt = 0;
vitcnt = 0;
sitcnt = 0;
setLastUpdateResult(UPDATE); // make sure that provider callbacks work
// Read back the output vectors and scalars
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin();
it != otable.end();
++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
KstVectorPtr vp = _outputVectors[(*it)._name];
vectorRealloced(vp, _outVectors[vitcnt], _outArrayLens[vitcnt]);
vp->setDirty();
// Inefficient, but do we have any other choice? We don't really know
// from the plugin how much of this vector is "new" or "shifted"
vp->setNewAndShift(vp->length(), vp->numShift());
vp->update(update_counter);
vitcnt++;
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
KstScalarPtr sp = _outputScalars[(*it)._name];
sp->setValue(_outScalars[itcnt++]);
sp->update(update_counter);
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
KstStringPtr sp = _outputStrings[(*it)._name];
sp->setValue(_outStrings[sitcnt++]);
sp->update(update_counter);
}
}
// if we have a fit plugin then create the necessary scalars from the parameter vector
createFitScalars();
_lastError = QString::null;
} else if (rc > 0) {
if (_lastError.isEmpty()) {
const char *err = _plugin->errorCode(rc);
if (err && *err) {
_lastError = err;
KstDebug::self()->log(i18n("Plugin %1 produced error: %2.").arg(tagName()).arg(_lastError), KstDebug::Error);
} else {
_lastError = QString::null;
}
}
} else {
bool doSend = _lastError.isEmpty() ? true : false;
switch (rc) {
case -1:
_lastError = i18n("Generic Error");
break;
case -2:
_lastError = i18n("Input Error");
break;
case -3:
_lastError = i18n("Memory Error");
break;
default:
_lastError = i18n("Unknown Error");
break;
}
if (doSend) {
KstDebug::self()->log(i18n("Plugin %2 produced error: %1.").arg(_lastError).arg(tagName()), KstDebug::Error);
}
}
unlockInputsAndOutputs();
CLEANUP();
#undef CLEANUP
return setLastUpdateResult(UPDATE);
}
bool KstPluginDialogI::saveOutputs(KstCPluginPtr plugin, KstSharedPtr<Plugin> p) {
const QValueList<Plugin::Data::IOValue>& otable = p->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin(); it != otable.end(); ++it) {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "QLineEdit");
if (!field) {
continue; // Some are unsupported
}
QLineEdit *li = static_cast<QLineEdit*>(field);
if (li->text().isEmpty()) {
li->setText((*it)._name);
}
QString nt = li->text();
if ((*it)._type == Plugin::Data::IOValue::TableType) {
if (!KstData::self()->vectorTagNameNotUnique(nt, false)) {
// Implicitly creates it if it doesn't exist
KstVectorPtr v = plugin->outputVectors()[(*it)._name];
if (!v) {
KstWriteLocker blockVectorUpdates(&KST::vectorList.lock());
v = new KstVector(KstObjectTag(nt, plugin->tag()), 0, plugin.data());
plugin->outputVectors().insert((*it)._name, v);
}
v->setTagName(KstObjectTag(nt, plugin->tag()));
} else if (plugin->outputVectors()[(*it)._name]->tagName() != nt) {
while (KstData::self()->vectorTagNameNotUnique(nt, false)) {
nt += "'";
}
KstVectorPtr v;
if (plugin->outputVectors().contains((*it)._name)) {
v = plugin->outputVectors()[(*it)._name];
} else {
KstWriteLocker blockVectorUpdates(&KST::vectorList.lock());
v = new KstVector(KstObjectTag(nt, plugin->tag()), 0, plugin.data());
plugin->outputVectors().insert((*it)._name, v);
}
v->setTagName(KstObjectTag(nt, plugin->tag()));
}
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
if (!KstData::self()->vectorTagNameNotUnique(nt, false)) {
KstStringPtr s;
if (plugin->outputStrings().contains((*it)._name)) {
s = plugin->outputStrings()[(*it)._name];
} else {
KstWriteLocker blockStringUpdates(&KST::stringList.lock());
s = new KstString(KstObjectTag(nt, plugin->tag()), plugin.data());
plugin->outputStrings().insert((*it)._name, s);
}
s->setTagName(KstObjectTag(nt, plugin->tag()));
} else if (plugin->outputStrings()[(*it)._name]->tagName() != nt) {
while (KstData::self()->vectorTagNameNotUnique(nt, false)) {
nt += "'";
}
KstStringPtr s;
if (plugin->outputStrings().contains((*it)._name)) {
s = plugin->outputStrings()[(*it)._name];
} else {
KstWriteLocker blockStringUpdates(&KST::stringList.lock());
s = new KstString(KstObjectTag(nt, plugin->tag()), plugin.data());
plugin->outputStrings().insert((*it)._name, s);
}
s->setTagName(KstObjectTag(nt, plugin->tag()));
}
} else if ((*it)._type == Plugin::Data::IOValue::PidType) {
// Nothing
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
if (!KstData::self()->vectorTagNameNotUnique(nt, false)) {
KstScalarPtr s;
if (plugin->outputScalars().contains((*it)._name)) {
s = plugin->outputScalars()[(*it)._name];
} else {
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
s = new KstScalar(KstObjectTag(nt, plugin->tag()), plugin.data());
plugin->outputScalars().insert((*it)._name, s);
}
s->setTagName(KstObjectTag(nt, plugin->tag()));
} else if (plugin->outputScalars()[(*it)._name]->tagName() != nt) {
while (KstData::self()->vectorTagNameNotUnique(nt, false)) {
nt += "'";
}
KstScalarPtr s;
if (plugin->outputScalars().contains((*it)._name)) {
s = plugin->outputScalars()[(*it)._name];
} else {
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
s = new KstScalar(KstObjectTag(nt, plugin->tag()), plugin.data());
plugin->outputScalars().insert((*it)._name, s);
}
s->setTagName(KstObjectTag(nt, plugin->tag()));
}
}
}
return true;
}
void KstPluginDialogI::generateEntries(bool input, int& cnt, QWidget *parent, QGridLayout *grid, const QValueList<Plugin::Data::IOValue>& table) {
QString scalarLabelTemplate, vectorLabelTemplate, stringLabelTemplate;
if (input) {
stringLabelTemplate = i18n("Input string - %1:");
scalarLabelTemplate = i18n("Input scalar - %1:");
vectorLabelTemplate = i18n("Input vector - %1:");
} else {
stringLabelTemplate = i18n("Output string - %1:");
scalarLabelTemplate = i18n("Output scalar - %1:");
vectorLabelTemplate = i18n("Output vector - %1:");
}
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = table.begin(); it != table.end(); ++it) {
QString labellabel;
bool scalar = false;
bool string = false;
switch ((*it)._type) {
case Plugin::Data::IOValue::PidType:
continue;
case Plugin::Data::IOValue::StringType:
labellabel = stringLabelTemplate.arg((*it)._name);
string = true;
break;
case Plugin::Data::IOValue::FloatType:
labellabel = scalarLabelTemplate.arg((*it)._name);
scalar = true;
break;
case Plugin::Data::IOValue::TableType:
if ((*it)._subType == Plugin::Data::IOValue::FloatSubType ||
(*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
labellabel = vectorLabelTemplate.arg((*it)._name);
} else {
// unsupported
continue;
}
break;
default:
// unsupported
continue;
}
QLabel *label = new QLabel(labellabel, parent, input ? "Input label" : "Output label");
QWidget *widget = 0L;
if (input) {
if (scalar) {
ScalarSelector *w = new ScalarSelector(parent, (*it)._name.latin1());
widget = w;
connect(w->_scalar, SIGNAL(activated(const QString&)), this, SLOT(updateScalarTooltip(const QString&)));
connect(widget, SIGNAL(newScalarCreated()), this, SIGNAL(modified()));
if (!(*it)._default.isEmpty()) {
w->_scalar->insertItem((*it)._default);
w->_scalar->setCurrentText((*it)._default);
}
KstScalarPtr p = *KST::scalarList.findTag(w->_scalar->currentText());
w->allowDirectEntry(true);
if (p) {
p->readLock();
QToolTip::remove(w->_scalar);
QToolTip::add(w->_scalar, QString::number(p->value()));
p->unlock();
}
} else if (string) {
StringSelector *w = new StringSelector(parent, (*it)._name.latin1());
widget = w;
connect(w->_string, SIGNAL(activated(const QString&)), this, SLOT(updateStringTooltip(const QString&)));
connect(widget, SIGNAL(newStringCreated()), this, SIGNAL(modified()));
if (!(*it)._default.isEmpty()) {
w->_string->insertItem((*it)._default);
w->_string->setCurrentText((*it)._default);
}
KstStringPtr p = *KST::stringList.findTag(w->_string->currentText());
w->allowDirectEntry(true);
if (p) {
p->readLock();
QToolTip::remove(w->_string);
QToolTip::add(w->_string, p->value());
p->unlock();
}
} else {
widget = new VectorSelector(parent, (*it)._name.latin1());
connect(widget, SIGNAL(newVectorCreated(const QString&)), this, SIGNAL(modified()));
}
} else {
bool KstPluginDialogI::saveInputs(KstCPluginPtr plugin, KstSharedPtr<Plugin> p) {
bool rc = true;
KST::vectorList.lock().readLock();
KST::scalarList.lock().readLock();
KST::stringList.lock().readLock();
const QValueList<Plugin::Data::IOValue>& itable = p->data()._inputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = itable.begin(); it != itable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "VectorSelector");
assert(field);
VectorSelector *vs = static_cast<VectorSelector*>(field);
KstVectorPtr v = *KST::vectorList.findTag(vs->selectedVector());
if (v) {
v->writeLock(); // to match with plugin->writeLock()
if (plugin->inputVectors().contains((*it)._name) && plugin->inputVectors()[(*it)._name] != v) {
plugin->inputVectors()[(*it)._name]->unlock();
}
plugin->inputVectors().insert((*it)._name, v);
} else if (plugin->inputVectors().contains((*it)._name)) {
plugin->inputVectors().erase((*it)._name);
rc = false;
}
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "StringSelector");
assert(field);
StringSelector *ss = static_cast<StringSelector*>(field);
KstStringPtr s = *KST::stringList.findTag(ss->selectedString());
if (s == *KST::stringList.end()) {
QString val = ss->_string->currentText();
KstStringPtr newString = new KstString(ss->_string->currentText(), 0L, val, true, false);
newString->writeLock(); // to match with plugin->writeLock()
if (plugin->inputStrings().contains((*it)._name) && plugin->inputStrings()[(*it)._name] != s) {
plugin->inputStrings()[(*it)._name]->unlock();
}
plugin->inputStrings().insert((*it)._name, newString);
} else {
s->writeLock(); // to match with plugin->writeLock()
if (plugin->inputStrings().contains((*it)._name) && plugin->inputStrings()[(*it)._name] != s) {
plugin->inputStrings()[(*it)._name]->unlock();
}
plugin->inputStrings().insert((*it)._name, s);
}
} else if ((*it)._type == Plugin::Data::IOValue::PidType) {
// Nothing
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "ScalarSelector");
assert(field);
ScalarSelector *ss = static_cast<ScalarSelector*>(field);
KstScalarPtr s = *KST::scalarList.findTag(ss->selectedScalar());
if (s == *KST::scalarList.end()) {
bool ok;
double val = ss->_scalar->currentText().toDouble(&ok);
if (ok) {
KstScalarPtr newScalar = new KstScalar(ss->_scalar->currentText(), 0L, val, true, false, false);
newScalar->writeLock(); // to match with plugin->writeLock()
if (plugin->inputScalars().contains((*it)._name) && plugin->inputScalars()[(*it)._name] != s) {
plugin->inputScalars()[(*it)._name]->unlock();
}
plugin->inputScalars().insert((*it)._name, newScalar);
} else {
s->writeLock(); // to match with plugin->writeLock()
if (plugin->inputScalars().contains((*it)._name) && plugin->inputScalars()[(*it)._name] != s) {
plugin->inputScalars()[(*it)._name]->unlock();
}
plugin->inputScalars().insert((*it)._name, s);
}
} else {
s->writeLock(); // to match with plugin->writeLock()
if (plugin->inputScalars().contains((*it)._name) && plugin->inputScalars()[(*it)._name] != s) {
plugin->inputScalars()[(*it)._name]->unlock();
}
plugin->inputScalars().insert((*it)._name, s);
}
} else {
}
}
KST::stringList.lock().unlock();
KST::scalarList.lock().unlock();
KST::vectorList.lock().unlock();
return rc;
}
bool Statistics::algorithm() {
KstVectorPtr data = inputVector(DATA);
KstScalarPtr mean = outputScalar(MEAN);
KstScalarPtr minimum = outputScalar(MINIMUM);
KstScalarPtr maximum = outputScalar(MAXIMUM);
KstScalarPtr variance = outputScalar(VARIANCE);
KstScalarPtr standard_deviation = outputScalar(STANDARD_DEVIATION);
KstScalarPtr median = outputScalar(MEDIAN);
KstScalarPtr absolute_deviation = outputScalar(ABSOLUTE_DEVIATION);
KstScalarPtr skewness = outputScalar(SKEWNESS);
KstScalarPtr kurtosis = outputScalar(KURTOSIS);
double* pCopy;
double dMean = 0.0;
double dMedian = 0.0;
double dStandardDeviation = 0.0;
double dTotal = 0.0;
double dSquaredTotal = 0.0;
double dMinimum = 0.0;
double dMaximum = 0.0;
double dVariance = 0.0;
double dAbsoluteDeviation = 0.0;
double dSkewness = 0.0;
double dKurtosis = 0.0;
int iLength;
int iRetVal = false;
if (data->length() > 0) {
iLength = data->length();
for (int i=0; i<iLength; i++) {
if (i == 0 || data->value()[i] < dMinimum) {
dMinimum = data->value()[i];
}
if (i == 0 || data->value()[i] > dMaximum) {
dMaximum = data->value()[i];
}
dTotal += data->value()[i];
dSquaredTotal += data->value()[i] * data->value()[i];
}
dMean = dTotal / (double)iLength;
if (iLength > 1) {
dVariance = 1.0 / ( (double)iLength - 1.0 );
dVariance *= dSquaredTotal - ( dTotal * dTotal / (double)iLength );
if (dVariance > 0.0) {
dStandardDeviation = sqrt( dVariance );
} else {
dVariance = 0.0;
dStandardDeviation = 0.0;
}
}
for (int i=0; i<iLength; i++) {
dAbsoluteDeviation += fabs( data->value()[i] - dMean );
dSkewness += pow( data->value()[i] - dMean, 3.0 );
dKurtosis += pow( data->value()[i] - dMean, 4.0 );
}
dAbsoluteDeviation /= (double)iLength;
dSkewness /= (double)iLength * pow( dStandardDeviation, 3.0 );
dKurtosis /= (double)iLength * pow( dStandardDeviation, 4.0 );
dKurtosis -= 3.0;
/*
sort by phase...
*/
pCopy = (double*)calloc( iLength, sizeof( double ) );
if (pCopy != NULL) {
memcpy( pCopy, data->value(), iLength * sizeof( double ) );
quicksort( pCopy, 0, iLength-1 );
dMedian = pCopy[ iLength / 2 ];
free( pCopy );
}
mean->setValue(dMean);
minimum->setValue(dMinimum);
maximum->setValue(dMaximum);
variance->setValue(dVariance);
standard_deviation->setValue(dStandardDeviation);
median->setValue(dMedian);
absolute_deviation->setValue(dAbsoluteDeviation);
skewness->setValue(dSkewness);
kurtosis->setValue(dKurtosis);
iRetVal = true;
}
return iRetVal;
}
void CrossPowerSpectrum::crossspectrum() {
KstVectorPtr v1 = *_inputVectors.find(VECTOR_ONE);
KstVectorPtr v2 = *_inputVectors.find(VECTOR_TWO);
KstScalarPtr fft = *_inputScalars.find(FFT_LENGTH);
KstScalarPtr sample = *_inputScalars.find(SAMPLE_RATE);
KstVectorPtr real = *_outputVectors.find(REAL);
KstVectorPtr imaginary = *_outputVectors.find(IMAGINARY);
KstVectorPtr frequency = *_outputVectors.find(FREQUENCY);
double SR = sample->value(); // sample rate
double df;
int i, xps_len;
double *a, *b;
double mean_a, mean_b;
int dv0, dv1, v_len;
int i_subset, n_subsets;
int i_samp, copyLen;
double norm_factor;
/* parse fft length */
xps_len = int( fft->value() - 0.99);
if ( xps_len > KSTPSDMAXLEN ) xps_len = KSTPSDMAXLEN;
if ( xps_len<2 ) xps_len = 2;
xps_len = int ( pow( 2, xps_len ) );
/* input vector lengths */
v_len = ( ( v1->length() < v2->length() ) ?
v1->length() : v2->length() );
dv0 = v_len/v1->length();
dv1 = v_len/v2->length();
while ( xps_len > v_len ) xps_len/=2;
// allocate the lengths
if ( real->length() != xps_len ) {
real->resize( xps_len, false );
imaginary->resize( xps_len, false );
frequency->resize( xps_len, false );
}
/* Fill the frequency and zero the xps */
df = SR/( 2.0*double( xps_len-1 ) );
for ( i=0; i<xps_len; i++ ) {
frequency->value()[i] = double( i ) * df;
real->value()[i] = 0.0;
imaginary->value()[i] = 0.0;
}
/* allocate input arrays */
int ALen = xps_len * 2;
a = new double[ALen];
b = new double[ALen];
/* do the fft's */
n_subsets = v_len/xps_len + 1;
for ( i_subset=0; i_subset<n_subsets; i_subset++ ) {
/* copy each chunk into a[] and find mean */
if (i_subset*xps_len + ALen <= v_len) {
copyLen = ALen;
} else {
copyLen = v_len - i_subset*xps_len;
}
mean_b = mean_a = 0;
for (i_samp = 0; i_samp < copyLen; i_samp++) {
i = ( i_samp + i_subset*xps_len )/dv0;
mean_a += (
a[i_samp] = v1->value()[i]
);
i = ( i_samp + i_subset*xps_len )/dv1;
mean_b += (
b[i_samp] = v2->value()[i]
);
}
if (copyLen>1) {
mean_a/=(double)copyLen;
mean_b/=(double)copyLen;
}
/* Remove Mean and apodize */
for (i_samp=0; i_samp<copyLen; i_samp++) {
a[i_samp] -= mean_a;
b[i_samp] -= mean_b;
}
for (;i_samp < ALen; i_samp++) {
a[i_samp] = 0.0;
b[i_samp] = 0.0;
}
/* fft */
rdft(ALen, 1, a);
rdft(ALen, 1, b);
/* sum each bin into psd[] */
real->value()[0] += ( a[0]*b[0] );
real->value()[xps_len-1] += ( a[1]*b[1] );
for (i_samp=1; i_samp<xps_len-1; i_samp++) {
real->value()[i_samp]+= ( a[i_samp*2] * b[i_samp*2] +
a[i_samp*2+1] * b[i_samp*2+1] );
imaginary->value()[i_samp]+= ( -a[i_samp*2] * b[i_samp*2+1] +
a[i_samp*2+1] * b[i_samp*2] );
}// (a+ci)(b+di)* = ab+cd +i(-ad + cb)
}
/* renormalize */
norm_factor = 1.0/((double(SR)*double(xps_len))*double(n_subsets));
for ( i=0; i<xps_len; i++ ) {
real->value()[i]*=norm_factor;
imaginary->value()[i]*=norm_factor;
}
/* free */
delete[] b;
delete[] a;
// return 0;
}
void doTests() {
KstScalarPtr sp = new KstScalar;
doTest(!sp->tagName().isEmpty());
doTest(sp->value() == 0.0);
*sp = 3.1415;
doTest(sp->displayable());
doTest(sp->value() == 3.1415);
sp->setValue(2.1415);
doTest(sp->value() == 2.1415);
sp->setValue(NOPOINT);
doTest(sp->value() != sp->value());
sp->setValue(INF);
doTest(sp->value() == INF);
doTest((*sp = 2.0).value() == 2.0);
SListener *listener = new SListener;
sp->connect(sp, SIGNAL(trigger()), listener, SLOT(trigger()));
*sp = 3.1415;
doTest(listener->_trigger == 1);
sp->setValue(3.1415);
doTest(listener->_trigger == 2);
*sp = 1.1415;
doTest(listener->_trigger == 3);
KstScalarPtr sp2 = new KstScalar(sp->tagName());
doTest(sp2->tagName() == sp->tagName() + "'");
doTest(sp->isGlobal());
doTest(sp2->isGlobal());
doTest(sp->displayable());
doTest(sp2->displayable());
QDomNode n;
QDomElement e;
n = makeDOM1("load1", "2.14159265").firstChild();
e = n.toElement();
KstScalarPtr sp3 = new KstScalar(e);
doTest(sp3->orphan() == false);
doTest(sp3->value() == 2.14159265);
doTest(sp3->tagName() == "load1");
doTest(sp3->isGlobal());
doTest(sp3->displayable());
n = makeDOM1("55.4232", "55.4232", true).firstChild();
e = n.toElement();
KstScalarPtr sp4 = new KstScalar(e);
doTest(sp4->orphan());
doTest(sp4->value() == 55.4232);
doTest(sp4->tagName() == "55.4232");
doTest(sp4->isGlobal());
doTest(!sp4->displayable());
n = makeDOM1("load2", "NAN").firstChild();
e = n.toElement();
sp4 = new KstScalar(e);
doTest(sp4->value() != sp4->value());
n = makeDOM1("load3", "INF").firstChild();
e = n.toElement();
sp4 = new KstScalar(e);
doTest(sp4->value() == INF);
n = makeDOM1("load4", "-INF").firstChild();
e = n.toElement();
sp4 = new KstScalar(e);
doTest(sp4->value() == -INF);
delete listener;
}
void BinnedMap::binnedmap() {
KstVectorPtr x = *_inputVectors.find(VECTOR_X);
KstVectorPtr y = *_inputVectors.find(VECTOR_Y);
KstVectorPtr z = *_inputVectors.find(VECTOR_Z);
KstMatrixPtr map = *_outputMatrices.find(MAP);
KstMatrixPtr hitsMap = *_outputMatrices.find(HITSMAP);
KstScalarPtr autobin = *_inputScalars.find(AUTOBIN);
if (autobin) {
if (autobin->value() != 0.0) {
_autoBin = true;
} else {
_autoBin = false;
}
}
if (_autoBin) {
double minx, miny, maxx, maxy;
int nx, ny;
autoSize(X(), Y(), &nx, &minx, &maxx, &ny, &miny, &maxy);
setNX(nx);
setNY(ny);
setXMin(minx);
setXMax(maxx);
setYMin(miny);
setYMax(maxy);
} else {
KstScalarPtr xmin = *_inputScalars.find(XMIN);
KstScalarPtr xmax = *_inputScalars.find(XMAX);
KstScalarPtr ymin = *_inputScalars.find(YMIN);
KstScalarPtr ymax = *_inputScalars.find(YMAX);
KstScalarPtr nx = *_inputScalars.find(NX);
KstScalarPtr ny = *_inputScalars.find(NY);
if (xmin) {
_xMin = xmin->value();
}
if (xmax) {
_xMax = xmax->value();
}
if (ymin) {
_yMin = ymin->value();
}
if (ymax) {
_yMax = ymax->value();
}
if (nx) {
_nx = (int)nx->value();
}
if (ny) {
_ny = (int)ny->value();
}
}
bool needsresize = false;
if (_nx < 2) {
_nx = 2;
needsresize = true;
}
if (_ny < 2) {
_ny = 2;
needsresize = true;
}
if ((map->xNumSteps() != _nx) || (map->yNumSteps() != _ny) ||
(map->minX() != _xMin) || (map->minY() != _yMin)) {
needsresize = true;
}
if (map->xStepSize() != (_xMax - _xMin)/double(_nx-1)) {
needsresize = true;
}
if (map->yStepSize() != (_yMax - _yMin)/double(_ny-1)) {
needsresize = true;
}
if (needsresize) {
map->change(map->tag(), _nx, _ny, _xMin, _yMin,
(_xMax - _xMin)/double(_nx-1), (_yMax - _yMin)/double(_ny-1));
map->resize(_nx, _ny);
hitsMap->change(hitsMap->tag(), _nx, _ny, _xMin, _yMin,
(_xMax - _xMin)/double(_nx-1), (_yMax - _yMin)/double(_ny-1));
hitsMap->resize(_nx, _ny);
}
map->zero();
hitsMap->zero();
int ns = z->length(); // the z vector defines the number of points.
double n,p, x0, y0, z0;
for (int i=0; i<ns; i++) {
x0 = x->interpolate(i, ns);
y0 = y->interpolate(i, ns);
z0 = z->interpolate(i, ns);
p = map->value(x0, y0)+z0;
map->setValue(x0, y0, p);
n = hitsMap->value(x0, y0)+1;
hitsMap->setValue(x0, y0, n);
}
for (int i=0; i<_nx; i++) {
for (int j=0; j<_ny; j++) {
p = map->valueRaw(i, j);
n = hitsMap->valueRaw(i, j);
if (n>0) {
map->setValueRaw(i, j, p/n);
} else {
map->setValueRaw(i, j, KST::NOPOINT);
}
}
}
}
void KstViewLabel::DataCache::update() {
for (QValueVector<DataRef>::ConstIterator i = data.begin(); valid && i != data.end(); ++i) {
switch ((*i).type) {
case DataRef::DataRef::DRScalar:
{
KST::scalarList.lock().readLock();
KstScalarPtr p = *KST::scalarList.findTag((*i).name);
KST::scalarList.lock().unlock();
if (p) {
p->readLock();
if (QVariant(p->value()) != (*i).value) {
valid = false;
}
p->unlock();
}
}
break;
case DataRef::DRString:
{
KST::stringList.lock().readLock();
KstStringPtr p = *KST::stringList.findTag((*i).name);
KST::stringList.lock().unlock();
if (p) {
p->readLock();
if (QVariant(p->value()) != (*i).value) {
valid = false;
}
p->unlock();
}
}
break;
case DataRef::DRExpression:
{
bool ok = false;
const double val = Equation::interpret((*i).name.latin1(), &ok, (*i).name.length());
if (QVariant(val) != (*i).value) {
valid = false;
}
}
break;
case DataRef::DRVector:
{
bool ok = false;
const double idx = Equation::interpret((*i).index.latin1(), &ok, (*i).index.length());
if (idx != (*i).indexValue) {
valid = false;
break;
}
KST::vectorList.lock().readLock();
KstVectorPtr p = *KST::vectorList.findTag((*i).name);
KST::vectorList.lock().unlock();
if (p) {
p->readLock();
if (QVariant(p->value(int((*i).indexValue))) != (*i).value) {
valid = false;
}
p->unlock();
}
}
break;
case DataRef::DataRef::DRFit:
{
KST::dataObjectList.lock().readLock();
KstDataObjectList::Iterator oi = KST::dataObjectList.findTag((*i).name);
KST::dataObjectList.lock().unlock();
if (oi != KST::dataObjectList.end()) {
KstCPluginPtr fit = kst_cast<KstCPlugin>(*oi);
if (fit) {
fit->readLock();
if (fit->label((int)((*i).indexValue)) != (*i).index) {
valid = false;
}
fit->unlock();
}
}
}
break;
}
}
}
bool UpdateThread::doUpdates(bool force, bool *gotData) {
KstObject::UpdateType U = KstObject::NO_CHANGE;
_updatedCurves.clear(); // HACK
if (gotData) {
*gotData = false;
}
#if UPDATEDEBUG > 0
if (force) {
qDebug() << "Forced update!" << endl;
}
#endif
_updateCounter++;
if (_updateCounter < 1) {
_updateCounter = 1; // check for wrap around
}
#if UPDATEDEBUG > 2
qDebug() << "UPDATE: counter=" << _updateCounter << endl;
#endif
{
// Must make a copy to avoid deadlock
KstBaseCurveList cl;
KstDataObjectList dol;
kstObjectSplitList<KstDataObject, KstBaseCurve>(KST::dataObjectList, cl, dol);
qSort(cl);
qSort(dol);
// Update all curves
for (uint i = 0; i < cl.count(); ++i) {
KstBaseCurvePtr bcp = cl[i];
bcp->writeLock();
assert(bcp.data());
#if UPDATEDEBUG > 1
qDebug() << "updating curve: " << (void*)bcp << " - " << bcp->tagName() << endl;
#endif
KstObject::UpdateType ut = bcp->update(_updateCounter);
bcp->unlock();
if (ut == KstObject::UPDATE) { // HACK
_updatedCurves.append(bcp);
}
if (U != KstObject::UPDATE) {
U = ut;
if (U == KstObject::UPDATE) {
#if UPDATEDEBUG > 0
qDebug() << "Curve " << bcp->tagName() << " said UPDATE" << endl;
#endif
}
}
if (_done || (_paused && !force)) {
#if UPDATEDEBUG > 1
qDebug() << "5 Returning from scan with U=" << (int)U << endl;
#endif
return U == KstObject::UPDATE;
}
}
// Update all data objects
for (uint i = 0; i < dol.count(); ++i) {
KstDataObjectPtr dp = dol[i];
dp->writeLock();
assert(dp.data());
#if UPDATEDEBUG > 1
qDebug() << "updating data object: " << (void*)dp << " - " << dp->tagName() << endl;
#endif
dp->update(_updateCounter);
dp->unlock();
if (_done || (_paused && !force)) {
#if UPDATEDEBUG > 1
qDebug() << "5 Returning from scan with U=" << (int)U << endl;
#endif
return U == KstObject::UPDATE;
}
}
}
// Update the files
if (!_paused) { // don't update even if paused && force
KST::dataSourceList.lock().readLock();
unsigned cnt = KST::dataSourceList.count();
for (uint i = 0; i < cnt; ++i) {
KstDataSourcePtr dsp = KST::dataSourceList[i];
dsp->writeLock();
dsp->update(_updateCounter);
dsp->unlock();
if (_done) {
KST::dataSourceList.lock().unlock();
return false;
}
}
KST::dataSourceList.lock().unlock();
}
if (KstScalar::scalarsDirty()) {
KstScalar::clearScalarsDirty(); // Must do this first and take a risk of
// falling slightly behind
KST::scalarList.lock().readLock();
KstScalarList sl = Q3DeepCopy<KstScalarList>(KST::scalarList.list()); // avoid deadlock on exit
KST::scalarList.lock().unlock();
for (KstScalarList::ConstIterator i = sl.begin(); i != sl.end(); ++i) {
KstScalarPtr sp = *i;
sp->writeLock();
KstObject::UpdateType ut = sp->update(_updateCounter);
sp->unlock();
if (ut == KstObject::UPDATE) {
U = KstObject::UPDATE;
}
if (_done) {
return false;
}
}
}
if (U == KstObject::UPDATE) {
qDebug() << "Update plots" << endl;
if (gotData) { // FIXME: do we need to consider all the other exit points?
*gotData = true;
}
}
#if UPDATEDEBUG > 1
qDebug() << "6 Returning from scan with U=" << (int)U << endl;
#endif
return U == KstObject::UPDATE;
}
void KstBasicDialogI::fillFieldsForEdit() {
KstBasicPluginPtr ptr = kst_cast<KstBasicPlugin>(_dp);
if (!ptr)
return; //shouldn't happen
ptr->readLock();
_tagName->setText(ptr->tagName());
_legendText->setText(defaultTag); //FIXME?
//Update the various widgets...
//input vectors...
QStringList iv = ptr->inputVectorList();
QStringList::ConstIterator ivI = iv.begin();
for (; ivI != iv.end(); ++ivI) {
KstVectorPtr p = ptr->inputVector(*ivI);
QString t = p ? p->tagName() : QString::null;
if (VectorSelector *w = vector(*ivI)) {
w->setSelection(t);
}
}
//input scalars...
QStringList is = ptr->inputScalarList();
QStringList::ConstIterator isI = is.begin();
for (; isI != is.end(); ++isI) {
KstScalarPtr p = ptr->inputScalar(*isI);
QString t = p ? p->tagName() : QString::null;
if (ScalarSelector *w = scalar(*isI)) {
w->setSelection(t);
}
}
//input strings...
QStringList istr = ptr->inputStringList();
QStringList::ConstIterator istrI = istr.begin();
for (; istrI != istr.end(); ++istrI) {
KstStringPtr p = ptr->inputString(*istrI);
QString t = p ? p->tagName() : QString::null;
if (StringSelector *w = string(*istrI)) {
w->setSelection(t);
}
}
//output vectors...
QStringList ov = ptr->outputVectorList();
QStringList::ConstIterator ovI = ov.begin();
for (; ovI != ov.end(); ++ovI) {
KstVectorPtr p = ptr->outputVector(*ovI);
QString t = p ? p->tagName() : QString::null;
if (QLineEdit *w = output(*ovI)) {
w->setText(t);
w->setEnabled(false);
}
}
//output scalars...
QStringList os = ptr->outputScalarList();
QStringList::ConstIterator osI = os.begin();
for (; osI != os.end(); ++osI) {
KstScalarPtr p = ptr->outputScalar(*osI);
QString t = p ? p->tagName() : QString::null;
if (QLineEdit *w = output(*osI)) {
w->setText(t);
w->setEnabled(false);
}
}
//ouput strings...
QStringList ostr = ptr->outputStringList();
QStringList::ConstIterator ostrI = ostr.begin();
for (; ostrI != ostr.end(); ++ostrI) {
KstStringPtr p = ptr->outputString(*ostrI);
QString t = p ? p->tagName() : QString::null;
if (QLineEdit *w = output(*ostrI)) {
w->setText(t);
w->setEnabled(false);
}
}
ptr->unlock();
adjustSize();
resize(minimumSizeHint());
setFixedHeight(height());
}
void KstVvDialogI::fillFieldsForEdit() {
KstVectorViewPtr vp = kst_cast<KstVectorView>(_dp);
if (!vp) {
return; // shouldn't be needed
}
vp->readLock();
_tagName->setText(vp->tagName());
_w->_xVector->setSelection(vp->in_xVTag());
_w->_yVector->setSelection(vp->in_yVTag());
if (vp->hasFlag()) {
_w->_FlagVector->setSelection(vp->FlagTag());
}
_w->_xMinCheckbox->setChecked(vp->useXmin());
_w->_xMaxCheckbox->setChecked(vp->useXmax());
_w->_yMinCheckbox->setChecked(vp->useYmin());
_w->_yMaxCheckbox->setChecked(vp->useYmax());
KstScalarPtr sc;
QString str;
sc = vp->xMinScalar();
if (!sc) {
_w->_xMinScalar->setSelection("0");
} else if (*KST::scalarList.findTag(sc->tag().displayString())) {
_w->_xMinScalar->setSelection(sc->tag().displayString());
} else {
// our scalar has been removed from the global list...
// just put its current value into the scalar selector.
// warning: after edit it won't be updated anymore!
// the motivation for putting this in is to not lose scale information when a plot is deleted.
_w->_xMinScalar->setSelection(QString::number(sc->value()));
}
sc = vp->xMaxScalar();
if (!sc) {
_w->_xMaxScalar->setSelection("0");
} else if (*KST::scalarList.findTag(sc->tag().displayString())) {
_w->_xMaxScalar->setSelection(sc->tag().displayString());
} else {
_w->_xMaxScalar->setSelection(QString::number(sc->value()));
}
sc = vp->yMinScalar();
if (!sc) {
_w->_yMinScalar->setSelection("0");
} else if (*KST::scalarList.findTag(sc->tag().displayString())) {
_w->_yMinScalar->setSelection(sc->tag().displayString());
} else {
_w->_yMinScalar->setSelection(QString::number(sc->value()));
}
sc = vp->yMaxScalar();
if (!sc) {
_w->_yMaxScalar->setSelection("0");
} else if (*KST::scalarList.findTag(sc->tag().displayString())) {
_w->_yMaxScalar->setSelection(sc->tag().displayString());
} else {
_w->_yMaxScalar->setSelection(QString::number(sc->value()));
}
vp->unlock();
updateButtons();
// can't edit curve props from here....
_w->_curveAppearance->hide();
_w->_curvePlacement->hide();
_legendText->hide();
_legendLabel->hide();
adjustSize();
resize(minimumSizeHint());
setFixedHeight(height());
}
bool KstPlugin::setPlugin(KstSharedPtr<Plugin> plugin) {
// Assumes that this is called with a write lock in place on this object
if (plugin == _plugin) {
return true;
}
freeParameters();
if (_localData) {
if (!_plugin || !_plugin->freeLocalData(&_localData)) {
free(_localData);
}
_localData = 0L;
}
if (!plugin) {
_inputVectors.clear();
_inputScalars.clear();
_inputStrings.clear();
_outputVectors.clear();
_outputScalars.clear();
_outputStrings.clear();
_plugin = 0L;
return true;
}
Plugin::countScalarsVectorsAndStrings(plugin->data()._inputs, _inScalarCnt, _inArrayCnt, _inStringCnt, _inPid);
if (_inputVectors.count() != _inArrayCnt ||
_inputScalars.count() != _inScalarCnt - _inPid ||
_inputStrings.count() != _inStringCnt) {
_plugin = 0L;
return false;
}
_outScalarCnt = 0;
_outArrayCnt = 0;
_outStringCnt = 0;
_outputVectors.clear();
_outputScalars.clear();
_outputStrings.clear();
const QValueList<Plugin::Data::IOValue>& otable = plugin->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin();
it != otable.end();
++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
KstVectorPtr v;
if ((*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
v = new KstVector(QString::null, 0, true);
} else {
v = new KstVector;
}
v->writeLock();
v->setProvider(this);
_outputVectors.insert((*it)._name, v);
_outArrayCnt++;
KST::addVectorToList(v);
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
KstScalarPtr s = new KstScalar;
s->writeLock();
s->setProvider(this);
_outputScalars.insert((*it)._name, s);
_outScalarCnt++;
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
KstStringPtr s = new KstString;
s->writeLock();
s->setProvider(this);
_outputStrings.insert((*it)._name, s);
_outStringCnt++;
}
}
allocateParameters();
_plugin = plugin;
return true;
}
KstPlugin::KstPlugin(const QDomElement& e)
: KstDataObject(e) {
QString pluginName;
_inStringCnt = 0;
_outStringCnt = 0;
commonConstructor();
QDomNode n = e.firstChild();
while (!n.isNull()) {
QDomElement e = n.toElement();
if (!e.isNull()) {
if (e.tagName() == "tag") {
setTagName(e.text());
} else if (e.tagName() == "name") {
pluginName = e.text();
} else if (e.tagName() == "ivector") {
_inputVectorLoadQueue.append(qMakePair(e.attribute("name"), e.text()));
} else if (e.tagName() == "iscalar") {
_inputScalarLoadQueue.append(qMakePair(e.attribute("name"), e.text()));
} else if (e.tagName() == "istring") {
_inputStringLoadQueue.append(qMakePair(e.attribute("name"), e.text()));
} else if (e.tagName() == "ovector") {
KstVectorPtr v;
if (e.attribute("scalarList", "0").toInt()) {
v = new KstVector(e.text(), 0, true);
} else {
v = new KstVector(e.text(), 0, false);
}
v->setProvider(this);
_outputVectors.insert(e.attribute("name"), v);
KST::addVectorToList(v);
} else if (e.tagName() == "oscalar") {
KstScalarPtr sp = new KstScalar(e.text());
sp->writeLock();
sp->setProvider(this);
sp->writeUnlock();
_outputScalars.insert(e.attribute("name"), sp);
} else if (e.tagName() == "ostring") {
KstStringPtr sp = new KstString(e.text());
sp->writeLock();
sp->setProvider(this);
sp->writeUnlock();
_outputStrings.insert(e.attribute("name"), sp);
}
}
n = n.nextSibling();
}
_plugin = PluginCollection::self()->plugin(pluginName);
if (!_plugin.data()) {
KstDebug::self()->log(i18n("Unable to load plugin %1 for \"%2\".").arg(pluginName).arg(tagName()), KstDebug::Warning);
} else {
Plugin::countScalarsVectorsAndStrings(_plugin->data()._inputs, _inScalarCnt, _inArrayCnt, _inStringCnt, _inPid);
const QValueList<Plugin::Data::IOValue>& otable = _plugin->data()._outputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = otable.begin();
it != otable.end();
++it) {
// FIXME: i18n?
if ((*it)._type == Plugin::Data::IOValue::TableType) {
_outArrayCnt++;
if (!_outputVectors.contains((*it)._name)) {
KstVectorPtr v;
if ((*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
v = new KstVector(tagName() + " vector - " + (*it)._name, 0, true);
} else {
v = new KstVector(tagName() + " vector - " + (*it)._name, 0, false);
}
v->setProvider(this);
_outputVectors.insert((*it)._name, v);
KST::addVectorToList(v);
}
} else if ((*it)._type == Plugin::Data::IOValue::MatrixType) {
abort(); // FIXME:
#if 0
_outArrayCnt += 2;
if (!_outputMatrices.contains((*it)._name)) {
KstMatrixPtr m;
if ((*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
m = new KstMatrix(tagName() + " matrix - " + (*it)._name, 0, true);
} else {
m = new KstMatrix(tagName() + " matrix - " + (*it)._name, 0, false);
}
m->setProvider(this);
_outputMatrices.insert((*it)._name, m);
KST::addVectorToList(v);
}
#endif
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
_outScalarCnt++;
if (!_outputScalars.contains((*it)._name)) {
KstScalarPtr s = new KstScalar(tagName() + " scalar - " + (*it)._name);
s->writeLock();
s->setProvider(this);
s->writeUnlock();
_outputScalars.insert((*it)._name, s);
}
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
_outStringCnt++;
if (!_outputStrings.contains((*it)._name)) {
KstStringPtr s = new KstString(tagName() + " string - " + (*it)._name);
s->writeLock();
s->setProvider(this);
s->writeUnlock();
_outputStrings.insert((*it)._name, s);
}
}
}
allocateParameters();
}
}
void renderLabel(RenderContext& rc, Label::Chunk *fi) {
// FIXME: RTL support
int oldSize = rc.size;
int oldY = rc.y;
int oldX = rc.x;
while (fi) {
if (fi->vOffset != Label::Chunk::None) {
if (fi->vOffset == Label::Chunk::Up) {
rc.y -= int(0.4 * rc.fontHeight());
} else { // Down
rc.y += int(0.4 * rc.fontHeight());
}
if (rc.size > 5) {
rc.size = (rc.size*2)/3;
}
}
QFont f = rc.font();
if (rc.fontSize() != rc.size) {
f.setPointSize(rc.size);
}
f.setBold(fi->attributes.bold);
f.setItalic(fi->attributes.italic);
f.setUnderline(fi->attributes.underline);
if (rc.p && fi->attributes.color.isValid()) {
rc.p->setPen(fi->attributes.color);
} else if (rc.p) {
rc.p->setPen(rc.pen);
}
rc.setFont(f);
if (fi->linebreak) {
rc.x = oldX;
rc.y += rc.fontAscent() + rc.fontDescent() + 1;
fi = fi->next;
continue;
}
if (!rc.substitute && (fi->scalar || fi->vector)) {
QString txt = QString("[") + fi->text + "]";
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->scalar) {
// do scalar/string/fit substitution
QString txt;
if (!fi->text.isEmpty() && fi->text[0] == '=') {
// Parse and evaluate as an equation
bool ok = false;
const double eqResult(Equation::interpret(fi->text.mid(1).latin1(), &ok));
txt = QString::number(eqResult, 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRExpression, fi->text, QString::null, 0.0, QVariant(eqResult)));
}
} else {
KST::scalarList.lock().readLock();
KstScalarPtr scp = *KST::scalarList.findTag(fi->text);
KST::scalarList.lock().unlock();
if (scp) {
scp->readLock();
txt = QString::number(scp->value(), 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRScalar, fi->text, QString::null, 0.0, QVariant(scp->value())));
}
scp->unlock();
} else {
KST::stringList.lock().readLock();
KstStringPtr stp = *KST::stringList.findTag(fi->text);
KST::stringList.lock().unlock();
if (stp) {
stp->readLock();
txt = stp->value();
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRString, fi->text, QString::null, 0.0, QVariant(stp->value())));
}
stp->unlock();
} else {
KST::dataObjectList.lock().readLock();
KstDataObjectList::Iterator oi = KST::dataObjectList.findTag(fi->text);
KST::dataObjectList.lock().unlock();
if (oi != KST::dataObjectList.end()) {
KstPluginPtr fit = kst_cast<KstPlugin>(*oi);
if (fit) {
fit->readLock();
const QString txtAll = fit->label(rc.precision);
fit->unlock();
const QValueList<QString> strList = QStringList::split('\n', txtAll);
QValueListConstIterator<QString> last = --(strList.end());
for (QValueListConstIterator<QString> iter = strList.begin(); iter != strList.end(); ++iter) {
txt = (*iter);
if (iter != last) {
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
} else {
rc.ascent = kMax(rc.ascent, -rc.y + rc.fontAscent());
if (-rc.y - rc.fontDescent() < 0) {
rc.descent = kMax(rc.descent, rc.fontDescent() + rc.y);
}
}
rc.x += rc.fontWidth(txt);
rc.xMax = kMax(rc.xMax, rc.x);
rc.x = oldX;
rc.y += rc.fontAscent() + rc.fontDescent() + 1;
}
}
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRFit, fi->text, txtAll, rc.precision, QVariant(0.0)));
}
}
}
}
}
}
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->vector) {
QString txt;
KST::vectorList.lock().readLock();
KstVectorPtr vp = *KST::vectorList.findTag(fi->text);
KST::vectorList.lock().unlock();
if (vp) {
if (!fi->expression.isEmpty()) {
// Parse and evaluate as an equation
bool ok = false;
// FIXME: make more efficient: cache the parsed equation
const double idx = Equation::interpret(fi->expression.latin1(), &ok);
if (ok) {
vp->readLock();
const double vVal(vp->value()[int(idx)]);
txt = QString::number(vVal, 'g', rc.precision);
if (rc._cache) {
rc._cache->append(DataRef(DataRef::DRVector, fi->text, fi->expression, idx, QVariant(vVal)));
}
vp->unlock();
} else {
txt = "NAN";
}
}
}
if (rc.p) {
rc.p->drawText(rc.x, rc.y, txt);
}
rc.x += rc.fontWidth(txt);
} else if (fi->tab) {
const int tabWidth = rc.fontWidth("MMMMMMMM");
const int toSkip = tabWidth - (rc.x - rc.xStart) % tabWidth;
if (rc.p && fi->attributes.underline) {
const int spaceWidth = rc.fontWidth(" ");
const int spacesToSkip = tabWidth / spaceWidth + (tabWidth % spaceWidth > 0 ? 1 : 0);
rc.p->drawText(rc.x, rc.y, QString().fill(' ', spacesToSkip));
}
rc.x += toSkip;
} else {
if (rc.p) {
#ifdef BENCHMARK
QTime t;
t.start();
#endif
rc.p->drawText(rc.x, rc.y, fi->text);
#ifdef BENCHMARK
kstdDebug() << "Renderer did draw, time: " << t.elapsed() << endl;
#endif
}
rc.x += rc.fontWidth(fi->text);
}
if (!rc.p) {
// No need to compute ascent and descent when really painting
rc.ascent = kMax(rc.ascent, -rc.y + rc.fontAscent());
if (-rc.y - rc.fontDescent() < 0) {
rc.descent = kMax(rc.descent, rc.fontDescent() + rc.y);
}
}
int xNext = rc.x;
if (fi->group) {
renderLabel(rc, fi->group);
xNext = rc.x;
}
if (fi->up) {
int xPrev = rc.x;
renderLabel(rc, fi->up);
xNext = kMax(xNext, rc.x);
rc.x = xPrev;
}
if (fi->down) {
renderLabel(rc, fi->down);
xNext = kMax(xNext, rc.x);
}
rc.x = xNext;
rc.xMax = kMax(rc.xMax, rc.x);
fi = fi->next;
}
rc.size = oldSize;
rc.y = oldY;
}
KstBindScalar::KstBindScalar(KJS::ExecState *exec, KstScalarPtr s)
: KstBindObject(exec, s.data(), "Scalar") {
KJS::Object o(this);
addBindings(exec, o);
}
