C++ AMnDIndex::rank方法代码示例

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

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

QPair<double, double> AM2DScanView::getCurrentExclusiveDataSourceRange(const AMnDIndex &start, const AMnDIndex &end) const
{
	if (start == end && start.rank() == 2 && end.rank() == 2){

		QPair<double, double> range = exclusive2DScanBar_->range();
		double val = double(currentExclusiveDataSource_->value(start));

		if ((val != -1 && range.first > val) || range.first == -1)
			range.first = val;

		if (range.second < val)
			range.second = val;

		return range;
	}

	else {

		int totalSize = 0;
		AMnDIndex startIndex = start;
		AMnDIndex endIndex = end;

		if (startIndex.rank() == 0 || endIndex.rank() == 0){

			startIndex = AMnDIndex(0, 0);
			endIndex = AMnDIndex(currentExclusiveDataSource_->size(0)-1, currentExclusiveDataSource_->size(1)-1);
			totalSize = startIndex.totalPointsTo(endIndex);
		}

		else
			totalSize = start.totalPointsTo(end);

		if (totalSize > 0){

			QVector<double> data(totalSize);
			currentExclusiveDataSource_->values(startIndex, endIndex, data.data());

			double min = data.at(0);
			double max = data.at(0);

			foreach (double value, data){

				if ((value != -1 && min > value) || min == -1)
					min = value;

				if (max < value)
					max = value;
			}

			return qMakePair(min, max);
		}

		else
			return qMakePair(-1.0, -1.0);

// Connected to be called when the values of the input data source change
void AM3DAdditionAB::onInputSourceValuesChanged(const AMnDIndex& start, const AMnDIndex& end)
{
	cacheUpdateRequired_ = true;

	AMnDIndex scanStart = start;
	AMnDIndex scanEnd = end;
	scanStart.setRank(start.rank()-1);
	scanEnd.setRank(end.rank()-1);

	if (scanStart == scanEnd)
		dirtyIndices_ << start;

	emitValuesChanged(start, end);
}

bool AM3DDeadTimeAB::values(const AMnDIndex &indexStart, const AMnDIndex &indexEnd, double *outputValues) const
{
	if(indexStart.rank() != 3 || indexEnd.rank() != 3)
		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()
			|| (unsigned)indexEnd.j() >= (unsigned)axes_.at(1).size || (unsigned)indexStart.j() > (unsigned)indexEnd.j()
			|| (unsigned)indexEnd.k() >= (unsigned)axes_.at(2).size || (unsigned)indexStart.k() > (unsigned)indexEnd.k())
		return false;
#endif

	int totalSize = indexStart.totalPointsTo(indexEnd);
	AMnDIndex start2D = AMnDIndex(indexStart.i(), indexStart.j());
	AMnDIndex end2D = AMnDIndex(indexEnd.i(), indexEnd.j());
	int icrOcrTotalSize = start2D.totalPointsTo(end2D);

	QVector<double> data = QVector<double>(totalSize);
	QVector<double> icr = QVector<double>(icrOcrTotalSize);
	QVector<double> ocr = QVector<double>(icrOcrTotalSize);
	spectra_->values(indexStart, indexEnd, data.data());
	icr_->values(start2D, end2D, icr.data());
	ocr_->values(start2D, end2D, ocr.data());

	for (int i = 0, iSize = indexEnd.i()-indexStart.i()+1; i < iSize; i++){

		for (int j = 0, jSize = indexEnd.j()-indexStart.j()+1; j < jSize; j++){

			// If ocr is equal to 0 then that will cause division by zero.  Since these are both count rates, they should both be greater than zero.
			if (icr.at(i*jSize+j) <= 0 || ocr.at(i*jSize+j) <= 0){

				for (int k = 0, kSize = indexEnd.k()-indexStart.k()+1; k < kSize; k++)
					outputValues[i*jSize*kSize+j*kSize+k] = 0;
			}

			else {

				double factor = icr.at(i*jSize+j)/ocr.at(i*jSize+j);

				for (int k = 0, kSize = indexEnd.k()-indexStart.k()+1; k < kSize; k++)
					outputValues[i*jSize*kSize+j*kSize+k] = data.at(i*jSize*kSize+j*kSize+k)*factor;
			}
		}
	}

	return true;
}

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

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

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

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

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

	for (int i = 0, size = indexes.rank(); i < size; i++)
		if((unsigned)indexes.at(i) >= (unsigned)axes_.at(i).size)
			return AMNumber(AMNumber::OutOfBoundsError);

	if (cacheUpdateRequired_)
		computeCachedValues();

	return cachedData_.at(indexes.flatIndexInArrayOfSize(size()));
}

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 AMInMemoryDataStore::measurementValuesImplementationRecursive(const AMIMDSMeasurement &measurement, const AMnDIndex &indexStart, const AMnDIndex &indexEnd, const AMnDIndex &fullSize, double **outputValues, int dimension, int cOffset) const {

	if(dimension == indexStart.rank()-1) { // base case: final dimension
		for(int i=indexStart.at(dimension); i<=indexEnd.at(dimension); ++i) {
			*((*outputValues)++) = double(measurement.at(cOffset+i));
		}
	}
	else {
		for(int i=indexStart.at(dimension); i<=indexEnd.at(dimension); ++i) {
			// get product of all higher dimensions:
			int multiplier = 1;
			for(int mu=dimension+1; mu<indexStart.rank(); ++mu)
				multiplier *= fullSize.at(mu);

			// recurse:
			measurementValuesImplementationRecursive(measurement, indexStart, indexEnd, fullSize, outputValues, dimension+1, cOffset + i*multiplier);
		}
	}
}

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

	if(!isValid())
		return false;

	if((unsigned)indexEnd.i() >= (unsigned)axes_.at(0).size || (unsigned)indexStart.i() > (unsigned)indexEnd.i()
			|| (unsigned)indexEnd.j() >= (unsigned)axes_.at(1).size || (unsigned)indexStart.j() > (unsigned)indexEnd.j()
			|| (unsigned)indexEnd.k() >= (unsigned)axes_.at(2).size || (unsigned)indexStart.k() > (unsigned)indexEnd.k())
		return false;

	int totalSize = indexStart.totalPointsTo(indexEnd);

	QVector<double> data = QVector<double>(totalSize);
	QVector<double> icr = QVector<double>(totalSize);
	QVector<double> ocr = QVector<double>(totalSize);
	spectra_->values(indexStart, indexEnd, data.data());
	icr_->values(indexStart, indexEnd, icr.data());
	ocr_->values(indexStart, indexEnd, ocr.data());

	for (int i = 0, iSize = indexEnd.i()-indexStart.i()+1; i < iSize; i++){

		for (int j = 0, jSize = indexEnd.j()-indexStart.j()+1; j < jSize; j++){

			for (int k = 0, kSize = indexEnd.k()-indexStart.k()+1; k < kSize; k++){

				int index = i + j*iSize + k*iSize*jSize;

				// If ocr is equal to 0 then that will cause division by zero.  Since these are both count rates, they should both be greater than zero.
				if (icr.at(index) <= 0 || ocr.at(index) <= 0)
					outputValues[index] = 0;

				else
					outputValues[index] = data.at(index)*icr.at(index)/ocr.at(index);
			}
		}
	}

	return true;
}

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

	if(!isValid())
		return false;

	for (int i = 0, size = indexStart.rank(); i < size; i++)
		if((unsigned)indexStart.at(i) >= (unsigned)axes_.at(i).size || (unsigned)indexStart.at(i) > (unsigned)indexEnd.at(i))
			return false;

	if (cacheUpdateRequired_)
		computeCachedValues();

	int totalSize = indexStart.totalPointsTo(indexEnd);
	memcpy(outputValues, cachedData_.constData()+indexStart.flatIndexInArrayOfSize(size()), totalSize*sizeof(double));

	return true;
}