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