C++ AMnDIndex类代码示例

AMNumber AMInMemoryDataStore::value(const AMnDIndex &scanIndex, int measurementId, const AMnDIndex &measurementIndex) const {

	// scan axis index doesn't provide enough / too many dimensions
	if(scanIndex.rank() != axes_.count())
		return AMNumber(AMNumber::DimensionError);

	if((unsigned)measurementId >= (unsigned)measurements_.count())
		return AMNumber(AMNumber::InvalidError);	// invalid measurement specified;

	if(measurementIndex.rank() != measurements_.at(measurementId).rank())
		return AMNumber(AMNumber::DimensionError);

	int flatMeasurementIndex = flatIndexForMeasurement(measurementId, measurementIndex);

	if(axes_.count() == 0) {
#ifdef AM_ENABLE_BOUNDS_CHECKING
		if(flatMeasurementIndex >= scalarScanPoint_.at(measurementId).size())
			return AMNumber(AMNumber::OutOfBoundsError);
#endif
		return scalarScanPoint_.at(measurementId).at(flatMeasurementIndex);
	}
	else { // higher dimensions:
		int flatScanIndex = scanIndex.flatIndexInArrayOfSize(scanSize_);
#ifdef AM_ENABLE_BOUNDS_CHECKING
		if(flatScanIndex >= scanPoints_.count())
			return AMNumber(AMNumber::OutOfBoundsError);
		if(flatMeasurementIndex >= scanPoints_.at(flatScanIndex).at(measurementId).size())
			return AMNumber(AMNumber::OutOfBoundsError);
#endif
		return scanPoints_.at(flatScanIndex).at(measurementId).at(flatMeasurementIndex);
	}
}

void AMNormalizationAB::reviewState()
{
	// Are there data sources?
	if(sources_.isEmpty()){

		setState(AMDataSource::InvalidFlag);
		return;
	}

	// Are all the data sources the same size?
	AMnDIndex firstSize = sources_.first()->size();

	for (int i = 0, size = firstSize.rank(); i < size; i++)
		foreach (AMDataSource *dataSource, sources_)
			if(firstSize.at(i) != dataSource->size(i)){

				setState(AMDataSource::InvalidFlag);
				return;
			}

	// Validity check on all data sources.
	bool valid = true;

	for (int i = 0; i < sources_.size(); i++)
		valid = valid && sources_.at(i)->isValid();

	if (valid)
		setState(0);
	else
		setState(AMDataSource::InvalidFlag);
}

bool AMInMemoryDataStore::setValue(const AMnDIndex &scanIndex, int measurementId, const AMnDIndex &measurementIndex, const AMNumber &newValue) {

	if(scanIndex.rank() != axes_.count())
		return false; // scan axis index doesn't provide enough / too many dimensions

	if((unsigned)measurementId >= (unsigned)measurements_.count())
		return false;	// invalid measurement specified;

	if(measurementIndex.rank() != measurements_.at(measurementId).rank())
		return false;

	int flatMeasurementIndex = flatIndexForMeasurement(measurementId, measurementIndex);

	if(axes_.count() == 0) {
#ifdef AM_ENABLE_BOUNDS_CHECKING
		if(flatMeasurementIndex >= scalarScanPoint_.at(measurementId).size())
			return false;
#endif
		scalarScanPoint_[measurementId][flatMeasurementIndex] = newValue;
	}
	else { // higher dimensions:
		int flatScanIndex = scanIndex.flatIndexInArrayOfSize(scanSize_);
#ifdef AM_ENABLE_BOUNDS_CHECKING
		if(flatScanIndex >= scanPoints_.count())
			return false;
		if(flatMeasurementIndex >= scanPoints_.at(flatScanIndex).at(measurementId).size())
			return false;
#endif
		scanPoints_[flatScanIndex][measurementId][flatMeasurementIndex] = newValue;
	}

	emitDataChanged(scanIndex, scanIndex, measurementId);
	return true;
}

AMNumber CLSQE65000Detector::reading(const AMnDIndex &indexes) const{
	if( (!isConnected()) || (indexes.rank() != 1) || (indexes.i() > 1024) )
		return AMNumber(AMNumber::DimensionError);

	AMReadOnlyPVControl *tmpControl = qobject_cast<AMReadOnlyPVControl*>(spectrumControl_);
	return tmpControl->readPV()->lastIntegerValues().at(indexes.i());
}

