KstObject::UpdateType BinnedMap::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
if (!X() || !Y() || !Z()) {
return setLastUpdateResult(NO_CHANGE);
}
bool depUpdated = force;
writeLockInputsAndOutputs();
depUpdated = UPDATE == X()->update(updateCounter) || depUpdated;
depUpdated = UPDATE == Y()->update(updateCounter) || depUpdated;
depUpdated = UPDATE == Z()->update(updateCounter) || depUpdated;
if (depUpdated) {
binnedmap();
//matrixRealloced(BinnedMap(), BinnedMap()->value(), real()->length());
map()->setDirty();
map()->update(updateCounter);
hitsMap()->setDirty();
hitsMap()->update(updateCounter);
}
unlockInputsAndOutputs();
return setLastUpdateResult(depUpdated ? UPDATE : NO_CHANGE);
}
void VScalar::changeFile(DataSourcePtr in_file) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (!in_file) {
Debug::self()->log(i18n("Data file for scalar %1 was not opened.", Name()), Debug::Warning);
}
}
void VScalar::change(DataSourcePtr in_datasource, const QString &in_field, int in_f0) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
_field = in_field;
setDataSource(in_datasource);
_f0 = in_f0;
}
// If a plugin provides a Parameters Vector, then scalars will be created, as well as a label.
void BasicPlugin::createScalars() {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (hasParameterVector()) {
VectorPtr vectorParam = _outputVectors["Parameters Vector"];
if (vectorParam) {
QString paramName;
int i = 0;
int length = vectorParam->length();
Q_ASSERT(store());
for (paramName = parameterName(i);
!paramName.isEmpty() && i < length;
paramName = parameterName(++i)) {
double scalarValue = vectorParam->value(i);
if (!_outputScalars.contains(paramName)) {
ScalarPtr s = store()->createObject<Scalar>();
s->setProvider(this);
s->setSlaveName(paramName);
s->setValue(scalarValue);
s->writeLock();
_outputScalars.insert(paramName, s);
} else {
_outputScalars[paramName]->setValue(scalarValue);
}
}
}
}
}
void KstCPlugin::createFitScalars() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
// Assumes that this is called with a write lock in place on this object
if (_plugin->data()._isFit && _outputVectors.contains("Parameters")) {
KstVectorPtr vectorParam = _outputVectors["Parameters"];
if (vectorParam) {
QString paramName;
int i = 0;
int length = vectorParam->length();
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
KST::scalarList.setUpdateDisplayTags(false);
for (paramName = _plugin->parameterName(i);
!paramName.isEmpty() && i < length;
paramName = _plugin->parameterName(++i)) {
double scalarValue = vectorParam->value(i);
if (!_outputScalars.contains(paramName)) {
KstScalarPtr s = new KstScalar(KstObjectTag(paramName, tag()), this, scalarValue);
s->KstObject::writeLock(); // must write lock, since fit scalars are created from update()
_outputScalars.insert(paramName, s);
++_outScalarCnt;
} else {
_outputScalars[paramName]->setValue(scalarValue);
}
}
KST::scalarList.setUpdateDisplayTags(true);
}
}
}
//
// to be used only from javaScript...
//
bool KstCPlugin::setModule(KstPluginPtr plugin) {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (plugin != _plugin) {
freeParameters();
if (_localData) {
if (!_plugin || !_plugin->freeLocalData(&_localData)) {
free(_localData);
}
_localData = 0L;
}
_inputVectors.clear();
_inputScalars.clear();
_inputStrings.clear();
_outputVectors.clear();
_outputScalars.clear();
_outputStrings.clear();
_plugin = plugin;
}
return true;
}
void VScalar::changeFile(DataSourcePtr in_datasource) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (!in_datasource) {
Debug::self()->log(tr("Data file for scalar %1 was not opened.").arg(Name()), Debug::Warning);
}
setDataSource(in_datasource);
}
void DataMatrix::reload() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (file()) {
file()->writeLock();
file()->reset();
file()->unlock();
reset();
}
}
void DataString::reload() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (_dp->dataSource()) {
_dp->dataSource()->writeLock();
_dp->dataSource()->reset();
_dp->dataSource()->unlock();
reset();
registerChange();
}
}
void DataMatrix::reset() { // must be called with a lock
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (file()) {
_samplesPerFrameCache = file()->matrix().optional(_field).samplesPerFrame;
}
resizeZ(0);
_NS = 0;
_nX = 1;
_nY = 0;
}
KstObject::UpdateType KstEquation::update(int update_counter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
bool xUpdated = false;
bool usedUpdated = false;
if (KstObject::checkUpdateCounter(update_counter) && !force) {
return lastUpdateResult();
}
if (!_pe) {
return setLastUpdateResult(NO_CHANGE);
}
assert(update_counter >= 0);
if (_xInVector == _inputVectors.end()) {
_xInVector = _inputVectors.find(XINVECTOR);
if (!*_xInVector) { // This is technically sort of fatal
return setLastUpdateResult(NO_CHANGE);
}
}
writeLockInputsAndOutputs();
KstVectorPtr v = *_xInVector;
xUpdated = KstObject::UPDATE == v->update(update_counter);
Equation::Context ctx;
ctx.sampleCount = _ns;
ctx.xVector = v;
usedUpdated = _pe && KstObject::UPDATE == _pe->update(update_counter, &ctx);
KstObject::UpdateType rc = NO_CHANGE; // if force, rc = UPDATE anyway.
if (force || xUpdated || usedUpdated) {
_isValid = FillY(force);
rc = UPDATE;
}
v = *_yOutVector;
if (rc == UPDATE) {
v->setDirty();
}
v->update(update_counter);
unlockInputsAndOutputs();
return setLastUpdateResult(rc);
}
void Image::internalUpdate() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
writeLockInputsAndOutputs();
if (_inputMatrices.contains(THEMATRIX)) {
MatrixPtr mp = _inputMatrices[THEMATRIX];
// stats
NS = mp->sampleCount();
MinX = mp->minX();
int xNumSteps = mp->xNumSteps();
double xStepSize = mp->xStepSize();
MaxX = xNumSteps*xStepSize + MinX;
MinY = mp->minY();
int yNumSteps = mp->yNumSteps();
double yStepSize = mp->yStepSize();
MaxY = yNumSteps*yStepSize + MinY;
_ns_maxx = MaxX;
_ns_minx = MinX;
_ns_maxy = MaxY;
_ns_miny = MinY;
MinPosY = MinY > 0 ? MinY : 0;
MinPosX = MinX > 0 ? MinX : 0;
//recalculate the thresholds if necessary
if (_autoThreshold) {
_zLower = mp->minValue();
_zUpper = mp->maxValue();
}
//update the contour lines
if (hasContourMap()) {
double min = mp->minValue(), max = mp->maxValue();
double contourStep = (max - min) / (double)(_numContourLines + 1);
if (contourStep > 0) {
_contourLines.clear();
for (int i = 0; i < _numContourLines; i++) {
_contourLines.append(min + (i+1) * contourStep);
}
}
}
_redrawRequired = true;
}
unlockInputsAndOutputs();
return;
}
void DataMatrix::reset() { // must be called with a lock
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (dataSource()) {
const DataInfo info = dataSource()->matrix().dataInfo(_field);
_samplesPerFrameCache = info.samplesPerFrame;
_invertXHint = info.invertXHint;
_invertYHint = info.invertYHint;
}
resizeZ(0);
_NS = 0;
_nX = 1;
_nY = 0;
_resetFieldMetadata();
}
void DataMatrix::changeFile(DataSourcePtr in_file) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (!in_file) {
Debug::self()->log(i18n("Data file for vector %1 was not opened.", Name()), Debug::Warning);
}
file() = in_file;
if (file()) {
file()->writeLock();
}
reset();
if (file()) {
file()->unlock();
}
}
void PSD::setVector(VectorPtr new_v) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
VectorPtr v = _inputVectors[INVECTOR];
if (v) {
if (v == new_v) {
return;
}
v->unlock();
}
_inputVectors.remove(INVECTOR);
new_v->writeLock();
_inputVectors[INVECTOR] = new_v;
_changed = true;
}
KstObject::UpdateType KstAVector::update(int update_counter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
if (KstObject::checkUpdateCounter(update_counter) && !force) {
return lastUpdateResult();
}
KstObject::UpdateType baseRC = KstVector::update(update_counter);
if (force) {
baseRC = UPDATE;
}
return baseRC;
}
void KstPSD::setVector(KstVectorPtr new_v) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
setRecursed(false);
KstVectorPtr v = _inputVectors[INVECTOR];
if (v) {
if (v == new_v) {
return;
}
}
_inputVectors.erase(INVECTOR);
_inputVectors[INVECTOR] = new_v;
setDirty();
}
KstObject::UpdateType KstString::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
QString v = value();
if (_provider) {
_provider->update(updateCounter);
}
return setLastUpdateResult(v == value() ? NO_CHANGE : UPDATE);
}
KstObject::UpdateType CrossPowerSpectrum::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
if (!v1() || !v2() || !fft() || !sample()) {
return setLastUpdateResult(NO_CHANGE);
}
bool depUpdated = force;
writeLockInputsAndOutputs();
depUpdated = UPDATE == v1()->update(updateCounter) || depUpdated;
depUpdated = UPDATE == v2()->update(updateCounter) || depUpdated;
depUpdated = UPDATE == fft()->update(updateCounter) || depUpdated;
depUpdated = UPDATE == sample()->update(updateCounter) || depUpdated;
crossspectrum();
vectorRealloced(real(), real()->value(), real()->length());
real()->setDirty();
real()->setNewAndShift(real()->length(), real()->numShift());
real()->update(updateCounter);
vectorRealloced(imaginary(), imaginary()->value(), imaginary()->length());
imaginary()->setDirty();
imaginary()->setNewAndShift(imaginary()->length(), imaginary()->numShift());
imaginary()->update(updateCounter);
vectorRealloced(frequency(), frequency()->value(), frequency()->length());
frequency()->setDirty();
frequency()->setNewAndShift(frequency()->length(), frequency()->numShift());
frequency()->update(updateCounter);
unlockInputsAndOutputs();
return setLastUpdateResult(depUpdated ? UPDATE : NO_CHANGE);
}
KstObject::UpdateType KstScalar::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
double v = value();
if (_provider) {
KstWriteLocker pl(_provider);
_provider->update(updateCounter);
} else if (force) {
return setLastUpdateResult(UPDATE);
}
return setLastUpdateResult(v == value() ? NO_CHANGE : UPDATE);
}
KstObject::UpdateType KstBasicPlugin::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (recursed()) {
return setLastUpdateResult(NO_CHANGE);
}
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
//Make sure we have all the necessary inputs
if (!inputsExist()) {
return setLastUpdateResult(NO_CHANGE);
}
writeLockInputsAndOutputs();
//Update the dependent inputs
bool depUpdated = updateInput(updateCounter, force);
//Call the plugins algorithm to operate on the inputs
//and produce the outputs
if ( !algorithm() ) {
KstDebug::self()->log(i18n("There is an error in the %1 algorithm.").arg(propertyString()), KstDebug::Error);
unlockInputsAndOutputs();
return lastUpdateResult();
}
//Perform update on the outputs
updateOutput(updateCounter);
createFitScalars();
unlockInputsAndOutputs();
return setLastUpdateResult(depUpdated ? UPDATE : NO_CHANGE);
}
void Curve::internalUpdate() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
VectorPtr cxV = *_inputVectors.find(XVECTOR);
VectorPtr cyV = *_inputVectors.find(YVECTOR);
if (!cxV || !cyV) {
return;
}
writeLockInputsAndOutputs();
MaxX = cxV->max();
MinX = cxV->min();
MeanX = cxV->mean();
MinPosX = cxV->minPos();
_ns_maxx = cxV->ns_max();
_ns_minx = cxV->ns_min();
if (MinPosX > MaxX) {
MinPosX = 0;
}
MaxY = cyV->max();
MinY = cyV->min();
MeanY = cyV->mean();
MinPosY = cyV->minPos();
_ns_maxy = cyV->ns_max();
_ns_miny = cyV->ns_min();
if (MinPosY > MaxY) {
MinPosY = 0;
}
NS = qMax(cxV->length(), cyV->length());
unlockInputsAndOutputs();
_redrawRequired = true;
return;
}
void Equation::internalUpdate() {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (!_pe) {
return;
}
writeLockInputsAndOutputs();
Equations::Context ctx;
ctx.sampleCount = _ns;
ctx.xVector = _xInVector;
_pe->update(&ctx);
_isValid = FillY(true);
unlockInputsAndOutputs();
updateVectorLabels();
return;
}
KstObject::UpdateType KstDataSource::update(int u) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
Q_UNUSED(u)
return KstObject::NO_CHANGE;
}
bool KstCPlugin::setPlugin(KstPluginPtr plugin) {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
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) {
KstWriteLocker blockVectorUpdates(&KST::vectorList.lock());
KstVectorPtr v;
if ((*it)._subType == Plugin::Data::IOValue::FloatNonVectorSubType) {
v = new KstVector(KstObjectTag((*it)._name, tag()), 0, this, true);
} else {
v = new KstVector(KstObjectTag((*it)._name, tag()), 0, this, false);
}
_outputVectors.insert((*it)._name, v);
++_outArrayCnt;
} else if ((*it)._type == Plugin::Data::IOValue::FloatType) {
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
KstScalarPtr s = new KstScalar(KstObjectTag((*it)._name, tag()), this);
_outputScalars.insert((*it)._name, s);
++_outScalarCnt;
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
KstWriteLocker blockStringUpdates(&KST::stringList.lock());
KstStringPtr s = new KstString(KstObjectTag((*it)._name, tag()), this);
_outputStrings.insert((*it)._name, s);
++_outStringCnt;
}
}
allocateParameters();
_plugin = plugin;
return true;
}
KstObject::UpdateType KstPSD::update(int update_counter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(update_counter) && !force) {
return lastUpdateResult();
}
if (recursed()) {
return setLastUpdateResult(NO_CHANGE);
}
writeLockInputsAndOutputs();
KstVectorPtr iv = _inputVectors[INVECTOR];
if (update_counter <= 0) {
assert(update_counter == 0);
force = true;
}
bool xUpdated = KstObject::UPDATE == iv->update(update_counter);
const int v_len = iv->length();
// Don't touch _last_n_new if !xUpdated since it will certainly be wrong.
if (!xUpdated && !force) {
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
_last_n_new += iv->numNew();
assert(_last_n_new >= 0);
int n_subsets = v_len/_PSDLen;
// determine if the PSD needs to be updated. if not using averaging, then we need at least _PSDLen/16 new data points. if averaging, then we want enough new data for a complete subset.
if ( ((_last_n_new < _PSDLen/16) || (_Average && (n_subsets - _last_n_subsets < 1))) && iv->length() != iv->numNew() && !force) {
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
_adjustLengths();
double *psd = (*_sVector)->value();
double *f = (*_fVector)->value();
int i_samp;
for (i_samp = 0; i_samp < _PSDLen; ++i_samp) {
f[i_samp] = i_samp * 0.5 * _Freq / (_PSDLen - 1);
}
_psdCalculator.calculatePowerSpectrum(iv->value(), v_len, psd, _PSDLen, _RemoveMean, _interpolateHoles, _Average, _averageLen, _Apodize, _apodizeFxn, _gaussianSigma, _Output, _Freq);
_last_n_subsets = n_subsets;
_last_n_new = 0;
updateVectorLabels();
(*_sVector)->setDirty();
(*_sVector)->update(update_counter);
(*_fVector)->setDirty();
(*_fVector)->update(update_counter);
unlockInputsAndOutputs();
return setLastUpdateResult(UPDATE);
}
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);
}
KstObject::UpdateType KstCSD::update(int update_counter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
KstVectorPtr inVector = _inputVectors[INVECTOR];
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(update_counter) && !force) {
return lastUpdateResult();
}
if (recursed()) {
return setLastUpdateResult(NO_CHANGE);
}
writeLockInputsAndOutputs();
if (update_counter <= 0) {
assert(update_counter == 0);
force = true;
}
bool xUpdated = KstObject::UPDATE == inVector->update(update_counter);
// if vector was not changed, don't update the CSD
if (!xUpdated && !force) {
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
double *tempOutput;
double *input;
int tempOutputLen = PSDCalculator::calculateOutputVectorLength(_windowSize, _average, _averageLength);
int xSize = 0;
_PSDLen = tempOutputLen;
tempOutput = new double[tempOutputLen];
input = inVector->value();
for (int i=0; i < inVector->length(); i+= _windowSize) {
// ensure there is enough data left
if (i + _windowSize >= inVector->length()) {
// if there isn't enough left for a complete window
break;
}
_psdCalculator.calculatePowerSpectrum(input + i, _windowSize, tempOutput,
tempOutputLen, _removeMean, _interpolateHoles,
_average, _averageLength, _apodize, _apodizeFxn,
_gaussianSigma, _outputType, _frequency);
// resize output matrix
(*_outMatrix)->resize(xSize+1, tempOutputLen);
if ((*_outMatrix)->sampleCount() == (xSize+1)*tempOutputLen) {
// copy elements to output matrix
for (int j=0; j < tempOutputLen; j++) {
(*_outMatrix)->setValueRaw(xSize, j, tempOutput[j]);
}
} else {
KstDebug::self()->log(i18n("Could not allocate sufficient memory for spectrogram."), KstDebug::Error);
break;
}
xSize++;
}
delete[] tempOutput;
double frequencyStep = 0.5 * _frequency / (double)( tempOutputLen - 1 );
(*_outMatrix)->change((*_outMatrix)->tag(), xSize, tempOutputLen, 0, 0, _windowSize, frequencyStep);
(*_outMatrix)->update(update_counter);
unlockInputsAndOutputs();
return setLastUpdateResult(UPDATE);
}
void KstDataObject::writeLockInputsAndOutputs() const {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
QList<KstPrimitivePtr>::const_iterator inputIt;
QList<KstPrimitivePtr>::const_iterator outputIt;
QList<KstPrimitivePtr> inputs;
QList<KstPrimitivePtr> outputs;
QList<KstStringPtr> sl;
QList<KstScalarPtr> sc;
QList<KstVectorPtr> vl;
QList<KstMatrixPtr> ml;
sl = _inputStrings.values();
for (QList<KstStringPtr>::iterator i = sl.begin(); i != sl.end(); ++i) {
inputs.append(*i);
}
sl = _outputStrings.values();
for (QList<KstStringPtr>::iterator i = sl.begin(); i != sl.end(); ++i) {
outputs.append(*i);
}
sc = _inputScalars.values();
for (QList<KstScalarPtr>::iterator i = sc.begin(); i != sc.end(); ++i) {
inputs.append(*i);
}
sc = _outputScalars.values();
for (QList<KstScalarPtr>::iterator i = sc.begin(); i != sc.end(); ++i) {
outputs.append(*i);
}
vl = _inputVectors.values();
for (QList<KstVectorPtr>::iterator i = vl.begin(); i != vl.end(); ++i) {
inputs.append(*i);
}
vl = _outputVectors.values();
for (QList<KstVectorPtr>::iterator i = vl.begin(); i != vl.end(); ++i) {
outputs.append(*i);
}
ml = _inputMatrices.values();
for (QList<KstMatrixPtr>::iterator i = ml.begin(); i != ml.end(); ++i) {
inputs.append(*i);
}
ml = _outputMatrices.values();
for (QList<KstMatrixPtr>::iterator i = ml.begin(); i != ml.end(); ++i) {
outputs.append(*i);
}
qSort(inputs);
qSort(outputs);
inputIt = inputs.begin();
outputIt = outputs.begin();
while (inputIt != inputs.end() || outputIt != outputs.end()) {
if (inputIt != inputs.end() && (outputIt == outputs.end() || (void*)((*inputIt).data()) < (void*)((*outputIt).data()))) {
if (*inputIt) {
(*inputIt)->writeLock();
}
++inputIt;
} else {
if (*outputIt) {
(*outputIt)->writeLock();
}
++outputIt;
}
}
}
KstObject::UpdateType EventMonitorEntry::update(int updateCounter) {
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
bool force = dirty();
setDirty(false);
if (KstObject::checkUpdateCounter(updateCounter) && !force) {
return lastUpdateResult();
}
writeLockInputsAndOutputs();
if (!_pExpression) {
reparse();
}
KstVectorPtr xv = *_xVector;
KstVectorPtr yv = *_yVector;
int ns = 1;
for (KstVectorMap::ConstIterator i = _vectorsUsed.begin(); i != _vectorsUsed.end(); ++i) {
ns = qMax(ns, i.value()->length());
}
double *rawValuesX = 0L;
double *rawValuesY = 0L;
if (xv && yv) {
if (xv->resize(ns)) {
rawValuesX = xv->value();
}
if (yv->resize(ns)) {
rawValuesY = yv->value();
}
}
Equation::Context ctx;
ctx.sampleCount = ns;
ctx.x = 0.0;
if (needToEvaluate()) {
if (_pExpression) {
for (ctx.i = _numDone; ctx.i < ns; ++ctx.i) {
const double value = _pExpression->value(&ctx);
if (value != 0.0) { // The expression evaluates to true
log(ctx.i);
if (rawValuesX && rawValuesY) {
rawValuesX[ctx.i] = ctx.i;
rawValuesY[ctx.i] = 1.0;
}
} else {
if (rawValuesX && rawValuesY) {
rawValuesX[ctx.i] = ctx.i;
rawValuesY[ctx.i] = 0.0;
}
}
}
_numDone = ns;
logImmediately();
}
} else {
_numDone = ns;
}
if (xv) {
xv->setDirty();
xv->update(updateCounter);
}
if (yv) {
yv->setDirty();
yv->update(updateCounter);
}
unlockInputsAndOutputs();
return setLastUpdateResult(NO_CHANGE);
}
