// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MultiOtsuThreshold::execute()
{
//int err = 0;
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
QString attrMatName = getSelectedCellArrayPath().getAttributeMatrixName();
//get dims
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]),
};
//wrap input as itk image
ImageProcessing::DefaultImageType::Pointer inputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_SelectedCellArray);
if(m_Slice)
{
//define 2d histogram generator
typedef itk::OtsuMultipleThresholdsImageFilter< ImageProcessing::DefaultSliceType, ImageProcessing::DefaultSliceType > ThresholdType;
ThresholdType::Pointer otsuThresholder = ThresholdType::New();
//wrap output buffer as image
ImageProcessing::DefaultImageType::Pointer outputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_NewCellArray);
//loop over slices
for(int i = 0; i < dims[2]; i++)
{
//get slice
ImageProcessing::DefaultSliceType::Pointer slice = ITKUtilitiesType::ExtractSlice(inputImage, ImageProcessing::ZSlice, i);
//threshold
otsuThresholder->SetInput(slice);
otsuThresholder->SetNumberOfThresholds(m_Levels);
otsuThresholder->SetLabelOffset(1);
//execute filters
try
{
otsuThresholder->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::OtsuMultipleThresholdsImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
//copy back into volume
ITKUtilitiesType::SetSlice(outputImage, otsuThresholder->GetOutput(), ImageProcessing::ZSlice, i);
}
}
else
{
typedef itk::OtsuMultipleThresholdsImageFilter< ImageProcessing::DefaultImageType, ImageProcessing::DefaultImageType > ThresholdType;
ThresholdType::Pointer otsuThresholder = ThresholdType::New();
otsuThresholder->SetInput(inputImage);
otsuThresholder->SetNumberOfThresholds(m_Levels);
otsuThresholder->SetLabelOffset(1);
ITKUtilitiesType::SetITKFilterOutput(otsuThresholder->GetOutput(), m_NewCellArrayPtr.lock());
//execute filters
try
{
otsuThresholder->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::OtsuMultipleThresholdsImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
//array name changing/cleanup
if(m_SaveAsNewArray == false)
{
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(m_SelectedCellArrayPath.getAttributeMatrixName());
attrMat->removeAttributeArray(m_SelectedCellArrayPath.getDataArrayName());
attrMat->renameAttributeArray(m_NewCellArrayName, m_SelectedCellArrayPath.getDataArrayName());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SobelEdge::execute()
{
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
QString attrMatName = getSelectedCellArrayPath().getAttributeMatrixName();
//wrap m_RawImageData as itk::image
ImageProcessing::DefaultImageType::Pointer inputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_SelectedCellArray);
if(m_Slice)
{
//wrap output array
ImageProcessing::DefaultImageType::Pointer outputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_NewCellArray);
//get dimensions
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]),
};
//create edge filter
typedef itk::SobelEdgeDetectionImageFilter<ImageProcessing::DefaultSliceType, ImageProcessing::FloatSliceType> SobelFilterType;
SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
//convert result back to uint8
typedef itk::RescaleIntensityImageFilter<ImageProcessing::FloatSliceType, ImageProcessing::DefaultSliceType> RescaleImageType;
RescaleImageType::Pointer rescaleFilter = RescaleImageType::New();
rescaleFilter->SetOutputMinimum(0);
rescaleFilter->SetOutputMaximum(255);
//loop over slices applying filters
for(int i = 0; i < dims[2]; ++i)
{
QString ss = QObject::tr("Finding Edges On Slice: %1").arg(i + 1);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
//get slice
ImageProcessing::DefaultSliceType::Pointer inputSlice = ITKUtilitiesType::ExtractSlice(inputImage, ImageProcessing::ZSlice, i);
//run filters
sobelFilter->SetInput(inputSlice);
rescaleFilter->SetInput(sobelFilter->GetOutput());
//execute filters
try
{
sobelFilter->Update();
rescaleFilter->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::SobelEdgeDetectionImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
//copy into volume
ITKUtilitiesType::SetSlice(outputImage, rescaleFilter->GetOutput(), ImageProcessing::ZSlice, i);
}
}
else
{
//create edge filter
typedef itk::SobelEdgeDetectionImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType> SobelFilterType;
SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
sobelFilter->SetInput(inputImage);
//convert result back to uint8
typedef itk::RescaleIntensityImageFilter<ImageProcessing::FloatImageType, ImageProcessing::DefaultImageType> RescaleImageType;
RescaleImageType::Pointer rescaleFilter = RescaleImageType::New();
rescaleFilter->SetInput(sobelFilter->GetOutput());
rescaleFilter->SetOutputMinimum(0);
rescaleFilter->SetOutputMaximum(255);
//have filter write to dream3d array instead of creating its own buffer
ITKUtilitiesType::SetITKFilterOutput(rescaleFilter->GetOutput(), m_NewCellArrayPtr.lock());
//execute filters
try
{
sobelFilter->Update();
rescaleFilter->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::SobelEdgeDetectionImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
//array name changing/cleanup
if(m_SaveAsNewArray == false)
{
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(m_SelectedCellArrayPath.getAttributeMatrixName());
attrMat->removeAttributeArray(m_SelectedCellArrayPath.getDataArrayName());
attrMat->renameAttributeArray(m_NewCellArrayName, m_SelectedCellArrayPath.getDataArrayName());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ImageMath::execute()
{
//int err = 0;
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
QString attrMatName = getSelectedCellArrayPath().getAttributeMatrixName();
//wrap m_RawImageData as itk::image
ImageProcessing::DefaultImageType::Pointer inputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_SelectedCellArray);
//define filter types
typedef itk::AddImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> AddType;
typedef itk::SubtractImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> SubtractType;
typedef itk::MultiplyImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> MultiplyType;
typedef itk::DivideImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> DivideType;
typedef itk::MinimumImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> MinType;
typedef itk::MaximumImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType> MaxType;
typedef itk::BinaryFunctorImageFilter< ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType, ImageProcessing::FloatImageType, ImageProcessing::Functor::Gamma<ImageProcessing::FloatPixelType> > GammaType;
typedef itk::LogImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType> LogType;
typedef itk::ExpImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType> ExpType;
typedef itk::SquareImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType> SquareType;
typedef itk::SqrtImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::FloatImageType> SqrtType;
typedef itk::InvertIntensityImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::DefaultImageType> InvertType;
//set up filter to cap image range + round
typedef itk::UnaryFunctorImageFilter< ImageProcessing::FloatImageType, ImageProcessing::DefaultImageType, ImageProcessing::Functor::LimitsRound<ImageProcessing::FloatPixelType, ImageProcessing::DefaultPixelType> > LimitsRoundType;
LimitsRoundType::Pointer limitsRound = LimitsRoundType::New();
//apply selected operation
switch(m_Operator)
{
case 0://add
{
AddType::Pointer add = AddType::New();
add->SetInput1(inputImage);
add->SetConstant2(m_Value);
limitsRound->SetInput(add->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 1://subtract
{
SubtractType::Pointer subtract = SubtractType::New();
subtract->SetInput1(inputImage);
subtract->SetConstant2(m_Value);
limitsRound->SetInput(subtract->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 2://multiply
{
MultiplyType::Pointer multiply = MultiplyType::New();
multiply->SetInput1(inputImage);
multiply->SetConstant2(m_Value);
limitsRound->SetInput(multiply->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 3://divide
{
DivideType::Pointer divide = DivideType::New();
divide->SetInput1(inputImage);
divide->SetConstant2(m_Value);
limitsRound->SetInput(divide->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 4://min
{
MinType::Pointer minimum = MinType::New();
minimum->SetInput1(inputImage);
minimum->SetConstant2(m_Value);
limitsRound->SetInput(minimum->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 5://max
{
MaxType::Pointer maximum = MaxType::New();
maximum->SetInput1(inputImage);
maximum->SetConstant2(m_Value);
limitsRound->SetInput(maximum->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 6://gamma
{
GammaType::Pointer gamma = GammaType::New();
gamma->SetInput1(inputImage);
gamma->SetConstant2(m_Value);
limitsRound->SetInput(gamma->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 7://log
{
LogType::Pointer logfilter = LogType::New();
logfilter->SetInput(inputImage);
limitsRound->SetInput(logfilter->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 8://exp
{
ExpType::Pointer expfilter = ExpType::New();
expfilter->SetInput(inputImage);
limitsRound->SetInput(expfilter->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 9://square
{
SquareType::Pointer square = SquareType::New();
square->SetInput(inputImage);
limitsRound->SetInput(square->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 10://squareroot
{
SqrtType::Pointer sqrtfilter = SqrtType::New();
sqrtfilter->SetInput(inputImage);
limitsRound->SetInput(sqrtfilter->GetOutput());
ITKUtilitiesType::SetITKFilterOutput(limitsRound->GetOutput(), m_NewCellArrayPtr.lock());
limitsRound->Update();
}
break;
case 11://invert
{
InvertType::Pointer invert = InvertType::New();
invert->SetInput(inputImage);
ITKUtilitiesType::SetITKFilterOutput(invert->GetOutput(), m_NewCellArrayPtr.lock());
invert->Update();
}
break;
}
//array name changing/cleanup
if(m_SaveAsNewArray == false)
{
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(m_SelectedCellArrayPath.getAttributeMatrixName());
attrMat->removeAttributeArray(m_SelectedCellArrayPath.getDataArrayName());
attrMat->renameAttributeArray(m_NewCellArrayName, m_SelectedCellArrayPath.getDataArrayName());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
