// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveFlaggedFeatures::assign_badpoints()
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_FeatureIdsArrayPath.getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
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]),
};
Int32ArrayType::Pointer neighborsPtr = Int32ArrayType::CreateArray(totalPoints, "_INTERNAL_USE_ONLY_Neighbors");
m_Neighbors = neighborsPtr->getPointer(0);
neighborsPtr->initializeWithValue(-1);
int32_t good = 1;
int32_t current = 0;
int32_t most = 0;
int64_t neighpoint = 0;
DimType neighpoints[6];
neighpoints[0] = -dims[0] * dims[1];
neighpoints[1] = -dims[0];
neighpoints[2] = -1;
neighpoints[3] = 1;
neighpoints[4] = dims[0];
neighpoints[5] = dims[0] * dims[1];
size_t counter = 1;
int64_t count = 0;
int64_t kstride = 0, jstride = 0;
int32_t featurename, feature;
int32_t neighbor;
QVector<int32_t> n(m_FlaggedFeaturesPtr.lock()->getNumberOfTuples(), 0);
while (counter != 0)
{
counter = 0;
for (DimType k = 0; k < dims[2]; k++)
{
kstride = dims[0] * dims[1] * k;
for (DimType j = 0; j < dims[1]; j++)
{
jstride = dims[0] * j;
for (DimType i = 0; i < dims[0]; i++)
{
count = kstride + jstride + i;
featurename = m_FeatureIds[count];
if (featurename < 0)
{
counter++;
current = 0;
most = 0;
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (feature >= 0)
{
n[feature]++;
current = n[feature];
if (current > most)
{
most = current;
m_Neighbors[count] = neighpoint;
}
}
}
}
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (feature >= 0) { n[feature] = 0; }
}
}
}
}
}
}
QString attrMatName = m_FeatureIdsArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
for (size_t j = 0; j < totalPoints; j++)
{
featurename = m_FeatureIds[j];
neighbor = m_Neighbors[j];
if (neighbor >= 0)
{
if (featurename < 0 && m_FeatureIds[neighbor] >= 0)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->copyTuple(neighbor, j);
}
}
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ErodeDilateBadData::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getFeatureIdsArrayPath().getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
Int32ArrayType::Pointer neighborsPtr = Int32ArrayType::CreateArray(totalPoints, "_INTERNAL_USE_ONLY_Neighbors");
m_Neighbors = neighborsPtr->getPointer(0);
neighborsPtr->initializeWithValue(-1);
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]),
};
int32_t good = 1;
int64_t count = 0;
int64_t kstride = 0, jstride = 0;
int32_t featurename = 0, feature = 0;
int32_t current = 0;
int32_t most = 0;
int64_t neighpoint = 0;
size_t numfeatures = 0;
for (size_t i = 0; i < totalPoints; i++)
{
featurename = m_FeatureIds[i];
if (featurename > numfeatures) { numfeatures = featurename; }
}
DimType neighpoints[6] = { 0, 0, 0, 0, 0, 0 };
neighpoints[0] = -dims[0] * dims[1];
neighpoints[1] = -dims[0];
neighpoints[2] = -1;
neighpoints[3] = 1;
neighpoints[4] = dims[0];
neighpoints[5] = dims[0] * dims[1];
QVector<int32_t> n(numfeatures + 1, 0);
for (int32_t iteration = 0; iteration < m_NumIterations; iteration++)
{
for (DimType k = 0; k < dims[2]; k++)
{
kstride = dims[0] * dims[1] * k;
for (DimType j = 0; j < dims[1]; j++)
{
jstride = dims[0] * j;
for (DimType i = 0; i < dims[0]; i++)
{
count = kstride + jstride + i;
featurename = m_FeatureIds[count];
if (featurename == 0)
{
current = 0;
most = 0;
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && (k == 0 || m_ZDirOn == false)) { good = 0; }
else if (l == 5 && (k == (dims[2] - 1) || m_ZDirOn == false)) { good = 0; }
else if (l == 1 && (j == 0 || m_YDirOn == false)) { good = 0; }
else if (l == 4 && (j == (dims[1] - 1) || m_YDirOn == false)) { good = 0; }
else if (l == 2 && (i == 0 || m_XDirOn == false)) { good = 0; }
else if (l == 3 && (i == (dims[0] - 1) || m_XDirOn == false)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (m_Direction == 0 && feature > 0)
{
m_Neighbors[neighpoint] = count;
}
if (feature > 0 && m_Direction == 1)
{
n[feature]++;
current = n[feature];
if (current > most)
{
most = current;
m_Neighbors[count] = neighpoint;
}
}
}
}
if (m_Direction == 1)
{
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
n[feature] = 0;
}
}
}
}
}
}
}
QString attrMatName = m_FeatureIdsArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
for (size_t j = 0; j < totalPoints; j++)
{
featurename = m_FeatureIds[j];
int32_t neighbor = m_Neighbors[j];
if (neighbor >= 0)
{
if ( (featurename == 0 && m_FeatureIds[neighbor] > 0 && m_Direction == 1)
|| (featurename > 0 && m_FeatureIds[neighbor] == 0 && m_Direction == 0))
{
for(QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->copyTuple(neighbor, j);
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 ErodeDilateCoordinationNumber::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getFeatureIdsArrayPath().getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
Int32ArrayType::Pointer neighborsPtr = Int32ArrayType::CreateArray(totalPoints, "Neighbors");
m_Neighbors = neighborsPtr->getPointer(0);
neighborsPtr->initializeWithValue(-1);
size_t udims[3] = {0, 0, 0};
m->getGeometryAs<ImageGeom>()->getDimensions(udims);
int64_t dims[3] =
{
static_cast<int64_t>(udims[0]),
static_cast<int64_t>(udims[1]),
static_cast<int64_t>(udims[2]),
};
int32_t good = 1;
int64_t point = 0;
int64_t kstride = 0, jstride = 0;
int32_t featurename = 0, feature = 0;
int32_t coordination = 0;
int32_t current = 0;
int32_t most = 0;
int64_t neighpoint = 0;
size_t numfeatures = 0;
for(size_t i = 0; i < totalPoints; i++)
{
featurename = m_FeatureIds[i];
if (featurename > numfeatures) { numfeatures = featurename; }
}
int64_t neighpoints[6] = { 0, 0, 0, 0, 0, 0 };
neighpoints[0] = -dims[0] * dims[1];
neighpoints[1] = -dims[0];
neighpoints[2] = -1;
neighpoints[3] = 1;
neighpoints[4] = dims[0];
neighpoints[5] = dims[0] * dims[1];
QString attrMatName = m_FeatureIdsArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
QVector<int32_t> n(numfeatures + 1, 0);
QVector<int32_t> coordinationNumber(totalPoints, 0);
bool keepgoing = true;
int32_t counter = 1;
while (counter > 0 && keepgoing == true)
{
counter = 0;
if (m_Loop == false) { keepgoing = false; }
for (int64_t k = 0; k < dims[2]; k++)
{
kstride = dims[0] * dims[1] * k;
for (int64_t j = 0; j < dims[1]; j++)
{
jstride = dims[0] * j;
for (int64_t i = 0; i < dims[0]; i++)
{
point = kstride + jstride + i;
featurename = m_FeatureIds[point];
coordination = 0;
current = 0;
most = 0;
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = point + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if ((featurename > 0 && feature == 0) || (featurename == 0 && feature > 0))
{
coordination = coordination + 1;
n[feature]++;
current = n[feature];
if (current > most)
{
most = current;
m_Neighbors[point] = neighpoint;
}
}
}
}
coordinationNumber[point] = coordination;
int32_t neighbor = m_Neighbors[point];
if (coordinationNumber[point] >= m_CoordinationNumber && coordinationNumber[point] > 0)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->copyTuple(neighbor, point);
}
}
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = point + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (feature > 0) { n[feature] = 0; }
}
}
}
}
}
for (int64_t k = 0; k < dims[2]; k++)
{
kstride = static_cast<int64_t>(dims[0] * dims[1] * k);
for (int64_t j = 0; j < dims[1]; j++)
{
jstride = static_cast<int64_t>(dims[0] * j);
for (int64_t i = 0; i < dims[0]; i++)
{
point = kstride + jstride + i;
if (coordinationNumber[point] >= m_CoordinationNumber)
{
counter++;
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CropImageGeometry::execute()
{
setErrorCondition(0);
/* Normally, filters call dataCheck during the execute to reuse code. Unfortunately, this cannot happen for this filter, because calling dataCheck
would destroy an Attribute Matrix that we need during the execute. Do not uncomment the code, and be careful when reusing code from either of
these functions. Make sure you understand how this works before you reuse any code. */
//dataCheck();
//if(getErrorCondition() < 0) { return; }
DataContainer::Pointer srcCellDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName());
AttributeMatrix::Pointer cellAttrMat = srcCellDataContainer->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
DataContainer::Pointer destCellDataContainer = srcCellDataContainer;
if (m_SaveAsNewDataContainer == true)
{
float ox = 0.0f, oy = 0.0f, oz = 0.0f, rx = 0.0f, ry = 0.0f, rz = 0.0f;
srcCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(ox, oy, oz);
srcCellDataContainer->getGeometryAs<ImageGeom>()->getResolution(rx, ry, rz);
destCellDataContainer = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getNewDataContainerName());
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
destCellDataContainer->setGeometry(image);
destCellDataContainer->getGeometryAs<ImageGeom>()->setOrigin(ox, oy, oz);
destCellDataContainer->getGeometryAs<ImageGeom>()->setResolution(rx, ry, rz);
AttributeMatrix::Pointer cellAttrMatCopy = cellAttrMat->deepCopy();
destCellDataContainer->addAttributeMatrix(cellAttrMatCopy->getName(), cellAttrMatCopy);
cellAttrMat = destCellDataContainer->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
}
if(NULL == destCellDataContainer.get() || NULL == cellAttrMat.get() || getErrorCondition() < 0)
{
return;
}
// No matter where the AM is (same DC or new DC), we have the correct DC and AM pointers...now it's time to crop
int64_t totalPoints = cellAttrMat->getNumTuples();
size_t udims[3] =
{ 0, 0, 0 };
srcCellDataContainer->getGeometryAs<ImageGeom>()->getDimensions(udims);
#if (CMP_SIZEOF_SIZE_T == 4)
typedef int32_t DimType;
#else
typedef int64_t DimType;
#endif
DimType dims[3] =
{ static_cast<DimType>(udims[0]), static_cast<DimType>(udims[1]), static_cast<DimType>(udims[2]), };
// Check to see if the dims have actually changed.
if(dims[0] == (m_XMax - m_XMin) && dims[1] == (m_YMax - m_YMin) && dims[2] == (m_ZMax - m_ZMin))
{
return;
}
// Get current origin
float oldOrigin[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(oldOrigin);
// Check to make sure the new dimensions are not "out of bounds" and warn the user if they are
if (dims[0] <= m_XMax)
{
QString ss = QObject::tr("The Max X value (%1) is greater than the Image Geometry X entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_XMax).arg(dims[0]);
setErrorCondition(-950);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if (dims[1] <= m_YMax)
{
QString ss = QObject::tr("The Max Y value (%1) is greater than the Image Geometry Y entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_YMax).arg(dims[1]);
setErrorCondition(-951);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if (dims[2] <= m_ZMax)
{
QString ss = QObject::tr("The Max Z value (%1) is greater than the Image Geometry Z entent (%2)."
" This may lead to junk data being filled into the extra space.").arg(m_ZMax).arg(dims[2]);
setErrorCondition(-952);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
int64_t XP = ( (m_XMax - m_XMin) + 1 );
int64_t YP = ( (m_YMax - m_YMin) + 1 );
int64_t ZP = ( (m_ZMax - m_ZMin) + 1 );
int64_t col = 0, row = 0, plane = 0;
int64_t colold = 0, rowold = 0, planeold = 0;
int64_t index = 0;
int64_t index_old = 0;
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (int64_t i = 0; i < ZP; i++)
{
QString ss = QObject::tr("Cropping Volume - Slice %1 of %2 Complete").arg(i).arg(ZP);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
planeold = (i + m_ZMin) * (srcCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints() * srcCellDataContainer->getGeometryAs<ImageGeom>()->getYPoints());
plane = (i * XP * YP);
for (int64_t j = 0; j < YP; j++)
{
rowold = (j + m_YMin) * srcCellDataContainer->getGeometryAs<ImageGeom>()->getXPoints();
row = (j * XP);
for (int64_t k = 0; k < XP; k++)
{
colold = (k + m_XMin);
col = k;
index_old = planeold + rowold + colold;
index = plane + row + col;
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
p->copyTuple(index_old, index);
}
}
}
}
destCellDataContainer->getGeometryAs<ImageGeom>()->setDimensions(static_cast<size_t>(XP), static_cast<size_t>(YP), static_cast<size_t>(ZP));
totalPoints = destCellDataContainer->getGeometryAs<ImageGeom>()->getNumberOfElements();
QVector<size_t> tDims(3, 0);
tDims[0] = XP;
tDims[1] = YP;
tDims[2] = ZP;
cellAttrMat->setTupleDimensions(tDims); // THIS WILL CAUSE A RESIZE of all the underlying data arrays.
if (m_RenumberFeatures == true)
{
totalPoints = destCellDataContainer->getGeometryAs<ImageGeom>()->getNumberOfElements();
// This just sanity checks to make sure there were existing features before the cropping
AttributeMatrix::Pointer cellFeatureAttrMat = srcCellDataContainer->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
size_t totalFeatures = cellFeatureAttrMat->getNumTuples();
QVector<bool> activeObjects(totalFeatures, false);
if (0 == totalFeatures)
{
setErrorCondition(-600);
notifyErrorMessage(getHumanLabel(), "The number of Features is 0 and should be greater than 0", getErrorCondition());
return;
}
//QVector<size_t> cDims(1, 1);
DataArrayPath dap = getFeatureIdsArrayPath();
if(getSaveAsNewDataContainer())
{
dap.setDataContainerName(getNewDataContainerName());
}
m_FeatureIdsPtr = cellAttrMat->getAttributeArrayAs<Int32ArrayType>(dap.getDataArrayName()); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
else
{
setErrorCondition(-601);
QString ss = QObject::tr("The FeatureIds array with name '%1' was not found in the destination DataContainer. The expected path was '%2'")
.arg(dap.getDataArrayName()).arg(dap.serialize("/"));
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
// Find the unique set of feature ids
for (int64_t i = 0; i < totalPoints; ++i)
{
int32_t currentFeatureId = m_FeatureIds[i];
if (currentFeatureId < totalFeatures)
{
activeObjects[currentFeatureId] = true;
}
else
{
setErrorCondition(-601);
QString ss = QObject::tr("The total number of Features from %1 is %2, but a value of %3 was found in DataArray %4.").arg(cellFeatureAttrMat->getName()).arg(totalFeatures).arg(currentFeatureId).arg(getFeatureIdsArrayPath().serialize("/"));
qDebug() << ss;
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
}
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
if(m_UpdateOrigin == true)
{
float resolution[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getResolution(resolution);
float origin[3] = {0.0f, 0.0f, 0.0f};
destCellDataContainer->getGeometryAs<ImageGeom>()->getOrigin(origin);
origin[0] = m_XMin * resolution[0] + oldOrigin[0];
origin[1] = m_YMin * resolution[1] + oldOrigin[1];
origin[2] = m_ZMin * resolution[2] + oldOrigin[2];
destCellDataContainer->getGeometryAs<ImageGeom>()->setOrigin(origin);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