// Connected to be called when the values of the input data source change
void AM2DDeadTimeAB::onInputSourceValuesChanged(const AMnDIndex& start, const AMnDIndex& end)
{
	if (start.rank() == axes_.size() && end.rank() == axes_.size())
		emitValuesChanged(start, end);

	else
		emitValuesChanged();
}

// Connected to be called when the values of the input data source change
void AMDeadTimeAB::onInputSourceValuesChanged(const AMnDIndex& start, const AMnDIndex& end)
{
	if (start.isValid() && end.isValid())
		emitValuesChanged(start, end);

	else
		emitValuesChanged();
}

AMnDIndex AMDetector::size() const
{
    AMnDIndex index = AMnDIndex(axes_.size(), AMnDIndex::DoNotInit);

    for (int i = 0, size = index.rank(); i < size; i++)
        index[i] = axes_.at(i).size;

    return index;
}

bool AMBasicXRFDetectorInfo::setSize(const AMnDIndex &size)
{
	if (size.rank() != 1)
		return false;

	channels_ = size.i();
	setModified(true);
	return true;
}

void AM3DAdditionAB::computeCachedValues() const
{
	AMnDIndex start = AMnDIndex();
	AMnDIndex end = AMnDIndex();

	if (dirtyIndices_.isEmpty()){

		start = AMnDIndex(rank(), AMnDIndex::DoInit);
		end = size()-1;
	}

	else {

		start = dirtyIndices_.first();
		end = dirtyIndices_.last();
		end[rank()-1] = size(rank()-1);
	}

	int totalSize = start.totalPointsTo(end);
	int flatStartIndex = start.flatIndexInArrayOfSize(size());
	QVector<double> data = QVector<double>(totalSize);
	sources_.at(0)->values(start, end, data.data());

	// Do the first data source separately to initialize the values.
	memcpy(cachedData_.data()+flatStartIndex, data.constData(), totalSize*sizeof(double));
	cachedData_ = data;

	// Iterate through the rest of the sources.
	for (int i = 1, count = sources_.size(); i < count; i++){

		sources_.at(i)->values(start, end, data.data());

		for (int j = 0; j < totalSize; j++)
			cachedData_[flatStartIndex+j] += data.at(j);
	}

	if (dirtyIndices_.isEmpty())
		cachedDataRange_ = AMUtility::rangeFinder(cachedData_);

	else{
		AMRange cachedRange = AMUtility::rangeFinder(cachedData_.mid(flatStartIndex, totalSize));

		if (cachedDataRange_.minimum() > cachedRange.minimum())
			cachedDataRange_.setMinimum(cachedRange.minimum());

		if (cachedDataRange_.maximum() < cachedRange.maximum())
			cachedDataRange_.setMaximum(cachedRange.maximum());
	}

	cacheUpdateRequired_ = false;
	dirtyIndices_.clear();
}

// Returns the dependent value at a (complete) set of axis indexes. Returns an invalid AMNumber if the indexes are insuffient or any are out of range, or if the data is not ready.
AMNumber AM1DExpressionAB::value(const AMnDIndex& indexes) const {
	if(!isValid())	// will catch most invalid situations: non matching sizes, invalid inputs, invalid expressions.
		return AMNumber(AMNumber::InvalidError);

	if(indexes.rank() != 1)
		return AMNumber(AMNumber::DimensionError);

#ifdef AM_ENABLE_BOUNDS_CHECKING
		if(indexes.i() < 0 || indexes.i() >= size_)
			return AMNumber(AMNumber::OutOfBoundsError);
#endif


	// can we get it directly? Single-value expressions don't require the parser.
	if(direct_) {
		// info on which variable to use is contained in directVar_.
		if(directVar_.useAxisValue)
			return sources_.at(directVar_.sourceIndex)->axisValue(0, indexes.i());
		else
			return sources_.at(directVar_.sourceIndex)->value(indexes);
	}

	// otherwise we need the parser
	else {
		// copy the new input data values into parser storage
		for(int i=0; i<usedVariables_.count(); i++) {
			AMParserVariable* usedVar = usedVariables_.at(i);
			if(usedVar->useAxisValue)
				usedVar->value = sources_.at(usedVar->sourceIndex)->axisValue(0, indexes.i());
			else
				usedVar->value = sources_.at(usedVar->sourceIndex)->value(indexes);
		}

		// evaluate using the parser:
		double rv;
		try {
			rv = parser_.Eval();
		}
		catch(mu::Parser::exception_type& e) {
			QString explanation = QString("AM1DExpressionAB Analysis Block: error evaluating value: %1: '%2'.  We found '%3' at position %4.").arg(QString::fromStdString(e.GetMsg()), QString::fromStdString(e.GetExpr()), QString::fromStdString(e.GetToken())).arg(e.GetPos());
			AMErrorMon::report(AMErrorReport(this, AMErrorReport::Debug, e.GetCode(), explanation));
			return AMNumber(AMNumber::InvalidError);
		}

		if (rv == std::numeric_limits<qreal>::infinity() || rv == -std::numeric_limits<qreal>::infinity() || rv == std::numeric_limits<qreal>::quiet_NaN())
			return 0;

		return rv;
	}
}

