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); }
Object::UpdateType StdinSource::update(int u) { if (Object::checkUpdateCounter(u)) { return lastUpdateResult(); } if (!_valid) { _src = DataSource::loadSource(store(), _filename, "ASCII"); if (_src && _src->isValid()) { _valid = true; } else { return setLastUpdateResult(Object::NO_CHANGE); } } fd_set rfds; struct timeval tv; int retval; char instr[4097]; int i = 0; bool new_data = false; bool got_some = false; int handle = _file->handle(); FILE *fp = fdopen(handle, "w+"); if (!fp) { return setLastUpdateResult(Object::NO_CHANGE); } do { /* Watch stdin (fd 0) to see when it has input. */ FD_ZERO(&rfds); FD_SET(0, &rfds); /* Wait up to 0 seconds. */ tv.tv_sec = 0; tv.tv_usec = 0; retval = select(1, &rfds, NULL, NULL, &tv); new_data = false; if (retval > 0) { char *fgs = fgets(instr, 4096, stdin); if (fgs && fp) { got_some = true; fputs(instr, fp); new_data = true; } } } while (++i < 100000 && new_data); fclose(fp); if (got_some && _src) { return setLastUpdateResult(_src->update(u)); } return setLastUpdateResult(Object::NO_CHANGE); }
KstObject::UpdateType DMCSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } if (_valid && _dmcObject && _dmcObject->updated()) { updateNumFramesScalar(); return setLastUpdateResult(KstObject::UPDATE); } return setLastUpdateResult(KstObject::NO_CHANGE); }
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); }
KstObject::UpdateType NADDirectSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } if (_conn && _conn->updated()) { updateNumFramesScalar(); kstdDebug() << "NAD::update(" << QString::number(u) << ") = UPDATE\n"; return setLastUpdateResult(KstObject::UPDATE); } else { kstdDebug() << "NAD::update(" << QString::number(u) << ") = NO_CHANGE\n"; return setLastUpdateResult(KstObject::NO_CHANGE); } }
KstObject::UpdateType IndirectSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } // recheck the indirect file for a changed filename QFile f(_filename); if (f.open(QIODevice::ReadOnly)) { char* data; if (0 < f.readLine(data,1000)) { QString ifn(data); KUrl url(ifn); if (url.isLocalFile() || url.protocol().isEmpty()) { if (QFileInfo(ifn).isRelative()) { ifn = QFileInfo(_filename).absolutePath() + QDir::separator() + ifn; } } if (!_child || ifn.trimmed() != _child->fileName()) { _child = 0L; // release KstDataSourcePtr p = KstDataSource::loadSource(ifn.trimmed()); if (p) { _child = p; _fieldList = p->fieldList(); _valid = true; } else { _valid = false; } } } } return setLastUpdateResult(_child ? _child->update(u) : KstObject::NO_CHANGE); }
KstObject::UpdateType KstPrimitive::update(int update_counter) { bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(update_counter) && !force) { return lastUpdateResult(); } KstObject::UpdateType providerRC = NO_CHANGE; if (update_counter > 0) { KstObjectPtr prov = KstObjectPtr(_provider); if (prov) { // provider is already locked providerRC = prov->update(update_counter); if (!force && providerRC == KstObject::NO_CHANGE) { return setLastUpdateResult(providerRC); } } } KstObject::UpdateType rc = internalUpdate(providerRC); setDirty(false); return rc; }
KstObject::UpdateType TemplateSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } // fill me in return setLastUpdateResult(KstObject::NO_CHANGE); }
KstObject::UpdateType HealpixSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } // updates not supported yet // we should check to see if the FITS file has changed on disk return setLastUpdateResult(KstObject::NO_CHANGE); }
KstObject::UpdateType KstScalar::update(int updateCounter) { bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(updateCounter) && !force) { return lastUpdateResult(); } double v = value(); if (_provider) { _provider->update(updateCounter); } else if (force) { return setLastUpdateResult(UPDATE); } 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 WMAPSource::update( int u ) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } KstObject::UpdateType updateType = KstObject::NO_CHANGE; return setLastUpdateResult(updateType); }
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); }
KstObject::UpdateType QimagesourceSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } int newNF = _image.width()*_image.height(); bool isnew = newNF != _frameCount; _frameCount = newNF; updateNumFramesScalar(); return setLastUpdateResult(isnew ? KstObject::UPDATE : KstObject::NO_CHANGE); }
KstObject::UpdateType DirFileSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } int err = 0; int newNF = GetNFrames(_filename.latin1(), &err, 0L); bool isnew = newNF != _frameCount; _frameCount = newNF; updateNumFramesScalar(); return setLastUpdateResult(isnew ? KstObject::UPDATE : KstObject::NO_CHANGE); }
KstObject::UpdateType FrameSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } QString tmpfilename; struct stat stat_buf; int done = 0; int dec = 0; int newN; if (_maxExt < 0) { // no hex number extension: only this file if (stat(_filename.toLatin1(), &stat_buf) != 0) { // file is gone newN = 0; } else { // file exists newN = stat_buf.st_size/_bytesPerFrame; } } else { do { tmpfilename.sprintf("%s%2.2x", _rootFileName.toLatin1().data(), _maxExt); if (stat(QFile::encodeName(tmpfilename).data(), &stat_buf) != 0) { if (_maxExt > _rootExt) { // deleted (?) check the next one down _maxExt--; dec = 1; } else { // All files have been deleted stat_buf.st_size = 0; done = 1; } } else { if (stat_buf.st_size == _bytesPerFrame*_framesPerFile) { // Full file if (dec) { // already checked next one up: it is empty done = 1; } else { _maxExt++; } } else { done = 1; } } } while (!done); newN = (_maxExt - _rootExt)*_framesPerFile + stat_buf.st_size/_bytesPerFrame; } bool isnew = _frameCount != newN; _frameCount = newN; updateNumFramesScalar(); return setLastUpdateResult(isnew ? KstObject::UPDATE : KstObject::NO_CHANGE); }
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 KstRMatrix::update(int update_counter) { bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(update_counter) && !force) { return lastUpdateResult(); } if (_file) { _file->writeLock(); } KstObject::UpdateType rc = doUpdate(force); if (_file) { _file->unlock(); } setDirty(false); return setLastUpdateResult(rc); }
KstObject::UpdateType KstViewLabel::update(int counter) { if (checkUpdateCounter(counter)) { return lastUpdateResult(); } KstObject::UpdateType rc = NO_CHANGE; _cache.update(); if (!_cache.valid) { rc = UPDATE; setDirty(); } if (rc != UPDATE) { rc = KstBorderedViewObject::update(counter); } else { KstBorderedViewObject::update(counter); } return setLastUpdateResult(rc); }
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 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); }
KstObject::UpdateType CdfSource::update(int u) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } return setLastUpdateResult(KstObject::NO_CHANGE); }
KstObject::UpdateType KstHistogram::update(int update_counter) { bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(update_counter) && !force) { return lastUpdateResult(); } if (update_counter <= 0) { assert(update_counter == 0); force = true; } bool xUpdated = KstObject::UPDATE == _inputVectors[RAWVECTOR]->update(update_counter); if (!xUpdated && !force) { return setLastUpdateResult(KstObject::NO_CHANGE); } int i_bin, i_pt, ns; double y = 0.0; double MaxY = 0.0; // do auto-binning if necessary if (_realTimeAutoBin) { int temp_NBins; double temp_xMin, temp_xMax; KstHistogram::AutoBin(_inputVectors[RAWVECTOR], &temp_NBins, &temp_xMax, &temp_xMin); internalSetNBins(temp_NBins); setXRange(temp_xMin, temp_xMax); } _NS = 3 * _NBins + 1; _W = (_MaxX - _MinX)/double(_NBins); memset(_Bins, 0, _NBins*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 < _NBins) { _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[_NBins-1]++; } } } for (i_bin=0; i_bin<_NBins; i_bin++) { y = _Bins[i_bin]; if (y > MaxY) { MaxY = y; } } switch (_NormMode) { case KST_HS_NUMBER: _Normalization = 1.0; (*_hVector)->setLabel(i18n("Number in bin")); break; case KST_HS_PERCENT: if (ns > 0) { _Normalization = 100.0/(double)ns; } else { _Normalization = 1.0; } (*_hVector)->setLabel(i18n("Percent in bin")); break; case KST_HS_FRACTION: if (ns > 0) { _Normalization = 1.0/(double)ns; } else { _Normalization = 1.0; } (*_hVector)->setLabel(i18n("Fraction in bin")); break; case KST_HS_MAX_ONE: if (MaxY > 0) { _Normalization = 1.0/MaxY; } else { _Normalization = 1.0; } (*_hVector)->setLabel(""); break; default: _Normalization = 1.0; break; } (*_bVector)->setLabel(_inputVectors[RAWVECTOR]->tagName()); double *bins = (*_bVector)->value(); double *hist = (*_hVector)->value(); for ( i_bin = 0; i_bin<_NBins; i_bin++ ) { bins[i_bin] = ( double( i_bin ) + 0.5 )*_W + _MinX; hist[i_bin] = _Bins[i_bin]*_Normalization; } (*_bVector)->setDirty(); (*_bVector)->update(update_counter); (*_hVector)->setDirty(); (*_hVector)->update(update_counter); return setLastUpdateResult(UPDATE); }
KstObject::UpdateType KstCSD::update(int update_counter) { KstVectorPtr inVector = _inputVectors[INVECTOR]; bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(update_counter) && !force) { return lastUpdateResult(); } 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 ) { return setLastUpdateResult(NO_CHANGE); } // create a psd generator KstPSDGenerator psdGenerator(0L, _frequency, _average, _length, _apodize, _removeMean, _apodizeFxn, _gaussianSigma); int xSize = 0; for (int i=0; i < inVector->length(); i+= _windowSize + 1) { int vectorSize = _windowSize; // determine size of actual input data if (i + _windowSize >= inVector->length()) { if (i == 0) { // if this is the one and only window, get a PSD vectorSize = i + _windowSize - inVector->length(); } else { // don't PSD the last window if it is chopped off break; } } // copy input vector elements into subvector QValueVector<double> psdInputVector(_windowSize, 0); double* inVectorArray = inVector->value(); for (int j=0; j < vectorSize; j++) { psdInputVector[j] = inVectorArray[i+j]; } // set the vector and calculate PSD psdGenerator.setInputVector(&psdInputVector); psdGenerator.updateNow(); // resize output matrix (*_outMatrix)->resize(xSize+1, psdGenerator.powerVector()->size()); // copy elements to output matrix for (uint j=0; j < psdGenerator.powerVector()->size(); j++) { (*_outMatrix)->setValueRaw(xSize, j, psdGenerator.powerVector()->at(j)); } xSize++; } (*_outMatrix)->change((*_outMatrix)->tagName(), xSize, psdGenerator.frequencyVector()->size(), 0, 0, _windowSize, psdGenerator.frequencyVectorStep()); (*_outMatrix)->update(update_counter); return setLastUpdateResult(UPDATE); }
KstObject::UpdateType KstCSD::update(int update_counter) { KstVectorPtr inVector = _inputVectors[INVECTOR]; bool force = dirty(); setDirty(false); if (KstObject::checkUpdateCounter(update_counter) && !force) { return lastUpdateResult(); } 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) { return setLastUpdateResult(NO_CHANGE); } double *tempOutput, *input; int tempOutputLen = PSDCalculator::calculateOutputVectorLength(_windowSize, _average, _averageLength); _PSDLen = 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 { KstDebug::self()->log(i18n("Could not allocate sufficient memory for CSD."), KstDebug::Error); break; } xSize++; } delete tempOutput; double frequencyStep = .5*_frequency/(double)(tempOutputLen-1); (*_outMatrix)->change((*_outMatrix)->tagName(), xSize, tempOutputLen, 0, 0, _windowSize, frequencyStep); (*_outMatrix)->update(update_counter); return setLastUpdateResult(UPDATE); }
KstObject::UpdateType LFIIOSource::update( int u ) { if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } KstObject::UpdateType updateType = KstObject::NO_CHANGE; QString strTemplate; QString strName; fitsfile* ffits; char charTemplate[ FLEN_CARD ]; char charName[ FLEN_CARD ]; long lNumFrames; long lMaxRepeat = 1; long lRepeat; long lWidth; int iColNumber; int iNumCols; int iStatus = 0; int iResult = 0; int iTypeCode; int i; _valid = false; if( !_filename.isNull( ) && !_filename.isEmpty( ) ) { iResult = fits_open_table( &ffits, _filename.toAscii( ), READONLY, &iStatus ); if( iResult == 0 ) { // // determine size of data... // iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus ); if( iResult == 0 ) { iResult = fits_get_num_rows( ffits, &lNumFrames, &iStatus ); if( iResult == 0 ) { _fieldList.clear( ); _fieldList.append( "INDEX" ); _valid = true; _bHasTime = false; // // need to multiply lNumFrames by the maximum value of the vector repeat value... // for( i=0; i<iNumCols; i++ ) { iStatus = 0; sprintf( charTemplate, "%d", i+1 ); iResult = fits_get_colname( ffits, CASEINSEN, charTemplate, charName, &iColNumber, &iStatus ); if( iResult == 0 ) { int iOffset = i; strName = charName; // // ensure that we don't add duplicates to the _fieldList... // while( _fieldList.indexOf( strName ) != -1 ) { strName = QString("%1[%2]").arg( charName ).arg( iOffset ); iOffset++; } } else { strName.setNum( i ); } _fieldList.append( strName ); iStatus = 0; iResult = fits_get_coltype( ffits, i+1, &iTypeCode, &lRepeat, &lWidth, &iStatus ); if( iResult == 0 ) { if( lRepeat > lMaxRepeat ) { lMaxRepeat = lRepeat; } } } // // check if we have a time field defined by the header keys TIMEZERO and DELTA_T. // If so then we create a new field called $TIME_FIELD, unless such a field already // exists, in which case we do nothing... // char charTimeZero[] = "TIMEZERO"; iStatus = 0; iResult = fits_read_key( ffits, TDOUBLE, charTimeZero, &_dTimeZero, 0L, &iStatus ); if( iResult == 0 ) { char charTimeDelta[] = "DELTA_T"; iResult = fits_read_key( ffits, TDOUBLE, charTimeDelta, &_dTimeDelta, 0L, &iStatus ); if( iResult == 0 ) { if( _fieldList.indexOf( QString( TIME_FIELD ) ) == _fieldList.size( )-1 ) { _bHasTime = true; _fieldList.append( TIME_FIELD ); } } } if( lNumFrames * lMaxRepeat != _numFrames ) { _numCols = iNumCols; _numFrames = lNumFrames * lMaxRepeat; updateType = KstObject::UPDATE; } } } iStatus = 0; fits_close_file( ffits, &iStatus ); } } updateNumFramesScalar(); return setLastUpdateResult(updateType); }