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;
}
int main (int argc, char *argv[])
{
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 << "Scales the tensors with a scalar factor" << std::endl;
std::cout << "Usage: -trueB0 <true B0> -m <MaskImage> -true <True Tensors> -f <flag for extended gradient> -t <initial tensor estimate> -g <gradient> -o <Output File> -s <Sigma> -nm <Noise Model> -Sim <intelligent COnvergence>" << std::endl;
return -1;
}
const string image_n =cl.follow("NoFile", 1, "-i");
const string out_n = cl.follow("NoFile", 1, "-o");
const int idx = cl.follow(0, 1, "-ix");
const int idy = cl.follow(0, 1, "-iy");
const int idz = cl.follow(0, 1, "-iz");
const int sx = cl.follow(0, 1, "-sx");
const int sy = cl.follow(0, 1, "-sy");
const int sz = cl.follow(0, 1, "-sz");
typedef itk::Image< float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(image_n);
reader->Update();
ImageType::Pointer image = reader->GetOutput();
ImageType::SizeType size;
ImageType::IndexType id;
id[0] = idx; id[1] = idy; id[2] = idz;
size[0] = sx; size[1] = sy; size[2] =sz;
ImageType::RegionType region(id, size);
typedef itk::ExtractImageFilter<ImageType, ImageType> FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetExtractionRegion(region);
filter->SetInput(image);
filter->SetDirectionCollapseToIdentity();
filter->Update();
ImageType::Pointer exImage = filter ->GetOutput();
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(out_n);
writer->SetInput(exImage);
writer->Update();
return 0;
}
int main(int argc, char *argv[])
{
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;
}
// One idea is to apply the rotation matrix
const string Linear_trans_n = cl.follow("NoFile",1,"-t");
const string ref_Image_n = cl.follow("NoFile",1, "-r");
const string out_n = cl.follow("NoFile",1,"-o");
const string B0_n =cl.follow("NoFile",1,"-B0");
const string T1_n =cl.follow("NoFile",1,"-T1");
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ImageReaderType;
ImageReaderType::Pointer imageReaderB0 = ImageReaderType::New();
imageReaderB0->SetFileName(B0_n);
imageReaderB0->Update();
std::cout << imageReaderB0->GetOutput()->GetDirection() << std::endl;
ImageReaderType::Pointer imageReaderT1 = ImageReaderType::New();
imageReaderT1->SetFileName(B0_n);
imageReaderT1->Update();
std::cout << imageReaderT1->GetOutput()->GetDirection() << std::endl;
// typedef itk::TransformFileReader TransformFileReaderType;
// typedef TransformFileReaderType::TransformListType TransformListType;
// typedef itk::TransformBase TransformBaseType;
// typedef itk::AffineTransform<double, 3> AffineTransformType;
//
// typedef itk::Image<float, 3> ImageType;
// typedef itk::ImageFileReader<ImageType> ImageReaderType;
// ImageReaderType::Pointer imageReader = ImageReaderType::New();
//
// imageReader->SetFileName(ref_Image_n);
// imageReader->Update();
// ImageType::Pointer refImage = imageReader->GetOutput();
//
//
//
// TransformFileReaderType::Pointer readerTransform = TransformFileReaderType::New();
// readerTransform->SetFileName(Linear_trans_n);
// readerTransform -> Update();
// TransformListType *list = readerTransform->GetTransformList();
// TransformBaseType * transform = list->front().GetPointer();
// TransformBaseType::ParametersType parameters = transform->GetParameters();
// AffineTransformType::Pointer transform_fwd = AffineTransformType::New();
// transform_fwd->SetParameters(parameters);
//
// std::cout << transform_fwd->GetParameters() << std::endl;
// typedef itk::Vector< float, 3 > VectorPixelType;
// typedef itk::Image< VectorPixelType, 3 > DisplacementFieldImageType;
//
//
// typedef itk::TransformToDisplacementFieldFilter<DisplacementFieldImageType, double> DisplacementFieldGeneratorType;
// DisplacementFieldGeneratorType::Pointer dispfieldGenerator = DisplacementFieldGeneratorType::New();
//
// dispfieldGenerator->UseReferenceImageOn();
// dispfieldGenerator->SetReferenceImage( refImage );
// dispfieldGenerator->SetTransform( transform_fwd );
// dispfieldGenerator->Update();
// DisplacementFieldImageType::Pointer dispField = dispfieldGenerator->GetOutput();
//
// typedef itk::ImageFileWriter<DisplacementFieldImageType> DispFieldWriterType;
// DispFieldWriterType::Pointer writer = DispFieldWriterType::New();
// writer->SetFileName(out_n);
// writer->SetInput(dispField);
// writer->Update();
return 0;
}
int main (int argc, char *argv[])
{
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 << "Scales the tensors with a scalar factor" << std::endl;
std::cout << "Usage: -trueB0 <true B0> -m <MaskImage> -true <True Tensors> -f <flag for extended gradient> -t <initial tensor estimate> -g <gradient> -o <Output File> -s <Sigma> -nm <Noise Model> -Sim <intelligent COnvergence>" << std::endl;
return -1;
}
const string file_g_n = cl.follow("NoFile",1, "-g");
const string fileIn = cl.follow("NoFile",1,"-i");
const string fileIn_HR = cl.follow("NoFile",1,"-iHR");
const string B0_n = cl.follow("NoFile", 1, "-B0");
const string mask_LR_n = cl.follow("NoFile",1, "-mLR");
const int numOfIter = cl.follow(1,1, "-n");
const float kappa_L = cl.follow(0.05, 1, "-k");
const float lambda_L = cl.follow(0.25, 1, "-lamb_L");
const string B0Image_HR_n = cl.follow("NoFile", 1, "-B0HR");
const string dispField_n = cl.follow("NoFile",1,"-d");
const string T1Image_n = cl.follow("NoFile",1,"-T1");
const string mask_HR_n = cl.follow("NoFile", 1, "-mHR");
// Usual Typedefs
typedef float RealType;
const int ImageDim =3;
typedef itk::Image<RealType, ImageDim> ScalarImageType;
typedef itk::Vector<double, ImageDim> VectorType;
typedef itk::Image<VectorType, ImageDim> DeformationFieldType;
typedef itk::Image<VectorType, ImageDim> VectorImageType;
typedef itk::ImageFileReader<ScalarImageType> ScalarImageReaderType;
typedef itk::ImageFileWriter<ScalarImageType> ScalarImageWriterType;
//Read T1 image
ScalarImageReaderType::Pointer scalarReader = ScalarImageReaderType::New();
scalarReader->SetFileName(T1Image_n.c_str());
scalarReader->Update();
ScalarImageType::Pointer T1_image = scalarReader->GetOutput();
// Read LR ImageList
typedef std::vector<ScalarImageType::Pointer> ImageListType;
ImageListType DWIList;
std::ifstream file(fileIn.c_str());
int numOfImages = 0;
file >> numOfImages;
for (int i=0; i < numOfImages ; i++) // change of numOfImages
{
char filename[256];
file >> filename;
ScalarImageReaderType::Pointer myReader=ScalarImageReaderType::New();
myReader->SetFileName(filename);
std::cout << "Reading.." << filename << std::endl; // add a try catch block
myReader->Update();
DWIList.push_back( myReader->GetOutput() ); //using push back to create a stack of diffusion images
}
// Read deformation field
typedef itk::ImageFileReader<DeformationFieldType> DeformationFieldReaderType;
DeformationFieldReaderType::Pointer deformationFieldReader = DeformationFieldReaderType::New();
deformationFieldReader->SetFileName(dispField_n.c_str());
deformationFieldReader->Update();
DeformationFieldType::Pointer defField = deformationFieldReader->GetOutput();
// Read Mask Image Spatial
typedef itk::ImageMaskSpatialObject<ImageDim> MaskSpatialObjectType;
typedef MaskSpatialObjectType::ImageType MaskSpatialImageType;
typedef itk::ImageFileReader<MaskSpatialImageType> MaskSpatialImageReaderType;
MaskSpatialImageReaderType::Pointer spatialReader = MaskSpatialImageReaderType::New();
spatialReader->SetFileName(mask_LR_n.c_str());
spatialReader->Update();
MaskSpatialImageType::Pointer maskSpatialImage_LR = spatialReader->GetOutput();
//Read Mask Image Normal
ScalarImageReaderType::Pointer maskImageReader = ScalarImageReaderType::New();
maskImageReader->SetFileName(mask_LR_n.c_str());
maskImageReader->Update();
ScalarImageType::Pointer maskImage_LR = maskImageReader->GetOutput();
// Resample diffusion Images
/* typedef itk::WarpImageFilter<ScalarImageType, ScalarImageType, DeformationFieldType> WarpImageFilterType;
typedef itk::ImageFileWriter<ScalarImageType> ScalarImageWriterType;
for (int i =0; i < numOfImages; i++)
{
WarpImageFilterType::Pointer warpImageFilter = WarpImageFilterType::New();
warpImageFilter->SetOutputSpacing(T1_image->GetSpacing());
warpImageFilter->SetOutputOrigin(T1_image->GetOrigin());
warpImageFilter->SetDisplacementField(defField);
warpImageFilter->SetInput(DWIList[i]);
warpImageFilter->Update();
ScalarImageType::Pointer imageDWI = warpImageFilter->GetOutput();
std::ostringstream num_con;
num_con << i ;
std::string result = num_con.str() + ".nii.gz";
ScalarImageWriterType::Pointer writer = ScalarImageWriterType::New();
writer->SetFileName(result);
writer->SetInput(imageDWI);
writer->Update();
std::cout<< i << "Done" << std::endl;
}*/
// Read Gradient List ScalarValues
typedef itk::Vector<double, 3> VectorDoubleType;
typedef std::vector<VectorDoubleType> GradientListType;
GradientListType GradientList;
std::ifstream fileg(file_g_n.c_str());
int numOfGrads =0;
fileg >> numOfGrads;
for (int i=0; i < numOfGrads ; i++)
{
VectorType g;
fileg >> g[0]; fileg >> g[1]; fileg >> g[2];
GradientList.push_back(g);
}
// Transform gradients
// Read the HR diffusion images,
typedef std::vector<ScalarImageType::Pointer> ImageListType;
ImageListType DWIList_HR;
std::ifstream fileHR(fileIn_HR.c_str());
int numOfImagesHR = 0;
fileHR >> numOfImagesHR;
/* for (int i=0; i < numOfImagesHR ; i++) // change of numOfImages
{
char filename[256];
fileHR >> filename;
ScalarImageReaderType::Pointer myReader=ScalarImageReaderType::New();
myReader->SetFileName(filename);
myReader->Update();
std::cout << "Reading.." << filename << std::endl; // add a try catch block
DWIList_HR.push_back(myReader->GetOutput());
}
*/
// Read HR mask image spatial
MaskSpatialImageReaderType::Pointer spatialReader_HR = MaskSpatialImageReaderType::New();
spatialReader_HR->SetFileName(mask_HR_n.c_str());
spatialReader_HR->Update();
MaskSpatialImageType::Pointer maskSpatial_HR = spatialReader_HR->GetOutput();
//Read HR mask image Normal
ScalarImageReaderType::Pointer maskImage_HR_reader = ScalarImageReaderType::New();
maskImage_HR_reader->SetFileName(mask_HR_n.c_str());
maskImage_HR_reader->Update();
ScalarImageType::Pointer maskImage_HR = maskImage_HR_reader->GetOutput();
// Read B0 HR image
ScalarImageReaderType::Pointer B0Image_HR_reader = ScalarImageReaderType::New();
B0Image_HR_reader->SetFileName(B0Image_HR_n.c_str());
B0Image_HR_reader->Update();
ScalarImageType::Pointer B0Image_HR = B0Image_HR_reader->GetOutput();
//Read B0 LR image
ScalarImageReaderType::Pointer B0_image_LR_reader = ScalarImageReaderType::New();
B0_image_LR_reader->SetFileName(B0_n.c_str());
B0_image_LR_reader->Update();
ScalarImageType::Pointer B0_image_LR = B0_image_LR_reader->GetOutput();
// ComputeGradientImages
/* TransformGradients transformGradients;
transformGradients.ReadMaskImage(maskImage_HR);
transformGradients.ReadDeformationField(defField);
transformGradients.ReadGradients(GradientList);
transformGradients.ComputeGradients();
typedef std::vector<VectorImageType::Pointer> GradientImageListType;
GradientImageListType GradientImageList;
GradientImageList = transformGradients.GetGradientImages();
std::cout << "Transformed all Gradients... Done." << std::endl;
typedef itk::ImageFileWriter<VectorImageType> GradientImageWriterType;
for (int i=0; i < numOfGrads; i++)
{
GradientImageWriterType::Pointer gradientImageWriter = GradientImageWriterType::New();
std::ostringstream c;
c << i;
std::string tempName;
tempName = "Gradient_" + c.str() + ".nii.gz";
gradientImageWriter->SetFileName(tempName);
gradientImageWriter->SetInput(GradientImageList[i]);
gradientImageWriter->Update();
}
*/
//Read GradientImages
const string file_gradImage_n = cl.follow("NoFile", 1, "-fG");
std::ifstream fileGImg(file_gradImage_n.c_str());
int numOfGradImages = 0;
fileGImg >> numOfGradImages;
typedef itk::ImageFileReader<VectorImageType> GradientImageReaderType;
typedef std::vector<VectorImageType::Pointer> GradientImageListType;
GradientImageListType gradientImageList;
/* for (int i=0; i < numOfGradImages; i++)
{
char filename[25];
fileGImg >> filename;
VectorImageType::Pointer gradientImage = VectorImageType::New();
GradientImageReaderType::Pointer gradientImageReader = GradientImageReaderType::New();
gradientImageReader->SetFileName(filename);
gradientImageReader->Update();
gradientImageList.push_back(gradientImageReader->GetOutput()) ;
std::cout << "Reading...." << filename << std::endl;
}*/
// Compute the matrix
MapFilterLR2HRDisp filter;
filter.ReadFixedImage(T1_image); //
filter.ReadMovingImage(B0_image_LR);
filter.ReadDeformationField(defField);
filter.ReadMaskImage(maskSpatial_HR);
filter.ComputeMapWithDefField();
vnl_sparse_matrix<float> MapLR2HR, MapHR2LR;
MapLR2HR = filter.GetLR2HRMatrix();
MapHR2LR = filter.GetHR2LRMatrix();
std::cout << "Computing Map done " << std::endl;
std::cout << B0_image_LR->GetLargestPossibleRegion().GetSize() << std::endl;
//
// ComposeImageFilter composeFilter;
// composeFilter.GetHRImage(T1_image);
// composeFilter.GetLRImage(B0_image_LR);
// composeFilter.ReadMatrix(MapLR2HR);
//
// ScalarImageType::Pointer tempImage1 = composeFilter.ComposeIt();
// std::cout << "Composing done " << std::endl;
//
// typedef itk::ImageFileWriter<ScalarImageType> ScalarWriterType;
// ScalarWriterType::Pointer scalarWriter = ScalarWriterType::New();
// scalarWriter->SetFileName("TempImage.nii.gz");
// scalarWriter->SetInput(tempImage1);
// scalarWriter->Update();
/* UnweightedLeastSquaresTensorEstimation UnWeightedTensorEstimator;
UnWeightedTensorEstimator.ReadDWIList(DWIList_HR);
UnWeightedTensorEstimator.ReadMask(maskImage_HR);
UnWeightedTensorEstimator.ReadBVal(1.0);
UnWeightedTensorEstimator.ReadGradientList(gradientImageList);
UnWeightedTensorEstimator.ReadB0Image(B0Image_HR);
typedef itk::DiffusionTensor3D<RealType> DiffusionTensorType;
typedef itk::Image<DiffusionTensorType, ImageDim> TensorImageType;
TensorImageType::Pointer tensorImage_init = UnWeightedTensorEstimator.Compute();
typedef itk::ImageFileWriter<TensorImageType> TensorWriterType;
TensorWriterType::Pointer tensorWriter = TensorWriterType::New();
tensorWriter->SetFileName("TensorImage.nii.gz");
tensorWriter->SetInput(tensorImage_init);
tensorWriter->Update();
//Compute Sigma
vnl_vector<RealType> Sigma;
// Compute Joint Estimation
// JointTensorEstimation jTestimation;
// jTestimation.ReadBVal(1.0);
// jTestimation.ReadDWIList(DWIList_HR);
// jTestimation.ReadMaskImage(maskImage_HR);
// jTestimation.ReadB0Image(B0Image_HR);
// jTestimation.ReadGradientList(gradientImageList);
// jTestimation.ReadInitialTensorImage(tensorImage_init);
// jTestimation.ReadKappa(kappa_L);
*/
return 0;
}
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 mask_n = cl.follow("NoFile", 1, "-m");
const string out_n = cl.follow("NoFile",1, "-o");
typedef itk::DiffusionTensor3D<float> DiffusionTensorType;
typedef itk::Image<DiffusionTensorType, 3> TensorImageType;
typedef itk::ImageFileReader<TensorImageType> TensorReaderType;
TensorReaderType::Pointer reader = TensorReaderType::New();
reader->SetFileName(image_n.c_str());
reader->Update();
TensorImageType::Pointer image = reader->GetOutput();
typedef itk::Image<float, 3> ScalarImageType;
typedef itk::ImageFileReader<ScalarImageType> ScalarReaderType;
ScalarReaderType::Pointer scalarReader = ScalarReaderType::New();
scalarReader->SetFileName(mask_n.c_str());
scalarReader->Update();
ScalarImageType::Pointer maskImage = scalarReader->GetOutput();
typedef itk::ImageRegionIterator<TensorImageType> TensorIterator;
typedef itk::ImageRegionIterator<ScalarImageType> ScalarIterator;
ScalarIterator itMask(maskImage, maskImage->GetLargestPossibleRegion());
TensorUtilities utilsTensor;
TensorImageType::Pointer logTensorImage = utilsTensor.LogTensorImageFilter(image, maskImage);
typedef itk::ImageFileWriter<TensorImageType> TensorImageWriterType;
TensorImageWriterType::Pointer tensorImageWriter = TensorImageWriterType::New();
tensorImageWriter->SetFileName("LogTensorImage_stupid.nii.gz");
tensorImageWriter->SetInput(logTensorImage);
tensorImageWriter->Update();
std::ofstream file;
file.open(out_n);
ScalarImageType::Pointer TraceImage = ScalarImageType::New();
CopyImage cpImage;
cpImage.CopyScalarImage(maskImage, TraceImage);
ScalarIterator itTr(TraceImage, TraceImage->GetLargestPossibleRegion());
TensorIterator itImg(logTensorImage, logTensorImage->GetLargestPossibleRegion());
for(itImg.GoToBegin(), itMask.GoToBegin(), itTr.GoToBegin(); !itTr.IsAtEnd(), !itImg.IsAtEnd(), !itMask.IsAtEnd(); ++itTr, ++itImg, ++itMask)
{
file << itImg.Get().GetTrace() << std::endl;
itTr.Set(itImg.Get().GetTrace()) ;
}
typedef itk::ImageFileWriter<ScalarImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName("LogTense_Trace.nii.gz");
writer->SetInput(TraceImage);
writer->Update();
file.close();
return 0;
}