// Helper function to implement the base-class version of values() when rank > 4.
void AMDataSource::valuesImplementationRecursive(const AMnDIndex &indexStart, const AMnDIndex &indexEnd, AMnDIndex current, int dimension, double **outputValues) const
{
    if(dimension == current.rank()-1) {	// base case: final dimension
        for(int i=indexStart.at(dimension); i<=indexEnd.at(dimension); ++i) {
            current[dimension] = i;
            *((*outputValues)++) = double(value(current));
        }
    }
    else {
        for(int i=indexStart.at(dimension); i<indexEnd.at(dimension); ++i) {
            current[dimension] = i;
            valuesImplementationRecursive(indexStart, indexEnd, current, dimension+1, outputValues);
        }
    }
}

AMNumber AMDeadTimeAB::value(const AMnDIndex &indexes) const
{
	if(indexes.rank() != 1)
		return AMNumber(AMNumber::DimensionError);

	if(!isValid())
		return AMNumber(AMNumber::InvalidError);

	if (indexes.i() >= spectra_->size(0))
		return AMNumber(AMNumber::OutOfBoundsError);

	if ((int)spectra_->value(indexes.i()) == 0)
		return 0;
	else
		return double(icr_->value(AMnDIndex()))/double(ocr_->value(AMnDIndex()))*(int)spectra_->value(indexes.i());
}

AMNumber REIXSXESImageInterpolationAB::value(const AMnDIndex &indexes) const
{
	if((indexes.rank() != 1))
		return AMNumber(AMNumber::DimensionError);

	if(!isValid())
		return AMNumber(AMNumber::InvalidError);

	if(((unsigned long)indexes.i() >= (unsigned long)axes_.at(0).size))
		return AMNumber(AMNumber::OutOfBoundsError);

	if(cacheUpdateRequired_)
		computeCachedValues();

	return AMNumber(cachedData_.at(indexes.i()));
}

AMNumber AM1DInterpolationAB::value(const AMnDIndex& indexes) const{
	if(indexes.rank() != 1)
		return AMNumber(AMNumber::DimensionError);

	if(!isValid())
		return AMNumber(AMNumber::InvalidError);

#ifdef AM_ENABLE_BOUNDS_CHECKING
		if((unsigned)indexes.i() >= (unsigned)axes_.at(0).size)
			return AMNumber(AMNumber::OutOfBoundsError);
#endif

	int index = indexes.i();

	return inputSource_->value(index);
}

bool AM1DInterpolationAB::values(const AMnDIndex &indexStart, const AMnDIndex &indexEnd, double *outputValues) const
{
	if(indexStart.rank() != 1 || indexEnd.rank() != 1)
		return false;

	if(!isValid())
		return false;

#ifdef AM_ENABLE_BOUNDS_CHECKING
	if((unsigned)indexEnd.i() >= (unsigned)axes_.at(0).size || (unsigned)indexStart.i() > (unsigned)indexEnd.i())
		return false;
#endif

	inputSource_->values(indexStart, indexEnd, outputValues);
	return true;
}