C++ vtkSmartPointer::GetArray方法代码示例

void DataAggregator::addPointData(int pointIndex, PointCoordinates coordinates, int currentTimeStep,
                                  vtkSmartPointer<vtkPointData> pointData) {
	this->lastTimeIndex = currentTimeStep;

	switch (this->dataType) {
	case Data::PRECIPITATION: {
		vtkSmartPointer<vtkDataArray> abstractPrecipitationRateArray =
		    pointData->GetArray("precipitationRates");
		vtkSmartPointer<vtkFloatArray> precipitationRateArray = vtkFloatArray::SafeDownCast(
		            abstractPrecipitationRateArray);

		if (!precipitationRateArray) {
			return;
		}

		double currentPrecipitationRate = precipitationRateArray->GetValue(pointIndex);

		if (this->aggregatedData.contains(coordinates)) {
			// The point has already been looked at before
			PrecipitationAggregationValue* currentValue = static_cast<PrecipitationAggregationValue*>
			        (this->aggregatedData.value(coordinates));

			// Accumulate the precipitation rates over time, therefore getting the total amount of precipitation.
			// To do this, two assumptions are made:
			// 1. The precipitation amount at the beginning of the accumulation is zero.
			// 2. A data point constantly emits precipitation with its precipitation rate until new precipitation rate data is available.
			currentValue->setAccumulatedPrecipitation(currentValue->getAccumulatedPrecipitation() + ((1.0 *
			        (currentTimeStep - currentValue->getTimeIndex()) * this->timeResolution) *
			        currentValue->getLastPrecipitationRate()));
			currentValue->setTimeIndex(currentTimeStep);
			currentValue->setLastPrecipitationRate(currentPrecipitationRate);
		} else {
			// This is the first time a point with these coordinates shows up
			PrecipitationAggregationValue* newValue = new PrecipitationAggregationValue();
			newValue->setLastPrecipitationRate(currentPrecipitationRate);
			newValue->setTimeIndex(currentTimeStep);
			this->aggregatedData.insert(coordinates, newValue);
		}
		break;
	}
	case Data::TEMPERATURE: {
		vtkSmartPointer<vtkDataArray> abstractTemperatureArray = pointData->GetArray("temperatures");
		vtkSmartPointer<vtkFloatArray> temperatureArray = vtkFloatArray::SafeDownCast(
		            abstractTemperatureArray);

		if (!temperatureArray) {
			return;
		}

		double currentTemperature = temperatureArray->GetValue(pointIndex);

		if (this->aggregatedData.contains(coordinates)) {
			// The point has already been looked at before
			TemperatureAggregationValue* currentValue = static_cast<TemperatureAggregationValue*>
			        (this->aggregatedData.value(coordinates));

			// Calculate the arithmetric mean with the cumulative moving average method.
			// This is a bit more costly than the naive way to calculate the average but prevents huge numbers from showing up while summing up all values.
			currentValue->setAverageTemperature((currentTemperature + (currentValue->getTimeIndex() *
			                                     currentValue->getAverageTemperature())) / (currentValue->getTimeIndex() * 1.0 + 1));
			currentValue->setTimeIndex(currentValue->getTimeIndex() + 1);
		} else {
			// This is the first time a point with these coordinates shows up
			TemperatureAggregationValue* newValue = new TemperatureAggregationValue();
			newValue->setAverageTemperature(currentTemperature);
			newValue->setTimeIndex(1);
			this->aggregatedData.insert(coordinates, newValue);
		}
		break;
	}
	case Data::WIND: {
		vtkSmartPointer<vtkDataArray> abstractVelocitiesArray = pointData->GetArray("speeds");
		vtkSmartPointer<vtkFloatArray> velocitiesArray = vtkFloatArray::SafeDownCast(
		            abstractVelocitiesArray);
		vtkSmartPointer<vtkDataArray> abstractBearingsArray = pointData->GetArray("directions");
		vtkSmartPointer<vtkFloatArray> bearingsArray = vtkFloatArray::SafeDownCast(
		            abstractBearingsArray);

		if (!velocitiesArray || !bearingsArray) {
			return;
		}

		double currentVelocity = velocitiesArray->GetValue(pointIndex);
		double currentBearing = bearingsArray->GetValue(pointIndex);

		if (this->aggregatedData.contains(coordinates)) {
			// The point has already been looked at before
			WindAggregationValue* currentValue = static_cast<WindAggregationValue*>(this->aggregatedData.value(
			        coordinates));

			// Calculate the arithmetric mean with the cumulative moving average method.
			// This is a bit more costly than the naive way to calculate the average but prevents huge numbers from showing up while summing up all values.
			currentValue->setAverageVelocity((currentVelocity + (currentValue->getTimeIndex() *
			                                  currentValue->getAverageVelocity())) / (currentValue->getTimeIndex() * 1.0 + 1));
			currentValue->setAverageBearing((currentBearing + (currentValue->getTimeIndex() *
			                                 currentValue->getAverageBearing())) / (currentValue->getTimeIndex() * 1.0 + 1));
			currentValue->setTimeIndex(currentValue->getTimeIndex() + 1);
		} else {
			// This is the first time a point with these coordinates shows up
			WindAggregationValue* newValue = new WindAggregationValue();
//.........这里部分代码省略.........