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 TemplateSource::update(int u) {
if (KstObject::checkUpdateCounter(u)) {
return lastUpdateResult();
}
// fill me in
return setLastUpdateResult(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 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);
}
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);
}
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 WMAPSource::update( int u )
{
if (KstObject::checkUpdateCounter(u)) {
return lastUpdateResult();
}
KstObject::UpdateType updateType = KstObject::NO_CHANGE;
return setLastUpdateResult(updateType);
}
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 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 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 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 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 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) {
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 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;
}
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 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 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 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 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 CdfSource::update(int u) {
if (KstObject::checkUpdateCounter(u)) {
return lastUpdateResult();
}
return setLastUpdateResult(KstObject::NO_CHANGE);
}
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 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 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);
}
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);
}
