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