// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSections::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
if (image->getXPoints() <= 1 || image->getYPoints() <= 1 || image->getZPoints() <= 1)
{
QString ss = QObject::tr("The Image Geometry is not 3D and cannot be run through this filter. The dimensions are (%1,%2,%3)").arg(image->getXPoints()).arg(image->getYPoints()).arg(image->getZPoints());
setErrorCondition(-3010);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), "");
getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, tempPath, -301);
if (true == m_WriteAlignmentShifts && m_AlignmentShiftFileName.isEmpty() == true)
{
QString ss = QObject::tr("The alignment shift file name is empty");
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularGridSampleSurfaceMesh::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if (getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
// Set the Dimensions, Resolution and Origin of the output data container
m->getGeometryAs<ImageGeom>()->setDimensions(m_XPoints, m_YPoints, m_ZPoints);
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->getGeometryAs<ImageGeom>()->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z);
QVector<size_t> tDims(3, 0);
tDims[0] = m_XPoints;
tDims[1] = m_YPoints;
tDims[2] = m_ZPoints;
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if (getErrorCondition() < 0 || NULL == cellAttrMat.get()) { return; }
QVector<size_t> cDims(1, 1);
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getFeatureIdsArrayName() );
m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, 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 */
}
int testCase1_Execute(const QString& name, int scalarType)
{
int err = 0;
int dataArraySize = ARRAY_SIZE * N;
int junkArraySize = 0;
int skipHeaderBytes = 0;
qDebug() << "Testing case 1: " << name << " with num comps " << N;
// Allocate an array, and get the dataArray from that array
boost::shared_array<T> array(new T[dataArraySize]); // This makes sure our allocated array is deleted when we leave
T* dataArray = array.get();
// Write some data into the data array
for(size_t i = 0; i < dataArraySize; ++i)
{
dataArray[i] = static_cast<T>(i);
}
// Create junkArray and set it to NULL because there is no junk in this test case
T* junkArray = NULL;
// Create the file and write to it. If any of the information is wrong, the result will be false
bool result = createAndWriteToFile(dataArray, dataArraySize, junkArray, junkArraySize, Detail::None);
// Test to make sure that the file was created and written to successfully
DREAM3D_REQUIRED(result, == , true)
// Create the data container
VolumeDataContainer::Pointer m = VolumeDataContainer::New();
m->setName(DREAM3D::Defaults::DataContainerName);
DataContainerArray::Pointer dca = DataContainerArray::New();
dca->pushBack(m);
// Create the filter, passing in the skipHeaderBytes
RawBinaryReader::Pointer filt = createRawBinaryReaderFilter(scalarType, N, skipHeaderBytes);
filt->setDataContainerArray(dca);
// Preflight, get the error condition, and check that there are no errors
filt->preflight();
err = filt->getErrorCondition();
DREAM3D_REQUIRED(err, >= , 0)
// Execute the filter, check that there are no errors, and compare the data
filt->execute();
DREAM3D_REQUIRED(err, >= , 0)
IDataArray::Pointer iData = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray("Test_Array");
T* data = reinterpret_cast<T*>(iData->getVoidPointer(0));
T d, p;
for(size_t i = 0; i < dataArraySize; ++i)
{
d = data[i];
p = dataArray[i];
DREAM3D_REQUIRE_EQUAL(d, p)
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setInputFileName( reader->readString( "InputFileName", getInputFileName() ) );
setDataContainerName( reader->readString( "DataContainerName", getDataContainerName() ) );
setCellAttributeMatrixName( reader->readString( "CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setImageDataArrayName( reader->readString( "ImageDataArrayName", getImageDataArrayName() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VtkStructuredPointsReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setVertexDataContainerName(reader->readString("VertexDataContainerName", getVertexDataContainerName()));
setVolumeDataContainerName(reader->readString("VolumeDataContainerName", getVolumeDataContainerName() ) );
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setVertexAttributeMatrixName(reader->readString("VertexAttributeMatrixName", getVertexAttributeMatrixName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setReadPointData(reader->readValue("ReadPointData", getReadPointData()));
setReadCellData(reader->readValue("ReadCellData", getReadCellData()));
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularGridSampleSurfaceMesh::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
SampleSurfaceMesh::readFilterParameters(reader, index);
reader->openFilterGroup(this, index);
setXPoints(reader->readValue("XPoints", getXPoints()));
setYPoints(reader->readValue("YPoints", getYPoints()));
setZPoints(reader->readValue("ZPoints", getZPoints()));
setResolution(reader->readFloatVec3("Resolution", getResolution()));
setOrigin(reader->readFloatVec3("Origin", getOrigin()));
setDataContainerName(reader->readString("DataContainerName", getDataContainerName()));
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setFeatureIdsArrayName(reader->readString("FeatureIdsArrayName", getFeatureIdsArrayName() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) );
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setDimensions( reader->readIntVec3("Dimensions", getDimensions() ) );
setResolution( reader->readFloatVec3("Resolution", getResolution() ) );
setOrigin( reader->readFloatVec3("Origin", getOrigin() ) );
setInputStatsArrayPath(reader->readDataArrayPath("InputStatsArrayPath", getInputStatsArrayPath() ) );
setInputPhaseTypesArrayPath(reader->readDataArrayPath("InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath() ) );
setInputStatsFile(reader->readString("InputStatsFile", getInputStatsFile() ) );
setEstimateNumberOfFeatures(reader->readValue("EstimateNumberOfFeatures", getEstimateNumberOfFeatures() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FeatureInfoReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setCellAttributeMatrixName(reader->readDataArrayPath("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setCellFeatureAttributeMatrixName(reader->readString("CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName() ) );
setFeatureEulerAnglesArrayName(reader->readString("FeatureEulerAnglesArrayName", getFeatureEulerAnglesArrayName() ) );
setFeaturePhasesArrayName(reader->readString("FeaturePhasesArrayName", getFeaturePhasesArrayName() ) );
setCellEulerAnglesArrayName(reader->readString("CellEulerAnglesArrayName", getCellEulerAnglesArrayName() ) );
setCellPhasesArrayName(reader->readString("CellPhasesArrayName", getCellPhasesArrayName() ) );
setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setCreateCellLevelArrays( reader->readValue("CreateCellLevelArrays", getCreateCellLevelArrays()) );
setRenumberFeatures( reader->readValue("RenumberFeatures", getRenumberFeatures()) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) );
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setCellFeatureAttributeMatrixName(reader->readString("CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName() ) );
setCellEnsembleAttributeMatrixName(reader->readString("CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName() ) );
setCrystalStructuresArrayName(reader->readString("CrystalStructuresArrayName", getCrystalStructuresArrayName() ) );
setFeatureIdsArrayName(reader->readString("FeatureIdsArrayName", getFeatureIdsArrayName() ) );
setSurfaceFeaturesArrayName(reader->readString("SurfaceFeaturesArrayName", getSurfaceFeaturesArrayName() ) );
setCellPhasesArrayName(reader->readString("CellPhasesArrayName", getCellPhasesArrayName() ) );
setAvgQuatsArrayName(reader->readString("AvgQuatsArrayName", getAvgQuatsArrayName() ) );
setQuatsArrayName(reader->readString("QuatsArrayName", getQuatsArrayName() ) );
setCellEulerAnglesArrayName(reader->readString("CellEulerAnglesArrayName", getCellEulerAnglesArrayName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setInputFeatureInfoFile( reader->readString( "InputFeatureInfoFile", getInputFeatureInfoFile() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateNodeTriangleConnectivity::dataCheck()
{
setErrorCondition(0);
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if(NULL == sm)
{
setErrorCondition(-384);
notifyErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
else
{
// We MUST have Nodes
if(sm->getVertices().get() == NULL)
{
setErrorCondition(-384);
notifyErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Nodes", getErrorCondition());
}
// We MUST have Triangles defined also.
if(sm->getFaces().get() == NULL)
{
setErrorCondition(-384);
notifyErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Triangles", getErrorCondition());
}
else
{
// This depends on the triangles array already being created
int size = sm->getFaces()->GetNumberOfTuples();
m_SurfaceMeshTriangleEdgesPtr = sattrMat->createNonPrereqArray<DataArray<int32_t>, AbstractFilter, int32_t>(this, m_CellAttributeMatrixName, m_SurfaceMeshTriangleEdgesArrayName, 0, size, 3); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshTriangleEdgesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshTriangleEdges = m_SurfaceMeshTriangleEdgesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// We do not know the size of the array so we can not use the macro so we just manually call
// the needed methods that will propagate these array additions to the pipeline
DataArray<int>::Pointer uniqueEdgesArray = DataArray<int>::CreateArray(1, 2, SIMPL::CellData::SurfaceMeshUniqueEdges);
sm->getAttributeMatrix(getCellAttributeMatrixName())->addAttributeArray(SIMPL::CellData::SurfaceMeshUniqueEdges, uniqueEdgesArray);
// This is just for tracking what Arrays are being created by this filter. Normally the macro
// would do this for us.
addCreatedCellData(SIMPL::CellData::SurfaceMeshUniqueEdges);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
// Resize the Cell AttributeMatrix to have the correct Tuple Dimensions.
QVector<size_t> tDims(3, 0);
tDims[0] = m->getGeometryAs<ImageGeom>()->getXPoints();
tDims[1] = m->getGeometryAs<ImageGeom>()->getYPoints();
tDims[2] = m->getGeometryAs<ImageGeom>()->getZPoints();
cellAttrMat->resizeAttributeArrays(tDims);
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::dataCheck()
{
setErrorCondition(0);
// Create the output Data Container
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
// Sanity Check the Dimensions and Resolution
INIT_SYNTH_VOLUME_CHECK(Dimensions.x, -5000);
INIT_SYNTH_VOLUME_CHECK(Dimensions.y, -5001);
INIT_SYNTH_VOLUME_CHECK(Dimensions.z, -5002);
INIT_SYNTH_VOLUME_CHECK(Resolution.x, -5003);
INIT_SYNTH_VOLUME_CHECK(Resolution.y, -5004);
INIT_SYNTH_VOLUME_CHECK(Resolution.z, -5005);
// Set the Dimensions, Resolution and Origin of the output data container
m->getGeometryAs<ImageGeom>()->setDimensions(m_Dimensions.x, m_Dimensions.y, m_Dimensions.z);
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->getGeometryAs<ImageGeom>()->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z);
// Create our output Cell and Ensemble Attribute Matrix objects
QVector<size_t> tDims(3, 0);
tDims[0] = m_Dimensions.x;
tDims[1] = m_Dimensions.y;
tDims[2] = m_Dimensions.z;
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 && cellAttrMat.get() == NULL) { return; }
QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component
UInt32ArrayType::Pointer phaseType = getDataContainerArray()->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(this, getInputPhaseTypesArrayPath(), cDims);
if(getErrorCondition() < 0 && phaseType.get() == NULL) { return; }
QVector<size_t> statsDims(1, 1);
StatsDataArray::Pointer statsPtr = getDataContainerArray()->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims);
if(getErrorCondition() < 0 && statsPtr.get() == NULL) { return; }
if(m_EstimateNumberOfFeatures)
{
m_EstimatedPrimaryFeatures = estimateNumFeatures(m_Dimensions, m_Resolution);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FeatureInfoReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input Feature Info File", "InputFile", getInputFile(), FilterParameter::Parameter, "*.txt"));
QStringList linkedProps;
linkedProps << "CellPhasesArrayName" << "CellEulerAnglesArrayName";
parameters.push_back(LinkedBooleanFilterParameter::New("Create Element Level Arrays", "CreateCellLevelArrays", getCreateCellLevelArrays(), linkedProps, FilterParameter::Parameter));
parameters.push_back(BooleanFilterParameter::New("Renumber Features", "RenumberFeatures", getRenumberFeatures(), FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Element Data", FilterParameter::RequiredArray));
{
AttributeMatrixSelectionFilterParameter::RequirementType req;
QVector<unsigned int> amTypes;
amTypes.push_back(DREAM3D::AttributeMatrixType::Cell);
amTypes.push_back(DREAM3D::AttributeMatrixType::Edge);
amTypes.push_back(DREAM3D::AttributeMatrixType::Face);
amTypes.push_back(DREAM3D::AttributeMatrixType::Vertex);
parameters.push_back(AttributeMatrixSelectionFilterParameter::New("Element Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Int32, 1, DREAM3D::AttributeMatrixObjectType::Element);
parameters.push_back(DataArraySelectionFilterParameter::New("Feature Ids", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Element Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Phases", "CellPhasesArrayName", getCellPhasesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Euler Angles", "CellEulerAnglesArrayName", getCellEulerAnglesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Feature Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Feature Attribute Matrix", "CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Phases", "FeaturePhasesArrayName", getFeaturePhasesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Euler Angles", "FeatureEulerAnglesArrayName", getFeatureEulerAnglesArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::setupFilterParameters()
{
FilterParameterVector parameters;
QStringList linkedProps("EstimatedPrimaryFeatures");
linkedProps << "InputStatsFile";
parameters.push_back(LinkedBooleanFilterParameter::New("Estimate Number of Features", "EstimateNumberOfFeatures", getEstimateNumberOfFeatures(), linkedProps, FilterParameter::Parameter));
parameters.push_back(InputFileFilterParameter::New("Input Statistics File", "InputStatsFile", getInputStatsFile(), FilterParameter::Parameter, "*.dream3d"));
PreflightUpdatedValueFilterParameter::Pointer param = PreflightUpdatedValueFilterParameter::New("Estimated Primary Features", "EstimatedPrimaryFeatures", getEstimatedPrimaryFeatures(), FilterParameter::Parameter);
param->setReadOnly(true);
parameters.push_back(param);
parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::StatsDataArray, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry);
QVector<uint32_t> geomTypes;
geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry);
geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry);
req.dcGeometryTypes = geomTypes;
parameters.push_back(DataArraySelectionFilterParameter::New("Statistics", "InputStatsArrayPath", getInputStatsArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::UInt32, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry);
QVector<uint32_t> geomTypes;
geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry);
geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry);
req.dcGeometryTypes = geomTypes;
parameters.push_back(DataArraySelectionFilterParameter::New("Phase Types", "InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(StringFilterParameter::New("Synthetic Volume Data Container", "DataContainerName", getDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(IntVec3FilterParameter::New("Dimensions", "Dimensions", getDimensions(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Resolution", "Resolution", getResolution(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Origin", "Origin", getOrigin(), FilterParameter::Parameter));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSectionsMutualInformation::find_shifts(std::vector<int64_t>& xshifts, std::vector<int64_t>& yshifts)
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
int64_t totalPoints = m->getAttributeMatrix(getCellAttributeMatrixName())->getNumTuples();
Int32ArrayType::Pointer p = Int32ArrayType::CreateArray((totalPoints * 1), "_INTERNAL_USE_ONLY_MIFeatureIds");
m_FeatureIds = p->getPointer(0);
std::ofstream outFile;
if (getWriteAlignmentShifts() == true)
{
outFile.open(getAlignmentShiftFileName().toLatin1().data());
}
size_t udims[3] = { 0, 0, 0 };
m->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]),
};
float disorientation = 0.0f;
float mindisorientation = std::numeric_limits<float>::max();
float** mutualinfo12 = NULL;
float* mutualinfo1 = NULL;
float* mutualinfo2 = NULL;
int32_t featurecount1 = 0, featurecount2 = 0;
int64_t newxshift = 0;
int64_t newyshift = 0;
int64_t oldxshift = 0;
int64_t oldyshift = 0;
float count = 0.0f;
DimType slice = 0;
int32_t refgnum = 0, curgnum = 0;
DimType refposition = 0;
DimType curposition = 0;
form_features_sections();
std::vector<std::vector<float> > misorients;
misorients.resize(dims[0]);
for (DimType a = 0; a < dims[0]; a++)
{
misorients[a].assign(dims[1], 0.0f);
}
for (DimType iter = 1; iter < dims[2]; iter++)
{
QString ss = QObject::tr("Aligning Sections || Determining Shifts || %1% Complete").arg(((float)iter / dims[2]) * 100);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
mindisorientation = std::numeric_limits<float>::max();
slice = (dims[2] - 1) - iter;
featurecount1 = featurecounts[slice];
featurecount2 = featurecounts[slice + 1];
mutualinfo12 = new float *[featurecount1];
mutualinfo1 = new float[featurecount1];
mutualinfo2 = new float[featurecount2];
for (int32_t a = 0; a < featurecount1; a++)
{
mutualinfo1[a] = 0.0f;
mutualinfo12[a] = new float[featurecount2];
for (int32_t b = 0; b < featurecount2; b++)
{
mutualinfo12[a][b] = 0.0f;
mutualinfo2[b] = 0.0f;
}
}
oldxshift = -1;
oldyshift = -1;
newxshift = 0;
newyshift = 0;
for (DimType a = 0; a < dims[0]; a++)
{
for (DimType b = 0; b < dims[1]; b++)
{
misorients[a][b] = 0;
}
}
while (newxshift != oldxshift || newyshift != oldyshift)
{
oldxshift = newxshift;
oldyshift = newyshift;
for (int32_t j = -3; j < 4; j++)
{
for (int32_t k = -3; k < 4; k++)
{
disorientation = 0;
count = 0;
if (misorients[k + oldxshift + dims[0] / 2][j + oldyshift + dims[1] / 2] == 0 && abs(k + oldxshift) < (dims[0] / 2)
&& (j + oldyshift) < (dims[1] / 2))
{
for (DimType l = 0; l < dims[1]; l = l + 4)
{
for (DimType n = 0; n < dims[0]; n = n + 4)
{
if ((l + j + oldyshift) >= 0 && (l + j + oldyshift) < dims[1] && (n + k + oldxshift) >= 0 && (n + k + oldxshift) < dims[0])
{
refposition = ((slice + 1) * dims[0] * dims[1]) + (l * dims[0]) + n;
curposition = (slice * dims[0] * dims[1]) + ((l + j + oldyshift) * dims[0]) + (n + k + oldxshift);
refgnum = m_FeatureIds[refposition];
curgnum = m_FeatureIds[curposition];
if (curgnum >= 0 && refgnum >= 0)
{
mutualinfo12[curgnum][refgnum]++;
mutualinfo1[curgnum]++;
mutualinfo2[refgnum]++;
count++;
}
}
else
{
mutualinfo12[0][0]++;
mutualinfo1[0]++;
mutualinfo2[0]++;
}
}
}
float ha = 0.0f;
float hb = 0.0f;
float hab = 0.0f;
for (int32_t b = 0; b < featurecount1; b++)
{
mutualinfo1[b] = mutualinfo1[b] / count;
if (mutualinfo1[b] != 0) { ha = ha + mutualinfo1[b] * logf(mutualinfo1[b]); }
}
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo2[c] = mutualinfo2[c] / float(count);
if (mutualinfo2[c] != 0) { hb = hb + mutualinfo2[c] * logf(mutualinfo2[c]); }
}
for (int32_t b = 0; b < featurecount1; b++)
{
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo12[b][c] = mutualinfo12[b][c] / count;
if (mutualinfo12[b][c] != 0) { hab = hab + mutualinfo12[b][c] * logf(mutualinfo12[b][c]); }
float value = 0.0f;
if (mutualinfo1[b] > 0 && mutualinfo2[c] > 0) { value = (mutualinfo12[b][c] / (mutualinfo1[b] * mutualinfo2[c])); }
if (value != 0) { disorientation = disorientation + (mutualinfo12[b][c] * logf(value)); }
}
}
for (int32_t b = 0; b < featurecount1; b++)
{
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo12[b][c] = 0.0f;
mutualinfo1[b] = 0.0f;
mutualinfo2[c] = 0.0f;
}
}
disorientation = 1.0f / disorientation;
misorients[k + oldxshift + dims[0] / 2][j + oldyshift + dims[1] / 2] = disorientation;
if (disorientation < mindisorientation)
{
newxshift = k + oldxshift;
newyshift = j + oldyshift;
mindisorientation = disorientation;
}
}
}
}
}
xshifts[iter] = xshifts[iter - 1] + newxshift;
yshifts[iter] = yshifts[iter - 1] + newyshift;
if (getWriteAlignmentShifts() == true)
{
outFile << slice << " " << slice + 1 << " " << newxshift << " " << newyshift << " " << xshifts[iter] << " " << yshifts[iter] << "\n";
}
delete[] mutualinfo1;
delete[] mutualinfo2;
for (int32_t i = 0; i < featurecount1; i++)
{
delete mutualinfo12[i];
}
delete[] mutualinfo12;
mutualinfo1 = NULL;
mutualinfo2 = NULL;
mutualinfo12 = NULL;
}
m->getAttributeMatrix(getCellAttributeMatrixName())->removeAttributeArray(DREAM3D::CellData::FeatureIds);
if (getWriteAlignmentShifts() == true)
{
outFile.close();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 YSChoiAbaqusReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input File", "InputFile", getInputFile(), FilterParameter::Parameter));
parameters.push_back(InputFileFilterParameter::New("Input Feature Orientation File", "InputFeatureInfoFile", getInputFeatureInfoFile(), FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Data Container Name", "CellEulerAnglesArrayName", getCellEulerAnglesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix Name", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Feature Attribute Matrix Name", "CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Ensemble Attribute Matrix Name", "CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Quats", "QuatsArrayName", getQuatsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("AvgQuats", "AvgQuatsArrayName", getAvgQuatsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Phases", "CellPhasesArrayName", getCellPhasesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("SurfaceFeatures", "SurfaceFeaturesArrayName", getSurfaceFeaturesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("FeatureIds", "FeatureIdsArrayName", getFeatureIdsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Crystal Structures", "CrystalStructuresArrayName", getCrystalStructuresArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
void testCase4_Execute(const QString& name, int scalarType)
{
int dataArraySize = ARRAY_SIZE * N;
int junkArraySize = 5;
int skipHeaderBytes = junkArraySize * sizeof(T);
int err = 0;
qDebug() << "Testing case 4: " << name << " with num comps " << N;
// Allocate an array, and get the dataArray from that array
boost::shared_array<T> array(new T[dataArraySize]); // This makes sure our allocated array is deleted when we leave
T* dataArray = array.get();
// Write some data into the data array
for(size_t i = 0; i < dataArraySize; ++i)
{
dataArray[i] = static_cast<T>(i);
}
// Create junkArray
T* junkArray = new T[junkArraySize];
// Write a pattern into junkArray
for(size_t i = 0; i < junkArraySize; ++i)
{
junkArray[i] = (unsigned)0xAB;
}
// Create the file and write to it. If any of the information is wrong, the result will be false
bool result = createAndWriteToFile(dataArray, dataArraySize, junkArray, junkArraySize, Detail::Start);
// Test to make sure that the file was created and written to successfully
DREAM3D_REQUIRED(result, == , true)
// Create the data container
VolumeDataContainer::Pointer m = VolumeDataContainer::New();
m->setName(DREAM3D::Defaults::DataContainerName);
DataContainerArray::Pointer dca = DataContainerArray::New();
dca->pushBack(m);
// Create the filter, passing in the skipHeaderBytes
RawBinaryReader::Pointer filt = createRawBinaryReaderFilter(scalarType, N, skipHeaderBytes);
filt->setDataContainerArray(dca);
// Preflight, get error condition, and check that there are no errors
filt->preflight();
err = filt->getErrorCondition();
DREAM3D_REQUIRED(err, >= , 0)
// Execute, get error condition, check that there are no errors, and compare the data
filt->execute();
err = filt->getErrorCondition();
DREAM3D_REQUIRED(err, >= , 0)
IDataArray::Pointer iData = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray("Test_Array");
T* data = reinterpret_cast<T*>(iData->getVoidPointer(0));
T d, p;
for(size_t i = 0; i < dataArraySize; ++i)
{
d = data[i];
p = dataArray[i];
DREAM3D_REQUIRE_EQUAL(d, p)
}
/*
* SUBTEST: Test when skipHeaderBytes is larger than expected
*/
// Create another data container
VolumeDataContainer::Pointer m2 = VolumeDataContainer::New();
m2->setName(DREAM3D::Defaults::DataContainerName);
DataContainerArray::Pointer dca2 = DataContainerArray::New();
dca2->pushBack(m2);
// Create another filter, passing in the skipHeaderBytes + 1
RawBinaryReader::Pointer filt2 = createRawBinaryReaderFilter(scalarType, N, skipHeaderBytes + 1);
filt2->setDataContainerArray(dca2);
// Preflight, get error condition, and check that there are errors
filt2->preflight();
err = filt2->getErrorCondition();
DREAM3D_REQUIRED(err, < , 0)
// Execute, get error condition, and check that the "file too small" error occurred
filt2->execute();
err = filt2->getErrorCondition();
DREAM3D_REQUIRED(err, == , RBRT_FILE_TOO_SMALL)
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FileSystemFilterParameter::New("Input File", "InputFileName", FilterParameterWidgetType::InputFileWidget, getInputFileName(), false, "", "*.tif *.jpeg *.png *.bmp", "Image"));
parameters.push_back(FilterParameter::New("Created Information", "", FilterParameterWidgetType::SeparatorWidget, "", true));
parameters.push_back(FilterParameter::New("Data Container Name", "DataContainerName", FilterParameterWidgetType::StringWidget, getDataContainerName(), true, ""));
parameters.push_back(FilterParameter::New("Cell Attribute Matrix Name", "CellAttributeMatrixName", FilterParameterWidgetType::StringWidget, getCellAttributeMatrixName(), true, ""));
parameters.push_back(FilterParameter::New("ImageData", "ImageDataArrayName", FilterParameterWidgetType::StringWidget, getImageDataArrayName(), true, ""));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::dataCheck()
{
DataArrayPath tempPath;
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
QVector<size_t> tDims(3, 0);
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 || NULL == cellAttrMat.get()) { return; }
tDims.resize(1);
tDims[0] = 0;
AttributeMatrix::Pointer cellFeatureAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellFeatureAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellFeature);
if(getErrorCondition() < 0 || NULL == cellFeatureAttrMat.get()) { return; }
AttributeMatrix::Pointer cellEnsembleAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellEnsembleAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellEnsemble);
if(getErrorCondition() < 0 || NULL == cellEnsembleAttrMat.get()) { return; }
QFileInfo fi(getInputFile());
if (getInputFile().isEmpty() == true)
{
QString ss = QObject::tr("%1 needs the Input File Set and it was not.").arg(ClassName());
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else if (fi.exists() == false)
{
QString ss = QObject::tr("The input file does not exist");
setErrorCondition(-388);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else
{
bool ok = false;
//const unsigned int size(1024);
// Read header from data file to figure out how many points there are
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
QString word;
bool headerdone = false;
int xpoints, ypoints, zpoints;
float resx, resy, resz;
while (headerdone == false)
{
QByteArray buf = in.readLine();
if (buf.startsWith(DIMS))
{
QList<QByteArray> tokens = buf.split(' ');
xpoints = tokens[1].toInt(&ok, 10);
ypoints = tokens[2].toInt(&ok, 10);
zpoints = tokens[3].toInt(&ok, 10);
size_t dims[3] = { static_cast<size_t>(xpoints), static_cast<size_t>(ypoints), static_cast<size_t>(zpoints) };
m->getGeometryAs<ImageGeom>()->setDimensions(dims);
m->getGeometryAs<ImageGeom>()->setOrigin(0, 0, 0);
}
if (RES == word)
{
QList<QByteArray> tokens = buf.split(' ');
resx = tokens[1].toInt(&ok, 10);
resy = tokens[2].toInt(&ok, 10);
resz = tokens[3].toInt(&ok, 10);
float res[3] = {resx, resy, resz};
m->getGeometryAs<ImageGeom>()->setResolution(res);
}
}
}
QVector<size_t> dims(1, 3);
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellEulerAnglesArrayName() );
m_CellEulerAnglesPtr = 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_CellEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellEulerAngles = m_CellEulerAnglesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 4;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getQuatsArrayName() );
m_QuatsPtr = 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_QuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Quats = m_QuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getAvgQuatsArrayName() );
m_AvgQuatsPtr = 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_AvgQuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AvgQuats = m_AvgQuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellPhasesArrayName() );
m_CellPhasesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 1, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CellPhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellPhases = m_CellPhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getSurfaceFeaturesArrayName() );
m_SurfaceFeaturesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, false, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceFeaturesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceFeatures = m_SurfaceFeaturesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), 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 */
//typedef DataArray<unsigned int> XTalStructArrayType;
tempPath.update(getDataContainerName(), getCellEnsembleAttributeMatrixName(), getCrystalStructuresArrayName() );
m_CrystalStructuresPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter, uint32_t>(this, tempPath, Ebsd::CrystalStructure::Cubic_High, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CrystalStructuresPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t VtkStructuredPointsReader::readDataTypeSection(std::istream& in, int32_t numValues, const std::string& nextKeyWord)
{
QByteArray buf(kBufferSize, '\0');
char* line = buf.data();
// Read keywords until end-of-file
while (this->readString(in, line, kBufferSize))
{
// read scalar data
if ( ! strncmp(lowerCase(line, kBufferSize), "scalars", 7) )
{
if ( this->readScalarData(in, numValues) <= 0 )
{
return 0;
}
}
// read vector data
else if ( ! strncmp(line, "vectors", 7) )
{
if ( this->readVectorData(in, numValues) <= 0 )
{
return 0;
}
}
#if 0
//
// read 3x3 tensor data
//
else if ( ! strncmp(line, "tensors", 7) )
{
if ( ! this->ReadTensorData(a, numPts) )
{
return 0;
}
}
//
// read normals data
//
else if ( ! strncmp(line, "normals", 7) )
{
if ( ! this->ReadNormalData(a, numPts) )
{
return 0;
}
}
//
// read texture coordinates data
//
else if ( ! strncmp(line, "texture_coordinates", 19) )
{
if ( ! this->ReadTCoordsData(a, numPts) )
{
return 0;
}
}
//
// read the global id data
//
else if ( ! strncmp(line, "global_ids", 10) )
{
if ( ! this->ReadGlobalIds(a, numPts) )
{
return 0;
}
}
//
// read the pedigree id data
//
else if ( ! strncmp(line, "pedigree_ids", 10) )
{
if ( ! this->ReadPedigreeIds(a, numPts) )
{
return 0;
}
}
//
// read color scalars data
//
else if ( ! strncmp(line, "color_scalars", 13) )
{
if ( ! this->ReadCoScalarData(a, numPts) )
{
return 0;
}
}
//
// read lookup table. Associate with scalar data.
//
else if ( ! strncmp(line, "lookup_table", 12) )
{
if ( ! this->ReadLutData(a) )
{
return 0;
}
}
//
// read field of data
//
else if ( ! strncmp(line, "field", 5) )
{
vtkFieldData* f;
if ( ! (f = this->ReadFieldData()) )
{
return 0;
}
for(int i = 0; i < f->GetNumberOfArrays(); i++)
{
a->AddArray(f->GetAbstractArray(i));
}
f->Delete();
}
#endif
// maybe bumped into cell data
else if ( ! strncmp(line, nextKeyWord.c_str(), 9) )
{
bool ok = false;
if (readString(in, line, 256))
{
if (nextKeyWord.compare("cell_data") == 0)
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getVolumeDataContainerName());
m_CurrentAttrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
int32_t ncells = QString(line).toInt(&ok);
this->readDataTypeSection(in, ncells, "point_data");
}
else if (nextKeyWord.compare("point_data") == 0)
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getVertexDataContainerName());
m_CurrentAttrMat = m->getAttributeMatrix(getVertexAttributeMatrixName());
int32_t npts = QString(line).toInt(&ok);
this->readDataTypeSection(in, npts, "cell_data");
}
}
}
else
{
//vtkErrorMacro(<< "Unsupported point attribute type: " << line
//<< " for file: " << (this->FileName?this->FileName:"(Null FileName)"));
return 0;
}
}
return 1;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VtkStructuredPointsReader::dataCheck()
{
initialize();
setErrorCondition(0);
QFileInfo fi(getInputFile());
if (getInputFile().isEmpty() == true)
{
QString ss = QObject::tr("The input file must be set");
setErrorCondition(-61000);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else if (fi.exists() == false)
{
QString ss = QObject::tr("The input file does not exist");
setErrorCondition(-61001);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
// First shot Sanity Checks.
if(!getReadCellData() && !getReadPointData())
{
QString ss = QObject::tr("At least one of Read Point Data or Read Cell Data must be checked");
setErrorCondition(-61002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
// Last chance sanity check
if(getErrorCondition() < 0) { return; }
// Create a Vertex Data Container even though we may remove it later. We need it later
// on in order to set the proper AttributeMatrix
DataContainer::Pointer pointData_DataContainer = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getVertexDataContainerName());
if(getErrorCondition() < 0 && NULL == pointData_DataContainer) { return; }
ImageGeom::Pointer pointDataGeom = ImageGeom::CreateGeometry(getVertexDataContainerName());
pointData_DataContainer->setGeometry(pointDataGeom);
QVector<size_t> tDims(1, 0);
AttributeMatrix::Pointer pointAttrMat = pointData_DataContainer->createNonPrereqAttributeMatrix<AbstractFilter>(this, getVertexAttributeMatrixName(), tDims, SIMPL::AttributeMatrixType::Cell);
if(getErrorCondition() < 0) { return; }
// Create a Volume Data Container even though we may remove it later. We need it later
// on in order to set the proper AttributeMatrix
DataContainer::Pointer cellData_DataContainer = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getVolumeDataContainerName());
if(getErrorCondition() < 0 && NULL == cellData_DataContainer) { return; }
ImageGeom::Pointer cellDataGeom = ImageGeom::CreateGeometry(getVolumeDataContainerName());
cellData_DataContainer->setGeometry(cellDataGeom);
tDims.resize(3);
tDims[0] = 0;
tDims[1] = 0;
tDims[2] = 0;
AttributeMatrix::Pointer cellAttrMat = cellData_DataContainer->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, SIMPL::AttributeMatrixType::Cell);
if(getErrorCondition() < 0) { return; }
// Scan through the file
readFile();
// now check to see what the user wanted
if (!getReadPointData())
{
getDataContainerArray()->removeDataContainer(getVertexDataContainerName());
}
if (!getReadCellData())
{
getDataContainerArray()->removeDataContainer(getVolumeDataContainerName());
}
// If there was no Cell Data, remove that dataContainer
if (cellAttrMat->getNumAttributeArrays() == 0)
{
getDataContainerArray()->removeDataContainer(getVolumeDataContainerName());
}
// If there were no Point Arrays then remove that dataContainer
if (pointAttrMat->getNumAttributeArrays() == 0)
{
getDataContainerArray()->removeDataContainer(getVertexDataContainerName());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularGridSampleSurfaceMesh::setupFilterParameters()
{
FilterParameterVector parameters = getFilterParameters();
parameters.push_back(IntFilterParameter::New("X Points", "XPoints", getXPoints(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Y Points", "YPoints", getYPoints(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Z Points", "ZPoints", getZPoints(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Resolution", "Resolution", getResolution(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Origin", "Origin", getOrigin(), FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Data Container", "DataContainerName", getDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Feature Ids", "FeatureIdsArrayName", getFeatureIdsArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSections::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
int64_t xspot = 0, yspot = 0;
int64_t newPosition = 0;
int64_t currentPosition = 0;
std::vector<int64_t> xshifts(dims[2], 0);
std::vector<int64_t> yshifts(dims[2], 0);
find_shifts(xshifts, yshifts);
QList<QString> voxelArrayNames = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArrayNames();
size_t progIncrement = dims[2] / 100;
size_t prog = 1;
size_t progressInt = 0;
size_t slice = 0;
for (size_t i = 1; i < dims[2]; i++)
{
if (i > prog)
{
progressInt = ((float)i / dims[2]) * 100.0f;
QString ss = QObject::tr("Transferring Cell Data || %1% Complete").arg(progressInt);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
prog = prog + progIncrement;
}
if (getCancel() == true)
{
return;
}
slice = (dims[2] - 1) - i;
for (size_t l = 0; l < dims[1]; l++)
{
for (size_t n = 0; n < dims[0]; n++)
{
if (yshifts[i] >= 0) { yspot = l; }
else if (yshifts[i] < 0) { yspot = dims[1] - 1 - l; }
if (xshifts[i] >= 0) { xspot = n; }
else if (xshifts[i] < 0) { xspot = dims[0] - 1 - n; }
newPosition = (slice * dims[0] * dims[1]) + (yspot * dims[0]) + xspot;
currentPosition = (slice * dims[0] * dims[1]) + ((yspot + yshifts[i]) * dims[0]) + (xspot + xshifts[i]);
if ((yspot + yshifts[i]) >= 0 && (yspot + yshifts[i]) <= static_cast<int64_t>(dims[1]) - 1 && (xspot + xshifts[i]) >= 0
&& (xspot + xshifts[i]) <= static_cast<int64_t>(dims[0]) - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
p->copyTuple( static_cast<size_t>(currentPosition), static_cast<size_t>(newPosition));
}
}
if ((yspot + yshifts[i]) < 0 || (yspot + yshifts[i]) > static_cast<int64_t>(dims[1] - 1) || (xspot + xshifts[i]) < 0
|| (xspot + xshifts[i]) > static_cast<int64_t>(dims[0]) - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
EXECUTE_FUNCTION_TEMPLATE(this, initializeArrayValues, p, p, newPosition)
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AdaptiveAlignmentMutualInformation::find_shifts(std::vector<int64_t>& xshifts, std::vector<int64_t>& yshifts, std::vector<float>& xneedshifts, std::vector<float>& yneedshifts)
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
int64_t totalPoints = m->getAttributeMatrix(getCellAttributeMatrixName())->getNumTuples();
m_MIFeaturesPtr = Int32ArrayType::CreateArray((totalPoints * 1), "_INTERNAL_USE_ONLY_MIFeatureIds");
m_MIFeaturesPtr->initializeWithZeros();
int32_t* miFeatureIds = m_MIFeaturesPtr->getPointer(0);
size_t udims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(udims);
uint64_t dims[3] =
{
static_cast<uint64_t>(udims[0]),
static_cast<uint64_t>(udims[1]),
static_cast<uint64_t>(udims[2]),
};
uint64_t maxstoredshifts = 1;
if (xneedshifts.size() > 0) maxstoredshifts = 20;
float disorientation = 0.0f;
std::vector<std::vector<int64_t>> newxshift(dims[2]);
std::vector<std::vector<int64_t>> newyshift(dims[2]);
std::vector<std::vector<float>> mindisorientation(dims[2]);
for (uint64_t a = 1; a < dims[2]; a++)
{
newxshift[a].resize(maxstoredshifts, 0);
newyshift[a].resize(maxstoredshifts, 0);
mindisorientation[a].resize(maxstoredshifts, std::numeric_limits<float>::max());
}
float** mutualinfo12 = NULL;
float* mutualinfo1 = NULL;
float* mutualinfo2 = NULL;
int32_t featurecount1 = 0, featurecount2 = 0;
int64_t oldxshift = 0;
int64_t oldyshift = 0;
float count = 0.0f;
uint64_t slice = 0;
int32_t refgnum = 0, curgnum = 0;
uint64_t refposition = 0;
uint64_t curposition = 0;
form_features_sections();
// Allocate a 2D Array which will be reused from slice to slice
// second dimension is assigned in each cycle separately
std::vector<std::vector<bool> > misorients(dims[0]);
const uint64_t halfDim0 = static_cast<uint64_t>(dims[0] * 0.5f);
const uint64_t halfDim1 = static_cast<uint64_t>(dims[1] * 0.5f);
uint64_t progInt = 0;
for (uint64_t iter = 1; iter < dims[2]; iter++)
{
progInt = static_cast<uint64_t>(iter * 100 / static_cast<float>(dims[2]));
QString ss = QObject::tr("Aligning Anisotropic Sections || Determining Shifts || %1% Complete").arg(progInt);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
slice = (dims[2] - 1) - iter;
featurecount1 = featurecounts[slice];
featurecount2 = featurecounts[slice + 1];
mutualinfo12 = new float *[featurecount1];
mutualinfo1 = new float[featurecount1];
mutualinfo2 = new float[featurecount2];
for (int32_t a = 0; a < featurecount1; a++)
{
mutualinfo1[a] = 0.0f;
mutualinfo12[a] = new float[featurecount2];
for (int32_t b = 0; b < featurecount2; b++)
{
mutualinfo12[a][b] = 0.0f;
mutualinfo2[b] = 0.0f;
}
}
oldxshift = -1;
oldyshift = -1;
for (uint64_t i = 0; i < dims[0]; i++)
{
misorients[i].assign(dims[1], false);
}
while (newxshift[iter][0] != oldxshift || newyshift[iter][0] != oldyshift)
{
oldxshift = newxshift[iter][0];
oldyshift = newyshift[iter][0];
for (int32_t j = -3; j < 4; j++)
{
for (int32_t k = -3; k < 4; k++)
{
disorientation = 0;
count = 0;
if (llabs(k + oldxshift) < halfDim0 && llabs(j + oldyshift) < halfDim1 && misorients[k + oldxshift + halfDim0][j + oldyshift + halfDim1] == false)
{
for (uint64_t l = 0; l < dims[1]; l = l + 4)
{
for (uint64_t n = 0; n < dims[0]; n = n + 4)
{
if ((l + j + oldyshift) >= 0 && (l + j + oldyshift) < dims[1] && (n + k + oldxshift) >= 0 && (n + k + oldxshift) < dims[0])
{
refposition = ((slice + 1) * dims[0] * dims[1]) + (l * dims[0]) + n;
curposition = (slice * dims[0] * dims[1]) + ((l + j + oldyshift) * dims[0]) + (n + k + oldxshift);
refgnum = miFeatureIds[refposition];
curgnum = miFeatureIds[curposition];
if (curgnum >= 0 && refgnum >= 0)
{
mutualinfo12[curgnum][refgnum]++;
mutualinfo1[curgnum]++;
mutualinfo2[refgnum]++;
count++;
}
}
else
{
mutualinfo12[0][0]++;
mutualinfo1[0]++;
mutualinfo2[0]++;
}
}
}
float ha = 0.0f;
float hb = 0.0f;
float hab = 0.0f;
for (int32_t b = 0; b < featurecount1; b++)
{
mutualinfo1[b] = mutualinfo1[b] / count;
if (mutualinfo1[b] != 0) { ha = ha + mutualinfo1[b] * logf(mutualinfo1[b]); }
}
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo2[c] = mutualinfo2[c] / float(count);
if (mutualinfo2[c] != 0) { hb = hb + mutualinfo2[c] * logf(mutualinfo2[c]); }
}
for (int32_t b = 0; b < featurecount1; b++)
{
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo12[b][c] = mutualinfo12[b][c] / count;
if (mutualinfo12[b][c] != 0) { hab = hab + mutualinfo12[b][c] * logf(mutualinfo12[b][c]); }
float value = 0.0f;
if (mutualinfo1[b] > 0 && mutualinfo2[c] > 0) { value = (mutualinfo12[b][c] / (mutualinfo1[b] * mutualinfo2[c])); }
if (value != 0) { disorientation = disorientation + (mutualinfo12[b][c] * logf(value)); }
}
}
for (int32_t b = 0; b < featurecount1; b++)
{
for (int32_t c = 0; c < featurecount2; c++)
{
mutualinfo12[b][c] = 0.0f;
mutualinfo1[b] = 0.0f;
mutualinfo2[c] = 0.0f;
}
}
disorientation = 1.0f / disorientation;
misorients[k + oldxshift + halfDim0][j + oldyshift + halfDim1] = true;
// compare the new shift with currently stored ones
int64_t s = maxstoredshifts;
while (s - 1 >= 0 && disorientation < mindisorientation[iter][s - 1])
{
s--;
}
// new shift is stored with index 's' in the arrays
if (s < maxstoredshifts)
{
// lag the shifts already stored
for (int64_t t = maxstoredshifts - 1; t > s; t--)
{
newxshift[iter][t] = newxshift[iter][t - 1];
newyshift[iter][t] = newyshift[iter][t - 1];
mindisorientation[iter][t] = mindisorientation[iter][t - 1];
}
// store the new shift
newxshift[iter][s] = k + oldxshift;
newyshift[iter][s] = j + oldyshift;
mindisorientation[iter][s] = disorientation;
}
}
}
}
}
xshifts[iter] = xshifts[iter - 1] + newxshift[iter][0];
yshifts[iter] = yshifts[iter - 1] + newyshift[iter][0];
delete[] mutualinfo1;
delete[] mutualinfo2;
for (int32_t i = 0; i < featurecount1; i++)
{
delete mutualinfo12[i];
}
delete[] mutualinfo12;
mutualinfo1 = NULL;
mutualinfo2 = NULL;
mutualinfo12 = NULL;
}
std::vector<uint64_t> curindex(dims[2], 0);
// find corrected shifts
if (xneedshifts.size() > 0)
{
QString ss = QObject::tr("Aligning Anisotropic Sections || Correcting shifts");
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
std::vector<float> changedisorientation(dims[2], 0);
std::vector<uint64_t> changeindex(dims[2], 0);
std::vector<float> changeerror(dims[2], 0);
std::vector<float> xshiftsest; // cumulative x-shifts estimated from SEM images
std::vector<float> yshiftsest; // cumulative y-shifts estimated from SEM images
float curerror = 0;
float tolerance = 1.0f / static_cast<float>(dims[2]);
// evaluate error between current shifts and desired shifts
if (xneedshifts.size() == 1) // error is computed as misagreement between slopes
{
curerror = compute_error1(dims[2], 0, xneedshifts[0], yneedshifts[0], newxshift, newyshift, curindex);
}
else if (xneedshifts.size() > 1) // error is computed as misagreement with shifts estimated from SEM images
{
xshiftsest.resize(dims[2], 0);
yshiftsest.resize(dims[2], 0);
for (uint64_t iter = 1; iter < dims[2]; iter++)
{
xshiftsest[iter] = xshiftsest[iter - 1] + xneedshifts[iter - 1];
yshiftsest[iter] = yshiftsest[iter - 1] + yneedshifts[iter - 1];
}
curerror = compute_error2(dims[2], 0, xshiftsest, yshiftsest, newxshift, newyshift, curindex);
}
// iterative selection of a candidate shift, recomputing of current candidates, evaluation of error
if (curerror > tolerance)
{
float minchangedisorientation = 0;
float minchangeerror = 0;
int64_t minchangeindex = 0;
int64_t minchangeiter = 0;
float olderror = 0;
float newerror = 0;
uint64_t progInt = 0;
do
{
QString ss = QObject::tr("Aligning Anisotropic Sections || Correcting Shifts || Iteration %1").arg(++progInt);;
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
if (getCancel() == true)
{
return;
}
olderror = curerror;
for (uint64_t iter = 1; iter < dims[2]; iter++)
{
float newminerror = std::numeric_limits<float>::max();
float newmindisorientation = std::numeric_limits<float>::max();
uint64_t newminindex = 0;
for (uint64_t index = curindex[iter] + 1; index < maxstoredshifts; index++)
{
// recompute error for the configuration with this candidate changed
if (xneedshifts.size() == 1)
{
newerror = compute_error1(iter, index, xneedshifts[0], yneedshifts[0], newxshift, newyshift, curindex);
}
else if (xneedshifts.size() > 1)
{
newerror = compute_error2(iter, index, xshiftsest, yshiftsest, newxshift, newyshift, curindex);
}
// compare the new error with the best current error
if (newerror < curerror &&
mindisorientation[iter][index] / mindisorientation[iter][0] < newmindisorientation)
{
newminerror = newerror;
newminindex = index;
newmindisorientation = mindisorientation[iter][index] / mindisorientation[iter][0];
}
}
// assign best error, corresponding index and disorientation value for this slice
changeerror[iter] = newminerror;
changeindex[iter] = newminindex;
changedisorientation[iter] = newmindisorientation;
}
// among all slices, find the best candidate (with minimum disorientation change)
minchangedisorientation = std::numeric_limits<float>::max() - 1;
minchangeerror = std::numeric_limits<float>::max();
minchangeindex = 0;
minchangeiter = 0;
for (uint64_t iter = 1; iter < dims[2]; iter++)
{
if (changeerror[iter] < curerror &&
(changedisorientation[iter] < minchangedisorientation ||
(changedisorientation[iter] == minchangedisorientation &&
llabs(newxshift[iter][changeindex[iter]]) + llabs(newyshift[iter][changeindex[iter]]) < llabs(newxshift[iter][minchangeindex]) + llabs(newyshift[iter][minchangeindex]))))
{
minchangeiter = iter;
minchangeindex = changeindex[iter];
minchangedisorientation = changedisorientation[iter];
minchangeerror = changeerror[iter];
}
}
if (minchangeerror < curerror && minchangeerror >= tolerance)
{
// assign the best candidate
changedisorientation[minchangeiter] = minchangedisorientation;
curindex[minchangeiter] = minchangeindex;
// reassign current error
curerror = minchangeerror;
}
} while (minchangedisorientation < std::numeric_limits<float>::max() - 1 && curerror < olderror && curerror > tolerance);
}
}
if (getWriteAlignmentShifts() == true)
{
std::ofstream outFile;
outFile.open(getAlignmentShiftFileName().toLatin1().data());
for (uint64_t iter = 1; iter < dims[2]; iter++)
{
slice = (dims[2] - 1) - iter;
xshifts[iter] = xshifts[iter - 1] + newxshift[iter][curindex[iter]];
yshifts[iter] = yshifts[iter - 1] + newyshift[iter][curindex[iter]];
outFile << slice << " " << slice + 1 << " " << newxshift[iter][curindex[iter]] << " " << newyshift[iter][curindex[iter]] << " " << xshifts[iter] << " " << yshifts[iter] << "\n";
}
outFile.close();
}
m->getAttributeMatrix(getCellAttributeMatrixName())->removeAttributeArray(DREAM3D::CellData::FeatureIds);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VtkStructuredPointsReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input VTK File", "InputFile", getInputFile(), FilterParameter::Parameter));
QStringList linkedProps;
linkedProps << "VertexDataContainerName" << "VertexAttributeMatrixName";
parameters.push_back(LinkedBooleanFilterParameter::New("Read Point Data", "ReadPointData", getReadPointData(), linkedProps, FilterParameter::Parameter));
linkedProps.clear();
linkedProps << "VolumeDataContainerName" << "CellAttributeMatrixName";
parameters.push_back(LinkedBooleanFilterParameter::New("Read Cell Data", "ReadCellData", getReadCellData(), linkedProps, FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Point Data Data Container", "VertexDataContainerName", getVertexDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Data Data Container", "VolumeDataContainerName", getVolumeDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Point Data Attribute Matrix", "VertexAttributeMatrixName", getVertexAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Data Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::execute()
{
QString ss;
dataCheck();
if(getErrorCondition() < 0)
{
setErrorCondition(-10000);
ss = QObject::tr("DataCheck did not pass during execute");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
//get volume container
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
//get input and output data
IDataArray::Pointer imageData = m_ImageDataPtr.lock();
//std::string fileNameString = getInputFileName().toLocal8Bit().constData();
//const char* fileNameCStr = fileNameString.c_str();
//execute type dependant portion using a Private Implementation that takes care of figuring out if
// we can work on the correct type and actually handling the algorithm execution. We pass in "this" so
// that the private implementation can get access to the current object to pass up status notifications,
// progress or handle "cancel" if needed.
if(ReadImagePrivate<int8_t>()(imageData))
{
ReadImagePrivate<int8_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint8_t>()(imageData) )
{
ReadImagePrivate<uint8_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int16_t>()(imageData) )
{
ReadImagePrivate<int16_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint16_t>()(imageData) )
{
ReadImagePrivate<uint16_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int32_t>()(imageData) )
{
ReadImagePrivate<int32_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint32_t>()(imageData) )
{
ReadImagePrivate<uint32_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int64_t>()(imageData) )
{
ReadImagePrivate<int64_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint64_t>()(imageData) )
{
ReadImagePrivate<uint64_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<float>()(imageData) )
{
ReadImagePrivate<float>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<double>()(imageData) )
{
ReadImagePrivate<double>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else
{
setErrorCondition(-10001);
ss = QObject::tr("A Supported DataArray type was not used for an input array.");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
attrMat->addAttributeArray(getImageDataArrayName(), imageData);
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
void YSChoiAbaqusReader::execute()
{
dataCheck();
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
int xpoints, ypoints, zpoints, totalpoints = 0;
float resx, resy, resz;
float** *mat = NULL;
//const unsigned int size(1024);
// Read header from data file to figure out how many points there are
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
QString word;
bool ok = false;
bool headerdone = false;
while (headerdone == false)
{
QByteArray buf = in.readLine();
if (buf.startsWith(DIMS))
{
QList<QByteArray> tokens = buf.split(' ');
xpoints = tokens[1].toInt(&ok, 10);
ypoints = tokens[2].toInt(&ok, 10);
zpoints = tokens[3].toInt(&ok, 10);
totalpoints = xpoints * ypoints * zpoints;
size_t dims[3] = { static_cast<size_t>(xpoints), static_cast<size_t>(ypoints), static_cast<size_t>(zpoints) };
m->getGeometryAs<ImageGeom>()->setDimensions(dims);
m->getGeometryAs<ImageGeom>()->setOrigin(0, 0, 0);
}
if (buf.startsWith(RES))
{
QList<QByteArray> tokens = buf.split(' ');
resx = tokens[1].toInt(&ok, 10);
resy = tokens[2].toInt(&ok, 10);
resz = tokens[3].toInt(&ok, 10);
float res[3] = {resx, resy, resz};
m->getGeometryAs<ImageGeom>()->setResolution(res);
}
if (buf.startsWith(LOOKUP))
{
headerdone = true;
word = QString(buf);
}
}
// Read header from grain info file to figure out how many features there are
QFile in2(getInputFeatureInfoFile());
if (!in2.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus Feature Info file could not be opened: %1").arg(getInputFeatureInfoFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
int numfeatures;
QByteArray buf = in2.readLine();
numfeatures = buf.toInt(&ok, 10);
buf = in2.readLine();
QList<QByteArray> tokens = buf.split(' ');
// in2 >> word >> word >> word >> word >> word >> word;
QVector<size_t> tDims(3, 0);
tDims[0] = xpoints;
tDims[1] = ypoints;
tDims[2] = zpoints;
m->getAttributeMatrix(getCellAttributeMatrixName())->resizeAttributeArrays(tDims);
tDims.resize(1);
tDims[0] = numfeatures + 1;
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
tDims[0] = 2;
m->getAttributeMatrix(getCellEnsembleAttributeMatrixName())->resizeAttributeArrays(tDims);
updateCellInstancePointers();
updateFeatureInstancePointers();
updateEnsembleInstancePointers();
//Read data file
int gnum = 0;
bool onedge = false;
int col, row, plane;
float value;
for (int i = 0; i < totalpoints; i++)
{
mat[i] = new float *[3];
for(int j = 0; j < 3; j++)
{
mat[i][j] = new float [3];
}
onedge = false;
gnum = tokens[6].toInt(&ok, 10);
col = i % xpoints;
row = (i / xpoints) % ypoints;
plane = i / (xpoints * ypoints);
if (col == 0 || col == (xpoints - 1) || row == 0 || row == (ypoints - 1) || plane == 0 || plane == (zpoints - 1)) { onedge = true; }
m_FeatureIds[i] = gnum;
m_SurfaceFeatures[gnum] = onedge;
}
for (int iter1 = 0; iter1 < 3; iter1++)
{
for (int iter2 = 0; iter2 < 3; iter2++)
{
headerdone = false;
while (headerdone == false)
{
buf = in2.readLine();
if (buf.startsWith(LOOKUP))
{
headerdone = true;
//in >> word;
}
}
for (int i = 0; i < totalpoints; i++)
{
onedge = 0;
value = buf.toInt(&ok, 10);
mat[i][iter1][iter2] = value;
}
}
}
//Read feature info
QuatF* avgQuats = reinterpret_cast<QuatF*>(m_AvgQuats);
avgQuats[0].x = 0.0;
avgQuats[0].y = 0.0;
avgQuats[0].z = 0.0;
avgQuats[0].w = 0.0;
for (int i = 1; i < numfeatures + 1; i++)
{
buf = in2.readLine();
tokens = buf.split(' ');
gnum = tokens[0].toInt(&ok, 10);
avgQuats[i].x = tokens[2].toFloat(&ok);
avgQuats[i].y = tokens[3].toFloat(&ok);
avgQuats[i].z = tokens[4].toFloat(&ok);
avgQuats[i].w = tokens[5].toFloat(&ok);
}
QuatF q;
QuatF* quats = reinterpret_cast<QuatF*>(m_Quats);
float g[3][3];
for(int i = 0; i < (xpoints * ypoints * zpoints); i++)
{
for(int j = 0; j < 3; j++)
{
for(int k = 0; k < 3; k++)
{
g[j][k] = mat[i][j][k];
}
}
MatrixMath::Normalize3x3(g);
q.w = static_cast<float>( sqrt((1.0 + g[0][0] + g[1][1] + g[2][2])) / 2.0 );
q.x = static_cast<float>( (g[1][2] - g[2][1]) / (4.0 * q.w) );
q.y = static_cast<float>( (g[2][0] - g[0][2]) / (4.0 * q.w) );
q.z = static_cast<float>( (g[0][1] - g[1][0]) / (4.0 * q.w) );
QuaternionMathF::Copy(q, quats[i]);
FOrientArrayType eu(m_CellEulerAngles + (3 * i), 3);
FOrientTransformsType::qu2eu(FOrientArrayType(q), eu);
delete[] mat[i];
}
delete[] mat;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSections::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t udims[3] = { 0, 0, 0 };
m->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]),
};
DimType slice = 0;
DimType xspot = 0, yspot = 0;
DimType newPosition = 0;
DimType currentPosition = 0;
std::vector<int64_t> xshifts(dims[2], 0);
std::vector<int64_t> yshifts(dims[2], 0);
find_shifts(xshifts, yshifts);
if (getSubtractBackground())
{
/**fit x and y shifts to lines
*
* y = mx + b
*
* m = (n*sum(x_i * y_i) - sum(x_i) * sum(y_i)) / (n*sum(x_i^2)-sum(x_i)^2
*
* b = (sum(y_i)-m*sum(x_i))/n
*
*/
// same for both
double sumX = 0.0; // sum(x_i)
double sumX_2 = 0.0; // sum(x_i^2)
// x shift line
double x_sumY = 0.0; // sum(y_i)
double x_sumXY = 0.0; // sum(x_i * y_i)
// y shift line
double y_sumY = 0.0; // sum(y_i)
double y_sumXY = 0.0; // sum(x_i * y_i)
for (DimType iter = 0; iter < dims[2]; iter++)
{
slice = static_cast<DimType>( (dims[2] - 1) - iter );
sumX = static_cast<double>(sumX + iter);
sumX_2 = static_cast<double>(sumX_2 + iter * iter);
x_sumY = static_cast<double>(x_sumY + xshifts[iter]);
x_sumXY = static_cast<double>(x_sumXY + iter * xshifts[iter]);
y_sumY = static_cast<double>(y_sumY + yshifts[iter]);
y_sumXY = static_cast<double>(y_sumXY + iter * yshifts[iter]);
}
double mx = static_cast<double>((dims[2] * x_sumXY - x_sumXY) / (dims[2] * sumX_2 - sumX));
double my = static_cast<double>((dims[2] * y_sumXY - y_sumXY) / (dims[2] * sumX_2 - sumX));
// adjust shifts so that fit line has 0 slope (~ends of the sample are fixed)
for (DimType iter = 1; iter < dims[2]; iter++)
{
slice = (dims[2] - 1) - iter;
xshifts[iter] = static_cast<int64_t>(xshifts[iter] - iter * mx);
yshifts[iter] = static_cast<int64_t>(yshifts[iter] - iter * my);
}
}
QList<QString> voxelArrayNames = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArrayNames();
DimType progIncrement = dims[2] / 100;
DimType prog = 1;
DimType progressInt = 0;
for (DimType i = 1; i < dims[2]; i++)
{
if (i > prog)
{
progressInt = ((float)i / dims[2]) * 100.0f;
QString ss = QObject::tr("Transferring Cell Data || %1% Complete").arg(progressInt);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
prog = prog + progIncrement;
}
if (getCancel() == true)
{
return;
}
slice = (dims[2] - 1) - i;
for (DimType l = 0; l < dims[1]; l++)
{
for (DimType n = 0; n < dims[0]; n++)
{
if (yshifts[i] >= 0) { yspot = l; }
else if (yshifts[i] < 0) { yspot = dims[1] - 1 - l; }
if (xshifts[i] >= 0) { xspot = n; }
else if (xshifts[i] < 0) { xspot = dims[0] - 1 - n; }
newPosition = (slice * dims[0] * dims[1]) + (yspot * dims[0]) + xspot;
currentPosition = (slice * dims[0] * dims[1]) + ((yspot + yshifts[i]) * dims[0]) + (xspot + xshifts[i]);
if ((yspot + yshifts[i]) >= 0 && (yspot + yshifts[i]) <= dims[1] - 1 && (xspot + xshifts[i]) >= 0
&& (xspot + xshifts[i]) <= dims[0] - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
p->copyTuple(currentPosition, newPosition);
}
}
if ((yspot + yshifts[i]) < 0 || (yspot + yshifts[i]) > dims[1] - 1 || (xspot + xshifts[i]) < 0
|| (xspot + xshifts[i]) > dims[0] - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
p->initializeTuple(newPosition, 0);
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
