// clitk
#include "clitkCommon.h"
+// itk
+#include <itkImageSource.h>
+
+// vtk
+#include <vtkSmartPointer.h>
+#include <vtkPolyData.h>
+
namespace clitk {
/* --------------------------------------------------------------------
itkSetMacro(LikeImage, ImagePointer);
itkGetConstMacro(LikeImage, ImagePointer);
+ itkSetMacro(Extrude, bool);
+ itkGetMacro(Extrude, bool);
+
protected:
MeshToBinaryImageFilter();
virtual ~MeshToBinaryImageFilter() {}
virtual void GenerateOutputInformation();
virtual void GenerateData();
+ bool m_Extrude;
ImagePointer m_LikeImage;
vtkSmartPointer<vtkPolyData> m_Mesh;
//--------------------------------------------------------------------
template <class ImageType>
clitk::MeshToBinaryImageFilter<ImageType>::
-MeshToBinaryImageFilter():itk::ImageSource<ImageType>()
+MeshToBinaryImageFilter() : itk::ImageSource<ImageType>(), m_Extrude(true)
{
}
//--------------------------------------------------------------------
sts->SetInformationInput(binary_image);
// Extrusion
- vtkSmartPointer<vtkLinearExtrusionFilter> extrude=vtkSmartPointer<vtkLinearExtrusionFilter>::New();
- extrude->SetInput(m_Mesh);
- // We extrude in the -slice_spacing direction to respect the FOCAL convention
- extrude->SetVector(0, 0, -m_LikeImage->GetSpacing()[2]);
- sts->SetInput(extrude->GetOutput());
+ if (m_Extrude)
+ {
+ vtkSmartPointer<vtkLinearExtrusionFilter> extrude=vtkSmartPointer<vtkLinearExtrusionFilter>::New();
+ extrude->SetInput(m_Mesh);
+ // We extrude in the -slice_spacing direction to respect the FOCAL convention
+ extrude->SetVector(0, 0, -m_LikeImage->GetSpacing()[2]);
+ sts->SetInput(extrude->GetOutput());
+ }
+ else
+ sts->SetInput(m_Mesh);
// Stencil
vtkSmartPointer<vtkImageStencil> stencil=vtkSmartPointer<vtkImageStencil>::New();
m_Exporter->SetInput( stencil->GetOutput() );
m_Importer->Update();
- writeImage<ImageType>(m_Importer->GetOutput(), "f.mhd");
+ // writeImage<ImageType>(m_Importer->GetOutput(), "f.mhd");
this->SetNthOutput(0, m_Importer->GetOutput());
typename ImageType::RegionType region;
typename ImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
typename ImageType::PointType p = image->GetOrigin();
- p[dim] = min;
+ if (min > p[dim]) p[dim] = min; // Check if not outside the image
typename ImageType::IndexType start;
image->TransformPhysicalPointToIndex(p, start);
- p[dim] = max;
+ double m = image->GetOrigin()[dim] + size[dim]*image->GetSpacing()[dim];
+ if (max > m) p[dim] = m; // Check if not outside the image
+ else p[dim] = max;
typename ImageType::IndexType end;
image->TransformPhysicalPointToIndex(p, end);
size[dim] = abs(end[dim]-start[dim]);
option "input2" j "Input mask 2" string yes
option "output" o "Output filename" string yes
-option "type" t "Bool type : " int default="1" no
+option "type" t "Bool type (0=AndNot, 1=And, 2=Or)" int default="1" no
ExtractStation_1RL_Post_Limits();
m_Working_Support = m_ListOfStations["1R"];
Remove_Structures(" 1R", "ScaleneMuscleAnt");
- Remove_Structures(" 1R", "CommonCarotidArteryRight");
+ Remove_Structures(" 1R", "RightCommonCarotidArtery");
m_Working_Support = m_ListOfStations["1L"];
Remove_Structures(" 1L", "ScaleneMuscleAnt");
- Remove_Structures(" 1L", "CommonCarotidArteryLeft");
+ Remove_Structures(" 1L", "LeftCommonCarotidArtery");
// Generic RelativePosition processes
m_ListOfStations["1R"] = this->ApplyRelativePositionList("Station_1R", m_ListOfStations["1R"]);
// m_Working_Support must be set
Remove_Structures(s, "BrachioCephalicVein");
Remove_Structures(s, "BrachioCephalicArtery");
- Remove_Structures(s, "CommonCarotidArteryLeft");
- Remove_Structures(s, "CommonCarotidArteryRight");
- Remove_Structures(s, "SubclavianArteryLeft");
- Remove_Structures(s, "SubclavianArteryRight");
+ Remove_Structures(s, "LeftCommonCarotidArtery");
+ Remove_Structures(s, "RightCommonCarotidArtery");
+ Remove_Structures(s, "LeftSubclavianArtery");
+ Remove_Structures(s, "RightSubclavianArtery");
Remove_Structures(s, "Thyroid");
Remove_Structures(s, "Aorta");
}
ExtractStation_3A_Remove_Structures()
{
Remove_Structures(" 3A", "Aorta");
- Remove_Structures(" 3A", "SubclavianArteryLeft");
- Remove_Structures(" 3A", "SubclavianArteryRight");
+ Remove_Structures(" 3A", "LeftSubclavianArtery");
+ Remove_Structures(" 3A", "RightSubclavianArtery");
Remove_Structures(" 3A", "Thyroid");
- Remove_Structures(" 3A", "CommonCarotidArteryLeft");
- Remove_Structures(" 3A", "CommonCarotidArteryRight");
+ Remove_Structures(" 3A", "LeftCommonCarotidArtery");
+ Remove_Structures(" 3A", "RightCommonCarotidArtery");
Remove_Structures(" 3A", "BrachioCephalicArtery");
// Remove_Structures("3A", "Bones"); --> should be in extractmediastinum
// Remove_Structures("3A", "BrachioCephalicVein"); ?
m_ListOfStations["3P"] = m_Working_Support;
StopCurrentStep<MaskImageType>(m_Working_Support);
- // ExtractStation_3P_LR_inf_Limits(); // <-- done in RelPosList
-
// Generic RelativePosition processes
m_ListOfStations["3P"] = this->ApplyRelativePositionList("Station_3P", m_ListOfStations["3P"]);
m_Working_Support = m_ListOfStations["3P"];
// LR limits superiorly => not here for the moment because not clear in the def
// ExtractStation_3P_LR_sup_Limits_2(); //TODO
// ExtractStation_3P_LR_sup_Limits(); // old version to change
+ // ExtractStation_3P_LR_inf_Limits(); // <-- done in RelPosList
// Store image filenames into AFDB
writeImage<MaskImageType>(m_ListOfStations["3P"], "seg/Station3P.mhd");
Trachea = clitk::ResizeImageLike<MaskImageType>(Trachea, m_Working_Support, GetBackgroundValue());
SubclavianArtery = clitk::ResizeImageLike<MaskImageType>(SubclavianArtery, m_Working_Support, GetBackgroundValue());
- writeImage<MaskImageType>(Trachea, "tr.mhd");
- writeImage<MaskImageType>(SubclavianArtery, "sca.mhd");
+ // writeImage<MaskImageType>(Trachea, "tr.mhd");
+ // writeImage<MaskImageType>(SubclavianArtery, "sca.mhd");
// Get list of slices
std::vector<MaskSlicePointer> slices_support;
m_CarinaZ, true, GetBackgroundValue());
m_ListOfSupports["Support_Superior_to_Carina"] = m_Support_Superior_to_Carina;
m_ListOfSupports["Support_Inferior_to_Carina"] = m_Support_Inferior_to_Carina;
- writeImage<MaskImageType>(m_Support_Inferior_to_Carina, "seg/Support_Inf_Carina.mhd");
- this->GetAFDB()->SetImageFilename("Support_Inf_Carina", "seg/Support_Inf_Carina.mhd");
- writeImage<MaskImageType>(m_Support_Superior_to_Carina, "seg/Support_Sup_Carina.mhd");
- this->GetAFDB()->SetImageFilename("Support_Sup_Carina", "seg/Support_Sup_Carina.mhd");
+ writeImage<MaskImageType>(m_Support_Inferior_to_Carina, "seg/Support_Inf_Carina.mha");
+ this->GetAFDB()->SetImageFilename("Support_Inf_Carina", "seg/Support_Inf_Carina.mha");
+ writeImage<MaskImageType>(m_Support_Superior_to_Carina, "seg/Support_Sup_Carina.mha");
+ this->GetAFDB()->SetImageFilename("Support_Sup_Carina", "seg/Support_Sup_Carina.mha");
// S1RL
Support_SupInf_S1RL();
m_ListOfSupports["S11"] = clitk::Clone<MaskImageType>(m_Support_Inferior_to_Carina);
// Store image filenames into AFDB
- writeImage<MaskImageType>(m_ListOfSupports["S1R"], "seg/Support_S1R.mhd");
- this->GetAFDB()->SetImageFilename("Support_S1R", "seg/Support_S1R.mhd");
- writeImage<MaskImageType>(m_ListOfSupports["S1L"], "seg/Support_S1L.mhd");
- this->GetAFDB()->SetImageFilename("Support_S1L", "seg/Support_S1L.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S1R"], "seg/Support_S1R.mha");
+ this->GetAFDB()->SetImageFilename("Support_S1R", "seg/Support_S1R.mha");
+ writeImage<MaskImageType>(m_ListOfSupports["S1L"], "seg/Support_S1L.mha");
+ this->GetAFDB()->SetImageFilename("Support_S1L", "seg/Support_S1L.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S2L"], "seg/Support_S2L.mhd");
- this->GetAFDB()->SetImageFilename("Support_S2L", "seg/Support_S2L.mhd");
- writeImage<MaskImageType>(m_ListOfSupports["S2R"], "seg/Support_S2R.mhd");
- this->GetAFDB()->SetImageFilename("Support_S2R", "seg/Support_S2R.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S2L"], "seg/Support_S2L.mha");
+ this->GetAFDB()->SetImageFilename("Support_S2L", "seg/Support_S2L.mha");
+ writeImage<MaskImageType>(m_ListOfSupports["S2R"], "seg/Support_S2R.mha");
+ this->GetAFDB()->SetImageFilename("Support_S2R", "seg/Support_S2R.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S3P"], "seg/Support_S3P.mhd");
- this->GetAFDB()->SetImageFilename("Support_S3P", "seg/Support_S3P.mhd");
- writeImage<MaskImageType>(m_ListOfSupports["S3A"], "seg/Support_S3A.mhd");
- this->GetAFDB()->SetImageFilename("Support_S3A", "seg/Support_S3A.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S3P"], "seg/Support_S3P.mha");
+ this->GetAFDB()->SetImageFilename("Support_S3P", "seg/Support_S3P.mha");
+ writeImage<MaskImageType>(m_ListOfSupports["S3A"], "seg/Support_S3A.mha");
+ this->GetAFDB()->SetImageFilename("Support_S3A", "seg/Support_S3A.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S4L"], "seg/Support_S4L.mhd");
- this->GetAFDB()->SetImageFilename("Support_S4L", "seg/Support_S4L.mhd");
- writeImage<MaskImageType>(m_ListOfSupports["S4R"], "seg/Support_S4R.mhd");
- this->GetAFDB()->SetImageFilename("Support_S4R", "seg/Support_S4R.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S4L"], "seg/Support_S4L.mha");
+ this->GetAFDB()->SetImageFilename("Support_S4L", "seg/Support_S4L.mha");
+ writeImage<MaskImageType>(m_ListOfSupports["S4R"], "seg/Support_S4R.mha");
+ this->GetAFDB()->SetImageFilename("Support_S4R", "seg/Support_S4R.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S5"], "seg/Support_S5.mhd");
- this->GetAFDB()->SetImageFilename("Support_S5", "seg/Support_S5.mhd");
- writeImage<MaskImageType>(m_ListOfSupports["S6"], "seg/Support_S6.mhd");
- this->GetAFDB()->SetImageFilename("Support_S6", "seg/Support_S6.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S5"], "seg/Support_S5.mha");
+ this->GetAFDB()->SetImageFilename("Support_S5", "seg/Support_S5.mha");
+ writeImage<MaskImageType>(m_ListOfSupports["S6"], "seg/Support_S6.mha");
+ this->GetAFDB()->SetImageFilename("Support_S6", "seg/Support_S6.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S7"], "seg/Support_S7.mhd");
- this->GetAFDB()->SetImageFilename("Support_S7", "seg/Support_S7.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S7"], "seg/Support_S7.mha");
+ this->GetAFDB()->SetImageFilename("Support_S7", "seg/Support_S7.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S8"], "seg/Support_S8.mhd");
- this->GetAFDB()->SetImageFilename("Support_S8", "seg/Support_S8.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S8"], "seg/Support_S8.mha");
+ this->GetAFDB()->SetImageFilename("Support_S8", "seg/Support_S8.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S9"], "seg/Support_S9.mhd");
- this->GetAFDB()->SetImageFilename("Support_S9", "seg/Support_S9.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S9"], "seg/Support_S9.mha");
+ this->GetAFDB()->SetImageFilename("Support_S9", "seg/Support_S9.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S10"], "seg/Support_S10.mhd");
- this->GetAFDB()->SetImageFilename("Support_S10", "seg/Support_S10.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S10"], "seg/Support_S10.mha");
+ this->GetAFDB()->SetImageFilename("Support_S10", "seg/Support_S10.mha");
- writeImage<MaskImageType>(m_ListOfSupports["S11"], "seg/Support_S11.mhd");
- this->GetAFDB()->SetImageFilename("Support_S11", "seg/Support_S11.mhd");
+ writeImage<MaskImageType>(m_ListOfSupports["S11"], "seg/Support_S11.mha");
+ this->GetAFDB()->SetImageFilename("Support_S11", "seg/Support_S11.mha");
WriteAFDB();
}
//--------------------------------------------------------------------
clitk::ExtractLymphStationsFilter<ImageType>::
Support_S5()
{
- StartNewStep("[Support] Sup-Inf limits S5 with aorta");
+ StartNewStep("[Support] Sup-Inf limits S5 with Aorta and MainPulmonaryArtery");
// Initial S5 support
MaskImagePointer S5 =
// Inf limits with "upper rim of the left main pulmonary artery"
// For the moment only, it will change.
- MaskImagePointer PulmonaryTrunk = this->GetAFDB()->template GetImage<MaskImageType>("PulmonaryTrunk");
+ MaskImagePointer MainPulmonaryArtery = this->GetAFDB()->template GetImage<MaskImageType>("MainPulmonaryArtery");
MaskImagePointType p;
p[0] = p[1] = p[2] = 0.0; // to avoid warning
- clitk::FindExtremaPointInAGivenDirection<MaskImageType>(PulmonaryTrunk, GetBackgroundValue(), 2, false, p);
- p[2] += PulmonaryTrunk->GetSpacing()[2];
+ clitk::FindExtremaPointInAGivenDirection<MaskImageType>(MainPulmonaryArtery, GetBackgroundValue(), 2, false, p);
+ p[2] += MainPulmonaryArtery->GetSpacing()[2];
// Cut Sup/Inf
S5 = clitk::CropImageAlongOneAxis<MaskImageType>(S5, 2, p[2], sup, true, GetBackgroundValue());
}
// Extract Stations
+ ExtractStation_1RL();
+ ExtractStation_2RL();
ExtractStation_3P();
ExtractStation_3A();
- ExtractStation_2RL();
- ExtractStation_1RL();
ExtractStation_4RL();
ExtractStation_5();
ExtractStation_6();
// ---------- TODO -----------------------
// Extract Station8
- ExtractStation_8();
+ // ExtractStation_8();
// Extract Station7
- this->StartNewStep("Station 7");
- this->StartSubStep();
- ExtractStation_7();
- this->StopSubStep();
+ //this->StartNewStep("Station 7");
+ //this->StartSubStep();
+ //ExtractStation_7();
+ //this->StopSubStep();
}
//--------------------------------------------------------------------
binarizedContour = clitk::CropImageAlongOneAxis<MaskImageType>(binarizedContour, 2, inf, sup,
false, GetBackgroundValue());
// Update the AFDB
- writeImage<MaskImageType>(binarizedContour, "seg/AntPostVesselsSeparation.mhd");
- this->GetAFDB()->SetImageFilename("AntPostVesselsSeparation", "seg/AntPostVesselsSeparation.mhd");
+ writeImage<MaskImageType>(binarizedContour, "seg/AntPostVesselsSeparation.mha");
+ this->GetAFDB()->SetImageFilename("AntPostVesselsSeparation", "seg/AntPostVesselsSeparation.mha");
this->WriteAFDB();
return binarizedContour;
typedef std::map<std::string, MaskImagePointer>::iterator MapIter;
MapOfStructures["BrachioCephalicArtery"] = this->GetAFDB()->template GetImage<MaskImageType>("BrachioCephalicArtery");
MapOfStructures["BrachioCephalicVein"] = this->GetAFDB()->template GetImage<MaskImageType>("BrachioCephalicVein");
- MapOfStructures["CommonCarotidArteryLeft"] = this->GetAFDB()->template GetImage<MaskImageType>("CommonCarotidArteryLeft");
- MapOfStructures["CommonCarotidArteryRight"] = this->GetAFDB()->template GetImage<MaskImageType>("CommonCarotidArteryRight");
- MapOfStructures["SubclavianArteryLeft"] = this->GetAFDB()->template GetImage<MaskImageType>("SubclavianArteryLeft");
- MapOfStructures["SubclavianArteryRight"] = this->GetAFDB()->template GetImage<MaskImageType>("SubclavianArteryRight");
+ MapOfStructures["CommonCarotidArteryLeft"] = this->GetAFDB()->template GetImage<MaskImageType>("LeftCommonCarotidArtery");
+ MapOfStructures["CommonCarotidArteryRight"] = this->GetAFDB()->template GetImage<MaskImageType>("RightCommonCarotidArtery");
+ MapOfStructures["SubclavianArteryLeft"] = this->GetAFDB()->template GetImage<MaskImageType>("LeftSubclavianArtery");
+ MapOfStructures["SubclavianArteryRight"] = this->GetAFDB()->template GetImage<MaskImageType>("RightSubclavianArtery");
MapOfStructures["Thyroid"] = this->GetAFDB()->template GetImage<MaskImageType>("Thyroid");
MapOfStructures["Aorta"] = this->GetAFDB()->template GetImage<MaskImageType>("Aorta");
MapOfStructures["Trachea"] = this->GetAFDB()->template GetImage<MaskImageType>("Trachea");
false, GetBackgroundValue());
// Update the AFDB
- writeImage<MaskImageType>(binarizedContour, "seg/AntPostVesselsSeparation.mhd");
- this->GetAFDB()->SetImageFilename("AntPostVesselsSeparation", "seg/AntPostVesselsSeparation.mhd");
+ writeImage<MaskImageType>(binarizedContour, "seg/AntPostVesselsSeparation.mha");
+ this->GetAFDB()->SetImageFilename("AntPostVesselsSeparation", "seg/AntPostVesselsSeparation.mha");
this->WriteAFDB();
return binarizedContour;
option "writeStep" w "Write image at each step" flag off
option "verboseOption" - "Display options values" flag off
option "verboseWarningOff" - "Do not display warning" flag off
-option "verboseMemory" - "Display memory usage" flag off
+option "verboseMemory" - "Display memory usage" flag off
+option "verboseTracking" - "Verbose tracking" flag off
section "I/O"
itkGetConstMacro(DebugFlag, bool);
itkBooleanMacro(DebugFlag);
+ itkSetMacro(VerboseTrackingFlag, bool);
+ itkGetConstMacro(VerboseTrackingFlag, bool);
+ itkBooleanMacro(VerboseTrackingFlag);
+
itkSetMacro(SoughtVesselSeedName, std::string);
itkGetConstMacro(SoughtVesselSeedName, std::string);
virtual void GenerateData();
bool m_DebugFlag;
+ bool m_VerboseTrackingFlag;
ImagePointer m_Input;
MaskImagePointer m_Working_Support;
MaskImagePointer m_Mediastinum;
SetMaxDistanceRightToCarina(35);
SetSoughtVesselSeedName("NoSeedNameGiven");
SetFinalOpeningRadius(1);
+ VerboseTrackingFlagOff();
}
//--------------------------------------------------------------------
// Build the final 3D image from the previous slice by slice processing
m_SoughtVessel = clitk::JoinSlices<MaskImageType>(m_slice_recon, m_Mask, 2);
- writeImage<MaskImageType>(m_SoughtVessel, "recon2.mhd");
+ // writeImage<MaskImageType>(m_SoughtVessel, "recon2.mhd");
// Set binary image, (remove other labels).
m_SoughtVessel =
m_Input =
clitk::CropImageRemoveLowerThan<ImageType>(m_Input, 2, m_CarinaZ, false, GetBackgroundValue());
+ // // Get seed, crop around
+ // MaskImagePointType SoughtVesselSeedPoint;
+ // GetAFDB()->GetPoint3D(m_SoughtVesselSeedName, SoughtVesselSeedPoint);
+
// Crop post
double m_CarinaY = centroids[1][1];
m_Input = clitk::CropImageRemoveGreaterThan<ImageType>(m_Input, 1,
uint currentSlice=index[2];
bool found = false;
LabelType previous_slice_label=recon->GetPixel(index);
+
+
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "TrackBifurcationFromPoint " << std::endl;
+ std::cout << "\t point3D = " << point3D << std::endl;
+ std::cout << "\t pointMaxSlice = " << pointMaxSlice << std::endl;
+ std::cout << "\t newLabel = " << newLabel << std::endl;
+ }
+
// DD(slices_recon.size());
do {
- // DD(currentSlice);
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "currentSlice = " << currentSlice << std::endl;
+ }
// Consider current reconstructed slice
MaskSlicePointer s = slices_recon[currentSlice];
MaskSlicePointer previous;
// -------------------------
// If no centroid were found
if (centroids.size() == 0) {
- // Last attempt to find -> check if previous centroid is inside a CCL
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "no centroid" << std::endl;
+ }
+ // Last attempt to find -> check if previous centroid is inside a CCL
// if in s -> get value, getcentroid add.
// DD(currentSlice);
//DD("Last change to find");
// Some centroid were found
// If several centroids, we found a bifurcation
if (centroids.size() > 1) {
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "Centroid" << centroids.size() << std::endl;
+ }
// int n = centroids.size();
// Debug point
std::vector<ImagePointType> d;
// if only one centroids, we change the current image with the current label
if (centroids.size() == 1) {
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "Centroid" << centroids.size() << std::endl;
+ }
+
//DD(centroids_label[0]);
s = clitk::SetBackground<MaskSliceType, MaskSliceType>(s, s, centroids_label[0], newLabel, true);
slices_recon[currentSlice] = s;
previousCenter = centroids[1];
}
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "End iteration c=" << centroids.size() << std::endl;
+ }
+
if (centroids.size() == 0) {
// DD("ZERO");
found = true;
std::vector<MaskSlicePointer> shapeObjectsSliceList; // keep slice, useful for 'union'
typename LabelObjectType::Pointer previousShapeObject;
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "TrackBifurcationFromPoint " << std::endl;
+ std::cout << "\t seedPoint = " << seedPoint << std::endl;
+ std::cout << "\t pointMaxSlice = " << pointMaxSlice << std::endl;
+ std::cout << "\t newLabel = " << newLabel << std::endl;
+ }
+
do {
// Debug
- std::cout << std::endl;
+ //std::cout << std::endl;
//DD(currentSlice);
ImagePointType c;
clitk::PointsUtils<MaskImageType>::Convert2DTo3D(previousCentroid, m_Mask, currentSlice-1, c);
//DD(c);
+ if (GetVerboseTrackingFlag()) {
+ std::cout << "Loop slice = " << currentSlice << " c = " << c << std::endl;
+ }
+
// Consider current reconstructed slice
MaskSlicePointer s = slices[currentSlice];
MaskSlicePointer previous;
f->SetMaxNumberOfFoundBifurcation(mArgsInfo.bif_arg);
f->SetFinalOpeningRadius(mArgsInfo.open_arg);
+
+ f->SetVerboseTrackingFlag(mArgsInfo.verboseTracking_flag);
// Output filename
this->AddOutputFilename(mArgsInfo.output_arg);
SetForegroundValueLeftLung(1);
SetForegroundValueRightLung(2);
SetDistanceMaxToAnteriorPartOfTheVertebralBody(10);
- SetOutputMediastinumFilename("mediastinum.mhd");
+ SetOutputMediastinumFilename("mediastinum.mha");
UseBonesOff();
}
//--------------------------------------------------------------------
left_lung = clitk::SetBackground<MaskImageType, MaskImageType>(left_lung, left_lung, 2, 1, false);
right_lung = clitk::ResizeImageLike<MaskImageType>(right_lung, output, this->GetBackgroundValue());
left_lung = clitk::ResizeImageLike<MaskImageType>(left_lung, output, this->GetBackgroundValue());
- this->GetAFDB()->template SetImage<MaskImageType>("RightLung", "seg/RightLung.mhd",
+ this->GetAFDB()->template SetImage<MaskImageType>("RightLung", "seg/RightLung.mha",
right_lung, true);
- this->GetAFDB()->template SetImage<MaskImageType>("LeftLung", "seg/LeftLung.mhd",
+ this->GetAFDB()->template SetImage<MaskImageType>("LeftLung", "seg/LeftLung.mha",
left_lung, true);
this->GetAFDB()->Write();
this->template StopCurrentStep<MaskImageType>(output);
bones_post = roiFilter->GetOutput();
// writeImage<MaskImageType>(bones_post, "b_post.mhd");
- // Now, insert this image in the AFDB
- this->GetAFDB()->template SetImage<MaskImageType>("Bones_Post", "seg/Bones_Post.mhd",
+ // Now, insert this image in the AFDB ==> (needed because used in the RelativePosition config file)
+ this->GetAFDB()->template SetImage<MaskImageType>("Bones_Post", "seg/Bones_Post.mha",
bones_post, true);
- this->GetAFDB()->template SetImage<MaskImageType>("Bones_Ant", "seg/Bones_Ant.mhd",
+ this->GetAFDB()->template SetImage<MaskImageType>("Bones_Ant", "seg/Bones_Ant.mha",
bones_ant, true);
- this->GetAFDB()->Write();
+ this->GetAFDB()->Write();
this->template StopCurrentStep<MaskImageType>(output);
}
// RelativePosition to avoid some issue due to superior boundaries.
this->StartNewStep("[Mediastinum] Keep inferior to CricoidCartilag");
// load Cricoid, get centroid, cut above (or below), lower bound
- MaskImagePointer CricoidCartilag = this->GetAFDB()->template GetImage <MaskImageType>("CricoidCartilag");
MaskImagePointType p;
- p[0] = p[1] = p[2] = 0.0; // to avoid warning
- clitk::FindExtremaPointInAGivenDirection<MaskImageType>(CricoidCartilag,
- this->GetBackgroundValue(), 2, true, p);
+ try {
+ MaskImagePointer CricoidCartilag = this->GetAFDB()->template GetImage <MaskImageType>("CricoidCartilag");
+ p[0] = p[1] = p[2] = 0.0; // to avoid warning
+ clitk::FindExtremaPointInAGivenDirection<MaskImageType>(CricoidCartilag,
+ this->GetBackgroundValue(), 2, true, p);
+ } catch (clitk::ExceptionObject e) {
+ //DD("CricoidCartilag image not found, try CricoidCartilagZ");
+ this->GetAFDB()->GetPoint3D("CricoidCartilagPoint", p);
+ }
output = clitk::CropImageRemoveGreaterThan<MaskImageType>(output, 2, p[2], true, this->GetBackgroundValue());
this->template StopCurrentStep<MaskImageType>(output);
try {
GetAFDB()->Load();
} catch (clitk::ExceptionObject e) {
- std::cout << "Could not read '" << GetAFDBFilename() << "', create one AFDB." << std::endl;
+ std::cout << "******* Could not read '" << GetAFDBFilename() << "', create one AFDB. ********" << std::endl;
GetAFDB();
}
}
TARGET_LINK_LIBRARIES(clitkBinaryImageToMesh ${ITK_LIBRARIES} vtkCommon vtkRendering)
SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkBinaryImageToMesh)
+ WRAP_GGO(clitkMeshToBinaryImage_GGO_C clitkMeshToBinaryImage.ggo)
+ ADD_EXECUTABLE(clitkMeshToBinaryImage clitkMeshToBinaryImage.cxx ${clitkMeshToBinaryImage_GGO_C})
+ TARGET_LINK_LIBRARIES(clitkMeshToBinaryImage clitkCommon ${ITK_LIBRARIES} ${VTK_LIBRARIES})
+ SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkMeshToBinaryImage)
+
WRAP_GGO(clitkMeshViewer_GGO_C clitkMeshViewer.ggo)
ADD_EXECUTABLE(clitkMeshViewer clitkMeshViewer.cxx ${clitkMeshViewer_GGO_C})
TARGET_LINK_LIBRARIES(clitkMeshViewer vtkCommon vtkRendering)
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================*/
+#include "clitkMeshToBinaryImage_ggo.h"
+#include "clitkMeshToBinaryImageFilter.h"
+#include "clitkCommon.h"
+#include "clitkImageCommon.h"
+
+#include <itkImageIOBase.h>
+#include <itkInvertIntensityImageFilter.h>
+
+#include <vtkOBJReader.h>
+
+#include <string>
+
+template <unsigned dim>
+void run(const args_info_clitkMeshToBinaryImage& argsInfo,
+ const itk::ImageIOBase * header)
+{
+ typedef itk::Image<unsigned char, dim> ImageType;
+ typename ImageType::Pointer like = ImageType::New();
+
+ typename ImageType::SizeType size;
+ for (unsigned i = 0; i < dim; ++i)
+ size[i] = header->GetDimensions(i);
+ typename ImageType::RegionType region;
+ region.SetSize(size);
+ like->SetRegions(region);
+
+ typename ImageType::SpacingType spacing;
+ for (unsigned i = 0; i < dim; ++i)
+ spacing[i] = header->GetSpacing(i);
+ like->SetSpacing(spacing);
+
+
+ typename ImageType::PointType origin;
+ for (unsigned i = 0; i < dim; ++i)
+ origin[i] = header->GetOrigin(i);
+ like->SetOrigin(origin);
+
+ vtkSmartPointer<vtkOBJReader> reader = vtkOBJReader::New();
+ reader->SetFileName(argsInfo.input_arg);
+ reader->Update();
+
+ typename clitk::MeshToBinaryImageFilter<ImageType>::Pointer filter =
+ clitk::MeshToBinaryImageFilter<ImageType>::New();
+ filter->SetExtrude(false);
+ filter->SetMesh(reader->GetOutput());
+ filter->SetLikeImage(like);
+ filter->Update();
+
+ typedef itk::InvertIntensityImageFilter<ImageType> InvertFilterType;
+ typename InvertFilterType::Pointer ifilter = InvertFilterType::New();
+ ifilter->SetInput(filter->GetOutput());
+ ifilter->SetMaximum(1);
+
+ clitk::writeImage(ifilter->GetOutput(), argsInfo.output_arg);
+}
+
+int main(int argc, char** argv)
+{
+ GGO(clitkMeshToBinaryImage, args_info);
+
+ itk::ImageIOBase::Pointer header =
+ clitk::readImageHeader(args_info.like_arg);
+ switch (header->GetNumberOfDimensions())
+ {
+ case 2:
+ run<2>(args_info, header);
+ break;
+ case 3:
+ run<3>(args_info, header);
+ break;
+ case 4:
+ run<4>(args_info, header);
+ break;
+ }
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+#File clitkBinaryImageToMesh.ggo
+package "clitkMeshToBinaryImage"
+version "1.0"
+purpose "Transform a vtk obj file into a binary mask"
+
+option "config" - "Config file" string no
+option "verbose" v "Verbose" flag off
+
+option "input" i "Input obj file" string yes
+option "output" o "Output binary image" string yes
+option "like" l "Output image will be like this one (size, spacing)" string yes
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff