void PTXViewerWidget::on_actionReplaceDepthImage_activated()
{
QString fileName = QFileDialog::getOpenFileName(this, "Open Depth Image", "", "Image Files (*.mha)");
if(fileName.toStdString().empty())
{
std::cout << "Filename was empty." << std::endl;
return;
}
typedef itk::ImageFileReader<PTXImage::FloatImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
//this->PTX.ReplaceDepth(reader->GetOutput());
QFuture<void> readerFuture = QtConcurrent::run(&PTX, &PTXImage::ReplaceDepth, reader->GetOutput());
this->FutureWatcher.setFuture(readerFuture);
this->ProgressDialog->setLabelText("Opening depth image...");
this->ProgressDialog->exec();
Display();
this->statusBar()->showMessage("Replaced depth image.");
}
int main(int argc, char* argv[])
{
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
const char* filenamereader = "/Users/Fabian/Documents/Pruebas/Prueba ITK/Archivo Binary/m1.mhd";
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(filenamereader);
reader->Update();
typedef itk::ScalarToFractalImageFilter<ImageType,ImageType> FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput(reader->GetOutput());
FilterType::RadiusType radius;
radius.Fill(3);
filter->SetNeighborhoodRadius(radius);
filter->Update();
// typedef itk::ImageFileWriter<ImageType> WriterType;
// const char* filenamewriter = "xy14_filter.bmp";
// WriterType::Pointer writer = WriterType::New();
// writer->SetFileName(filenamewriter);
// writer->SetInput(filter->GetOutput());
// writer->Update();
return 0;
}
void MriWatcherGUI::LoadOverlay(const QString& filename2)
{
ReaderType::Pointer reader = ReaderType::New();
QString filename = filename2;
filename.replace( QRegExp("\\"), "/" );
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;
}
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
m_imageframelist[i]->g_imageframe->SetInputOverlay(reader->GetOutput() );
m_originalimage = reader->GetOutput();
if( m_originalimage.IsNotNull() )
{
m_imagemanager.SetSourceOverlay(m_originalimage);
g_slice_slider->setEnabled(true);
g_overlay_alpha_slider->setEnabled(true);
}
g_loadimg->setDown(false);
g_loadoverlay->setDown(false);
}
}
void MriWatcherGUI::LoadImg2()
{
QString filename = QFileDialog::getOpenFileName(
this,
tr("Select one image files to open"),
QDir::currentPath(),
tr("*.jpg *.gipl* *.raw* *.hdr *.mha *.mhd* *.nhdr* *nrrd* *nii*") );
if( filename != NULL )
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( filename.toLatin1().constData() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & e )
{
QMessageBox::information( this, "MriWatcher", "Unable to load file:\n" + filename.toLatin1() );
return;
}
m_originalimage = reader->GetOutput();
if( m_originalimage.IsNotNull() )
{
m_imagemanager.SetTargetImage(m_originalimage);
g_alpha->setValue(50);
// g_overlay_alpha_slider->setEnabled(true);
}
g_loadimg2->setDown(false);
}
}
// ------------------------------------------------------------------------
void loadImageSeries(SeriesTransform &series,
const unsigned int &instanceNumbers)
{
// resize the image vector
series.images.resize(series.imageFilenames.size());
typedef itk::GDCMImageIO IOType;
typedef itk::ImageFileReader<ImageType> ReaderType;
for(unsigned int i = 0; i < instanceNumbers; i++)
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetImageIO(IOType::New());
reader->SetFileName(series.imageFilenames[i]);
try
{
reader->Update();
}
catch(itk::ExceptionObject &e)
{
std::cout << e << std::endl;
exit(1);
}
series.images[i] = reader->GetOutput();
}
}
int main (int argc, char *argv[])
{
if(argc != 4)
{
std::cout << "Required arguments: InputFilename(ptx) MaskFilename(png) OutputFilePrefix" << std::endl;
return EXIT_FAILURE;
}
std::string inputFilename = argv[1];
std::string maskFilename = argv[2];
std::string outputFilePrefix = argv[3];
typedef itk::ImageFileReader<itk::Image<unsigned char, 2> > ReaderType;
ReaderType::Pointer maskReader = ReaderType::New();
maskReader->SetFileName(maskFilename);
maskReader->Update();
PTXImage ptxImage = PTXReader::Read(inputFilename);
ptxImage.ApplyMask(maskReader->GetOutput());
ptxImage.WriteRGBImage(outputFilePrefix);
std::stringstream pointsss;
pointsss << outputFilePrefix << ".vtp";
ptxImage.WritePointCloud(pointsss.str());
return EXIT_SUCCESS;
}
void Form::on_btnOpen_clicked()
{
QString fileName = QFileDialog::getOpenFileName(this, "Open File", ".", "Image Files (*.jpg *.jpeg *.bmp *.png)");
std::cout << "Got filename: " << fileName.toStdString() << std::endl;
if(fileName.toStdString().empty())
{
std::cout << "Filename was empty." << std::endl;
return;
}
/*
typedef itk::RGBPixel<unsigned char> RGBPixelType;
typedef itk::Image<RGBPixelType> RGBImageType;
typedef itk::ImageFileReader<RGBImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
RGBImageType::Pointer itkimage = reader->GetOutput();
*/
//typedef itk::VectorImage<unsigned char, 2> ImageType;
typedef itk::VectorImage<char, 2> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
ImageType::Pointer itkimage = reader->GetOutput();
QImage image(itkimage->GetLargestPossibleRegion().GetSize()[0], itkimage->GetLargestPossibleRegion().GetSize()[1], QImage::Format_RGB32);
itk::ImageRegionIterator<ImageType> imageIterator(itkimage, itkimage->GetLargestPossibleRegion());
QColor black(0,0,0);
while(!imageIterator.IsAtEnd())
{
ImageType::PixelType pixel = imageIterator.Get();
//QRgb qtPixel(pixel[0], pixel[1], pixel[2]);
//image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], QColor(pixel[0], pixel[1], pixel[2]).rgb());
image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], black.rgb());
++imageIterator;
}
//QPixmap image;
//image.loadFromData(itkimage->GetBufferPointer());
QGraphicsScene* scene = new QGraphicsScene();
//scene->addPixmap(image);
scene->addPixmap(QPixmap::fromImage(image));
this->graphicsView->setScene(scene);
}
int main(int argc, char** argv) {
if(argc != 3){
std::cout << "Usage: Test2DImage inputFilename outputFilename";
return 1;
}
typedef signed int InputPixelType;
const unsigned int Dimension = 2;
typedef itk::Image<InputPixelType, Dimension> InputImageType;
typedef itk::RGBPixel<unsigned char> RGBPixelType;
typedef itk::Image<RGBPixelType, 2> RGBImageType;
typedef itk::ImageFileReader<InputImageType> ReaderType;
typedef itk::ImageFileWriter<RGBImageType> WriterType;
typedef itk::GDCMImageIO ImageIOType;
typedef itk::GradientAnisotropicDiffusionImageFilter<InputImageType,
InputImageType> DiffusionFilterType;
typedef itk::GradientMagnitudeImageFilter<InputImageType, InputImageType>
GradientMagnitudeFilterType;
typedef itk::Functor::ScalarToRGBPixelFunctor<int> ColorMapFunctorType;
typedef itk::UnaryFunctorImageFilter<InputImageType,
RGBImageType, ColorMapFunctorType> ColorMapFilterType;
typedef itk::JPEGImageIO JImageIOType;
ReaderType::Pointer reader = ReaderType::New();
WriterType::Pointer writer = WriterType::New();
ImageIOType::Pointer GDCMImageIO = ImageIOType::New();
JImageIOType::Pointer JPEGImageIO = JImageIOType::New();
ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New();
reader->SetFileName(argv[1]);
reader->SetImageIO(GDCMImageIO);
try {
reader->Update();
}
catch (itk::ExceptionObject & e) {
std::cerr << "exception in file reader " << std::endl;
std::cerr << e << std::endl;
return 1;
}
DiffusionFilterType::Pointer diffusion = DiffusionFilterType::New();
diffusion->SetNumberOfIterations(1);
diffusion->SetConductanceParameter(4);
diffusion->SetTimeStep(0.125);
GradientMagnitudeFilterType::Pointer gradient = GradientMagnitudeFilterType::New();
diffusion->SetInput(reader->GetOutput());
gradient->SetInput(diffusion->GetOutput());
gradient->Update();
MyWatershedSegmenter<InputImageType> watershed(gradient->GetOutput());
watershed.buildLowerCompleteImage();
watershed.buildLabeledImage();
colormapper->SetInput(watershed.returnFinalImage());
writer->SetInput(colormapper->GetOutput());
writer->UseInputMetaDataDictionaryOff();
writer->SetImageIO(JPEGImageIO);
writer->SetFileName(argv[2]);
writer->Update();
}
int main( int argc, char * argv[] )
{
if( argc < 7 )
{
std::cerr << "Usage: " << std::endl;
std::cerr << argv[0] << std::endl;
std::cerr << " <InputImage> <OutputImage> <LowerThreshold>";
std::cerr << " <UpperThreshold> <OutsideValue> <InsideValue>"
<< std::endl;
return EXIT_FAILURE;
}
const unsigned int Dimension = 2;
typedef unsigned char PixelType;
const char * InputImage = argv[1];
const char * OutputImage = argv[2];
const PixelType LowerThreshold = static_cast<PixelType>(atoi( argv[3] ) );
const PixelType UpperThreshold = static_cast<PixelType>(atoi( argv[4] ) );
const PixelType OutsideValue = static_cast<PixelType>(atoi( argv[5] ) );
const PixelType InsideValue = static_cast<PixelType>(atoi( argv[6] ) );
typedef itk::Image< PixelType, Dimension > ImageType;
typedef itk::ImageFileReader< ImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( InputImage );
typedef itk::BinaryThresholdImageFilter< ImageType, ImageType >
FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput( reader->GetOutput() );
filter->SetLowerThreshold( LowerThreshold );
filter->SetUpperThreshold( UpperThreshold );
filter->SetOutsideValue( OutsideValue );
filter->SetInsideValue( InsideValue );
typedef itk::ImageFileWriter< ImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName( OutputImage );
writer->SetInput( filter->GetOutput() );
try
{
writer->Update();
}
catch( itk::ExceptionObject & e )
{
std::cerr << "Error: " << e << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
bool extractPointAndNormalFromMask(string filename, CVector3 &point, CVector3 &normal1, CVector3 &normal2)
{
ReaderType::Pointer reader = ReaderType::New();
itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
reader->SetImageIO(io);
reader->SetFileName(filename);
try {
reader->Update();
} catch( itk::ExceptionObject & e ) {
cerr << "Exception caught while reading input image " << endl;
cerr << e << endl;
return false;
}
ImageType::Pointer image = reader->GetOutput();
vector<CVector3> result;
ImageType::IndexType ind;
itk::Point<double,3> pnt;
ImageIterator it( image, image->GetRequestedRegion() );
it.GoToBegin();
while(!it.IsAtEnd())
{
if (it.Get()!=0)
{
ind = it.GetIndex();
image->TransformIndexToPhysicalPoint(ind, pnt);
bool added = false;
if (result.size() == 0) {
result.push_back(CVector3(pnt[0],pnt[1],pnt[2]));
added = true;
}
else {
for (vector<CVector3>::iterator it=result.begin(); it!=result.end(); it++) {
if (pnt[2] < (*it)[2]) {
result.insert(it, CVector3(pnt[0],pnt[1],pnt[2]));
added = true;
break;
}
}
}
if (!added) result.push_back(CVector3(pnt[0],pnt[1],pnt[2]));
}
++it;
}
if (result.size() != 3) {
cerr << "Error: Not enough of too many points in the binary mask. Number of point needed = 3. Detected points = " << result.size() << endl;
return false;
}
point = result[1];
normal1 = (result[0]-result[1]).Normalize();
normal2 = (result[2]-result[1]).Normalize();
return true;
}
int main (int argc, char *argv[])
{
// Verify arguments
if(argc != 3)
{
std::cerr << "Required arguments: InputFileName OutputFileName" << std::endl;
return EXIT_FAILURE;
}
// Parse arguments
std::string inputFileName = argv[1];
std::string outputFileName = argv[2];
// Output arguments
std::cout << "Input image: " << inputFileName << std::endl;
std::cout << "Output image: " << outputFileName << std::endl;
//typedef itk::Image<unsigned char, 2> ImageType;
typedef itk::RGBPixel<float> RGBFloatPixelType; // We must use float pixels so that the averaging operation does not overflow
typedef itk::Image<RGBFloatPixelType> RGBFloatImageType;
typedef itk::ImageFileReader<RGBFloatImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(inputFileName);
reader->Update();
SmallHoleFiller<RGBFloatImageType> smallHoleFiller;
smallHoleFiller.SetImage(reader->GetOutput());
RGBFloatImageType::PixelType green;
green.SetRed(0);
green.SetGreen(255);
green.SetBlue(0);
smallHoleFiller.SetHolePixel(green);
smallHoleFiller.GenerateMaskFromImage();
smallHoleFiller.Fill();
typedef itk::RGBPixel<unsigned char> RGBUCharPixelType;
typedef itk::Image<RGBUCharPixelType> RGBUCharImageType;
typedef itk::CastImageFilter<RGBFloatImageType, RGBUCharImageType> CastFilterType;
CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(smallHoleFiller.GetOutput());
castFilter->Update();
typedef itk::ImageFileWriter< RGBUCharImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outputFileName);
writer->SetInput(castFilter->GetOutput());
writer->Update();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
if( argc < 2 )
{
std::cerr<<argv[0]<<" InputImage"<<std::endl;
return EXIT_FAILURE;
}
typedef RGBImageType InputImageType;
typedef RGBImageType2D OutputImageType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
//typedef itk::ImageFileReader< UCharImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( argv[1] );
std::cout<<argv[1]<<std::endl;
try
{
reader->Update();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << "Exception caught !" << std::endl;
std::cerr << excep << std::endl;
}
InputImageType::Pointer in = reader->GetOutput();
Focus *f = new Focus( in );
f->SetRadius(10);
//std::vector<float> vars = f->FindVariance(1.93,4.57,300);
f->MakeVarianceImage();
//OutputImageType::Pointer p = f->MakeProjection();
OutputImageType::Pointer p = f->MakeProjectionColor();
delete f;
typedef itk::ImageFileWriter< OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName( "best.tif" );
writer->SetInput( p );
try
{
writer->Update();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << "Exception caught !" << std::endl;
std::cerr << excep << std::endl;
}
std::cerr << "PRESS ENTER TO EXIT\n";
getchar();
}
int main(int argc, char *argv[])
{
std::string inputFileName = argv[1];
std::string outputPrefix = argv[2];
std::cout << "Input: " << inputFileName << std::endl;
std::cout << "Output prefix: " << outputPrefix << std::endl;
typedef itk::ImageFileReader<FloatVectorImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(inputFileName);
reader->Update();
ClusterColorsAdaptive clusterColors;
clusterColors.SetNumberOfColors(100);
clusterColors.ConstructFromImage(reader->GetOutput());
std::vector<ColorMeasurementVectorType> colorMeasurements = clusterColors.GetColors();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New();
colors->SetName("Colors");
colors->SetNumberOfComponents(3);
for(unsigned int colorId = 0; colorId < colorMeasurements.size(); ++colorId)
{
double point[3];
unsigned char color[3];
for(unsigned int component = 0; component < 3; component++)
{
point[component] = colorMeasurements[colorId][component];
color[component] = colorMeasurements[colorId][component];
}
std::cout << "ColorId " << colorId << " : " << point[0] << " " << point[1] << " " << point[2] << std::endl;
points->InsertNextPoint(point);
colors->InsertNextTupleValue(color);
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->GetPointData()->SetScalars(colors);
vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
glyphFilter->SetInputConnection(polyData->GetProducerPort());
glyphFilter->Update();
vtkSmartPointer<vtkXMLPolyDataWriter> writer = vtkSmartPointer<vtkXMLPolyDataWriter>::New();
writer->SetInputConnection(glyphFilter->GetOutputPort());
writer->SetFileName((outputPrefix + ".vtp").c_str());
writer->Write();
return EXIT_SUCCESS;
}
int main(int argc, char* *argv)
{
GetPot cl(argc, argv);
if( cl.size() == 1 || cl.search(2, "--help", "-h") )
{
std::cout << "Not enough arguments" << std::endl;
return -1;
}
const string image_n = cl.follow("NoFile", 1, "-i");
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(image_n.c_str());
reader-> Update();
ImageType::Pointer image = reader->GetOutput();
typedef itk::ImageRegionIterator<ImageType> ImageIterator;
ImageIterator it(image, image->GetLargestPossibleRegion());
for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
if (it.Get() < -5 )
{
it.Set(1.0);
std::cout << it.GetIndex() << std::endl;
}
else if (it.Get() > 5 )
{
it.Set(1.0);
std::cout << it.GetIndex() << std::endl;
}
else
{
it.Set(0.0);
}
}
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName("Trace_mask.nii.gz");
writer->SetInput(image);
writer->Update();
return 0;
}
int main(int argc,char ** argv){
typedef itk::Image<float,3> ImageType;
typedef itk::Image<float,2> SliceType;
typedef itk::ImageFileReader<ImageType> ReaderType;
typedef itk::ImageFileWriter<SliceType> WriterType;
typedef itk::BoundedReciprocalImageFilter<ImageType,ImageType> BoundedReciprocalType;
BoundedReciprocalType::Pointer boundedReciprocal = BoundedReciprocalType::New();
typedef ttt::AdvectiveDiffusion2DIterationImageFilter<SliceType,SliceType> AdvectionDiffusion2DIterationType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(argv[1]);
reader->UpdateOutputInformation();
typedef itk::ExtractImageFilter<ImageType,SliceType> ExtractorType;
ExtractorType::Pointer extractor = ExtractorType::New();
ImageType::RegionType extractionRegion = reader->GetOutput()->GetLargestPossibleRegion();
extractionRegion.SetSize(2,0);
boundedReciprocal->SetInput(reader->GetOutput());
extractor->SetInput(boundedReciprocal->GetOutput());
extractor->SetExtractionRegion(extractionRegion);
extractor->SetDirectionCollapseToIdentity();
AdvectionDiffusion2DIterationType::Pointer advectionDiffusionIteration =AdvectionDiffusion2DIterationType::New();
advectionDiffusionIteration->SetInput(extractor->GetOutput());
advectionDiffusionIteration->SetNumberOfThreads(1.0);
WriterType::Pointer sliceWriter = WriterType::New();
sliceWriter->SetInput(extractor->GetOutput());
sliceWriter->SetFileName(argv[2]);
sliceWriter->Update();
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(argv[3]);
writer->SetInput(advectionDiffusionIteration->GetOutput());
writer->Update();
}
int main(int argc, char*argv[])
{
// Verify arguments
if(argc != 4)
{
std::cerr << "Required: image.png mask.fgmask output.png" << std::endl;
return EXIT_FAILURE;
}
// Parse arguments
std::string imageFilename = argv[1];
// This image should have white pixels indicating foreground pixels and be black elsewhere.
std::string maskFilename = argv[2];
std::string outputFilename = argv[3];
// Output arguments
std::cout << "imageFilename: " << imageFilename << std::endl
<< "maskFilename: " << maskFilename << std::endl
<< "outputFilename: " << outputFilename << std::endl;
// The type of the image to segment
typedef itk::Image<itk::CovariantVector<unsigned char, 3>, 2> ImageType;
// Read the image
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(imageFilename);
reader->Update();
// Read the mask
ForegroundBackgroundSegmentMask::Pointer mask =
ForegroundBackgroundSegmentMask::New();
mask->Read(maskFilename);
// Perform the segmentation
std::cout << "Starting GrabCut..." << std::endl;
GrabCut<ImageType> grabCut;
grabCut.SetImage(reader->GetOutput());
grabCut.SetInitialMask(mask);
grabCut.PerformSegmentation();
// Get and write the result
ImageType::Pointer result = ImageType::New();
grabCut.GetSegmentedImage(result);
ITKHelpers::WriteImage(result.GetPointer(), outputFilename);
return 0;
}
bool itkDataSHImageReader::read (const QString &path)
{
this->readInformation ( path );
dtkDebug() << "Read with: " << this->description();
if (medAbstractData *medData = dynamic_cast<medAbstractData*>(this->data()) ) {
if (medData->identifier()=="itkDataSHImageDouble3") {
typedef itk::VectorImage<double, 3> SHImageType;
typedef itk::ImageFileReader<SHImageType> ReaderType;
SHImageType::Pointer image = 0;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName ( path.toLatin1().constData() );
try {
reader->Update();
}
catch (itk::ExceptionObject &e) {
dtkDebug() << e.GetDescription();
return false;
}
image = reader->GetOutput();
medData->setData (image);
}
else if (medData->identifier()=="itkDataSHImageFloat3") {
typedef itk::VectorImage<float, 3> SHImageType;
typedef itk::ImageFileReader<SHImageType> ReaderType;
SHImageType::Pointer image = 0;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName ( path.toLatin1().constData() );
try {
reader->Update();
}
catch (itk::ExceptionObject &e) {
dtkDebug() << e.GetDescription();
return false;
}
image = reader->GetOutput();
medData->setData (image);
}
else {
dtkDebug() << "Unsupported data type";
return false;
}
}
else {
dtkDebug() << "No data set or could not create one";
return false;
}
return true;
}
int main( int argc, char** argv )
{
if( argc < 2 )
{
std::cerr << "Usage: " << argv[0] << " inputImage" << std::endl;
return 1;
}
const unsigned int Dimension = 3;
typedef float PixelType;
typedef itk::Image< PixelType, Dimension > ImageType;
typedef itk::ImageFileReader< ImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( argv[1] );
try
{
reader->Update();
}
catch( itk::ExceptionObject& e )
{
std::cerr << "Error: " << e << std::endl;
return 1;
}
ImageType::ConstPointer output = reader->GetOutput();
typedef itk::BoxMeanImageFilter< ImageType, ImageType > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput( reader->GetOutput() );
FilterType::RadiusType radius;
radius.Fill( 3 );
filter->SetRadius( radius );
try
{
filter->Update();
}
catch( itk::ExceptionObject& e )
{
std::cerr << "Error: " << e << std::endl;
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
if(argc < 3)
{
std::cerr << "Required: inputFilename outputFilename" << std::endl;
return EXIT_FAILURE;
}
std::string inputFilename = argv[1];
std::string outputFilename = argv[2];
std::cout << "inputFilename " << inputFilename << std::endl;
std::cout << "outputFilename " << outputFilename << std::endl;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(inputFilename);
reader->Update();
typedef itk::DerivativeImageFilter<ImageType, ImageType> DerivativeImageFilterType;
DerivativeImageFilterType::Pointer xDerivativeFilter = DerivativeImageFilterType::New();
xDerivativeFilter->SetDirection(0);
xDerivativeFilter->SetOrder(1);
xDerivativeFilter->SetInput(reader->GetOutput());
xDerivativeFilter->Update();
DerivativeImageFilterType::Pointer yDerivativeFilter = DerivativeImageFilterType::New();
yDerivativeFilter->SetOrder(1);
yDerivativeFilter->SetDirection(1);
yDerivativeFilter->SetInput(reader->GetOutput());
yDerivativeFilter->Update();
typedef itk::ComposeImageFilter<ImageType, GradientImageType> ComposeImageFilterType;
ComposeImageFilterType::Pointer composeFilter = ComposeImageFilterType::New();
composeFilter->SetInput1(xDerivativeFilter->GetOutput());
composeFilter->SetInput2(yDerivativeFilter->GetOutput());
composeFilter->Update();
typedef itk::ImageFileWriter<GradientImageType> WriterType;
WriterType::Pointer xWriter = WriterType::New();
xWriter->SetFileName(outputFilename);
xWriter->SetInput(composeFilter->GetOutput());
xWriter->Update();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
std::string inputFileName = argv[1];
std::string outputPrefix = argv[2];
std::cout << "Input: " << inputFileName << std::endl;
std::cout << "Output prefix: " << outputPrefix << std::endl;
typedef itk::ImageFileReader<FloatVectorImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(inputFileName);
reader->Update();
HelpersOutput::WriteVectorImageAsRGB(reader->GetOutput(), outputPrefix + "/Image.mha");
WriteImagePixelsToRGBSpace(reader->GetOutput(), outputPrefix + "/ImageColors.vtp");
WriteClusteredPixelsInRGBSpace(reader->GetOutput(), 20, outputPrefix + "/ImageColorsClustered.vtp");
FloatVectorImageType::Pointer blurred = FloatVectorImageType::New();
//float blurVariance = 2.0f; // almost no visible blurring
//float blurVariance = 10.0f; // slight blurring of concrete
float blurVariance = 30.0f;
Helpers::AnisotropicBlurAllChannels<FloatVectorImageType>(reader->GetOutput(), blurred, blurVariance);
HelpersOutput::WriteVectorImageAsRGB(blurred, outputPrefix + "/BlurredImage.mha");
WriteImagePixelsToRGBSpace(blurred, outputPrefix + "/BlurredImageColors.vtp");
WriteClusteredPixelsInRGBSpace(blurred, 20, outputPrefix + "/BlurredImageColorsClustered.vtp");
return EXIT_SUCCESS;
}
virtual void SetUp() {
m_KernelReader = ReaderType::New();
m_InputReader = ReaderType::New();
m_Rescaler = Rescaler01FilterType::New();
m_Rescaler->SetInput(m_InputReader->GetOutput());
m_Rescaler->SetOutputMinimum(0);
m_Rescaler->SetOutputMaximum(1);
m_Deconvoluter = DeconvolutionFilterType::New();
m_Deconvoluter->SetKernelImage( m_KernelReader->GetOutput() );
m_Deconvoluter->SetInput( m_Rescaler->GetOutput() );
m_Writer = WriterType::New();
m_Writer->SetInput( m_Deconvoluter->GetOutput() );
}
itk::Image<unsigned char, 3>::Pointer boner::Importer::import(std::string path)
{
itk::Image<unsigned char, 3>::Pointer image;
typedef itk::ImageSeriesReader<itk::Image<unsigned char, 3>> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
itk::GDCMSeriesFileNames::Pointer namegenerator = itk::GDCMSeriesFileNames::New();
namegenerator->SetInputDirectory(path);
reader->SetImageIO(itk::GDCMImageIO::New());
reader->SetFileNames(namegenerator->GetInputFileNames());
image = reader->GetOutput();
image->Update();
return image;
}
void LidarSegmentationWidget::on_action_Selections_LoadFromImage_triggered()
{
QString filename = QFileDialog::getOpenFileName(this,
"Open Image", ".", "PNG Files (*.png)");
if(filename.isEmpty())
{
return;
}
typedef itk::ImageFileReader< RGBImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(filename.toStdString());
reader->Update();
RGBPixelType greenPixel;
greenPixel.SetRed(0);
greenPixel.SetGreen(255);
greenPixel.SetBlue(0);
RGBPixelType redPixel;
redPixel.SetRed(255);
redPixel.SetGreen(0);
redPixel.SetBlue(0);
itk::ImageRegionConstIterator<RGBImageType> imageIterator(reader->GetOutput(),
reader->GetOutput()->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
if(imageIterator.Get() == greenPixel)
{
this->Sources.push_back(imageIterator.GetIndex());
}
else if(imageIterator.Get() == redPixel)
{
this->Sinks.push_back(imageIterator.GetIndex());
}
++imageIterator;
}
UpdateSelections();
}
int zernike:: ReadInputImage(std::string imageFileName)
{
inputImage = ImageType::New();
typedef itk::ImageFileReader< ImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( imageFileName );
try
{
reader->Update();
}
catch ( itk::ExceptionObject &err)
{
std::cout << "ExceptionObject caught !" << std::endl;
std::cout << err << std::endl;
return -1;
}
inputImage = reader->GetOutput();
}
void FileSelector::LoadAndDisplayImage()
{
this->ImageFileName = this->FileSelectionWidgetImage->currentIndex().data(QFileSystemModel::FilePathRole).toString().toStdString();
typedef itk::ImageFileReader<FloatVectorImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(this->ImageFileName);
reader->Update();
this->Image = reader->GetOutput();
QImage image = HelpersQt::GetQImageColor<FloatVectorImageType>(this->Image, this->Image->GetLargestPossibleRegion());
image = HelpersQt::FitToGraphicsView(image, this->graphicsViewImage);
this->ImageGraphicsScene->clear();
this->ImageGraphicsScene->addPixmap(QPixmap::fromImage(image));
Verify();
}
void FileSelector::LoadAndDisplayMask()
{
this->MaskFileName = this->FileSelectionWidgetMask->currentIndex().data(QFileSystemModel::FilePathRole).toString().toStdString();
typedef itk::ImageFileReader<Mask> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(this->MaskFileName);
reader->Update();
this->ImageMask = reader->GetOutput();
QImage mask = HelpersQt::GetQImageScalar<Mask>(this->ImageMask, this->ImageMask->GetLargestPossibleRegion());
mask = HelpersQt::FitToGraphicsView(mask, this->graphicsViewMask);
this->MaskGraphicsScene->clear();
this->MaskGraphicsScene->addPixmap(QPixmap::fromImage(mask));
Verify();
}
std::vector<cleaver::AbstractScalarField*>
NRRDTools::loadNRRDFiles(std::vector<std::string> files,
double sigma) {
std::vector<cleaver::AbstractScalarField*> fields;
size_t num = 0;
for (auto file : files) {
// read file using ITK
if (file.find(".nrrd") != std::string::npos) {
itk::NrrdImageIOFactory::RegisterOneFactory();
} else if (file.find(".mha") != std::string::npos) {
itk::MetaImageIOFactory::RegisterOneFactory();
}
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(file);
reader->Update();
//do some blurring
GaussianBlurType::Pointer blur = GaussianBlurType::New();
blur->SetInput(reader->GetOutput());
blur->SetVariance(sigma * sigma);
blur->Update();
ImageType::Pointer img = blur->GetOutput();
//convert the image to a cleaver "abstract field"
auto region = img->GetLargestPossibleRegion();
auto numPixel = region.GetNumberOfPixels();
float *data = new float[numPixel];
auto x = region.GetSize()[0], y = region.GetSize()[1], z = region.GetSize()[2];
fields.push_back(new cleaver::FloatField(data, x, y, z));
auto beg = file.find_last_of("/") + 1;
auto name = file.substr(beg, file.size() - beg);
fields[num]->setName(name);
itk::ImageRegionConstIterator<ImageType> imageIterator(img, region);
size_t pixel = 0;
while (!imageIterator.IsAtEnd()) {
// Get the value of the current pixel
float val = static_cast<float>(imageIterator.Get());
((cleaver::FloatField*)fields[num])->data()[pixel++] = val;
++imageIterator;
}
((cleaver::FloatField*)fields[num])->setScale(cleaver::vec3(1., 1., 1.));
num++;
}
return fields;
}
void segmentation::on_filterButton_clicked()
{
typedef float InputPixelType;
typedef float OutputPixelType;
typedef itk::Image< InputPixelType, 3 > InputImageType;
typedef itk::Image< OutputPixelType, 3> OutputImageType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
typedef itk::CurvatureAnisotropicDiffusionImageFilter<
InputImageType, OutputImageType > FilterType;
FilterType::Pointer filter = FilterType::New();
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( inputFileName);
filter->SetInput( reader->GetOutput() );
const unsigned int numberOfIterations = 3;//5
const double timeStep = 0.0625; //timeStep=0.125(for 2D), 0.0625(for 3D)
const double conductance = 3;//3
filter->SetNumberOfIterations( numberOfIterations );
filter->SetTimeStep( timeStep );
filter->SetConductanceParameter( conductance );
filter->Update();//time-costing
typedef unsigned short WritePixelType;//unsigned char
typedef itk::Image< WritePixelType, 3 > WriteImageType;
typedef itk::RescaleIntensityImageFilter<
OutputImageType, WriteImageType > RescaleFilterType;
RescaleFilterType::Pointer rescaler = RescaleFilterType::New();
rescaler->SetOutputMinimum( 0 );
rescaler->SetOutputMaximum( 65535 );//255 for CNV, for PED
typedef itk::ImageFileWriter< WriteImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
filePrefix = filePrefix + "_filter.mhd";
strcpy(outputFileName, filePrefix.c_str());//string to char*
writer->SetFileName(outputFileName);
rescaler->SetInput( filter->GetOutput() );
writer->SetInput( rescaler->GetOutput() );
writer->Update();
//将结果图返回主窗口显示
emit returnOutputFileName(outputFileName);//发出信号
}
void PTXViewerWidget::on_actionReplaceColorImage_activated()
{
QString fileName = QFileDialog::getOpenFileName(this, "Open Color Image", "", "Image Files (*.mha *.png)");
if(fileName.toStdString().empty())
{
std::cout << "Filename was empty." << std::endl;
return;
}
typedef itk::ImageFileReader<PTXImage::RGBImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
this->PTX.ReplaceRGB(reader->GetOutput());
Display();
this->statusBar()->showMessage("Replaced color image.");
}
int main (int argc, char *argv[])
{
const unsigned int ImageDimension = 2;
GetPot cl (argc, const_cast<char**>(argv));
if( cl.size() == 1 || cl.search (2,"--help","-h") )
{
std::cout << "Not Enough Arguments" << std::endl;
std::cout << "Generate the Gradient Table" << std::endl;
std::cout << "Usage: return -1" << std::endl;
}
const string image_n = cl.follow("NoFile",1, "-i");
const string out_n = cl.follow("NoFile",1, "-o");
typedef itk::DiffusionTensor3D<float> DiffusionTensorType;
typedef itk::Image<DiffusionTensorType, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(image_n);
reader->Update();
ImageType::Pointer image = reader->GetOutput();
typedef itk::ImageRegionIterator<ImageType> TensorIterator;
TensorIterator itImg(image, image->GetLargestPossibleRegion());
std::ofstream file;
file.open(out_n);
for(itImg.GoToBegin(); !itImg.IsAtEnd(); ++itImg)
{
file << itImg.Get() << std::endl;
}
file.close();
return 0;
}
