IDataArray::Pointer copyData(IDataArray::Pointer inputData, size_t totalPoints, int32_t* featureIds) { QString cellArrayName = inputData->getName(); typename DataArray<T>::Pointer feature = std::dynamic_pointer_cast<DataArray<T> >(inputData); if (NULL == feature) { return IDataArray::NullPointer(); } QVector<size_t> cDims = inputData->getComponentDimensions(); typename DataArray<T>::Pointer cell = DataArray<T>::CreateArray(totalPoints, cDims, cellArrayName); T* fPtr = feature->getPointer(0); T* cPtr = cell->getPointer(0); int32_t numComp = feature->getNumberOfComponents(); int32_t featureIdx = 0; for (size_t i = 0; i < totalPoints; ++i) { // Get the feature id (or what ever the user has selected as their "Feature" identifier featureIdx = featureIds[i]; // Now get the pointer to the start of the tuple for the Feature Array at the given Feature Id Index value T* fSourcePtr = fPtr + (numComp * featureIdx); // Now get the pointer to the start of the tuple for the Cell Array at the proper index T* cDestPtr = cPtr + (numComp * i); // Now just raw copy the bytes from the source to the destination ::memcpy(cDestPtr, fSourcePtr, sizeof(T) * numComp); } return cell; }
void reduceArrayOnly(IDataArray::Pointer inputData, IDataArray::Pointer reducedData, int compNumber) { typename DataArray<T>::Pointer inputArrayPtr = boost::dynamic_pointer_cast<DataArray<T> >(inputData); typename DataArray<T>::Pointer reducedArrayPtr = boost::dynamic_pointer_cast<DataArray<T> >(reducedData); if (NULL == inputArrayPtr) { return; } T* inputArray = inputArrayPtr->getPointer(0); T* reducedArray = reducedArrayPtr->getPointer(0); size_t numPoints = inputArrayPtr->getNumberOfTuples(); size_t numComps = inputArrayPtr->getNumberOfComponents(); for (size_t i = 0; i < numPoints; i++) { for (size_t j = 0; j < numComps; j++) { if (j > compNumber) { reducedArray[(numComps - 1)*i + j - 1] = inputArray[numComps * i + j]; } else if (j < compNumber) { reducedArray[(numComps - 1)*i + j] = inputArray[numComps * i + j]; } } } }
int __ValidateArray(typename DataArray<T>::Pointer array, size_t numTuples, int numComp) { int err = 0; DREAM3D_REQUIRED(true, ==, array->isAllocated() ); size_t nt = array->getNumberOfTuples(); DREAM3D_REQUIRED(nt, ==, numTuples); int nc = array->getNumberOfComponents(); DREAM3D_REQUIRED(nc, ==, numComp ); size_t typeSize = array->getTypeSize(); DREAM3D_REQUIRE_EQUAL(sizeof(T), typeSize); size_t numElements = array->getSize(); DREAM3D_REQUIRED(numElements, ==, (nt * nc) ); // initialize the array with zeros to get a baseline array->initializeWithZeros(); // Get a pointer to the data and loop through the array making sure all values are Zero T* ptr = array->getPointer(0); for(size_t i = 0; i < numElements; i++) { DREAM3D_REQUIRE_EQUAL(0, ptr[i]); } //Splat another value across the array starting at an offset into the array //and test those values made it into the array correctly array->initializeWithValue(static_cast<T>(1), numComp); for(size_t i = numComp; i < numElements; i++) { DREAM3D_REQUIRE_EQUAL(static_cast<T>(1), ptr[i]); } // Initialize the entire array with a value (offset = 0); array->initializeWithValue(static_cast<T>(2), 0); for(size_t i = 0; i < numElements; i++) { DREAM3D_REQUIRE_EQUAL(static_cast<T>(2), ptr[i]); } // Initialize the entire array with a value (offset = 0), this time using the default value for the offset array->initializeWithValue(static_cast<T>(3)); ptr = array->getPointer(0); for(size_t i = 0; i < numElements; i++) { DREAM3D_REQUIRE_EQUAL(static_cast<T>(3), ptr[i]); array->setValue(i, static_cast<T>(4)); T val = array->getValue(i); DREAM3D_REQUIRE_EQUAL(val, static_cast<T>(4)) } // Test setting of a Tuple with a value, which means all components of that tuple will have the same value size_t index = 0; array->initializeWithZeros(); for(size_t t = 0; t < numTuples; t++) { array->initializeTuple(t, 6.0); for(int j = 0; j < numComp; j++) { T val = array->getComponent(t, j); DREAM3D_REQUIRE_EQUAL(val, (static_cast<T>(6)) ) } } // Test setting individual components to a specific value index = 0; array->initializeWithZeros(); for(size_t t = 0; t < numTuples; t++) { for(int j = 0; j < numComp; j++) { index = t * numComp + j; array->setComponent(t, j, static_cast<T>(t + j) ); T val = array->getComponent(t, j); DREAM3D_REQUIRE_EQUAL(val, (static_cast<T>(t + j))) val = array->getValue(index); DREAM3D_REQUIRE_EQUAL(val, (static_cast<T>(t + j))) } } /// virtual QVector<size_t> getComponentDimensions() // Test resizing the array based on a give number of tuples. The number of Components will stay the same at each tuple array->resize(numTuples * 2); array->initializeWithZeros(); // Init the grown array to all Zeros nt = array->getNumberOfTuples(); DREAM3D_REQUIRED(nt, ==, (numTuples * 2) ); nc = array->getNumberOfComponents(); DREAM3D_REQUIRED(nc, ==, numComp ); // Test resizing the array to a smaller size array->resize(numTuples); array->initializeWithZeros(); // Init the grown array to all Zeros nt = array->getNumberOfTuples(); DREAM3D_REQUIRED(nt, ==, (numTuples) ); nc = array->getNumberOfComponents(); DREAM3D_REQUIRED(nc, ==, numComp ); ////clear() // This resizes the array to Zero destroying all the data in the process. array->clear(); DREAM3D_REQUIRED(false, ==, array->isAllocated() ); nt = array->getNumberOfTuples(); DREAM3D_REQUIRED(nt, ==, 0); nc = array->getNumberOfComponents(); DREAM3D_REQUIRED(nc, ==, numComp); nt = array->getSize(); DREAM3D_REQUIRED(nt, ==, 0); ptr = array->getPointer(0); DREAM3D_REQUIRED_PTR(ptr, ==, NULL); // Test resizing the array to a any larger size array->resize(numTuples); array->initializeWithZeros(); // Init the grown array to all Zeros nt = array->getNumberOfTuples(); DREAM3D_REQUIRED(nt, ==, (numTuples) ); nc = array->getNumberOfComponents(); DREAM3D_REQUIRED(nc, ==, numComp ); ptr = array->getPointer(0); DREAM3D_REQUIRED_PTR(ptr, !=, NULL); return err; }