void Preprocess::OtsuBinarize(int num_thresholds, int num_in_foreground, bool fgrnd_dark)
{
//Create histogram:
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImageType3D > HistogramGeneratorType;
typedef HistogramGeneratorType::HistogramType HistogramType;
HistogramGeneratorType::Pointer histoGenerator = HistogramGeneratorType::New();
histoGenerator->SetNumberOfBins( 256 );
histoGenerator->SetInput( myImg );
try
{
histoGenerator->Compute();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << " Histogram Computation: exception caught !" << std::endl;
std::cerr << excep << std::endl;
return;
}
//Estimate thresholds:
typedef itk::OtsuMultipleThresholdsCalculator< HistogramType > CalculatorType;
CalculatorType::Pointer calculator = CalculatorType::New();
calculator->SetNumberOfThresholds( num_thresholds );
calculator->SetInputHistogram( histoGenerator->GetOutput() );
try
{
calculator->Update();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << " Otsu Computation: exception caught !" << std::endl;
std::cerr << excep << std::endl;
return;
}
const CalculatorType::OutputType &thresholdVector = calculator->GetOutput();
//Estimate Binarization thresholds:
PixelType lowerThreshold,upperThreshold;
if( fgrnd_dark ) //Do I want to make the foregound of the binary dark:
{
CalculatorType::OutputType::const_iterator itNum = thresholdVector.end();
for( int i=0; i<(num_thresholds-num_in_foreground+1); ++i )
--itNum;
upperThreshold = static_cast<PixelType>(*itNum);
lowerThreshold = itk::NumericTraits<PixelType>::min();
}
else
{
CalculatorType::OutputType::const_iterator itNum = thresholdVector.begin();
for( int i=0; i<(num_thresholds-num_in_foreground); ++i )
++itNum;
lowerThreshold = static_cast<PixelType>(*itNum);
upperThreshold = itk::NumericTraits<PixelType>::max();
}
//std::cerr << "Binarization Thresholds: " << lowerThreshold << " " << upperThreshold << std::endl;
typedef itk::BinaryThresholdImageFilter< ImageType3D, ImageType3D > ThreshFilterType;
ThreshFilterType::Pointer threshfilter = ThreshFilterType::New();
threshfilter->SetOutsideValue( 0 );
threshfilter->SetInsideValue( (int)itk::NumericTraits<PixelType>::max() );
threshfilter->SetInput( myImg );
threshfilter->SetLowerThreshold( lowerThreshold );
threshfilter->SetUpperThreshold( upperThreshold );
try
{
threshfilter->Update();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << " Threshold: exception caught !" << std::endl;
std::cerr << excep << std::endl;
return;
}
myImg = threshfilter->GetOutput();
}
void MriWatcherGUI::LoadFile(const QString& filename)
{
ReaderType::Pointer reader = ReaderType::New();
ImageType::Pointer image = reader->GetOutput();
reader->SetFileName( filename.toLatin1().constData() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & e )
{
// std::cerr << "Exception in file reader " << std::endl;
// std::cerr << e << std::endl;
QMessageBox::information( this, "MriWatcher",
"Unable to load file:\n" + filename);
return;
}
m_numberofimages++;
ImageFrameGUI* m_imageframe = new ImageFrameGUI(m_frame);
connect(m_imageframe->g_imageframe, SIGNAL( Clicked(int) ), this, SLOT( ImageFrameClicked() ) );
connect(m_imageframe, SIGNAL( GetFiles(const QString &) ), this, SLOT( LoadOverlay(const QString &) ) );
m_imageframe->g_imageframe->SetManager(&m_imagemanager);
m_imageframe->g_imageframe->SetSlider(g_slice_slider);
m_imageframe->g_imageframe->SetId(m_direction);
QFileInfo info(filename);
m_imageframe->g_imageframe->SetImageName(info.baseName() );
m_imageframe->g_imageframe->DrawPosition(g_draw_position->isChecked() );
m_imageframe->g_imageframe->DrawIntensity(g_draw_intensity->isChecked() );
// This string should only be used for display purposes it is not
// safe to use this for comparison of types
// QString pixeltypestring(reader->GetImageIO()->GetComponentTypeInfo().name());
QString pixeltypestring(QString::fromStdString(reader->GetImageIO()->GetComponentTypeAsString(
reader->GetImageIO()->GetComponentType() ) ) );
m_imageframe->g_imageframe->DrawImageName(g_draw_name->isChecked() );
m_imagesize = image->GetLargestPossibleRegion().GetSize();
m_imagespacing = image->GetSpacing();
int m_cimagesize[3];
m_cimagesize[0] = m_imagesize[0];
m_cimagesize[1] = m_imagesize[1];
m_cimagesize[2] = m_imagesize[2];
float m_cpixdim[3];
m_cpixdim[0] = m_imagespacing[0];
m_cpixdim[1] = m_imagespacing[1];
m_cpixdim[2] = m_imagespacing[2];
m_imageframe->g_imageframe->SetImageInfo(m_cimagesize, m_cpixdim, pixeltypestring);
m_imageframe->g_imageframe->DrawImageInfo(g_draw_info->isChecked() );
typedef MinimumMaximumImageCalculator<ImageType> CalculatorType;
CalculatorType::Pointer calculator = CalculatorType::New();
calculator->SetImage(image);
calculator->Compute();
ImageType::PixelType m_min = calculator->GetMinimum();
ImageType::PixelType m_max = calculator->GetMaximum();
if( m_max > m_imagemax )
{
m_imagemax = m_max;
}
if( m_min < m_imagemin )
{
m_imagemin = m_min;
}
m_imageframe->g_imageframe->SetImageMinMax(m_min, m_max);
if( m_numberofimages == 1 )
{
m_imagemanager.SetSourceImage(image);
}
m_imageframe->g_imageframe->SetInputImage(image);
m_imageframe->g_imageframe->ChangeAlpha(100);
ReDraw();
g_slice_slider->setEnabled(true);
m_frame->setGeometry(QRect(m_frame->x(), m_frame->y(), m_frame->height(), m_frame->width() ) );
// gridLayout_imageWindows->addWidget(m_imageframe);
m_imageframelayout->addWidget(m_imageframe);
m_imageframelist.push_back(m_imageframe);
// m_imageframe->setLayout(m_imageframelayout);
m_imageframe->show();
// g_scrollArea->setWidget(m_imageframe);
if( m_imageframelist.size() == 1 )
{
m_imagemanager.SetCrosshair(m_imagesize[0] / 2, m_imagesize[1] / 2, m_imagesize[2] / 2);
}
else
{
m_imagemanager.UpdateCrosshair();
}
if( m_imagesize[0] > m_maxsize[0] )
{
m_maxsize[0] = m_imagesize[0];
}
if( m_imagesize[1] > m_maxsize[1] )
{
m_maxsize[1] = m_imagesize[1];
}
if( m_imagesize[2] > m_maxsize[2] )
{
m_maxsize[2] = m_imagesize[2];
}
UpdateLabel();
/*
if (!filename.isEmpty()) {
QImage image(filename);
if (image.isNull()) {
QMessageBox::information(this, tr("Image Viewer"),
tr("Cannot load %1.").arg(filename));
return;
}
// imageLabel->setPixmap(QPixmap::fromImage(image));
}
*/
}
void WholeCellSeg::BinarizationForRealBounds(){
if( !nuc_im_set || !cyt_im_set ){
std::cerr<<"Complete segmenting nuclei and set input imge before starting segmentation\n";
return;
}
itk::SizeValueType size1=cyt_im_inp->GetLargestPossibleRegion().GetSize()[0];
itk::SizeValueType size2=cyt_im_inp->GetLargestPossibleRegion().GetSize()[1];
if( ( size1 != nuclab_inp->GetLargestPossibleRegion().GetSize()[0] ) ||
( size2 != nuclab_inp->GetLargestPossibleRegion().GetSize()[1] ) )
{
std::cerr<<"The input images must be of the same size\n";
return;
}
typedef unsigned short int UShortPixelType;
typedef itk::ImageRegionIteratorWithIndex< UShortImageType > IteratorType;
typedef itk::ImageRegionConstIterator< UShortImageType > ConstIteratorType;
typedef itk::Statistics::ScalarImageToHistogramGenerator< IntImageType > ScalarImageToHistogramGeneratorType;
typedef ScalarImageToHistogramGeneratorType::HistogramType HistogramType;
typedef itk::OtsuMultipleThresholdsCalculator< HistogramType > CalculatorType;
typedef itk::RescaleIntensityImageFilter< UShortImageType, IntImageType > RescaleUsIntType;
typedef itk::RescaleIntensityImageFilter< UShortImageType, UShortImageType > RescaleUsUsType;
typedef itk::BinaryThresholdImageFilter< IntImageType, UShortImageType > ThreshFilterType;
typedef itk::BinaryThresholdImageFilter< UShortImageType, UShortImageType > ThresholdFilterType;
typedef itk::OrImageFilter< UShortImageType, UShortImageType, UShortImageType > OrFilterType;
typedef itk::BinaryBallStructuringElement< UShortPixelType, 2 > StructuringElementType;
typedef itk::BinaryErodeImageFilter< UShortImageType, UShortImageType, StructuringElementType > ErodeFilterType;
typedef itk::BinaryDilateImageFilter< UShortImageType, UShortImageType, StructuringElementType > DilateFilterType;
unsigned char *in_Image;
itk::SizeValueType ind=0;
//Call Yousef's binarization method if the number of bin levels is < 2
if( num_levels < 2 ){
bin_Image = (unsigned short *) malloc (size1*size2*sizeof(unsigned short));
for(itk::SizeValueType j=0; j<size2; ++j)
for(itk::SizeValueType i=0; i<size1; ++i)
BIN_Image(i,j)=255;
in_Image = (unsigned char *) malloc (size1*size2);
if( ( in_Image == NULL ) || ( bin_Image == NULL ) ){
std::cerr << "Memory allocation for binarization of image failed\n";
return;
}
RescaleUsUsType::Pointer rescaleususfilter = RescaleUsUsType::New();
rescaleususfilter->SetInput( cyt_im_inp );
rescaleususfilter->SetOutputMaximum( itk::NumericTraits<unsigned char>::max() );
rescaleususfilter->SetOutputMinimum( 0 );
rescaleususfilter->Update();
UShortImageType::Pointer resc_cyt_im = UShortImageType::New();
resc_cyt_im = rescaleususfilter->GetOutput();
ConstIteratorType pix_buf1( resc_cyt_im, resc_cyt_im->GetRequestedRegion() );
for ( pix_buf1.GoToBegin(); !pix_buf1.IsAtEnd(); ++pix_buf1, ++ind )
in_Image[ind]=(unsigned char)(pix_buf1.Get());
int ok = 0;
ok = Cell_Binarization_2D(in_Image,bin_Image, size1, size2, shift_bin);
free( in_Image );
if( !ok ){
std::cerr<<"Binarization Failed\n";
return;
}
//copy the output binary image into the ITK image
intermediate_bin_im_out = UShortImageType::New();
UShortImageType::PointType origin;
origin[0] = 0;
origin[1] = 0;
intermediate_bin_im_out->SetOrigin( origin );
UShortImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
UShortImageType::SizeType size;
size[0] = size1; // size along X
size[1] = size2; // size along Y
UShortImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
intermediate_bin_im_out->SetRegions( region );
intermediate_bin_im_out->Allocate();
intermediate_bin_im_out->FillBuffer(0);
intermediate_bin_im_out->Update();
itk::SizeValueType dum,dum1;
dum = 0;
dum1 = USHRT_MAX;
//unsigned int asd,asd1; asd=0; asd1=0;
IteratorType iterator ( intermediate_bin_im_out, intermediate_bin_im_out->GetRequestedRegion() );
for(itk::SizeValueType i=0; i < (size1*size2); ++i){
if( bin_Image[i] )
iterator.Set( dum1 );
else
iterator.Set( dum );
++iterator;
}
}
//Call multi level binarization method if the number of bin levels is >= 2
else{
RescaleUsIntType::Pointer rescaleusintfilter = RescaleUsIntType::New();
ScalarImageToHistogramGeneratorType::Pointer scalarImageToHistogramGenerator = ScalarImageToHistogramGeneratorType::New();
rescaleusintfilter->SetInput( cyt_im_inp );
rescaleusintfilter->SetOutputMaximum( itk::NumericTraits<unsigned short>::max() );
rescaleusintfilter->SetOutputMinimum( 0 );
rescaleusintfilter->Update();
ThreshFilterType::Pointer threshfilter = ThreshFilterType::New();
CalculatorType::Pointer calculator = CalculatorType::New();
scalarImageToHistogramGenerator->SetNumberOfBins( 255 );
calculator->SetNumberOfThresholds( num_levels );
threshfilter->SetOutsideValue( (int)0 );
threshfilter->SetInsideValue( (int)USHRT_MAX );
scalarImageToHistogramGenerator->SetInput( rescaleusintfilter->GetOutput() );
scalarImageToHistogramGenerator->Compute();
calculator->SetInputHistogram( scalarImageToHistogramGenerator->GetOutput() );
threshfilter->SetInput( rescaleusintfilter->GetOutput() );
calculator->Update();
const CalculatorType::OutputType &thresholdVector = calculator->GetOutput();
CalculatorType::OutputType::const_iterator itNum = thresholdVector.begin();
int lowerThreshold,upperThreshold;
for( int i=0; i<(num_levels-num_levels_incl); ++i ) ++itNum;
lowerThreshold = static_cast<unsigned short>(*itNum);
upperThreshold = itk::NumericTraits<unsigned short>::max();
threshfilter->SetLowerThreshold( lowerThreshold );
threshfilter->SetUpperThreshold( upperThreshold );
threshfilter->Update();
intermediate_bin_im_out = UShortImageType::New();
intermediate_bin_im_out = threshfilter->GetOutput();
}
//Fill holes left by the nuclei
ThresholdFilterType::Pointer binarythreshfilter = ThresholdFilterType::New();
binarythreshfilter->SetInsideValue( USHRT_MAX );
binarythreshfilter->SetOutsideValue( 0 );
binarythreshfilter->SetLowerThreshold( 1 );
binarythreshfilter->SetUpperThreshold( USHRT_MAX );
binarythreshfilter->SetInput( nuclab_inp );
OrFilterType::Pointer orfilter = OrFilterType::New();
orfilter->SetInput1( binarythreshfilter->GetOutput() );
orfilter->SetInput2( intermediate_bin_im_out );
//dialate and erode
ErodeFilterType::Pointer binaryErode = ErodeFilterType::New();
DilateFilterType::Pointer binaryDilate = DilateFilterType::New();
StructuringElementType structuringElement;
structuringElement.SetRadius( 3 ); // 3x3 structuring element
structuringElement.CreateStructuringElement();
binaryErode->SetKernel( structuringElement );
binaryErode->SetErodeValue( USHRT_MAX );
binaryDilate->SetDilateValue( USHRT_MAX );
binaryDilate->SetKernel( structuringElement );
binaryErode->SetInput( binaryDilate->GetOutput() );
binaryDilate->SetInput( orfilter->GetOutput() );
//erode and dialate
ErodeFilterType::Pointer binaryErode1 = ErodeFilterType::New();
DilateFilterType::Pointer binaryDilate1 = DilateFilterType::New();
binaryErode1->SetKernel( structuringElement );
binaryErode1->SetErodeValue( USHRT_MAX );
binaryDilate1->SetDilateValue( USHRT_MAX );
binaryDilate1->SetKernel( structuringElement );
binaryErode1->SetInput( binaryErode->GetOutput() );
binaryDilate1->SetInput( binaryErode1->GetOutput() );
binaryDilate1->Update();
//Get pointer to the final binary image and return it to calling function
UShortImageType::Pointer image_bin = UShortImageType::New();
image_bin = binaryDilate1->GetOutput();
bin_im_out = image_bin;
bin_done = 1;
//Update bin array
ind=0;
if( draw_real_bounds ){
ConstIteratorType pix_buf3( bin_im_out, bin_im_out->GetRequestedRegion() );
for ( pix_buf3.GoToBegin(); !pix_buf3.IsAtEnd(); ++pix_buf3, ++ind )
bin_Image[ind]=(pix_buf3.Get());
}else
free( bin_Image );
/*
typedef itk::ImageFileWriter< UShortImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName( "bin_info.tif" );
writer->SetInput( bin_im_out );//RescaleIntIO1--finalO/P
writer->Update();
*/
return;
}
USImageType::PixelType returnthresh( itk::SmartPointer<USImageType> input_image,
int num_bin_levs, int num_in_fg ){
//Instantiate the different image and filter types that will be used
typedef itk::ImageRegionConstIterator< USImageType > ConstIteratorType;
typedef itk::Statistics::Histogram< float > HistogramType;
typedef itk::OtsuMultipleThresholdsCalculator< HistogramType > CalculatorType;
std::cout<<"Starting threshold computation\n";
//Create a temporary histogram container:
const int numBins = itk::NumericTraits<USImageType::PixelType>::max();
double *tempHist;
tempHist = (double*) malloc( sizeof(double) * numBins );
for(USImageType::PixelType i=0; i<numBins; ++i)
tempHist[i] = 0;
USImageType::PixelType maxval = itk::NumericTraits<USImageType::PixelType>::ZeroValue();
USImageType::PixelType minval = itk::NumericTraits<USImageType::PixelType>::max();
//Populate the histogram (assume pixel type is actually is some integer type):
ConstIteratorType it( input_image, input_image->GetRequestedRegion() );
for ( it.GoToBegin(); !it.IsAtEnd(); ++it ){
USImageType::PixelType pix = it.Get();
++tempHist[pix];
if( pix > maxval ) maxval = pix;
if( pix < minval ) minval = pix;
}
//return max of type if there is no variation in the staining
if( (maxval-minval)<3 ) return itk::NumericTraits<USImageType::PixelType>::max();
const USImageType::PixelType numBinsPresent = maxval+1;
//Find max value in the histogram
double floatIntegerMax = itk::NumericTraits<USImageType::PixelType>::max();
double max = 0.0;
for(USImageType::PixelType i=0; i<numBinsPresent; ++i)
if( tempHist[i] > max )
max = tempHist[i];
double scaleFactor = 1;
if(max >= floatIntegerMax)
scaleFactor = floatIntegerMax / max;
HistogramType::Pointer histogram = HistogramType::New() ;
// initialize histogram
HistogramType::SizeType size;
HistogramType::MeasurementVectorType lowerBound;
HistogramType::MeasurementVectorType upperBound;
lowerBound.SetSize(1);
upperBound.SetSize(1);
size.SetSize(1);
lowerBound.Fill(0.0);
upperBound.Fill((double)maxval);
size.Fill(numBinsPresent);
histogram->SetMeasurementVectorSize(1);
histogram->Initialize(size, lowerBound, upperBound ) ;
USImageType::PixelType i=0;
for (HistogramType::Iterator iter = histogram->Begin(); iter != histogram->End(); ++iter ){
float norm_freq = (float)(tempHist[i] * scaleFactor);
iter.SetFrequency(norm_freq);
++i;
}
std::cout<<"Histogram computed\n";
CalculatorType::Pointer calculator = CalculatorType::New();
calculator->SetNumberOfThresholds( num_bin_levs );
calculator->SetInputHistogram( histogram );
calculator->Update();
const CalculatorType::OutputType &thresholdVector = calculator->GetOutput();
CalculatorType::OutputType::const_iterator itNum = thresholdVector.begin();
float thresh;
for(USImageType::PixelType i=0; i < num_in_fg; ++itNum, ++i)
thresh = (static_cast<float>(*itNum));
std::cout<<"Threshold computed: "<<thresh<<std::endl;
return (USImageType::PixelType)(thresh+0.5);
}