// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t VtkStructuredPointsReader:: readFile()
{
int32_t err = 0;
DataContainer::Pointer volDc = getDataContainerArray()->getDataContainer(getVolumeDataContainerName());
AttributeMatrix::Pointer volAm = volDc->getAttributeMatrix(getCellAttributeMatrixName());
DataContainer::Pointer vertDc = getDataContainerArray()->getDataContainer(getVertexDataContainerName());
AttributeMatrix::Pointer vertAm = vertDc->getAttributeMatrix(getVertexAttributeMatrixName());
std::ifstream in(getInputFile().toLatin1().constData(), std::ios_base::in | std::ios_base::binary);
if (!in.is_open())
{
QString msg = QObject::tr("Error opening output file '%1'").arg(getInputFile());
setErrorCondition(-61003);
notifyErrorMessage(getHumanLabel(), msg, getErrorCondition());
return -100;
}
QByteArray buf(kBufferSize, '\0');
char* buffer = buf.data();
err = readLine(in, buffer, kBufferSize); // Read Line 1 - VTK Version Info
err = readLine(in, buffer, kBufferSize); // Read Line 2 - User Comment
setComment(QString(buf));
err = readLine(in, buffer, kBufferSize); // Read Line 3 - BINARY or ASCII
QString fileType(buf);
if (fileType.startsWith("BINARY") == true)
{
setFileIsBinary(true);
}
else if (fileType.startsWith("ASCII") == true)
{
setFileIsBinary(false);
}
else
{
QString ss = QObject::tr("The file type of the VTK legacy file could not be determined. It should be 'ASCII' or 'BINARY' and should appear on line 3 of the file");
setErrorCondition(-61004);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
// Read Line 4 - Type of Dataset
err = readLine(in, buffer, kBufferSize);
QList<QByteArray> words = buf.split(' ');
if (words.size() != 2)
{
QString ss = QObject::tr("Error reading the type of data set. Was expecting 2 words but got %1").arg(QString(buf));
setErrorCondition(-61005);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
QString dataset(words.at(1));
dataset = dataset.trimmed();
setDatasetType(dataset); // Should be STRUCTURED_POINTS
bool ok = false;
err = readLine(in, buffer, kBufferSize); // Read Line 5 which is the Dimension values
// But we need the 'extents' which is one less in all directions (unless dim=1)
QVector<size_t> dims(3, 0);
QList<QByteArray> tokens = buf.split(' ');
dims[0] = tokens[1].toInt(&ok, 10);
dims[1] = tokens[2].toInt(&ok, 10);
dims[2] = tokens[3].toInt(&ok, 10);
QVector<size_t> tDims(3, 0);
tDims[0] = dims[0];
tDims[1] = dims[1];
tDims[2] = dims[2];
vertAm->setTupleDimensions(tDims);
vertDc->getGeometryAs<ImageGeom>()->setDimensions(dims.data());
tDims[0] = dims[0] - 1;
tDims[1] = dims[1] - 1;
tDims[2] = dims[2] - 1;
volAm->setTupleDimensions(tDims);
volDc->getGeometryAs<ImageGeom>()->setDimensions(tDims.data());
err = readLine(in, buffer, kBufferSize); // Read Line 7 which is the Scaling values
tokens = buf.split(' ');
float resolution[3];
resolution[0] = tokens[1].toFloat(&ok);
resolution[1] = tokens[2].toFloat(&ok);
resolution[2] = tokens[3].toFloat(&ok);
volDc->getGeometryAs<ImageGeom>()->setResolution(resolution);
vertDc->getGeometryAs<ImageGeom>()->setResolution(resolution);
err = readLine(in, buffer, kBufferSize); // Read Line 6 which is the Origin values
tokens = buf.split(' ');
float origin[3];
origin[0] = tokens[1].toFloat(&ok);
origin[1] = tokens[2].toFloat(&ok);
origin[2] = tokens[3].toFloat(&ok);
volDc->getGeometryAs<ImageGeom>()->setOrigin(origin);
vertDc->getGeometryAs<ImageGeom>()->setOrigin(origin);
// Read the first key word which should be POINT_DATA or CELL_DATA
err = readLine(in, buffer, kBufferSize); // Read Line 6 which is the first type of data we are going to read
tokens = buf.split(' ');
QString word = QString(tokens[0]);
int32_t npts = 0, ncells = 0;
int32_t numPts = 0;
if ( word.startsWith("CELL_DATA") )
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getVolumeDataContainerName());
m_CurrentAttrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
ncells = tokens[1].toInt(&ok);
if (m_CurrentAttrMat->getNumTuples() != ncells)
{
setErrorCondition(-61006);
notifyErrorMessage(getHumanLabel(), QString("Number of cells does not match number of tuples in the Attribute Matrix"), getErrorCondition());
return getErrorCondition();
}
this->readDataTypeSection(in, ncells, "point_data");
}
else if ( word.startsWith("POINT_DATA") )
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getVertexDataContainerName());
m_CurrentAttrMat = m->getAttributeMatrix(getVertexAttributeMatrixName());
npts = tokens[1].toInt(&ok);
if (m_CurrentAttrMat->getNumTuples() != npts)
{
setErrorCondition(-61007);
notifyErrorMessage(getHumanLabel(), QString("Number of points does not match number of tuples in the Attribute Matrix"), getErrorCondition());
return getErrorCondition();
}
this->readDataTypeSection(in, numPts, "cell_data");
}
// Close the file since we are done with it.
in.close();
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t FeatureInfoReader::readFile()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return getErrorCondition(); }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_FeatureIdsArrayPath.getDataContainerName());
AttributeMatrix::Pointer cellFeatureAttrMat = m->getAttributeMatrix(getCellFeatureAttributeMatrixName());
std::ifstream inFile;
inFile.open(getInputFile().toLatin1().data(), std::ios_base::binary);
if (!inFile)
{
QString ss = QObject::tr("Error opening input file: %1").arg(getInputFile());
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
int32_t numfeatures = 0;
int32_t gnum = 0, phase = 0;
int32_t maxphase = 0;
float ea1 = 0.0f, ea2 = 0.0f, ea3 = 0.0f;
inFile >> numfeatures;
if (0 == numfeatures)
{
QString ss = QObject::tr("The number of Features (%1) specified in the file must be greater than zero").arg(numfeatures);
setErrorCondition(-600);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
int32_t maxFeatureId = 0;
for (size_t i = 0; i < totalPoints; i++)
{
if (m_FeatureIds[i] > maxFeatureId)
{
maxFeatureId = m_FeatureIds[i];
}
}
if (numfeatures != maxFeatureId)
{
QString ss = QObject::tr("The number of Features (%1) specified in the file does not correspond to the maximum Feature Id (%2) in the selected Feature Ids array").arg(numfeatures).arg(maxFeatureId);
setErrorCondition(-600);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
QVector<size_t> tDims(1, numfeatures + 1);
cellFeatureAttrMat->setTupleDimensions(tDims);
updateFeatureInstancePointers();
for (int32_t i = 0; i < numfeatures; i++)
{
inFile >> gnum >> phase >> ea1 >> ea2 >> ea3;
if (gnum > maxFeatureId)
{
QString ss = QObject::tr("A Feature Id (%1) specified in the file is larger than the maximum Feature Id (%2) in the selected Feature Ids array").arg(numfeatures).arg(maxFeatureId);
setErrorCondition(-600);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return getErrorCondition();
}
m_FeatureEulerAngles[3 * gnum] = ea1;
m_FeatureEulerAngles[3 * gnum + 1] = ea2;
m_FeatureEulerAngles[3 * gnum + 2] = ea3;
m_FeaturePhases[gnum] = phase;
if (phase > maxphase) { maxphase = phase; }
}
if (m_CreateCellLevelArrays == true)
{
for (size_t i = 0; i < totalPoints; i++)
{
gnum = m_FeatureIds[i];
m_CellEulerAngles[3 * i] = m_FeatureEulerAngles[3 * gnum];
m_CellEulerAngles[3 * i + 1] = m_FeatureEulerAngles[3 * gnum + 1];
m_CellEulerAngles[3 * i + 2] = m_FeatureEulerAngles[3 * gnum + 2];
m_CellPhases[i] = m_FeaturePhases[gnum];
}
}
if (m_RenumberFeatures == true)
{
size_t totalFeatures = cellFeatureAttrMat->getNumTuples();
// Find the unique set of feature ids
QVector<bool> activeObjects(totalFeatures, false);
for (size_t i = 0; i < totalPoints; ++i)
{
activeObjects[m_FeatureIds[i]] = true;
}
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
notifyStatusMessage(getHumanLabel(), "Complete");
return 0;
}