bool TestIsClosedLoop() { std::cout << "TestIsClosedLoop()" << std::endl; // Open loop { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); for(itk::Index<2>::IndexValueType i = 20; i < 30; ++i) { itk::Index<2> pixel = {{i, 50}}; image->SetPixel(pixel, 255); } itk::Index<2> start = {{25, 50}}; bool isClosedLoop = ITKHelpers::IsClosedLoop(image.GetPointer(), start); std::cout << "Is closed loop? " << isClosedLoop << std::endl; } // Closed loop { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); itk::Index<2> corner0 = {{10,10}}; itk::Index<2> corner1 = {{30,30}}; ITKHelpers::DrawRectangle(image.GetPointer(), 255, corner0, corner1); itk::Index<2> start = {{10, 10}}; bool isClosedLoop = ITKHelpers::IsClosedLoop(image.GetPointer(), start); std::cout << "Is closed loop? " << isClosedLoop << std::endl; } return true; }
bool TestBreadthFirstOrderingNonZeroPixels() { std::cout << "TestBreadthFirstOrderingNonZeroPixels()" << std::endl; typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); for(itk::Index<2>::IndexValueType i = 20; i < 30; ++i) { itk::Index<2> pixel = {{i, 50}}; image->SetPixel(pixel, 255); } itk::Index<2> start = {{25, 50}}; std::vector<itk::Index<2> > breadthFirstOrdering = ITKHelpers::BreadthFirstOrderingNonZeroPixels(image.GetPointer(), start); for(unsigned int i = 0; i < breadthFirstOrdering.size(); ++i) { //std::cout << breadthFirstOrdering[i] << " "; std::cout << breadthFirstOrdering[i] << std::endl; } std::cout << std::endl; return true; }
void TestGetOpenContourOrdering() { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); for(unsigned int i = 20; i < 30; ++i) { itk::Index<2> pixel = {{i, 50}}; image->SetPixel(pixel, 255); } itk::Index<2> start = {{25, 50}}; std::vector<itk::Index<2> > contourOrdering = ITKHelpers::GetOpenContourOrdering(image.GetPointer(), start); for(unsigned int i = 0; i < contourOrdering.size(); ++i) { //std::cout << breadthFirstOrdering[i] << " "; std::cout << contourOrdering[i] << std::endl; } std::cout << std::endl; }
void TestGetClosedContourOrdering() { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); itk::Index<2> corner0 = {{10,10}}; itk::Index<2> corner1 = {{30,30}}; ITKHelpers::DrawRectangle(image.GetPointer(), 255, corner0, corner1); itk::Index<2> start = {{10, 10}}; std::vector<itk::Index<2> > ordering = ITKHelpers::GetClosedContourOrdering(image.GetPointer(), start); for(unsigned int i = 0; i < ordering.size(); ++i) { std::cout << ordering[i] << std::endl; } std::cout << std::endl; }
int main(int, char* [] ) { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner={{0,0}}; itk::Size<2> size = {{10,10}}; itk::ImageRegion<2> region(corner,size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); unsigned char searchValue = 255; // This value does not appear in the image, so both functions // will have to search the entire image. int counter = 0; for(unsigned int i = 0; i < 1e7; ++i) { // counter += HasValue(image.GetPointer(), searchValue); // About 3 seconds counter += HasValueConditional(image.GetPointer(), searchValue); // About 3.3 seconds } std::cout << "counter " << counter << std::endl; return 0; }
void NRRDTools::saveNRRDFile(const cleaver::FloatField *field, const std::string &name) { auto dims = field->dataBounds().size; ImageType::Pointer img = ImageType::New(); itk::Index<3> start; start.Fill(0); ImageType::SizeType size; size[0] = static_cast<size_t>(dims[0]); size[1] = static_cast<size_t>(dims[1]); size[2] = static_cast<size_t>(dims[2]); ImageType::RegionType region(start, size); img->SetRegions(region); img->Allocate(); img->FillBuffer(0); for (size_t i = 0; i < dims[0]; i++) { for (size_t j = 0; j < dims[1]; j++) { for (size_t k = 0; k < dims[2]; k++) { ImageType::IndexType pixelIndex; pixelIndex[0] = i; pixelIndex[1] = j; pixelIndex[2] = k; auto data = ((cleaver::FloatField*)field)->data(); img->SetPixel(pixelIndex, data[i + size[0] * j + size[0] * size[1] * k]); } } } WriterType::Pointer write = WriterType::New(); write->SetFileName(name + ((name.find_first_of(".nrrd") == std::string::npos) ? ".nrrd" : "")); write->SetInput(img); write->Update(); }
// ------------------------------------------------------------------------ void createOutput(const ImageType::Pointer &input, ImageType::Pointer &output) { output->SetDirection(input->GetDirection()); output->SetSpacing(input->GetSpacing()); output->SetRegions(input->GetLargestPossibleRegion()); output->SetOrigin(input->GetOrigin()); output->Allocate(); output->FillBuffer(0); }
// ------------------------------------------------------------------------ void buildShortAxisVolume(const SeriesTransform::Map &transforms, const unsigned int seriesNumber, ImageType::Pointer &saVolume) { // get the short axis transforms SeriesTransform::Map::const_iterator mapIt = transforms.begin(); std::vector<SeriesTransform> saSlices; while(mapIt != transforms.end()) { if(mapIt->second.series == seriesNumber) { unsigned int sliceNum = mapIt->second.slice; if(saSlices.size() < (sliceNum+1)) saSlices.resize(sliceNum+1); saSlices[sliceNum] = mapIt->second; } ++mapIt; } // get the dimensions of the output image ImageType::Pointer reference = saSlices[0].images[0]; unsigned int x,y,z; x = reference->GetLargestPossibleRegion().GetSize()[0]; y = reference->GetLargestPossibleRegion().GetSize()[1]; z = saSlices.size(); ImageType::RegionType region; ImageType::SizeType size; ImageType::IndexType index; size[0] = x; size[1] = y; size[2] = z; index.Fill(0); region.SetSize(size); region.SetIndex(index); // get the other parts ImageType::SpacingType spacing = reference->GetSpacing(); spacing[2] = saSlices[0].sliceThickness; ImageType::DirectionType direction = reference->GetDirection(); ImageType::PointType origin = reference->GetOrigin(); saVolume->SetOrigin(origin); saVolume->SetDirection(direction); saVolume->SetSpacing(spacing); saVolume->SetRegions(region); saVolume->Allocate(); saVolume->FillBuffer(0); }
ComposeImageFilter::ImageType::Pointer ComposeImageFilter::ComposeIt() { ImageType::Pointer outputImage = ImageType::New(); outputImage->SetRegions(m_imageLR->GetLargestPossibleRegion()); outputImage->SetOrigin(m_imageLR->GetOrigin()); outputImage->SetSpacing(m_imageLR->GetSpacing()); outputImage->SetDirection(m_imageLR->GetDirection()); outputImage->Allocate(); outputImage->FillBuffer(0.0); std::cout << "outputImage" << std::endl; ImageType::IndexType testIndex; testIndex[0] = 0; testIndex[1]=0; testIndex[2]=0; std::cout << m_matrix.rows() << " " << m_matrix.cols() << std::endl; for (int i=0; i< m_matrix.rows() ; i++ ) { vcl_vector<int> rowIndices; vcl_vector<float> rowValues; vcl_vector<pair_t> rowM = m_matrix.get_row(i); float sum_vox =0; ImageType::IndexType outputIndex; outputIndex = ComputeImageIndex(i, m_imageLR); // std::cout << "ImageLR " << " " << i << " " << outputIndex << std::endl; for (vcl_vector<pair_t>::const_iterator it = rowM.begin(); it != rowM.end(); ++it) { ImageType::IndexType HRIndex; HRIndex = ComputeImageIndex(it->first, m_imageHR); sum_vox += (it->second)* (m_imageHR->GetPixel(HRIndex)); // std::cout << HRIndex << " " << it->second << std::endl; } // std::cout << sum_vox << std::endl; outputImage->SetPixel(outputIndex, sum_vox); // } return outputImage; }
bool TestRandomImage() { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); ITKHelpers::RandomImage(image.GetPointer()); ITKHelpers::WriteImage(image.GetPointer(), "random.png"); return true; }
void snapshot_beta_points(Nodes const& nodes) { // clear it g_snapshot_image->FillBuffer(0); for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) { // &&& Hmm, maybe we can do better than this; make it truly sparse. ImageType::IndexType index; g_snapshot_image->TransformPhysicalPointToIndex((*it)->pos(), index); PixelType density = g_snapshot_image->GetPixel(index); // There is no natural beta intensity (except maybe beta-like-ness, // which we don't keep) density += constants::BetaPointDisplayFakeDensity; g_snapshot_image->SetPixel(index, density); } }
bool VolumeProcess:: RunFillingZeroOnBouandary(int Bx,int By,int Bz) { ImageType::Pointer tempImg = ImageType::New(); tempImg->SetRegions( m_outputImage->GetLargestPossibleRegion() ); tempImg->Allocate(); tempImg->FillBuffer(0); ImageType::RegionType fullRegion = m_outputImage->GetBufferedRegion(); int numColumns = fullRegion.GetSize(0); int numRows = fullRegion.GetSize(1); int numStacks = fullRegion.GetSize(2); int i, j,k; itk::ImageRegionIteratorWithIndex< ImageType > itr( m_outputImage, fullRegion ); for(itr.GoToBegin(); !itr.IsAtEnd(); ++itr) { ImageType::IndexType index = itr.GetIndex(); ImageType::PixelType pix = m_outputImage->GetPixel(index); i = index[0]; j = index[1]; k = index[2]; if (i < Bx || i > numColumns -Bx || j < By || j > numRows-By ||k <Bz ||k > numStacks-Bz ) tempImg->SetPixel(itr.GetIndex(), 0); else tempImg->SetPixel(itr.GetIndex(), pix); } //Copy temp img back to image itk::ImageRegionIterator< ImageType > itr1( tempImg, tempImg->GetLargestPossibleRegion()); itk::ImageRegionIterator< ImageType > itr2( m_outputImage, m_outputImage->GetLargestPossibleRegion()); for(itr1.GoToBegin(), itr2.GoToBegin() ; !itr1.IsAtEnd(); ++itr1, ++itr2) { itr2.Set( itr1.Get() ); } if(debug) std::cerr << "RunFillingZero Done" << std::endl; return true; }
void TestDrawRectangle() { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{100,100}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); itk::Index<2> corner0 = {{10,10}}; itk::Index<2> corner1 = {{30,30}}; ITKHelpers::DrawRectangle(image.GetPointer(), 255, corner0, corner1); ITKHelpers::WriteImage(image.GetPointer(), "rectangle.png"); }
int main(int, char* [] ) { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0, 0}}; itk::Size<2> size = {{31, 31}}; // Both dimensions of the size must be odd for the logic in this code to work itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); image->FillBuffer(1); // This is the pixel we will repeatedly query itk::Index<2> queryIndex = {{size[0]/2, size[0]/2}}; // Create a list of all of the offsets relative to the queryIndex std::vector<itk::Offset<2> > offsets; itk::ImageRegionConstIteratorWithIndex<ImageType> imageIterator(image, region); while(!imageIterator.IsAtEnd()) { offsets.push_back(imageIterator.GetIndex() - queryIndex); ++imageIterator; } // Call these functions many times for timing stability int totalSum = 0; // This variable is used so the compiler doesn't optimize away the loop for(unsigned int i = 0; i < 1e4; ++i) { // ImageType::PixelType pixelSum = SumPixelsManual(image.GetPointer(), queryIndex, offsets); // about 2 seconds ImageType::PixelType pixelSum = SumPixelsIterator(image.GetPointer(), queryIndex, offsets); totalSum += pixelSum; } std::cout << "totalSum " << totalSum << std::endl; return 0; }
void TestGetAllPatchesContainingPixel() { typedef itk::Image<float, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{10,10}}; itk::ImageRegion<2> imageRegion(corner,size); image->SetRegions(imageRegion); image->Allocate(); image->FillBuffer(0.0f); itk::Index<2> queryPixel = {{5,5}}; std::vector<itk::ImageRegion<2> > allPatches = ITKHelpers::GetAllPatchesContainingPixel(queryPixel, 1, imageRegion); std::cout << "Number of patches " << allPatches.size() << std::endl; }
int main(int argc, char ** argv){ typedef itk::Image<float,3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; typedef itk::ImageFileWriter<ImageType> WriterType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); typedef itk::HessianRecursiveGaussianImageFilter<ImageType> HessianFilterType; typedef HessianFilterType::OutputImageType HessianImageType; typedef HessianImageType::PixelType HessianType; HessianFilterType::Pointer hessianFilter = HessianFilterType::New(); hessianFilter->SetSigma(0.05); hessianFilter->SetInput(reader->GetOutput()); hessianFilter->Update(); HessianImageType::Pointer hessianImage = hessianFilter->GetOutput(); hessianImage->DisconnectPipeline(); typedef itk::ImageRegionConstIteratorWithIndex<HessianImageType> IteratorType; IteratorType hessianIterator(hessianImage,hessianImage->GetLargestPossibleRegion()); typedef HessianType::EigenValuesArrayType EigenvalueArrayType; EigenvalueArrayType expectation; expectation.Fill(0.0); unsigned count=0; ImageType::Pointer small = ImageType::New(); small->CopyInformation(reader->GetOutput()); small->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); small->Allocate(); small->FillBuffer(0.0); ImageType::Pointer medium = ImageType::New(); medium->CopyInformation(reader->GetOutput()); medium->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); medium->Allocate(); medium->FillBuffer(0.0); ImageType::Pointer large = ImageType::New(); large->CopyInformation(reader->GetOutput()); large->SetRegions(reader->GetOutput()->GetLargestPossibleRegion()); large->Allocate(); large->FillBuffer(0.0); while(!hessianIterator.IsAtEnd()){ auto hessian = hessianIterator.Get(); EigenvalueArrayType eigenValues; hessian.ComputeEigenValues(eigenValues); std::sort(eigenValues.Begin(),eigenValues.End(),[](double & a, double &b){ return std::abs(a) > std::abs(b); }); //std::cout << eigenValues[0] << "\t"<< eigenValues[1] << "\t" << eigenValues[2] <<std::endl; if(eigenValues[0]<0){ expectation[0]+=eigenValues[0]; expectation[1]+=eigenValues[1]; expectation[2]+=eigenValues[2]; count++; large->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[0])); medium->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[1])); small->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[2])); } ++hessianIterator; } expectation[0]=expectation[0]/count; expectation[1]=expectation[1]/count; expectation[2]=expectation[2]/count; WriterType::Pointer smallWriter = WriterType::New(); smallWriter->SetInput(small); smallWriter->SetFileName("small.mha"); smallWriter->Update(); WriterType::Pointer mediumWriter = WriterType::New(); mediumWriter->SetInput(medium); mediumWriter->SetFileName("medium.mha"); mediumWriter->Update(); WriterType::Pointer largeWriter = WriterType::New(); largeWriter->SetInput(large); largeWriter->SetFileName("large.mha"); largeWriter->Update(); std::cout << "Expectation: \t" << expectation<< std::endl; }
void CCropDialog::DoCrop(int nStartX, int nStartY, int nWidth, int nLength, QString strInputFileName, QString strOutputFileName) { if(QFile::exists(strOutputFileName)) { return; // } ImageType::IndexType start; start[0] = nStartX; start[1] = nStartY; ImageType::SizeType size; size[0] = nWidth; size[1] = nLength; ImageType::RegionType desiredRegion; desiredRegion.SetSize( size ); desiredRegion.SetIndex( start ); FilterType::Pointer filter = FilterType::New(); filter->SetRegionOfInterest( desiredRegion ); ReaderType::Pointer reader = ReaderType::New(); const char * inputFilename = strInputFileName.toStdString().c_str(); reader->SetFileName( inputFilename ); filter->SetInput( reader->GetOutput() ); //bool bbErrorInSourceImage = false; try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return; // EXIT_FAILURE; } //////////////////////////////////// // prepare the output ImageType::Pointer pOutputImage = ImageType::New(); pOutputImage->SetRegions( filter->GetOutput()->GetRequestedRegion() ); //pOutputImage->CopyInformation(pReader->GetOutput()); pOutputImage->Allocate(); /////////////////////////////////// // fill buffer with initial value ImageType::PixelType InitialValue = 255; pOutputImage->FillBuffer( InitialValue ); //if(bErrorInSourceImage != true) { ConstIteratorType InputItX(filter->GetOutput(), filter->GetOutput()->GetRequestedRegion()); IteratorType OutputItX(pOutputImage, filter->GetOutput()->GetRequestedRegion()); DoRelight(0, InputItX, OutputItX); ConstIteratorType InputItY(pOutputImage, filter->GetOutput()->GetRequestedRegion()); IteratorType OutputItY(pOutputImage, filter->GetOutput()->GetRequestedRegion()); DoRelight(1, InputItY, OutputItY); } WriterType::Pointer pWriter = WriterType::New(); const char * outputFilename = strOutputFileName.toStdString().c_str(); pWriter->SetFileName(outputFilename); pWriter->SetInput( pOutputImage ); try { pWriter->Update(); } catch ( itk::ExceptionObject &err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return; // -1; } }
void DistanceMapFilter::applyDistanceMapFilter(QString flnm, QList<Vec> clipPos, QList<Vec> clipNormal, QList<CropObject> crops, QList<PathObject> paths, uchar *lut, int chan) { int bpv = 1; if (m_voxelType > 0) bpv = 2; int nbytes = bpv*m_nY*m_nZ; bool trim = (qRound(m_dataSize.x) < m_height || qRound(m_dataSize.y) < m_width || qRound(m_dataSize.z) < m_depth); bool clipPresent = (clipPos.count() > 0); m_cropPresent = false; m_tearPresent = false; m_blendPresent = false; for(int ci=0; ci<m_crops.count(); ci++) { if (crops[ci].cropType() < CropObject::Tear_Tear) m_cropPresent = true; else if (crops[ci].cropType() < CropObject::View_Tear) m_tearPresent = true; else if (m_crops[ci].cropType() > CropObject::Displace_Displace && m_crops[ci].cropType() < CropObject::Glow_Ball) m_blendPresent = true; } m_pathCropPresent = false; m_pathBlendPresent = false; for (int i=0; i<m_paths.count(); i++) { if (m_paths[i].blend()) m_pathBlendPresent = true; if (m_paths[i].crop()) m_pathCropPresent = true; } m_meshLog->moveCursor(QTextCursor::End); int d0 = 0; int d1 = m_nX-1; int d0z = d0 + qRound(m_dataMin.z); int d1z = d1 + qRound(m_dataMin.z); uchar *opacityVol = new uchar[m_nX*m_nY*m_nZ]; uchar *cropped = new uchar[nbytes]; uchar *tmp = new uchar[nbytes]; int i0 = 0; for(int i=d0z; i<=d1z; i++) { m_meshProgress->setValue((int)(100.0*(float)i0/(float)m_nX)); qApp->processEvents(); int iv = qBound(0, i, m_depth-1); uchar *vslice = m_vfm->getSlice(iv); memset(cropped, 0, nbytes); if (!trim) memcpy(tmp, vslice, nbytes); else { int wmin = qRound(m_dataMin.y); int hmin = qRound(m_dataMin.x); if (m_voxelType == 0) { for(int w=0; w<m_nY; w++) for(int h=0; h<m_nZ; h++) tmp[w*m_nZ + h] = vslice[(wmin+w)*m_height + (hmin+h)]; } else { for(int w=0; w<m_nY; w++) for(int h=0; h<m_nZ; h++) ((ushort*)tmp)[w*m_nZ + h] = ((ushort*)vslice)[(wmin+w)*m_height + (hmin+h)]; } } int jk = 0; for(int j=0; j<m_nY; j++) for(int k=0; k<m_nZ; k++) { Vec po = Vec(m_dataMin.x+k, m_dataMin.y+j, iv); bool ok = true; // we don't want to scale before pruning int mop = 0; { Vec pp = po - m_dataMin; int ppi = pp.x/m_pruneLod; int ppj = pp.y/m_pruneLod; int ppk = pp.z/m_pruneLod; ppi = qBound(0, ppi, m_pruneX-1); ppj = qBound(0, ppj, m_pruneY-1); ppk = qBound(0, ppk, m_pruneZ-1); int mopidx = ppk*m_pruneY*m_pruneX + ppj*m_pruneX + ppi; mop = m_pruneData[3*mopidx + chan]; ok = (mop > 0); } po *= m_samplingLevel; if (ok && clipPresent) ok = StaticFunctions::getClip(po, clipPos, clipNormal); if (ok && m_cropPresent) ok = checkCrop(po); if (ok && m_pathCropPresent) ok = checkPathCrop(po); if (ok && m_blendPresent) { ushort v; if (m_voxelType == 0) v = tmp[j*m_nZ + k]; else v = ((ushort*)tmp)[j*m_nZ + k]; ok = checkBlend(po, v, lut); } if (ok && m_pathBlendPresent) { ushort v; if (m_voxelType == 0) v = tmp[j*m_nZ + k]; else v = ((ushort*)tmp)[j*m_nZ + k]; ok = checkPathBlend(po, v, lut); } if (ok) cropped[jk] = mop; else cropped[jk] = 0; jk ++; } if (m_voxelType == 0) { for(int j=0; j<m_nY*m_nZ; j++) { if (cropped[j] == 0) tmp[j] = 0; } } else { for(int j=0; j<m_nY*m_nZ; j++) { if (cropped[j] == 0) ((ushort*)tmp)[j] = 0; } } applyOpacity(iv, cropped, lut, tmp); memcpy(opacityVol + i0*m_nY*m_nZ, tmp, m_nY*m_nZ); i0++; } delete [] tmp; delete [] cropped; m_meshProgress->setValue(100); qApp->processEvents(); //------------ if (m_tearPresent) { uchar *data0 = new uchar[m_nX*m_nY*m_nZ]; memcpy(data0, opacityVol, m_nX*m_nY*m_nZ); applyTear(d0, d1, 0, data0, opacityVol, false); delete [] data0; } typedef uchar PixelType; const unsigned int Dimension = 3; typedef itk::Image< PixelType, Dimension > ImageType; ImageType::IndexType start; start.Fill(0); ImageType::SizeType size; size[0] = m_nZ; size[1] = m_nY; size[2] = m_nX; ImageType::RegionType region(start, size); ImageType::Pointer image = ImageType::New(); image->SetRegions(region); image->Allocate(); image->FillBuffer(0); uchar *iptr = (uchar*)image->GetBufferPointer(); memcpy(iptr, opacityVol, m_nX*m_nY*m_nZ); typedef itk::Image< float, 3 > OutputImageType; typedef itk::SignedMaurerDistanceMapImageFilter<ImageType, OutputImageType> DistanceMapFilter; DistanceMapFilter::Pointer filter = DistanceMapFilter::New(); filter->SetInput( image ); filter->SetSquaredDistance(0); filter->SetUseImageSpacing(0); filter->SetInsideIsPositive(1); filter->Update(); QFile fp; fp.setFileName(flnm); fp.open(QFile::WriteOnly); uchar vt = 8; fp.write((char*)&vt, 1); fp.write((char*)&m_nX, 4); fp.write((char*)&m_nY, 4); fp.write((char*)&m_nZ, 4); OutputImageType *dimg = filter->GetOutput(); char *tdata = (char*)(dimg->GetBufferPointer()); fp.write(tdata, 4*m_nX*m_nY*m_nZ); fp.close(); m_meshLog->moveCursor(QTextCursor::End); m_meshLog->insertPlainText("Signed Distance Map data saved in "+flnm); QMessageBox::information(0, "", QString("Signed Distance Map saved in "+flnm)); }
void CUnitVolumeMakerDlg::GetImage(int iWidth, int iLength, int iHeight, int iZ, EZoomOut eZoomOutLevel) { int nCol; int nX, nY, nZ; int nRibbonWidth; int nImageWidth; int nRightWidth; int nTotalWidth; QString strPathName, strImageFileName, strImageVolPathName, strImage4VolFileName; nRibbonWidth = qRound(float(m_TissueBlock.m_Ribbon.m_nWidth)/eZoomOutLevel); nCol = (int)((m_TissueBlock.m_UnitCube.m_nWidth*iWidth)/nRibbonWidth); nX = nRibbonWidth - (nRibbonWidth*(nCol+1)-(iWidth*m_TissueBlock.m_UnitCube.m_nWidth)); nY = iLength*m_TissueBlock.m_UnitCube.m_nLength; nZ = iHeight*m_TissueBlock.m_UnitCube.m_nHeight; strPathName = QString(tr("%1%2%3/%4/") .arg(sINIT_DATA_DIR).arg(sZOOM_OUT_DIR_PREFIX).arg(eZoomOutLevel).arg(nCol)); strImageFileName.sprintf("%05d%s", nZ+eZoomOutLevel*iZ, sDATA_FILE_FORMAT); nRightWidth = nRibbonWidth - nX; if(nRightWidth > m_TissueBlock.m_UnitCube.m_nWidth) { nImageWidth = qMin(m_TissueBlock.m_UnitCube.m_nWidth, nRibbonWidth); } else { nImageWidth = nRightWidth; } // extract nX, nY, nImageWidth, m_TissueBlock.m_UnitCube.m_nLength //... qDebug() << "nX: " << nX << ", nY: " << nY << ", nImageWidth: " << nImageWidth << "\n"; ui.listWidgetResult->addItem(tr("nCol: %1, nX: %2, nY: %3, nImageWidth: %4").arg(nCol).arg(nX).arg(nY).arg(nImageWidth)); ui.listWidgetResult->addItem(strPathName); ui.listWidgetResult->addItem(strImageFileName); // source image filename (full path) QString strFileName = strPathName + strImageFileName; ///////////////////////// // read an image // typedef typedef unsigned char PixelType; const unsigned int nDimension = 2; typedef itk::Image<PixelType, nDimension> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; typedef itk::ImageFileWriter<ImageType> WriterType; //typedef itk::RegionOfInterestImageFilter<ImageType, ImageType> ROIFilterType; typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType; typedef itk::ImageRegionIterator< ImageType> IteratorType; ///////////////////////////////////// // input: a region of a source image ImageType::RegionType InputRegion; ImageType::RegionType::IndexType InputStart; ImageType::RegionType::SizeType InputSize; InputStart[0] = nX; InputStart[1] = nY; InputSize[0] = nImageWidth; InputSize[1] = m_TissueBlock.m_UnitCube.m_nLength; InputRegion.SetSize( InputSize ); InputRegion.SetIndex( InputStart ); ///////////////////////////////////// // output: a region of a output image ImageType::RegionType OutputRegion, OutputSubRegion; ImageType::RegionType::IndexType OutputStart; ImageType::RegionType::SizeType OutputSize; OutputStart[0] = 0; OutputStart[1] = 0; OutputSize[0] = m_TissueBlock.m_UnitCube.m_nWidth; //InputSize[0]; OutputSize[1] = m_TissueBlock.m_UnitCube.m_nLength; //InputSize[1]; OutputRegion.SetSize( OutputSize ); OutputRegion.SetIndex( OutputStart ); OutputSize[0] = InputSize[0]; OutputSize[1] = InputSize[1]; OutputSubRegion.SetSize( OutputSize ); OutputSubRegion.SetIndex( OutputStart ); bool bErrorInSourceImage = false; ///////////////////////////////////// // read the source image ReaderType::Pointer pReader = ReaderType::New(); pReader->SetFileName(strFileName.toStdString()); try { pReader->Update(); } catch ( itk::ExceptionObject &err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; bErrorInSourceImage = true; //return; // -1; } // Check that the region is contained within the input image. if(!pReader->GetOutput()->GetRequestedRegion().IsInside( InputRegion ) ) { std::cerr << "Error" << std::endl; std::cerr << "The region " << InputRegion << "is not contained within the input image region " << pReader->GetOutput()->GetRequestedRegion() << std::endl; bErrorInSourceImage = true; //return; // -1; } //////////////////////////////////// // prepare the output ImageType::Pointer pOutputImage = ImageType::New(); pOutputImage->SetRegions( OutputRegion ); pOutputImage->Allocate(); /////////////////////////////////// // fill buffer with initial value ImageType::PixelType InitialValue = nDEF_BG_COLOR; pOutputImage->FillBuffer( InitialValue ); ///////////////////////////////////////////////////////////////////////// // get pixels from the source image file and put them into the output image file if(bErrorInSourceImage != true) { ConstIteratorType InputIt( pReader->GetOutput(), InputRegion ); IteratorType OutputIt( pOutputImage, OutputSubRegion ); for(InputIt.GoToBegin(), OutputIt.GoToBegin(); !InputIt.IsAtEnd(); ++InputIt, ++OutputIt) { OutputIt.Set(InputIt.Get()); } } nTotalWidth = nImageWidth; while(nTotalWidth < m_TissueBlock.m_UnitCube.m_nWidth) { nCol++; if(nCol == m_TissueBlock.m_nNumCol) break; nX = 0; nImageWidth = m_TissueBlock.m_UnitCube.m_nWidth - nTotalWidth; if(nImageWidth > nRibbonWidth) { nImageWidth = nRibbonWidth; } strPathName = QString(tr("%1%2%3/%4/") .arg(sINIT_DATA_DIR).arg(sZOOM_OUT_DIR_PREFIX).arg(eZoomOutLevel).arg(nCol)); strImageFileName.sprintf("%05d%s", nZ+eZoomOutLevel*iZ, sDATA_FILE_FORMAT); // extract nX, nY, nImageWidth, m_TissueBlock.m_UnitCube.m_nLength // for display qDebug() << "nX: " << nX << ", nY: " << nY << ", nImageWidth: " << nImageWidth << "\n"; ui.listWidgetResult->addItem(tr("nCol: %1, nX: %2, nY: %3, nImageWidth: %4").arg(nCol).arg(nX).arg(nY).arg(nImageWidth)); ui.listWidgetResult->addItem(strPathName); ui.listWidgetResult->addItem(strImageFileName); // source image filename (full path) strFileName = strPathName + strImageFileName; // set input size InputStart[0] = nX; InputStart[1] = nY; InputSize[0] = nImageWidth; InputSize[1] = m_TissueBlock.m_UnitCube.m_nLength; InputRegion.SetSize( InputSize ); InputRegion.SetIndex( InputStart ); OutputSize[0] = InputSize[0]; OutputSize[1] = InputSize[1]; ImageType::RegionType::IndexType OutputStartSub; OutputStartSub[0] = nTotalWidth; OutputStartSub[1] = 0; OutputSubRegion.SetSize( OutputSize ); OutputSubRegion.SetIndex( OutputStartSub ); bErrorInSourceImage = false; ///////////////////////////////////// // read the source image //ReaderType::Pointer pReader = ReaderType::New(); pReader->SetFileName(strFileName.toStdString()); try { pReader->Update(); } catch ( itk::ExceptionObject &err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; bErrorInSourceImage = true; //return; // -1; } // Check that the region is contained within the input image. if(!pReader->GetOutput()->GetRequestedRegion().IsInside( InputRegion ) ) { std::cerr << "Error" << std::endl; std::cerr << "The region " << InputRegion << "is not contained within the input image region " << pReader->GetOutput()->GetRequestedRegion() << std::endl; bErrorInSourceImage = true; //return; // -1; } //////////////////////////////////// // prepare the output //ImageType::Pointer pOutputImage = ImageType::New(); //pOutputImage->SetRegions( OutputRegion ); //pOutputImage->Allocate(); if(bErrorInSourceImage != true) { ConstIteratorType InputIt( pReader->GetOutput(), InputRegion ); IteratorType OutputIt( pOutputImage, OutputSubRegion ); for(InputIt.GoToBegin(), OutputIt.GoToBegin(); !InputIt.IsAtEnd(); ++InputIt, ++OutputIt) { OutputIt.Set(InputIt.Get()); } } nTotalWidth += nImageWidth; } ///////////////////////////////////////////////////////// // get an output image file name (full path) strImageVolPathName = QString(tr("%1%2%3/%4/") .arg(sINIT_DATA_DIR).arg(sZOOM_OUT_DIR_PREFIX).arg(eZoomOutLevel).arg(sVOL_DIR_PREFIX)); QString strVolDir; strVolDir.sprintf("%03d_%03d_%03d", iWidth, iLength, iHeight); strVolDir = strImageVolPathName + strVolDir; QDir dir; dir.mkdir(strImageVolPathName); dir.mkdir(strVolDir); strImage4VolFileName.sprintf("%03d_%03d_%03d/%05d%s", iWidth, iLength, iHeight, nZ+eZoomOutLevel*iZ, sDATA_FILE_FORMAT); strImage4VolFileName = strImageVolPathName + strImage4VolFileName; ///////////////////////////////// // write an output image WriterType::Pointer pWriter = WriterType::New(); pWriter->SetFileName(strImage4VolFileName.toStdString()); pWriter->SetInput( pOutputImage ); try { pWriter->Update(); } catch ( itk::ExceptionObject &err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return; // -1; } }
int main(int argc, char *argv[]) { //check that the user specified the right number of command line arguments if(argc < 3) { cerr << argv[0] << " <input file> <output file>" << endl; cerr << argv[0] << " <raw input file> <sizeX> <sizeY> <sizeZ> <output file>" << endl; return EXIT_FAILURE; } //check if the input image is .raw bool rawInput = false; string inputFileName = argv[1]; const char *outputFileName; //double space[3]={1,1,1}; if(inputFileName.rfind(".raw") != string::npos) { //if so, the user is also required to pass in image dimensions if(argc < 6) { cerr << "Usage: <raw input file> <sizeX> <sizeY> <sizeZ> <output file>" << endl; return EXIT_FAILURE; } rawInput = true; sizeX = atoi(argv[2]); sizeY = atoi(argv[3]); sizeZ = atoi(argv[4]); outputFileName = argv[5]; } else { outputFileName = argv[2]; } FILE *infile = 0; FILE *outfile; int i,j,k; int ii, jj, kk; DATATYPEOUT *volout; long idx; int sizeExpand = 0; DATATYPEOUT blockMax; int timesDilate; int border; unsigned short *GraphcutResults; cout << "Volume Processing..." << endl; //make sure we can write to the output file if((outfile=fopen(outputFileName, "wb")) == NULL) { cerr << "Output file open error!" << endl; return EXIT_FAILURE; } typedef float PixelType; const unsigned int Dimension = 3; typedef itk::Image< PixelType, Dimension > ImageType; ImageType::Pointer inputImage; if(rawInput) { if((infile=fopen(inputFileName.c_str(), "rb"))==NULL) { cout << "Input file open error!" << endl; return EXIT_FAILURE; } volin = (DATATYPEIN*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEIN)); if (fread(volin, sizeof(DATATYPEIN), sizeX*sizeY*sizeZ, infile) < (unsigned int)(sizeX*sizeY*sizeZ)) { cerr << "File size is not the same as volume size" << endl; return EXIT_FAILURE; } inputImage = ImageType::New(); ImageType::PointType origin; origin[0] = 0.; origin[1] = 0.; origin[2] = 0.; inputImage->SetOrigin( origin ); ImageType::IndexType start; start[0] = 0; start[1] = 0; start[2] = 0; ImageType::SizeType size; size[0] = sizeX; size[1] = sizeY; size[2] = sizeZ; ImageType::RegionType region; region.SetSize( size ); region.SetIndex( start ); inputImage->SetRegions( region ); inputImage->Allocate(); inputImage->FillBuffer(0); inputImage->Update(); typedef itk::ImageRegionIteratorWithIndex< ImageType > IteratorType; IteratorType iterator1(inputImage,inputImage->GetRequestedRegion()); int lng = sizeX*sizeY*sizeZ; for(int i=0; i<lng; i++) { iterator1.Set((float)volin[i]); ++iterator1; } } // end if(rawInput) else { typedef itk::ImageFileReader< ImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); inputImage = reader->GetOutput(); reader->SetFileName( inputFileName.c_str() ); try { reader->Update(); } catch( itk::ExceptionObject & err ) { cerr << "ExceptionObject caught!" << endl; cerr << err << endl; return EXIT_FAILURE; } } // end of itk image read // ---------------Linear Mapping --------------------// typedef itk::RescaleIntensityImageFilter< ImageType, ImageType> RescaleFilterType; RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New(); rescaleFilter->SetInput(inputImage); rescaleFilter->SetOutputMinimum( 0 ); rescaleFilter->SetOutputMaximum( 255 ); try { rescaleFilter->Update(); } catch( itk::ExceptionObject & err ) { cerr << "ExceptionObject caught!" << endl; cerr << err << endl; return EXIT_FAILURE; } inputImage = rescaleFilter->GetOutput(); cout << "The Linear Mapping is done\n"; # if Curvature_Anistropic_Diffusion { cout << "The Curvature Diffusion is doing\n"; typedef itk::CurvatureAnisotropicDiffusionImageFilter< ImageType, ImageType > MCD_FilterType; MCD_FilterType::Pointer MCDFilter = MCD_FilterType::New(); //Initialnization, using the paper's optimal parameters const unsigned int numberOfIterations = 5; const double timeStep = 0.0425; const double conductance = 3; MCDFilter->SetNumberOfIterations(numberOfIterations); MCDFilter->SetTimeStep( timeStep ); MCDFilter->SetConductanceParameter( conductance ); MCDFilter->SetInput(inputImage); try { MCDFilter->Update(); } catch( itk::ExceptionObject & err ) { cerr << "ExceptionObject caught!" << endl; cerr << err << endl; return EXIT_FAILURE; } inputImage=MCDFilter->GetOutput(); cout << "The Curvature Diffusion is done\n"; } #endif ImageType::RegionType region = inputImage->GetBufferedRegion(); ImageType::SizeType size = region.GetSize(); cout << "input image size: " << size << endl; sizeX = size[0]; sizeY = size[1]; sizeZ = size[2]; itk::ImageRegionIterator< ImageType > itr( inputImage, inputImage->GetBufferedRegion() ); itr.GoToBegin(); idx = 0; volin = (DATATYPEIN*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEIN)); while( ! itr.IsAtEnd() ) { volin[idx] = itr.Get(); ++itr; ++idx; } //allocate memory for the output image volout = (DATATYPEOUT*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEOUT)); // one pre-processing scheme GraphcutResults = (unsigned short*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(unsigned short)); Neuron_Binarization_3D(volin,GraphcutResults,sizeX,sizeY,sizeZ,0,1); for (k=0; k<(sizeZ+sizeExpand*2); k++) for (j=0; j<sizeY; j++) for (i=0; i<sizeX; i++) { volout[k *sizeX*sizeY + j *sizeX + i] = 0; } //initial to zeros std::cout << "Do you think we need the distance transform to make the centerline of image become bright with higher intensity?"; char tmpAnswer = 'n'; //tmpAnswer = getchar(); if (tmpAnswer =='Y' || tmpAnswer =='y') { unsigned char *GraphcutResultsTmp; GraphcutResultsTmp = (unsigned char*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(unsigned char)); for (k=0; k<(sizeZ+sizeExpand*2); k++) for (j=0; j<sizeY; j++) for (i=0; i<sizeX; i++) { GraphcutResultsTmp[k *sizeX*sizeY + j *sizeX + i] = (unsigned char) GraphcutResults[k *sizeX*sizeY + j *sizeX + i]; } //initial to zeros distTransform(GraphcutResultsTmp,sizeX,sizeY,sizeZ); for (k=0; k<sizeZ; k++) { // threshold first for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { idx = k *sizeX*sizeY + j *sizeX + i; volin[idx] = GraphcutResultsTmp [idx]; } // end for } // end for } // end for free(GraphcutResultsTmp); GraphcutResultsTmp=NULL; } // end if else { for (k=0; k<sizeZ; k++) { // threshold first for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { idx = k *sizeX*sizeY + j *sizeX + i; if (GraphcutResults [idx] == 0) { volin[idx] = 0; } } } } } // end else free(GraphcutResults); GraphcutResults=NULL; // the secpnd Pre-Processing method, corresponding to the old version MDL /* double threshold; // by xiao liang, using 3 sigma theory to estimate threshold; double meanValue =0.0, VarianceValue = 0.0; // threshold first for (k=0; k<sizeZ; k++) { for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { idx = k *sizeX*sizeY + j *sizeX + i; meanValue += volin[idx]; } } } meanValue = meanValue/(double)(sizeX*sizeY*sizeZ); // threshold first for (k=0; k<sizeZ; k++) { for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { idx = k *sizeX*sizeY + j *sizeX + i; VarianceValue += (volin[idx]-meanValue)*(volin[idx]-meanValue); } } } VarianceValue = VarianceValue/(double)(sizeX*sizeY*sizeZ); VarianceValue = sqrt(VarianceValue); double m_threshold=OtsuThreshold (sizeX,sizeY,sizeZ); if (m_threshold > 7 || m_threshold < 0) { threshold =(meanValue-VarianceValue/30); } else { threshold = m_threshold; } //threshold =7; cout << "OTSU optimal threshold " << threshold << endl; for (k=0; k<(sizeZ+sizeExpand*2); k++) for (j=0; j<sizeY; j++) for (i=0; i<sizeX; i++) { volout[k *sizeX*sizeY + j *sizeX + i] = 0; } //initial to zeros for (k=0; k<sizeZ; k++) { // threshold first for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { idx = k *sizeX*sizeY + j *sizeX + i; if (volin[idx] < threshold) { volin[idx] = 0; } } } } */ // Method 2: Dilation of the object timesDilate = 1; border = 3; while (timesDilate >0 ) { for (k=border; k<sizeZ-border; k++) { for (j=border; j<sizeY-border; j++) { for (i=border; i<sizeX-border; i++) { blockMax = volin[k *sizeX*sizeY + j *sizeX + i]; for (kk=-1; kk<=1; kk++) { for (jj=-1; jj<=1; jj++) { for (ii=-1; ii<=1; ii++) { if(volin[(k+kk)*sizeX*sizeY + (j+jj)*sizeX + (i+ii)] > blockMax) { blockMax = volin[(k+kk)*sizeX*sizeY + (j+jj)*sizeX + (i+ii)]; } } } } // Keep the peak of the original intensity if (blockMax == volin[k *sizeX*sizeY + j *sizeX + i] && blockMax != 0) { blockMax = blockMax + 1; //if (blockMax > 255) blockMax = 255; } volout[k *sizeX*sizeY + j *sizeX + i] = blockMax; } } } // copy volout back to volin for the next dilation for (k=0; k<sizeZ; k++) { for (j=0; j<sizeY; j++) { for (i=0; i<sizeX; i++) { volin[k *sizeX*sizeY + j *sizeX + i] = volout[k *sizeX*sizeY + j *sizeX + i]; } } } timesDilate--; } //----- Image write /* typedef itk::ImageRegionIteratorWithIndex< ImageType > IteratorType; IteratorType iterator1(inputImage,inputImage->GetRequestedRegion()); int lng = sizeX*sizeY*sizeZ; for(int i=0; i<lng; i++) { iterator1.Set((float)volin[i]); ++iterator1; } */ //write the output image and free memory fwrite(volout, sizeX*sizeY*sizeZ, sizeof(DATATYPEOUT), outfile); FILE *mhdfile; if((mhdfile=fopen("volume_Processed.mhd","w"))==NULL) { cerr << "output file open error!" << endl; return -1; } fprintf (mhdfile,"ObjectType = Image\n"); fprintf (mhdfile,"NDims = 3\n"); fprintf (mhdfile,"BinaryData = True\n"); fprintf (mhdfile,"BinaryDataByteOrderMSB = False\n"); fprintf (mhdfile,"CompressedData = False\n"); fprintf (mhdfile,"TransformMatrix = 1 0 0 0 1 0 0 0 1\n"); fprintf (mhdfile,"Offset = 0 0 0\n"); fprintf (mhdfile,"CenterOfRotation = 0 0 0\n"); fprintf (mhdfile,"AnatomicalOrientation = RAI\n"); fprintf (mhdfile,"ElementSpacing = 1 1 1\n"); fprintf (mhdfile,"DimSize = %d %d %d\n",sizeX,sizeY,sizeZ); fprintf (mhdfile,"ElementType = MET_UCHAR\n"); fprintf (mhdfile,"ElementDataFile = volume_Processed.raw\n"); fclose(mhdfile); if (rawInput) fclose(infile); fclose(outfile); free(volin); // by xiao free(volout); // by xiao volin=NULL; volout=NULL; //cout << "Done" << endl; return 0; }
bool VolumeProcess::DialateImage(int iterations) { int border = 2; ImageType::Pointer tempImg = ImageType::New(); tempImg->SetRegions( m_outputImage->GetLargestPossibleRegion() ); tempImg->Allocate(); tempImg->FillBuffer(0); ImageType::RegionType fullRegion = m_outputImage->GetBufferedRegion(); ImageType::RegionType borderRegion; borderRegion.SetIndex(0, fullRegion.GetIndex(0)+border); borderRegion.SetIndex(1, fullRegion.GetIndex(1)+border); borderRegion.SetIndex(2, fullRegion.GetIndex(2)+border); borderRegion.SetSize(0, fullRegion.GetSize(0)-(2*border)); borderRegion.SetSize(1, fullRegion.GetSize(1)-(2*border)); borderRegion.SetSize(2, fullRegion.GetSize(2)-(2*border)); itk::ImageRegionIteratorWithIndex< ImageType > itr( m_outputImage, borderRegion ); while(iterations > 0) { for(itr.GoToBegin(); !itr.IsAtEnd(); ++itr) { double blockMax = itr.Get(); for(int k=-1; k<=1; k++) { for(int j=-1; j<=1; j++) { for(int i=-1; i<=1; i++) { ImageType::IndexType index = itr.GetIndex(); index[0] += i; index[1] += j; index[2] += k; ImageType::PixelType pix = m_outputImage->GetPixel(index); if((double)pix > blockMax) { blockMax = (double)pix; } } } } // Keep the peak of the original intensity if (blockMax == itr.Get() && blockMax != 0) { blockMax = blockMax + 1; } tempImg->SetPixel(itr.GetIndex(), blockMax); } //Copy temp img back to image for next dialation itk::ImageRegionIterator< ImageType > itr1( tempImg, tempImg->GetLargestPossibleRegion() ); itk::ImageRegionIterator< ImageType > itr2( m_outputImage, m_outputImage->GetLargestPossibleRegion() ); for(itr1.GoToBegin(), itr2.GoToBegin() ; !itr1.IsAtEnd(); ++itr1, ++itr2) { itr2.Set( itr1.Get() ); } iterations--; } if(debug) std::cerr << "Dialation Done" << std::endl; return true; }