// ------------------------------------------------------------------------ void ValveNormaliser::AlignValve(const ValveType::Pointer &input, ValveType::Pointer &output) { if(!output) output = ValveType::New(); ImageType::Pointer image = input->GetImage(); PointType p1 = input->GetP1(); PointType p2 = input->GetP2(); // tranlsation to the origin m_Transform = TransformType::New(); m_Transform->SetCenter(p1); TransformType::OutputVectorType axis; for(unsigned int i = 0; i < 3; i++) { axis[i] = -image->GetDirection()(i,2); } itk::Vector<double, 3> vec1, vec2; for(unsigned int i = 0; i < 3; i++) { vec1[i] = p2[i]-p1[i]; vec2[i] = image->GetDirection()(i,0); } vec1.Normalize(); vec2.Normalize(); double angle = acos(vec2*vec1); itk::Vector<double,3> axis2 = itk::CrossProduct(vec1,vec2); axis2.Normalize(); m_Transform->Rotate3D(axis, angle); typedef itk::ResampleImageFilter<ImageType, ImageType> ResamplerType; ResamplerType::Pointer resampler = ResamplerType::New(); resampler->SetInput(image); resampler->SetTransform(m_Transform); resampler->SetOutputParametersFromImage(image); resampler->Update(); // create the output if(!output) output = ValveLine<3>::New(); output->SetImage(resampler->GetOutput()); output->SetP1(m_Transform->TransformPoint(input->GetP1())); output->SetP2(m_Transform->GetInverseTransform()->TransformPoint(input->GetP2())); output->UpdateIndexs(); }
// ------------------------------------------------------------------------ void transformPointToPatient(const ImageType::Pointer &reference, const SeriesTransform &series, const std::vector<int> &roiOffset, const ImageType::PointType &input, ImageType::PointType &output) { // rotation is easy MatrixType rotTemp = reference->GetDirection().GetVnlMatrix(); MatrixType rotation; rotation.set_size(3,3); for(unsigned int i = 0; i < 3; i++) { rotation(i,0) = rotTemp(i,1); rotation(i,1) = rotTemp(i,0); rotation(i,2) = rotTemp(i,2); } VectorType refOrig = reference->GetOrigin().GetVnlVector(); VectorType offset = vnl_inverse(rotation) * refOrig; vnl_vector<double> vnl_output; // translate the point vnl_output = vnl_inverse(rotation) * input.GetVnlVector(); vnl_output = vnl_output - offset; vnl_output /= reference->GetSpacing()[0]; for(unsigned int i = 0; i < 3; i++) { vnl_output[i] -= roiOffset[i]; vnl_output[i] -= series.translation[i]; } output[0] = vnl_output[0]; output[1] = vnl_output[1]; output[2] = vnl_output[2]; }
bool imageSort(const ImageType::Pointer &im1, const ImageType::Pointer &im2) { ImageType::PointType or1 = im1->GetOrigin(); ImageType::PointType or2 = im2->GetOrigin(); ImageType::DirectionType direction = im1->GetDirection(); itk::Vector<double, 3> dir, v1, v2, normed; for(unsigned int i = 0; i < 3; i++) { dir[i] = direction(i,2); v1[i] = or1[i]; v2[i] = or2[i]; } std::cout << dir << std::endl; double mul1 = v1[0] / dir[0]; double mul2 = v2[0] / dir[0]; return (mul1<mul2); }
// ------------------------------------------------------------------------ void buildOutput(const SeriesTransform::List &series, ImageType::Pointer &outputImage, ImageType::Pointer &outputLabel, const unsigned int & timestep) { // get the output parameters unsigned int slices = series.size(); unsigned int timeSteps = series.front().images.size(); ImageType::Pointer ref = series.front().images.front(); ImageType::SpacingType spacing = ref->GetSpacing(); spacing[2] = series.front().sliceThickness; ImageType::DirectionType direction = ref->GetDirection(); ImageType::PointType origin = ref->GetOrigin(); ImageType::RegionType region = ref->GetLargestPossibleRegion(); region.SetSize(2,slices); // create the outputs outputImage->SetSpacing(spacing); outputImage->SetDirection(direction); outputImage->SetOrigin(origin); outputImage->SetRegions(region); outputImage->Allocate(); outputLabel->SetSpacing(spacing); outputLabel->SetDirection(direction); outputLabel->SetOrigin(origin); outputLabel->SetRegions(region); outputLabel->Allocate(); itk::ImageRegionIterator<ImageType> outLIt(outputLabel, outputLabel->GetLargestPossibleRegion()); itk::ImageRegionIterator<ImageType> outImIt(outputImage, outputImage->GetLargestPossibleRegion()); // loop through the slices for(unsigned int i = 0; i < slices; i++) { ImageType::Pointer im = series[i].images[timestep]; ImageType::Pointer label = series[i].labelImages[timestep]; itk::ImageRegionConstIterator<ImageType> imIt(im, im->GetLargestPossibleRegion()); itk::ImageRegionConstIterator<ImageType> lIt(label, label->GetLargestPossibleRegion()); while(!imIt.IsAtEnd()) { outLIt.Set(lIt.Get()); outImIt.Set(imIt.Get()); ++imIt; ++lIt; ++outLIt; ++outImIt; } } }
// ------------------------------------------------------------------------ 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); }
// ------------------------------------------------------------------------ void DicomParser::writeSeries(const DicomSeries &series, const QString &outputFolder) { // create the series name QString name = QString::fromStdString(series.description); name.replace(" ","_"); name += "_" + QString::number(series.images.front().seriesNumber); name += ".nrrd"; QDir path(outputFolder); QString fullPath = path.absoluteFilePath(name); std::vector<DicomImage> images = series.images; std::sort(images.begin(), images.end()); // write and build the output images typedef itk::Image<unsigned short, 3> ImageType; typedef itk::Image<unsigned short, 4> OutputImageType; typedef itk::ImageFileReader<ImageType> ReaderType; typedef itk::JoinSeriesImageFilter<ImageType, OutputImageType> JoinerType; JoinerType::Pointer joiner = JoinerType::New(); ImageType::Pointer orig; for(unsigned int i = 0; i < images.size(); i++) { ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(images[i].filename); std::cout << images[i].filename << std::endl; reader->SetImageIO(itk::GDCMImageIO::New()); reader->Update(); ImageType::Pointer im = reader->GetOutput(); if(i == 0) orig = im; im->SetOrigin(orig->GetOrigin()); im->SetDirection(orig->GetDirection()); im->SetSpacing(orig->GetSpacing()); joiner->SetInput(i, reader->GetOutput()); } std::cout << joiner->GetOutput()->GetDirection() << std::endl; typedef itk::ImageFileWriter<OutputImageType> WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(joiner->GetOutput()); writer->SetFileName(fullPath.toStdString()); writer->SetImageIO(itk::NrrdImageIO::New()); writer->Update(); }
// ------------------------------------------------------------------------ void computeTransform(const ImageType::Pointer &image, vnl_matrix<double> &transform) { vnl_matrix<double> dirMat = image->GetDirection().GetVnlMatrix(); transform.set_size(4,4); for(unsigned int i = 0; i < 3; i++) { for(unsigned int j = 0; j < 3; j++) { transform(i,j) = dirMat(i,j); } } }
// ------------------------------------------------------------------------ void InitialTransformExtractor::Compute() { GetFilenames(m_Filenames); BuildMapping(m_Mapping); std::string referenceFilename = GetReferenceImageFilename(); // load the reference file typedef itk::ImageFileReader<ImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(referenceFilename); reader->SetImageIO(itk::GDCMImageIO::New()); reader->Update(); ImageType::Pointer refImage = reader->GetOutput(); // flip the x and y axis typedef itk::PermuteAxesImageFilter<ImageType> FlipperType; FlipperType::Pointer flipper = FlipperType::New(); itk::FixedArray<unsigned int, 3> order; order[0] = 1; order[1] = 0; order[2] = 2; flipper->SetOrder(order); flipper->SetInput(refImage); flipper->Update(); //refImage = flipper->GetOutput(); // transformation is the negative origin of the reference ImageType::PointType origin = refImage->GetOrigin(); m_Translation[0] = -origin[0]; m_Translation[1] = -origin[1]; m_Translation[2] = -origin[2]; m_Rotation = refImage->GetDirection().GetInverse(); m_Reference = refImage; }
void NrrdQBallImageReader ::GenerateData() { if ( m_FileName == "") { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename of the vessel tree to be read is empty!"); } else { try { const std::string& locale = "C"; const std::string& currLocale = setlocale( LC_ALL, NULL ); if ( locale.compare(currLocale)!=0 ) { try { setlocale(LC_ALL, locale.c_str()); } catch(...) { MITK_INFO << "Could not set locale " << locale; } } typedef itk::VectorImage<float,3> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(this->m_FileName); reader->Update(); ImageType::Pointer img = reader->GetOutput(); typedef itk::Image<itk::Vector<float,QBALL_ODFSIZE>,3> VecImgType; VecImgType::Pointer vecImg = VecImgType::New(); vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin vecImg->SetDirection( img->GetDirection() ); // Set the image direction vecImg->SetLargestPossibleRegion( img->GetLargestPossibleRegion()); vecImg->SetBufferedRegion( img->GetLargestPossibleRegion() ); vecImg->Allocate(); itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot = ot.Begin(); itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() ); typedef ImageType::PixelType VarPixType; typedef VecImgType::PixelType FixPixType; for (it = it.Begin(); !it.IsAtEnd(); ++it) { VarPixType vec = it.Get(); FixPixType fixVec(vec.GetDataPointer()); ot.Set(fixVec); ++ot; } this->GetOutput()->InitializeByItk(vecImg.GetPointer()); this->GetOutput()->SetVolume(vecImg->GetBufferPointer()); try { setlocale(LC_ALL, currLocale.c_str()); } catch(...) { MITK_INFO << "Could not reset locale " << currLocale; } } catch(std::exception& e) { throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what()); } catch(...) { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!"); } } }
// ------------------------------------------------------------------------ void NormaliseImage(const ImageType::Pointer &input, const ImageType::Pointer &reference, ImageType::Pointer &output, SeriesTransform &trans) { // flip the x and y axis typedef itk::PermuteAxesImageFilter<ImageType> FlipperType; FlipperType::Pointer flipper = FlipperType::New(); itk::FixedArray<unsigned int, 3> order; order[0] = 1; order[1] = 0; order[2] = 2; flipper->SetOrder(order); flipper->SetInput(input); flipper->Update(); output = flipper->GetOutput(); // get the reference offset vnl_vector<double> refOrigin(3); refOrigin[0] = reference->GetOrigin()[0];// + trans.translation[0]; refOrigin[1] = reference->GetOrigin()[1];// + trans.translation[1]; refOrigin[2] = reference->GetOrigin()[2];// + trans.translation[2]; vnl_matrix<double> refRot = reference->GetDirection().GetVnlMatrix(); vnl_matrix<double> refRotInv = vnl_inverse(refRot); vnl_vector<double> refOffset = refRotInv * refOrigin; // get the image origin vnl_vector<double> origin(3); origin[0] = output->GetOrigin()[0]; origin[1] = output->GetOrigin()[1]; origin[2] = output->GetOrigin()[2]; // apply the rotation to the origin origin = refRotInv * origin; // apply the offset to the origin origin = origin - refOffset; // apply the scaling origin /= reference->GetSpacing()[0]; // put the values into the output image ImageType::PointType itkOrigin; itkOrigin[0] = origin[0]; itkOrigin[1] = origin[1]; itkOrigin[2] = origin[2]; ImageType::SpacingType spacing; spacing.Fill(output->GetSpacing()[0] / reference->GetSpacing()[0]); // get the new direction ImageType::DirectionType dirOut = output->GetDirection(); dirOut = reference->GetDirection().GetInverse() * dirOut.GetVnlMatrix(); output->SetSpacing(spacing); output->SetDirection(dirOut); output->SetOrigin(itkOrigin); }
std::vector<itk::SmartPointer<BaseData> > NrrdTensorImageReader::Read() { std::vector<itk::SmartPointer<mitk::BaseData> > result; std::string location = GetInputLocation(); if ( location == "") { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!"); } else { try { mitk::LocaleSwitch localeSwitch("C"); try { std::string fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti.nii.gz"; int c = 0; while( itksys::SystemTools::FileExists(fname3) ) { fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti_" + boost::lexical_cast<std::string>(c) + ".nii.gz"; ++c; } itksys::SystemTools::CopyAFile(location.c_str(), fname3.c_str()); typedef itk::VectorImage<float,3> ImageType; itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(fname3); reader->Update(); ImageType::Pointer img = reader->GetOutput(); TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New(); vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin vecImg->SetDirection( img->GetDirection() ); // Set the image direction vecImg->SetRegions( img->GetLargestPossibleRegion()); vecImg->Allocate(); itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot.GoToBegin(); itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() ); it.GoToBegin(); typedef ImageType::PixelType VarPixType; typedef TensorImage::PixelType FixPixType; int numComponents = img->GetNumberOfComponentsPerPixel(); if (numComponents==6) { MITK_INFO << "Trying to load dti as 6-comp nifti ..."; while (!it.IsAtEnd()) { VarPixType vec = it.Get(); FixPixType fixVec(vec.GetDataPointer()); TensorImage::PixelType tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(3)); tensor.SetElement(4, vec.GetElement(4)); tensor.SetElement(5, vec.GetElement(5)); fixVec = tensor; ot.Set(fixVec); ++ot; ++it; } } else if(numComponents==9) { MITK_INFO << "Trying to load dti as 9-comp nifti ..."; while (!it.IsAtEnd()) { VarPixType vec = it.Get(); TensorImage::PixelType tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(4)); tensor.SetElement(4, vec.GetElement(5)); tensor.SetElement(5, vec.GetElement(8)); FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; ++it; } } else if (numComponents==1) { MITK_INFO << "Trying to load dti as 4D nifti ..."; typedef itk::Image<float,4> ImageType; typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(fname3); reader->Update(); ImageType::Pointer img = reader->GetOutput(); itk::Size<4> size = img->GetLargestPossibleRegion().GetSize(); while (!ot.IsAtEnd()) { TensorImage::PixelType tensor; ImageType::IndexType idx; idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2]; if (size[3]==6) { for (unsigned int te=0; te<size[3]; te++) { idx[3] = te; tensor.SetElement(te, img->GetPixel(idx)); } } else if (size[3]==9) { idx[3] = 0; tensor.SetElement(0, img->GetPixel(idx)); idx[3] = 1; tensor.SetElement(1, img->GetPixel(idx)); idx[3] = 2; tensor.SetElement(2, img->GetPixel(idx)); idx[3] = 4; tensor.SetElement(3, img->GetPixel(idx)); idx[3] = 5; tensor.SetElement(4, img->GetPixel(idx)); idx[3] = 8; tensor.SetElement(5, img->GetPixel(idx)); } else throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of components for DTI file. Should be 6 or 9!"); FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; } } OutputType::Pointer resultImage = OutputType::New(); resultImage->InitializeByItk( vecImg.GetPointer() ); resultImage->SetVolume( vecImg->GetBufferPointer() ); result.push_back( resultImage.GetPointer() ); } catch(...) { MITK_INFO << "Trying to load dti as nrrd ..."; typedef itk::VectorImage<float,3> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(location); reader->Update(); ImageType::Pointer img = reader->GetOutput(); TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New(); vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin vecImg->SetDirection( img->GetDirection() ); // Set the image direction vecImg->SetRegions( img->GetLargestPossibleRegion()); vecImg->Allocate(); itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot.GoToBegin(); itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() ); it.GoToBegin(); typedef ImageType::PixelType VarPixType; typedef TensorImage::PixelType FixPixType; int numComponents = img->GetNumberOfComponentsPerPixel(); itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary(); std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys(); std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin(); std::string metaString; bool readFrame = false; double xx, xy, xz, yx, yy, yz, zx, zy, zz; MeasurementFrameType measFrame; measFrame.SetIdentity(); MeasurementFrameType measFrameTransp; measFrameTransp.SetIdentity(); for (; itKey != imgMetaKeys.end(); itKey ++) { itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString); if (itKey->find("measurement frame") != std::string::npos) { sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); if (xx>10e-10 || xy>10e-10 || xz>10e-10 || yx>10e-10 || yy>10e-10 || yz>10e-10 || zx>10e-10 || zy>10e-10 || zz>10e-10 ) { readFrame = true; measFrame(0,0) = xx; measFrame(0,1) = xy; measFrame(0,2) = xz; measFrame(1,0) = yx; measFrame(1,1) = yy; measFrame(1,2) = yz; measFrame(2,0) = zx; measFrame(2,1) = zy; measFrame(2,2) = zz; measFrameTransp = measFrame.GetTranspose(); } } } if (numComponents==6) { while (!it.IsAtEnd()) { // T'=RTR' VarPixType vec = it.Get(); FixPixType fixVec(vec.GetDataPointer()); if(readFrame) { TensorImage::PixelType tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(3)); tensor.SetElement(4, vec.GetElement(4)); tensor.SetElement(5, vec.GetElement(5)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); fixVec = tensor; } ot.Set(fixVec); ++ot; ++it; } } else if(numComponents==9) { while (!it.IsAtEnd()) { VarPixType vec = it.Get(); TensorImage::PixelType tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(4)); tensor.SetElement(4, vec.GetElement(5)); tensor.SetElement(5, vec.GetElement(8)); if(readFrame) { tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); } FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; ++it; } } else if (numComponents==1) { typedef itk::Image<float,4> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(location); reader->Update(); ImageType::Pointer img = reader->GetOutput(); itk::Size<4> size = img->GetLargestPossibleRegion().GetSize(); while (!ot.IsAtEnd()) { TensorImage::PixelType tensor; ImageType::IndexType idx; idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2]; if (size[3]==6) { for (unsigned int te=0; te<size[3]; te++) { idx[3] = te; tensor.SetElement(te, img->GetPixel(idx)); } } else if (size[3]==9) { idx[3] = 0; tensor.SetElement(0, img->GetPixel(idx)); idx[3] = 1; tensor.SetElement(1, img->GetPixel(idx)); idx[3] = 2; tensor.SetElement(2, img->GetPixel(idx)); idx[3] = 4; tensor.SetElement(3, img->GetPixel(idx)); idx[3] = 5; tensor.SetElement(4, img->GetPixel(idx)); idx[3] = 8; tensor.SetElement(5, img->GetPixel(idx)); } else throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!"); if(readFrame) { tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); } FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; } } else { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!"); } OutputType::Pointer resultImage = OutputType::New(); resultImage->InitializeByItk( vecImg.GetPointer() ); resultImage->SetVolume( vecImg->GetBufferPointer() ); result.push_back( resultImage.GetPointer() ); } } catch(std::exception& e) { throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what()); } catch(...) { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!"); } } return result; }
void NrrdTensorImageReader ::GenerateData() { if ( m_FileName == "") { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!"); } else { try { const std::string& locale = "C"; const std::string& currLocale = setlocale( LC_ALL, NULL ); if ( locale.compare(currLocale)!=0 ) { try { setlocale(LC_ALL, locale.c_str()); } catch(...) { MITK_INFO << "Could not set locale " << locale; } } typedef itk::VectorImage<float,3> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(this->m_FileName); reader->Update(); ImageType::Pointer img = reader->GetOutput(); typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType; VecImgType::Pointer vecImg = VecImgType::New(); vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin vecImg->SetDirection( img->GetDirection() ); // Set the image direction vecImg->SetRegions( img->GetLargestPossibleRegion()); vecImg->Allocate(); itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot = ot.Begin(); itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() ); it = it.Begin(); typedef ImageType::PixelType VarPixType; typedef VecImgType::PixelType FixPixType; int numComponents = img->GetNumberOfComponentsPerPixel(); itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary(); std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys(); std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin(); std::string metaString; bool readFrame = false; double xx, xy, xz, yx, yy, yz, zx, zy, zz; MeasurementFrameType measFrame; measFrame.SetIdentity(); MeasurementFrameType measFrameTransp; measFrameTransp.SetIdentity(); for (; itKey != imgMetaKeys.end(); itKey ++) { itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString); if (itKey->find("measurement frame") != std::string::npos) { sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); if (xx>10e-10 || xy>10e-10 || xz>10e-10 || yx>10e-10 || yy>10e-10 || yz>10e-10 || zx>10e-10 || zy>10e-10 || zz>10e-10 ) { readFrame = true; measFrame(0,0) = xx; measFrame(0,1) = xy; measFrame(0,2) = xz; measFrame(1,0) = yx; measFrame(1,1) = yy; measFrame(1,2) = yz; measFrame(2,0) = zx; measFrame(2,1) = zy; measFrame(2,2) = zz; measFrameTransp = measFrame.GetTranspose(); } } } if (numComponents==6) { while (!it.IsAtEnd()) { // T'=RTR' VarPixType vec = it.Get(); FixPixType fixVec(vec.GetDataPointer()); if(readFrame) { itk::DiffusionTensor3D<float> tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(3)); tensor.SetElement(4, vec.GetElement(4)); tensor.SetElement(5, vec.GetElement(5)); tensor = tensor.PreMultiply(measFrame); tensor = tensor.PostMultiply(measFrameTransp); fixVec = tensor; } ot.Set(fixVec); ++ot; ++it; } } else if(numComponents==9) { while (!it.IsAtEnd()) { VarPixType vec = it.Get(); itk::DiffusionTensor3D<float> tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(4)); tensor.SetElement(4, vec.GetElement(5)); tensor.SetElement(5, vec.GetElement(8)); if(readFrame) { tensor = tensor.PreMultiply(measFrame); tensor = tensor.PostMultiply(measFrameTransp); } FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; ++it; } } else { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!"); } this->GetOutput()->InitializeByItk(vecImg.GetPointer()); this->GetOutput()->SetVolume(vecImg->GetBufferPointer()); try { setlocale(LC_ALL, currLocale.c_str()); } catch(...) { MITK_INFO << "Could not reset locale " << currLocale; } } catch(std::exception& e) { throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what()); } catch(...) { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!"); } } }
void QmitkBasicImageProcessing::StartButtonClicked() { if(!m_SelectedImageNode->GetNode()) return; this->BusyCursorOn(); mitk::Image::Pointer newImage; try { newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData()); } catch ( std::exception &e ) { QString exceptionString = "An error occured during image loading:\n"; exceptionString.append( e.what() ); QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton ); this->BusyCursorOff(); return; } // check if input image is valid, casting does not throw exception when casting from 'NULL-Object' if ( (! newImage) || (newImage->IsInitialized() == false) ) { this->BusyCursorOff(); QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton ); return; } // check if operation is done on 4D a image time step if(newImage->GetDimension() > 3) { mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New(); timeSelector->SetInput(newImage); timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() ); timeSelector->Update(); newImage = timeSelector->GetOutput(); } // check if image or vector image ImageType::Pointer itkImage = ImageType::New(); VectorImageType::Pointer itkVecImage = VectorImageType::New(); int isVectorImage = newImage->GetPixelType().GetNumberOfComponents(); if(isVectorImage > 1) { CastToItkImage( newImage, itkVecImage ); } else { CastToItkImage( newImage, itkImage ); } std::stringstream nameAddition(""); int param1 = m_Controls->sbParam1->value(); int param2 = m_Controls->sbParam2->value(); double dparam1 = m_Controls->dsbParam1->value(); double dparam2 = m_Controls->dsbParam2->value(); double dparam3 = m_Controls->dsbParam3->value(); try{ switch (m_SelectedAction) { case GAUSSIAN: { GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput( itkImage ); gaussianFilter->SetVariance( param1 ); gaussianFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone(); nameAddition << "_Gaussian_var_" << param1; std::cout << "Gaussian filtering successful." << std::endl; break; } case MEDIAN: { MedianFilterType::Pointer medianFilter = MedianFilterType::New(); MedianFilterType::InputSizeType size; size.Fill(param1); medianFilter->SetRadius( size ); medianFilter->SetInput(itkImage); medianFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone(); nameAddition << "_Median_radius_" << param1; std::cout << "Median Filtering successful." << std::endl; break; } case TOTALVARIATION: { if(isVectorImage > 1) { VectorTotalVariationFilterType::Pointer TVFilter = VectorTotalVariationFilterType::New(); TVFilter->SetInput( itkVecImage.GetPointer() ); TVFilter->SetNumberIterations(param1); TVFilter->SetLambda(double(param2)/1000.); TVFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone(); } else { ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New(); floatCaster->SetInput( itkImage ); floatCaster->Update(); FloatImageType::Pointer fImage = floatCaster->GetOutput(); TotalVariationFilterType::Pointer TVFilter = TotalVariationFilterType::New(); TVFilter->SetInput( fImage.GetPointer() ); TVFilter->SetNumberIterations(param1); TVFilter->SetLambda(double(param2)/1000.); TVFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone(); } nameAddition << "_TV_Iter_" << param1 << "_L_" << param2; std::cout << "Total Variation Filtering successful." << std::endl; break; } case DILATION: { BallType binaryBall; binaryBall.SetRadius( param1 ); binaryBall.CreateStructuringElement(); DilationFilterType::Pointer dilationFilter = DilationFilterType::New(); dilationFilter->SetInput( itkImage ); dilationFilter->SetKernel( binaryBall ); dilationFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone(); nameAddition << "_Dilated_by_" << param1; std::cout << "Dilation successful." << std::endl; break; } case EROSION: { BallType binaryBall; binaryBall.SetRadius( param1 ); binaryBall.CreateStructuringElement(); ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New(); erosionFilter->SetInput( itkImage ); erosionFilter->SetKernel( binaryBall ); erosionFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone(); nameAddition << "_Eroded_by_" << param1; std::cout << "Erosion successful." << std::endl; break; } case OPENING: { BallType binaryBall; binaryBall.SetRadius( param1 ); binaryBall.CreateStructuringElement(); OpeningFilterType::Pointer openFilter = OpeningFilterType::New(); openFilter->SetInput( itkImage ); openFilter->SetKernel( binaryBall ); openFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone(); nameAddition << "_Opened_by_" << param1; std::cout << "Opening successful." << std::endl; break; } case CLOSING: { BallType binaryBall; binaryBall.SetRadius( param1 ); binaryBall.CreateStructuringElement(); ClosingFilterType::Pointer closeFilter = ClosingFilterType::New(); closeFilter->SetInput( itkImage ); closeFilter->SetKernel( binaryBall ); closeFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone(); nameAddition << "_Closed_by_" << param1; std::cout << "Closing successful." << std::endl; break; } case GRADIENT: { GradientFilterType::Pointer gradientFilter = GradientFilterType::New(); gradientFilter->SetInput( itkImage ); gradientFilter->SetSigma( param1 ); gradientFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone(); nameAddition << "_Gradient_sigma_" << param1; std::cout << "Gradient calculation successful." << std::endl; break; } case LAPLACIAN: { // the laplace filter requires a float type image as input, we need to cast the itkImage // to correct type ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New(); caster->SetInput( itkImage ); caster->Update(); FloatImageType::Pointer fImage = caster->GetOutput(); LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New(); laplacianFilter->SetInput( fImage ); laplacianFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone(); nameAddition << "_Second_Derivative"; std::cout << "Laplacian filtering successful." << std::endl; break; } case SOBEL: { // the sobel filter requires a float type image as input, we need to cast the itkImage // to correct type ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New(); caster->SetInput( itkImage ); caster->Update(); FloatImageType::Pointer fImage = caster->GetOutput(); SobelFilterType::Pointer sobelFilter = SobelFilterType::New(); sobelFilter->SetInput( fImage ); sobelFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone(); nameAddition << "_Sobel"; std::cout << "Edge Detection successful." << std::endl; break; } case THRESHOLD: { ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New(); thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2); thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1); thFilter->SetInsideValue(1); thFilter->SetOutsideValue(0); thFilter->SetInput(itkImage); thFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone(); nameAddition << "_Threshold"; std::cout << "Thresholding successful." << std::endl; break; } case INVERSION: { InversionFilterType::Pointer invFilter = InversionFilterType::New(); mitk::ScalarType min = newImage->GetScalarValueMin(); mitk::ScalarType max = newImage->GetScalarValueMax(); invFilter->SetMaximum( max + min ); invFilter->SetInput(itkImage); invFilter->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone(); nameAddition << "_Inverted"; std::cout << "Image inversion successful." << std::endl; break; } case DOWNSAMPLING: { ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New(); downsampler->SetInput( itkImage ); NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New(); downsampler->SetInterpolator( interpolator ); downsampler->SetDefaultPixelValue( 0 ); ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing(); spacing *= (double) param1; downsampler->SetOutputSpacing( spacing ); downsampler->SetOutputOrigin( itkImage->GetOrigin() ); downsampler->SetOutputDirection( itkImage->GetDirection() ); ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize(); for ( int i = 0; i < 3; ++i ) { size[i] /= param1; } downsampler->SetSize( size ); downsampler->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone(); nameAddition << "_Downsampled_by_" << param1; std::cout << "Downsampling successful." << std::endl; break; } case FLIPPING: { FlipImageFilterType::Pointer flipper = FlipImageFilterType::New(); flipper->SetInput( itkImage ); itk::FixedArray<bool, 3> flipAxes; for(int i=0; i<3; ++i) { if(i == param1) { flipAxes[i] = true; } else { flipAxes[i] = false; } } flipper->SetFlipAxes(flipAxes); flipper->UpdateLargestPossibleRegion(); newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone(); std::cout << "Image flipping successful." << std::endl; break; } case RESAMPLING: { std::string selectedInterpolator; ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New(); switch (m_SelectedInterpolation) { case LINEAR: { LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New(); resampler->SetInterpolator(interpolator); selectedInterpolator = "Linear"; break; } case NEAREST: { NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New(); resampler->SetInterpolator(interpolator); selectedInterpolator = "Nearest"; break; } default: { LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New(); resampler->SetInterpolator(interpolator); selectedInterpolator = "Linear"; break; } } resampler->SetInput( itkImage ); resampler->SetOutputOrigin( itkImage->GetOrigin() ); ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize(); ImageType::SpacingType input_spacing = itkImage->GetSpacing(); ImageType::SizeType output_size; ImageType::SpacingType output_spacing; output_size[0] = input_size[0] * (input_spacing[0] / dparam1); output_size[1] = input_size[1] * (input_spacing[1] / dparam2); output_size[2] = input_size[2] * (input_spacing[2] / dparam3); output_spacing [0] = dparam1; output_spacing [1] = dparam2; output_spacing [2] = dparam3; resampler->SetSize( output_size ); resampler->SetOutputSpacing( output_spacing ); resampler->SetOutputDirection( itkImage->GetDirection() ); resampler->UpdateLargestPossibleRegion(); ImageType::Pointer resampledImage = resampler->GetOutput(); newImage = mitk::ImportItkImage( resampledImage ); nameAddition << "_Resampled_" << selectedInterpolator; std::cout << "Resampling successful." << std::endl; break; } case RESCALE: { FloatImageType::Pointer floatImage = FloatImageType::New(); CastToItkImage( newImage, floatImage ); itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::Pointer filter = itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::New(); filter->SetInput(0, floatImage); filter->SetOutputMinimum(dparam1); filter->SetOutputMaximum(dparam2); filter->Update(); floatImage = filter->GetOutput(); newImage = mitk::Image::New(); newImage->InitializeByItk(floatImage.GetPointer()); newImage->SetVolume(floatImage->GetBufferPointer()); nameAddition << "_Rescaled"; std::cout << "Rescaling successful." << std::endl; break; } default: this->BusyCursorOff(); return; } } catch (...) { this->BusyCursorOff(); QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input..."); return; } newImage->DisconnectPipeline(); // adjust level/window to new image mitk::LevelWindow levelwindow; levelwindow.SetAuto( newImage ); mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New(); levWinProp->SetLevelWindow( levelwindow ); // compose new image name std::string name = m_SelectedImageNode->GetNode()->GetName(); if (name.find(".pic.gz") == name.size() -7 ) { name = name.substr(0,name.size() -7); } name.append( nameAddition.str() ); // create final result MITK data storage node mitk::DataNode::Pointer result = mitk::DataNode::New(); result->SetProperty( "levelwindow", levWinProp ); result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) ); result->SetData( newImage ); // for vector images, a different mapper is needed if(isVectorImage > 1) { mitk::VectorImageMapper2D::Pointer mapper = mitk::VectorImageMapper2D::New(); result->SetMapper(1,mapper); } // reset GUI to ease further processing // this->ResetOneImageOpPanel(); // add new image to data storage and set as active to ease further processing GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() ); if ( m_Controls->cbHideOrig->isChecked() == true ) m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) ); // TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result); // show the results mitk::RenderingManager::GetInstance()->RequestUpdateAll(); this->BusyCursorOff(); }
void NrrdTensorImageReader ::GenerateData() { if ( m_FileName == "") { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!"); } else { try { const std::string& locale = "C"; const std::string& currLocale = setlocale( LC_ALL, NULL ); if ( locale.compare(currLocale)!=0 ) { try { setlocale(LC_ALL, locale.c_str()); } catch(...) { MITK_INFO << "Could not set locale " << locale; } } try { MITK_INFO << "Trying to load dti as nifti ..."; std::string fname3 = "temp_dti.nii"; itksys::SystemTools::CopyAFile(m_FileName.c_str(), fname3.c_str()); typedef itk::Image<float,4> ImageType; itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(fname3); reader->Update(); itksys::SystemTools::RemoveFile(fname3.c_str()); ImageType::Pointer img = reader->GetOutput(); itk::Size<4> size = img->GetLargestPossibleRegion().GetSize(); itk::ImageRegion< 3 > region; region.SetSize(0,size[0]); region.SetSize(1,size[1]); region.SetSize(2,size[2]); itk::Vector<double,3> spacing; spacing[0] = img->GetSpacing()[0]; spacing[1] = img->GetSpacing()[1]; spacing[2] = img->GetSpacing()[2]; itk::Point<double,3> origin; origin[0] = img->GetOrigin()[0]; origin[1] = img->GetOrigin()[1]; origin[2] = img->GetOrigin()[2]; itk::Matrix<double,3,3> direction; direction[0][0] = img->GetDirection()[0][0]; direction[1][0] = img->GetDirection()[1][0]; direction[2][0] = img->GetDirection()[2][0]; direction[0][1] = img->GetDirection()[0][1]; direction[1][1] = img->GetDirection()[1][1]; direction[2][1] = img->GetDirection()[2][1]; direction[0][2] = img->GetDirection()[0][2]; direction[1][2] = img->GetDirection()[1][2]; direction[2][2] = img->GetDirection()[2][2]; typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType; typedef VecImgType::PixelType FixPixType; VecImgType::Pointer vecImg = VecImgType::New(); vecImg->SetSpacing( spacing ); vecImg->SetOrigin( origin ); vecImg->SetDirection( direction ); vecImg->SetRegions( region ); vecImg->Allocate(); itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot = ot.Begin(); while (!ot.IsAtEnd()) { itk::DiffusionTensor3D<float> tensor; ImageType::IndexType idx; idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2]; if (size[3]==6) { for (int te=0; te<size[3]; te++) { idx[3] = te; tensor.SetElement(te, img->GetPixel(idx)); } } else if (size[3]==9) { idx[3] = 0; tensor.SetElement(0, img->GetPixel(idx)); idx[3] = 1; tensor.SetElement(1, img->GetPixel(idx)); idx[3] = 2; tensor.SetElement(2, img->GetPixel(idx)); idx[3] = 4; tensor.SetElement(3, img->GetPixel(idx)); idx[3] = 5; tensor.SetElement(4, img->GetPixel(idx)); idx[3] = 8; tensor.SetElement(5, img->GetPixel(idx)); } else throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!"); FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; } this->GetOutput()->InitializeByItk(vecImg.GetPointer()); this->GetOutput()->SetVolume(vecImg->GetBufferPointer()); } catch(...) { MITK_INFO << "Trying to load dti as nrrd ..."; typedef itk::VectorImage<float,3> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(this->m_FileName); reader->Update(); ImageType::Pointer img = reader->GetOutput(); typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType; VecImgType::Pointer vecImg = VecImgType::New(); vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin vecImg->SetDirection( img->GetDirection() ); // Set the image direction vecImg->SetRegions( img->GetLargestPossibleRegion()); vecImg->Allocate(); itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() ); ot = ot.Begin(); itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() ); it = it.Begin(); typedef ImageType::PixelType VarPixType; typedef VecImgType::PixelType FixPixType; int numComponents = img->GetNumberOfComponentsPerPixel(); itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary(); std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys(); std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin(); std::string metaString; bool readFrame = false; double xx, xy, xz, yx, yy, yz, zx, zy, zz; MeasurementFrameType measFrame; measFrame.SetIdentity(); MeasurementFrameType measFrameTransp; measFrameTransp.SetIdentity(); for (; itKey != imgMetaKeys.end(); itKey ++) { itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString); if (itKey->find("measurement frame") != std::string::npos) { sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); if (xx>10e-10 || xy>10e-10 || xz>10e-10 || yx>10e-10 || yy>10e-10 || yz>10e-10 || zx>10e-10 || zy>10e-10 || zz>10e-10 ) { readFrame = true; measFrame(0,0) = xx; measFrame(0,1) = xy; measFrame(0,2) = xz; measFrame(1,0) = yx; measFrame(1,1) = yy; measFrame(1,2) = yz; measFrame(2,0) = zx; measFrame(2,1) = zy; measFrame(2,2) = zz; measFrameTransp = measFrame.GetTranspose(); } } } if (numComponents==6) { while (!it.IsAtEnd()) { // T'=RTR' VarPixType vec = it.Get(); FixPixType fixVec(vec.GetDataPointer()); if(readFrame) { itk::DiffusionTensor3D<float> tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(3)); tensor.SetElement(4, vec.GetElement(4)); tensor.SetElement(5, vec.GetElement(5)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); fixVec = tensor; } ot.Set(fixVec); ++ot; ++it; } } else if(numComponents==9) { while (!it.IsAtEnd()) { VarPixType vec = it.Get(); itk::DiffusionTensor3D<float> tensor; tensor.SetElement(0, vec.GetElement(0)); tensor.SetElement(1, vec.GetElement(1)); tensor.SetElement(2, vec.GetElement(2)); tensor.SetElement(3, vec.GetElement(4)); tensor.SetElement(4, vec.GetElement(5)); tensor.SetElement(5, vec.GetElement(8)); if(readFrame) { tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); } FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; ++it; } } else if (numComponents==1) { typedef itk::Image<float,4> ImageType; itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New(); typedef itk::ImageFileReader<ImageType> FileReaderType; FileReaderType::Pointer reader = FileReaderType::New(); reader->SetImageIO(io); reader->SetFileName(this->m_FileName); reader->Update(); ImageType::Pointer img = reader->GetOutput(); itk::Size<4> size = img->GetLargestPossibleRegion().GetSize(); MITK_INFO << size; while (!ot.IsAtEnd()) { itk::DiffusionTensor3D<float> tensor; ImageType::IndexType idx; idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2]; if (size[3]==6) { for (int te=0; te<size[3]; te++) { idx[3] = te; tensor.SetElement(te, img->GetPixel(idx)); } // idx[3] = 0; // tensor.SetElement(0, img->GetPixel(idx)); // idx[3] = 1; // tensor.SetElement(1, img->GetPixel(idx)); // idx[3] = 3; // tensor.SetElement(2, img->GetPixel(idx)); // idx[3] = 2; // tensor.SetElement(3, img->GetPixel(idx)); // idx[3] = 4; // tensor.SetElement(4, img->GetPixel(idx)); // idx[3] = 5; // tensor.SetElement(5, img->GetPixel(idx)); } else if (size[3]==9) { idx[3] = 0; tensor.SetElement(0, img->GetPixel(idx)); idx[3] = 1; tensor.SetElement(1, img->GetPixel(idx)); idx[3] = 2; tensor.SetElement(2, img->GetPixel(idx)); idx[3] = 4; tensor.SetElement(3, img->GetPixel(idx)); idx[3] = 5; tensor.SetElement(4, img->GetPixel(idx)); idx[3] = 8; tensor.SetElement(5, img->GetPixel(idx)); } else throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!"); if(readFrame) { tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame)); tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp)); } FixPixType fixVec(tensor); ot.Set(fixVec); ++ot; } } else { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!"); } this->GetOutput()->InitializeByItk(vecImg.GetPointer()); this->GetOutput()->SetVolume(vecImg->GetBufferPointer()); } try { setlocale(LC_ALL, currLocale.c_str()); } catch(...) { MITK_INFO << "Could not reset locale " << currLocale; } } catch(std::exception& e) { throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what()); } catch(...) { throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!"); } } }
int main(int, char ** argv) { OptionsData options; readXMLValues(argv[2], options); exit(1); // parse the dicom directory gdcm::Directory dir; dir.Load(argv[1], true); gdcm::Directory::FilenamesType filenames = dir.GetFilenames(); gdcm::Tag seriesDescription = gdcm::Tag(0x0008,0x103e); gdcm::Tag seriesNumber = gdcm::Tag(0x0020,0x0011); gdcm::Tag instanceNumber = gdcm::Tag(0x0020,0x0013); gdcm::Tag sliceThickness = gdcm::Tag(0x0018,0x0050); gdcm::Tag triggerTime = gdcm::Tag(0x0018,0x1060); gdcm::Tag numberOfImages = gdcm::Tag(0x0018,0x1090); gdcm::Tag slicePosition = gdcm::Tag(0x0019,0x1015); gdcm::Tag imagePosition = gdcm::Tag(0x0020,0x0032); gdcm::Tag imageOrientation = gdcm::Tag(0x0020,0x0037); gdcm::Tag sliceLocation = gdcm::Tag(0x0020,0x1041); gdcm::Tag rows = gdcm::Tag(0x0028,0x0010); gdcm::Tag cols = gdcm::Tag(0x0028,0x0011); gdcm::Tag pixelSpacing = gdcm::Tag(0x0028,0x0030); gdcm::Scanner scanner; scanner.AddTag(seriesDescription); scanner.AddTag(seriesNumber); scanner.AddTag(instanceNumber); scanner.AddTag(sliceThickness); scanner.AddTag(triggerTime); scanner.AddTag(numberOfImages); scanner.AddTag(slicePosition); scanner.AddTag(imagePosition); scanner.AddTag(imageOrientation); scanner.AddTag(sliceLocation); scanner.AddTag(rows); scanner.AddTag(cols); scanner.AddTag(pixelSpacing); scanner.Scan(filenames); gdcm::Scanner::MappingType mapping = scanner.GetMappings(); // extract all the images that are Short axis and are the first instance gdcm::Directory::FilenamesType targetFilenames; for(unsigned int i = 0; i < filenames.size(); i++) { const char * fname = filenames[i].c_str(); if(mapping.count(fname) == 0) continue; // extract the image information std::string descriptionStr = mapping[fname][seriesDescription]; std::string instanceNumberStr = mapping[fname][instanceNumber]; QString description = QString::fromStdString(descriptionStr); unsigned int instanceNumber = QString::fromStdString(instanceNumberStr).toInt(); // check that the description is a short axis one and is instance 1 if(instanceNumber == 1 && description.contains("sa", Qt::CaseInsensitive)) { targetFilenames.push_back(filenames[i]); } } // sort the images based on their slice position /* gdcm::Sorter sorter; sorter.SetSortFunction(position_sort); sorter.StableSort(targetFilenames); gdcm::Directory::FilenamesType sorted = sorter.GetFilenames(); for(unsigned int i = 0; i < sorted.size(); i++) { const char * fname = sorted[i].c_str(); std::string position = mapping[fname][imagePosition]; std::cout << position << std::endl; std::cout << mapping[fname][sliceLocation] << std::endl; } */ std::cout << targetFilenames.size() << std::endl; // find the slice with the smallest slice position double smallest = 1000000.0; int smallestIndex; for(unsigned int i = 0; i < targetFilenames.size(); i++) { const char * fname = targetFilenames[i].c_str(); std::string slicePosition = mapping[fname][sliceLocation]; double pos = QString::fromStdString(slicePosition).toDouble(); std::cout << pos << std::endl; if(pos < smallest) { smallest = pos; smallestIndex = i; } } // load the image typedef itk::Image<unsigned short, 3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(targetFilenames[smallestIndex]); reader->SetImageIO(itk::GDCMImageIO::New()); reader->Update(); // flip the x and y axis typedef itk::PermuteAxesImageFilter<ImageType> FlipperType; FlipperType::Pointer flipper = FlipperType::New(); itk::FixedArray<unsigned int, 3> order; order[0] = 1; order[1] = 0; order[2] = 2; flipper->SetOrder(order); flipper->SetInput(reader->GetOutput()); flipper->Update(); ImageType::Pointer referenceImage = flipper->GetOutput(); ImageType::DirectionType direction = referenceImage->GetDirection(); direction.SetIdentity(); referenceImage->SetDirection(direction); ImageType::PointType origin = referenceImage->GetOrigin(); origin.Fill(20.0); referenceImage->SetOrigin(origin); ImageType::SpacingType spacing; spacing.Fill(1.0); referenceImage->SetSpacing(spacing); flipper->GetOutput()->Print(std::cout); typedef itk::ImageFileWriter<ImageType> WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetInput(referenceImage); writer->SetImageIO(itk::NrrdImageIO::New()); writer->SetFileName("test.nrrd"); writer->Update(); std::cout << targetFilenames[smallestIndex] << std::endl; return 0; }
vtkSmartPointer<vtkImageData> GNC::GCS::ControladorCarga::CargarITKMultidimensionalUnsignedShort(IComando* cmd, ListaRutas& listaFicheros, int* orientacion, double* spacing) { vtkSmartPointer<vtkImageData> img = vtkSmartPointer<vtkImageData>::New(); //int bitsStored, highBit, bitsAllocated,pixelRepresentation = 0; wxCriticalSectionLocker locker(*m_pCriticalSection); typedef double PixelType; typedef itk::Image<PixelType, 3 > ImageType; typedef itk::GDCMImageIO ImageIOType; typedef itk::ImageSeriesReader<ImageType> GenericReaderType; ImageIOType::Pointer dicomIO = ImageIOType::New(); GenericReaderType::Pointer reader = GenericReaderType::New(); CargaItkProgressCallback::Pointer cbProgreso = CargaItkProgressCallback::New(); try { reader->SetImageIO(dicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } reader->SetFileNames(filesCopy); } else { throw GNC::GCS::ControladorCargaException( "No input files", "ControladorCarga/CargarITKMultidimensionalUnsignedShort"); } //reader->GetOutput()->ReleaseDataFlagOn(); cbProgreso->SetCommand(cmd); cbProgreso->SetTexto(_Std("Reading properties")); reader->AddObserver (itk::ProgressEvent(), cbProgreso); reader->UpdateOutputInformation(); } catch (itk::ExceptionObject& ex) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Error reading the study: ") + ex.GetDescription(), "ControladorCarga/CargaMultidimensional"); } catch (std::exception& ex) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Internal error reading the study: "), std::string("ControladorCarga/CargaMultidimensional") + ex.what()); } catch (...) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Internal error reading the study: "), "ControladorCarga/CargaMultidimensional"); } if (orientacion != NULL) { ImageType::Pointer im = reader->GetOutput(); ImageType::DirectionType dir = im->GetDirection(); /* std::cout << dir[0][0] << ", " << dir[0][1] << ", " << dir[0][2] << std::endl; std::cout << dir[1][0] << ", " << dir[1][1] << ", " << dir[1][2] << std::endl; std::cout << dir[2][0] << ", " << dir[2][1] << ", " << dir[2][2] << std::endl; */ if( std::abs( dir[0][2] ) > std::abs(dir[1][2]) && std::abs( dir[0][2]) > std::abs(dir[2][2])) { //std::cout << "SAGITAL" << std::endl; *orientacion = 0; } else if( std::abs( dir[1][2] ) > std::abs(dir[0][2]) && std::abs( dir[1][2]) > std::abs(dir[2][2])) { //std::cout << "CORONAL" << std::endl; *orientacion = 1; } else if( std::abs( dir[2][2] ) > std::abs(dir[0][2]) && std::abs( dir[2][2]) > std::abs(dir[1][2])) { //std::cout << "AXIAL" << std::endl; *orientacion = 2; } } GenericReaderType::OutputImageType::SizeType dims = reader->GetOutput()->GetLargestPossibleRegion().GetSize(); img->SetDimensions(dims[0], dims[1], dims[2]); img->SetOrigin(dicomIO->GetOrigin(0), dicomIO->GetOrigin(1), dicomIO->GetOrigin(2)); if(spacing == NULL) { double chk_spacing[3] = {dicomIO->GetSpacing(0), dicomIO->GetSpacing(1), dicomIO->GetSpacing(2)}; if (chk_spacing[0] < std::numeric_limits<double>::epsilon() || chk_spacing[1] < std::numeric_limits<double>::epsilon()) { std::stringstream ss; ss << _Std("Spacing is not valid: (") << chk_spacing[0] << ", " << chk_spacing[1] << ", " << chk_spacing[2] << ")"; GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL,ss.str(),GNC::GCS::Events::EventoMensajes::PopUpMessage,GNC::GCS::Events::EventoMensajes::Aviso)); chk_spacing[0] = 1.0f; chk_spacing[1] = 1.0f; chk_spacing[2] = 1.0f; } img->SetSpacing(chk_spacing); } else { double chk_spacing[3] = {spacing[0], spacing[1], spacing[2]}; if (chk_spacing[0] < std::numeric_limits<double>::epsilon() || chk_spacing[1] < std::numeric_limits<double>::epsilon()) { std::stringstream ss; ss << _Std("Spacing is not valid: (") << chk_spacing[0] << ", " << chk_spacing[1] << ", " << chk_spacing[2] << ")"; GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL,ss.str(),GNC::GCS::Events::EventoMensajes::PopUpMessage,GNC::GCS::Events::EventoMensajes::Aviso)); chk_spacing[0] = 1.0f; chk_spacing[1] = 1.0f; chk_spacing[2] = 1.0f; } img->SetSpacing(chk_spacing); } itk::ProcessObject::Pointer processObject; switch(dicomIO->GetComponentType()) { case ImageIOType::UCHAR: { typedef unsigned char TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_UNSIGNED_CHAR, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::CHAR: { typedef char TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_CHAR, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::USHORT: { typedef unsigned short TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_UNSIGNED_SHORT, dicomIO->GetNumberOfComponents()); } catch(const std::bad_alloc&) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Internal Error"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::SHORT: { typedef short TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_SHORT, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::UINT: { typedef unsigned int TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_UNSIGNED_INT, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::INT: { typedef int TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_INT, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::ULONG: { typedef unsigned long TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_UNSIGNED_LONG, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::LONG: { typedef long TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_LONG, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::FLOAT: { typedef float TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_FLOAT, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::DOUBLE: { typedef double TypedPixelType; typedef itk::Image<TypedPixelType, 3 > TypedImageType; typedef itk::ImageSeriesReader<TypedImageType> TypedReaderType; try { img->AllocateScalars(VTK_DOUBLE, dicomIO->GetNumberOfComponents()); } catch (...) { throw GNC::GCS::ControladorCargaException( _Std("Error loading the study: Out of memory"), "ControladorCarga/CargaMultidimensional"); } TypedReaderType::Pointer treader = TypedReaderType::New(); ImageIOType::Pointer tdicomIO = ImageIOType::New(); treader->SetImageIO(tdicomIO); if (listaFicheros.size() > 0) { std::vector<std::string> filesCopy(listaFicheros.size()); GNC::GCS::IControladorCarga::ListaRutas::iterator it = listaFicheros.begin(); std::vector<std::string>::size_type off = 0; while (it != listaFicheros.end()) { filesCopy[off++] = *(it++); } treader->SetFileNames(filesCopy); } treader->SetUseStreaming(true); //treader->GetOutput()->ReleaseDataFlagOn(); treader->GetOutput()->GetPixelContainer()->SetImportPointer((TypedReaderType::OutputImageType::PixelType*)(img->GetScalarPointer()), dims[0] * dims[1] * dims[2], false ); processObject = treader; } break; case ImageIOType::UNKNOWNCOMPONENTTYPE: default: throw GNC::GCS::ControladorCargaException( _Std("Error reading the study: unsupported pixel format"), "ControladorCarga/CargaMultidimensional"); } cbProgreso->SetTexto("Leyendo dataset"); processObject->AddObserver (itk::ProgressEvent(), cbProgreso); try { processObject->UpdateLargestPossibleRegion(); } catch (itk::ExceptionObject& ex) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Error reading the study: ") + ex.GetDescription(), "ControladorCarga/CargaMultidimensional"); } catch (...) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Internal error reading the study: "), "ControladorCarga/CargaMultidimensional"); } if (processObject->GetAbortGenerateData()) { reader->ResetPipeline(); throw GNC::GCS::ControladorCargaException( _Std("Process canceled by user."), "ControladorCarga/CargaMultidimensional"); } //se modifica si es necesario /* { typedef itk::MetaDataObject< std::string > MetaDataStringType; for (itk::MetaDataDictionary::ConstIterator it = dicomIO->GetMetaDataDictionary().Begin(); it != dicomIO->GetMetaDataDictionary().End(); ++it) { itk::MetaDataObjectBase::Pointer entry = it->second; MetaDataStringType::Pointer entryvalue = dynamic_cast<MetaDataStringType *> (entry.GetPointer()); if(it->first == "0028|0100") { //bits allocated std::istringstream is(entryvalue->GetMetaDataObjectValue()); is >>bitsAllocated; } else if(it->first == "0028|0101") { //bits stored std::istringstream is(entryvalue->GetMetaDataObjectValue()); is >>bitsStored; } else if(it->first == "0028|0102") {//high bit std::istringstream is(entryvalue->GetMetaDataObjectValue()); is >>highBit; } else if(it->first == "0028|0103") {//pixel representation=> 0 es unsigned 1 es signed std::istringstream is(entryvalue->GetMetaDataObjectValue()); is >>pixelRepresentation; } } if(bitsAllocated != bitsStored) { switch(dicomIO->GetComponentType()) { case ImageIOType::UCHAR: pixelRepresentation = 0; //a partir de aqui se trata el pixelrepresentation case ImageIOType::CHAR: { unsigned char* data = (unsigned char*) img->GetScalarPointer(); unsigned char desplazamientoSigno; desplazamientoSigno = highBit; unsigned char maskComprobarSigno = 1; maskComprobarSigno <<= desplazamientoSigno; unsigned char maskClearParteAltaPositivo = 0; //se meten unos en la parte baja if(pixelRepresentation == 0) { for(int i = 0; i<= desplazamientoSigno; ++i) { maskClearParteAltaPositivo <<=1; maskClearParteAltaPositivo |=1; } } else { for(int i = 0; i< desplazamientoSigno; ++i) { maskClearParteAltaPositivo <<=1; maskClearParteAltaPositivo |=1; } } //se meten unos en la parte alta unsigned char maskSetParteAltaNegativo = 0x80; if(pixelRepresentation != 0) { for(int i=0; i< 8-desplazamientoSigno; ++i) { maskSetParteAltaNegativo >>=1; maskSetParteAltaNegativo |=0x80; } } int size = dims[0] * dims[1] * dims[2]; if(pixelRepresentation == 0) { if(maskClearParteAltaPositivo != 0xFF) { // si es ff no tiene sentido hacer nada int size = dims[0] * dims[1] * dims[2] * 2; for(int i= 0; i< size; i+=2) { //es positivo data[i] &= maskClearParteAltaPositivo; } } } else { for(int i= 0; i< size; ++i) { if((data[i] & maskComprobarSigno) == 0) { //es positivo data[i] &= maskClearParteAltaPositivo; } else { //es negativo => aplicar el complemento a dos... data[i] |= maskSetParteAltaNegativo; } } } } break; case ImageIOType::USHORT: pixelRepresentation = 0; //a partir de aqui se trata el pixelrepresentation case ImageIOType::SHORT: { unsigned char* data = (unsigned char*) img->GetScalarPointer(); unsigned char posicionInicial; unsigned char desplazamientoSigno; if(highBit>=8) { //little endian desplazamientoSigno = highBit - 8 ; posicionInicial = 1; } else { //bigEndian desplazamientoSigno = highBit; posicionInicial = 0; } unsigned char maskComprobarSigno = 1; maskComprobarSigno <<= desplazamientoSigno; unsigned char maskClearParteAltaPositivo = 0; //se meten unos en la parte baja if(pixelRepresentation == 0) { for(int i = 0; i<= desplazamientoSigno; ++i) { maskClearParteAltaPositivo <<=1; maskClearParteAltaPositivo |=1; } } else { for(int i = 0; i< desplazamientoSigno; ++i) { maskClearParteAltaPositivo <<=1; maskClearParteAltaPositivo |=1; } } //se meten unos en la parte alta unsigned char maskSetParteAltaNegativo = 0x80; if(pixelRepresentation != 0) { for(int i=0; i< 8-desplazamientoSigno; ++i) { maskSetParteAltaNegativo >>=1; maskSetParteAltaNegativo |=0x80; } } int size = dims[0] * dims[1] * dims[2] * 2; if(pixelRepresentation == 0) { if(maskClearParteAltaPositivo != 0xFF) { // si es ff no tiene sentido hacer nada int size = dims[0] * dims[1] * dims[2] * 2; for(int i= posicionInicial; i< size; i+=2) { //es positivo data[i] &= maskClearParteAltaPositivo; } } } else { for(int i= posicionInicial; i< size; i+=2) { if((data[i] & maskComprobarSigno) == 0) { //es positivo data[i] &= maskClearParteAltaPositivo; } else { //es negativo => aplicar el complemento a dos... data[i] |= maskSetParteAltaNegativo; } } } } break; case ImageIOType::UINT: { //d momento no hago na } break; case ImageIOType::INT: { //d momento no hago na } break; case ImageIOType::ULONG: { //d momento no hago na } break; case ImageIOType::LONG: { //d momento no hago na } break; case ImageIOType::FLOAT: case ImageIOType::DOUBLE: break; case ImageIOType::UNKNOWNCOMPONENTTYPE: default: throw GNC::GCS::ControladorCargaException( std::string("Error reading the study: Formato de pixel no soportado"), "ControladorCarga/CargaMultidimensional"); } } }*/ return img; }
int main(int argc, char ** argv) { // load the input matrix utils::MatrixReader::Pointer reader = utils::MatrixReader::New(); reader->SetFilename("/home/om0000/ValveTracking/TrainingData/conf6/conf6-MV-2C-0.hdf5"); reader->Read(); Params pparams("/home/om0000/ValveTracking/TrainingData/conf6/extract_features.json"); MatrixType pos = reader->GetOutput()->doubleData["p1-pos"]; MatrixType neg = reader->GetOutput()->doubleData["p1-neg"]; for(unsigned int tNum = 0; tNum < pos.rows(); tNum++) { MatrixType test = pos.row(tNum); MatrixType others(pos.rows()-1, pos.cols()); unsigned int count = 0; for(unsigned int i = 0; i < pos.rows(); i++) { if(i != tNum) { others.row(count) = pos.row(i); count++; } } unsigned int T = others.rows(); unsigned int Knn = 5; unsigned int newCount = 0; unsigned int NN = 50; srand (time(NULL)); MatrixType smotePos(NN*T, pos.cols()); for(unsigned int i = 0; i < T; i++) { MatrixType s1 = others.row(i); MatrixType dists(T,1); std::vector<IndexDistPair> sortList; for(unsigned int j = 0; j < T; j++) { if(i == j) continue; std::pair<int, double> p(j, (others.row(j)-s1).norm()); sortList.push_back(p); } std::sort(sortList.begin(), sortList.end(), index_sort); unsigned int N = NN; while(N != 0) { int nn = sortList[rand() % Knn].first; MatrixType newF(1, others.cols()); for(unsigned int j = 0; j < others.cols(); j++) { double diff = others(nn,j) - s1(0,j); double gap = (double) rand() / RAND_MAX; smotePos(newCount, j) = round(s1(0,j) + (gap*diff)); } newCount++; N--; } } // combine the pos and neg MatrixType newAll, all; IntMatrixType newLabels, labels; combine(others, neg, all, labels); combine(smotePos, neg, newAll, newLabels); /* cv::Mat vType = cv::Mat(pos.cols()+1, 1, CV_8U); vType.setTo(cv::Scalar(CV_VAR_NUMERICAL)); vType.at<uchar>(pos.cols(), 0) = CV_VAR_CATEGORICAL; cv::Mat X = convert(newAll); cv::Mat y = convert(newLabels); cv::Mat cvtest = convert(test); cv::BoostParams params; params.boost_type = CvBoost::GENTLE; cv::Boost cls; std::cout << "Training" << std::endl; //cls.train(X, CV_ROW_SAMPLE, y, //cv::Mat(), cv::Mat(), vType, cv::Mat(), params); cls.load("cls.cls", "hello"); std::cout << "Testing" << std::endl; std::cout << cls.predict(cvtest, cv::Mat(), cv::Range::all(), false, true) << std::endl; /* cv::RandomTreeParams params; params.max_depth = 25; params.regression_accuracy = 0.00001; cv::NormalBayesClassifier cls; cls.train(X, y); cv::Mat out; cls.predict(cvtest, &out); std::cout << out << std::endl; */ //cv::RandomTrees trees; //trees.train(X, CV_ROW_SAMPLE, y, //cv::Mat(), cv::Mat(), vType, cv::Mat(), params); //std::cout << trees.predict(cvtest) << std::endl; /* MatrixType probs1, probs2; IntMatrixType cls1, cls2; */ vt::SVMClassifier::Pointer svm1 = vt::SVMClassifier::New(); svm1->Train(all, labels); vt::SVMClassifier::Pointer svm2 = vt::SVMClassifier::New(); svm2->Train(newAll, newLabels); // load the image ValveSequenceReader<3>::Pointer reader = ValveSequenceReader<3>::New(); reader->SetFileName(argv[1]); ValveSequence<3>::Pointer sequence = reader->GetOutput(); typedef ValveLine<3> ValveType; typedef ValveType::ImageType ImageType; ValveType::Pointer valve = sequence->GetValveLine(0); ImageType::Pointer image = valve->GetImage(); typedef itk::Image<double, 3> RealImageType; RealImageType::Pointer output = RealImageType::New(); output->SetOrigin(image->GetOrigin()); output->SetSpacing(image->GetSpacing()); output->SetRegions(image->GetLargestPossibleRegion()); output->SetDirection(image->GetDirection()); output->Allocate(); RealImageType::Pointer output2 = RealImageType::New(); output2->SetOrigin(image->GetOrigin()); output2->SetSpacing(image->GetSpacing()); output2->SetRegions(image->GetLargestPossibleRegion()); output2->SetDirection(image->GetDirection()); output2->Allocate(); itk::ImageRegionIterator<RealImageType> it(output, output->GetLargestPossibleRegion()); itk::ImageRegionIterator<RealImageType> it2(output2, output2->GetLargestPossibleRegion()); while(!it.IsAtEnd()) { ImageType::IndexType index = it.GetIndex(); ImageType::PointType pt; output->TransformIndexToPhysicalPoint(index, pt); MatrixType feature; extractLBPFeature(pparams, valve, pt, feature); MatrixType p1,p2; IntMatrixType c1, c2; svm1->PredictProbability(feature, c1, p1); svm2->PredictProbability(feature, c2, p2); it.Set(p1(0,0)); it2.Set(p2(0,0)); ++it2; ++it; } utils::RealVolumeIO::Write("votes.nrrd", output); utils::RealVolumeIO::Write("votes2.nrrd", output); utils::ImageVolumeIO::Write("image.nrrd", image); return 0; } return 0; }
void mitk::DiffusionPropertyHelper::AverageRedundantGradients(double precision) { mitk::GradientDirectionsProperty* DirectionsProperty = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() ); GradientDirectionsContainerType::Pointer oldDirs = DirectionsProperty->GetGradientDirectionsContainer(); GradientDirectionsContainerType::Pointer newDirs = CalcAveragedDirectionSet(precision, oldDirs); // if sizes equal, we do not need to do anything in this function if(oldDirs->size() == newDirs->size()) return; // new image ImageType::Pointer oldImage = ImageType::New(); mitk::CastToItkImage( m_Image, oldImage); ImageType::Pointer newITKImage = ImageType::New(); newITKImage->SetSpacing( oldImage->GetSpacing() ); // Set the image spacing newITKImage->SetOrigin( oldImage->GetOrigin() ); // Set the image origin newITKImage->SetDirection( oldImage->GetDirection() ); // Set the image direction newITKImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() ); newITKImage->SetVectorLength( newDirs->size() ); newITKImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() ); newITKImage->Allocate(); // average image data that corresponds to identical directions itk::ImageRegionIterator< ImageType > newIt(newITKImage, newITKImage->GetLargestPossibleRegion()); newIt.GoToBegin(); itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion()); oldIt.GoToBegin(); // initial new value of voxel ImageType::PixelType newVec; newVec.SetSize(newDirs->size()); newVec.AllocateElements(newDirs->size()); // find which gradients should be averaged GradientDirectionsContainerType::Pointer oldDirections = oldDirs; std::vector<std::vector<int> > dirIndices; for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirs->Begin(); gdcitNew != newDirs->End(); ++gdcitNew) { dirIndices.push_back(std::vector<int>(0)); for(GradientDirectionsContainerType::ConstIterator gdcitOld = oldDirs->Begin(); gdcitOld != oldDirections->End(); ++gdcitOld) { if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision)) { //MITK_INFO << gdcitNew.Value() << " " << gdcitOld.Value(); dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index()); } } } //int ind1 = -1; while(!newIt.IsAtEnd()) { // progress //typename ImageType::IndexType ind = newIt.GetIndex(); //ind1 = ind.m_Index[2]; // init new vector with zeros newVec.Fill(0.0); // the old voxel value with duplicates ImageType::PixelType oldVec = oldIt.Get(); for(unsigned int i=0; i<dirIndices.size(); i++) { // do the averaging const unsigned int numavg = dirIndices[i].size(); unsigned int sum = 0; for(unsigned int j=0; j<numavg; j++) { //MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)]; sum += oldVec[dirIndices[i].at(j)]; } if(numavg == 0) { MITK_ERROR << "VectorImage: Error on averaging. Possibly due to corrupted data"; return; } newVec[i] = sum / numavg; } newIt.Set(newVec); ++newIt; ++oldIt; } mitk::GrabItkImageMemory( newITKImage, m_Image ); m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) ); m_Image->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) ); ApplyMeasurementFrame(); UpdateBValueMap(); std::cout << std::endl; }