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); }