void BasicPlugin::internalUpdate() { //Make sure we have all the necessary inputs if (!inputsExist()) return; writeLockInputsAndOutputs(); //Call the plugins algorithm to operate on the inputs //and produce the outputs if ( !algorithm() ) { Debug::self()->log(i18n("There is an error in the %1 algorithm.").arg(propertyString()), Debug::Error); unlockInputsAndOutputs(); return; } //Perform update on the outputs updateOutput(); createScalars(); unlockInputsAndOutputs(); return; }
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 EventMonitorEntry::internalUpdate() { writeLockInputsAndOutputs(); if (!_pExpression) { reparse(); } VectorPtr xv = *_xVector; VectorPtr yv = *_yVector; int ns = 1; for (VectorMap::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(); } } Equations::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; } unlockInputsAndOutputs(); return; }
void PSD::internalUpdate() { writeLockInputsAndOutputs(); VectorPtr iv = _inputVectors[INVECTOR]; const int v_len = iv->length(); _last_n_new += iv->numNew(); assert(_last_n_new >= 0); int n_subsets = (v_len)/_PSDLength; // determine if the PSD needs to be updated. // if not using averaging, then we need at least _PSDLength/16 new data points. // if averaging, then we want enough new data for a complete subset. // ... unless we are counting from end at fixed length (scrolling data). bool scrolling_data = (_last_n == iv->length()); if ( (!_changed) && ((_last_n_new < _PSDLength/16) || (_Average && scrolling_data && (_last_n_new < _PSDLength/16)) || (_Average && !scrolling_data && (n_subsets - _last_n_subsets < 1))) && iv->length() != iv->numNew()) { unlockInputsAndOutputs(); return; } _changed = false; _adjustLengths(); double *psd = _sVector->value(); double *f = _fVector->value(); int i_samp; for (i_samp = 0; i_samp < _PSDLength; ++i_samp) { f[i_samp] = i_samp * 0.5 * _Frequency / (_PSDLength - 1); } //f[0] = -1E-280; // really 0 (this shouldn't be needed...) _psdCalculator.calculatePowerSpectrum(iv->value(), v_len, psd, _PSDLength, _RemoveMean, _interpolateHoles, _Average, _averageLength, _Apodize, _apodizeFxn, _gaussianSigma, _Output, _Frequency); _last_n_subsets = n_subsets; _last_n_new = 0; _last_n = iv->length(); updateVectorLabels(); // should be updated by the update manager //_sVector->update(); //_fVector->update(); unlockInputsAndOutputs(); return; }
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 CSD::internalUpdate() { VectorPtr inVector = _inputVectors[CSD_INVECTOR]; writeLockInputsAndOutputs(); double *tempOutput, *input; int tempOutputLen = PSDCalculator::calculateOutputVectorLength(_windowSize, _average, _averageLength); _length = tempOutputLen; tempOutput = new double[tempOutputLen]; input = inVector->value(); int xSize = 0; for (int i=0; i < inVector->length(); i+= _windowSize) { //ensure there is enough data left. if (i + _windowSize >= inVector->length()) { break; //If there isn't enough left for a complete window. } _psdCalculator.calculatePowerSpectrum(input + i, _windowSize, tempOutput, tempOutputLen, _removeMean, false, _average, _averageLength, _apodize, _apodizeFxn, _gaussianSigma, _outputType, _frequency); // resize output matrix _outMatrix->resize(xSize+1, tempOutputLen); if (_outMatrix->sampleCount() == (xSize+1)*tempOutputLen) { // all is well. // copy elements to output matrix for (int j=0; j < tempOutputLen; j++) { _outMatrix->setValueRaw(xSize, j, tempOutput[j]); } } else { Debug::self()->log(i18n("Could not allocate sufficient memory for CSD."), Debug::Error); break; } xSize++; } delete[] tempOutput; double frequencyStep = .5*_frequency/(double)(tempOutputLen-1); _outMatrix->change(xSize, tempOutputLen, 0, 0, _windowSize/_frequency, frequencyStep); unlockInputsAndOutputs(); return; }
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 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; }
bool KstEquation::FillY(bool force) { int v_shift=0, v_new; int i0=0; int ns; writeLockInputsAndOutputs(); // determine value of Interp if (_doInterp) { ns = (*_xInVector)->length(); for (KstVectorMap::ConstIterator i = VectorsUsed.begin(); i != VectorsUsed.end(); ++i) { if (i.data()->length() > ns) { ns = i.data()->length(); } } } else { ns = (*_xInVector)->length(); } if (_ns != (*_xInVector)->length() || ns != (*_xInVector)->length() || (*_xInVector)->numShift() != (*_xInVector)->numNew()) { _ns = ns; KstVectorPtr xv = *_xOutVector; KstVectorPtr yv = *_yOutVector; if (!xv->resize(_ns)) { // FIXME: handle error? unlockInputsAndOutputs(); return false; } if (!yv->resize(_ns)) { // FIXME: handle error? unlockInputsAndOutputs(); return false; } yv->zero(); i0 = 0; // other vectors may have diffent lengths, so start over v_shift = _ns; } else { // calculate shift and new samples // only do shift optimization if all used vectors are same size and shift v_shift = (*_xInVector)->numShift(); v_new = (*_xInVector)->numNew(); for (KstVectorMap::ConstIterator i = VectorsUsed.begin(); i != VectorsUsed.end(); ++i) { if (v_shift != i.data()->numShift()) { v_shift = _ns; } if (v_new != i.data()->numNew()) { v_shift = _ns; } if (_ns != i.data()->length()) { v_shift = _ns; } } if (v_shift > _ns/2 || force) { i0 = 0; v_shift = _ns; } else { KstVectorPtr xv = *_xOutVector; KstVectorPtr yv = *_yOutVector; for (int i = v_shift; i < _ns; i++) { yv->value()[i - v_shift] = yv->value()[i]; xv->value()[i - v_shift] = xv->value()[i]; } i0 = _ns - v_shift; } } _numShifted = (*_yOutVector)->numShift() + v_shift; if (_numShifted > _ns) { _numShifted = _ns; } _numNew = _ns - i0 + (*_yOutVector)->numNew(); if (_numNew > _ns) { _numNew = _ns; } (*_xOutVector)->setNewAndShift(_numNew, _numShifted); (*_yOutVector)->setNewAndShift(_numNew, _numShifted); double *rawxv = (*_xOutVector)->value(); double *rawyv = (*_yOutVector)->value(); KstVectorPtr iv = (*_xInVector); Equation::Context ctx; ctx.sampleCount = _ns; ctx.xVector = iv; if (!_pe) { if (_equation.isEmpty()) { unlockInputsAndOutputs(); return true; } QMutexLocker ml(&Equation::mutex()); yy_scan_string(_equation.latin1()); int rc = yyparse(); _pe = static_cast<Equation::Node*>(ParsedEquation); if (_pe && rc == 0) { Equation::FoldVisitor vis(&ctx, &_pe); KstStringMap sm; _pe->collectObjects(VectorsUsed, ScalarsUsed, sm); ParsedEquation = 0L; } else { delete (Equation::Node*)ParsedEquation; ParsedEquation = 0L; _pe = 0L; unlockInputsAndOutputs(); return false; } } for (ctx.i = i0; ctx.i < _ns; ++ctx.i) { rawxv[ctx.i] = iv->value(ctx.i); ctx.x = iv->interpolate(ctx.i, _ns); rawyv[ctx.i] = _pe->value(&ctx); } if (!(*_xOutVector)->resize(iv->length())) { // FIXME: handle error? unlockInputsAndOutputs(); return false; } unlockInputsAndOutputs(); return true; }
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); }
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); }
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); }
void Histogram::internalUpdate() { writeLockInputsAndOutputs(); int i_bin, i_pt, ns; double y = 0.0; double MaxY = 0.0; // do auto-binning if necessary if (_realTimeAutoBin) { int temp_NumberOfBins; double temp_xMin, temp_xMax; Histogram::AutoBin(_inputVectors[RAWVECTOR], &temp_NumberOfBins, &temp_xMax, &temp_xMin); internalSetNumberOfBins(temp_NumberOfBins); internalSetXRange(temp_xMin, temp_xMax); } _NS = 3 * _NumberOfBins + 1; _W = (_MaxX - _MinX)/double(_NumberOfBins); memset(_Bins, 0, _NumberOfBins*sizeof(*_Bins)); ns = _inputVectors[RAWVECTOR]->length(); for (i_pt = 0; i_pt < ns ; ++i_pt) { y = _inputVectors[RAWVECTOR]->interpolate(i_pt, ns); i_bin = (int)floor((y-_MinX)/_W); if (i_bin >= 0 && i_bin < _NumberOfBins) { _Bins[i_bin]++; } else { // the top boundary of the top bin is included in the top bin. // for all other bins, the top boundary is included in the next bin if (y == _MaxX) { _Bins[_NumberOfBins-1]++; } } } for (i_bin=0; i_bin<_NumberOfBins; ++i_bin) { y = _Bins[i_bin]; if (y > MaxY) { MaxY = y; } } LabelInfo label_info; switch (_NormalizationMode) { case Number: _Normalization = 1.0; label_info.quantity = tr("Number"); break; case Percent: if (ns > 0) { _Normalization = 100.0/(double)ns; } else { _Normalization = 1.0; } label_info.quantity = tr("Percent"); break; case Fraction: if (ns > 0) { _Normalization = 1.0/(double)ns; } else { _Normalization = 1.0; } label_info.quantity = tr("Fraction"); break; case MaximumOne: if (MaxY > 0) { _Normalization = 1.0/MaxY; } else { _Normalization = 1.0; } label_info.quantity = tr("Normalized Frequency"); break; default: _Normalization = 1.0; label_info.quantity = tr("Number"); break; } _bVector->setLabelInfo(_inputVectors[RAWVECTOR]->labelInfo()); label_info.quantity.clear(); label_info.units.clear(); label_info.name = tr( "Histogram of %1").arg(_bVector->labelInfo().name); label_info.file = _bVector->labelInfo().file; _hVector->setTitleInfo(label_info); double *bins = _bVector->value(); double *hist = _hVector->value(); for ( i_bin = 0; i_bin<_NumberOfBins; ++i_bin ) { bins[i_bin] = ( double( i_bin ) + 0.5 )*_W + _MinX; hist[i_bin] = _Bins[i_bin]*_Normalization; } unlockInputsAndOutputs(); }
void Histogram::internalUpdate() { writeLockInputsAndOutputs(); int i_bin, i_pt, ns; double y = 0.0; double MaxY = 0.0; // do auto-binning if necessary if (_realTimeAutoBin) { int temp_NumberOfBins; double temp_xMin, temp_xMax; Histogram::AutoBin(_inputVectors[RAWVECTOR], &temp_NumberOfBins, &temp_xMax, &temp_xMin); internalSetNumberOfBins(temp_NumberOfBins); internalSetXRange(temp_xMin, temp_xMax); } _NS = 3 * _NumberOfBins + 1; _W = (_MaxX - _MinX)/double(_NumberOfBins); memset(_Bins, 0, _NumberOfBins*sizeof(*_Bins)); ns = _inputVectors[RAWVECTOR]->length(); for (i_pt = 0; i_pt < ns ; i_pt++) { y = _inputVectors[RAWVECTOR]->interpolate(i_pt, ns); i_bin = (int)floor((y-_MinX)/_W); if (i_bin >= 0 && i_bin < _NumberOfBins) { _Bins[i_bin]++; } else { // the top boundry of the top bin is included in the top bin. // for all other bins, the top boundry is included in the next bin if (y == _MaxX) { _Bins[_NumberOfBins-1]++; } } } for (i_bin=0; i_bin<_NumberOfBins; i_bin++) { y = _Bins[i_bin]; if (y > MaxY) { MaxY = y; } } switch (_NormalizationMode) { case Number: _Normalization = 1.0; _hVector->setLabel(i18n("Number in bin")); break; case Percent: if (ns > 0) { _Normalization = 100.0/(double)ns; } else { _Normalization = 1.0; } _hVector->setLabel(i18n("Percent in bin")); break; case Fraction: if (ns > 0) { _Normalization = 1.0/(double)ns; } else { _Normalization = 1.0; } _hVector->setLabel(i18n("Fraction in bin")); break; case MaximumOne: if (MaxY > 0) { _Normalization = 1.0/MaxY; } else { _Normalization = 1.0; } _hVector->setLabel(""); break; default: _Normalization = 1.0; break; } _bVector->setLabel(_inputVectors[RAWVECTOR]->descriptiveName()); double *bins = _bVector->value(); double *hist = _hVector->value(); for ( i_bin = 0; i_bin<_NumberOfBins; i_bin++ ) { bins[i_bin] = ( double( i_bin ) + 0.5 )*_W + _MinX; hist[i_bin] = _Bins[i_bin]*_Normalization; } // these will get updated by the update manager now // that their provider been changed. //_bVector->update(); //_hVector->update(); unlockInputsAndOutputs(); }