// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int EstablishShapeTypes::getPhaseCount()
{
DataContainerArray::Pointer dca = getDataContainerArray();
AttributeMatrix::Pointer inputAttrMat = dca->getAttributeMatrix(getInputPhaseTypesArrayPath());
if (NULL == inputAttrMat.get() ) { return 0; }
if (__SHOW_DEBUG_MSG__)
{
qDebug() << " data->getNumberOfTuples(): " << inputAttrMat->getTupleDimensions();
qDebug() << "Name" << inputAttrMat->getName();
}
if (inputAttrMat->getType() < DREAM3D::AttributeMatrixType::VertexEnsemble
|| inputAttrMat->getType() > DREAM3D::AttributeMatrixType::CellEnsemble )
{
return 0;
}
QVector<size_t> tupleDims = inputAttrMat->getTupleDimensions();
size_t phaseCount = 1;
for (int32_t i = 0; i < tupleDims.size(); i++)
{
phaseCount = phaseCount * tupleDims[i];
}
return phaseCount;
}
int32_t readDataChunk(AttributeMatrix::Pointer attrMat, std::istream& in, bool inPreflight, bool binary,
const QString& scalarName, int32_t scalarNumComp)
{
size_t numTuples = attrMat->getNumTuples();
QVector<size_t> tDims = attrMat->getTupleDimensions();
QVector<size_t> cDims(1, scalarNumComp);
typename DataArray<T>::Pointer data = DataArray<T>::CreateArray(tDims, cDims, scalarName, !inPreflight);
data->initializeWithZeros();
attrMat->addAttributeArray(data->getName(), data);
if (inPreflight == true)
{
return skipVolume<T>(in, binary, numTuples * scalarNumComp);
}
else
{
if (binary)
{
int32_t err = vtkReadBinaryData<T>(in, data->getPointer(0), numTuples, scalarNumComp);
if( err < 0 )
{
std::cout << "Error Reading Binary Data '" << scalarName.toStdString() << "' " << attrMat->getName().toStdString()
<< " numTuples = " << numTuples << std::endl;
return err;
}
if(BIGENDIAN == 0) {data->byteSwapElements(); }
}
else
{
T value = static_cast<T>(0.0);
size_t totalSize = numTuples * scalarNumComp;
for (size_t i = 0; i < totalSize; ++i)
{
in >> value;
data->setValue(i, value);
}
}
}
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 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);
}
}
