// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MoveData::dataCheck()
{
setErrorCondition(0);
DataArrayPath amSrcPath = getAttributeMatrixSource();
DataArrayPath amDestPath = getAttributeMatrixDestination();
DataArrayPath daSrcPath = getDataArraySource();
if (getWhatToMove() == k_MoveAttributeMatrix)
{
DataContainer::Pointer amDestDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerDestination());
DataContainer::Pointer amSrcDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, amSrcPath.getDataContainerName());
AttributeMatrix::Pointer amSrcAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, amSrcPath, -301);
if(getErrorCondition() < 0) { return; }
if (amSrcDataContainer->getName() == amDestDataContainer->getName())
{
QString ss = QObject::tr("The source and destination Data Container are the same. Is this what you meant to do?");
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
amDestDataContainer->addAttributeMatrix(amSrcAttributeMatrix->getName(), amSrcAttributeMatrix);
amSrcDataContainer->removeAttributeMatrix(amSrcAttributeMatrix->getName());
}
else if (getWhatToMove() == k_MoveDataArray )
{
AttributeMatrix::Pointer daSrcAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, daSrcPath, -301);
AttributeMatrix::Pointer daDestAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, amDestPath, -301);
IDataArray::Pointer daSrcDataArray = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, daSrcPath);
if(getErrorCondition() < 0) { return; }
if (daDestAttributeMatrix->getNumTuples() != daSrcDataArray->getNumberOfTuples())
{
setErrorCondition(-11019);
QString ss = QObject::tr("The number of tuples of source Attribute Array (%1) and destination Attribute Matrix (%2) do not match").arg(daSrcDataArray->getNumberOfTuples()).arg(daDestAttributeMatrix->getNumTuples());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
else if (amSrcPath == amDestPath)
{
QString ss = QObject::tr("The source and destination Attribute Matrix are the same. Is this what you meant to do?");
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
daDestAttributeMatrix->addAttributeArray(daSrcPath.getDataArrayName(), daSrcDataArray);
daSrcAttributeMatrix->removeAttributeArray(daSrcPath.getDataArrayName());
}
else
{
setErrorCondition(-11020);
QString ss = QObject::tr("Neither an Attribute Matrix nor an Attribute Array was selected to be moved");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
DataContainer::Pointer DataContainer::deepCopy()
{
DataContainer::Pointer dcCopy = DataContainer::New(getName());
dcCopy->setName(getName());
if (m_Geometry.get() != NULL)
{
IGeometry::Pointer geomCopy = m_Geometry->deepCopy();
dcCopy->setGeometry(geomCopy);
}
for (AttributeMatrixMap_t::iterator iter = getAttributeMatrices().begin(); iter != getAttributeMatrices().end(); ++iter)
{
AttributeMatrix::Pointer attrMat = (*iter)->deepCopy();
dcCopy->addAttributeMatrix(attrMat->getName(), attrMat);
}
return dcCopy;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChangeResolution::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m;
if(m_SaveAsNewDataContainer == false)
{
m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
}
else
{
m = getDataContainerArray()->getDataContainer(getNewDataContainerName());
}
if(m->getGeometryAs<ImageGeom>()->getXRes() == m_Resolution.x
&& m->getGeometryAs<ImageGeom>()->getYRes() == m_Resolution.y
&& m->getGeometryAs<ImageGeom>()->getZRes() == m_Resolution.z)
{
return;
}
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
float sizex = (dims[0]) * m->getGeometryAs<ImageGeom>()->getXRes();
float sizey = (dims[1]) * m->getGeometryAs<ImageGeom>()->getYRes();
float sizez = (dims[2]) * m->getGeometryAs<ImageGeom>()->getZRes();
size_t m_XP = size_t(sizex / m_Resolution.x);
size_t m_YP = size_t(sizey / m_Resolution.y);
size_t m_ZP = size_t(sizez / m_Resolution.z);
if (m_XP == 0) { m_XP = 1; }
if (m_YP == 0) { m_YP = 1; }
if (m_ZP == 0) { m_ZP = 1; }
size_t totalPoints = m_XP * m_YP * m_ZP;
float x = 0.0f, y = 0.0f, z = 0.0f;
size_t col = 0, row = 0, plane = 0;
size_t index;
size_t index_old;
std::vector<size_t> newindicies(totalPoints);
for (size_t i = 0; i < m_ZP; i++)
{
QString ss = QObject::tr("Changing Resolution - %1 Percent Complete").arg(((float)i / m->getGeometryAs<ImageGeom>()->getZPoints()) * 100);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
for (size_t j = 0; j < m_YP; j++)
{
for (size_t k = 0; k < m_XP; k++)
{
x = (k * m_Resolution.x);
y = (j * m_Resolution.y);
z = (i * m_Resolution.z);
col = size_t(x / m->getGeometryAs<ImageGeom>()->getXRes());
row = size_t(y / m->getGeometryAs<ImageGeom>()->getYRes());
plane = size_t(z / m->getGeometryAs<ImageGeom>()->getZRes());
index_old = (plane * m->getGeometryAs<ImageGeom>()->getXPoints() * m->getGeometryAs<ImageGeom>()->getYPoints()) + (row * m->getGeometryAs<ImageGeom>()->getXPoints()) + col;
index = (i * m_XP * m_YP) + (j * m_XP) + k;
newindicies[index] = index_old;
}
}
}
QVector<size_t> tDims(3, 0);
tDims[0] = m_XP;
tDims[1] = m_YP;
tDims[2] = m_ZP;
AttributeMatrix::Pointer newCellAttrMat = AttributeMatrix::New(tDims, cellAttrMat->getName(), cellAttrMat->getType());
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
// Make a copy of the 'p' array that has the same name. When placed into
// the data container this will over write the current array with
// the same name. At least in theory.
IDataArray::Pointer data = p->createNewArray(p->getNumberOfTuples(), p->getComponentDimensions(), p->getName());
data->resize(totalPoints);
void* source = NULL;
void* destination = NULL;
size_t newIndicies_I = 0;
int nComp = data->getNumberOfComponents();
for (size_t i = 0; i < static_cast<size_t>(totalPoints); i++)
{
newIndicies_I = newindicies[i];
source = p->getVoidPointer((nComp * newIndicies_I));
destination = data->getVoidPointer((data->getNumberOfComponents() * i));
::memcpy(destination, source, p->getTypeSize() * data->getNumberOfComponents());
}
cellAttrMat->removeAttributeArray(*iter);
newCellAttrMat->addAttributeArray(*iter, data);
}
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->getGeometryAs<ImageGeom>()->setDimensions(m_XP, m_YP, m_ZP);
m->removeAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
m->addAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName(), newCellAttrMat);
// Feature Ids MUST already be renumbered.
if (m_RenumberFeatures == true)
{
totalPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements();
AttributeMatrix::Pointer cellFeatureAttrMat = m->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
size_t totalFeatures = cellFeatureAttrMat->getNumTuples();
QVector<bool> activeObjects(totalFeatures, false);
if (0 == totalFeatures)
{
notifyErrorMessage(getHumanLabel(), "The number of Features is 0 and should be greater than 0", -600);
return;
}
updateCellInstancePointers();
// Find the unique set of feature ids
for (size_t i = 0; i < totalPoints; ++i)
{
activeObjects[m_FeatureIds[i]] = true;
}
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WarpRegularGrid::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m;
if (m_SaveAsNewDataContainer == false) { m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName()); }
else { m = getDataContainerArray()->getDataContainer(getNewDataContainerName()); }
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
AttributeMatrix::Pointer newCellAttrMat = cellAttrMat->deepCopy();
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
float res[3] = { 0.0f, 0.0f, 0.0f };
m->getGeometryAs<ImageGeom>()->getResolution(res);
size_t totalPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements();
float x = 0.0f, y = 0.0f, z = 0.0f;
float newX = 0.0f, newY = 0.0f;
int col = 0.0f, row = 0.0f, plane = 0.0f;
size_t index;
size_t index_old;
std::vector<size_t> newindicies(totalPoints);
std::vector<bool> goodPoint(totalPoints, true);
for (size_t i = 0; i < dims[2]; i++)
{
QString ss = QObject::tr("Warping Data - %1 Percent Complete").arg(((float)i / dims[2]) * 100);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
for (size_t j = 0; j < dims[1]; j++)
{
for (size_t k = 0; k < dims[0]; k++)
{
x = static_cast<float>((k * res[0]));
y = static_cast<float>((j * res[1]));
z = static_cast<float>((i * res[2]));
index = (i * dims[0] * dims[1]) + (j * dims[0]) + k;
determine_warped_coordinates(x, y, newX, newY);
col = newX / res[0];
row = newY / res[1];
plane = i;
index_old = (plane * dims[0] * dims[1]) + (row * dims[0]) + col;
newindicies[index] = index_old;
if (col > 0 && col < dims[0] && row > 0 && row < dims[1]) { goodPoint[index] = true; }
else { goodPoint[index] = false; }
}
}
}
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
// Make a copy of the 'p' array that has the same name. When placed into
// the data container this will over write the current array with
// the same name. At least in theory
IDataArray::Pointer data = p->createNewArray(p->getNumberOfTuples(), p->getComponentDimensions(), p->getName());
data->resize(totalPoints);
void* source = NULL;
void* destination = NULL;
size_t newIndicies_I = 0;
int nComp = data->getNumberOfComponents();
for (size_t i = 0; i < static_cast<size_t>(totalPoints); i++)
{
newIndicies_I = newindicies[i];
if(goodPoint[i] == true)
{
source = p->getVoidPointer((nComp * newIndicies_I));
destination = data->getVoidPointer((data->getNumberOfComponents() * i));
::memcpy(destination, source, p->getTypeSize() * data->getNumberOfComponents());
}
else
{
int var = 0;
data->initializeTuple(i, &var);
}
}
cellAttrMat->removeAttributeArray(*iter);
newCellAttrMat->addAttributeArray(*iter, data);
}
m->removeAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
m->addAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName(), newCellAttrMat);
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CropImageGeometry::execute()
{
setErrorCondition(0);
/* Normally, filters call dataCheck during the execute to reuse code. Unfortunately, this cannot happen for this filter, because calling dataCheck
would destroy an Attribute Matrix that we need during the execute. Do not uncomment the code, and be careful when reusing code from either of
these functions. Make sure you understand how this works before you reuse any code. */
//dataCheck();
//if(getErrorCondition() < 0) { return; }
DataContainer::Pointer srcCellDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName());
AttributeMatrix::Pointer cellAttrMat = srcCellDataContainer->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
DataContainer::Pointer destCellDataContainer = srcCellDataContainer;
if (m_SaveAsNewDataContainer == true)
{
float ox = 0.0f, oy = 0.0f, oz = 0.0f, rx = 0.0f, ry = 0.0f, rz = 0.0f;
srcCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(ox, oy, oz);
srcCellDataContainer->getGeometryAs<ImageGeom>()->getResolution(rx, ry, rz);
destCellDataContainer = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getNewDataContainerName());
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
destCellDataContainer->setGeometry(image);
destCellDataContainer->getGeometryAs<ImageGeom>()->setOrigin(ox, oy, oz);
destCellDataContainer->getGeometryAs<ImageGeom>()->setResolution(rx, ry, rz);
AttributeMatrix::Pointer cellAttrMatCopy = cellAttrMat->deepCopy();
destCellDataContainer->addAttributeMatrix(cellAttrMatCopy->getName(), cellAttrMatCopy);
cellAttrMat = destCellDataContainer->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
}
if(NULL == destCellDataContainer.get() || NULL == cellAttrMat.get() || getErrorCondition() < 0)
{
return;
}
// No matter where the AM is (same DC or new DC), we have the correct DC and AM pointers...now it's time to crop
int64_t totalPoints = cellAttrMat->getNumTuples();
size_t udims[3] =
{ 0, 0, 0 };
srcCellDataContainer->getGeometryAs<ImageGeom>()->getDimensions(udims);
#if (CMP_SIZEOF_SIZE_T == 4)
typedef int32_t DimType;
#else
typedef int64_t DimType;
#endif
DimType dims[3] =
{ static_cast<DimType>(udims[0]), static_cast<DimType>(udims[1]), static_cast<DimType>(udims[2]), };
// Check to see if the dims have actually changed.
if(dims[0] == (m_XMax - m_XMin) && dims[1] == (m_YMax - m_YMin) && dims[2] == (m_ZMax - m_ZMin))
{
return;
}
// Get current origin
float oldOrigin[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(oldOrigin);
// Check to make sure the new dimensions are not "out of bounds" and warn the user if they are
if (dims[0] <= m_XMax)
{
QString ss = QObject::tr("The Max X value (%1) is greater than the Image Geometry X entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_XMax).arg(dims[0]);
setErrorCondition(-950);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if (dims[1] <= m_YMax)
{
QString ss = QObject::tr("The Max Y value (%1) is greater than the Image Geometry Y entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_YMax).arg(dims[1]);
setErrorCondition(-951);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if (dims[2] <= m_ZMax)
{
QString ss = QObject::tr("The Max Z value (%1) is greater than the Image Geometry Z entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_ZMax).arg(dims[2]);
setErrorCondition(-952);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
int64_t XP = ( (m_XMax - m_XMin) + 1 );
int64_t YP = ( (m_YMax - m_YMin) + 1 );
int64_t ZP = ( (m_ZMax - m_ZMin) + 1 );
int64_t col = 0, row = 0, plane = 0;
int64_t colold = 0, rowold = 0, planeold = 0;
int64_t index = 0;
int64_t index_old = 0;
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (int64_t i = 0; i < ZP; i++)
{
QString ss = QObject::tr("Cropping Volume - Slice %1 of %2 Complete").arg(i).arg(ZP);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
planeold = (i + m_ZMin) * (srcCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints() * srcCellDataContainer->getGeometryAs<ImageGeom>()->getYPoints());
plane = (i * XP * YP);
for (int64_t j = 0; j < YP; j++)
{
rowold = (j + m_YMin) * srcCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints();
row = (j * XP);
for (int64_t k = 0; k < XP; k++)
{
colold = (k + m_XMin);
col = k;
index_old = planeold + rowold + colold;
index = plane + row + col;
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
p->copyTuple(index_old, index);
}
}
}
}
destCellDataContainer->getGeometryAs<ImageGeom>()->setDimensions(static_cast<size_t>(XP), static_cast<size_t>(YP), static_cast<size_t>(ZP));
totalPoints = destCellDataContainer->getGeometryAs<ImageGeom>()->getNumberOfElements();
QVector<size_t> tDims(3, 0);
tDims[0] = XP;
tDims[1] = YP;
tDims[2] = ZP;
cellAttrMat->setTupleDimensions(tDims); // THIS WILL CAUSE A RESIZE of all the underlying data arrays.
if (m_RenumberFeatures == true)
{
totalPoints = destCellDataContainer->getGeometryAs<ImageGeom>()->getNumberOfElements();
// This just sanity checks to make sure there were existing features before the cropping
AttributeMatrix::Pointer cellFeatureAttrMat = srcCellDataContainer->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
size_t totalFeatures = cellFeatureAttrMat->getNumTuples();
QVector<bool> activeObjects(totalFeatures, false);
if (0 == totalFeatures)
{
setErrorCondition(-600);
notifyErrorMessage(getHumanLabel(), "The number of Features is 0 and should be greater than 0", getErrorCondition());
return;
}
//QVector<size_t> cDims(1, 1);
DataArrayPath dap = getFeatureIdsArrayPath();
if(getSaveAsNewDataContainer())
{
dap.setDataContainerName(getNewDataContainerName());
}
m_FeatureIdsPtr = cellAttrMat->getAttributeArrayAs<Int32ArrayType>(dap.getDataArrayName()); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
else
{
setErrorCondition(-601);
QString ss = QObject::tr("The FeatureIds array with name '%1' was not found in the destination DataContainer. The expected path was '%2'")
.arg(dap.getDataArrayName()).arg(dap.serialize("/"));
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
// Find the unique set of feature ids
for (int64_t i = 0; i < totalPoints; ++i)
{
int32_t currentFeatureId = m_FeatureIds[i];
if (currentFeatureId < totalFeatures)
{
activeObjects[currentFeatureId] = true;
}
else
{
setErrorCondition(-601);
QString ss = QObject::tr("The total number of Features from %1 is %2, but a value of %3 was found in DataArray %4.").arg(cellFeatureAttrMat->getName()).arg(totalFeatures).arg(currentFeatureId).arg(getFeatureIdsArrayPath().serialize("/"));
qDebug() << ss;
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
}
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
if(m_UpdateOrigin == true)
{
float resolution[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getResolution(resolution);
float origin[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(origin);
origin[0] = m_XMin * resolution[0] + oldOrigin[0];
origin[1] = m_YMin * resolution[1] + oldOrigin[1];
origin[2] = m_ZMin * resolution[2] + oldOrigin[2];
destCellDataContainer->getGeometryAs<ImageGeom>()->setOrigin(origin);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CropImageGeometry::dataCheck()
{
if(getErrorCondition() < 0) { return; }
setErrorCondition(0);
// Validate the incoming DataContainer, Geometry, and AttributeMatrix ; bail if any do not exist since we plan on using them later on in the dataCheck
// Error messages are handled by the getPrereq functions
DataContainer::Pointer srcCellDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName());
ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName());
AttributeMatrix::Pointer srcCellAttrMat = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, getCellAttributeMatrixPath(), -301);
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer destCellDataContainer = srcCellDataContainer;
AttributeMatrix::Pointer destCellAttrMat;
if (m_SaveAsNewDataContainer == true)
{
float ox = 0.0f, oy = 0.0f, oz = 0.0f, rx = 0.0f, ry = 0.0f, rz = 0.0f;
size_t dx = 0, dy = 0, dz = 0;
image->getOrigin(ox, oy, oz);
image->getResolution(rx, ry, rz);
image->getDimensions(dx, dy, dz);
destCellDataContainer = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getNewDataContainerName());
if(NULL == destCellDataContainer.get() || getErrorCondition() < 0)
{
return;
}
IGeometry::Pointer imageCopy = image->deepCopy();
destCellDataContainer->setGeometry(imageCopy);
destCellAttrMat = srcCellAttrMat->deepCopy();
destCellDataContainer->addAttributeMatrix(destCellAttrMat->getName(), destCellAttrMat);
}
else
{
destCellAttrMat = srcCellAttrMat;
}
if(NULL == destCellDataContainer.get() || NULL == destCellAttrMat.get() || getErrorCondition() < 0)
{
return;
}
if (getXMax() < getXMin())
{
QString ss = QObject::tr("X Max (%1) less than X Min (%2)").arg(getXMax()).arg(getXMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getYMax() < getYMin())
{
QString ss = QObject::tr("Y Max (%1) less than Y Min (%2)").arg(getYMax()).arg(getYMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getZMax() < getZMin())
{
QString ss = QObject::tr("Z Max (%1) less than Z Min (%2)").arg(getZMax()).arg(getZMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getXMin() < 0)
{
QString ss = QObject::tr("X Min (%1) less than 0").arg(getXMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getYMin() < 0)
{
QString ss = QObject::tr("Y Min (%1) less than 0").arg(getYMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getZMin() < 0)
{
QString ss = QObject::tr("Z Min (%1) less than 0").arg(getZMin());
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getXMax() > (static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints()) - 1))
{
QString ss = QObject::tr("The X Max (%1) is greater than the Image Geometry X extent (%2)").arg(getXMax()).arg(static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints()) - 1);
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getYMax() > (static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getYPoints()) - 1))
{
QString ss = QObject::tr("The Y Max (%1) is greater than the Image Geometry Y extent (%2)").arg(getYMax()).arg(static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getYPoints()) - 1);
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
if (getZMax() > (static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getZPoints()) - 1))
{
QString ss = QObject::tr("The Z Max (%1) is greater than the Image Geometry Z extent (%2)").arg(getZMax()).arg(static_cast<int64_t>(destCellDataContainer->getGeometryAs<ImageGeom>()->getZPoints()) - 1);
notifyErrorMessage(getHumanLabel(), ss, -5550);
setErrorCondition(-5550);
}
QVector<size_t> tDims(3, 0);
if (getXMax() - getXMin() < 0) { setXMax(getXMin() + 1); }
if (getYMax() - getYMin() < 0) { setYMax(getYMin() + 1); }
if (getZMax() - getZMin() < 0) { setZMax(getZMin() + 1); }
tDims[0] = (getXMax() - getXMin()) + 1;
tDims[1] = (getYMax() - getYMin()) + 1;
tDims[2] = (getZMax() - getZMin()) + 1;
destCellDataContainer->getGeometryAs<ImageGeom>()->setDimensions(tDims[0], tDims[1], tDims[2]);
// If any of the sanity checks fail above then we should NOT attempt to go any further.
if (getErrorCondition() < 0) { return; }
size_t totalPoints = 1;
for(int i = 0; i < 3; i++) {
if(tDims[i] != 0) { totalPoints *= tDims[i]; }
}
AttributeMatrix::Pointer newCellAttrMat = AttributeMatrix::New(tDims, destCellAttrMat->getName(), destCellAttrMat->getType());
QList<QString> voxelArrayNames = destCellAttrMat->getAttributeArrayNames();
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = destCellAttrMat->getAttributeArray(*iter);
//
IDataArray::Pointer data = p->createNewArray(totalPoints, p->getComponentDimensions(), p->getName(), false);
destCellAttrMat->removeAttributeArray(*iter);
newCellAttrMat->addAttributeArray(*iter, data);
}
destCellDataContainer->removeAttributeMatrix(destCellAttrMat->getName());
destCellDataContainer->addAttributeMatrix(newCellAttrMat->getName(), newCellAttrMat);
if(m_RenumberFeatures == true)
{
QVector<size_t> cDims(1, 1);
m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{
m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0);
} /* Now assign the raw pointer to data from the DataArray<T> object */
AttributeMatrix::Pointer cellFeatureAttrMat = srcCellDataContainer->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
if(NULL == cellFeatureAttrMat.get()) { return; }
QVector<bool> activeObjects(cellFeatureAttrMat->getNumTuples(), true);
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularizeZSpacing::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) {
return;
}
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
size_t dims[3];
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
std::ifstream inFile;
inFile.open(m_InputFile.toLatin1().data());
float zval = 0.0f;
std::vector<float> zboundvalues(dims[2] + 1, 0.0);
for (size_t iter = 0; iter < dims[2] + 1; iter++)
{
inFile >> zval;
zboundvalues[iter] = zval;
}
inFile.close();
float xRes = m->getGeometryAs<ImageGeom>()->getXRes();
float yRes = m->getGeometryAs<ImageGeom>()->getYRes();
float sizez = zboundvalues[dims[2]];
size_t m_XP = dims[0];
size_t m_YP = dims[1];
size_t m_ZP = static_cast<size_t>(sizez / m_NewZRes);
if (m_ZP == 0) {
m_ZP = 1;
}
size_t totalPoints = m_XP * m_YP * m_ZP;
size_t index = 0, oldindex = 0;
size_t plane = 0;
std::vector<size_t> newindicies(totalPoints, 0);
for (size_t i = 0; i < m_ZP; i++)
{
plane = 0;
for (size_t iter = 1; iter < dims[2]; iter++)
{
if ((i * m_NewZRes) > zboundvalues[iter]) {
plane = iter;
}
}
for (size_t j = 0; j < m_YP; j++)
{
for (size_t k = 0; k < m_XP; k++)
{
oldindex = (plane * dims[0] * dims[1]) + (j * dims[0]) + k;
index = (i * dims[0] * dims[1]) + (j * dims[0]) + k;
newindicies[index] = oldindex;
}
}
}
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
QVector<size_t> tDims(3, 0);
tDims[0] = m_XP;
tDims[1] = m_YP;
tDims[2] = m_ZP;
AttributeMatrix::Pointer newCellAttrMat = AttributeMatrix::New(tDims, cellAttrMat->getName(), cellAttrMat->getType());
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
// Make a copy of the 'p' array that has the same name. When placed into
// the data container this will over write the current array with
// the same name. At least in theory
IDataArray::Pointer data = p->createNewArray(p->getNumberOfTuples(), p->getComponentDimensions(), p->getName());
data->resize(totalPoints);
void* source = NULL;
void* destination = NULL;
size_t newIndicies_I = 0;
int nComp = data->getNumberOfComponents();
for (size_t i = 0; i < static_cast<size_t>(totalPoints); i++)
{
newIndicies_I = newindicies[i];
source = p->getVoidPointer((nComp * newIndicies_I));
destination = data->getVoidPointer((data->getNumberOfComponents() * i));
::memcpy(destination, source, p->getTypeSize() * data->getNumberOfComponents());
}
cellAttrMat->removeAttributeArray(*iter);
newCellAttrMat->addAttributeArray(*iter, data);
}
m->getGeometryAs<ImageGeom>()->setResolution(xRes, yRes, m_NewZRes);
m->getGeometryAs<ImageGeom>()->setDimensions(m_XP, m_YP, m_ZP);
m->removeAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
m->addAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName(), newCellAttrMat);
notifyStatusMessage(getHumanLabel(), "Complete");
}