// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AvizoUniformCoordinateWriter::dataCheck()
{
setErrorCondition(0);
DataContainer::Pointer dc = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getFeatureIdsArrayPath().getDataContainerName(), false);
if (getErrorCondition() < 0 || NULL == dc.get()) {
return;
}
ImageGeom::Pointer image = dc->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if (getErrorCondition() < 0 || NULL == image.get()) {
return;
}
if(m_OutputFile.isEmpty() == true)
{
QString ss = QObject::tr("The output file must be set before executing this filter.");
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if(m_WriteFeatureIds == true)
{
QVector<size_t> dims(1, 1);
m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), dims); /* 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 */
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindMaxima::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
//check for required arrays
QVector<size_t> compDims(1, 1);
m_SelectedCellArrayPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getSelectedCellArrayPath(), compDims);
if(NULL != m_SelectedCellArrayPtr.lock().get())
{
m_SelectedCellArray = m_SelectedCellArrayPtr.lock().get();
}
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) { return; }
//configured created name / location
tempPath.update(getSelectedCellArrayPath().getDataContainerName(), getSelectedCellArrayPath().getAttributeMatrixName(), getNewCellArrayName() );
DataContainer::Pointer dataContiner = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getSelectedCellArrayPath().getDataContainerName() );
AttributeMatrix::Pointer attrMatrix = dataContiner->getPrereqAttributeMatrix<AbstractFilter>(this, getSelectedCellArrayPath().getAttributeMatrixName(), 80000);
IDataArray::Pointer redArrayptr = attrMatrix->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getSelectedCellArrayPath().getDataArrayName(), 80000);
//create new boolean array
tempPath.update(getSelectedCellArrayPath().getDataContainerName(), getSelectedCellArrayPath().getAttributeMatrixName(), getNewCellArrayName() );
m_NewCellArrayPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, 0, compDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_NewCellArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_NewCellArray = m_NewCellArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
FloatVec3_t CropImageGeometry::getCurrentVolumeDataContainerResolutions()
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
FloatVec3_t data;
if (NULL != m)
{
ImageGeom::Pointer image = m->getGeometryAs<ImageGeom>();
if (image.get() != NULL)
{
data.x = image->getXRes();
data.y = image->getYRes();
data.z = image->getZRes();
}
else
{
data.x = 0;
data.y = 0;
data.z = 0;
}
}
else
{
data.x = 0;
data.y = 0;
data.z = 0;
}
return data;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GrayToRGB::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
//check for required arrays
QVector<size_t> compDims(1, 1);
m_RedPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getRedArrayPath(), compDims);
if(NULL != m_RedPtr.lock().get())
{
m_Red = m_RedPtr.lock().get();
}
m_GreenPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getGreenArrayPath(), compDims);
if(NULL != m_GreenPtr.lock().get())
{
m_Green = m_GreenPtr.lock().get();
}
m_BluePtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getBlueArrayPath(), compDims);
if(NULL != m_BluePtr.lock().get())
{
m_Blue = m_BluePtr.lock().get();
}
//configured created name / location
tempPath.update(getRedArrayPath().getDataContainerName(), getRedArrayPath().getAttributeMatrixName(), getNewCellArrayName() );
DataContainer::Pointer redDC = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getRedArrayPath().getDataContainerName() );
if(getErrorCondition() < 0) {
return;
}
AttributeMatrix::Pointer redAM = redDC->getPrereqAttributeMatrix<AbstractFilter>(this, getRedArrayPath().getAttributeMatrixName(), 80000);
if(getErrorCondition() < 0) {
return;
}
IDataArray::Pointer redArrayptr = redAM->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getRedArrayPath().getDataArrayName(), 80000);
if(getErrorCondition() < 0) {
return;
}
ImageGeom::Pointer image = redDC->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) {
return;
}
//create new array of same type
compDims[0] = 3;
m_NewCellArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, compDims, redArrayptr);
if( NULL != m_NewCellArrayPtr.lock().get() )
{
m_NewCellArray = m_NewCellArrayPtr.lock()->getVoidPointer(0);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindEllipsoidError::dataCheck()
{
DataArrayPath tempPath;
setErrorCondition(0);
QVector<size_t> dims(1, 1);
m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), dims); /* 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 */
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = getDataContainerArray()->getDataContainer(getFeatureIdsArrayPath().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) { return; }
dims[0] = 3;
m_CentroidsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getCentroidsArrayPath(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CentroidsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Centroids = m_CentroidsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 3;
m_AxisEulerAnglesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getAxisEulerAnglesArrayPath(), dims);
if( NULL != m_AxisEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AxisEulerAngles = m_AxisEulerAnglesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 3;
m_AxisLengthsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getAxisLengthsArrayPath(), dims);
if( NULL != m_AxisLengthsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AxisLengths = m_AxisLengthsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
m_NumCellsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getNumCellsArrayPath(), dims);
if( NULL != m_NumCellsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_NumCells = m_NumCellsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if (m_WriteIdealEllipseFeatureIds == true)
{
dims[0] = 1;
tempPath.update(m_FeatureIdsArrayPath.getDataContainerName(), m_FeatureIdsArrayPath.getAttributeMatrixName(), getIdealFeatureIdsArrayName() );
m_IdealFeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_IdealFeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_IdealFeatureIds = m_IdealFeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
dims[0] = 1;
tempPath.update(m_NumCellsArrayPath.getDataContainerName(), m_NumCellsArrayPath.getAttributeMatrixName(), getEllipsoidErrorArrayName() );
m_EllipsoidErrorPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_EllipsoidErrorPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_EllipsoidError = m_EllipsoidErrorPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RGBToGray::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath = getSelectedCellArrayArrayPath();
//check for required arrays
QVector<size_t> compDims(1, 3);
m_SelectedCellArrayPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, tempPath, compDims);
if(NULL != m_SelectedCellArrayPtr.lock().get())
{
m_SelectedCellArray = m_SelectedCellArrayPtr.lock().get();
}
else // Something went wrong because that should have worked. Bail out now.
{
return;
}
#if 0
//get type
QString typeName = getDataContainerArray()->getDataContainer(getSelectedCellArrayArrayPath().getDataContainerName())->getAttributeMatrix(getSelectedCellArrayArrayPath().getAttributeMatrixName())->getAttributeArray(getSelectedCellArrayArrayPath().getDataArrayName())->getTypeAsString();;
int type = TemplateUtilities::getTypeFromTypeName(typeName);
//create new array of same type
dims[0] = 1;
TEMPLATE_CREATE_NONPREREQ_ARRAY(NewCellArray, tempPath, dims, type);
#endif
DataContainer::Pointer dc = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getSelectedCellArrayArrayPath().getDataContainerName() );
if(getErrorCondition() < 0) { return; }
AttributeMatrix::Pointer am = dc->getPrereqAttributeMatrix<AbstractFilter>(this, getSelectedCellArrayArrayPath().getAttributeMatrixName(), 80000);
if(getErrorCondition() < 0) { return; }
IDataArray::Pointer data = am->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getSelectedCellArrayArrayPath().getDataArrayName(), 80000);
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = dc->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) { return; }
compDims[0] = 1;
//configured created name / location
tempPath.setDataArrayName(getNewCellArrayName());
m_NewCellArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, compDims, data);
if( NULL != m_NewCellArrayPtr.lock().get() )
{
m_NewCellArray = m_NewCellArrayPtr.lock()->getVoidPointer(0);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RequiredZThickness::dataCheck()
{
setErrorCondition(0);
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer dataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerSelection());
if (getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = dataContainer->getGeometryAs<ImageGeom>();
if( NULL == image.get() )
{
setErrorCondition(-7789);
notifyErrorMessage(getHumanLabel(), "Missing Image Geometry in the selected DataContainer", getErrorCondition());
return;
}
size_t dims[3] = { 0, 0, 0 };
image->getDimensions(dims);
if (dims[2] < getNumZVoxels() && m_PreflightCheck)
{
setErrorCondition(-7787);
QString str;
QTextStream ss(&str);
ss << "Number of Z Voxels does not meet required value during preflight of the filter. \n";
ss << " Required Z Voxels: " << m_NumZVoxels << "\n";
ss << " Current Z Voxels: " << dims[2];
notifyErrorMessage(getHumanLabel(), str, getErrorCondition());
}
else if (dims[2] < getNumZVoxels() && !m_PreflightCheck)
{
QString str;
QTextStream ss(&str);
ss << "Number of Z Voxels does not meet required value during preflight but will be checked during pipeline execution.\n";
ss << " Required Z Voxels: " << m_NumZVoxels << "\n";
ss << " Current Z Voxels: " << dims[2];
notifyWarningMessage(getHumanLabel(), str, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Watershed::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
QVector<size_t> dims(1, 1);
m_SelectedCellArrayPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<ImageProcessing::DefaultPixelType>, AbstractFilter>(this, getSelectedCellArrayPath(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SelectedCellArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SelectedCellArray = m_SelectedCellArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) { return; }
tempPath.update(getSelectedCellArrayPath().getDataContainerName(), getSelectedCellArrayPath().getAttributeMatrixName(), getFeatureIdsArrayName() );
m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, dims); /* 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 */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SineParamsSegmentFeatures::dataCheck()
{
DataArrayPath tempPath;
setErrorCondition(0);
//Set the DataContainerName for the Parent Class (SegmentFeatures) to Use
setDataContainerName(m_SineParamsArrayPath.getDataContainerName());
SegmentFeatures::dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerName(), false);
if(getErrorCondition() < 0 || NULL == m) { return; }
QVector<size_t> tDims(1, 0);
AttributeMatrix::Pointer cellFeatureAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellFeatureAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellFeature);
if(getErrorCondition() < 0 || NULL == cellFeatureAttrMat.get()) { return; }
ImageGeom::Pointer image = m->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0 || NULL == image.get()) { return; }
QVector<size_t> dims(1, 3);
m_SineParamsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getSineParamsArrayPath(), dims);
if( NULL != m_SineParamsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SineParams = m_SineParamsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
tempPath.update(getDataContainerName(), m_SineParamsArrayPath.getAttributeMatrixName(), getFeatureIdsArrayName() );
m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, dims); /* 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 */
if(m_UseGoodVoxels == true)
{
m_GoodVoxelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<bool>, AbstractFilter>(this, getGoodVoxelsArrayPath(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_GoodVoxelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_GoodVoxels = m_GoodVoxelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getActiveArrayName() );
m_ActivePtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, true, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_ActivePtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Active = m_ActivePtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int VTKFileReader::readHeader()
{
int err = 0;
if (getInputFile().isEmpty() == true)
{
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), "FileName was not set and must be valid", -1);
return -1;
}
if (NULL == getDataContainerArray()->getDataContainer(getDataContainerName()).get())
{
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), "DataContainer Pointer was NULL and must be valid", -1);
return -1;
}
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("VTF file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), msg, getErrorCondition());
return -100;
}
QByteArray buf;
buf = in.readLine(); // Read Line 1 - VTK Version Info
buf = in.readLine(); // Read Line 2 - User Comment
setComment(QString(buf.trimmed()));
buf = in.readLine(); // 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
{
err = -1;
qDebug()
<< "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."
;
return err;
}
QList<QByteArray> tokens;
buf = in.readLine(); // Read Line 4 - Type of Dataset
{
tokens = buf.split(' ');
setDatasetType(QString(tokens[1]));
}
buf = in.readLine(); // Read Line 5 which is the Dimension values
bool ok = false;
int64_t dims[3];
tokens = buf.split(' ');
dims[0] = tokens[1].toLongLong(&ok, 10);
dims[1] = tokens[2].toLongLong(&ok, 10);
dims[2] = tokens[3].toLongLong(&ok, 10);
#if (CMP_SIZEOF_SSIZE_T==4)
int64_t max = std::numeric_limits<size_t>::max();
#else
int64_t max = std::numeric_limits<int64_t>::max();
#endif
if (dims[0] * dims[1] * dims[2] > max )
{
err = -1;
QString ss = QObject::tr("The total number of elements '%1' is greater than this program can hold. Try the 64 bit version.").arg(dims[0] * dims[1] * dims[2]);
setErrorCondition(err);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return err;
}
if (dims[0] > max || dims[1] > max || dims[2] > max)
{
err = -1;
QString ss = QObject::tr("One of the dimensions is greater than the max index for this sysem. Try the 64 bit version. dim[0]=%1 dim[1]=%2im[2]=%3")\
.arg(dims[0]).arg(dims[1]).arg(dims[2]);
setErrorCondition(err);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return err;
}
size_t dcDims[3] = { static_cast<size_t>(dims[0]), static_cast<size_t>(dims[1]), static_cast<size_t>(dims[2]) };
DataContainer::Pointer dc = getDataContainerArray()->getDataContainer(getDataContainerName());
if (dc.get() == NULL)
{
return -1;
}
ImageGeom::Pointer image = dc->getGeometryAs<ImageGeom>();
if (image.get() == NULL)
{
return -1;
}
image->setDimensions(dcDims);
buf = in.readLine(); // Read Line 6 which is the Origin values
float origin[3];
tokens = buf.split(' ');
origin[0] = tokens[1].toFloat(&ok);
origin[1] = tokens[2].toFloat(&ok);
origin[2] = tokens[3].toFloat(&ok);
image->setOrigin(origin);
buf = in.readLine(); // Read Line 7 which is the Scaling values
float resolution[3];
tokens = buf.split(' ');
resolution[0] = tokens[1].toFloat(&ok);
resolution[1] = tokens[2].toFloat(&ok);
resolution[2] = tokens[3].toFloat(&ok);
image->setResolution(resolution);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MultiEmmpmFilter::dataCheck()
{
setErrorCondition(0);
if (DataArrayPath::ValidateVector(getInputDataArrayVector()) == false)
{
setErrorCondition(-62000);
QString ss = QObject::tr("All Attribute Arrays must belong to the same Data Container and Attribute Matrix");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
QVector<size_t> cDims(1, 1); // We need a single component, gray scale image
#if 0
m_InputImagePtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter>(this, getInputDataArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if (NULL != m_InputImagePtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{
m_InputImage = m_InputImagePtr.lock()->getPointer(0);
} /* Now assign the raw pointer to data from the DataArray<T> object */
if (getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = getDataContainerArray()->getDataContainer(getInputDataArrayPath().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if (getErrorCondition() < 0 || NULL == image.get()) { return; }
m_OutputImagePtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter, uint8_t>(this, getOutputDataArrayPath(), 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if (NULL != m_OutputImagePtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{
m_OutputImage = m_OutputImagePtr.lock()->getPointer(0);
} /* Now assign the raw pointer to data from the DataArray<T> object */
#endif
if (getOutputArrayPrefix().isEmpty())
{
setErrorCondition(-62002);
QString message = QObject::tr("Using a prefix (even a single alphanumeric value) is required so that the output Xdmf files can be written correctly");
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
}
if (getInputDataArrayVector().isEmpty())
{
setErrorCondition(-62003);
QString message = QObject::tr("At least one Attribute Array must be selected");
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
DataArrayPath inputAMPath = DataArrayPath::GetAttributeMatrixPath(getInputDataArrayVector());
AttributeMatrix::Pointer inAM = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, inputAMPath, -301);
if(getErrorCondition() < 0 || NULL == inAM.get()) { return; }
// Now create our output attributeMatrix which will contain all of our segmented images
QVector<size_t> tDims = inAM->getTupleDimensions();
AttributeMatrix::Pointer outAM = getDataContainerArray()->getDataContainer(inputAMPath.getDataContainerName())->createNonPrereqAttributeMatrix<AbstractFilter>(this, getOutputAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 || NULL == outAM.get()) { return; }
// Get the list of checked array names from the input data arrays list
QList<QString> arrayNames = DataArrayPath::GetDataArrayNames(getInputDataArrayVector());
for (int32_t i = 0; i < arrayNames.size(); i++ )
{
QString daName = arrayNames.at(i);
QString newName = getOutputArrayPrefix() + arrayNames.at(i);
inputAMPath.setDataArrayName(daName);
getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter>(this, inputAMPath, cDims);
if (getErrorCondition() < 0) { return; }
outAM->createAndAddAttributeArray<UInt8ArrayType, AbstractFilter, uint8_t>(this, newName, 0, cDims);
}
// The EM/MPM Library has a hard coded MAX Classes of 16
if (getNumClasses() > 15)
{
setErrorCondition(-62000);
QString ss = QObject::tr("The maximum number of classes is 15");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
// It does not make any sense if we want anything less than 2 classes
if (getNumClasses() < 2)
{
setErrorCondition(-62001);
QString ss = QObject::tr("The minimum number of classes is 2");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeData::dataCheck()
{
setErrorCondition(0);
getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, getCellAttributeMatrixPath(), -301);
ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName());
if(NULL == image.get()) { return; }
if (getXMax() < getXMin())
{
QString ss = QObject::tr("X Max (%1) less than X Min (%2)").arg(getXMax()).arg(getXMin());
setErrorCondition(-5551);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMax() < getYMin())
{
QString ss = QObject::tr("Y Max (%1) less than Y Min (%2)").arg(getYMax()).arg(getYMin());
setErrorCondition(-5552);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMax() < getZMin())
{
QString ss = QObject::tr("Z Max (%1) less than Z Min (%2)").arg(getZMax()).arg(getZMin());
setErrorCondition(-5553);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getXMin() < 0)
{
QString ss = QObject::tr("X Min (%1) less than 0").arg(getXMin());
setErrorCondition(-5554);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMin() < 0)
{
QString ss = QObject::tr("Y Min (%1) less than 0").arg(getYMin());
setErrorCondition(-5555);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMin() < 0)
{
QString ss = QObject::tr("Z Min (%1) less than 0").arg(getZMin());
setErrorCondition(-5556);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getXMax() > (static_cast<int64_t>(image->getXPoints()) - 1))
{
QString ss = QObject::tr("The X Max you entered of %1 is greater than your Max X Point of %2").arg(getXMax()).arg(static_cast<int64_t>(image->getXPoints()) - 1);
setErrorCondition(-5557);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMax() > (static_cast<int64_t>(image->getYPoints()) - 1))
{
QString ss = QObject::tr("The Y Max you entered of %1 is greater than your Max Y Point of %2").arg(getYMax()).arg(static_cast<int64_t>(image->getYPoints()) - 1);
setErrorCondition(-5558);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMax() > (static_cast<int64_t>(image->getZPoints()) - 1))
{
QString ss = QObject::tr("The Z Max you entered of %1) greater than your Max Z Point of %2").arg(getZMax()).arg(static_cast<int64_t>(image->getZPoints()) - 1);
setErrorCondition(-5559);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::dataCheck()
{
setErrorCondition(0);
//check file name exists
if(getInputFileName().isEmpty())
{
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), "The input file name must be set before executing this filter.", getErrorCondition());
return;
}
//read image metadata
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO(getInputFileName().toLocal8Bit().constData(), itk::ImageIOFactory::ReadMode);
if(NULL == imageIO)
{
setErrorCondition(-2);
QString message = QObject::tr("Unable to read image '%1'").arg(getInputFileName());
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
imageIO->SetFileName(getInputFileName().toLocal8Bit().data());
imageIO->ReadImageInformation();
//get size of image
const size_t numDimensions = imageIO->GetNumberOfDimensions();
int xdim = imageIO->GetDimensions(0);
int ydim = imageIO->GetDimensions(1);
int zdim = 1;
if(3 != numDimensions)
{
if(2 == numDimensions)
{
//allow 2 dimensional images (as 3d image with size 1 in the z direction)
}
else
{
QString message = QObject::tr("3 dimensional image required (slected image dimensions: %1)").arg(numDimensions);
setErrorCondition(-3);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
else
{
zdim = imageIO->GetDimensions(2);
}
//determine if container/attribute matrix already exist. if so check size compatibility
DataArrayPath createdPath;
DataContainer::Pointer m;
AttributeMatrix::Pointer cellAttrMat;
createdPath.update(getDataContainerName(), getCellAttributeMatrixName(), getImageDataArrayName() );
m = getDataContainerArray()->getDataContainer(getDataContainerName());
bool createAttributeMatrix = false;
if(NULL == m.get()) //datacontainer doesn't exist->create
{
m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
m->getGeometryAs<ImageGeom>()->setDimensions(xdim, ydim, zdim);
double zRes = 1;
double zOrigin = 0;
if(3 == numDimensions)
{
zRes = imageIO->GetSpacing(2);
zOrigin = imageIO->GetOrigin(2);
}
m->getGeometryAs<ImageGeom>()->setResolution(imageIO->GetSpacing(0), imageIO->GetSpacing(0), zRes);
m->getGeometryAs<ImageGeom>()->setOrigin(imageIO->GetOrigin(0), imageIO->GetOrigin(1), zOrigin);
createAttributeMatrix = true;
if(getErrorCondition() < 0) { return; }
}
else //datacontainer exists, check if attribute matrix exists
{
bool dcExists = m->doesAttributeMatrixExist(getCellAttributeMatrixName());
ImageGeom::Pointer image = m->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0) { return; }
size_t iDims[3] = { 0, 0, 0 };
float iRes[3] = { 0.0f, 0.0f, 0.0f };
float iOrigin[4] = { 0.0f, 0.0f, 0.0f };
image->getDimensions(iDims);
image->getResolution(iRes);
image->getOrigin(iOrigin);
if(dcExists && NULL != image.get())//attribute matrix exists, check compatibility
{
//get matrix
cellAttrMat = m->getPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), false);
if(getErrorCondition() < 0) { return; }
//check dimension compatibility
QVector<size_t> tDims = cellAttrMat->getTupleDimensions();
if(tDims[0] != xdim || iDims[0] != xdim)
{
QString message = QObject::tr("The x size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(xdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[0]);
setErrorCondition(-4);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(tDims[1] != ydim || iDims[1] != ydim)
{
QString message = QObject::tr("The y size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(ydim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[1]);
setErrorCondition(-5);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(3 == numDimensions)
{
if(tDims[2] != zdim || iDims[2] != zdim)
{
QString message = QObject::tr("The z size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(zdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[2]);
setErrorCondition(-6);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
else
{
if(tDims[2] != 1 || iDims[2] != 1)
{
QString message = QObject::tr("The z size of '%1' (%2) does not match the x size of '%3' (1)").arg(getInputFileName()).arg(zdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName());
setErrorCondition(-7);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
}
else //attribute matrix doesn't exist, create
{
createAttributeMatrix = true;
}
}
//image/attribute matrix dimensions
QVector<size_t> tDims(3, 0);
tDims[0] = xdim;
tDims[1] = ydim;
tDims[2] = zdim;
//create attribute matrix if needed
if(createAttributeMatrix)
{
//create attribute matrix
cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0) { return; }
}
//check pixel type (scalar, vector, etc) for support
QVector<size_t> componentDims(1, 0);
itk::ImageIOBase::IOPixelType pixelType = imageIO->GetPixelType();
switch(pixelType)
{
case itk::ImageIOBase::SCALAR:
componentDims[0] = 1;
break;
case itk::ImageIOBase::RGB:
componentDims[0] = 3;
break;
case itk::ImageIOBase::RGBA:
componentDims[0] = 4;
break;
default:
setErrorCondition(-80001);
notifyErrorMessage(getHumanLabel(), "The Pixel Type of the image is not supported with DREAM3D.", getErrorCondition());
}
// Check to make sure everything is OK with reading the image
if(getErrorCondition() < 0)
{
std::string pixelTypeName = itk::ImageIOBase::GetPixelTypeAsString(pixelType);
QString message = QObject::tr("The pixel type of '%1' (%2) is unsupported").arg(getInputFileName()).arg(QString::fromStdString(pixelTypeName));
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
//Now get how the actual image data is stored.
IDataArray::Pointer data;
itk::ImageIOBase::IOComponentType componentType = imageIO->GetComponentType();
if(itk::ImageIOBase::CHAR == componentType)
{
data = Int8ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::UCHAR == componentType)
{
data = UInt8ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::SHORT == componentType)
{
data = Int16ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::USHORT == componentType)
{
data = UInt16ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::INT == componentType)
{
data = Int32ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::UINT == componentType)
{
data = UInt32ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::LONG == componentType)
{
data = Int64ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::ULONG == componentType)
{
data = UInt64ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::FLOAT == componentType)
{
data = FloatArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::DOUBLE == componentType)
{
data = DoubleArrayType::CreateArray(0, "Temp", false);
}
else
{
std::string componentTypeName = itk::ImageIOBase::GetComponentTypeAsString(componentType);
QString message = QObject::tr("The component type type of '%1' (%2) is unsupported").arg(getInputFileName()).arg(QString::fromStdString(componentTypeName));
setErrorCondition(-9);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(getErrorCondition() < 0) { return; }
m_ImageDataPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, createdPath, componentDims, data);
if( NULL != m_ImageDataPtr.lock().get() )
{
m_ImageData = m_ImageDataPtr.lock()->getVoidPointer(0);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeData::dataCheck()
{
setErrorCondition(0);
if (m_CellAttributeMatrixPaths.size() <= 0)
{
QString ss = "At least one data array must be selected.";
setErrorCondition(-5550);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
DataArrayPath attributeMatrixPath(m_CellAttributeMatrixPaths[0].getDataContainerName(), m_CellAttributeMatrixPaths[0].getAttributeMatrixName(), "");
getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, attributeMatrixPath, -301);
ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, attributeMatrixPath.getDataContainerName());
if(NULL == image.get()) { return; }
if (getXMax() < getXMin())
{
QString ss = QObject::tr("X Max (%1) less than X Min (%2)").arg(getXMax()).arg(getXMin());
setErrorCondition(-5551);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMax() < getYMin())
{
QString ss = QObject::tr("Y Max (%1) less than Y Min (%2)").arg(getYMax()).arg(getYMin());
setErrorCondition(-5552);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMax() < getZMin())
{
QString ss = QObject::tr("Z Max (%1) less than Z Min (%2)").arg(getZMax()).arg(getZMin());
setErrorCondition(-5553);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getXMin() < 0)
{
QString ss = QObject::tr("X Min (%1) less than 0").arg(getXMin());
setErrorCondition(-5554);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMin() < 0)
{
QString ss = QObject::tr("Y Min (%1) less than 0").arg(getYMin());
setErrorCondition(-5555);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMin() < 0)
{
QString ss = QObject::tr("Z Min (%1) less than 0").arg(getZMin());
setErrorCondition(-5556);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getXMax() > (static_cast<int64_t>(image->getXPoints()) - 1))
{
QString ss = QObject::tr("The X Max you entered of %1 is greater than your Max X Point of %2").arg(getXMax()).arg(static_cast<int64_t>(image->getXPoints()) - 1);
setErrorCondition(-5557);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getYMax() > (static_cast<int64_t>(image->getYPoints()) - 1))
{
QString ss = QObject::tr("The Y Max you entered of %1 is greater than your Max Y Point of %2").arg(getYMax()).arg(static_cast<int64_t>(image->getYPoints()) - 1);
setErrorCondition(-5558);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (getZMax() > (static_cast<int64_t>(image->getZPoints()) - 1))
{
QString ss = QObject::tr("The Z Max you entered of %1) greater than your Max Z Point of %2").arg(getZMax()).arg(static_cast<int64_t>(image->getZPoints()) - 1);
setErrorCondition(-5559);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(attributeMatrixPath.getDataContainerName());
size_t udims[3] =
{ 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(udims);
QString attrMatName = attributeMatrixPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = DataArrayPath::GetDataArrayNames(m_CellAttributeMatrixPaths);
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
QString type = p->getTypeAsString();
if (type == "int8_t")
{
checkInitialization<int8_t>(p);
}
else if (type == "int16_t")
{
checkInitialization<int16_t>(p);
}
else if (type == "int32_t")
{
checkInitialization<int32_t>(p);
}
else if (type == "int64_t")
{
checkInitialization<int64_t>(p);
}
else if (type == "uint8_t")
{
checkInitialization<uint8_t>(p);
}
else if (type == "uint16_t")
{
checkInitialization<uint16_t>(p);
}
else if (type == "uint32_t")
{
checkInitialization<uint32_t>(p);
}
else if (type == "uint64_t")
{
checkInitialization<uint64_t>(p);
}
else if (type == "float")
{
checkInitialization<float>(p);
}
else if (type == "double")
{
checkInitialization<double>(p);
}
if (getErrorCondition() < 0)
{
return;
}
}
}