cmake_policy(VERSION 2.8)
if(COMMAND cmake_policy)
cmake_policy(SET CMP0003 NEW)
+ cmake_policy(SET CMP0007 NEW)
endif(COMMAND cmake_policy)
if(NOT DEFINED CLITK_SOURCE_DIR)
set(CLITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
endif(NOT DEFINED CLITK_SOURCE_DIR)
+# Default build type
+IF(NOT CMAKE_BUILD_TYPE)
+ SET(CMAKE_BUILD_TYPE Release CACHE STRING
+ "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+ FORCE)
+ENDIF(NOT CMAKE_BUILD_TYPE)
#=========================================================
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
# Compilation options
option(CLITK_EXPERIMENTAL "Enable experimental software and features" OFF)
+mark_as_advanced(CLITK_EXPERIMENTAL)
option(CLITK_BUILD_TOOLS "Build command-line tools" OFF)
option(CLITK_BUILD_SEGMENTATION "Build command-line segmentation tools" OFF)
option(CLITK_BUILD_REGISTRATION "Build command-line registration tools" OFF)
option(CLITK_BUILD_VV "Build vv the 4D visualizer (requires VTK and QT)" ON)
+
if(CLITK_BUILD_VV)
+ if(VTK_VERSION VERSION_LESS 6.0.0)
+ set(vv_QT_VERSION "4" CACHE INTERNAL "Expected Qt version")
+ else()
+ set(vv_QT_VERSION "5" CACHE INTERNAL "Expected Qt version")
+ endif()
+
add_subdirectory(${CLITK_SOURCE_DIR}/vv ${PROJECT_BINARY_DIR}/vv)
endif(CLITK_BUILD_VV)
#=========================================================
### Check if ITK was compiled with SYSTEM_GDCM = ON
set(CLITK_USE_SYSTEM_GDCM FALSE)
-if(ITK_VERSION_MAJOR LESS "4")
- if(ITK_USE_SYSTEM_GDCM)
- set(CLITK_USE_SYSTEM_GDCM TRUE)
- endif(ITK_USE_SYSTEM_GDCM)
-else()
- # ITK4 creates a target for each gdcm library when it compiles GDCM
- get_target_property(GDCMDICTTARG gdcmDICT TYPE )
- if(NOT GDCMDICTTARG)
- set(CLITK_USE_SYSTEM_GDCM TRUE)
- endif()
+# ITK4 creates a target for each gdcm library when it compiles GDCM
+get_target_property(GDCMDICTTARG gdcmDICT TYPE )
+if(NOT GDCMDICTTARG)
+ set(CLITK_USE_SYSTEM_GDCM TRUE)
endif()
+
ImageTypesManager(FilterType * f) { mFilter = f; }
virtual void DoIt(int dim, int ncomp, std::string pixelname) {
- // std::cout << "ImageTypesManager DoIt " << dim << " " << pixelname << std::endl;
+ //std::cout << "ImageTypesManager DoIt " << dim << " " << pixelname << std::endl;
if (mMapOfImageTypeToFunction[dim][ncomp][pixelname])
mMapOfImageTypeToFunction[dim][ncomp][pixelname]->Execute();
}
#include "clitkImageCommon.h"
// vtk
+#include <vtkVersion.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkSmartPointer.h>
#include <vtkImageStencil.h>
// Create new output image
mBinaryImage = vtkSmartPointer<vtkImageData>::New();
+#if VTK_MAJOR_VERSION <= 5
mBinaryImage->SetScalarTypeToUnsignedChar();
+#endif
mBinaryImage->SetOrigin(&origin[0]);
mBinaryImage->SetSpacing(&mSpacing[0]);
mBinaryImage->SetExtent(0, extend[0],
0, extend[1],
0, extend[2]);
+#if VTK_MAJOR_VERSION <= 5
mBinaryImage->AllocateScalars();
+#else
+ mBinaryImage->AllocateScalars(VTK_UNSIGNED_CHAR, 1);
+#endif
memset(mBinaryImage->GetScalarPointer(), 0,
mBinaryImage->GetDimensions()[0]*mBinaryImage->GetDimensions()[1]*mBinaryImage->GetDimensions()[2]*sizeof(unsigned char));
// Extrude
vtkSmartPointer<vtkLinearExtrusionFilter> extrude=vtkSmartPointer<vtkLinearExtrusionFilter>::New();
+#if VTK_MAJOR_VERSION <= 5
extrude->SetInput(mesh);
+#else
+ extrude->SetInputData(mesh);
+#endif
///We extrude in the -slice_spacing direction to respect the FOCAL convention (NEEDED !)
extrude->SetVector(0, 0, -mSpacing[2]);
//http://www.nabble.com/Bug-in-vtkPolyDataToImageStencil--td23368312.html#a23370933
sts->SetTolerance(0);
sts->SetInformationInput(mBinaryImage);
+#if VTK_MAJOR_VERSION <= 5
sts->SetInput(extrude->GetOutput());
+#else
+ sts->SetInputConnection(extrude->GetOutputPort(0));
+#endif
//sts->SetInput(mesh);
vtkSmartPointer<vtkImageStencil> stencil=vtkSmartPointer<vtkImageStencil>::New();
+#if VTK_MAJOR_VERSION <= 5
stencil->SetStencil(sts->GetOutput());
+#else
+ stencil->SetStencilConnection(sts->GetOutputPort(0));
+#endif
+#if VTK_MAJOR_VERSION <= 5
stencil->SetInput(mBinaryImage);
+#else
+ stencil->SetInputData(mBinaryImage);
+#endif
stencil->ReverseStencilOn();
stencil->Update();
#include <vtkImageClip.h>
#include <vtkMarchingSquares.h>
#include <vtkPolyDataWriter.h>
+#include <vtkVersion.h>
#if GDCM_MAJOR_VERSION == 2
#include "gdcmAttribute.h"
//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+void clitk::DicomRT_ROI::SetROINumber(int number)
+{
+ mNumber = number;
+}
+//--------------------------------------------------------------------
+
+
//--------------------------------------------------------------------
const std::string & clitk::DicomRT_ROI::GetName() const
{
#if GDCM_MAJOR_VERSION == 2
bool clitk::DicomRT_ROI::Read(gdcm::Item * itemInfo, gdcm::Item * itemContour)
{
- FATAL("Error : compile vv with itk4 + external gdcm");
+ //FATAL("Error : compile vv with itk4 + external gdcm");
// Keep dicom item
mItemInfo = itemInfo;
mItemContour = itemContour;
{
vtkSmartPointer<vtkAppendPolyData> append = vtkSmartPointer<vtkAppendPolyData>::New();
for(unsigned int i=0; i<mListOfContours.size(); i++) {
- append->AddInput(mListOfContours[i]->GetMesh());
+#if VTK_MAJOR_VERSION <= 5
+ append->AddInput(mListOfContours[i]->GetMesh());
+#else
+ append->AddInputData(mListOfContours[i]->GetMesh());
+#endif
}
append->Update();
// Get initial extend for the clipping
vtkSmartPointer<vtkImageClip> clipper = vtkSmartPointer<vtkImageClip>::New();
+#if VTK_MAJOR_VERSION <= 5
clipper->SetInput(image);
+#else
+ clipper->SetInputData(image);
+#endif
+
int* extent = image->GetExtent();
DDV(extent, 6);
// std::vector<int> extend;
vtkSmartPointer<vtkMarchingSquares> squares = vtkSmartPointer<vtkMarchingSquares>::New();
+#if VTK_MAJOR_VERSION <= 5
squares->SetInput(image);
+#else
+ squares->SetInputData(image);
+#endif
squares->SetImageRange(extent[0], extent[1], extent[2], extent[3], i, i);
squares->SetValue(1, 1.0);
squares->Update();
vtkSmartPointer<vtkAppendPolyData> append = vtkSmartPointer<vtkAppendPolyData>::New();
for(unsigned int i=0; i<n; i++) {
+#if VTK_MAJOR_VERSION <= 5
append->AddInput(contours[i]);
+#else
+ append->AddInputData(contours[i]);
+#endif
}
append->Update();
// Write vtk
vtkPolyDataWriter * w = vtkPolyDataWriter::New();
+#if VTK_MAJOR_VERSION <= 5
w->SetInput(mMesh);
+#else
+ w->SetInputData(mMesh);
+#endif
w->SetFileName("toto.vtk");
w->Write();
std::string filename);
int GetROINumber() const;
+ void SetROINumber(int);
const std::string & GetName() const;
const std::string & GetFilename() const;
const std::vector<double> & GetDisplayColor() const;
//--------------------------------------------------------------------
void clitk::DicomRT_StructureSet::Read(const std::string & filename)
{
-#if CLITK_USE_SYSTEM_GDCM == 1
- vtkSmartPointer<vtkGDCMPolyDataReader> reader = vtkGDCMPolyDataReader::New();
- reader->SetFileName(filename.c_str());
- reader->Update();
-
- // Get global information
- vtkRTStructSetProperties * p = reader->GetRTStructSetProperties();
- mStudyID = p->GetStudyInstanceUID();
- mStudyDate = p->GetStructureSetDate();
- mLabel = p->GetStructureSetLabel();
- mName = p->GetStructureSetName();
- mTime = p->GetStructureSetTime();
-
- int n = p->GetNumberOfStructureSetROIs();
- for(unsigned int i=0; i<n; i++) {
- // Get the roi number
- int roinumber = p->GetStructureSetROINumber(i);
- // Create the roi
- DicomRT_ROI::Pointer roi = DicomRT_ROI::New();
- roi->Read(reader, i);
- // Insert in the map
- mROIs[roinumber] = roi;
- }
- return;
-#endif // END version with system gdcm (vtkGDCMPolyDataReader)
-
- // Open DICOM
-#if GDCM_MAJOR_VERSION == 2
- FATAL("Error : compile vv with itk4 + external gdcm");
-
- // Read gdcm file
- mReader = new gdcm::Reader;
- mReader->SetFileName(filename.c_str());
- mReader->Read();
- mFile = &(mReader->GetFile());
- const gdcm::DataSet & ds = mFile->GetDataSet();
+//Try to avoid to use extern GDCM library
+
+ //check the RS file is available before conversion
+ gdcm::Reader RTreader;
+ RTreader.SetFileName( filename.c_str() );
+ if( !RTreader.Read() )
+ {
+ std::cout << "Problem reading file: " << filename << std::endl;
+ return;
+ }
+
+ const gdcm::DataSet& ds = RTreader.GetFile().GetDataSet();
- // Check file type
- //Verify if the file is a RT-Structure-Set dicom file
gdcm::MediaStorage ms;
- ms.SetFromFile(*mFile);
- if( ms != gdcm::MediaStorage::RTStructureSetStorage )
- {
- std::cerr << "Error. the file " << filename
- << " is not a Dicom Struct ? (must have a SOP Class UID [0008|0016] = 1.2.840.10008.5.1.4.1.1.481.3 ==> [RT Structure Set Storage])"
- << std::endl;
- exit(0);
- }
+ ms.SetFromFile( RTreader.GetFile() );
+
+ // (3006,0020) SQ (Sequence with explicit length #=4) # 370, 1 StructureSetROISequence
+ gdcm::Tag tssroisq(0x3006,0x0020);
+ if( !ds.FindDataElement( tssroisq ) )
+ {
+ std::cout << "Problem locating 0x3006,0x0020 - Is this a valid RT Struct file?" << std::endl;
+ return;
+ }
+ gdcm::Tag troicsq(0x3006,0x0039);
+ if( !ds.FindDataElement( troicsq ) )
+ {
+ std::cout << "Problem locating 0x3006,0x0039 - Is this a valid RT Struct file?" << std::endl;
+ return;
+ }
- gdcm::Attribute<0x8,0x60> modality;
- modality.SetFromDataSet( ds );
- if( modality.GetValue() != "RTSTRUCT" )
- {
- std::cerr << "Error. the file " << filename
- << " is not a Dicom Struct ? (must have 0x0008,0x0060 = RTSTRUCT [RT Structure Set Storage])"
- << std::endl;
- exit(0);
- }
+ const gdcm::DataElement &roicsq = ds.GetDataElement( troicsq );
+ gdcm::SmartPointer<gdcm::SequenceOfItems> sqi = roicsq.GetValueAsSQ();
+ if( !sqi || !sqi->GetNumberOfItems() )
+ {
+ return;
+ }
+ const gdcm::DataElement &ssroisq = ds.GetDataElement( tssroisq );
+ gdcm::SmartPointer<gdcm::SequenceOfItems> ssqi = ssroisq.GetValueAsSQ();
+ if( !ssqi || !ssqi->GetNumberOfItems() )
+ {
+ return;
+ }
+
// Read global info
gdcm::Attribute<0x20,0x10> studyid;
studyid.SetFromDataSet( ds );
// Temporary store the list of items
std::map<int, gdcm::Item*> mMapOfROIInfo;
std::map<int, gdcm::Item*> mMapOfROIContours;
-
-std::map<int, clitk::DicomRT_ROI::Pointer> mROIs;
- std::map<int, std::string> mMapOfROIName;
-#if GDCM_MAJOR_VERSION == 2
- gdcm::Reader * mReader;
- gdcm::SmartPointer<gdcm::SequenceOfItems> mROIInfoSequenceOfItems;
- gdcm::SmartPointer<gdcm::SequenceOfItems> mROIContoursSequenceOfItems;
-#endif
- gdcm::File * mFile;
-
+
//----------------------------------
// Read all ROI Names and number
// 0x3006,0x0020 = [ Structure Set ROI Sequence ]
- gdcm::Tag tssroisq(0x3006,0x0020);
- const gdcm::DataElement &ssroisq = ds.GetDataElement( tssroisq );
+ //gdcm::Tag tssroisq(0x3006,0x0020);
+ //const gdcm::DataElement &ssroisq = ds.GetDataElement( tssroisq );
mROIInfoSequenceOfItems = ssroisq.GetValueAsSQ();
gdcm::SmartPointer<gdcm::SequenceOfItems> & roi_seq = mROIInfoSequenceOfItems;
assert(roi_seq); // TODO error message
//----------------------------------
// Read all ROI item
// 0x3006,0x0039 = [ ROI Contour Sequence ]
- gdcm::Tag troicsq(0x3006,0x0039);
- const gdcm::DataElement &roicsq = ds.GetDataElement( troicsq );
+ //gdcm::Tag troicsq(0x3006,0x0039);
+ //const gdcm::DataElement &roicsq = ds.GetDataElement( troicsq );
gdcm::SmartPointer<gdcm::SequenceOfItems> roi_contour_seq = roicsq.GetValueAsSQ();
mROIContoursSequenceOfItems = roi_contour_seq;
assert(roi_contour_seq); // TODO error message
for(std::map<int, gdcm::Item*>::iterator i = mMapOfROIInfo.begin(); i != mMapOfROIInfo.end(); i++) {
int nb = i->first;//ReadROINumber(i);//mROIIndex[i];
// Create the roi
- DicomRT_ROI::Pointer roi = DicomRT_ROI::New();
- roi->Read(mMapOfROIInfo[nb], mMapOfROIContours[nb]);
- // mListOfROI.push_back(roi);
- // mMapOfROIIndex[nb] = i;
- mROIs[nb] = roi;
- }
-
- //----------------------------------------------------------------------------------------
- //----------------------------------------------------------------------------------------
- //----------------------------------------------------------------------------------------
-#else
- mFile = new gdcm::File;
- mFile->SetFileName(filename.c_str());
- mFile->SetMaxSizeLoadEntry(16384); // Needed ...
- mFile->SetLoadMode(gdcm::LD_NOSHADOW); // don't load shadow tags (in order to save memory)
- mFile->Load();
-
- // Check file type
- //Verify if the file is a RT-Structure-Set dicom file
- if (!gdcm::Util::DicomStringEqual(mFile->GetEntryValue(0x0008,0x0016),"1.2.840.10008.5.1.4.1.1.481.3")) { //SOP clas UID
- std::cerr << "Error. the file " << filename
- << " is not a Dicom Struct ? (must have a SOP Class UID [0008|0016] = 1.2.840.10008.5.1.4.1.1.481.3 ==> [RT Structure Set Storage])"
- << std::endl;
- exit(0);
- }
- if (!gdcm::Util::DicomStringEqual(mFile->GetEntryValue(0x0008,0x0060),"RTSTRUCT")) { //SOP clas UID
- std::cerr << "Error. the file " << filename
- << " is not a Dicom Struct ? (must have 0x0008,0x0060 = RTSTRUCT [RT Structure Set Storage])"
- << std::endl;
- exit(0);
- }
-
- // Read global info
- mStudyID = mFile->GetValEntry(0x0020,0x0010)->GetValue();
- mStudyTime = mFile->GetValEntry(0x008,0x0020)->GetValue();
- mStudyDate = mFile->GetValEntry(0x008,0x0030)->GetValue();
- mLabel = mFile->GetValEntry(0x3006,0x002)->GetValue();
- if (!mFile->GetValEntry(0x3006,0x004)) {
- mName = "Anonymous";
- }
- else {
- mName = mFile->GetValEntry(0x3006,0x004)->GetValue();
- }
- mTime = mFile->GetValEntry(0x3006,0x009)->GetValue();
-
- //----------------------------------
- // Read all ROI Names and number
- // 0x3006,0x0020 = [ Structure Set ROI Sequence ]
- gdcm::SeqEntry * roi_seq=mFile->GetSeqEntry(0x3006,0x0020);
- assert(roi_seq); // TODO error message
- for (gdcm::SQItem* r=roi_seq->GetFirstSQItem(); r!=0; r=roi_seq->GetNextSQItem()) {
- std::string name = r->GetEntryValue(0x3006,0x0026); // 0x3006,0x0026 = [ROI Name]
- int nb = atoi(r->GetEntryValue(0x3006,0x0022).c_str()); // 0x3006,0x0022 = [ROI Number]
- // Check if such a number already exist
- if (mMapOfROIName.find(nb) != mMapOfROIName.end()) {
- std::cerr << "WARNING. A Roi already exist with the number "
- << nb << ". I replace." << std::endl;
- }
- // Add in map
- mMapOfROIName[nb] = name;
- }
-
- //----------------------------------
- // Read all ROI
- // 0x3006,0x0039 = [ ROI Contour Sequence ]
- gdcm::SeqEntry * roi_contour_seq=mFile->GetSeqEntry(0x3006,0x0039);
- assert(roi_contour_seq); // TODO error message
- int n=0;
- for (gdcm::SQItem* r=roi_contour_seq->GetFirstSQItem(); r!=0; r=roi_contour_seq->GetNextSQItem()) {
- DicomRT_ROI::Pointer roi = DicomRT_ROI::New();
- roi->Read(mMapOfROIName, r);
- mROIs[roi->GetROINumber()] = roi;
- n++;
+ mROIs[nb] = DicomRT_ROI::New();
+ mROIs[nb]->Read(mMapOfROIInfo[nb], mMapOfROIContours[nb]);
}
+
+ return;
-#endif
}
//--------------------------------------------------------------------
#include "clitkUSVoxImageIOFactory.h"
#include "clitkSvlImageIOFactory.h"
#endif
-#if ITK_VERSION_MAJOR >= 4
- #include "itkGDCMImageIOFactory.h"
- #include "itkPNGImageIOFactory.h"
-#endif
+#include "itkGDCMImageIOFactory.h"
+#include "itkPNGImageIOFactory.h"
//--------------------------------------------------------------------
// Register factories
void clitk::RegisterClitkFactories()
{
-#if ITK_VERSION_MAJOR >= 4
std::list< itk::ObjectFactoryBase * > fl = itk::GDCMImageIOFactory::GetRegisteredFactories();
for (std::list< itk::ObjectFactoryBase * >::iterator it = fl.begin(); it != fl.end(); ++it)
if (dynamic_cast<itk::GDCMImageIOFactory *>(*it))
itk::PNGImageIOFactory::UnRegisterFactory(*it);
break;
}
-#endif
#if CLITK_PRIVATE_FEATURES
clitk::UsfImageIOFactory::RegisterOneFactory();
clitk::USVoxImageIOFactory::RegisterOneFactory();
#endif
clitk::GateAsciiImageIOFactory::RegisterOneFactory();
clitk::DicomRTDoseIOFactory::RegisterOneFactory();
-#if ITK_VERSION_MAJOR <= 3
- itk::ImageIOFactory::RegisterBuiltInFactories();
-#endif
clitk::VoxImageIOFactory::RegisterOneFactory();
clitk::VfImageIOFactory::RegisterOneFactory();
clitk::XdrImageIOFactory::RegisterOneFactory();
rtk::ImagXImageIOFactory::RegisterOneFactory();
rtk::XRadImageIOFactory::RegisterOneFactory();
clitk::EsrfHstImageIOFactory::RegisterOneFactory();
-#if ITK_VERSION_MAJOR >= 4
itk::GDCMImageIOFactory::RegisterOneFactory();
itk::PNGImageIOFactory::RegisterOneFactory();
-#endif
} ////
extractedRegion.SetIndex(start);
typename FilterType::Pointer filter = FilterType::New();
-#if ITK_VERSION_MAJOR == 4
filter->SetDirectionCollapseToSubmatrix();
-#endif
filter->SetExtractionRegion(extractedRegion);
filter->SetInput(input);
filter->ReleaseDataFlagOn();
vv_image->AddItkImage<ItkImageType>(filter->GetOutput());
+ vv_image->ComputeScalarRangeBase<PixelType, Dim-1>(filter->GetOutput());
}
vv_image->SetTimeSpacing(input->GetSpacing()[Dim-1]);
vv_image->SetTimeOrigin(input->GetOrigin()[Dim-1]);
if (time_sequence) //The time sequence case: create a series of VTK images
ReadTimeSequence<Dim,PixelType>(vv_image, input, time_sequence);
- else //Dim == 1,2,3 and not time_sequence
+ else { //Dim == 1,2,3 and not time_sequence
vv_image->AddItkImage<InputImageType>(input);
-
+ vv_image->ComputeScalarRangeBase<PixelType, Dim>(input);
+ }
return vv_image;
}
};
// vtk
#include <vtkImageData.h>
#include <vtkTransform.h>
+#include <vtkDataObject.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
+#include <vtkVersion.h>
// std
#include <cassert>
mTimeSpacing = 1;
mTimeOrigin = 0;
mImageDimension = 0;
+ mrange[0] = std::numeric_limits<int>::max();;//min
+ mrange[1] = std::numeric_limits<int>::min();;//max
}
//--------------------------------------------------------------------
// mItkToVtkConverters is therefore not being updated, but
// up to here it's not being used anyway...
mImageDimension = 0;
+#if VTK_MAJOR_VERSION <= 5
int* extent = input->GetWholeExtent();
+#else
+ int* extent = input->GetInformation()->Get(vtkDataObject::DATA_EXTENT());
+#endif
if (extent[4] != extent[5])
mImageDimension = 3;
else if (extent[3] != extent[4])
//--------------------------------------------------------------------
void vvImage::GetScalarRange(double* range)
{
- assert(mVtkImages.size());
- double * temp = mVtkImages[0]->GetScalarRange();
- range[0]=temp[0];
- range[1]=temp[1];
- for (unsigned int i=1; i<mVtkImages.size(); i++) {
- temp = mVtkImages[i]->GetScalarRange();
- if (temp[0] < range[0]) range[0]=temp[0];
- if (temp[1] > range[1]) range[1]=temp[1];
- }
+ range[0]=mrange[0];
+ range[1]=mrange[1];
}
//--------------------------------------------------------------------
#include <vector>
#include <itkObjectFactory.h>
#include <itkProcessObject.h>
+#include <itkMinimumMaximumImageCalculator.h>
+#include <itkCastImageFilter.h>
#define VTK_EXCLUDE_STRSTREAM_HEADERS
#include <vtkSmartPointer.h>
typedef itk::SmartPointer<Self> Pointer;
typedef itk::ProcessObject::Pointer ConverterPointer;
itkNewMacro(Self);
+
+ struct DimensionDispatchBase {};
+ template< unsigned int VDimension >
+ struct DimensionDispatch:public DimensionDispatchBase {};
void Init();
void Reset();
int GetNumberOfDimensions() const;
int GetNumberOfSpatialDimensions();
void GetScalarRange(double* range);
+ template<class TPixelType, unsigned int VImageDimension> void ComputeScalarRangeBase(itk::Image<TPixelType,VImageDimension> *input);
+ template<class TPixelType, unsigned int VImageDimension> void ComputeScalarRange(DimensionDispatchBase, itk::Image<TPixelType,VImageDimension> *input);
+ template<class TPixelType, unsigned int VImageDimension> void ComputeScalarRange(DimensionDispatch< 1 >, itk::Image<TPixelType,VImageDimension> *input);
unsigned long GetActualMemorySize();
std::vector<double> GetSpacing();
std::vector<double> GetOrigin() const;
double mTimeOrigin;
double mTimeSpacing;
unsigned int mImageDimension;
+ double mrange[2];
};
//------------------------------------------------------------------------------
- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
===========================================================================*/
#include <itkImageToVTKImageFilter.h>
+#include <itkPixelTraits.h>
//--------------------------------------------------------------------
template<class TItkImageType>
// Update input before conversion to enable exceptions thrown by the ITK pipeline.
// Otherwise, vtkImageImport catches the exception for us.
input->Update();
-
+
// Convert from ITK object to VTK object
mImageDimension = TItkImageType::ImageDimension;
typedef itk::ImageToVTKImageFilter <TItkImageType> ConverterType;
matrix->Identity();
for(unsigned int i=0; i<input->GetImageDimension(); i++) {
for(unsigned int j=0; j<input->GetImageDimension(); j++) {
+#if VTK_MAJOR_VERSION <= 6
(*matrix)[i][j] = input->GetDirection()[i][j];
// Direction is used around the image origin in ITK
(*matrix)[i][3] -= (*matrix)[i][j] * input->GetOrigin()[j];
+#else
+ (*matrix).SetElement(i, j, input->GetDirection()[i][j]);
+ // Direction is used around the image origin in ITK
+ (*matrix).SetElement(i, 3, (*matrix).GetElement(i,3) - (*matrix).GetElement(i,j) * input->GetOrigin()[j]);
+#endif
}
+#if VTK_MAJOR_VERSION <= 6
(*matrix)[i][3] += input->GetOrigin()[i];
+#else
+ (*matrix).SetElement(i, 3, (*matrix).GetElement(i,3) + input->GetOrigin()[i]);
+#endif
}
// GetDirection provides the forward transform, vtkImageReslice wants the inverse
mDictionary.push_back(&(input->GetMetaDataDictionary()));
}
//--------------------------------------------------------------------
+
+/** Dispatch the computation of scalar range between vector and scalar image */
+template<class TPixelType, unsigned int VImageDimension>
+void vvImage::ComputeScalarRangeBase(itk::Image<TPixelType,VImageDimension> *input)
+{
+ itkStaticConstMacro(Dimension1, unsigned int, itk::PixelTraits< TPixelType >::Dimension);
+ ComputeScalarRange(DimensionDispatch< Dimension1 >(), input);
+}
+
+//--------------------------------------------------------------------
+/** Compute the scalar range for a vector pixel type */
+/** TO DO*/
+template<class TPixelType, unsigned int VImageDimension>
+void vvImage::ComputeScalarRange(DimensionDispatchBase, itk::Image<TPixelType,VImageDimension> *input)
+{
+}
+
+//--------------------------------------------------------------------
+/** Compute the scalar range for a scalar pixel type */
+template<class TPixelType, unsigned int VImageDimension>
+void vvImage::ComputeScalarRange(DimensionDispatch< 1 >, itk::Image<TPixelType,VImageDimension> *input)
+{
+ typedef typename itk::Image<TPixelType,VImageDimension> TItkImageType;
+ typedef itk::MinimumMaximumImageCalculator <TItkImageType> ImageCalculatorFilterType;
+
+ typename ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New ();
+ TPixelType tempMin, tempMax;
+ double tempRange[2];
+ imageCalculatorFilter->SetImage(input);
+ imageCalculatorFilter->Compute();
+ tempMin= imageCalculatorFilter->GetMinimum();
+ tempMax= imageCalculatorFilter->GetMaximum();
+
+ tempRange[0] = (double) tempMin;
+ tempRange[1] = (double) tempMax;
+
+ if (tempRange[0] < mrange[0]) mrange[0]=tempRange[0];
+ if (tempRange[1] > mrange[1]) mrange[1]=tempRange[1];
+}
+//--------------------------------------------------------------------
else
std::cerr << "Error, input pixel type : " << InputPixelType << " unknown !" << std::endl;
- if (CLITK_EXPERIMENTAL && mLastError.size()==0) {
+ if (mLastError.size()==0) {
//ReadNkiImageTransform();
ReadMatImageTransform();
}
reader->SetFileName(*i);
try {
mImage->AddItkImage<InputImageType>(reader->GetOutput());
+ mImage->ComputeScalarRangeBase<InputPixelType, VImageDimension-1>(reader->GetOutput());
} catch ( itk::ExceptionObject & err ) {
std::cerr << "Error while reading " << mInputFilenames[0].c_str()
<< " " << err << std::endl;
filter->SetExtractionRegion(extractedRegion);
filter->SetInput(reader->GetOutput());
filter->ReleaseDataFlagOn();
-#if ITK_VERSION_MAJOR == 4
filter->SetDirectionCollapseToSubmatrix();
-#endif
try {
mImage->AddItkImage<SlicedImageType>(filter->GetOutput());
+ mImage->ComputeScalarRangeBase<InputPixelType, VImageDimension-1>(filter->GetOutput());
} catch ( itk::ExceptionObject & err ) {
std::cerr << "Error while slicing " << mInputFilenames[0].c_str()
<< "(slice #" << mSlice << ") " << err << std::endl;
* This filter is implemented using the propagation algorithm
*/
-#if ITK_VERSION_MAJOR == 4
template <class TInputImage, class TOutputImage, class TtNorm=Functor::Minimum<
typename TOutputImage::PixelType,
typename TOutputImage::PixelType,
typename TOutputImage::PixelType> >
-#else
- template <class TInputImage, class TOutputImage, class TtNorm=Function::Minimum<
- typename TOutputImage::PixelType,
- typename TOutputImage::PixelType,
- typename TOutputImage::PixelType> >
-#endif
class ITK_EXPORT RelativePositionPropImageFilter :
public ImageToImageFilter< TInputImage, TOutputImage >
{
#include <itkBinaryErodeImageFilter.h>
#include <itkBinaryBallStructuringElement.h>
#include <itkAddImageFilter.h>
-#if ITK_VERSION_MAJOR >= 4
- #include <itkDivideImageFilter.h>
-#else
- #include <itkDivideByConstantImageFilter.h>
-#endif
+#include <itkDivideImageFilter.h>
// itk [Bloch et al]
#include "RelativePositionPropImageFilter.h"
// Divide by the number of relpos
if (GetNumberOfAngles() != 1) {
-#if ITK_VERSION_MAJOR >= 4
typedef itk::DivideImageFilter<FloatImageType, FloatImageType, FloatImageType> DivideFilter;
typename DivideFilter::Pointer divideFilter = DivideFilter::New();
divideFilter->SetConstant2(GetNumberOfAngles());
-#else
- typedef itk::DivideByConstantImageFilter<FloatImageType, float, FloatImageType> DivideFilter;
- typename DivideFilter::Pointer divideFilter = DivideFilter::New();
- divideFilter->SetConstant(GetNumberOfAngles());
-#endif
divideFilter->SetInput(m_FuzzyMap);
divideFilter->Update();
m_FuzzyMap = divideFilter->GetOutput();
void BeforeThreadedGenerateData(void );
// Threaded Generate Data
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, int threadId );
-#endif
-
//------------------------------------------------
//Member data
//-----------------------------------------------------------------------
template <class InputImageType, class OutputImageType>
void
- BackProjectImageFilter<InputImageType, OutputImageType>
-#if ITK_VERSION_MAJOR >= 4
- ::ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId )
-#else
- ::ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, int threadId )
-#endif
+ BackProjectImageFilter<InputImageType, OutputImageType>::ThreadedGenerateData( const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId )
{
//Projection pointer
InputImageConstPointer inputPtr=this->GetInput();
//========================================================================================
//Threaded execution should implement generate threaded data
-#if ITK_VERSION_MAJOR >= 4
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-#endif
+ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId );
bool m_Verbose;
PixelType m_EdgePaddingValue;
//=========================================================================================================================
//update the output for the outputRegionForThread
-#if ITK_VERSION_MAJOR >= 4
template<class InputImageType, class OutputImageType>
void ComposeVFFilter<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId )
-#else
- template<class InputImageType, class OutputImageType>
- void ComposeVFFilter<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId )
-#endif
{
//Get pointer to the output
const OutputImageRegionType &srcRegion);
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-#endif
InputImageRegionType m_ExtractionRegion;
OutputImageRegionType m_OutputImageRegion;
*/
template <class TInputImage, class TOutputImage>
void
-ExtractImageFilter<TInputImage,TOutputImage>
-#if ITK_VERSION_MAJOR >= 4
-::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId)
-#else
-::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId)
-#endif
+ExtractImageFilter<TInputImage,TOutputImage>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId)
{
itkDebugMacro(<<"Actually executing");
m_size[GetDirection()] = 0;
m_region.SetSize(m_size);
int start = m_index[GetDirection()];
-#if ITK_VERSION_MAJOR >= 4
this->SetNumberOfIndexedInputs(m_NumberOfSlices);
-#else
- this->SetNumberOfOutputs(m_NumberOfSlices);
-#endif
//--------------------------------------------------------------------
// loop ExtractImageFilter with region updated, push_back
m_index[GetDirection()] = start + i;
m_region.SetIndex(m_index);
extract->SetExtractionRegion(m_region);
-#if ITK_VERSION_MAJOR == 4
extract->SetDirectionCollapseToSubmatrix();
-#endif
extract->Update();
this->SetNthOutput(i, extract->GetOutput());
}
//the actual processing
void BeforeThreadedGenerateData();
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-#endif
//member data
typename WeightsImageType::Pointer m_Weights;
//=========================================================================================================================
//update the output for the outputRegionForThread
template<class InputImageType, class OutputImageType>
-#if ITK_VERSION_MAJOR >= 4
void HelperClass1<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId )
-#else
-void HelperClass1<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId )
-#endif
{
// std::cout << "HelperClass1::ThreadedGenerateData - IN " << threadId << std::endl;
//Get pointer to the input
//the actual processing
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-#endif
//member data
typename WeightsImageType::Pointer m_Weights;
//=========================================================================================================================
//update the output for the outputRegionForThread
-#if ITK_VERSION_MAJOR >= 4
template<class InputImageType, class OutputImageType > void HelperClass2<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId )
-#else
-template<class InputImageType, class OutputImageType > void HelperClass2<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId )
-#endif
{
// std::cout << "HelperClass2::ThreadedGenerateData - IN " << threadId << std::endl;
#include <vtkLinearExtrusionFilter.h>
#include <vtkImageStencil.h>
#include <vtkMetaImageWriter.h>
+#include <vtkVersion.h>
#include "itkVTKImageImport.h"
#include "vtkImageExport.h"
{
// GO
vtkSmartPointer<vtkImageData> binary_image=vtkSmartPointer<vtkImageData>::New();
+#if VTK_MAJOR_VERSION <= 5
binary_image->SetScalarTypeToUnsignedChar();
// Set spacing
// Allocate data
binary_image->AllocateScalars();
+#else
+ // Set spacing
+ PointType samp_origin = m_LikeImage->GetOrigin();
+ SpacingType spacing=m_LikeImage->GetSpacing();
+ double * spacing2 = new double[3];
+ spacing2[0] = spacing[0];
+ spacing2[1] = spacing[1];
+ spacing2[2] = spacing[2];
+ binary_image->SetSpacing(spacing2);
+
+ // Set origin
+ /// Put the origin on a voxel to avoid small skips
+ binary_image->SetOrigin(samp_origin[0], samp_origin[1], samp_origin[2]);
+
+ // Compute image bounds
+ binary_image->SetExtent(0,m_LikeImage->GetLargestPossibleRegion().GetSize()[0],
+ 0,m_LikeImage->GetLargestPossibleRegion().GetSize()[1],
+ 0,m_LikeImage->GetLargestPossibleRegion().GetSize()[2]
+ );
+
+ // Allocate data
+ binary_image->AllocateScalars(VTK_UNSIGNED_CHAR, 1);
+#endif
memset(binary_image->GetScalarPointer(),0,
binary_image->GetDimensions()[0]*binary_image->GetDimensions()[1]*binary_image->GetDimensions()[2]*sizeof(unsigned char));
if (m_Extrude)
{
vtkSmartPointer<vtkLinearExtrusionFilter> extrude=vtkSmartPointer<vtkLinearExtrusionFilter>::New();
+#if VTK_MAJOR_VERSION <= 5
extrude->SetInput(m_Mesh);
+#else
+ extrude->SetInputData(m_Mesh);
+#endif
// We extrude in the -slice_spacing direction to respect the FOCAL convention
extrude->SetVector(0, 0, -m_LikeImage->GetSpacing()[2]);
+#if VTK_MAJOR_VERSION <= 5
sts->SetInput(extrude->GetOutput());
+#else
+ sts->SetInputConnection(extrude->GetOutputPort());
+#endif
// When extrude ScaleFactor indicate the extrusion scaling (default = 1)
/*
*/
}
else
+#if VTK_MAJOR_VERSION <= 5
sts->SetInput(m_Mesh);
+#else
+ sts->SetInputData(m_Mesh);
+#endif
// Stencil
vtkSmartPointer<vtkImageStencil> stencil=vtkSmartPointer<vtkImageStencil>::New();
+#if VTK_MAJOR_VERSION <= 5
stencil->SetStencil(sts->GetOutput());
stencil->SetInput(binary_image);
+#else
+ stencil->SetStencilData(sts->GetOutput());
+ stencil->SetInputData(binary_image);
+#endif
// Convert VTK to ITK
vtkImageExport * m_Exporter = vtkImageExport::New();
m_Importer->SetBufferPointerCallback( m_Exporter->GetBufferPointerCallback());
m_Importer->SetCallbackUserData( m_Exporter->GetCallbackUserData());
+#if VTK_MAJOR_VERSION <= 5
m_Exporter->SetInput( stencil->GetOutput() );
+#else
+ m_Exporter->SetInputData( stencil->GetOutput() );
+#endif
m_Importer->Update();
// writeImage<ImageType>(m_Importer->GetOutput(), "f.mhd");
#include "itkConnectedComponentImageFilter.h"
#include "itkStatisticsImageFilter.h"
#include "itkCastImageFilter.h"
-#if ITK_VERSION_MAJOR >= 4
- #include "itkTestingComparisonImageFilter.h"
-#else
- #include "itkDifferenceImageFilter.h"
-#endif
+#include "itkTestingComparisonImageFilter.h"
#include "itkThresholdImageFilter.h"
namespace clitk
typedef itk::StatisticsImageFilter<InternalImageType> StatisticsImageFilterType;
typedef itk::BinaryBallStructuringElement<InternalPixelType,InputImageDimension > KernelType;
typedef clitk::ConditionalBinaryDilateImageFilter<InternalImageType, InternalImageType , KernelType> ConditionalBinaryDilateImageFilterType;
-#if ITK_VERSION_MAJOR >= 4
typedef itk::Testing::ComparisonImageFilter<InternalImageType, InternalImageType> DifferenceImageFilterType;
-#else
- typedef itk::DifferenceImageFilter<InternalImageType, InternalImageType> DifferenceImageFilterType;
-#endif
typedef itk::CastImageFilter<InternalImageType, OutputImageType> OutputCastImageFilterType;
typedef clitk::SetBackgroundImageFilter<InternalImageType, InternalImageType, InternalImageType> SetBackgroundImageFilterType;
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
-#endif
private:
FlexibleBinaryFunctorImageFilter(const Self&); //purposely not implemented
template <class TInputImage1, class TInputImage2, class TOutputImage, class TFunction >
void
FlexibleBinaryFunctorImageFilter<TInputImage1, TInputImage2, TOutputImage, TFunction>
-::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread,
-#if ITK_VERSION_MAJOR >= 4
- itk::ThreadIdType threadId )
-#else
- int threadId)
-#endif
+::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, itk::ThreadIdType threadId )
{
const unsigned int dim = Input1ImageType::ImageDimension;
VTKImageToImageFilter<TOutputImage>
::SetInput( vtkImageData * inputImage )
{
+#if VTK_MAJOR_VERSION <= 5
m_Exporter->SetInput( inputImage );
+#else
+ m_Exporter->SetInputData( inputImage );
+#endif
}
typedef typename InputImageType::PixelType PixelType;
//typedef typename InputImageType::ImageDimension Dimension;
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
bool threadsGiven=m_ArgsInfo.threads_given;
int threads=m_ArgsInfo.threads_arg;
-#endif
//Coordinate Representation
typedef double TCoordRep;
typename MetricType::Pointer metric=genericMetric->GetMetricPointer();
if (movingMask) metric->SetMovingImageMask(movingMask);
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
if (threadsGiven) metric->SetNumberOfThreads( threads );
-#else
- if (m_Verbose) std::cout<<"Not setting the number of threads (not compiled with USE_OPTIMIZED_REGISTRATION_METHODS)..."<<std::endl;
-#endif
//============================================================================
// Initialize using image moments.
if (m_Verbose) std::cout << "Starting the registration now..." << std::endl;
try {
-#if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 2)
- registration->StartRegistration();
-#else
registration->Update();
-#endif
} catch ( itk::ExceptionObject & err ) {
std::cerr << "ExceptionObject caught !" << std::endl;
std::cerr << err << std::endl;
// Crop the fixedImage to the bounding box to facilitate multi-resolution
typedef itk::ExtractImageFilter<FixedImageType,FixedImageType> ExtractImageFilterType;
typename ExtractImageFilterType::Pointer extractImageFilter=ExtractImageFilterType::New();
-#if ITK_VERSION_MAJOR == 4
extractImageFilter->SetDirectionCollapseToSubmatrix();
-#endif
extractImageFilter->SetInput(fixedImage);
extractImageFilter->SetExtractionRegion(transformRegion);
extractImageFilter->Update();
typedef itk::ImageToImageMetric< FixedImageType, MovingImageType > MetricType;
typename MetricType::Pointer metric=genericMetric->GetMetricPointer();
if (movingMask) metric->SetMovingImageMask(movingMask);
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
if (threadsGiven) {
metric->SetNumberOfThreads( threads );
if (m_Verbose) std::cout<< "Using " << threads << " threads." << std::endl;
}
-#else
- if (m_Verbose) std::cout<<"Not setting the number of threads (not compiled with USE_OPTIMIZED_REGISTRATION_METHODS)..."<<std::endl;
-#endif
-
//=======================================================
// Optimizer
try
{
-#if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 2)
- registration->StartRegistration();
-#else
registration->Update();
-#endif
}
catch( itk::ExceptionObject & err )
{
# else
typedef itk::TransformToDisplacementFieldFilter<DisplacementFieldType, double> ConvertorType;
# endif
-#else
- typedef itk::TransformToDeformationFieldSource<DisplacementFieldType, double> ConvertorType;
#endif
typename ConvertorType::Pointer filter= ConvertorType::New();
filter->SetNumberOfThreads(1);
/** Standard parameters container. */
typedef typename Superclass::ParametersType ParametersType;
-#if ITK_VERSION_MAJOR >= 4
typedef typename Superclass::NumberOfParametersType NumberOfParametersType;
-#endif
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
}
/** Compute the Jacobian Matrix of the transformation at one point */
-#if ITK_VERSION_MAJOR >= 4
virtual void ComputeJacobianWithRespectToParameters (const InputPointType &p, JacobianType &jacobian) const;
virtual void ComputeJacobianWithRespectToPosition (const InputPointType &p, JacobianType &jacobian) const
{
itkExceptionMacro( "ComputeJacobianWithRespectToPosition not yet implemented for " << this->GetNameOfClass() );
}
-#else
- virtual const JacobianType& GetJacobian(const InputPointType &point ) const;
-#endif
/** Return the number of parameters that completely define the Transfom */
-#if ITK_VERSION_MAJOR >= 4
virtual NumberOfParametersType GetNumberOfParameters(void) const;
-#else
- virtual unsigned int GetNumberOfParameters(void) const;
-#endif
/** Return the number of parameters per dimension */
unsigned int GetNumberOfParametersPerDimension(void) const;
// VD Add MultipleBSplineDeformableTransform as friend to facilitate wrapping
friend class MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>;
-#if ITK_VERSION_MAJOR >= 4
mutable JacobianType m_SharedDataBSplineJacobian;
-#endif
-
}; //class BSplineDeformableTransform
// Constructor with default arguments
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
- BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
- ::BSplineDeformableTransform():Superclass(0)
-#else
- ::BSplineDeformableTransform():Superclass(OutputDimension,0)
-#endif
+ BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::BSplineDeformableTransform():Superclass(0)
{
unsigned int i;
// Get the number of parameters
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
typename BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::NumberOfParametersType
-#else
- unsigned int
-#endif
BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
::GetNumberOfParameters(void) const
{
m_CoefficientImage = m_WrappedImage;
//JV Wrap jacobian into OutputDimension X Vectorial images
-#if ITK_VERSION_MAJOR >= 4
this->m_SharedDataBSplineJacobian.set_size( OutputDimension, this->GetNumberOfParameters() );
-#else
- this->m_Jacobian.set_size( OutputDimension, this->GetNumberOfParameters() );
-#endif
// Use memset to set the memory
-#if ITK_VERSION_MAJOR >= 4
JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_SharedDataBSplineJacobian.data_block());
-#else
- JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_Jacobian.data_block());
-#endif
+
memset(jacobianDataPointer, 0, OutputDimension*numberOfPixels*sizeof(JacobianPixelType));
m_LastJacobianIndex = m_ValidRegion.GetIndex();
m_NeedResetJacobian = false;
// JV weights are identical as for transformpoint, could be done simultaneously in metric!!!!
// Compute the Jacobian in one position
-#if ITK_VERSION_MAJOR >= 4
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
void
BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
jacobian = m_SharedDataBSplineJacobian;
}
-#else
- template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
- const
- typename BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
- ::JacobianType &
- BSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
- ::GetJacobian( const InputPointType & point ) const
- {
- // Can only compute Jacobian if parameters are set via
- // SetParameters or SetParametersByValue
- // if( m_InputParametersPointer == NULL )
- // {
- // itkExceptionMacro( <<"Cannot compute Jacobian: parameters not set" );
- // }
-
- if (m_NeedResetJacobian)
- ResetJacobian();
- //========================================================
- // For each dimension, copy the weight to the support region
- //========================================================
-
- // Check if inside mask
- if(m_Mask && !(m_Mask->IsInside(point) ) )
- {
- // Outside: no (deformable) displacement
- return this->m_Jacobian;
- }
-
- //Get index
- this->TransformPointToContinuousIndex( point, m_Index );
-
- // NOTE: if the support region does not lie totally within the grid
- // we assume zero displacement and return the input point
- if ( !this->InsideValidRegion( m_Index ) )
- {
- return this->m_Jacobian;
- }
-
- //Compute interpolation weights
- const WeightsDataType *weights=NULL;
- m_VectorInterpolator->EvaluateWeightsAtContinuousIndex( m_Index, &weights, m_LastJacobianIndex);
- m_SupportRegion.SetIndex( m_LastJacobianIndex );
-
- //Reset the iterators
- unsigned int j = 0;
- for ( j = 0; j < OutputDimension; j++ )
- m_Iterator[j] = IteratorType( m_JacobianImage[j], m_SupportRegion);
-
- // For each dimension, copy the weight to the support region
- while ( ! (m_Iterator[0]).IsAtEnd() )
- {
- //copy weight to jacobian image
- for ( j = 0; j < OutputDimension; j++ )
- {
- m_ZeroVector[j]=*weights;
- (m_Iterator[j]).Set( m_ZeroVector);
- m_ZeroVector[j]=itk::NumericTraits<JacobianValueType>::Zero;
- ++(m_Iterator[j]);
- }
- // go to next coefficient in the support region
- weights++;
- }
- m_NeedResetJacobian = true;
-
- // Return the result
- return this->m_Jacobian;
-
- }
-#endif
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
# else
# include "itkTransformToDisplacementFieldFilter.h"
# endif
-#else
-# include "itkTransformToDeformationFieldSource.h"
#endif
namespace clitk
# else
typedef itk::TransformToDisplacementFieldFilter<OutputImageType, double> ConvertorType;
# endif
-#else
- typedef itk::TransformToDeformationFieldSource<OutputImageType, double> ConvertorType;
#endif
itkNewMacro(Self);
typedef clitk::VectorImageToImageFilter<BLUTCoefficientImageType, typename ITKTransformType::ImageType> FilterType;
typename FilterType::Pointer component_filter[BLUTCoefficientImageType::ImageDimension];
-
-#if ITK_VERSION_MAJOR >= 4
typename ITKTransformType::CoefficientImageArray coefficient_images;
-#else
- typename ITKTransformType::ImagePointer coefficient_images[BLUTCoefficientImageType::ImageDimension];
-#endif
for (unsigned int i=0; i < BLUTCoefficientImageType::ImageDimension; i++) {
component_filter[i] = FilterType::New();
coefficient_images[i] = component_filter[i]->GetOutput();
}
-#if ITK_VERSION_MAJOR >= 4
// RP: 16/01/2013
// ATTENTION: Apparently, there's a bug in the SetCoefficientImages function of ITK 4.x
// I needed to use SetParametersByValue instead.
m_ITKTransform->SetGridRegion(input->GetLargestPossibleRegion());
m_ITKTransform->SetGridSpacing(input->GetSpacing());
m_ITKTransform->SetParametersByValue(params);
-#else
- m_ITKTransform->SetCoefficientImage(coefficient_images);
-#endif
m_GenericTransform = m_ITKTransform;
}
if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint , jacobian);
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
const RealType fixedValue = ti.Value();
this->m_NumberOfPixelsCounted++;
if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
const RealType fixedValue = ti.Value();
this->m_NumberOfPixelsCounted++;
return OutputCovariantVectorType();
}
-#if ITK_VERSION_MAJOR >= 4
virtual void ComputeJacobianWithRespectToParameters (const InputPointType &p, JacobianType &jacobian) const
{
itkExceptionMacro( << "DeformationFieldTransform doesn't declare ComputeJacobianWithRespectToParameters" );
{
itkExceptionMacro( << "DeformationFieldTransform doesn't declare ComputeJacobianWithRespectToPosition" );
}
-#else
- virtual const JacobianType& GetJacobian(const InputPointType &point ) const
- {
- itkExceptionMacro( << "DeformationFieldTransform doesn't declare GetJacobian" );
- return this->m_Jacobian;
- }
-#endif
protected:
DeformationFieldTransform();
// Constructor
template<class TScalarType, unsigned int InputDimension, unsigned int OutputDimension, unsigned int SpaceDimension>
- DeformationFieldTransform<TScalarType, InputDimension, OutputDimension, SpaceDimension>
-#if ITK_VERSION_MAJOR >= 4
- ::DeformationFieldTransform():Superclass(1)
-#else
- ::DeformationFieldTransform():Superclass(OutputDimension,1)
-#endif
+ DeformationFieldTransform<TScalarType, InputDimension, OutputDimension, SpaceDimension>::DeformationFieldTransform():Superclass(1)
+
{
m_DeformationField=NULL;
m_Interpolator=DefaultInterpolatorType::New();
//find the multiresolution filter
// typedef typename RegistrationFilterType::FixedImageType InternalImageType;
// typedef typename RegistrationFilterType::MovingImageType MovingImageType;
-#if ITK_VERSION_MAJOR >= 4
typedef typename RegistrationFilterType::DisplacementFieldType DisplacementFieldType;
-#else
- typedef typename RegistrationFilterType::DeformationFieldType DisplacementFieldType;
-#endif
typedef clitk::MultiResolutionPDEDeformableRegistration<FixedImageType, MovingImageType, DisplacementFieldType> MultiResolutionRegistrationType;
typedef CommandResolutionLevelUpdate<MultiResolutionRegistrationType> LevelObserver;
//JV TODO
// pdeFilter->SetMaximumError(m_ArgsInfo.maxError_arg);
// pdeFilter->SetMaximumKernelWidth(m_ArgsInfo.maxError_arg);
-#if ITK_VERSION_MAJOR >= 4
pdeFilter->SetSmoothDisplacementField(!m_ArgsInfo.fluid_flag);
-#else
- pdeFilter->SetSmoothDeformationField(!m_ArgsInfo.fluid_flag);
-#endif
pdeFilter->SetSmoothUpdateField(m_ArgsInfo.fluid_flag);
pdeFilter->SetUseImageSpacing( m_ArgsInfo.spacing_flag );
typedef itk::WarpImageFilter< MovingImageType, FixedImageType, DeformationFieldType > WarpFilterType;
typename WarpFilterType::Pointer warp = WarpFilterType::New();
-#if ITK_VERSION_MAJOR >= 4
warp->SetDisplacementField( deformationField );
-#else
- warp->SetDeformationField( deformationField );
-#endif
warp->SetInput( movingImageReader->GetOutput() );
warp->SetOutputOrigin( fixedImage->GetOrigin() );
warp->SetOutputSpacing( fixedImage->GetSpacing() );
typename FixedImageType::Pointer m_FixedImage;
typename FixedImageMaskType::ConstPointer m_FixedImageMask;
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
FixedImagePixelType m_FixedImageSamplesIntensityThreshold;
bool m_UseFixedImageSamplesIntensityThreshold;
-#endif
-
};
} // end namespace clitk
m_Maximize=false;
m_Verbose=false;
m_FixedImageRegionGiven=false;
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
m_FixedImageSamplesIntensityThreshold=0;
m_UseFixedImageSamplesIntensityThreshold=false;
-#endif
m_FixedImageMask=NULL;
}
m_Metric->SetFixedImageRegion(m_FixedImageRegion);
//m_Metric->SetFixedImageRegion(mask_region);
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
-
//============================================================================
// Set the lower intensity threshold
if (m_ArgsInfo.intThreshold_given) {
if (m_Verbose) std::cout<<"number of mask pixels "<<totalNumberOfMaskPixels<<std::endl;
}
-
-#else
- if (m_Verbose) std::cout<<"Not setting the fixed image intensity threshold or the fraction of samples to use (not compiled with USE_OPTIMIZED_REGISTRATION_METHODS)..."<<std::endl;
-
-
-#endif
//============================================================================
//return the pointer
return m_Metric;
bool m_OptimizerInitialized;
InternalOptimizerType * m_VnlOptimizer;
-#if ITK_VERSION_MAJOR > 3
mutable std::ostringstream m_StopConditionDescription;
-#else
- mutable itk::OStringStream m_StopConditionDescription;
-#endif
BoundValueType m_LowerBound;
BoundValueType m_UpperBound;
BoundSelectionType m_BoundSelection;
# else
# include "itkTransformToDisplacementFieldFilter.h"
# endif
-#else
-# include "itkTransformToDeformationFieldSource.h"
#endif
#include "itkAffineTransform.h"
# else
typedef itk::TransformToDisplacementFieldFilter<OutputImageType, double> ConvertorType;
# endif
-#else
- typedef itk::TransformToDeformationFieldSource<OutputImageType, double> ConvertorType;
#endif
typename ConvertorType::Pointer filter= ConvertorType::New();
if( tempField.IsNull() )
{
-#if ITK_VERSION_MAJOR >= 4
m_RegistrationFilter->SetInitialDisplacementField( NULL );
-#else
- m_RegistrationFilter->SetInitialDeformationField( NULL );
-#endif
}
else
{
tempField = m_FieldExpander->GetOutput();
tempField->DisconnectPipeline();
-#if ITK_VERSION_MAJOR >= 4
m_RegistrationFilter->SetInitialDisplacementField( tempField );
-#else
- m_RegistrationFilter->SetInitialDeformationField( tempField );
-#endif
-
}
// setup registration filter and pyramids
/** Standard parameters container. */
typedef typename Superclass::ParametersType ParametersType;
-#if ITK_VERSION_MAJOR >= 4
typedef typename Superclass::NumberOfParametersType NumberOfParametersType;
-#endif
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
}
/** Compute the Jacobian Matrix of the transformation at one point */
-#if ITK_VERSION_MAJOR >= 4
virtual void ComputeJacobianWithRespectToParameters (const InputPointType &p, JacobianType &jacobian) const;
virtual void ComputeJacobianWithRespectToPosition (const InputPointType &p, JacobianType &jacobian) const
{
itkExceptionMacro( "ComputeJacobianWithRespectToPosition not yet implemented for " << this->GetNameOfClass() );
}
-#else
- virtual const JacobianType& GetJacobian(const InputPointType &point ) const;
-#endif
/** Return the number of parameters that completely define the Transfom */
-#if ITK_VERSION_MAJOR >= 4
virtual NumberOfParametersType GetNumberOfParameters(void) const;
-#else
- virtual unsigned int GetNumberOfParameters(void) const;
-#endif
/** Return the number of parameters per dimension */
unsigned int GetNumberOfParametersPerDimension(void) const;
std::vector<ParametersType> m_parameters;
mutable std::vector<CoefficientImagePointer> m_CoefficientImages;
mutable int m_LastJacobian;
-#if ITK_VERSION_MAJOR >= 4
mutable JacobianType m_SharedDataBSplineJacobian;
-#endif
void InitJacobian();
// FIXME it seems not used
{
// Constructor with default arguments
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
- MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
- ::MultipleBSplineDeformableTransform() : Superclass(0)
-#else
- ::MultipleBSplineDeformableTransform() : Superclass(OutputDimension, 0)
-#endif
+ MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::MultipleBSplineDeformableTransform() : Superclass(0)
{
m_nLabels = 1;
m_labels = 0;
#undef LOOP_ON_LABELS
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
inline typename MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::NumberOfParametersType
-#else
- inline unsigned int
-#endif
MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
::GetNumberOfParameters(void) const
{
return m_trans[lidx]->DeformablyTransformPoint(inputPoint);
}
-#if ITK_VERSION_MAJOR >= 4
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
inline void
MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
jacobian = this->m_SharedDataBSplineJacobian;
}
-#else
- template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
- inline const typename MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::JacobianType &
- MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
- ::GetJacobian( const InputPointType & point ) const
- {
- if (m_LastJacobian != -1)
- m_trans[m_LastJacobian]->ResetJacobian();
-
- int lidx = 0;
- if (m_labels)
- lidx = m_labelInterpolator->Evaluate(point) - 1;
- if (lidx == -1)
- {
- m_LastJacobian = lidx;
- return this->m_Jacobian;
- }
-
- m_trans[lidx]->GetJacobian(point);
- m_LastJacobian = lidx;
-
- return this->m_Jacobian;
- }
-#endif
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
inline void
MultipleBSplineDeformableTransform<TCoordRep, NInputDimensions,NOutputDimensions>::InitJacobian()
{
unsigned numberOfParameters = this->GetNumberOfParameters();
-#if ITK_VERSION_MAJOR >= 4
this->m_SharedDataBSplineJacobian.set_size(OutputDimension, numberOfParameters);
JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_SharedDataBSplineJacobian.data_block());
-#else
- this->m_Jacobian.set_size(OutputDimension, numberOfParameters);
- JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_Jacobian.data_block());
-#endif
memset(jacobianDataPointer, 0, numberOfParameters * sizeof (JacobianPixelType));
unsigned tot = 0;
// This line can be removed once the optimized versions
// gets integrated into the main directories.
#include "itkConfigure.h"
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "clitkOptNormalizedCorrelationImageToImageMetric.h"
-#else
-
-#include "itkImageToImageMetric.h"
-#include "itkCovariantVector.h"
-#include "itkPoint.h"
-
-
-namespace clitk
-{
-
-template < class TFixedImage, class TMovingImage >
-class ITK_EXPORT NormalizedCorrelationImageToImageMetric :
- public itk::ImageToImageMetric< TFixedImage, TMovingImage>
-{
-public:
-
- /** Standard class typedefs. */
- typedef NormalizedCorrelationImageToImageMetric Self;
- typedef itk::ImageToImageMetric<TFixedImage, TMovingImage > Superclass;
-
- typedef itk::SmartPointer<Self> Pointer;
- typedef itk::SmartPointer<const Self> ConstPointer;
-
- /** Method for creation through the object factory. */
- itkNewMacro(Self);
-
- /** Run-time type information (and related methods). */
- itkTypeMacro(NormalizedCorrelationImageToImageMetric, itk::Object);
-
-
- /** Types transferred from the base class */
- typedef typename Superclass::RealType RealType;
- typedef typename Superclass::TransformType TransformType;
- typedef typename Superclass::TransformPointer TransformPointer;
- typedef typename Superclass::TransformParametersType TransformParametersType;
- typedef typename Superclass::TransformJacobianType TransformJacobianType;
- typedef typename Superclass::GradientPixelType GradientPixelType;
- typedef typename Superclass::OutputPointType OutputPointType;
- typedef typename Superclass::InputPointType InputPointType;
-
- typedef typename Superclass::MeasureType MeasureType;
- typedef typename Superclass::DerivativeType DerivativeType;
- typedef typename Superclass::FixedImageType FixedImageType;
- typedef typename Superclass::MovingImageType MovingImageType;
- typedef typename Superclass::FixedImageConstPointer FixedImageConstPointer;
- typedef typename Superclass::MovingImageConstPointer MovingImageConstPointer;
-
-
- /** Get the derivatives of the match measure. */
- void GetDerivative( const TransformParametersType & parameters,
- DerivativeType & Derivative ) const;
-
- /** Get the value for single valued optimizers. */
- MeasureType GetValue( const TransformParametersType & parameters ) const;
-
- /** Get value and derivatives for multiple valued optimizers. */
- void GetValueAndDerivative( const TransformParametersType & parameters,
- MeasureType& Value, DerivativeType& Derivative ) const;
-
- /** Set/Get SubtractMean boolean. If true, the sample mean is subtracted
- * from the sample values in the cross-correlation formula and
- * typically results in narrower valleys in the cost fucntion.
- * Default value is false. */
- itkSetMacro( SubtractMean, bool );
- itkGetConstReferenceMacro( SubtractMean, bool );
- itkBooleanMacro( SubtractMean );
-
-protected:
- NormalizedCorrelationImageToImageMetric();
- virtual ~NormalizedCorrelationImageToImageMetric() {};
- void PrintSelf(std::ostream& os, itk::Indent indent) const;
-
-private:
- NormalizedCorrelationImageToImageMetric(const Self&); //purposely not implemented
- void operator=(const Self&); //purposely not implemented
-
- bool m_SubtractMean;
-
-};
-
-} // end namespace clitk
-
-#ifndef ITK_MANUAL_INSTANTIATION
-#include "clitkNormalizedCorrelationImageToImageMetric.txx"
-#endif
-
-#endif // opt
#endif // _clitkNormalizedCorrelationImageToImageMetric.txx
// gets integrated into the main directories.
#include "itkConfigure.h"
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "clitkOptNormalizedCorrelationImageToImageMetric.txx"
-#else
-
-
-#include "clitkNormalizedCorrelationImageToImageMetric.h"
-
-#include "itkImageRegionConstIteratorWithIndex.h"
-
-
-namespace clitk
-{
-
-/*
- * Constructor
- */
-template <class TFixedImage, class TMovingImage>
-NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>
-::NormalizedCorrelationImageToImageMetric()
-{
- m_SubtractMean = false;
-}
-
-/*
- * Get the match Measure
- */
-template <class TFixedImage, class TMovingImage>
-typename NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>::MeasureType
-NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>
-::GetValue( const TransformParametersType & parameters ) const
-{
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- MeasureType measure;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- measure = sfm / denom;
- } else {
- measure = itk::NumericTraits< MeasureType >::Zero;
- }
-
- return measure;
-
-}
-
-
-
-
-
-/*
- * Get the Derivative Measure
- */
-template < class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>
-::GetDerivative( const TransformParametersType & parameters,
- DerivativeType & derivative ) const
-{
-
- if( !this->GetGradientImage() ) {
- itkExceptionMacro(<<"The gradient image is null, maybe you forgot to call Initialize()");
- }
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- const unsigned int dimension = FixedImageType::ImageDimension;
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- const unsigned int ParametersDimension = this->GetNumberOfParameters();
- derivative = DerivativeType( ParametersDimension );
- derivative.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeF = DerivativeType( ParametersDimension );
- derivativeF.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM = DerivativeType( ParametersDimension );
- derivativeM.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- ti.GoToBegin();
- // First compute the sums
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
- // Compute contributions to derivatives
- ti.GoToBegin();
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if ( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if ( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
-
-#if ITK_VERSION_MAJOR >= 4
- TransformJacobianType jacobian;
- this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
- // Get the gradient by NearestNeighboorInterpolation:
- // which is equivalent to round up the point components.
- typedef typename OutputPointType::CoordRepType CoordRepType;
- typedef itk::ContinuousIndex<CoordRepType,MovingImageType::ImageDimension>
- MovingImageContinuousIndexType;
-
- MovingImageContinuousIndexType tempIndex;
- this->m_MovingImage->TransformPhysicalPointToContinuousIndex( transformedPoint, tempIndex );
-
- typename MovingImageType::IndexType mappedIndex;
- mappedIndex.CopyWithRound( tempIndex );
-
- const GradientPixelType gradient =
- this->GetGradientImage()->GetPixel( mappedIndex );
-
- for(unsigned int par=0; par<ParametersDimension; par++) {
- RealType sumF = itk::NumericTraits< RealType >::Zero;
- RealType sumM = itk::NumericTraits< RealType >::Zero;
- for(unsigned int dim=0; dim<dimension; dim++) {
- const RealType differential = jacobian( dim, par ) * gradient[dim];
- sumF += fixedValue * differential;
- sumM += movingValue * differential;
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sumF -= differential * sf / this->m_NumberOfPixelsCounted;
- sumM -= differential * sm / this->m_NumberOfPixelsCounted;
- }
- }
- derivativeF[par] += sumF;
- derivativeM[par] += sumM;
- }
- }
-
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = ( derivativeF[i] - (sfm/smm)* derivativeM[i] ) / denom;
- }
- } else {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = itk::NumericTraits< MeasureType >::Zero;
- }
- }
-
-}
-
-
-/*
- * Get both the match Measure and theDerivative Measure
- */
-template <class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>
-::GetValueAndDerivative(const TransformParametersType & parameters,
- MeasureType & value, DerivativeType & derivative) const
-{
-
-
- if( !this->GetGradientImage() ) {
- itkExceptionMacro(<<"The gradient image is null, maybe you forgot to call Initialize()");
- }
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- const unsigned int dimension = FixedImageType::ImageDimension;
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- const unsigned int ParametersDimension = this->GetNumberOfParameters();
- derivative = DerivativeType( ParametersDimension );
- derivative.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeF = DerivativeType( ParametersDimension );
- derivativeF.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM = DerivativeType( ParametersDimension );
- derivativeM.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM1 = DerivativeType( ParametersDimension );
- derivativeM1.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- ti.GoToBegin();
- // First compute the sums
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
-
- // Compute contributions to derivatives
- ti.GoToBegin();
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
-
-#if ITK_VERSION_MAJOR >= 4
- TransformJacobianType jacobian;
- this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
- // Get the gradient by NearestNeighboorInterpolation:
- // which is equivalent to round up the point components.
- typedef typename OutputPointType::CoordRepType CoordRepType;
- typedef itk::ContinuousIndex<CoordRepType,MovingImageType::ImageDimension>
- MovingImageContinuousIndexType;
-
- MovingImageContinuousIndexType tempIndex;
- this->m_MovingImage->TransformPhysicalPointToContinuousIndex( transformedPoint, tempIndex );
-
- typename MovingImageType::IndexType mappedIndex;
- mappedIndex.CopyWithRound( tempIndex );
-
- const GradientPixelType gradient =
- this->GetGradientImage()->GetPixel( mappedIndex );
-
- for(unsigned int par=0; par<ParametersDimension; par++) {
- RealType sumF = itk::NumericTraits< RealType >::Zero;
- RealType sumM = itk::NumericTraits< RealType >::Zero;
- for(unsigned int dim=0; dim<dimension; dim++) {
- const RealType differential = jacobian( dim, par ) * gradient[dim];
- sumF += fixedValue * differential;
- sumM += movingValue * differential;
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sumF -= differential * sf / this->m_NumberOfPixelsCounted;
- sumM -= differential * sm / this->m_NumberOfPixelsCounted;
- }
- }
- derivativeF[par] += sumF;
- derivativeM[par] += sumM;
- }
- }
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = ( derivativeF[i] - (sfm/smm)* derivativeM[i] ) / denom;
- }
- value = sfm / denom;
- } else {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = itk::NumericTraits< MeasureType >::Zero;
- }
- value = itk::NumericTraits< MeasureType >::Zero;
- }
-
-
-
-}
-
-template < class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetric<TFixedImage,TMovingImage>
-::PrintSelf(std::ostream& os, itk::Indent indent) const
-{
- Superclass::PrintSelf(os, indent);
- os << indent << "SubtractMean: " << m_SubtractMean << std::endl;
-}
-
-} // end namespace itk
-
-
-#endif // opt
-
#endif // _clitkNormalizedCorrelationImageToImageMetric.txx
// gets integrated into the main directories.
#include "itkConfigure.h"
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "clitkOptNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.h"
-#else
-
-#include "itkImageToImageMetric.h"
-#include "itkCovariantVector.h"
-#include "itkPoint.h"
-
-
-namespace clitk
-{
-
-template < class TFixedImage, class TMovingImage >
-class ITK_EXPORT NormalizedCorrelationImageToImageMetricFor3DBLUTFFD :
- public itk::ImageToImageMetric< TFixedImage, TMovingImage>
-{
-public:
-
- /** Standard class typedefs. */
- typedef NormalizedCorrelationImageToImageMetricFor3DBLUTFFD Self;
- typedef itk::ImageToImageMetric<TFixedImage, TMovingImage > Superclass;
-
- typedef itk::SmartPointer<Self> Pointer;
- typedef itk::SmartPointer<const Self> ConstPointer;
-
- /** Method for creation through the object factory. */
- itkNewMacro(Self);
-
- /** Run-time type information (and related methods). */
- itkTypeMacro(NormalizedCorrelationImageToImageMetricFor3DBLUTFFD, itk::Object);
-
-
- /** Types transferred from the base class */
- typedef typename Superclass::RealType RealType;
- typedef typename Superclass::TransformType TransformType;
- typedef typename Superclass::TransformPointer TransformPointer;
- typedef typename Superclass::TransformParametersType TransformParametersType;
- typedef typename Superclass::TransformJacobianType TransformJacobianType;
- typedef typename Superclass::GradientPixelType GradientPixelType;
- typedef typename Superclass::OutputPointType OutputPointType;
- typedef typename Superclass::InputPointType InputPointType;
-
- typedef typename Superclass::MeasureType MeasureType;
- typedef typename Superclass::DerivativeType DerivativeType;
- typedef typename Superclass::FixedImageType FixedImageType;
- typedef typename Superclass::MovingImageType MovingImageType;
- typedef typename Superclass::FixedImageConstPointer FixedImageConstPointer;
- typedef typename Superclass::MovingImageConstPointer MovingImageConstPointer;
-
-
- /** Get the derivatives of the match measure. */
- void GetDerivative( const TransformParametersType & parameters,
- DerivativeType & Derivative ) const;
-
- /** Get the value for single valued optimizers. */
- MeasureType GetValue( const TransformParametersType & parameters ) const;
-
- /** Get value and derivatives for multiple valued optimizers. */
- void GetValueAndDerivative( const TransformParametersType & parameters,
- MeasureType& Value, DerivativeType& Derivative ) const;
-
- /** Set/Get SubtractMean boolean. If true, the sample mean is subtracted
- * from the sample values in the cross-correlation formula and
- * typically results in narrower valleys in the cost fucntion.
- * Default value is false. */
- itkSetMacro( SubtractMean, bool );
- itkGetConstReferenceMacro( SubtractMean, bool );
- itkBooleanMacro( SubtractMean );
-
-protected:
- NormalizedCorrelationImageToImageMetricFor3DBLUTFFD();
- virtual ~NormalizedCorrelationImageToImageMetricFor3DBLUTFFD() {};
- void PrintSelf(std::ostream& os, itk::Indent indent) const;
-
-private:
- NormalizedCorrelationImageToImageMetricFor3DBLUTFFD(const Self&); //purposely not implemented
- void operator=(const Self&); //purposely not implemented
-
- bool m_SubtractMean;
-
-};
-
-} // end namespace clitk
-
-#ifndef ITK_MANUAL_INSTANTIATION
-#include "clitkNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.txx"
-#endif
-
-#endif // opt
-
#endif // _clitkNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.txx
// This line can be removed once the optimized versions
// gets integrated into the main directories.
#include "itkConfigure.h"
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "clitkOptNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.txx"
-#else
-
-
-#include "clitkNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.h"
-
-#include "itkImageRegionConstIteratorWithIndex.h"
-
-
-namespace clitk
-{
-
-/*
- * Constructor
- */
-template <class TFixedImage, class TMovingImage>
-NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::NormalizedCorrelationImageToImageMetricFor3DBLUTFFD()
-{
- m_SubtractMean = false;
-}
-
-/*
- * Get the match Measure
- */
-template <class TFixedImage, class TMovingImage>
-typename NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>::MeasureType
-NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetValue( const TransformParametersType & parameters ) const
-{
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- MeasureType measure;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- measure = sfm / denom;
- } else {
- measure = itk::NumericTraits< MeasureType >::Zero;
- }
-
- return measure;
-
-}
-
-
-
-
-
-/*
- * Get the Derivative Measure
- */
-template < class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetDerivative( const TransformParametersType & parameters,
- DerivativeType & derivative ) const
-{
-
- if( !this->GetGradientImage() ) {
- itkExceptionMacro(<<"The gradient image is null, maybe you forgot to call Initialize()");
- }
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- const unsigned int dimension = FixedImageType::ImageDimension;
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- const unsigned int ParametersDimension = this->GetNumberOfParameters();
- derivative = DerivativeType( ParametersDimension );
- derivative.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeF = DerivativeType( ParametersDimension );
- derivativeF.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM = DerivativeType( ParametersDimension );
- derivativeM.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- ti.GoToBegin();
- // First compute the sums
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
- // Compute contributions to derivatives
- ti.GoToBegin();
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if ( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if ( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
-
-#if ITK_VERSION_MAJOR >= 4
- TransformJacobianType jacobian;
- this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
- // Get the gradient by NearestNeighboorInterpolation:
- // which is equivalent to round up the point components.
- typedef typename OutputPointType::CoordRepType CoordRepType;
- typedef itk::ContinuousIndex<CoordRepType,MovingImageType::ImageDimension>
- MovingImageContinuousIndexType;
-
- MovingImageContinuousIndexType tempIndex;
- this->m_MovingImage->TransformPhysicalPointToContinuousIndex( transformedPoint, tempIndex );
-
- typename MovingImageType::IndexType mappedIndex;
- mappedIndex.CopyWithRound( tempIndex );
-
- const GradientPixelType gradient =
- this->GetGradientImage()->GetPixel( mappedIndex );
-
- for(unsigned int par=0; par<ParametersDimension; par++) {
- RealType sumF = itk::NumericTraits< RealType >::Zero;
- RealType sumM = itk::NumericTraits< RealType >::Zero;
- for(unsigned int dim=0; dim<dimension; dim++) {
- const RealType differential = jacobian( dim, par ) * gradient[dim];
- sumF += fixedValue * differential;
- sumM += movingValue * differential;
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sumF -= differential * sf / this->m_NumberOfPixelsCounted;
- sumM -= differential * sm / this->m_NumberOfPixelsCounted;
- }
- }
- derivativeF[par] += sumF;
- derivativeM[par] += sumM;
- }
- }
-
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = ( derivativeF[i] - (sfm/smm)* derivativeM[i] ) / denom;
- }
- } else {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = itk::NumericTraits< MeasureType >::Zero;
- }
- }
-
-}
-
-
-/*
- * Get both the match Measure and theDerivative Measure
- */
-template <class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetValueAndDerivative(const TransformParametersType & parameters,
- MeasureType & value, DerivativeType & derivative) const
-{
-
-
- if( !this->GetGradientImage() ) {
- itkExceptionMacro(<<"The gradient image is null, maybe you forgot to call Initialize()");
- }
-
- FixedImageConstPointer fixedImage = this->m_FixedImage;
-
- if( !fixedImage ) {
- itkExceptionMacro( << "Fixed image has not been assigned" );
- }
-
- const unsigned int dimension = FixedImageType::ImageDimension;
-
- typedef itk::ImageRegionConstIteratorWithIndex<FixedImageType> FixedIteratorType;
-
- FixedIteratorType ti( fixedImage, this->GetFixedImageRegion() );
-
- typename FixedImageType::IndexType index;
-
- this->m_NumberOfPixelsCounted = 0;
-
- this->SetTransformParameters( parameters );
-
- typedef typename itk::NumericTraits< MeasureType >::AccumulateType AccumulateType;
-
- AccumulateType sff = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType smm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sfm = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sf = itk::NumericTraits< AccumulateType >::Zero;
- AccumulateType sm = itk::NumericTraits< AccumulateType >::Zero;
-
- const unsigned int ParametersDimension = this->GetNumberOfParameters();
- derivative = DerivativeType( ParametersDimension );
- derivative.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeF = DerivativeType( ParametersDimension );
- derivativeF.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM = DerivativeType( ParametersDimension );
- derivativeM.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- DerivativeType derivativeM1 = DerivativeType( ParametersDimension );
- derivativeM1.Fill( itk::NumericTraits<typename DerivativeType::ValueType>::Zero );
-
- ti.GoToBegin();
- // First compute the sums
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
- sff += fixedValue * fixedValue;
- smm += movingValue * movingValue;
- sfm += fixedValue * movingValue;
- if ( this->m_SubtractMean ) {
- sf += fixedValue;
- sm += movingValue;
- }
- this->m_NumberOfPixelsCounted++;
- }
-
- ++ti;
- }
-
-
- // Compute contributions to derivatives
- ti.GoToBegin();
- while(!ti.IsAtEnd()) {
-
- index = ti.GetIndex();
-
- InputPointType inputPoint;
- fixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- if( this->m_FixedImageMask && !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++ti;
- continue;
- }
-
- OutputPointType transformedPoint = this->m_Transform->TransformPoint( inputPoint );
-
- if( this->m_MovingImageMask && !this->m_MovingImageMask->IsInside( transformedPoint ) ) {
- ++ti;
- continue;
- }
-
- if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
- const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
- const RealType fixedValue = ti.Get();
-
-#if ITK_VERSION_MAJOR >= 4
- TransformJacobianType jacobian;
- this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
-
- // Get the gradient by NearestNeighboorInterpolation:
- // which is equivalent to round up the point components.
- typedef typename OutputPointType::CoordRepType CoordRepType;
- typedef itk::ContinuousIndex<CoordRepType,MovingImageType::ImageDimension>
- MovingImageContinuousIndexType;
-
- MovingImageContinuousIndexType tempIndex;
- this->m_MovingImage->TransformPhysicalPointToContinuousIndex( transformedPoint, tempIndex );
-
- typename MovingImageType::IndexType mappedIndex;
- mappedIndex.CopyWithRound( tempIndex );
-
- const GradientPixelType gradient =
- this->GetGradientImage()->GetPixel( mappedIndex );
-
- for(unsigned int par=0; par<ParametersDimension; par++) {
- RealType sumF = itk::NumericTraits< RealType >::Zero;
- RealType sumM = itk::NumericTraits< RealType >::Zero;
- for(unsigned int dim=0; dim<dimension; dim++) {
- const RealType differential = jacobian( dim, par ) * gradient[dim];
- sumF += fixedValue * differential;
- sumM += movingValue * differential;
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sumF -= differential * sf / this->m_NumberOfPixelsCounted;
- sumM -= differential * sm / this->m_NumberOfPixelsCounted;
- }
- }
- derivativeF[par] += sumF;
- derivativeM[par] += sumM;
- }
- }
- ++ti;
- }
-
- if ( this->m_SubtractMean && this->m_NumberOfPixelsCounted > 0 ) {
- sff -= ( sf * sf / this->m_NumberOfPixelsCounted );
- smm -= ( sm * sm / this->m_NumberOfPixelsCounted );
- sfm -= ( sf * sm / this->m_NumberOfPixelsCounted );
- }
-
- const RealType denom = -1.0 * vcl_sqrt(sff * smm );
-
- if( this->m_NumberOfPixelsCounted > 0 && denom != 0.0) {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = ( derivativeF[i] - (sfm/smm)* derivativeM[i] ) / denom;
- }
- value = sfm / denom;
- } else {
- for(unsigned int i=0; i<ParametersDimension; i++) {
- derivative[i] = itk::NumericTraits< MeasureType >::Zero;
- }
- value = itk::NumericTraits< MeasureType >::Zero;
- }
-
-
-
-}
-
-template < class TFixedImage, class TMovingImage>
-void
-NormalizedCorrelationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::PrintSelf(std::ostream& os, itk::Indent indent) const
-{
- Superclass::PrintSelf(os, indent);
- os << indent << "SubtractMean: " << m_SubtractMean << std::endl;
-}
-
-} // end namespace itk
-
-
-#endif // opt
-
#endif // _clitkNormalizedCorrelationImageToImageMetricFor3DBLUTFFD.txx
#ifndef __clitkOptNormalizedCorrelationImageToImageMetric_h
#define __clitkOptNormalizedCorrelationImageToImageMetric_h
-#if ITK_VERSION_MAJOR >= 4
- #include "itkImageToImageMetric.h"
-#else
- #include "itkOptImageToImageMetric.h"
-#endif
+#include "itkImageToImageMetric.h"
#include "itkCovariantVector.h"
#include "itkPoint.h"
#include "itkIndex.h"
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
}
// Jacobian should be evaluated at the unmapped (fixed image) point.
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
transform->ComputeJacobianWithRespectToParameters(fixedImagePoint, jacobian);
-#else
- const TransformJacobianType & jacobian = transform
- ->GetJacobian( fixedImagePoint );
-#endif
for(unsigned int par=0; par<this->m_NumberOfParameters; par++) {
RealType sumF = itk::NumericTraits< RealType >::Zero;
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
//We need the sums and the value to be calculated first
value=this->ComputeSums(parameters);
#ifndef __clitkOptNormalizedCorrelationImageToImageMetricFor3DBLUTFFD_h
#define __clitkOptNormalizedCorrelationImageToImageMetricFor3DBLUTFFD_h
-#if ITK_VERSION_MAJOR >= 4
- #include "itkImageToImageMetric.h"
-#else
- #include "itkOptImageToImageMetric.h"
-#endif
+#include "itkImageToImageMetric.h"
#include "itkCovariantVector.h"
#include "itkPoint.h"
#include "itkIndex.h"
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
}
// Jacobian should be evaluated at the unmapped (fixed image) point.
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
transform->ComputeJacobianWithRespectToParameters( fixedImagePoint, jacobian );
-#else
- const TransformJacobianType & jacobian = transform->GetJacobian( fixedImagePoint );
-#endif
// for(unsigned int par=0; par<this->m_NumberOfParameters; par++)
// {
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
//We need the sums and the value to be calculated first
value=this->ComputeSums(parameters);
return OutputCovariantVectorType();
}
-#if ITK_VERSION_MAJOR >= 4
virtual void ComputeJacobianWithRespectToParameters (const InputPointType &p, JacobianType &jacobian) const
{
itkExceptionMacro( << "PointListTransform doesn't declare ComputeJacobianWithRespectToParameters" );
{
itkExceptionMacro( << "PointListTransform doesn't declare ComputeJacobianWithRespectToPosition" );
}
-#else
- virtual const JacobianType& GetJacobian(const InputPointType &point ) const
- {
- itkExceptionMacro( << "PointListTransform doesn't declare GetJacobian" );
- return this->m_Jacobian;
- }
-#endif
protected:
PointListTransform();
// Constructor
template<class TScalarType, unsigned int NDimensions, unsigned int NOutputDimensions>
- PointListTransform<TScalarType, NDimensions, NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
- ::PointListTransform():Superclass(1)
-#else
- ::PointListTransform():Superclass(NOutputDimensions,1)
-#endif
+ PointListTransform<TScalarType, NDimensions, NOutputDimensions>::PointListTransform():Superclass(1)
{
m_PointLists.resize(0);
m_PointList.resize(1);
/** Standard parameters container. */
typedef typename Superclass::ParametersType ParametersType;
-#if ITK_VERSION_MAJOR >= 4
typedef typename Superclass::NumberOfParametersType NumberOfParametersType;
-#endif
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
}
/** Compute the Jacobian Matrix of the transformation at one point */
-#if ITK_VERSION_MAJOR >= 4
virtual void ComputeJacobianWithRespectToParameters (const InputPointType &p, JacobianType &jacobian) const;
virtual void ComputeJacobianWithRespectToPosition (const InputPointType &p, JacobianType &jacobian) const
{
itkExceptionMacro( "ComputeJacobianWithRespectToPosition not yet implemented for " << this->GetNameOfClass() );
}
-#else
- virtual const JacobianType& GetJacobian(const InputPointType &point ) const;
-#endif
/** Return the number of parameters that completely define the Transfom */
-#if ITK_VERSION_MAJOR >= 4
virtual NumberOfParametersType GetNumberOfParameters(void) const;
-#else
- virtual unsigned int GetNumberOfParameters(void) const;
-#endif
//JV Return the padded number of parameters
virtual unsigned int GetPaddedNumberOfParameters(void) const;
// JV Shape
unsigned int m_TransformShape;
-#if ITK_VERSION_MAJOR >= 4
mutable JacobianType m_SharedDataBSplineJacobian;
-#endif
}; //class ShapedBLUTSpatioTemporalDeformableTransform
// Constructor with default arguments
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
- ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
- ::ShapedBLUTSpatioTemporalDeformableTransform():Superclass(0)
-#else
- ::ShapedBLUTSpatioTemporalDeformableTransform():Superclass(OutputDimension,0)
-#endif
+ ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::ShapedBLUTSpatioTemporalDeformableTransform():Superclass(0)
{
unsigned int i;
// Get the number of parameters
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
typename ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>::NumberOfParametersType
-#else
- unsigned int
-#endif
ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
::GetNumberOfParameters(void) const
{
//=====================================
//JV Wrap jacobian into OutputDimension X Vectorial images
//=====================================
-#if ITK_VERSION_MAJOR >= 4
this->m_SharedDataBSplineJacobian.set_size( OutputDimension, this->GetNumberOfParameters() );
-#else
- this->m_Jacobian.set_size( OutputDimension, this->GetNumberOfParameters() );
-#endif
// Use memset to set the memory
// JV four rows of three comps of parameters
-#if ITK_VERSION_MAJOR >= 4
JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_SharedDataBSplineJacobian.data_block());
-#else
- JacobianPixelType * jacobianDataPointer = reinterpret_cast<JacobianPixelType *>(this->m_Jacobian.data_block());
-#endif
memset(jacobianDataPointer, 0, OutputDimension*numberOfPixels*sizeof(JacobianPixelType));
for (unsigned int j=0; j<OutputDimension; j++)
// JV weights are identical as for transformpoint, could be done simultaneously in metric!!!!
// Compute the Jacobian in one position
template<class TCoordRep, unsigned int NInputDimensions, unsigned int NOutputDimensions>
-#if ITK_VERSION_MAJOR >= 4
void
ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
::ComputeJacobianWithRespectToParameters( const InputPointType & point, JacobianType & jacobian) const
-#else
- const
- typename ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
- ::JacobianType &
- ShapedBLUTSpatioTemporalDeformableTransform<TCoordRep, NInputDimensions, NOutputDimensions>
- ::GetJacobian( const InputPointType & point ) const
-#endif
{
//========================================================
if(m_Mask && !(m_Mask->IsInside(point) ) )
{
// Outside: no (deformable) displacement
-#if ITK_VERSION_MAJOR >= 4
jacobian = m_SharedDataBSplineJacobian;
return;
-#else
- return this->m_Jacobian;
-#endif
}
// Get index
// we assume zero displacement and return the input point
if ( !this->InsideValidRegion( m_Index ) )
{
-#if ITK_VERSION_MAJOR >= 4
jacobian = m_SharedDataBSplineJacobian;
return;
-#else
- return this->m_Jacobian;
-#endif
}
// Compute interpolation weights
}
// Return the result
-#if ITK_VERSION_MAJOR >= 4
jacobian = m_SharedDataBSplineJacobian;
-#else
- return this->m_Jacobian;
-#endif
}
// This line can be removed once the optimized versions
// gets integrated into the main directories.
#include "itkConfigure.h"
-
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "itkOptMattesMutualInformationImageToImageMetricFor3DBLUTFFD.h"
-#else
-
-#include "itkImageToImageMetric.h"
-#include "itkCovariantVector.h"
-#include "itkPoint.h"
-#include "itkIndex.h"
-#include "itkBSplineKernelFunction.h"
-#include "itkBSplineDerivativeKernelFunction.h"
-#include "itkCentralDifferenceImageFunction.h"
-#include "itkBSplineInterpolateImageFunction.h"
-#include "itkBSplineDeformableTransform.h"
-#include "itkArray2D.h"
-
-namespace itk
-{
-
-/** \class MattesMutualInformationImageToImageMetricFor3DBLUTFFD
- * \brief Computes the mutual information between two images to be
- * registered using the method of Mattes et al.
- *
- * MattesMutualInformationImageToImageMetricFor3DBLUTFFD computes the mutual
- * information between a fixed and moving image to be registered.
- *
- * This class is templated over the FixedImage type and the MovingImage
- * type.
- *
- * The fixed and moving images are set via methods SetFixedImage() and
- * SetMovingImage(). This metric makes use of user specified Transform and
- * Interpolator. The Transform is used to map points from the fixed image to
- * the moving image domain. The Interpolator is used to evaluate the image
- * intensity at user specified geometric points in the moving image.
- * The Transform and Interpolator are set via methods SetTransform() and
- * SetInterpolator().
- *
- * If a BSplineInterpolationFunction is used, this class obtain
- * image derivatives from the BSpline interpolator. Otherwise,
- * image derivatives are computed using central differencing.
- *
- * \warning This metric assumes that the moving image has already been
- * connected to the interpolator outside of this class.
- *
- * The method GetValue() computes of the mutual information
- * while method GetValueAndDerivative() computes
- * both the mutual information and its derivatives with respect to the
- * transform parameters.
- *
- * The calculations are based on the method of Mattes et al [1,2]
- * where the probability density distribution are estimated using
- * Parzen histograms. Since the fixed image PDF does not contribute
- * to the derivatives, it does not need to be smooth. Hence,
- * a zero order (box car) BSpline kernel is used
- * for the fixed image intensity PDF. On the other hand, to ensure
- * smoothness a third order BSpline kernel is used for the
- * moving image intensity PDF.
- *
- * On Initialize(), the FixedImage is uniformly sampled within
- * the FixedImageRegion. The number of samples used can be set
- * via SetNumberOfSpatialSamples(). Typically, the number of
- * spatial samples used should increase with the image size.
- *
- * The option UseAllPixelOn() disables the random sampling and uses
- * all the pixels of the FixedImageRegion in order to estimate the
- * joint intensity PDF.
- *
- * During each call of GetValue(), GetDerivatives(),
- * GetValueAndDerivatives(), marginal and joint intensity PDF's
- * values are estimated at discrete position or bins.
- * The number of bins used can be set via SetNumberOfHistogramBins().
- * To handle data with arbitray magnitude and dynamic range,
- * the image intensity is scale such that any contribution to the
- * histogram will fall into a valid bin.
- *
- * One the PDF's have been contructed, the mutual information
- * is obtained by doubling summing over the discrete PDF values.
- *
- *
- * Notes:
- * 1. This class returns the negative mutual information value.
- * 2. This class in not thread safe due the private data structures
- * used to the store the sampled points and the marginal and joint pdfs.
- *
- * References:
- * [1] "Nonrigid multimodality image registration"
- * D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank
- * Medical Imaging 2001: Image Processing, 2001, pp. 1609-1620.
- * [2] "PET-CT Image Registration in the Chest Using Free-form Deformations"
- * D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank
- * IEEE Transactions in Medical Imaging. Vol.22, No.1,
- January 2003. pp.120-128.
- * [3] "Optimization of Mutual Information for MultiResolution Image
- * Registration"
- * P. Thevenaz and M. Unser
- * IEEE Transactions in Image Processing, 9(12) December 2000.
- *
- * \ingroup RegistrationMetrics
- * \ingroup ThreadUnSafe
- */
-template <class TFixedImage,class TMovingImage >
-class ITK_EXPORT MattesMutualInformationImageToImageMetricFor3DBLUTFFD :
- public ImageToImageMetric< TFixedImage, TMovingImage >
-{
-public:
-
- /** Standard class typedefs. */
- typedef MattesMutualInformationImageToImageMetricFor3DBLUTFFD Self;
- typedef ImageToImageMetric< TFixedImage, TMovingImage > Superclass;
- typedef SmartPointer<Self> Pointer;
- typedef SmartPointer<const Self> ConstPointer;
-
- /** Method for creation through the object factory. */
- itkNewMacro(Self);
-
- /** Run-time type information (and related methods). */
- itkTypeMacro(MattesMutualInformationImageToImageMetricFor3DBLUTFFD, ImageToImageMetric);
-
- /** Types inherited from Superclass. */
- typedef typename Superclass::TransformType TransformType;
- typedef typename Superclass::TransformPointer TransformPointer;
- typedef typename Superclass::TransformJacobianType TransformJacobianType;
- typedef typename Superclass::InterpolatorType InterpolatorType;
- typedef typename Superclass::MeasureType MeasureType;
- typedef typename Superclass::DerivativeType DerivativeType;
- typedef typename Superclass::ParametersType ParametersType;
- typedef typename Superclass::FixedImageType FixedImageType;
- typedef typename Superclass::MovingImageType MovingImageType;
- typedef typename Superclass::FixedImageConstPointer FixedImageConstPointer;
- typedef typename Superclass::MovingImageConstPointer MovingImageCosntPointer;
- typedef typename Superclass::InputPointType InputPointType;
- typedef typename Superclass::OutputPointType OutputPointType;
-
- typedef typename Superclass::CoordinateRepresentationType
- CoordinateRepresentationType;
-
- /** Index and Point typedef support. */
- typedef typename FixedImageType::IndexType FixedImageIndexType;
- typedef typename FixedImageIndexType::IndexValueType FixedImageIndexValueType;
- typedef typename MovingImageType::IndexType MovingImageIndexType;
- typedef typename TransformType::InputPointType FixedImagePointType;
- typedef typename TransformType::OutputPointType MovingImagePointType;
-
- /** The moving image dimension. */
- itkStaticConstMacro( MovingImageDimension, unsigned int,
- MovingImageType::ImageDimension );
-
- /**
- * Initialize the Metric by
- * (1) making sure that all the components are present and plugged
- * together correctly,
- * (2) uniformly select NumberOfSpatialSamples within
- * the FixedImageRegion, and
- * (3) allocate memory for pdf data structures. */
- virtual void Initialize(void) throw ( ExceptionObject );
-
- /** Get the derivatives of the match measure. */
- void GetDerivative( const ParametersType& parameters,
- DerivativeType & Derivative ) const;
-
- /** Get the value. */
- MeasureType GetValue( const ParametersType& parameters ) const;
-
- /** Get the value and derivatives for single valued optimizers. */
- void GetValueAndDerivative( const ParametersType& parameters,
- MeasureType& Value,
- DerivativeType& Derivative ) const;
-
- /** Number of spatial samples to used to compute metric */
- itkSetClampMacro( NumberOfSpatialSamples, unsigned long,
- 1, NumericTraits<unsigned long>::max() );
- itkGetConstReferenceMacro( NumberOfSpatialSamples, unsigned long);
-
- /** Number of bins to used in the histogram. Typical value is 50. */
- itkSetClampMacro( NumberOfHistogramBins, unsigned long,
- 1, NumericTraits<unsigned long>::max() );
- itkGetConstReferenceMacro( NumberOfHistogramBins, unsigned long);
-
- /** Reinitialize the seed of the random number generator that selects the
- * sample of pixels used for estimating the image histograms and the joint
- * histogram. By nature, this metric is not deterministic, since at each run
- * it may select a different set of pixels. By initializing the random number
- * generator seed to the same value you can restore determinism. On the other
- * hand, calling the method ReinitializeSeed() without arguments will use the
- * clock from your machine in order to have a very random initialization of
- * the seed. This will indeed increase the non-deterministic behavior of the
- * metric. */
- void ReinitializeSeed();
- void ReinitializeSeed(int);
-
- /** Select whether the metric will be computed using all the pixels on the
- * fixed image region, or only using a set of randomly selected pixels. */
- itkSetMacro(UseAllPixels,bool);
- itkGetConstReferenceMacro(UseAllPixels,bool);
- itkBooleanMacro(UseAllPixels);
-
- /** This variable selects the method to be used for computing the Metric
- * derivatives with respect to the Transform parameters. Two modes of
- * computation are available. The choice between one and the other is a
- * trade-off between computation speed and memory allocations. The two modes
- * are described in detail below:
- *
- * UseExplicitPDFDerivatives = True
- * will compute the Metric derivative by first calculating the derivatives of
- * each one of the Joint PDF bins with respect to each one of the Transform
- * parameters and then accumulating these contributions in the final metric
- * derivative array by using a bin-specific weight. The memory required for
- * storing the intermediate derivatives is a 3D array of doubles with size
- * equals to the product of (number of histogram bins)^2 times number of
- * transform parameters. This method is well suited for Transform with a small
- * number of parameters.
- *
- * UseExplicitPDFDerivatives = False will compute the Metric derivative by
- * first computing the weights for each one of the Joint PDF bins and caching
- * them into an array. Then it will revisit each one of the PDF bins for
- * computing its weighted contribution to the full derivative array. In this
- * method an extra 2D array is used for storing the weights of each one of
- * the PDF bins. This is an array of doubles with size equals to (number of
- * histogram bins)^2. This method is well suited for Transforms with a large
- * number of parameters, such as, BSplineDeformableTransforms. */
- itkSetMacro(UseExplicitPDFDerivatives,bool);
- itkGetConstReferenceMacro(UseExplicitPDFDerivatives,bool);
- itkBooleanMacro(UseExplicitPDFDerivatives);
-
- /** This boolean flag is only relevant when this metric is used along
- * with a BSplineDeformableTransform. The flag enables/disables the
- * caching of values computed when a physical point is mapped through
- * the BSplineDeformableTransform. In particular it will cache the
- * values of the BSpline weights for that points, and the indexes
- * indicating what BSpline-grid nodes are relevant for that specific
- * point. This caching is made optional due to the fact that the
- * memory arrays used for the caching can reach large sizes even for
- * moderate image size problems. For example, for a 3D image of
- * 256^3, using 20% of pixels, these arrays will take about 1
- * Gigabyte of RAM for storage. The ratio of computing time between
- * using the cache or not using the cache can reach 1:5, meaning that
- * using the caching can provide a five times speed up. It is
- * therefore, interesting to enable the caching, if enough memory is
- * available for it. The caching is enabled by default, in order to
- * preserve backward compatibility with previous versions of ITK. */
- itkSetMacro(UseCachingOfBSplineWeights,bool);
- itkGetConstReferenceMacro(UseCachingOfBSplineWeights,bool);
- itkBooleanMacro(UseCachingOfBSplineWeights);
-
-protected:
-
- MattesMutualInformationImageToImageMetricFor3DBLUTFFD();
- virtual ~MattesMutualInformationImageToImageMetricFor3DBLUTFFD() {};
- void PrintSelf(std::ostream& os, Indent indent) const;
-
- /** \class FixedImageSpatialSample
- * A fixed image spatial sample consists of the fixed domain point
- * and the fixed image value at that point. */
- /// @cond
- class FixedImageSpatialSample
- {
- public:
- FixedImageSpatialSample():FixedImageValue(0.0) {
- FixedImagePointValue.Fill(0.0);
- }
- ~FixedImageSpatialSample() {};
-
- FixedImagePointType FixedImagePointValue;
- double FixedImageValue;
- unsigned int FixedImageParzenWindowIndex;
- };
- /// @endcond
-
- /** FixedImageSpatialSample typedef support. */
- typedef std::vector<FixedImageSpatialSample>
- FixedImageSpatialSampleContainer;
-
- /** Container to store a set of points and fixed image values. */
- FixedImageSpatialSampleContainer m_FixedImageSamples;
-
- /** Uniformly select a sample set from the fixed image domain. */
- virtual void SampleFixedImageDomain(
- FixedImageSpatialSampleContainer& samples);
-
- /** Gather all the pixels from the fixed image domain. */
- virtual void SampleFullFixedImageDomain(
- FixedImageSpatialSampleContainer& samples);
-
- /** Transform a point from FixedImage domain to MovingImage domain.
- * This function also checks if mapped point is within support region. */
- virtual void TransformPoint( unsigned int sampleNumber,
- const ParametersType& parameters,
- MovingImagePointType& mappedPoint,
- bool& sampleWithinSupportRegion,
- double& movingImageValue ) const;
-
-private:
-
- //purposely not implemented
- MattesMutualInformationImageToImageMetricFor3DBLUTFFD(const Self&);
- //purposely not implemented
- void operator=(const Self&);
-
-
- /** The marginal PDFs are stored as std::vector. */
- typedef float PDFValueType;
- typedef std::vector<PDFValueType> MarginalPDFType;
-
- /** The fixed image marginal PDF. */
- mutable MarginalPDFType m_FixedImageMarginalPDF;
-
- /** The moving image marginal PDF. */
- mutable MarginalPDFType m_MovingImageMarginalPDF;
-
- /** Helper array for storing the values of the JointPDF ratios. */
- typedef double PRatioType;
- typedef Array2D< PRatioType > PRatioArrayType;
- mutable PRatioArrayType m_PRatioArray;
-
- /** Helper variable for accumulating the derivative of the metric. */
- mutable DerivativeType m_MetricDerivative;
-
- /** Typedef for the joint PDF and PDF derivatives are stored as ITK Images. */
- typedef Image<PDFValueType,2> JointPDFType;
- typedef JointPDFType::IndexType JointPDFIndexType;
- typedef JointPDFType::PixelType JointPDFValueType;
- typedef JointPDFType::RegionType JointPDFRegionType;
- typedef JointPDFType::SizeType JointPDFSizeType;
- typedef Image<PDFValueType,3> JointPDFDerivativesType;
- typedef JointPDFDerivativesType::IndexType JointPDFDerivativesIndexType;
- typedef JointPDFDerivativesType::PixelType JointPDFDerivativesValueType;
- typedef JointPDFDerivativesType::RegionType JointPDFDerivativesRegionType;
- typedef JointPDFDerivativesType::SizeType JointPDFDerivativesSizeType;
-
- /** The joint PDF and PDF derivatives. */
- typename JointPDFType::Pointer m_JointPDF;
- typename JointPDFDerivativesType::Pointer m_JointPDFDerivatives;
-
- unsigned long m_NumberOfSpatialSamples;
- unsigned long m_NumberOfParameters;
-
- /** Variables to define the marginal and joint histograms. */
- unsigned long m_NumberOfHistogramBins;
- double m_MovingImageNormalizedMin;
- double m_FixedImageNormalizedMin;
- double m_MovingImageTrueMin;
- double m_MovingImageTrueMax;
- double m_FixedImageBinSize;
- double m_MovingImageBinSize;
-
- /** Typedefs for BSpline kernel and derivative functions. */
- typedef BSplineKernelFunction<3> CubicBSplineFunctionType;
- typedef BSplineDerivativeKernelFunction<3> CubicBSplineDerivativeFunctionType;
-
- /** Cubic BSpline kernel for computing Parzen histograms. */
- typename CubicBSplineFunctionType::Pointer m_CubicBSplineKernel;
- typename CubicBSplineDerivativeFunctionType::Pointer
- m_CubicBSplineDerivativeKernel;
-
- /** Precompute fixed image parzen window indices. */
- virtual void ComputeFixedImageParzenWindowIndices(
- FixedImageSpatialSampleContainer& samples );
-
- /**
- * Types and variables related to image derivative calculations.
- * If a BSplineInterpolationFunction is used, this class obtain
- * image derivatives from the BSpline interpolator. Otherwise,
- * image derivatives are computed using central differencing.
- */
- typedef CovariantVector< double,
- itkGetStaticConstMacro(MovingImageDimension) >
- ImageDerivativesType;
-
- /** Compute image derivatives at a point. */
- virtual void ComputeImageDerivatives( const MovingImagePointType& mappedPoint,
- ImageDerivativesType& gradient ) const;
-
- /** Boolean to indicate if the interpolator BSpline. */
- bool m_InterpolatorIsBSpline;
-
- /** Typedefs for using BSpline interpolator. */
- typedef
- BSplineInterpolateImageFunction<MovingImageType,
- CoordinateRepresentationType>
- BSplineInterpolatorType;
-
- /** Pointer to BSplineInterpolator. */
- typename BSplineInterpolatorType::Pointer m_BSplineInterpolator;
-
- /** Typedefs for using central difference calculator. */
- typedef CentralDifferenceImageFunction<MovingImageType,
- CoordinateRepresentationType>
- DerivativeFunctionType;
-
- /** Pointer to central difference calculator. */
- typename DerivativeFunctionType::Pointer m_DerivativeCalculator;
-
-
- /** Compute PDF derivative contribution for each parameter. */
- virtual void ComputePDFDerivatives( unsigned int sampleNumber,
- int movingImageParzenWindowIndex,
- const ImageDerivativesType&
- movingImageGradientValue,
- double cubicBSplineDerivativeValue
- ) const;
-
- /**
- * Types and variables related to BSpline deformable transforms.
- * If the transform is of type third order BSplineDeformableTransform,
- * then we can speed up the metric derivative calculation by
- * only inspecting the parameters within the support region
- * of a mapped point.
- */
-
- /** Boolean to indicate if the transform is BSpline deformable. */
- bool m_TransformIsBSpline;
-
- /** The number of BSpline parameters per image dimension. */
- long m_NumParametersPerDim;
-
- /**
- * The number of BSpline transform weights is the number of
- * of parameter in the support region (per dimension ). */
- unsigned long m_NumBSplineWeights;
-
- /** The fixed image dimension. */
- itkStaticConstMacro( FixedImageDimension, unsigned int,
- FixedImageType::ImageDimension );
-
- /**
- * Enum of the deformabtion field spline order.
- */
- enum { DeformationSplineOrder = 3 };
-
- /**
- * Typedefs for the BSplineDeformableTransform.
- */
- typedef BSplineDeformableTransform<
- CoordinateRepresentationType,
- ::itk::GetImageDimension<FixedImageType>::ImageDimension,
- DeformationSplineOrder> BSplineTransformType;
- typedef typename BSplineTransformType::WeightsType
- BSplineTransformWeightsType;
- typedef typename BSplineTransformType::ParameterIndexArrayType
- BSplineTransformIndexArrayType;
-
- /**
- * Variables used when transform is of type BSpline deformable.
- */
- typename BSplineTransformType::Pointer m_BSplineTransform;
-
- /**
- * Cache pre-transformed points, weights, indices and
- * within support region flag.
- */
- typedef typename BSplineTransformWeightsType::ValueType WeightsValueType;
- typedef Array2D<WeightsValueType> BSplineTransformWeightsArrayType;
- typedef typename BSplineTransformIndexArrayType::ValueType IndexValueType;
- typedef Array2D<IndexValueType> BSplineTransformIndicesArrayType;
- typedef std::vector<MovingImagePointType> MovingImagePointArrayType;
- typedef std::vector<bool> BooleanArrayType;
-
- BSplineTransformWeightsArrayType m_BSplineTransformWeightsArray;
- BSplineTransformIndicesArrayType m_BSplineTransformIndicesArray;
- MovingImagePointArrayType m_PreTransformPointsArray;
- BooleanArrayType m_WithinSupportRegionArray;
-
- typedef FixedArray<unsigned long,
- ::itk::GetImageDimension<FixedImageType>::ImageDimension>
- ParametersOffsetType;
- ParametersOffsetType m_ParametersOffset;
-
- bool m_UseAllPixels;
-
- virtual void PreComputeTransformValues();
-
- bool m_ReseedIterator;
- int m_RandomSeed;
-
- // Selection of explicit or implicit computation of PDF derivatives
- // with respect to Transform parameters.
- bool m_UseExplicitPDFDerivatives;
-
- // Variables needed for optionally caching values when using a BSpline transform.
- bool m_UseCachingOfBSplineWeights;
- mutable BSplineTransformWeightsType m_Weights;
- mutable BSplineTransformIndexArrayType m_Indices;
-
-};
-
-} // end namespace itk
-
-#ifndef ITK_MANUAL_INSTANTIATION
-#include "itkMattesMutualInformationImageToImageMetricFor3DBLUTFFD.txx"
-#endif
-
-#endif
-
#endif
// gets integrated into the main directories.
#include "itkConfigure.h"
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "itkOptMattesMutualInformationImageToImageMetricFor3DBLUTFFD.txx"
-#else
-
-
-#include "itkMattesMutualInformationImageToImageMetricFor3DBLUTFFD.h"
-#include "itkBSplineInterpolateImageFunction.h"
-#include "itkCovariantVector.h"
-#include "itkImageRandomConstIteratorWithIndex.h"
-#include "itkImageRegionConstIterator.h"
-#include "itkImageRegionIterator.h"
-#include "itkImageIterator.h"
-#include "vnl/vnl_math.h"
-#include "itkBSplineDeformableTransform.h"
-
-namespace itk
-{
-
-
-/**
- * Constructor
- */
-template < class TFixedImage, class TMovingImage >
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::MattesMutualInformationImageToImageMetricFor3DBLUTFFD()
-{
-
- m_NumberOfSpatialSamples = 500;
- m_NumberOfHistogramBins = 50;
-
- this->SetComputeGradient(false); // don't use the default gradient for now
-
- m_InterpolatorIsBSpline = false;
- m_TransformIsBSpline = false;
-
- // Initialize PDFs to NULL
- m_JointPDF = NULL;
- m_JointPDFDerivatives = NULL;
-
- m_UseExplicitPDFDerivatives = true;
-
- typename BSplineTransformType::Pointer transformer =
- BSplineTransformType::New();
- this->SetTransform (transformer);
-
- typename BSplineInterpolatorType::Pointer interpolator =
- BSplineInterpolatorType::New();
- this->SetInterpolator (interpolator);
-
- // Initialize memory
- m_MovingImageNormalizedMin = 0.0;
- m_FixedImageNormalizedMin = 0.0;
- m_MovingImageTrueMin = 0.0;
- m_MovingImageTrueMax = 0.0;
- m_FixedImageBinSize = 0.0;
- m_MovingImageBinSize = 0.0;
- m_CubicBSplineDerivativeKernel = NULL;
- m_BSplineInterpolator = NULL;
- m_DerivativeCalculator = NULL;
- m_NumParametersPerDim = 0;
- m_NumBSplineWeights = 0;
- m_BSplineTransform = NULL;
- m_NumberOfParameters = 0;
- m_UseAllPixels = false;
- m_ReseedIterator = false;
- m_RandomSeed = -1;
- m_UseCachingOfBSplineWeights = true;
-}
-
-
-/**
- * Print out internal information about this class
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::PrintSelf(std::ostream& os, Indent indent) const
-{
-
- Superclass::PrintSelf(os, indent);
-
- os << indent << "NumberOfSpatialSamples: ";
- os << m_NumberOfSpatialSamples << std::endl;
- os << indent << "NumberOfHistogramBins: ";
- os << m_NumberOfHistogramBins << std::endl;
- os << indent << "UseAllPixels: ";
- os << m_UseAllPixels << std::endl;
-
- // Debugging information
- os << indent << "NumberOfParameters: ";
- os << m_NumberOfParameters << std::endl;
- os << indent << "FixedImageNormalizedMin: ";
- os << m_FixedImageNormalizedMin << std::endl;
- os << indent << "MovingImageNormalizedMin: ";
- os << m_MovingImageNormalizedMin << std::endl;
- os << indent << "MovingImageTrueMin: ";
- os << m_MovingImageTrueMin << std::endl;
- os << indent << "MovingImageTrueMax: ";
- os << m_MovingImageTrueMax << std::endl;
- os << indent << "FixedImageBinSize: ";
- os << m_FixedImageBinSize << std::endl;
- os << indent << "MovingImageBinSize: ";
- os << m_MovingImageBinSize << std::endl;
- os << indent << "InterpolatorIsBSpline: ";
- os << m_InterpolatorIsBSpline << std::endl;
- os << indent << "TransformIsBSpline: ";
- os << m_TransformIsBSpline << std::endl;
- os << indent << "UseCachingOfBSplineWeights: ";
- os << m_UseCachingOfBSplineWeights << std::endl;
- os << indent << "UseExplicitPDFDerivatives: ";
- os << m_UseExplicitPDFDerivatives << std::endl;
-
-}
-
-
-/**
- * Initialize
- */
-template <class TFixedImage, class TMovingImage>
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::Initialize(void) throw ( ExceptionObject )
-{
- this->Superclass::Initialize();
-
- // Cache the number of transformation parameters
- m_NumberOfParameters = this->m_Transform->GetNumberOfParameters();
-
- /**
- * Compute the minimum and maximum for the FixedImage over
- * the FixedImageRegion.
- *
- * NB: We can't use StatisticsImageFilter to do this because
- * the filter computes the min/max for the largest possible region
- */
- double fixedImageMin = NumericTraits<double>::max();
- double fixedImageMax = NumericTraits<double>::NonpositiveMin();
-
- typedef ImageRegionConstIterator<FixedImageType> FixedIteratorType;
- FixedIteratorType fixedImageIterator(
- this->m_FixedImage, this->GetFixedImageRegion() );
-
- for ( fixedImageIterator.GoToBegin();
- !fixedImageIterator.IsAtEnd(); ++fixedImageIterator ) {
-
- double sample = static_cast<double>( fixedImageIterator.Get() );
-
- if ( sample < fixedImageMin ) {
- fixedImageMin = sample;
- }
-
- if ( sample > fixedImageMax ) {
- fixedImageMax = sample;
- }
- }
-
-
- /**
- * Compute the minimum and maximum for the entire moving image
- * in the buffer.
- */
- double movingImageMin = NumericTraits<double>::max();
- double movingImageMax = NumericTraits<double>::NonpositiveMin();
-
- typedef ImageRegionConstIterator<MovingImageType> MovingIteratorType;
- MovingIteratorType movingImageIterator(
- this->m_MovingImage, this->m_MovingImage->GetBufferedRegion() );
-
- for ( movingImageIterator.GoToBegin();
- !movingImageIterator.IsAtEnd(); ++movingImageIterator) {
- double sample = static_cast<double>( movingImageIterator.Get() );
-
- if ( sample < movingImageMin ) {
- movingImageMin = sample;
- }
-
- if ( sample > movingImageMax ) {
- movingImageMax = sample;
- }
- }
-
- m_MovingImageTrueMin = movingImageMin;
- m_MovingImageTrueMax = movingImageMax;
-
- itkDebugMacro( " FixedImageMin: " << fixedImageMin <<
- " FixedImageMax: " << fixedImageMax << std::endl );
- itkDebugMacro( " MovingImageMin: " << movingImageMin <<
- " MovingImageMax: " << movingImageMax << std::endl );
-
-
- /**
- * Compute binsize for the histograms.
- *
- * The binsize for the image intensities needs to be adjusted so that
- * we can avoid dealing with boundary conditions using the cubic
- * spline as the Parzen window. We do this by increasing the size
- * of the bins so that the joint histogram becomes "padded" at the
- * borders. Because we are changing the binsize,
- * we also need to shift the minimum by the padded amount in order to
- * avoid minimum values filling in our padded region.
- *
- * Note that there can still be non-zero bin values in the padded region,
- * it's just that these bins will never be a central bin for the Parzen
- * window.
- *
- */
- const int padding = 2; // this will pad by 2 bins
-
- m_FixedImageBinSize = ( fixedImageMax - fixedImageMin ) /
- static_cast<double>( m_NumberOfHistogramBins - 2 * padding );
- m_FixedImageNormalizedMin = fixedImageMin / m_FixedImageBinSize -
- static_cast<double>( padding );
-
- m_MovingImageBinSize = ( movingImageMax - movingImageMin ) /
- static_cast<double>( m_NumberOfHistogramBins - 2 * padding );
- m_MovingImageNormalizedMin = movingImageMin / m_MovingImageBinSize -
- static_cast<double>( padding );
-
-
- itkDebugMacro( "FixedImageNormalizedMin: " << m_FixedImageNormalizedMin );
- itkDebugMacro( "MovingImageNormalizedMin: " << m_MovingImageNormalizedMin );
- itkDebugMacro( "FixedImageBinSize: " << m_FixedImageBinSize );
- itkDebugMacro( "MovingImageBinSize; " << m_MovingImageBinSize );
-
- if( m_UseAllPixels ) {
- m_NumberOfSpatialSamples =
- this->GetFixedImageRegion().GetNumberOfPixels();
- }
-
- /**
- * Allocate memory for the fixed image sample container.
- */
- m_FixedImageSamples.resize( m_NumberOfSpatialSamples );
-
-
- /**
- * Allocate memory for the marginal PDF and initialize values
- * to zero. The marginal PDFs are stored as std::vector.
- */
- m_FixedImageMarginalPDF.resize( m_NumberOfHistogramBins, 0.0 );
- m_MovingImageMarginalPDF.resize( m_NumberOfHistogramBins, 0.0 );
-
- /**
- * Allocate memory for the joint PDF and joint PDF derivatives.
- * The joint PDF and joint PDF derivatives are store as itk::Image.
- */
- m_JointPDF = JointPDFType::New();
-
- // Instantiate a region, index, size
- JointPDFRegionType jointPDFRegion;
- JointPDFIndexType jointPDFIndex;
- JointPDFSizeType jointPDFSize;
-
- // Deallocate the memory that may have been allocated for
- // previous runs of the metric.
- this->m_JointPDFDerivatives = NULL; // by destroying the dynamic array
- this->m_PRatioArray.SetSize( 1, 1 ); // and by allocating very small the static ones
- this->m_MetricDerivative = DerivativeType( 1 );
-
- //
- // Now allocate memory according to the user-selected method.
- //
- if( this->m_UseExplicitPDFDerivatives ) {
- this->m_JointPDFDerivatives = JointPDFDerivativesType::New();
- JointPDFDerivativesRegionType jointPDFDerivativesRegion;
- JointPDFDerivativesIndexType jointPDFDerivativesIndex;
- JointPDFDerivativesSizeType jointPDFDerivativesSize;
-
- // For the derivatives of the joint PDF define a region starting from {0,0,0}
- // with size {m_NumberOfParameters,m_NumberOfHistogramBins,
- // m_NumberOfHistogramBins}. The dimension represents transform parameters,
- // fixed image parzen window index and moving image parzen window index,
- // respectively.
- jointPDFDerivativesIndex.Fill( 0 );
- jointPDFDerivativesSize[0] = m_NumberOfParameters;
- jointPDFDerivativesSize[1] = m_NumberOfHistogramBins;
- jointPDFDerivativesSize[2] = m_NumberOfHistogramBins;
-
- jointPDFDerivativesRegion.SetIndex( jointPDFDerivativesIndex );
- jointPDFDerivativesRegion.SetSize( jointPDFDerivativesSize );
-
- // Set the regions and allocate
- m_JointPDFDerivatives->SetRegions( jointPDFDerivativesRegion );
- m_JointPDFDerivatives->Allocate();
- } else {
- /** Allocate memory for helper array that will contain the pRatios
- * for each bin of the joint histogram. This is part of the effort
- * for flattening the computation of the PDF Jacobians.
- */
- this->m_PRatioArray.SetSize( this->m_NumberOfHistogramBins, this->m_NumberOfHistogramBins );
- this->m_MetricDerivative = DerivativeType( this->GetNumberOfParameters() );
- }
-
- // For the joint PDF define a region starting from {0,0}
- // with size {m_NumberOfHistogramBins, m_NumberOfHistogramBins}.
- // The dimension represents fixed image parzen window index
- // and moving image parzen window index, respectively.
- jointPDFIndex.Fill( 0 );
- jointPDFSize.Fill( m_NumberOfHistogramBins );
-
- jointPDFRegion.SetIndex( jointPDFIndex );
- jointPDFRegion.SetSize( jointPDFSize );
-
- // Set the regions and allocate
- m_JointPDF->SetRegions( jointPDFRegion );
- m_JointPDF->Allocate();
-
-
- /**
- * Setup the kernels used for the Parzen windows.
- */
- m_CubicBSplineKernel = CubicBSplineFunctionType::New();
- m_CubicBSplineDerivativeKernel = CubicBSplineDerivativeFunctionType::New();
-
-
- if( m_UseAllPixels ) {
- /**
- * Take all the pixels within the fixed image region)
- * to create the sample points list.
- */
- this->SampleFullFixedImageDomain( m_FixedImageSamples );
- } else {
- /**
- * Uniformly sample the fixed image (within the fixed image region)
- * to create the sample points list.
- */
- this->SampleFixedImageDomain( m_FixedImageSamples );
- }
-
- /**
- * Pre-compute the fixed image parzen window index for
- * each point of the fixed image sample points list.
- */
- this->ComputeFixedImageParzenWindowIndices( m_FixedImageSamples );
-
- /**
- * Check if the interpolator is of type BSplineInterpolateImageFunction.
- * If so, we can make use of its EvaluateDerivatives method.
- * Otherwise, we instantiate an external central difference
- * derivative calculator.
- *
- * TODO: Also add it the possibility of using the default gradient
- * provided by the superclass.
- *
- */
- m_InterpolatorIsBSpline = true;
-
- BSplineInterpolatorType * testPtr = dynamic_cast<BSplineInterpolatorType *>(
- this->m_Interpolator.GetPointer() );
- if ( !testPtr ) {
- m_InterpolatorIsBSpline = false;
-
- m_DerivativeCalculator = DerivativeFunctionType::New();
-
-#ifdef ITK_USE_ORIENTED_IMAGE_DIRECTION
- m_DerivativeCalculator->UseImageDirectionOn();
-#endif
-
- m_DerivativeCalculator->SetInputImage( this->m_MovingImage );
-
- m_BSplineInterpolator = NULL;
- itkDebugMacro( "Interpolator is not BSpline" );
- } else {
- m_BSplineInterpolator = testPtr;
-
-#ifdef ITK_USE_ORIENTED_IMAGE_DIRECTION
- m_BSplineInterpolator->UseImageDirectionOn();
-#endif
-
- m_DerivativeCalculator = NULL;
- itkDebugMacro( "Interpolator is BSpline" );
- }
-
- /**
- * Check if the transform is of type BSplineDeformableTransform.
- *
- * If so, several speed up features are implemented.
- * [1] Precomputing the results of bulk transform for each sample point.
- * [2] Precomputing the BSpline weights for each sample point,
- * to be used later to directly compute the deformation vector
- * [3] Precomputing the indices of the parameters within the
- * the support region of each sample point.
- */
- m_TransformIsBSpline = true;
-
- BSplineTransformType * testPtr2 = dynamic_cast<BSplineTransformType *>(
- this->m_Transform.GetPointer() );
- if( !testPtr2 ) {
- m_TransformIsBSpline = false;
- m_BSplineTransform = NULL;
- itkDebugMacro( "Transform is not BSplineDeformable" );
- } else {
- m_BSplineTransform = testPtr2;
- m_NumParametersPerDim =
- m_BSplineTransform->GetNumberOfParametersPerDimension();
- m_NumBSplineWeights = m_BSplineTransform->GetNumberOfWeights();
- itkDebugMacro( "Transform is BSplineDeformable" );
- }
-
- if( this->m_TransformIsBSpline ) {
- // First, deallocate memory that may have been used from previous run of the Metric
- this->m_BSplineTransformWeightsArray.SetSize( 1, 1 );
- this->m_BSplineTransformIndicesArray.SetSize( 1, 1 );
- this->m_PreTransformPointsArray.resize( 1 );
- this->m_WithinSupportRegionArray.resize( 1 );
- this->m_Weights.SetSize( 1 );
- this->m_Indices.SetSize( 1 );
-
-
- if( this->m_UseCachingOfBSplineWeights ) {
- m_BSplineTransformWeightsArray.SetSize(
- m_NumberOfSpatialSamples, m_NumBSplineWeights );
- m_BSplineTransformIndicesArray.SetSize(
- m_NumberOfSpatialSamples, m_NumBSplineWeights );
- m_PreTransformPointsArray.resize( m_NumberOfSpatialSamples );
- m_WithinSupportRegionArray.resize( m_NumberOfSpatialSamples );
-
- this->PreComputeTransformValues();
- } else {
- this->m_Weights.SetSize( this->m_NumBSplineWeights );
- this->m_Indices.SetSize( this->m_NumBSplineWeights );
- }
-
- for ( unsigned int j = 0; j < FixedImageDimension; j++ ) {
- m_ParametersOffset[j] = j *
- m_BSplineTransform->GetNumberOfParametersPerDimension();
- }
- }
-
-}
-
-
-/**
- * Uniformly sample the fixed image domain using a random walk
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::SampleFixedImageDomain( FixedImageSpatialSampleContainer& samples )
-{
-
- // Set up a random interator within the user specified fixed image region.
- typedef ImageRandomConstIteratorWithIndex<FixedImageType> RandomIterator;
- RandomIterator randIter( this->m_FixedImage, this->GetFixedImageRegion() );
-
- randIter.SetNumberOfSamples( m_NumberOfSpatialSamples );
- randIter.GoToBegin();
-
- typename FixedImageSpatialSampleContainer::iterator iter;
- typename FixedImageSpatialSampleContainer::const_iterator end=samples.end();
-
- if( this->m_FixedImageMask ) {
-
- InputPointType inputPoint;
-
- iter=samples.begin();
- int count = 0;
- int samples_found = 0;
- int maxcount = m_NumberOfSpatialSamples * 10;
- while( iter != end ) {
-
- if ( count > maxcount ) {
-#if 0
- itkExceptionMacro(
- "Drew too many samples from the mask (is it too small?): "
- << maxcount << std::endl );
-#else
-samples.resize(samples_found);
-// this->SetNumberOfSpatialSamples(sample_found);
-break;
-#endif
- }
- count++;
-
- // Get sampled index
- FixedImageIndexType index = randIter.GetIndex();
- // Check if the Index is inside the mask, translate index to point
- this->m_FixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- // If not inside the mask, ignore the point
- if( !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++randIter; // jump to another random position
- continue;
- }
-
- // Get sampled fixed image value
- (*iter).FixedImageValue = randIter.Get();
- // Translate index to point
- (*iter).FixedImagePointValue = inputPoint;
- samples_found++;
- // Jump to random position
- ++randIter;
- ++iter;
- }
- } else {
- for( iter=samples.begin(); iter != end; ++iter ) {
- // Get sampled index
- FixedImageIndexType index = randIter.GetIndex();
- // Get sampled fixed image value
- (*iter).FixedImageValue = randIter.Get();
- // Translate index to point
- this->m_FixedImage->TransformIndexToPhysicalPoint( index,
- (*iter).FixedImagePointValue );
- // Jump to random position
- ++randIter;
-
- }
- }
-}
-
-/**
- * Sample the fixed image domain using all pixels in the Fixed image region
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::SampleFullFixedImageDomain( FixedImageSpatialSampleContainer& samples )
-{
-
- // Set up a region interator within the user specified fixed image region.
- typedef ImageRegionConstIteratorWithIndex<FixedImageType> RegionIterator;
- RegionIterator regionIter( this->m_FixedImage, this->GetFixedImageRegion() );
-
- regionIter.GoToBegin();
-
- typename FixedImageSpatialSampleContainer::iterator iter;
- typename FixedImageSpatialSampleContainer::const_iterator end=samples.end();
-
- if( this->m_FixedImageMask ) {
- InputPointType inputPoint;
-
- iter=samples.begin();
- unsigned long nSamplesPicked = 0;
-
- while( iter != end && !regionIter.IsAtEnd() ) {
- // Get sampled index
- FixedImageIndexType index = regionIter.GetIndex();
- // Check if the Index is inside the mask, translate index to point
- this->m_FixedImage->TransformIndexToPhysicalPoint( index, inputPoint );
-
- // If not inside the mask, ignore the point
- if( !this->m_FixedImageMask->IsInside( inputPoint ) ) {
- ++regionIter; // jump to next pixel
- continue;
- }
-
- // Get sampled fixed image value
- (*iter).FixedImageValue = regionIter.Get();
- // Translate index to point
- (*iter).FixedImagePointValue = inputPoint;
-
- ++regionIter;
- ++iter;
- ++nSamplesPicked;
- }
-
- // If we picked fewer samples than the desired number,
- // resize the container
- if (nSamplesPicked != this->m_NumberOfSpatialSamples) {
- this->m_NumberOfSpatialSamples = nSamplesPicked;
- samples.resize(this->m_NumberOfSpatialSamples);
- }
- } else { // not restricting sample throwing to a mask
-
- // cannot sample more than the number of pixels in the image region
- if ( this->m_NumberOfSpatialSamples
- > this->GetFixedImageRegion().GetNumberOfPixels()) {
- this->m_NumberOfSpatialSamples
- = this->GetFixedImageRegion().GetNumberOfPixels();
- samples.resize(this->m_NumberOfSpatialSamples);
- }
-
- for( iter=samples.begin(); iter != end; ++iter ) {
- // Get sampled index
- FixedImageIndexType index = regionIter.GetIndex();
- // Get sampled fixed image value
- (*iter).FixedImageValue = regionIter.Get();
- // Translate index to point
- this->m_FixedImage->TransformIndexToPhysicalPoint( index,
- (*iter).FixedImagePointValue );
- ++regionIter;
- }
- }
-}
-
-/**
- * Uniformly sample the fixed image domain using a random walk
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::ComputeFixedImageParzenWindowIndices(
- FixedImageSpatialSampleContainer& samples )
-{
-
- typename FixedImageSpatialSampleContainer::iterator iter;
- typename FixedImageSpatialSampleContainer::const_iterator end=samples.end();
-
- for( iter=samples.begin(); iter != end; ++iter ) {
-
- // Determine parzen window arguments (see eqn 6 of Mattes paper [2]).
- double windowTerm =
- static_cast<double>( (*iter).FixedImageValue ) / m_FixedImageBinSize -
- m_FixedImageNormalizedMin;
- unsigned int pindex = static_cast<unsigned int>( vcl_floor(windowTerm ) );
-
- // Make sure the extreme values are in valid bins
- if ( pindex < 2 ) {
- pindex = 2;
- } else if ( pindex > (m_NumberOfHistogramBins - 3) ) {
- pindex = m_NumberOfHistogramBins - 3;
- }
-
- (*iter).FixedImageParzenWindowIndex = pindex;
-
- }
-
-}
-
-/**
- * Get the match Measure
- */
-template < class TFixedImage, class TMovingImage >
-typename MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::MeasureType
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetValue( const ParametersType& parameters ) const
-{
-
- // Reset marginal pdf to all zeros.
- // Assumed the size has already been set to NumberOfHistogramBins
- // in Initialize().
- for ( unsigned int j = 0; j < m_NumberOfHistogramBins; j++ ) {
- m_FixedImageMarginalPDF[j] = 0.0;
- m_MovingImageMarginalPDF[j] = 0.0;
- }
-
- // Reset the joint pdfs to zero
- m_JointPDF->FillBuffer( 0.0 );
-
- // Set up the parameters in the transform
- this->m_Transform->SetParameters( parameters );
-
-
- // Declare iterators for iteration over the sample container
- typename FixedImageSpatialSampleContainer::const_iterator fiter;
- typename FixedImageSpatialSampleContainer::const_iterator fend =
- m_FixedImageSamples.end();
-
- unsigned long nSamples=0;
- unsigned long nFixedImageSamples=0;
-
-
- for ( fiter = m_FixedImageSamples.begin(); fiter != fend; ++fiter ) {
-
- // Get moving image value
- MovingImagePointType mappedPoint;
- bool sampleOk;
- double movingImageValue;
-
- this->TransformPoint( nFixedImageSamples, parameters, mappedPoint,
- sampleOk, movingImageValue );
-
- ++nFixedImageSamples;
-
- if( sampleOk ) {
-
- ++nSamples;
-
- /**
- * Compute this sample's contribution to the marginal and
- * joint distributions.
- *
- */
-
- // Determine parzen window arguments (see eqn 6 of Mattes paper [2])
- double movingImageParzenWindowTerm =
- movingImageValue / m_MovingImageBinSize - m_MovingImageNormalizedMin;
- unsigned int movingImageParzenWindowIndex =
- static_cast<unsigned int>( vcl_floor(movingImageParzenWindowTerm ) );
-
- // Make sure the extreme values are in valid bins
- if ( movingImageParzenWindowIndex < 2 ) {
- movingImageParzenWindowIndex = 2;
- } else if ( movingImageParzenWindowIndex > (m_NumberOfHistogramBins - 3) ) {
- movingImageParzenWindowIndex = m_NumberOfHistogramBins - 3;
- }
-
-
- // Since a zero-order BSpline (box car) kernel is used for
- // the fixed image marginal pdf, we need only increment the
- // fixedImageParzenWindowIndex by value of 1.0.
- m_FixedImageMarginalPDF[(*fiter).FixedImageParzenWindowIndex] +=
- static_cast<PDFValueType>( 1 );
-
- /**
- * The region of support of the parzen window determines which bins
- * of the joint PDF are effected by the pair of image values.
- * Since we are using a cubic spline for the moving image parzen
- * window, four bins are affected. The fixed image parzen window is
- * a zero-order spline (box car) and thus effects only one bin.
- *
- * The PDF is arranged so that moving image bins corresponds to the
- * zero-th (column) dimension and the fixed image bins corresponds
- * to the first (row) dimension.
- *
- */
-
- // Pointer to affected bin to be updated
- JointPDFValueType *pdfPtr = m_JointPDF->GetBufferPointer() +
- ( (*fiter).FixedImageParzenWindowIndex
- * m_JointPDF->GetOffsetTable()[1] );
-
- // Move the pointer to the first affected bin
- int pdfMovingIndex = static_cast<int>( movingImageParzenWindowIndex ) - 1;
- pdfPtr += pdfMovingIndex;
-
- for (; pdfMovingIndex <= static_cast<int>( movingImageParzenWindowIndex )
- + 2;
- pdfMovingIndex++, pdfPtr++ ) {
-
- // Update PDF for the current intensity pair
- double movingImageParzenWindowArg =
- static_cast<double>( pdfMovingIndex ) -
- static_cast<double>( movingImageParzenWindowTerm );
-
- *(pdfPtr) += static_cast<PDFValueType>(
- m_CubicBSplineKernel->Evaluate( movingImageParzenWindowArg ) );
-
- } //end parzen windowing for loop
-
- } //end if-block check sampleOk
- } // end iterating over fixed image spatial sample container for loop
-
- itkDebugMacro( "Ratio of voxels mapping into moving image buffer: "
- << nSamples << " / " << m_NumberOfSpatialSamples
- << std::endl );
-
- if( nSamples < m_NumberOfSpatialSamples / 16 ) {
- itkExceptionMacro( "Too many samples map outside moving image buffer: "
- << nSamples << " / " << m_NumberOfSpatialSamples
- << std::endl );
- }
-
- this->m_NumberOfPixelsCounted = nSamples;
-
-
- /**
- * Normalize the PDFs, compute moving image marginal PDF
- *
- */
- typedef ImageRegionIterator<JointPDFType> JointPDFIteratorType;
- JointPDFIteratorType jointPDFIterator ( m_JointPDF,
- m_JointPDF->GetBufferedRegion() );
-
- jointPDFIterator.GoToBegin();
-
- // Compute joint PDF normalization factor
- // (to ensure joint PDF sum adds to 1.0)
- double jointPDFSum = 0.0;
-
- while( !jointPDFIterator.IsAtEnd() ) {
- jointPDFSum += jointPDFIterator.Get();
- ++jointPDFIterator;
- }
-
- if ( jointPDFSum == 0.0 ) {
- itkExceptionMacro( "Joint PDF summed to zero" );
- }
-
-
- // Normalize the PDF bins
- jointPDFIterator.GoToEnd();
- while( !jointPDFIterator.IsAtBegin() ) {
- --jointPDFIterator;
- jointPDFIterator.Value() /= static_cast<PDFValueType>( jointPDFSum );
- }
-
-
- // Normalize the fixed image marginal PDF
- double fixedPDFSum = 0.0;
- for( unsigned int bin = 0; bin < m_NumberOfHistogramBins; bin++ ) {
- fixedPDFSum += m_FixedImageMarginalPDF[bin];
- }
-
- if ( fixedPDFSum == 0.0 ) {
- itkExceptionMacro( "Fixed image marginal PDF summed to zero" );
- }
-
- for( unsigned int bin=0; bin < m_NumberOfHistogramBins; bin++ ) {
- m_FixedImageMarginalPDF[bin] /= static_cast<PDFValueType>( fixedPDFSum );
- }
-
-
- // Compute moving image marginal PDF by summing over fixed image bins.
- typedef ImageLinearIteratorWithIndex<JointPDFType> JointPDFLinearIterator;
- JointPDFLinearIterator linearIter( m_JointPDF,
- m_JointPDF->GetBufferedRegion() );
-
- linearIter.SetDirection( 1 );
- linearIter.GoToBegin();
- unsigned int movingIndex1 = 0;
-
- while( !linearIter.IsAtEnd() ) {
-
- double sum = 0.0;
-
- while( !linearIter.IsAtEndOfLine() ) {
- sum += linearIter.Get();
- ++linearIter;
- }
-
- m_MovingImageMarginalPDF[movingIndex1] = static_cast<PDFValueType>(sum);
-
- linearIter.NextLine();
- ++movingIndex1;
-
- }
-
- /**
- * Compute the metric by double summation over histogram.
- */
-
- // Setup pointer to point to the first bin
- JointPDFValueType * jointPDFPtr = m_JointPDF->GetBufferPointer();
-
- // Initialze sum to zero
- double sum = 0.0;
-
- for( unsigned int fixedIndex = 0;
- fixedIndex < m_NumberOfHistogramBins;
- ++fixedIndex ) {
-
- double fixedImagePDFValue = m_FixedImageMarginalPDF[fixedIndex];
-
- for( unsigned int movingIndex = 0;
- movingIndex < m_NumberOfHistogramBins;
- ++movingIndex, jointPDFPtr++ ) {
-
- double movingImagePDFValue = m_MovingImageMarginalPDF[movingIndex];
- double jointPDFValue = *(jointPDFPtr);
-
- // check for non-zero bin contribution
- if( jointPDFValue > 1e-16 && movingImagePDFValue > 1e-16 ) {
-
- double pRatio = vcl_log(jointPDFValue / movingImagePDFValue );
- if( fixedImagePDFValue > 1e-16) {
- sum += jointPDFValue * ( pRatio - vcl_log(fixedImagePDFValue ) );
- }
-
- } // end if-block to check non-zero bin contribution
- } // end for-loop over moving index
- } // end for-loop over fixed index
-
- return static_cast<MeasureType>( -1.0 * sum );
-
-}
-
-
-/**
- * Get the both Value and Derivative Measure
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetValueAndDerivative(
- const ParametersType& parameters,
- MeasureType& value,
- DerivativeType& derivative) const
-{
-
- // Set output values to zero
- value = NumericTraits< MeasureType >::Zero;
-
- if( this->m_UseExplicitPDFDerivatives ) {
- m_JointPDFDerivatives->FillBuffer( 0.0 );
- derivative = DerivativeType( this->GetNumberOfParameters() );
- derivative.Fill( NumericTraits< MeasureType >::Zero );
- } else {
- this->m_MetricDerivative.Fill( NumericTraits< MeasureType >::Zero );
- this->m_PRatioArray.Fill( 0.0 );
- }
-
- // Reset marginal pdf to all zeros.
- // Assumed the size has already been set to NumberOfHistogramBins
- // in Initialize().
- for ( unsigned int j = 0; j < m_NumberOfHistogramBins; j++ ) {
- m_FixedImageMarginalPDF[j] = 0.0;
- m_MovingImageMarginalPDF[j] = 0.0;
- }
-
- // Reset the joint pdfs to zero
- m_JointPDF->FillBuffer( 0.0 );
-
-
- // Set up the parameters in the transform
- this->m_Transform->SetParameters( parameters );
-
-
- // Declare iterators for iteration over the sample container
- typename FixedImageSpatialSampleContainer::const_iterator fiter;
- typename FixedImageSpatialSampleContainer::const_iterator fend =
- m_FixedImageSamples.end();
-
- unsigned long nSamples=0;
- unsigned long nFixedImageSamples=0;
-
- for ( fiter = m_FixedImageSamples.begin(); fiter != fend; ++fiter ) {
-
- // Get moving image value
- MovingImagePointType mappedPoint;
- bool sampleOk;
- double movingImageValue;
-
-
- this->TransformPoint( nFixedImageSamples, parameters, mappedPoint,
- sampleOk, movingImageValue );
-
- if( sampleOk ) {
- ++nSamples;
-
- // Get moving image derivative at the mapped position
- ImageDerivativesType movingImageGradientValue;
- this->ComputeImageDerivatives( mappedPoint, movingImageGradientValue );
-
-
- /**
- * Compute this sample's contribution to the marginal
- * and joint distributions.
- *
- */
-
- // Determine parzen window arguments (see eqn 6 of Mattes paper [2])
- double movingImageParzenWindowTerm =
- movingImageValue / m_MovingImageBinSize - m_MovingImageNormalizedMin;
- unsigned int movingImageParzenWindowIndex =
- static_cast<unsigned int>( vcl_floor(movingImageParzenWindowTerm ) );
-
- // Make sure the extreme values are in valid bins
- if ( movingImageParzenWindowIndex < 2 ) {
- movingImageParzenWindowIndex = 2;
- } else if ( movingImageParzenWindowIndex > (m_NumberOfHistogramBins - 3) ) {
- movingImageParzenWindowIndex = m_NumberOfHistogramBins - 3;
- }
-
-
- // Since a zero-order BSpline (box car) kernel is used for
- // the fixed image marginal pdf, we need only increment the
- // fixedImageParzenWindowIndex by value of 1.0.
- m_FixedImageMarginalPDF[(*fiter).FixedImageParzenWindowIndex] +=
- static_cast<PDFValueType>( 1 );
-
- /**
- * The region of support of the parzen window determines which bins
- * of the joint PDF are effected by the pair of image values.
- * Since we are using a cubic spline for the moving image parzen
- * window, four bins are effected. The fixed image parzen window is
- * a zero-order spline (box car) and thus effects only one bin.
- *
- * The PDF is arranged so that moving image bins corresponds to the
- * zero-th (column) dimension and the fixed image bins corresponds
- * to the first (row) dimension.
- *
- */
-
- // Pointer to affected bin to be updated
- JointPDFValueType *pdfPtr = m_JointPDF->GetBufferPointer() +
- ( (*fiter).FixedImageParzenWindowIndex * m_NumberOfHistogramBins );
-
- // Move the pointer to the fist affected bin
- int pdfMovingIndex = static_cast<int>( movingImageParzenWindowIndex ) - 1;
- pdfPtr += pdfMovingIndex;
-
- for (; pdfMovingIndex <= static_cast<int>( movingImageParzenWindowIndex )
- + 2;
- pdfMovingIndex++, pdfPtr++ ) {
- // Update PDF for the current intensity pair
- double movingImageParzenWindowArg =
- static_cast<double>( pdfMovingIndex ) -
- static_cast<double>(movingImageParzenWindowTerm);
-
- *(pdfPtr) += static_cast<PDFValueType>(
- m_CubicBSplineKernel->Evaluate( movingImageParzenWindowArg ) );
-
- if( this->m_UseExplicitPDFDerivatives ) {
- // Compute the cubicBSplineDerivative for later repeated use.
- double cubicBSplineDerivativeValue =
- m_CubicBSplineDerivativeKernel->Evaluate(
- movingImageParzenWindowArg );
-
- // Compute PDF derivative contribution.
- this->ComputePDFDerivatives( nFixedImageSamples,
- pdfMovingIndex,
- movingImageGradientValue,
- cubicBSplineDerivativeValue );
- }
-
- } //end parzen windowing for loop
-
- } //end if-block check sampleOk
-
- ++nFixedImageSamples;
-
- } // end iterating over fixed image spatial sample container for loop
-
- itkDebugMacro( "Ratio of voxels mapping into moving image buffer: "
- << nSamples << " / " << m_NumberOfSpatialSamples
- << std::endl );
-
- if( nSamples < m_NumberOfSpatialSamples / 16 ) {
- itkExceptionMacro( "Too many samples map outside moving image buffer: "
- << nSamples << " / " << m_NumberOfSpatialSamples
- << std::endl );
- }
-
- this->m_NumberOfPixelsCounted = nSamples;
-
- /**
- * Normalize the PDFs, compute moving image marginal PDF
- *
- */
- typedef ImageRegionIterator<JointPDFType> JointPDFIteratorType;
- JointPDFIteratorType jointPDFIterator ( m_JointPDF,
- m_JointPDF->GetBufferedRegion() );
-
- jointPDFIterator.GoToBegin();
-
-
- // Compute joint PDF normalization factor
- // (to ensure joint PDF sum adds to 1.0)
- double jointPDFSum = 0.0;
-
- while( !jointPDFIterator.IsAtEnd() ) {
- jointPDFSum += jointPDFIterator.Get();
- ++jointPDFIterator;
- }
-
- if ( jointPDFSum == 0.0 ) {
- itkExceptionMacro( "Joint PDF summed to zero" );
- }
-
-
- // Normalize the PDF bins
- jointPDFIterator.GoToEnd();
- while( !jointPDFIterator.IsAtBegin() ) {
- --jointPDFIterator;
- jointPDFIterator.Value() /= static_cast<PDFValueType>( jointPDFSum );
- }
-
-
- // Normalize the fixed image marginal PDF
- double fixedPDFSum = 0.0;
- for( unsigned int bin = 0; bin < m_NumberOfHistogramBins; bin++ ) {
- fixedPDFSum += m_FixedImageMarginalPDF[bin];
- }
-
- if ( fixedPDFSum == 0.0 ) {
- itkExceptionMacro( "Fixed image marginal PDF summed to zero" );
- }
-
- for( unsigned int bin=0; bin < m_NumberOfHistogramBins; bin++ ) {
- m_FixedImageMarginalPDF[bin] /= static_cast<PDFValueType>( fixedPDFSum );
- }
-
-
- // Compute moving image marginal PDF by summing over fixed image bins.
- typedef ImageLinearIteratorWithIndex<JointPDFType> JointPDFLinearIterator;
- JointPDFLinearIterator linearIter(
- m_JointPDF, m_JointPDF->GetBufferedRegion() );
-
- linearIter.SetDirection( 1 );
- linearIter.GoToBegin();
- unsigned int movingIndex1 = 0;
-
- while( !linearIter.IsAtEnd() ) {
-
- double sum = 0.0;
-
- while( !linearIter.IsAtEndOfLine() ) {
- sum += linearIter.Get();
- ++linearIter;
- }
-
- m_MovingImageMarginalPDF[movingIndex1] = static_cast<PDFValueType>(sum);
-
- linearIter.NextLine();
- ++movingIndex1;
-
- }
-
- double nFactor = 1.0 / ( m_MovingImageBinSize
- * static_cast<double>( nSamples ) );
-
- if( this->m_UseExplicitPDFDerivatives ) {
- // Normalize the joint PDF derivatives by the test image binsize and nSamples
- typedef ImageRegionIterator<JointPDFDerivativesType>
- JointPDFDerivativesIteratorType;
- JointPDFDerivativesIteratorType jointPDFDerivativesIterator (
- m_JointPDFDerivatives,
- m_JointPDFDerivatives->GetBufferedRegion()
- );
-
- jointPDFDerivativesIterator.GoToBegin();
-
- while( !jointPDFDerivativesIterator.IsAtEnd() ) {
- jointPDFDerivativesIterator.Value() *= nFactor;
- ++jointPDFDerivativesIterator;
- }
- }
-
- /**
- * Compute the metric by double summation over histogram.
- */
-
- // Setup pointer to point to the first bin
- JointPDFValueType * jointPDFPtr = m_JointPDF->GetBufferPointer();
-
- // Initialize sum to zero
- double sum = 0.0;
-
- for( unsigned int fixedIndex = 0;
- fixedIndex < m_NumberOfHistogramBins;
- ++fixedIndex ) {
- double fixedImagePDFValue = m_FixedImageMarginalPDF[fixedIndex];
-
- for( unsigned int movingIndex = 0; movingIndex < m_NumberOfHistogramBins;
- ++movingIndex, jointPDFPtr++ ) {
- double movingImagePDFValue = m_MovingImageMarginalPDF[movingIndex];
- double jointPDFValue = *(jointPDFPtr);
-
- // check for non-zero bin contribution
- if( jointPDFValue > 1e-16 && movingImagePDFValue > 1e-16 ) {
-
- double pRatio = vcl_log(jointPDFValue / movingImagePDFValue );
-
- if( fixedImagePDFValue > 1e-16) {
- sum += jointPDFValue * ( pRatio - vcl_log(fixedImagePDFValue ) );
- }
-
- if( this->m_UseExplicitPDFDerivatives ) {
- // move joint pdf derivative pointer to the right position
- JointPDFValueType * derivPtr = m_JointPDFDerivatives->GetBufferPointer()
- + ( fixedIndex * m_JointPDFDerivatives->GetOffsetTable()[2] )
- + ( movingIndex * m_JointPDFDerivatives->GetOffsetTable()[1] );
-
- for( unsigned int parameter=0; parameter < m_NumberOfParameters; ++parameter, derivPtr++ ) {
- // Ref: eqn 23 of Thevenaz & Unser paper [3]
- derivative[parameter] -= (*derivPtr) * pRatio;
- } // end for-loop over parameters
- } else {
- this->m_PRatioArray[fixedIndex][movingIndex] = pRatio * nFactor;
- }
- } // end if-block to check non-zero bin contribution
- } // end for-loop over moving index
- } // end for-loop over fixed index
-
- if( !(this->m_UseExplicitPDFDerivatives ) ) {
- // Second pass: This one is done for accumulating the contributions
- // to the derivative array.
-
- nFixedImageSamples = 0;
-
- for ( fiter = m_FixedImageSamples.begin(); fiter != fend; ++fiter ) {
-
- // Get moving image value
- MovingImagePointType mappedPoint;
- bool sampleOk;
- double movingImageValue;
-
- this->TransformPoint( nFixedImageSamples, parameters, mappedPoint,
- sampleOk, movingImageValue );
-
- if( sampleOk ) {
- // Get moving image derivative at the mapped position
- ImageDerivativesType movingImageGradientValue;
- this->ComputeImageDerivatives( mappedPoint, movingImageGradientValue );
-
-
- /**
- * Compute this sample's contribution to the marginal
- * and joint distributions.
- *
- */
-
- // Determine parzen window arguments (see eqn 6 of Mattes paper [2]).
- double movingImageParzenWindowTerm =
- movingImageValue / m_MovingImageBinSize - m_MovingImageNormalizedMin;
- unsigned int movingImageParzenWindowIndex =
- static_cast<unsigned int>( vcl_floor(movingImageParzenWindowTerm ) );
-
- // Make sure the extreme values are in valid bins
- if ( movingImageParzenWindowIndex < 2 ) {
- movingImageParzenWindowIndex = 2;
- } else if ( movingImageParzenWindowIndex > (m_NumberOfHistogramBins - 3) ) {
- movingImageParzenWindowIndex = m_NumberOfHistogramBins - 3;
- }
-
-
- // Move the pointer to the fist affected bin
- int pdfMovingIndex = static_cast<int>( movingImageParzenWindowIndex ) - 1;
-
- for (; pdfMovingIndex <= static_cast<int>( movingImageParzenWindowIndex )
- + 2;
- pdfMovingIndex++ ) {
-
- // Update PDF for the current intensity pair
- double movingImageParzenWindowArg =
- static_cast<double>( pdfMovingIndex ) -
- static_cast<double>(movingImageParzenWindowTerm);
-
- // Compute the cubicBSplineDerivative for later repeated use.
- double cubicBSplineDerivativeValue =
- m_CubicBSplineDerivativeKernel->Evaluate(
- movingImageParzenWindowArg );
-
- // Compute PDF derivative contribution.
- this->ComputePDFDerivatives( nFixedImageSamples,
- pdfMovingIndex,
- movingImageGradientValue,
- cubicBSplineDerivativeValue );
-
-
- } //end parzen windowing for loop
-
- } //end if-block check sampleOk
-
- ++nFixedImageSamples;
-
- } // end iterating over fixed image spatial sample container for loop
-
-
- derivative = this->m_MetricDerivative;
- }
-
- value = static_cast<MeasureType>( -1.0 * sum );
-}
-
-
-/**
- * Get the match measure derivative
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::GetDerivative( const ParametersType& parameters,
- DerivativeType & derivative ) const
-{
- MeasureType value;
- // call the combined version
- this->GetValueAndDerivative( parameters, value, derivative );
-}
-
-
-/**
- * Compute image derivatives using a central difference function
- * if we are not using a BSplineInterpolator, which includes
- * derivatives.
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::ComputeImageDerivatives(
- const MovingImagePointType& mappedPoint,
- ImageDerivativesType& gradient ) const
-{
-
- if( m_InterpolatorIsBSpline ) {
- // Computed moving image gradient using derivative BSpline kernel.
- gradient = m_BSplineInterpolator->EvaluateDerivative( mappedPoint );
- } else {
- // For all generic interpolator use central differencing.
- gradient = m_DerivativeCalculator->Evaluate( mappedPoint );
- }
-
-}
-
-
-/**
- * Transform a point from FixedImage domain to MovingImage domain.
- * This function also checks if mapped point is within support region.
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::TransformPoint(
- unsigned int sampleNumber,
- const ParametersType& parameters,
- MovingImagePointType& mappedPoint,
- bool& sampleOk,
- double& movingImageValue ) const
-{
-
- if ( !m_TransformIsBSpline ) {
- // Use generic transform to compute mapped position
- mappedPoint = this->m_Transform->TransformPoint(
- m_FixedImageSamples[sampleNumber].FixedImagePointValue );
-
- // Check if mapped point inside image buffer
- sampleOk = this->m_Interpolator->IsInsideBuffer( mappedPoint );
- } else {
-
- if( this->m_UseCachingOfBSplineWeights ) {
- // If the transform is BSplineDeformable, we can use the precomputed
- // weights and indices to obtained the mapped position
- //
- const WeightsValueType * weights =
- m_BSplineTransformWeightsArray[sampleNumber];
- const IndexValueType * indices =
- m_BSplineTransformIndicesArray[sampleNumber];
- mappedPoint.Fill( 0.0 );
-
- if ( m_WithinSupportRegionArray[sampleNumber] ) {
- for ( unsigned int k = 0; k < m_NumBSplineWeights; k++ ) {
- for ( unsigned int j = 0; j < FixedImageDimension; j++ ) {
- mappedPoint[j] += weights[k] *
- parameters[ indices[k] + m_ParametersOffset[j] ];
- }
- }
- }
-
- for( unsigned int j = 0; j < FixedImageDimension; j++ ) {
- mappedPoint[j] += m_PreTransformPointsArray[sampleNumber][j];
- }
-
- // Check if mapped point inside image buffer
- sampleOk = this->m_Interpolator->IsInsideBuffer( mappedPoint );
-
- // Check if mapped point is within the support region of a grid point.
- // This is neccessary for computing the metric gradient
- sampleOk = sampleOk && m_WithinSupportRegionArray[sampleNumber];
- } else {
- // If not caching values, we invoke the Transform to recompute the
- // mapping of the point.
- this->m_BSplineTransform->TransformPoint(
- this->m_FixedImageSamples[sampleNumber].FixedImagePointValue,
- mappedPoint, this->m_Weights, this->m_Indices, sampleOk);
-
- // Check if mapped point inside image buffer
- sampleOk = sampleOk && this->m_Interpolator->IsInsideBuffer( mappedPoint );
- }
-
- }
-
- // If user provided a mask over the Moving image
- if ( this->m_MovingImageMask ) {
- // Check if mapped point is within the support region of the moving image
- // mask
- sampleOk = sampleOk && this->m_MovingImageMask->IsInside( mappedPoint );
- }
-
-
- if ( sampleOk ) {
- movingImageValue = this->m_Interpolator->Evaluate( mappedPoint );
-
- if ( movingImageValue < m_MovingImageTrueMin ||
- movingImageValue > m_MovingImageTrueMax ) {
- // need to throw out this sample as it will not fall into a valid bin
- sampleOk = false;
- }
- }
-}
-
-
-/**
- * Compute PDF derivatives contribution for each parameter
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::ComputePDFDerivatives(
- unsigned int sampleNumber,
- int pdfMovingIndex,
- const ImageDerivativesType& movingImageGradientValue,
- double cubicBSplineDerivativeValue ) const
-{
-
- const int pdfFixedIndex =
- m_FixedImageSamples[sampleNumber].FixedImageParzenWindowIndex;
-
- JointPDFValueType * derivPtr = NULL;
- double precomputedWeight = 0.0;
-
- if( this->m_UseExplicitPDFDerivatives ) {
- // Update bins in the PDF derivatives for the current intensity pair
- derivPtr = m_JointPDFDerivatives->GetBufferPointer() +
- ( pdfFixedIndex * m_JointPDFDerivatives->GetOffsetTable()[2] ) +
- ( pdfMovingIndex * m_JointPDFDerivatives->GetOffsetTable()[1] );
- } else {
- // Recover the precomputed weight for this specific PDF bin
- precomputedWeight = this->m_PRatioArray[pdfFixedIndex][pdfMovingIndex];
- }
-
- if( !m_TransformIsBSpline ) {
-
- /**
- * Generic version which works for all transforms.
- */
-
- // Compute the transform Jacobian.
- typedef typename TransformType::JacobianType JacobianType;
-#if ITK_VERSION_MAJOR >= 4
- JacobianType jacobian;
- this->m_Transform->ComputeJacobianWithRespectToParameters( m_FixedImageSamples[sampleNumber].FixedImagePointValue, jacobian );
-#else
- const JacobianType & jacobian =
- this->m_Transform->GetJacobian( m_FixedImageSamples[sampleNumber].FixedImagePointValue );
-#endif
-
- for ( unsigned int mu = 0; mu < m_NumberOfParameters; mu++ ) {
- double innerProduct = 0.0;
- for ( unsigned int dim = 0; dim < FixedImageDimension; dim++ ) {
- innerProduct += jacobian[dim][mu] * movingImageGradientValue[dim];
- }
-
- const double derivativeContribution = innerProduct * cubicBSplineDerivativeValue;
-
- if( this->m_UseExplicitPDFDerivatives ) {
- *(derivPtr) -= derivativeContribution;
- ++derivPtr;
- } else {
- this->m_MetricDerivative[mu] += precomputedWeight * derivativeContribution;
- }
- }
-
- } else {
- const WeightsValueType * weights = NULL;
- const IndexValueType * indices = NULL;
-
- if( this->m_UseCachingOfBSplineWeights ) {
- /**
- * If the transform is of type BSplineDeformableTransform,
- * we can obtain a speed up by only processing the affected parameters.
- * Note that these pointers are just pointing to pre-allocated rows
- * of the caching arrays. There is therefore, no need to free this
- * memory.
- */
- weights = m_BSplineTransformWeightsArray[sampleNumber];
- indices = m_BSplineTransformIndicesArray[sampleNumber];
- } else {
-#if ITK_VERSION_MAJOR >= 4
- m_BSplineTransform->ComputeJacobianFromBSplineWeightsWithRespectToPosition(
- m_FixedImageSamples[sampleNumber].FixedImagePointValue, m_Weights, m_Indices );
-#else
- m_BSplineTransform->GetJacobian(
- m_FixedImageSamples[sampleNumber].FixedImagePointValue, m_Weights, m_Indices );
-#endif
- }
-
- for( unsigned int dim = 0; dim < FixedImageDimension; dim++ ) {
-
- double innerProduct;
- int parameterIndex;
-
- for( unsigned int mu = 0; mu < m_NumBSplineWeights; mu++ ) {
-
- /* The array weights contains the Jacobian values in a 1-D array
- * (because for each parameter the Jacobian is non-zero in only 1 of the
- * possible dimensions) which is multiplied by the moving image
- * gradient. */
- if( this->m_UseCachingOfBSplineWeights ) {
- innerProduct = movingImageGradientValue[dim] * weights[mu];
- parameterIndex = indices[mu] + m_ParametersOffset[dim];
- } else {
- innerProduct = movingImageGradientValue[dim] * this->m_Weights[mu];
- parameterIndex = this->m_Indices[mu] + this->m_ParametersOffset[dim];
- }
-
- const double derivativeContribution = innerProduct * cubicBSplineDerivativeValue;
-
- if( this->m_UseExplicitPDFDerivatives ) {
- JointPDFValueType * ptr = derivPtr + parameterIndex;
- *(ptr) -= derivativeContribution;
- } else {
- this->m_MetricDerivative[parameterIndex] += precomputedWeight * derivativeContribution;
- }
-
- } //end mu for loop
- } //end dim for loop
-
- } // end if-block transform is BSpline
-
-}
-
-
-// Method to reinitialize the seed of the random number generator
-template < class TFixedImage, class TMovingImage > void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::ReinitializeSeed()
-{
- Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed();
-}
-
-// Method to reinitialize the seed of the random number generator
-template < class TFixedImage, class TMovingImage > void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::ReinitializeSeed(int seed)
-{
- Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->SetSeed(
- seed);
-}
-
-
-/**
- * Cache pre-transformed points, weights and indices.
- * This method is only called if the flag UseCachingOfBSplineWeights is ON.
- */
-template < class TFixedImage, class TMovingImage >
-void
-MattesMutualInformationImageToImageMetricFor3DBLUTFFD<TFixedImage,TMovingImage>
-::PreComputeTransformValues()
-{
- // Create all zero dummy transform parameters
- ParametersType dummyParameters( this->m_Transform->GetNumberOfParameters() );
- dummyParameters.Fill( 0.0 );
- this->m_Transform->SetParameters( dummyParameters );
-
- // Cycle through each sampled fixed image point
- BSplineTransformWeightsType weights( m_NumBSplineWeights );
- BSplineTransformIndexArrayType indices( m_NumBSplineWeights );
- bool valid;
- MovingImagePointType mappedPoint;
-
- // Declare iterators for iteration over the sample container
- typename FixedImageSpatialSampleContainer::const_iterator fiter;
- typename FixedImageSpatialSampleContainer::const_iterator fend =
- m_FixedImageSamples.end();
- unsigned long counter = 0;
-
- for( fiter = m_FixedImageSamples.begin(); fiter != fend; ++fiter, counter++ ) {
- m_BSplineTransform->TransformPoint(
- m_FixedImageSamples[counter].FixedImagePointValue,
- mappedPoint, weights, indices, valid );
-
- for( unsigned long k = 0; k < m_NumBSplineWeights; k++ ) {
- m_BSplineTransformWeightsArray[counter][k] = weights[k];
- m_BSplineTransformIndicesArray[counter][k] = indices[k];
- }
-
- m_PreTransformPointsArray[counter] = mappedPoint;
- m_WithinSupportRegionArray[counter] = valid;
-
- }
-
-}
-
-
-} // end namespace itk
-
-
-#endif
-
#endif
// gets integrated into the main directories.
#include "itkConfigure.h"
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "itkOptMeanSquaresImageToImageMetricFor3DBLUTFFD.h"
-#else
-
-#include "itkImageToImageMetric.h"
-#include "itkCovariantVector.h"
-#include "itkPoint.h"
-
-
-namespace itk
-{
-/** \class MeanSquaresImageToImageMetricFor3DBLUTFFD
- * \brief Computes similarity between two objects to be registered
- *
- * This Class is templated over the type of the fixed and moving
- * images to be compared.
- *
- * This metric computes the sum of squared differences between pixels in
- * the moving image and pixels in the fixed image. The spatial correspondance
- * between both images is established through a Transform. Pixel values are
- * taken from the Moving image. Their positions are mapped to the Fixed image
- * and result in general in non-grid position on it. Values at these non-grid
- * position of the Fixed image are interpolated using a user-selected Interpolator.
- *
- * \ingroup RegistrationMetrics
- */
-template < class TFixedImage, class TMovingImage >
-class ITK_EXPORT MeanSquaresImageToImageMetricFor3DBLUTFFD :
- public ImageToImageMetric< TFixedImage, TMovingImage>
-{
-public:
-
- /** Standard class typedefs. */
- typedef MeanSquaresImageToImageMetricFor3DBLUTFFD Self;
- typedef ImageToImageMetric<TFixedImage, TMovingImage > Superclass;
- typedef SmartPointer<Self> Pointer;
- typedef SmartPointer<const Self> ConstPointer;
-
- /** Method for creation through the object factory. */
- itkNewMacro(Self);
-
- /** Run-time type information (and related methods). */
- itkTypeMacro(MeanSquaresImageToImageMetricFor3DBLUTFFD, ImageToImageMetric);
-
-
- /** Types transferred from the base class */
- typedef typename Superclass::RealType RealType;
- typedef typename Superclass::TransformType TransformType;
- typedef typename Superclass::TransformPointer TransformPointer;
- typedef typename Superclass::TransformParametersType TransformParametersType;
- typedef typename Superclass::TransformJacobianType TransformJacobianType;
- typedef typename Superclass::GradientPixelType GradientPixelType;
- typedef typename Superclass::GradientImageType GradientImageType;
- typedef typename Superclass::InputPointType InputPointType;
- typedef typename Superclass::OutputPointType OutputPointType;
-
- typedef typename Superclass::MeasureType MeasureType;
- typedef typename Superclass::DerivativeType DerivativeType;
- typedef typename Superclass::FixedImageType FixedImageType;
- typedef typename Superclass::MovingImageType MovingImageType;
- typedef typename Superclass::FixedImageConstPointer FixedImageConstPointer;
- typedef typename Superclass::MovingImageConstPointer MovingImageConstPointer;
-
-
- /** Get the derivatives of the match measure. */
- void GetDerivative( const TransformParametersType & parameters,
- DerivativeType & derivative ) const;
-
- /** Get the value for single valued optimizers. */
- MeasureType GetValue( const TransformParametersType & parameters ) const;
-
- /** Get value and derivatives for multiple valued optimizers. */
- void GetValueAndDerivative( const TransformParametersType & parameters,
- MeasureType& Value, DerivativeType& Derivative ) const;
-
-#ifdef ITK_USE_CONCEPT_CHECKING
- /** Begin concept checking */
- itkConceptMacro(MovingPixelTypeHasNumericTraitsCheck,
- (Concept::HasNumericTraits<typename TMovingImage::PixelType>));
- itkConceptMacro(MovingRealTypeAdditivieOperatorsCheck,
- (Concept::AdditiveOperators<
- typename NumericTraits<typename TMovingImage::PixelType>::RealType>));
- itkConceptMacro(MovingRealTypeMultiplyOperatorCheck,
- (Concept::MultiplyOperator<
- typename NumericTraits<typename TMovingImage::PixelType>::RealType>));
-
- /** End concept checking */
-#endif
-
-protected:
- MeanSquaresImageToImageMetricFor3DBLUTFFD();
- virtual ~MeanSquaresImageToImageMetricFor3DBLUTFFD() {};
-
-private:
- MeanSquaresImageToImageMetricFor3DBLUTFFD(const Self&); //purposely not implemented
- void operator=(const Self&); //purposely not implemented
-
-};
-
-} // end namespace itk
-
-#ifndef ITK_MANUAL_INSTANTIATION
-#include "itkMeanSquaresImageToImageMetricFor3DBLUTFFD.txx"
-#endif
-
-#endif
-
#endif
// gets integrated into the main directories.
#include "itkConfigure.h"
-#if defined(ITK_USE_OPTIMIZED_REGISTRATION_METHODS) || ITK_VERSION_MAJOR >= 4
#include "itkOptMeanSquaresImageToImageMetricFor3DBLUTFFD.txx"
-#else
#include "itkMeanSquaresImageToImageMetricFor3DBLUTFFD.h"
#include "itkImageRegionConstIteratorWithIndex.h"
if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
const RealType fixedValue = ti.Value();
this->m_NumberOfPixelsCounted++;
if( this->m_Interpolator->IsInsideBuffer( transformedPoint ) ) {
const RealType movingValue = this->m_Interpolator->Evaluate( transformedPoint );
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
this->m_Transform->ComputeJacobianWithRespectToParameters( inputPoint, jacobian );
-#else
- const TransformJacobianType & jacobian =
- this->m_Transform->GetJacobian( inputPoint );
-#endif
const RealType fixedValue = ti.Value();
this->m_NumberOfPixelsCounted++;
#ifndef __itkOptMattesMutualInformationImageToImageMetricFor3DBLUTFFD_h
#define __itkOptMattesMutualInformationImageToImageMetricFor3DBLUTFFD_h
-#if ITK_VERSION_MAJOR >= 4
- #include "itkImageToImageMetric.h"
-#else
- #include "itkOptImageToImageMetric.h"
-#endif
+#include "itkImageToImageMetric.h"
#include "itkCovariantVector.h"
#include "itkPoint.h"
#include "itkIndex.h"
{
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING ON SAMPLES
this->GetValueAndDerivativeMultiThreadedInitiate();
transform = this->m_Transform;
}
-#if ITK_VERSION_MAJOR >= 4
JacobianType jacobian;
transform->ComputeJacobianWithRespectToParameters(this->m_FixedImageSamples[sampleNumber].point, jacobian);
-#else
- const JacobianType& jacobian =
- transform->GetJacobian( this->m_FixedImageSamples[sampleNumber].point );
-#endif
// for ( unsigned int mu = 0; mu < this->m_NumberOfParameters; mu++ )
// {
indicesHelper = &(this->m_BSplineTransformIndices);
}
-#if ITK_VERSION_MAJOR >= 4
this->m_BSplineTransform->ComputeJacobianFromBSplineWeightsWithRespectToPosition(
this->m_FixedImageSamples[sampleNumber].point,
*weightsHelper, *indicesHelper );
-#else
- this->m_BSplineTransform->GetJacobian(
- this->m_FixedImageSamples[sampleNumber].point,
- *weightsHelper, *indicesHelper );
-#endif
}
for( unsigned int dim = 0; dim < Superclass::FixedImageDimension; dim++ ) {
#ifndef __itkOptMeanSquaresImageToImageMetricFor3DBLUTFFD_h
#define __itkOptMeanSquaresImageToImageMetricFor3DBLUTFFD_h
-#if ITK_VERSION_MAJOR >= 4
- #include "itkImageToImageMetric.h"
-#else
- #include "itkOptImageToImageMetric.h"
-#endif
+#include "itkImageToImageMetric.h"
#include "itkCovariantVector.h"
#include "itkPoint.h"
#include "itkIndex.h"
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// MUST BE CALLED TO INITIATE PROCESSING
this->GetValueMultiThreadedInitiate();
}
// Jacobian should be evaluated at the unmapped (fixed image) point.
-#if ITK_VERSION_MAJOR >= 4
TransformJacobianType jacobian;
transform->ComputeJacobianWithRespectToParameters(this->m_FixedImageSamples[fixedImageSample].point, jacobian);
-#else
- const TransformJacobianType & jacobian = transform ->GetJacobian( this->m_FixedImageSamples[fixedImageSample].point );
-#endif
//double sum;
unsigned int par, dim;
for( par=0; par<this->m_NumberOfParameters; par+=3) {
// Set up the parameters in the transform
this->m_Transform->SetParameters( parameters );
-#if ITK_VERSION_MAJOR < 4
- this->m_Parameters = parameters;
-#endif
// Reset the joint pdfs to zero
memset( m_ThreaderMSE,
//--------------------------------------------------------------------
void clitk::AnatomicalFeatureDatabase::SetPoint3D(std::string tag, PointType3D & p)
{
-#if ITK_VERSION_MAJOR > 3
std::ostringstream value;
-#else
- ::itk::OStringStream value;
-#endif
value << p[0] << " " << p[1] << " " << p[2];
m_MapOfTag[tag] = value.str();
}
opening->Update();
typename SlicerFilterType::Pointer slicer = SlicerFilterType::New();
-#if ITK_VERSION_MAJOR >= 4
slicer->SetDirectionCollapseToIdentity();
-#endif
slicer->SetInput(opening->GetOutput());
// label result
for (unsigned int j = 0; j < nlables; j++) {
shape = label_map->GetNthLabelObject(j);
if (shape->Size() > 150 && shape->Size() <= max_size) {
-#if ITK_VERSION_MAJOR < 4
- double e = 1 - 1/shape->GetBinaryElongation();
-#else
double e = 1 - 1/shape->GetElongation();
-#endif
//double area = 1 - r->Area() ;
if (e < max_elongation) {
nshapes++;
start2D[m_Directions[i]]=sliceIndex;
desiredRegion.SetIndex( start2D );
extractFilter->SetExtractionRegion( desiredRegion );
-#if ITK_VERSION_MAJOR == 4
extractFilter->SetDirectionCollapseToSubmatrix();
-#endif
extractFilter->Update( );
typename ImageSliceType::Pointer slice= extractFilter->GetOutput();
// try to guess ideal ellipse axes from the lungs' bounding box and centroid
// with some hard-coded "magic" constants...
-#if ITK_VERSION_MAJOR >= 4
typename LabelType::RegionType lung_bbox = label->GetBoundingBox();
-#else
- typename LabelType::RegionType lung_bbox = label->GetRegion();
-#endif
+
axes[0] = 0.95*lung_bbox.GetSize()[0]*spacing[0]/2;
axes[1] = 0.3*lung_bbox.GetSize()[1]*spacing[1]/2;
axes[2] = 1.25*fabs(lung_centroid[2] - center[2]);
IteratorType it(ball.GetRadius(),
input,
input->GetLargestPossibleRegion());
-#if ITK_VERSION_MAJOR < 4
- typename BallType::ConstIterator nit;
- unsigned idx = 0;
- for (nit = ball.Begin(); nit != ball.End(); ++nit, ++idx)
- {
- if (*nit)
- {
- it.ActivateOffset(it.GetOffset(idx));
- }
- else
- {
- it.DeactivateOffset(it.GetOffset(idx));
- }
- }
-#else
it.CreateActiveListFromNeighborhood(ball);
it.NeedToUseBoundaryConditionOff();
-#endif
it.SetLocation(seeds[0]);
for (typename IteratorType::ConstIterator i = it.Begin(); !i.IsAtEnd(); ++i)
WRAP_GGO(clitkBinarizeImage_GGO_C clitkBinarizeImage.ggo)
add_library(clitkBinarizeImageLib clitkBinarizeImageGenericFilter.cxx ${clitkBinarizeImage_GGO_C})
+WRAP_GGO(clitkProfileImage_GGO_C clitkProfileImage.ggo)
+add_library(clitkProfileImageLib clitkProfileImageGenericFilter.cxx ${clitkProfileImage_GGO_C})
+
WRAP_GGO(clitkImageArithm_GGO_C clitkImageArithm.ggo)
add_library(clitkImageArithmImageLib clitkImageArithmGenericFilter.cxx ${clitkImageArithm_GGO_C})
add_executable(clitkBinarizeImage clitkBinarizeImage.cxx)
target_link_libraries(clitkBinarizeImage clitkBinarizeImageLib clitkCommon)
set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkBinarizeImage)
+
+ add_executable(clitkProfileImage clitkProfileImage.cxx)
+ target_link_libraries(clitkProfileImage clitkProfileImageLib clitkCommon)
+ set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkProfileImage)
WRAP_GGO(clitkVFResample_GGO_C clitkVFResample.ggo)
add_executable(clitkVFResample clitkVFResample.cxx clitkVFResampleGenericFilter.cxx ${clitkVFResample_GGO_C})
#=========================================================
- if(ITK_VERSION_MAJOR VERSION_LESS 4)
- message("clitkDice is not compatible with ITK<4. It will not be built.")
- message("clitkDicomRTPlan2Gate is not compatible with GDCM<2 (ITK<4). It will not be built.")
- else(ITK_VERSION_MAJOR VERSION_LESS 4)
- WRAP_GGO(clitkDice_GGO_C clitkDice.ggo)
- add_executable(clitkDice clitkDice.cxx ${clitkDice_GGO_C})
- target_link_libraries(clitkDice clitkSegmentationGgoLib clitkCommon ${ITK_LIBRARIES} )
- set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkDice)
-
- WRAP_GGO(clitkDicomRTPlan2Gate_GGO_C clitkDicomRTPlan2Gate.ggo)
- add_executable(clitkDicomRTPlan2Gate clitkDicomRTPlan2Gate.cxx clitkDicomRTPlan2Gate_ggo.c)
- target_link_libraries(clitkDicomRTPlan2Gate clitkCommon)
- set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkDicomRTPlan2Gate)
- endif(ITK_VERSION_MAJOR VERSION_LESS 4)
+ WRAP_GGO(clitkDice_GGO_C clitkDice.ggo)
+ add_executable(clitkDice clitkDice.cxx ${clitkDice_GGO_C})
+ target_link_libraries(clitkDice clitkSegmentationGgoLib clitkCommon ${ITK_LIBRARIES} )
+ set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkDice)
+
+ WRAP_GGO(clitkDicomRTPlan2Gate_GGO_C clitkDicomRTPlan2Gate.ggo)
+ add_executable(clitkDicomRTPlan2Gate clitkDicomRTPlan2Gate.cxx clitkDicomRTPlan2Gate_ggo.c)
+ target_link_libraries(clitkDicomRTPlan2Gate clitkCommon)
+ set(TOOLS_INSTALL ${TOOLS_INSTALL} clitkDicomRTPlan2Gate)
#=========================================================
typename ImageType::PointType origin = output->GetOrigin();
typename ImageType::SpacingType spacing = output->GetSpacing();
if (mArgsInfo.verbose_flag) std::cout << "origin before crop " << origin << std::endl;
- for (unsigned int i = 0; i < output->GetImageDimension(); i++)
- origin[i] += index[i]*spacing[i];
+ input->TransformIndexToPhysicalPoint(index,origin);
if (mArgsInfo.verbose_flag) std::cout << "origin after crop " << origin << std::endl;
output->SetOrigin(origin);
#include "vvImageReader.h"
#include "vvImageWriter.h"
#include <gdcmFile.h>
+#include <vtkVersion.h>
#include <vtkImageChangeInformation.h>
#if GDCM_MAJOR_VERSION == 2
#include <gdcmImageHelper.h>
std::vector<int> size = image->GetSize();
origin[0] = -spacing[0]*size[0]/2.0;
origin[1] = -spacing[1]*size[1]/2.0;
+#if VTK_MAJOR_VERSION <= 5
modifier->SetInput(vtk_image);
+#else
+ modifier->SetInputData(vtk_image);
+#endif
modifier->SetOutputOrigin(origin[0], origin[1], locs[sliceIndex[0]]);
modifier->Update();
vvImage::Pointer focal_image = vvImage::New();
}
else {
labelImage=LabelImageType::New();
+ labelImage->SetDirection(input->GetDirection());
labelImage->SetRegions(input->GetLargestPossibleRegion());
labelImage->SetOrigin(input->GetOrigin());
labelImage->SetSpacing(input->GetSpacing());
std::cout<<statisticsFilter->GetMaximum(label)<<std::endl;
if (m_Verbose) std::cout<<"Sum: ";
std::cout<<statisticsFilter->GetSum(label)<<std::endl;
+ if (m_Verbose) std::cout<<"Volume (cc): ";
+ std::cout<<statisticsFilter->GetCount(label)*spacing_cc<<std::endl;
if (m_Verbose) std::cout<<"Bounding box: ";
for(unsigned int i =0; i <statisticsFilter->GetBoundingBox(label).size(); i++)
std::cout<<statisticsFilter->GetBoundingBox(label)[i]<<" ";
* @brief
*
===================================================*/
-#if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 2)
-# include "itkCompose3DVectorImageFilter.h"
-#else
# include "itkComposeImageFilter.h"
-#endif
namespace clitk
{
typedef itk::Image<itk::Vector<PixelType,3>, Dimension> OutputImageType;
// Filter
-#if ITK_VERSION_MAJOR < 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR <= 2)
- typedef itk::Compose3DVectorImageFilter<InputImageType,OutputImageType> ComposeFilterType;
-#else
typedef itk::ComposeImageFilter<InputImageType,OutputImageType> ComposeFilterType;
-#endif
typename ComposeFilterType::Pointer composeFilter=ComposeFilterType::New();
// Read the inputs
//itk include
#include "itkLightObject.h"
-#if ITK_VERSION_MAJOR >= 4
- #include "itkInverseDisplacementFieldImageFilter.h"
-#else
- #include "itkInverseDeformationFieldImageFilter.h"
-#endif
+#include "itkInverseDisplacementFieldImageFilter.h"
namespace clitk
{
case 2: {
// Create the InverseDeformationFieldFilter
-#if ITK_VERSION_MAJOR >= 4
typedef itk::InverseDisplacementFieldImageFilter<InputImageType,OutputImageType> FilterType;
-#else
- typedef itk::InverseDeformationFieldImageFilter<InputImageType,OutputImageType> FilterType;
-#endif
typename FilterType::Pointer filter =FilterType::New();
filter->SetInput(input);
filter->SetOutputOrigin(input->GetOrigin());
//itk include
#include "itkLightObject.h"
-#if ITK_VERSION_MAJOR >= 4
- #include "itkInverseDisplacementFieldImageFilter.h"
-#else
- #include "itkInverseDeformationFieldImageFilter.h"
-#endif
+#include "itkInverseDisplacementFieldImageFilter.h"
namespace clitk
{
--- /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
+===========================================================================**/
+
+// clitk
+#include "clitkProfileImage_ggo.h"
+#include "clitkProfileImageGenericFilter.h"
+
+//--------------------------------------------------------------------
+int main(int argc, char * argv[])
+{
+
+ // Init command line
+ GGO(clitkProfileImage, args_info);
+ CLITK_INIT;
+
+ // Filter
+ typedef clitk::ProfileImageGenericFilter FilterType;
+ FilterType::Pointer filter = FilterType::New();
+
+ filter->SetArgsInfo(args_info);
+
+ CLITK_TRY_CATCH_EXIT(filter->Update());
+
+ return EXIT_SUCCESS;
+} // This is the end, my friend
+//--------------------------------------------------------------------
--- /dev/null
+#File clitkProfileImage.ggo
+package "clitkProfileImage"
+version "1.0"
+purpose "Save the profile between 2 points of the input image in the output text file"
+
+option "config" - "Config file" string no
+option "verbose" v "Verbose" flag off
+option "imagetypes" - "Display allowed image types" flag off
+
+option "input" i "Input image filename" string yes
+option "output" o "Output texte filename" string yes
+option "point1" f "First point (mm)" double yes multiple(-4)
+option "point2" s "Second point (mm)" double yes multiple(-4)
+
+
+
--- /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
+===========================================================================**/
+#ifndef clitkProfileImageGenericFilter_cxx
+#define clitkProfileImageGenericFilter_cxx
+
+/* =================================================
+ * @file clitkProfileImageGenericFilter.cxx
+ * @author Thomas Baudier <thomas.baudier@creatis.insa-lyon.fr>
+ * @date 22 dec 2015
+ *
+ * @brief
+ *
+ ===================================================*/
+
+#include "clitkProfileImageGenericFilter.h"
+
+// itk include
+#include <itkLineIterator.h>
+#include <itkPoint.h>
+
+#include <clitkCommon.h>
+
+
+
+namespace clitk
+{
+
+//--------------------------------------------------------------------
+ProfileImageGenericFilter::ProfileImageGenericFilter():
+ ImageToImageGenericFilter<Self>("ProfileImage")
+{
+ InitializeImageType<2>();
+ InitializeImageType<3>();
+ InitializeImageType<4>();
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+void ProfileImageGenericFilter::InitializeImageType()
+{
+ ADD_DEFAULT_IMAGE_TYPES(Dim);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+vtkFloatArray* ProfileImageGenericFilter::GetArrayX()
+{
+ return(mArrayX);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+vtkFloatArray* ProfileImageGenericFilter::GetArrayY()
+{
+ return(mArrayY);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+vtkFloatArray* ProfileImageGenericFilter::GetCoord()
+{
+ return(mCoord);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void ProfileImageGenericFilter::SetArgsInfo(const args_info_type & a)
+{
+ mArgsInfo=a;
+ if (mArgsInfo.verbose_given)
+ SetIOVerbose(mArgsInfo.verbose_flag);
+ if (mArgsInfo.imagetypes_given && mArgsInfo.imagetypes_flag)
+ this->PrintAvailableImageTypes();
+
+ if (mArgsInfo.input_given) {
+ SetInputFilename(mArgsInfo.input_arg);
+ }
+ if (mArgsInfo.output_given) {
+ SetOutputFilename(mArgsInfo.output_arg);
+ }
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+// Update with the number of dimensions and the pixeltype
+//--------------------------------------------------------------------
+template<class InputImageType>
+void
+ProfileImageGenericFilter::UpdateWithInputImageType()
+{
+
+ // Reading input
+ typename InputImageType::Pointer input = this->template GetInput<InputImageType>(0);
+ typedef typename InputImageType::PixelType PixelType;
+ typedef typename InputImageType::IndexType IndexType;
+
+ mArrayX = vtkSmartPointer<vtkFloatArray>::New();
+ mArrayY = vtkSmartPointer<vtkFloatArray>::New();
+ mCoord = vtkSmartPointer<vtkFloatArray>::New();
+ mCoord->SetNumberOfComponents(InputImageType::ImageDimension);
+
+ /*typename InputImageType::Pointer outputImage;
+ outputImage = InputImageType::New();
+
+ outputImage->SetRegions(input->GetLargestPossibleRegion());
+ outputImage->Allocate();
+ outputImage->FillBuffer(0); */
+
+ //Iterator
+ IndexType pointBegin, pointEnd;
+
+ for (int i = 0; i < mArgsInfo.point1_given; ++i) {
+ pointBegin[i] = mArgsInfo.point1_arg[i];
+ pointEnd[i] = mArgsInfo.point2_arg[i];
+ }
+
+ itk::LineConstIterator<InputImageType> itProfile(input, pointBegin, pointEnd);
+ itProfile.GoToBegin();
+ int lineNumber(1);
+ double *tuple;
+ double distance;
+ tuple = new double[InputImageType::ImageDimension];
+ itk::Point<double, InputImageType::ImageDimension> transformedFirstPoint;
+ itk::Point<double, InputImageType::ImageDimension> transformedCurrentPoint;
+
+ input->TransformIndexToPhysicalPoint(itProfile.GetIndex(), transformedFirstPoint);
+
+ while (!itProfile.IsAtEnd())
+ {
+ // Fill in the table the intensity value
+ mArrayY->InsertNextTuple1(itProfile.Get());
+
+ for (int i=0; i<InputImageType::ImageDimension; ++i) {
+ tuple[i] = itProfile.GetIndex()[i];
+ }
+
+ input->TransformIndexToPhysicalPoint(itProfile.GetIndex(), transformedCurrentPoint);
+ distance = transformedFirstPoint.EuclideanDistanceTo(transformedCurrentPoint);
+
+ // Fill in the table the distance value
+ mArrayX->InsertNextTuple1(distance);
+
+ // Fille in the table the voxel coordinate value
+ mCoord->InsertNextTuple(tuple);
+ ++lineNumber;
+ ++itProfile;
+ }
+
+ /*
+ itk::LineIterator<InputImageType> otProfile(outputImage, pointBegin, pointEnd);
+ otProfile.GoToBegin();
+ while (!otProfile.IsAtEnd())
+ {
+ otProfile.Set(1.0);
+ ++otProfile;
+ }
+
+ this->template SetNextOutput<InputImageType>(outputImage): */
+
+ delete [] tuple;
+}
+//--------------------------------------------------------------------
+
+
+}//end clitk
+
+#endif //#define clitkProfileImageGenericFilter_cxx
--- /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
+===========================================================================**/
+
+#ifndef clitkProfileImageGenericFilter_h
+#define clitkProfileImageGenericFilter_h
+
+#include "clitkIO.h"
+#include "clitkImageToImageGenericFilter.h"
+#include "clitkProfileImage_ggo.h"
+
+#include <vtkIntArray.h>
+#include <vtkFloatArray.h>
+
+//--------------------------------------------------------------------
+namespace clitk
+{
+
+ class ITK_EXPORT ProfileImageGenericFilter:
+ public ImageToImageGenericFilter<ProfileImageGenericFilter>
+ {
+
+ public:
+ //--------------------------------------------------------------------
+ typedef ProfileImageGenericFilter Self;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+ typedef args_info_clitkProfileImage args_info_type;
+
+ //--------------------------------------------------------------------
+ // Method for creation through the object factory
+ // and Run-time type information (and related methods)
+ itkNewMacro(Self);
+ itkTypeMacro(ProfileImageGenericFilter, LightObject);
+
+ //--------------------------------------------------------------------
+ void SetArgsInfo(const args_info_type & a);
+
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
+
+ vtkFloatArray* GetArrayX();
+ vtkFloatArray* GetArrayY();
+ vtkFloatArray* GetCoord();
+
+ protected:
+ ProfileImageGenericFilter();
+ template<unsigned int Dim> void InitializeImageType();
+ args_info_type mArgsInfo;
+
+
+ vtkSmartPointer<vtkFloatArray> mArrayX;
+ vtkSmartPointer<vtkFloatArray> mArrayY;
+ vtkSmartPointer<vtkFloatArray> mCoord;
+
+
+ }; // end class
+ //--------------------------------------------------------------------
+
+} // end namespace clitk
+//--------------------------------------------------------------------
+
+#endif // #define clitkProfileImageGenericFilter_h
size[i] = mArgsInfo.size_arg[i];
filter->SetOutputSize(size);
}
- itk::ImageIOBase::Pointer header = clitk::readImageHeader(mArgsInfo.input_arg);
for(unsigned int i=0; i<dim; i++){
- origin[i] = header->GetOrigin(i);
+ origin[i] = input->GetOrigin()[i];
}
for(unsigned int i=0; i<dim; i++) {
for(unsigned int j=0;j<dim;j++) {
- direction(i,j) = header->GetDirection(i)[j];
+ direction(i,j) = input->GetDirection()[i][j];
}
}
filter->SetOutputOrigin(origin);
size[mSplitDimension]=0;
typename ImageType::RegionType extracted_region;
extracted_region.SetSize(size);
-#if ITK_VERSION_MAJOR >= 4
filter->SetDirectionCollapseToIdentity();
-#endif
filter->SetExtractionRegion(extracted_region);
filter->Update();
//----------------------------------------
// Update
//----------------------------------------
-#if ITK_VERSION_MAJOR >= 4
void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId );
-#else
- void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, int threadId );
-#endif
//----------------------------------------
// Data members
// Generate Data
//-------------------------------------------------------------------
template<class InputImageType, class OutputImageType>
- void
-#if ITK_VERSION_MAJOR >= 4
- VectorImageToImageFilter<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId)
-#else
- VectorImageToImageFilter<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, int threadId)
-#endif
+ void VectorImageToImageFilter<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, itk::ThreadIdType threadId)
{
// Iterators
typename OutputImageType::Pointer output=this->GetOutput();
//Backward mapping
typedef itk::WarpImageFilter<InputImageType, InputImageType, DeformationFieldType> BackwardWarpFilterType;
typename BackwardWarpFilterType::Pointer backwardWarpFilter= BackwardWarpFilterType::New();
-#if ITK_VERSION_MAJOR >= 4
backwardWarpFilter->SetDisplacementField( deformationField );
-#else
- backwardWarpFilter->SetDeformationField( deformationField );
-#endif
backwardWarpFilter->SetEdgePaddingValue( static_cast<PixelType>(m_ArgsInfo.pad_arg) );
backwardWarpFilter->SetOutputSpacing( deformationField->GetSpacing() );
backwardWarpFilter->SetOutputOrigin( input->GetOrigin() );
option "newSeriesUID" e "Write the series with a new series UID (ignored if given in key/tag option)" flag off
option "newStudyUID" u "Write the series with a new study UID (ignored if given in key/tag option; forces newSeriesUID = true)" flag off
option "useSizeAsReference" s "Use the size of the dicom image as reference for an occasional resampling" flag off
+option "preserve" p "Preserve private tags and keep original UID (eg: Xio)" flag off
// Read the series
typename ReaderType::Pointer reader = ReaderType::New();
+ if (m_ArgsInfo.preserve_flag) {
+#if GDCM_MAJOR_VERSION >= 2
+ gdcmIO->LoadPrivateTagsOn();
+ gdcmIO->KeepOriginalUIDOn();
+#endif
+ }
reader->SetImageIO( gdcmIO );
reader->SetFileNames( filenames_in );
try {
# To avoid warning with some version
if(COMMAND cmake_policy)
cmake_policy(SET CMP0003 NEW)
+ cmake_policy(SET CMP0007 NEW)
endif(COMMAND cmake_policy)
#=========================================================
vvToolConvert ## with dummy vvToolConvert.ui
vvToolROIManager
vvToolSegmentation
+ vvToolProfile
## these ones are for tests (not working)
+ # vvToolTest
# vvToolFoo
# vvToolFooWithWidgetBase
# vvToolPlastimatch
# Future issues : when tool depend on other tools ... how to manage that ?
# >> add the relevant $_LIBS variable to the tool that has dependencies?
set(vvToolBinarize_LIBS clitkBinarizeImageLib)
+set(vvToolProfile_LIBS clitkProfileImageLib)
set(vvToolResample_LIBS clitkResampleImageLib)
set(vvToolConvert_LIBS clitkImageConvertLib)
set(vvToolExtractPatient_LIBS clitkSegmentationGgoLib)
#=========================================================
# Qt related commands
-find_package(Qt4 REQUIRED)
-link_directories(${QT_LIBRARY_DIR})
+if(vv_QT_VERSION VERSION_GREATER "4")
+ find_package(Qt5Widgets REQUIRED)
+ find_package(Qt5Network REQUIRED)
+ find_package(Qt5Designer REQUIRED)
+else()
+ find_package(Qt4 REQUIRED)
+endif()
-QT4_WRAP_CPP(vv_SRCS
- vvMainWindowBase.h
- QTreePushButton.h
- vvDocumentation.h
- vvHelpDialog.h
- vvQDicomSeriesSelector.h
- vvSlicerManager.h
- vvStructureSetActor.h
- vvROIActor.h
- vvToolCreatorBase.h
- )
+if(vv_QT_VERSION VERSION_GREATER "4")
+ link_directories(${QT5Widgets_LIBRARIES})
+ link_directories(${QT5Network_LIBRARIES})
+ link_directories(${QT5Designer_LIBRARIES})
+else()
+ link_directories(${QT_LIBRARY_DIR})
+endif()
-QT4_WRAP_UI(vv_UI_CXX
- qt_ui/vvHelpDialog.ui
- qt_ui/vvDocumentation.ui
- qt_ui/vvDicomSeriesSelector.ui
- qt_ui/vvDummyWindow.ui #For testing
- )
+if(vv_QT_VERSION VERSION_GREATER "4")
+ qt5_wrap_cpp(vv_SRCS
+ vvMainWindowBase.h
+ QTreePushButton.h
+ vvDocumentation.h
+ vvHelpDialog.h
+ vvQDicomSeriesSelector.h
+ vvSlicerManager.h
+ vvSlicer.h
+ vvStructureSetActor.h
+ vvROIActor.h
+ vvToolCreatorBase.h
+ )
+else()
+ QT4_WRAP_CPP(vv_SRCS
+ vvMainWindowBase.h
+ QTreePushButton.h
+ vvDocumentation.h
+ vvHelpDialog.h
+ vvQDicomSeriesSelector.h
+ vvSlicerManager.h
+ vvSlicer.h
+ vvStructureSetActor.h
+ vvROIActor.h
+ vvToolCreatorBase.h
+ )
+endif()
-QT4_ADD_RESOURCES(vv_SRCS vvIcons.qrc)
+if(vv_QT_VERSION VERSION_GREATER "4")
+ qt5_wrap_ui(vv_UI_CXX
+ qt_ui/vvHelpDialog.ui
+ qt_ui/vvDocumentation.ui
+ qt_ui/vvDicomSeriesSelector.ui
+ qt_ui/vvDummyWindow.ui #For testing
+ )
+else()
+ QT4_WRAP_UI(vv_UI_CXX
+ qt_ui/vvHelpDialog.ui
+ qt_ui/vvDocumentation.ui
+ qt_ui/vvDicomSeriesSelector.ui
+ qt_ui/vvDummyWindow.ui #For testing
+ )
+endif()
-# Add the autotools in the header vvToolsList.h for initialization of the dummy
-# variables in vv.cxx for the tools contained in vvLib
-if(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
- file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
- foreach(tool ${vv_TOOLS})
- file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "#include \"${tool}.h\"\n")
- file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "extern const vvToolCreator<${tool}> *dummy${tool};\n")
- file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "const vvToolCreator<${tool}> *dummy${tool}2 = dummy${tool};\n\n")
+if(vv_QT_VERSION VERSION_GREATER "4")
+ QT5_add_resources(vv_SRCS vvIcons.qrc)
+else()
+ QT4_ADD_RESOURCES(vv_SRCS vvIcons.qrc)
+endif()
+
+ # Add the autotools in the header vvToolsList.h for initialization of the dummy
+ # variables in vv.cxx for the tools contained in vvLib
+ if(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
+ file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
+ foreach(tool ${vv_TOOLS})
+ file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "#include \"${tool}.h\"\n")
+ file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "extern const vvToolCreator<${tool}> *dummy${tool};\n")
+ file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h "const vvToolCreator<${tool}> *dummy${tool}2 = dummy${tool};\n\n")
+ endforeach(tool)
+ endif(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
+
+ # Add the autotools and the common files ui
+ foreach(tool ${vv_TOOLS} ${vv_COMMON_WITH_UI})
+ set(vv_SRCS ${vv_SRCS} ${tool}.cxx)
+ if(vv_QT_VERSION VERSION_GREATER "4")
+ QT5_WRAP_CPP(vv_SRCS ${tool}.h)
+ QT5_WRAP_UI(vv_UI_CXX qt_ui/${tool}.ui)
+ else()
+ QT4_WRAP_CPP(vv_SRCS ${tool}.h)
+ QT4_WRAP_UI(vv_UI_CXX qt_ui/${tool}.ui)
+ endif()
endforeach(tool)
-endif(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/vvToolsList.h)
-
-# Add the autotools and the common files ui
-foreach(tool ${vv_TOOLS} ${vv_COMMON_WITH_UI})
- set(vv_SRCS ${vv_SRCS} ${tool}.cxx)
- QT4_WRAP_CPP(vv_SRCS ${tool}.h)
- QT4_WRAP_UI(vv_UI_CXX qt_ui/${tool}.ui)
-endforeach(tool)
-
-# Add the common source files
-foreach(tool ${vv_COMMON})
- set(vv_SRCS ${vv_SRCS} ${tool}.cxx)
- QT4_WRAP_CPP(vv_SRCS ${tool}.h)
-endforeach(tool)
-
-# if Windows and Qt was built as a static lib then don't set QT_DLL flag
-set(QT_STATIC 0)
-if(WIN32)
- if(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
- file(READ ${QT_LIBRARY_DIR}/QtCore.prl QT_CORE_PRL)
- if(${QT_CORE_PRL} MATCHES "static")
- set(QT_STATIC 1)
- endif(${QT_CORE_PRL} MATCHES "static")
- endif(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
-endif(WIN32)
-if(NOT QT_STATIC)
- add_definitions(-DQT_DLL)
-endif(NOT QT_STATIC)
-
-add_definitions(-DQT_THREAD_SUPPORT)
+
+ # Add the common source files
+ foreach(tool ${vv_COMMON})
+ set(vv_SRCS ${vv_SRCS} ${tool}.cxx)
+ if(vv_QT_VERSION VERSION_GREATER "4")
+ QT5_WRAP_CPP(vv_SRCS ${tool}.h)
+ else()
+ QT4_WRAP_CPP(vv_SRCS ${tool}.h)
+ endif()
+ endforeach(tool)
+
+ # if Windows and Qt was built as a static lib then don't set QT_DLL flag
+ set(QT_STATIC 0)
+ if(WIN32)
+ if(vv_QT_VERSION VERSION_GREATER "4")
+ if(EXISTS ${Qt5Widgets_LIBRARIES}/QtCore.prl)
+ file(READ ${Qt5Widgets_LIBRARIES}/QtCore.prl QT_CORE_PRL)
+ if(${QT_CORE_PRL} MATCHES "static")
+ set(QT_STATIC 1)
+ endif(${QT_CORE_PRL} MATCHES "static")
+ endif(EXISTS ${Qt5Widgets_LIBRARIES}/QtCore.prl)
+ else()
+ if(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
+ file(READ ${QT_LIBRARY_DIR}/QtCore.prl QT_CORE_PRL)
+ if(${QT_CORE_PRL} MATCHES "static")
+ set(QT_STATIC 1)
+ endif(${QT_CORE_PRL} MATCHES "static")
+ endif(EXISTS ${QT_LIBRARY_DIR}/QtCore.prl)
+ endif()
+ endif(WIN32)
+ if(NOT QT_STATIC)
+ add_definitions(-DQT_DLL)
+ endif(NOT QT_STATIC)
-include_directories(
- ${QT_INCLUDES}
- ${QT_INCLUDE_DIR}
- ${QT_QTGUI_INCLUDE_DIR}
- ${QT_QTCORE_INCLUDE_DIR}
- ${CMAKE_CURRENT_BINARY_DIR}
- ${CMAKE_CURRENT_SOURCE_DIR}
-)
+ add_definitions(-DQT_THREAD_SUPPORT)
+ if(vv_QT_VERSION VERSION_GREATER "4")
+ include_directories(
+ ${Qt5Widgets_INCLUDE_DIRS}
+ ${Qt5Gui_INCLUDE_DIRS}
+ ${Qt5Core_INCLUDE_DIRS}
+ ${Qt5Network_INCLUDE_DIRS}
+ ${Qt5Designer_INCLUDE_DIRS}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+ else()
+ include_directories(
+ ${QT_INCLUDES}
+ ${QT_INCLUDE_DIR}
+ ${QT_QTGUI_INCLUDE_DIR}
+ ${QT_QTCORE_INCLUDE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+ endif()
#=========================================================
#=========================================================
#=========================================================
#Add Foundation Libraries (this should be after our libraries, since we depend
#on them)
+if(vv_QT_VERSION VERSION_GREATER "4")
+set(foundationLibraries clitkCommon ${ITK_LIBRARIES} ${VTK_LIBRARIES})
+else()
set(foundationLibraries clitkCommon ${ITK_LIBRARIES} QVTK vtkHybrid)
+endif()
#=========================================================
# Use CxImage to create animated gifs
endif()
#=========================================================
#Create binary and libs for tests
+if(vv_QT_VERSION VERSION_GREATER "4")
+set(vvExternalLibs clitkSegmentationGgoLib ${toolLibs} ${foundationLibraries} ${vvCxImage} Qt5::Widgets Qt5::Network Qt5::Designer ${APPLE_FRAMEWORKS})
+else()
set(vvExternalLibs clitkSegmentationGgoLib ${toolLibs} ${foundationLibraries} ${vvCxImage} ${QT_LIBRARIES} ${QT_QTNETWORK_LIBRARY} ${APPLE_FRAMEWORKS})
+endif()
# QtNetwork is required by vvRegisterForm
+#-----------------------------------------------------------------------------
+# For retina displays, see
+# http://public.kitware.com/pipermail/vtkusers/2015-February/090117.html
+if(APPLE)
+ set(vv_SRCS ${vv_SRCS} vvOSXHelper.mm)
+endif()
+
add_library(vvLib ${vv_SRCS} ${vv_UI_CXX})
target_link_libraries(vvLib ${vvExternalLibs})
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
- <item row="0" column="0" colspan="2">
+ <item row="0" column="0" colspan="-1">
<widget class="QLabel" name="nameLabel">
<property name="text">
<string><html><head><meta name="qrichtext" content="1" /><style type="text/css">
<x>0</x>
<y>0</y>
<width>1008</width>
- <height>20</height>
+ <height>27</height>
</rect>
</property>
<property name="defaultUp">
<property name="text">
<string>Open image(s)</string>
</property>
+ <property name="shortcut">
+ <string>Ctrl+O</string>
+ </property>
<property name="iconVisibleInMenu">
<bool>true</bool>
</property>
<property name="text">
<string>Navigation Help</string>
</property>
- <property name="shortcut">
- <string>F1</string>
- </property>
<property name="iconVisibleInMenu">
<bool>true</bool>
</property>
+ <property name="priority">
+ <enum>QAction::NormalPriority</enum>
+ </property>
</action>
<action name="actionOpen_Dicom_Struct">
<property name="icon">
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>vvToolProfile</class>
+ <widget class="QWidget" name="vvToolProfile">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>505</width>
+ <height>452</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Profile image</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <item>
+ <layout class="QGridLayout" name="gridLayout_2">
+ <property name="horizontalSpacing">
+ <number>6</number>
+ </property>
+ <item row="2" column="1">
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <item>
+ <widget class="QPushButton" name="mSelectPoint2Button">
+ <property name="text">
+ <string>Select point 2</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="Point2">
+ <property name="text">
+ <string>Center of voxel2 (vox):</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item row="2" column="3">
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <item>
+ <widget class="QLabel" name="mPosPoint2Label">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>200</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="text">
+ <string/>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item row="3" column="3">
+ <layout class="QHBoxLayout" name="horizontalLayout_6">
+ <item>
+ <widget class="QToolButton" name="mCancelPointsButton">
+ <property name="text">
+ <string>Cancel</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="mSaveProfileButton">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>Save Profile</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item row="1" column="1">
+ <layout class="QHBoxLayout" name="horizontalLayout_7">
+ <item>
+ <widget class="QPushButton" name="mSelectPoint1Button">
+ <property name="text">
+ <string>Select point 1</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="Point1">
+ <property name="text">
+ <string>Center of voxel1 (vox):</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item row="1" column="3">
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <widget class="QLabel" name="mPosPoint1Label">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>200</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="text">
+ <string/>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <item>
+ <widget class="Line" name="line_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QVTKWidget" name="ProfileWidget" native="true">
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>300</height>
+ </size>
+ </property>
+ <property name="mouseTracking">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </widget>
+ <customwidgets>
+ <customwidget>
+ <class>QVTKWidget</class>
+ <extends>QWidget</extends>
+ <header>QVTKWidget.h</header>
+ </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
</sizepolicy>
</property>
<property name="text">
- <string> </string>
+ <string/>
</property>
</widget>
</item>
</property>
</spacer>
</item>
+ <item>
+ <widget class="QPushButton" name="mRemoveButton">
+ <property name="text">
+ <string>1</string>
+ </property>
+ <property name="icon">
+ <iconset resource="../vvIcons.qrc">
+ <normaloff>:/common/icons/standardbutton-cancel-16.png</normaloff>:/common/icons/standardbutton-cancel-16.png</iconset>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QLabel" name="mROInameLabel_3">
<property name="sizePolicy">
<bool>false</bool>
</property>
<property name="text">
- <string/>
+ <string>All</string>
</property>
<property name="icon">
<iconset resource="../vvIcons.qrc">
- <normaloff>:/common/icons/exit.png</normaloff>:/common/icons/exit.png</iconset>
+ <normaloff>:/common/icons/standardbutton-cancel-16.png</normaloff>:/common/icons/standardbutton-cancel-16.png</iconset>
</property>
</widget>
</item>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>vvToolTest</class>
+ <widget class="QWidget" name="vvToolTest">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>433</width>
+ <height>222</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Test sphere</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="Line" name="line_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
<rect>
<x>0</x>
<y>0</y>
- <width>179</width>
+ <width>194</width>
<height>62</height>
</rect>
</property>
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
- <widget class="vvToolInputSelectorWidget" name="mToolInputSelectionWidget" native="true"/>
+ <widget class="vvToolInputSelectorWidget" name="mToolInputSelectionWidget" native="true">
+ <property name="maximumSize">
+ <size>
+ <width>16777215</width>
+ <height>200</height>
+ </size>
+ </property>
+ </widget>
<widget class="QWidget" name="mToolWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
#include "vtkObjectFactory.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "vtkDataSetAttributes.h"
-
-#include <vtkstd/string>
+#include <vtkVersion.h>
+#include <vtkAlgorithm.h>
#include <sys/stat.h>
//----------------------------------------------------------------------------
-vtkCxxRevisionMacro(vtkVOXImageWriter, "DummyRevision");
vtkStandardNewMacro(vtkVOXImageWriter);
//----------------------------------------------------------------------------
void vtkVOXImageWriter::Write( )
{
this->SetErrorCode(vtkErrorCode::NoError);
-
+#if VTK_MAJOR_VERSION <= 5
this->GetInput()->UpdateInformation();
-
+#else
+ this->UpdateInformation();
+#endif
// Error checking
if (this->GetInput() == NULL ) {
vtkErrorMacro(<<"Write:Please specify an input!");
}
int nDims = 3;
+#if VTK_MAJOR_VERSION <= 5
int * ext = this->GetInput()->GetWholeExtent();
+#else
+ int * ext = this->GetInformation()->Get(vtkDataObject::DATA_EXTENT());
+#endif
if ( ext[4] == ext[5] ) {
nDims = 2;
if ( ext[2] == ext[3] ) {
origin[1] += ext[2] * spacing[1];
origin[2] += ext[4] * spacing[2];
+#if VTK_MAJOR_VERSION <= 5
this->GetInput()->SetUpdateExtent(ext[0], ext[1],
ext[2], ext[3],
ext[4], ext[5]);
this->GetInput()->UpdateData();
-
-
+#else
+ this->SetUpdateExtent(ext);
+ this->Update();
+#endif
this->SetFileDimensionality(nDims);
this->InvokeEvent(vtkCommand::StartEvent);
class vtkVOXImageWriter : public vtkImageWriter
{
public:
- vtkTypeRevisionMacro(vtkVOXImageWriter,vtkImageWriter);
+ vtkTypeMacro(vtkVOXImageWriter,vtkImageWriter);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
const std::string open_mode_names[] = {"base", "overlay", "fusion", "vf", "contour", "fusionSequence"};
if(open_mode==O_BASE)
window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME);
- else if (open_mode==O_OVERLAY)
+ else if (open_mode==O_OVERLAY && window.CheckAddedImage(n_image_loaded-1, "overlay"))
window.AddOverlayImage(n_image_loaded-1,sequence_filenames,vvImageReader::MERGEDWITHTIME);
else if (open_mode==O_LANDMARKS)
window.AddLandmarks(n_image_loaded-1,sequence_filenames);
- else if (open_mode==O_FUSION)
+ else if (open_mode==O_FUSION && window.CheckAddedImage(n_image_loaded-1, "fusion") && window.CheckAddedImage(n_image_loaded-1, "fusionSequence"))
window.AddFusionImage(n_image_loaded-1,sequence_filenames,vvImageReader::MERGEDWITHTIME);
else {
std::cerr << "Sequences are not managed for opening " << open_mode_names[open_mode] << std::endl;
first_of_wl_set = n_image_loaded-1;
}
}
- else if (open_mode==O_VF)
+ else if (open_mode==O_VF && window.CheckAddedImage(n_image_loaded-1, "vector"))
window.AddField(current.c_str(), n_image_loaded-1);
- else if (open_mode==O_OVERLAY)
+ else if (open_mode==O_OVERLAY && window.CheckAddedImage(n_image_loaded-1, "overlay"))
window.AddOverlayImage(n_image_loaded-1,image,vvImageReader::IMAGE);
else if (open_mode==O_CONTOUR)
window.AddDCStructContour(n_image_loaded-1,current.c_str());
- else if (open_mode==O_FUSION)
+ else if (open_mode==O_FUSION && window.CheckAddedImage(n_image_loaded-1, "fusion") && window.CheckAddedImage(n_image_loaded-1, "fusionSequence"))
window.AddFusionImage(n_image_loaded-1,image,vvImageReader::IMAGE);
else if (open_mode==O_LANDMARKS)
window.AddLandmarks(n_image_loaded-1,image);
#include "vvAnimatedGIFWriter.h"
#include "clitkDD.h"
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include <vtkImageData.h>
#include <vtkImageQuantizeRGBToIndex.h>
#include <vtkImageAppend.h>
void vvAnimatedGIFWriter::Write()
{
// get the data
+#if VTK_MAJOR_VERSION <= 5
this->GetInput()->UpdateInformation();
int *wExtent = this->GetInput()->GetWholeExtent();
this->GetInput()->SetUpdateExtent(wExtent);
this->GetInput()->Update();
+#else
+ this->UpdateInformation();
+ int *wExtent = this->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT());
+ this->SetUpdateExtent(wExtent);
+ this->Update();
+#endif
RGBslices.push_back( vtkSmartPointer<vtkImageData>::New() );
RGBslices.back()->ShallowCopy(this->GetInput());
+#if VTK_MAJOR_VERSION <= 5
RGBvolume->AddInput(RGBslices.back());
+#else
+ RGBvolume->AddInputData(RGBslices.back());
+#endif
}
//---------------------------------------------------------------------------
// Quantize to 8 bit colors
vtkSmartPointer<vtkImageQuantizeRGBToIndex> quant = vtkSmartPointer<vtkImageQuantizeRGBToIndex>::New();
quant->SetNumberOfColors(256);
+#if VTK_MAJOR_VERSION <= 5
quant->SetInput(RGBvolume->GetOutput());
+#else
+ quant->SetInputConnection(RGBvolume->GetOutputPort());
+#endif
quant->Update();
// Convert to 8 bit image
vtkSmartPointer<vtkImageCast> cast = vtkSmartPointer<vtkImageCast>::New();
+#if VTK_MAJOR_VERSION <= 5
cast->SetInput( quant->GetOutput() );
+#else
+ cast->SetInputConnection( quant->GetOutputPort() );
+#endif
cast->SetOutputScalarTypeToUnsignedChar();
cast->Update();
#include "vvBinaryImageOverlayActor.h"
#include "vvImage.h"
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include <vtkImageActor.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkProperty.h>
#include <vtkImageMapToRGBA.h>
#include <vtkLookupTable.h>
+#include <vtkImageMapper3D.h>
//------------------------------------------------------------------------------
vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
-{
+{
mTSlice = -1;
mSlice = 0;
mColor.resize(3);
//------------------------------------------------------------------------------
vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
-{
+{
mImageActorList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::RemoveActors()
-{
+{
for (unsigned int i = 0; i < mImageActorList.size(); i++) {
if (mSlicer != 0) {
if (mSlicer != NULL) {
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
-{
+{
mColor[0] = r;
mColor[1] = g;
mColor[2] = b;
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
-{
+{
mSlicer = slicer;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
-{
+{
if (!mSlicer) {
std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
exit(0);
for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
// how many intensity ?
vtkSmartPointer<vtkImageMapToRGBA> mOverlayMapper = vtkSmartPointer<vtkImageMapToRGBA>::New();
- mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
+ if (mImage->IsTimeSequence())
+ {
+ #if VTK_MAJOR_VERSION <= 5
+ mOverlayMapper->SetInput(mImage->GetVTKImages()[numImage]);
+#else
+ mOverlayMapper->SetInputData(mImage->GetVTKImages()[numImage]);
+#endif
+ }
+ else {
+#if VTK_MAJOR_VERSION <= 5
+ mOverlayMapper->SetInput(mImage->GetVTKImages()[0]);
+#else
+ mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]);
+#endif
+ }
double range[2];
- mImage->GetVTKImages()[0]->GetScalarRange(range);
+ if (mImage->IsTimeSequence())
+ {
+ mImage->GetVTKImages()[numImage]->GetScalarRange(range);
+ }
+ else {
+ mImage->GetVTKImages()[0]->GetScalarRange(range);
+ }
int n = range[1]-range[0]+1;
mColorLUT->SetRange(range[0],range[1]);
mColorLUT->SetNumberOfTableValues(n);
mOverlayMapper->SetLookupTable(mColorLUT);
vtkSmartPointer<vtkImageActor> mOverlayActor = vtkSmartPointer<vtkImageActor>::New();
+#if VTK_MAJOR_VERSION <= 5
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
+#else
+ mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
+#endif
mOverlayActor->SetPickable(0);
mOverlayActor->SetVisibility(IsVisible);
//mOverlayActor->SetOpacity(1.0);
mMapperList.push_back(mOverlayMapper);
mImageActorList.push_back(mOverlayActor);
- mSlicer->GetRenderer()->AddActor(mOverlayActor);
+ mSlicer->GetRenderer()->AddActor(mImageActorList[numImage]);
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetOpacity(double d)
-{
+{
mAlpha = d;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
-{
+{
mImage = image;
if (modeBG) {
mBackgroundValue = bg;
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::HideActors()
-{
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
for(unsigned int i=0; i<mImageActorList.size(); i++) {
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::ShowActors()
-{
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
mTSlice = mSlicer->GetTSlice();
- // for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mImageActorList[mTSlice]->VisibilityOn();
UpdateSlice(0, mSlice);
- //}
// Caller MUST call Render
//mSlicer->Render();
}
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::UpdateColor()
-{
+{
mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
// how many intensity ?
mOverlayMapper->SetLookupTable(mColorLUT);
vtkImageActor * mOverlayActor = mImageActorList[numImage];
+#if VTK_MAJOR_VERSION <= 5
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
+#else
+ mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
+#endif
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
-{
+{
if (!mSlicer) return;
if (!force) {
int orientation = mSlicer->GetOrientation();
int maskExtent[6];
ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
- ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
+ ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetVTKImages()[mTSlice], mImage->GetVTKImages()[mTSlice]);
+#if VTK_MAJOR_VERSION <= 5
mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
+#else
+ mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
+#endif
+ HideActors();
+ mImageActorList[mTSlice]->VisibilityOn();
SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
// set previous slice
int slice,
int * inExtent,
int * outExtent)
-{
+{
switch (orientation) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
//----------------------------------------------------------------------------
void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
-{
+{
for(int i=0; i<3; i++) {
double a = (image->GetOrigin()[i] + inExtent[i*2]*image->GetSpacing()[i] -
overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
int * extent,
vtkImageActor * actor,
double position)
-{
+{
/* FIXME
Error according to camera orientation
*/
#include "vtkVOXImageWriter.h"
#include <vtkImageData.h>
+#include <vtkVersion.h>
#include "clitkCommon.h"
#include "vvSlicerManager.h"
for (unsigned int i=0; i<images.size(); i++) {
std::stringstream filename;
filename << temp_dir << "/temp_" << i << ".vox";
+#if VTK_MAJOR_VERSION <= 5
vox->SetInput(images[i]);
+#else
+ vox->SetInputData(images[i]);
+#endif
vox->SetFileName(filename.str().c_str());
if (i==refimage)
ref_file=filename.str();
===========================================================================**/
#include "vvGlyph2D.h"
+#include <vtkVersion.h>
#include "vtkCell.h"
#include "vtkDataSet.h"
#include "vtkFloatArray.h"
#include "vtkTransform.h"
#include "vtkUnsignedCharArray.h"
-vtkCxxRevisionMacro(vvGlyph2D, "DummyRevision");
vtkStandardNewMacro(vvGlyph2D);
vvGlyph2D::vvGlyph2D()
defaultPointIds[0] = 0;
defaultPointIds[1] = 1;
defaultSource->SetPoints(defaultPoints);
- defaultSource->InsertNextCell(VTK_LINE, 2, defaultPointIds);
+ defaultSource->InsertNextCell(VTK_LINE, 2, defaultPointIds);
+#if VTK_MAJOR_VERSION <= 5
defaultSource->SetUpdateExtent(0, 1, 0);
this->SetSource(defaultSource);
+#else
+ this->SetUpdateExtent(0, 1, 0);
+ this->SetSourceData(defaultSource);
+#endif
defaultSource->Delete();
defaultSource = NULL;
defaultPoints->Delete();
class vvGlyph2D : public vtkGlyph3D
{
public:
- vtkTypeRevisionMacro(vvGlyph2D,vtkGlyph3D);
+ vtkTypeMacro(vvGlyph2D,vtkGlyph3D);
void PrintSelf(ostream& os, vtkIndent indent);
// Description
#include "vtkPolyData.h"
#include "vtkUnsignedCharArray.h"
-vtkCxxRevisionMacro(vvGlyphSource, "DummyRevision");
vtkStandardNewMacro(vvGlyphSource);
{
public:
static vvGlyphSource *New();
- vtkTypeRevisionMacro(vvGlyphSource,vtkGlyphSource2D);
+ vtkTypeMacro(vvGlyphSource,vtkGlyphSource2D);
void PrintSelf(ostream& os, vtkIndent indent);
void SetGlyphTypeToSpecificArrow() {
<file>icons/8b.png</file>
<file>icons/1b.png</file>
<file>icons/binarize.png</file>
+ <file>icons/profile.png</file>
<file>icons/resample.png</file>
<file>icons/crop.png</file>
<file>icons/splashscreen2.png</file>
#include "vvImageContour.h"
#include "vvImage.h"
+#include <vtkVersion.h>
#include <vtkImageActor.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkImageData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
+#include <vtkInformation.h>
//------------------------------------------------------------------------------
vvImageContour::vvImageContour()
-{
+{
mTSlice = -1;
mSlice = 0;
mHiddenImageIsUsed = false;
//------------------------------------------------------------------------------
vvImageContour::~vvImageContour()
-{
+{
mSquaresActorList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::RemoveActors()
-{
+{
for (unsigned int i = 0; i < mSquaresActorList.size(); i++) {
if (mSlicer != 0) {
if (mSlicer!= NULL) {
//------------------------------------------------------------------------------
-void vvImageContour::SetSlicer(vvSlicer * slicer) {
+void vvImageContour::SetSlicer(vvSlicer * slicer)
+{
mSlicer = slicer;
// Create an actor for each time slice
for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
//------------------------------------------------------------------------------
-void vvImageContour::SetImage(vvImage::Pointer image) {
+void vvImageContour::SetImage(vvImage::Pointer image)
+{
for (unsigned int numImage = 0; numImage < image->GetVTKImages().size(); numImage++) {
+#if VTK_MAJOR_VERSION <= 5
mClipperList[numImage]->SetInput(image->GetVTKImages()[numImage]);
+#else
+ mClipperList[numImage]->SetInputData(image->GetVTKImages()[numImage]);
+#endif
}
mHiddenImageIsUsed = true;
mHiddenImage = image;
//------------------------------------------------------------------------------
-void vvImageContour::SetPreserveMemoryModeEnabled(bool b) {
+void vvImageContour::SetPreserveMemoryModeEnabled(bool b)
+{
// FastCache mode work only if threshold is always the same
if (mDisplayModeIsPreserveMemory == b) return;
mDisplayModeIsPreserveMemory = b;
//------------------------------------------------------------------------------
-void vvImageContour::SetColor(double r, double g, double b) {
+void vvImageContour::SetColor(double r, double g, double b)
+{
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetColor(r,g,b);
+ mSquaresActorList[i]->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::SetLineWidth(double w)
-{
+{
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetLineWidth(w);
}
//------------------------------------------------------------------------------
-void vvImageContour::HideActors() {
+void vvImageContour::HideActors()
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
//------------------------------------------------------------------------------
-void vvImageContour::ShowActors() {
+void vvImageContour::ShowActors()
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
mTSlice = mSlicer->GetTSlice();
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::Update(double value) {
+void vvImageContour::Update(double value)
+{
if (!mSlicer) return;
if (mPreviousValue == value) {
if (mPreviousSlice == mSlicer->GetSlice()) {
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithPreserveMemoryMode() {
+void vvImageContour::UpdateWithPreserveMemoryMode()
+{
// Only change actor visibility if tslice change
mPreviousTslice = mTSlice;
mTSlice = mSlicer->GetTSlice();
if (mPreviousTslice != mTSlice) {
if (mPreviousTslice != -1) mSquaresActorList[mPreviousTslice]->VisibilityOff();
}
-
+
mSlicer->Render();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::InitializeCacheMode() {
+void vvImageContour::InitializeCacheMode()
+{
clitkExceptionMacro("TODO : not implemented yet");
mPreviousSlice = mPreviousOrientation = 0;
int dim = mSlicer->GetImage()->GetNumberOfDimensions();
//------------------------------------------------------------------------------
-int vvImageContour::ComputeCurrentOrientation() {
+int vvImageContour::ComputeCurrentOrientation()
+{
// Get extent of image in the slicer
int* extent = mSlicer->GetImageActor()->GetDisplayExtent();
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithFastCacheMode() {
+void vvImageContour::UpdateWithFastCacheMode()
+{
clitkExceptionMacro("TODO : not implemented yet");
// Compute orientation
//------------------------------------------------------------------------------
-void vvImageContour::CreateNewActor(int numImage) {
+void vvImageContour::CreateNewActor(int numImage)
+{
vtkSmartPointer<vtkActor> squaresActor = vtkSmartPointer<vtkActor>::New();
vtkSmartPointer<vtkImageClip> clipper = vtkSmartPointer<vtkImageClip>::New();
vtkSmartPointer<vtkMarchingSquares> squares = vtkSmartPointer<vtkMarchingSquares>::New();
vtkSmartPointer<vtkPolyDataMapper> squaresMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
- if (mHiddenImageIsUsed)
+ if (mHiddenImageIsUsed) {
+#if VTK_MAJOR_VERSION <= 5
clipper->SetInput(mHiddenImage->GetVTKImages()[0]);
- else
+#else
+ clipper->SetInputData(mHiddenImage->GetVTKImages()[0]);
+#endif
+ } else {
+#if VTK_MAJOR_VERSION <= 5
clipper->SetInput(mSlicer->GetImage()->GetVTKImages()[numImage]);
-
+#else
+ clipper->SetInputData(mSlicer->GetImage()->GetVTKImages()[numImage]);
+#endif
+ }
+#if VTK_MAJOR_VERSION <= 5
squares->SetInput(clipper->GetOutput());
squaresMapper->SetInput(squares->GetOutput());
+#else
+ squares->SetInputConnection(clipper->GetOutputPort(0));
+ squaresMapper->SetInputConnection(squares->GetOutputPort(0));
+#endif
squaresMapper->ScalarVisibilityOff();
squaresActor->SetMapper(squaresMapper);
squaresActor->GetProperty()->SetColor(1.0,0,0);
+ squaresActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
squaresActor->SetPickable(0);
squaresActor->VisibilityOff();
mSlicer->GetRenderer()->AddActor(squaresActor);
vtkPolyDataMapper * mapper,
vtkMarchingSquares * squares,
vtkImageClip * clipper,
- double threshold, int orientation, int slice) {
+ double threshold, int orientation, int slice)
+{
// Set parameter for the MarchigSquare
squares->SetValue(0, threshold);
-
+ squares->Update();
// Get image extent
int* extent = mSlicer->GetImageActor()->GetDisplayExtent();
extent2 = extent;
actor->VisibilityOn();
}
-
+
clipper->SetOutputWholeExtent(extent2[0],extent2[1],extent2[2],
extent2[3],extent2[4],extent2[5]);
-
+
if (mHiddenImageIsUsed) delete extent2;
// Move the actor to be visible
// DD(mDepth);
// position[orientation] = -mDepth;
// actor->SetPosition(position);
-
mapper->Update();
}
//------------------------------------------------------------------------------
jacobian_filter->SetUseImageSpacingOn();
vf_connector->SetInput(mVF->GetVTKImages()[num]);
warp_filter->SetInput(input[num]);
-#if ITK_VERSION_MAJOR >= 4
warp_filter->SetDisplacementField(vf_connector->GetOutput());
-#else
- warp_filter->SetDeformationField(vf_connector->GetOutput());
-#endif
jacobian_filter->SetInput(vf_connector->GetOutput());
warp_filter->SetOutputSpacing(input[num]->GetSpacing());
warp_filter->SetOutputOrigin(input[num]->GetOrigin());
#define VVINTENSITYVALUESLIDER_H
// qt
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QDialog>
// clitk
#include <vtkRendererCollection.h>
#include "clitkCommon.h"
-
-vtkCxxRevisionMacro(vvInteractorStyleNavigator, "DummyRevision");
vtkStandardNewMacro(vvInteractorStyleNavigator);
//----------------------------------------------------------------------------
{
public:
static vvInteractorStyleNavigator *New();
- vtkTypeRevisionMacro(vvInteractorStyleNavigator, vtkInteractorStyle);
+ vtkTypeMacro(vvInteractorStyleNavigator, vtkInteractorStyle);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
#include "vvImage.h"
// qt
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QDialog>
#include "ui_vvLabelImageLoaderWidget.h"
#include <string>
#include <locale.h>
+#include <vtkVersion.h>
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkFloatArray.h"
//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+void vvLandmarks::RemoveLandmarkWithLabel(vtkStdString label, int time)
+{
+ if (label != "P1" && label != "P2")
+ return;
+ // erase a vtkPoint by shifiting the array .
+ // not a problem here because there are no
+ // pologyons linking the points
+ int t = time;//mLandmarks[index].coordinates[3];
+ int npoints = mPoints[t]->GetNumberOfPoints();
+
+ //search of the index corresponding to the label
+ int index(0);
+ while (mLabels[t]->GetValue(index) != label)
+ ++index;
+
+ for (int i = index; i < npoints - 1; i++) {
+ mPoints[t]->InsertPoint(i, mPoints[t]->GetPoint(i+1));
+ std::string str_i; // string which will contain the result
+ std::ostringstream convert; // stream used for the conversion
+ convert << i; // insert the textual representation of 'i' in the characters in the stream
+ str_i = convert.str(); // set 'str_i' to the contents of the stream
+ mLabels[t]->SetValue(i,mLabels[t]->GetValue(i+1));
+ }
+ mPoints[t]->SetNumberOfPoints(npoints-1);
+ mLabels[t]->SetNumberOfValues(npoints-1);
+ mLabels[t]->Modified();
+ mPolyData->Modified();
+
+ mLandmarks[t].erase(mLandmarks[t].begin() + index);
+ mIds[t]->RemoveLastTuple();
+}
+//--------------------------------------------------------------------
+
+
//--------------------------------------------------------------------
void vvLandmarks::RemoveLandmark(int index)
{
mPolyData->GetPointData()->SetScalars(mIds[time]);
mPolyData->GetPointData()->AddArray(mLabels[time]);
mPolyData->Modified();
+#if VTK_MAJOR_VERSION <= 5
mPolyData->Update();
+#else
+ //mPolyData->Update();
+#endif
mTime = time;
}
}
void AddLandmark(float x,float y,float z,float t,double value);
void RemoveLastLandmark();
+ void RemoveLandmarkWithLabel(vtkStdString, int);
void RemoveLandmark(int index);
void RemoveAll();
float* GetCoordinates(int index);
double GetPixelValue(int index);
std::string GetComments(int index);
+ vtkStringArray* GetLabels() { return mLabels[mTime]; }
unsigned int GetNumberOfPoints() { return (unsigned int) mLandmarks[mTime].size(); }
//int GetNumberOfSources(){return mText.size();}
#include "vtkUnsignedCharArray.h"
#include <cassert>
-vtkCxxRevisionMacro(vvLandmarksGlyph, "DummyRevision");
vtkStandardNewMacro(vvLandmarksGlyph);
#define vtkfont_width 9
class vvLandmarksGlyph : public vtkTextSource
{
public:
- vtkTypeRevisionMacro(vvLandmarksGlyph,vtkTextSource);
+ vtkTypeMacro(vvLandmarksGlyph,vtkTextSource);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
#include <QtGui>
#include <Qt>
+#include <QFileDialog>
#include "QTreePushButton.h"
#include "vvLandmarks.h"
//====================================================================
vvLandmarksPanel::vvLandmarksPanel(QWidget * parent):QWidget(parent)
-{
+{
setupUi(this);
tableWidget->verticalHeader()->hide();
}
void vvLandmarksPanel::Load()
-{
+{
QString file = QFileDialog::getOpenFileName(this,tr("Load Landmarks"),
mCurrentPath.c_str(),tr("Landmarks ( *.txt *.pts)"));
if (!file.isEmpty()) {
}
bool vvLandmarksPanel::LoadFromFile(std::vector<std::string> files)
-{
+{
if (!mCurrentLandmarks->LoadFile(files))
return false;
- SetCurrentLandmarks(mCurrentLandmarks,2);
+ SetCurrentLandmarks(mCurrentLandmarks,0);
emit UpdateRenderWindows();
return true;
}
void vvLandmarksPanel::Save()
-{
+{
QString file = QFileDialog::getSaveFileName(this,
tr("Save Landmarks"),
mCurrentPath.c_str(),tr("Landmarks ( *.txt)"));
}
void vvLandmarksPanel::SelectPoint()
-{
+{
if (tableWidget->rowCount() > 0) {
QList<QTableWidgetItem *> items = tableWidget->selectedItems();
if (!items.empty()) {
void vvLandmarksPanel::RemoveSelectedPoints()
-{
+{
if (tableWidget->rowCount() > 0) {
QList<QTableWidgetItem *> items = tableWidget->selectedItems();
if (items.empty()) {
}
void vvLandmarksPanel::RemoveAllPoints()
-{
+{
mCurrentLandmarks->RemoveAll();
tableWidget->clearContents();
tableWidget->setRowCount(0);
}
void vvLandmarksPanel::AddPoint()
-{
+{
AddPoint(mCurrentLandmarks->GetNumberOfPoints()-1);
}
void vvLandmarksPanel::AddPoint(int landmarksIndex)
-{
+{
int rowIndex = tableWidget->rowCount();
// DD(rowIndex);
tableWidget->setRowCount(rowIndex+1);
}
void vvLandmarksPanel::SetCurrentLandmarks(vvLandmarks* lm,int time)
-{
+{
if (time != lm->GetTime())
return;
-
loadButton->setEnabled(1);
saveButton->setEnabled(1);
removeButton->setEnabled(1);
tableWidget->clearContents();
tableWidget->setRowCount(0);
for (unsigned int i = 0; i < mCurrentLandmarks->GetNumberOfPoints(); i++) {
- AddPoint(i);
+ if ((mCurrentLandmarks->GetLabels()->GetValue(i) != "P1") && (mCurrentLandmarks->GetLabels()->GetValue(i) != "P2"))
+ AddPoint(i);
}
//if (time > 1)
//tableWidget->setColumnHidden(4,1);
}
void vvLandmarksPanel::SetCurrentImage(std::string filename)
-{
+{
QString image = "<b>CurrentImage : </b>";
image += vtksys::SystemTools::GetFilenameWithoutLastExtension(filename).c_str();
nameLabel->setText(image);
}
void vvLandmarksPanel::CommentsChanged(int row, int column)
-{
+{
if (column == 6) {
mCurrentLandmarks->ChangeComments(row,std::string(tableWidget->item(row,column)->text().toStdString()));
tableWidget->resizeColumnsToContents();
#include "QTreePushButton.h"
#include <QUrl>
#include <QSettings>
+#include <QShortcut>
// VV include
#include "vvMainWindow.h"
#include "vvReadState.h"
#include "clitkConfiguration.h"
#include "clitkMatrix.h"
+#ifdef Q_OS_OSX
+# include "vvOSXHelper.h"
+#endif
// ITK include
#include <itkImage.h>
#include <itkNumericSeriesFileNames.h>
// VTK include
+#include <vtkImageMapper3D.h>
+#include <vtkInformation.h>
+#include <vtkVersion.h>
#include <vtkImageData.h>
#include <vtkImageActor.h>
#include <vtkCornerAnnotation.h>
//------------------------------------------------------------------------------
vvMainWindow::vvMainWindow():vvMainWindowBase()
-{
+{
setupUi(this); // this sets up the GUI
+ //Qt::WindowFlags flags = windowFlags();
+ //setWindowFlags(flags | Qt::WindowStaysOnTopHint);
+
mInputPathName = "";
mMenuTools = menuTools;
// mMenuSegmentation = menuSegmentation;
contextActions.resize(0);
QAction* actionOpen_new_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/fileopen.png")),
tr("O&pen new Image"));
- actionOpen_new_image->setShortcut(QKeySequence(tr("Ctrl+O")));
connect(actionOpen_new_image,SIGNAL(triggered()),this,SLOT(OpenImages()));
contextActions.push_back(actionOpen_new_image);
contextMenu.addSeparator();
tr("Reset transformation to identity"));
connect(actionResetMatrix, SIGNAL(triggered()), this,SLOT(ResetTransformationToIdentity()));
- // TRIAL DS
- /*
- QMenu * m = new QMenu(menubar);
- m->setTitle("TOTO");
- // m->setObjectName(QString::fromUtf8("TOTOTO"));
- contextMenu.addMenu(m);
- QAction * a = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
- tr("BIDON"));
- QAction * b = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
- tr("BIDON2"));
- m->addAction(a);
- m->addAction(b);
- connect(a,SIGNAL(triggered()),this,SLOT(AddFusionImage()));
- */
-
//init the DataTree
mSlicerManagers.resize(0);
connect(actionAdd_overlay_image_to_current_image,SIGNAL(triggered()), this,SLOT(SelectOverlayImage()));
connect(actionAdd_USSequence_toCT,SIGNAL(triggered()), this,SLOT(SelectFusionSequence()));
connect(actionNavigation_Help,SIGNAL(triggered()),this,SLOT(ShowHelpDialog()));
+
+ QShortcut *shortcutHelp = new QShortcut(QKeySequence(QKeySequence::HelpContents),this);
+ shortcutHelp->setContext(Qt::ApplicationShortcut);
+ QObject::connect(shortcutHelp, SIGNAL(activated()), this, SLOT(ShowHelpDialog()));
+
connect(actionDocumentation,SIGNAL(triggered()),this,SLOT(ShowDocumentation()));
connect(actionRegister_vv,SIGNAL(triggered()),this,SLOT(PopupRegisterForm()));
SOViewWidget->hide();
SEViewWidget->hide();
+#ifdef Q_OS_OSX
+ disableGLHiDPI(NOViewWidget->winId());
+ disableGLHiDPI(NEViewWidget->winId());
+ disableGLHiDPI(SOViewWidget->winId());
+ disableGLHiDPI(SEViewWidget->winId());
+#endif
+
//Recently opened files
std::list<std::string> recent_files = GetRecentlyOpenedImages();
recentlyOpenedFilesMenu=NULL;
//timerMemory->setInterval(5);
connect(timerMemory, SIGNAL(timeout()), this, SLOT(UpdateMemoryUsage()));
timerMemory->start(2000);
-
}
+
//------------------------------------------------------------------------------
void vvMainWindow::show()
-{
+{
vvMainWindowBase::show();
PopupRegisterForm(true);
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateMemoryUsage()
-{
+{
// clitk::PrintMemory(true);
if (clitk::GetMemoryUsageInMb() == 0) infoPanel->setMemoryInMb("NA");
else infoPanel->setMemoryInMb(QString::number(clitk::GetMemoryUsageInMb())+" MiB");
//------------------------------------------------------------------------------
void vvMainWindow::createRecentlyOpenedFilesMenu()
-{
+{
recentlyOpenedFilesMenu = new QMenu("Recently opened files...");
recentlyOpenedFilesMenu->setIcon(QIcon(QString::fromUtf8(":/common/icons/open.png")));
menuFile->insertMenu(actionOpen_Image_With_Time,recentlyOpenedFilesMenu);
//------------------------------------------------------------------------------
void vvMainWindow::updateRecentlyOpenedFilesMenu(const std::list<std::string> &recent_files)
-{
+{
if(recentlyOpenedFilesMenu==NULL) {
createRecentlyOpenedFilesMenu();
} else {
//------------------------------------------------------------------------------
void vvMainWindow::ComputeMidPosition()
-{
+{
bool ok;
int index=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
- int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
- mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
+ int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
+mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
vvMidPosition midp;
midp.slicer_manager = mSlicerManagers[index];
//------------------------------------------------------------------------------
void vvMainWindow::AddContour(int image_index, vvMesh::Pointer contour, bool propagation)
-{
+{
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,"filename.vtk");
item->setData(1,Qt::UserRole,tr("contour"));
brush.setColor(QColor(contour->r*255,contour->g*255,contour->b*255));
brush.setStyle(Qt::SolidPattern);
item->setData(COLUMN_IMAGE_NAME,Qt::BackgroundRole,brush);
- // item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,contour->structure_name.c_str());
+ item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,contour->structure_name.c_str());
for (int j = 1; j <= 4; j++)
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(image_index)->data(j,Qt::CheckStateRole));
//------------------------------------------------------------------------------
void vvMainWindow::OpenVTKContour()
-{
+{
if (mSlicerManagers.size() > 0) {
QString Extensions = "Images ( *.vtk *.obj)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::AddDCStructContour(int index, QString file)
-{
+{
vvMeshReader reader;
reader.SetFilename(file.toStdString());
vvStructSelector selector;
//------------------------------------------------------------------------------
void vvMainWindow::OpenDCStructContour()
-{
+{
if (mSlicerManagers.size() > 0) {
QString Extensions = "Dicom Files ( *.dcm RS*)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::ComputeDeformableRegistration()
-{
+{
if (mSlicerManagers.size() > 0) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvDeformationDialog dialog(index,mSlicerManagers);
//------------------------------------------------------------------------------
void vvMainWindow::WarpImage()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (!mSlicerManagers[index]->GetVF().IsNull()) {
bool ok;
- int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
+ int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
WarpImage(mSlicerManagers[index],ref);
//------------------------------------------------------------------------------
void vvMainWindow::WarpImage(vvSlicerManager* selected_slicer,int reference_phase)
-{
+{
if (!selected_slicer->GetVF().IsNull()) {
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QFileInfo info(selected_slicer->GetFileName().c_str());
//------------------------------------------------------------------------------
vvMainWindow::~vvMainWindow()
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] != NULL)
delete mSlicerManagers[i];
}
+ delete documentation;
+ delete help_dialog;
+ delete dicomSeriesSelector;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
QTabWidget * vvMainWindow::GetTab()
-{
+{
return tabWidget;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::MergeImages()
-{
+{
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::SliceImages()
-{
+{
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::MergeImagesWithTime()
-{
+{
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images With Time"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::OpenDicom()
-{
+{
std::vector<std::string> files;
//std::cout << "dicomSeriesSelector " << std::endl;
//------------------------------------------------------------------------------
void vvMainWindow::OpenImages()
-{
+{
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
}
//------------------------------------------------------------------------------
void vvMainWindow::OpenRecentImage()
-{
+{
QAction * caller = qobject_cast<QAction*>(sender());
std::vector<std::string> images;
images.push_back(caller->text().toStdString());
//------------------------------------------------------------------------------
void vvMainWindow::OpenImageWithTime()
-{
+{
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::LoadedImageType filetype)
-{
+{
//Separate the way to open images and dicoms
int fileSize;
if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME)
// Change filename if an image with the same already exist
int number = GetImageDuplicateFilenameNumber(files[i] + std::string("_slice"));
- if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED)
+ if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED) {
SetImageSucceed = imageManager->SetImage(files[i],filetype, number, j);
- else {
+ } else {
SetImageSucceed = imageManager->SetImages(files,filetype, number);
}
-
if (!SetImageSucceed) {
QApplication::restoreOverrideCursor();
QString error = "Cannot open file \n";
QMessageBox::information(this,tr("Reading problem"),error);
delete imageManager;
} else {
+
mSlicerManagers.push_back(imageManager);
//create an item in the tree with good settings
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(),SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
-
InitSlicers();
numberofsuccesulreads++;
}
}
}
+
if (numberofsuccesulreads) {
NOViewWidget->show();
NEViewWidget->show();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateTree()
-{
+{
DataTree->resizeColumnToContents(COLUMN_TREE);
DataTree->resizeColumnToContents(COLUMN_UL_VIEW);
DataTree->resizeColumnToContents(COLUMN_UR_VIEW);
//------------------------------------------------------------------------------
void vvMainWindow::CurrentImageChanged(std::string id)
-{
+{
if (id == mCurrentSelectedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::CurrentPickedImageChanged(std::string id)
-{
+{
if (id == mCurrentPickedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::ImageInfoChanged()
-{
+{
contextActions[6]->setEnabled(1);
contextActions[5]->setEnabled(1);
actionSave_As->setEnabled(1);
//------------------------------------------------------------------------------
void vvMainWindow::ShowDocumentation()
-{
+{
documentation->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::PopupRegisterForm(bool checkCanPush)
-{
+{
vvRegisterForm* registerForm = new vvRegisterForm(QUrl("http://www.creatis.insa-lyon.fr/~dsarrut/vvregister/write.php"), getVVSettingsPath(), getSettingsOptionFormat());
if(!checkCanPush) {
registerForm->show();
//------------------------------------------------------------------------------
void vvMainWindow::ShowHelpDialog()
-{
+{
help_dialog->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ChangeViewMode()
-{
+{
typedef struct _SIZE{
QSplitter* splitter;
QList<int> size1, size2;
//------------------------------------------------------------------------------
QString vvMainWindow::GetSizeInBytes(unsigned long size)
-{
+{
QString result = "";// QString::number(size);
//result += " bytes (";
if (size > 1000000000) {
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorDoubleAsString(std::vector<double> vectorDouble)
-{
+{
QString result;
for (unsigned int i= 0; i < vectorDouble.size(); i++) {
if (i != 0)
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorIntAsString(std::vector<int> vectorInt)
-{
+{
QString result;
for (unsigned int i= 0; i < vectorInt.size(); i++) {
if (i != 0)
//------------------------------------------------------------------------------
//this actually returns the SlicerManager index!
int vvMainWindow::GetSlicerIndexFromItem(QTreeWidgetItem* item)
-{
+{
QString id = item->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
//------------------------------------------------------------------------------
QTreeWidgetItem* vvMainWindow::GetItemFromSlicerManager(vvSlicerManager* sm)
-{
+{
QString id = sm->GetId().c_str();
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
//------------------------------------------------------------------------------
void vvMainWindow::DisplayChanged(QTreeWidgetItem *clickedItem, int column)
-{
+{
if ( column >= COLUMN_CLOSE_IMAGE || column <= 0)
return;
//------------------------------------------------------------------------------
void vvMainWindow::InitSlicers()
-{
+{
if (mSlicerManagers.size()) {
mSlicerManagers.back()->GenerateDefaultLookupTable();
-
mSlicerManagers.back()->SetSlicerWindow(0,NOViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(1,NEViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(2,SOViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(3,SEViewWidget->GetRenderWindow());
- mSlicerManagers.back()->Render(); // SR: displayed #slice is wrong without this
+#if VTK_MAJOR_VERSION <= 5
+ mSlicerManagers.back()->Render(); // SR: displayed #slice is wrong without this / TB: With VTK6 and multiple images, all slicers are updated, not only the first
+#endif
}
}
//------------------------------------------------------------------------------
void vvMainWindow::InitDisplay()
-{
+{
if (mSlicerManagers.size()) {
//BE CAREFUL : this is absolutely necessary to set the interactor style
//in order to have the same style instanciation for all SlicerManagers in
bool AlreadySelected = false;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
mSlicerManagers[i]->SetInteractorStyleNavigator(j,style);
-
//select the image only if previous are not selected
if (DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 1) {
mSlicerManagers[i]->UpdateSlicer(j,1);
AlreadySelected = true;
} else if (i == DataTree->topLevelItemCount()-1 && !AlreadySelected) {
- if (DataTree->selectedItems().size() == 0)
+ if (DataTree->selectedItems().size() == 0) {
DataTree->topLevelItem(i)->setSelected(1);
+ }
DataTree->topLevelItem(i)->setData(j+1,Qt::CheckStateRole,2);
mSlicerManagers[i]->UpdateSlicer(j,1);
DisplaySliders(i,j);
//------------------------------------------------------------------------------
void vvMainWindow::DisplaySliders(int slicer, int window)
-{
+{
if(!mSlicerManagers[slicer]->GetSlicer(window)->GetRenderer()->GetDraw())
return;
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage(QTreeWidgetItem* item, int column)
-{
+{
int index = GetSlicerIndexFromItem(item);
if (DataTree->topLevelItem(index) != item) {
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage(QTreeWidgetItem* item, int column)
-{
+{
// int index = GetSlicerIndexFromItem(item);
// QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
// if (item->data(1,Qt::UserRole).toString() == "vector")
//------------------------------------------------------------------------------
void vvMainWindow::MousePositionChanged(int visibility,double x, double y, double z, double X, double Y, double Z , double value)
-{
+{
infoPanel->setCurrentInfo(visibility,x,y,z,X,Y,Z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::VectorChanged(int visibility,double x, double y, double z, double value)
-{
+{
overlayPanel->getCurrentVectorInfo(visibility,x,y,z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::OverlayChanged(int visibility, double valueOver, double valueRef)
-{
+{
overlayPanel->getCurrentOverlayInfo(visibility,valueOver, valueRef);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::FusionChanged(int visibility, double value)
-{
+{
overlayPanel->getCurrentFusionInfo(visibility,value);
}
//------------------------------------------------------------------------------
//or when UpdateWindowLevel() is called ; when slicerManager emits WindowLevelChanged
//when ImageInfoChanged() is called
void vvMainWindow::WindowLevelChanged()
-{
+{
// Base image
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if(index==-1) return;
//------------------------------------------------------------------------------
void vvMainWindow::WindowLevelEdited()
-{
+{
presetComboBox->setCurrentIndex(WL_USER);
UpdateWindowLevel();
}
//------------------------------------------------------------------------------
void vvMainWindow::SetWindowLevel(double w, double l)
-{
+{
windowSpinBox->setValue(w);
levelSpinBox->setValue(l);
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateWindowLevel()
-{
+{
if (DataTree->selectedItems().size()) {
if (presetComboBox->currentIndex() == WL_VENTILATION) //For ventilation
colorMapComboBox->setCurrentIndex(5);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlicingPreset()
-{
+{
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
//------------------------------------------------------------------------------
void vvMainWindow::UpdateColorMap()
-{
+{
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetColorMap(colorMapComboBox->currentIndex());
}
//------------------------------------------------------------------------------
void vvMainWindow::SwitchWindowLevel()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
int window = mSlicerManagers[index]->GetColorWindow();
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::ApplyWindowLevelToAllImages()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if(index==-1) return;
double window = mSlicerManagers[index]->GetColorWindow();
//------------------------------------------------------------------------------
void vvMainWindow::ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax)
-{
+{
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
+ SetWindowLevel(window, mSlicerManagers[i]->GetColorLevel());
mSlicerManagers[i]->SetColorWindow(window);
mSlicerManagers[i]->SetPreset(WL_USER);
mSlicerManagers[i]->Render();
//------------------------------------------------------------------------------
void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
-{
+{
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
+ SetWindowLevel(mSlicerManagers[i]->GetColorWindow(), level);
mSlicerManagers[i]->SetColorLevel(level);
mSlicerManagers[i]->SetPreset(WL_USER);
mSlicerManagers[i]->Render();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i]->GetId() == id) {
mSlicerManagers[i]->GetSlicer(slicer)->SetCurrentPosition(x,y,z,temps);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkedNavigation(std::string id, vvSlicerManager * sm, vvSlicer* refSlicer)
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (id == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->UpdateLinkedNavigation(refSlicer);
//------------------------------------------------------------------------------
void vvMainWindow::ShowContextMenu(QPoint point)
-{
+{
if (!DataTree->selectedItems().size()) {
contextActions[1]->setEnabled(0);
contextActions[2]->setEnabled(0);
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage()
-{
+{
CloseImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage()
-{
+{
ReloadImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SelectOverlayImage()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+ if (!(CheckAddedImage(index, "overlay")))
+ return;
+
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
+ if (files.isEmpty())
+ return;
+
+ std::vector<std::string> vecFileNames;
+ for (int i = 0; i < files.size(); i++) {
+ vecFileNames.push_back(files[i].toStdString());
+ }
+
+ AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+bool vvMainWindow::CheckAddedImage(int index, QString imageType)
+{
//check if one overlay image is added
for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
- if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "overlay") {
+ if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString().compare(imageType) == 0) {
QString error = "Cannot add more than one compared image\n";
error += "Please remove first ";
error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
QMessageBox::information(this,tr("Problem adding compared image !"),error);
- return;
+ return false;
}
-
- QString Extensions = EXTENSIONS;
- Extensions += ";;All Files (*)";
- QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
- if (files.isEmpty())
- return;
-
- std::vector<std::string> vecFileNames;
- for (int i = 0; i < files.size(); i++) {
- vecFileNames.push_back(files[i].toStdString());
- }
- AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
+ return true;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("overlay").c_str());
qApp->processEvents();
+#if VTK_MAJOR_VERSION > 5
+ for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+#endif
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
//------------------------------------------------------------------------------
void vvMainWindow::AddROI(int index, QString file)
-{
+{
/*
// Get slice manager
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionImage()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
- //check if one fusion image is added
- for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
- if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
- (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
- QString error = "Cannot add more than one fusion image\n";
- error += "Please remove first ";
- error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
- QMessageBox::information(this,tr("Problem adding fusion image !"),error);
- return;
- }
+ if (!(CheckAddedImage(index, "fusion")) || !(CheckAddedImage(index, "fusionSequence")))
+ return;
- QString Extensions = EXTENSIONS;
- Extensions += ";;All Files (*)";
- QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Fusion image"),mInputPathName,Extensions);
- if (files.isEmpty())
- return;
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Fusion image"),mInputPathName,Extensions);
+ if (files.isEmpty())
+ return;
- std::vector<std::string> vecFileNames;
- for (int i = 0; i < files.size(); i++) {
- vecFileNames.push_back(files[i].toStdString());
- }
- AddFusionImage(index,vecFileNames,vvImageReader::IMAGE);
+ std::vector<std::string> vecFileNames;
+ for (int i = 0; i < files.size(); i++) {
+ vecFileNames.push_back(files[i].toStdString());
+ }
+ AddFusionImage(index,vecFileNames,vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ResetTransformationToIdentity()
-{
+{
std::string actorType = DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString().toStdString();
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->ResetTransformationToIdentity(actorType);
//------------------------------------------------------------------------------
void vvMainWindow::AddFusionImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
qApp->processEvents();
-
+#if VTK_MAJOR_VERSION > 5
+ for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+#endif
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddLandmarks(int index, std::vector<std::string> files)
-{
+{
if (!landmarksPanel->LoadFromFile(files))
QMessageBox::information(this,tr("Problem reading Landmarks !"),"File doesn't exist!");
//------------------------------------------------------------------------------
void vvMainWindow::OpenField()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
- //check if a vector field has already been added
- for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
- if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "vector") {
- QString error = "Cannot add more than one vector field\n";
- error += "Please remove first ";
- error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
- QMessageBox::information(this,tr("Problem adding vector field!"),error);
- return;
- }
+
+ if (!(CheckAddedImage(index, "vector")))
+ return;
- QString Extensions = "Images ( *.mhd *.mha *.vf *.nii *.nrrd *.nhdr)";
- // Extensions += ";;Images ( *.mha)";
- // Extensions += ";;VF Images ( *.vf)";
- // Extensions += ";;nii Images ( *.nii)";
- // Extensions += ";;nrrd Images ( *.nrrd)";
- // Extensions += ";;nhdr Images ( *.nhdr)";
- Extensions += ";;All Files (*)";
- QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
- if (!file.isEmpty())
- AddField(file,index);
+ QString Extensions = "Images ( *.mhd *.mha *.vf *.nii *.nrrd *.nhdr)";
+ // Extensions += ";;Images ( *.mha)";
+ // Extensions += ";;VF Images ( *.vf)";
+ // Extensions += ";;nii Images ( *.nii)";
+ // Extensions += ";;nrrd Images ( *.nrrd)";
+ // Extensions += ";;nhdr Images ( *.nhdr)";
+ Extensions += ";;All Files (*)";
+ QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
+ if (!file.isEmpty())
+ AddField(file,index);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddFieldEntry(QString filename,int index,bool from_disk)
-{
+{
//create an item in the tree with good settings
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,filename.toStdString().c_str());
//------------------------------------------------------------------------------
void vvMainWindow::AddField(vvImage::Pointer vf,QString file,int index)
-{
+{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
vvSlicerManager* imageManager = mSlicerManagers[index];
if (imageManager->SetVF(vf,file.toStdString())) {
AddFieldEntry(file,index,false);
+#if VTK_MAJOR_VERSION > 5
+ for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+#endif
} else {
QString error = "Cannot import the vector field for this image.\n";
error += imageManager->GetLastError().c_str();
//------------------------------------------------------------------------------
void vvMainWindow::AddField(QString file,int index)
-{
+{
if (QFile::exists(file)) {
mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
//------------------------------------------------------------------------------
void vvMainWindow::SetVFProperty(int subsampling, int scale, int log, int width, double r, double g, double b)
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
for (int i = 0; i < 4; i++) {
//------------------------------------------------------------------------------
void vvMainWindow::SetOverlayProperty(int color, int linked, double window, double level)
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay()) {
mSlicerManagers[index]->SetOverlayColor(color);
//------------------------------------------------------------------------------
void vvMainWindow::SetFusionProperty(int opacity, int thresOpacity, int colormap,double window, double level, bool showLegend)
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
mSlicerManagers[index]->SetFusionColorMap(colormap);
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionSequence()
-{
+{
//get the index of the slicer manager of the main sequence (CT)
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
- //check if one overlay image is already associated
- for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
- if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
- (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
- QString error = "Cannot add more than one compared image\n";
- error += "Please remove first ";
- error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
- QMessageBox::information(this,tr("Problem adding compared image !"),error);
- return;
- }
- QString Extensions = EXTENSIONS;
- Extensions += ";;All Files (*)";
- QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image sequence"),mInputPathName,Extensions);
- if (files.isEmpty())
- return;
+ if (!(CheckAddedImage(index, "fusion")) || !(CheckAddedImage(index, "fusionSequence")))
+ return;
- std::vector<std::string> vecFileNames;
- for (int i = 0; i < files.size(); i++) {
- vecFileNames.push_back(files[i].toStdString());
- }
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image sequence"),mInputPathName,Extensions);
+ if (files.isEmpty())
+ return;
- //associate the secondary sequence (US) to the main one
- AddFusionSequence(index,vecFileNames,vvImageReader::MERGEDWITHTIME);
+ std::vector<std::string> vecFileNames;
+ for (int i = 0; i < files.size(); i++) {
+ vecFileNames.push_back(files[i].toStdString());
+ }
+
+ //associate the secondary sequence (US) to the main one
+ AddFusionSequence(index,vecFileNames,vvImageReader::MERGEDWITHTIME);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvMainWindow::SelectFusionSequenceCorrespondances() {
-
+void vvMainWindow::SelectFusionSequenceCorrespondances()
+{
//make sure the index is right?
//in the end, I should attach the temporal data to the right sequence!
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
bool signalOK = true;
unsigned nbFrameMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
unsigned nbFrameSecondary = mSlicerManagers[index]->GetFusionSequenceNbFrames();
-std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
+ std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
std::vector<unsigned> temporalCorrespondances;
if ( tmpVect.size() == nbFrameMain + nbFrameSecondary ) {
for (unsigned i=0 ; i<tmpVect.size() ; i++) {
//when this function is called index is the slicer manager index corresponding to the main sequence (CT)
//the files behind fileNames points to the data for the secondary sequence
void vvMainWindow::AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusionSequence").c_str());
qApp->processEvents();
+#if VTK_MAJOR_VERSION > 5
+ for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+#endif
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
}
//------------------------------------------------------------------------------
//fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
//------------------------------------------------------------------------------
void vvMainWindow::SaveAs()
-{
+{
if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
QMessageBox::warning(this,tr("Unsupported type"),tr("Sorry, saving a vector field is unsupported for the moment"));
return;
//------------------------------------------------------------------------------
void vvMainWindow::SaveCurrentState()
-{
+{
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save Current Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::SaveCurrentStateAs(const std::string& stateFile)
-{
+{
vvSaveState save_state;
save_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedState()
-{
+{
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getOpenFileName(this,
tr("Load Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedStateFile(const std::string& stateFile)
-{
+{
vvReadState read_state;
read_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::LinkAllImages()
-{
+{
linkPanel->linkAll();
}
//------------------------------------------------------------------------------
void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
-{
+{
if (!fromPanel) {
// delegate to linkPanel if call came from elsewhere...
linkPanel->addLinkFromIds(image1, image2);
//------------------------------------------------------------------------------
void vvMainWindow::RemoveLink(QString image1,QString image2)
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->RemoveLink(image2.toStdString());
//------------------------------------------------------------------------------
void vvMainWindow::ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset)
-{
+{
if(mSlicerManagers.size()==1)
return;
}
//------------------------------------------------------------------------------
void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (DataTree->topLevelItem(i)->data(column,Qt::CheckStateRole).toInt() > 1) {
//i is the SlicerManager that is in charge of this slicer.
//------------------------------------------------------------------------------
void vvMainWindow::NOHorizontalSliderMoved()
-{
+{
// if (mCurrentTime == NOHorizontalSlider->value()) return;
HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
// mCurrentTime = NOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEHorizontalSliderMoved()
-{
+{
// if (mCurrentTime == NEHorizontalSlider->value()) return;
HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
// mCurrentTime = NEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOHorizontalSliderMoved()
-{
+{
// if (mCurrentTime == SOHorizontalSlider->value()) return;
HorizontalSliderMoved(SOHorizontalSlider->value(),COLUMN_DL_VIEW,2);
// mCurrentTime = SOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEHorizontalSliderMoved()
-{
+{
// if (mCurrentTime == SEHorizontalSlider->value()) return;
HorizontalSliderMoved(SEHorizontalSlider->value(),COLUMN_DR_VIEW,3);
// mCurrentTime = SEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NOVerticalSliderChanged()
-{
+{
static int value=-1;
if (value == NOVerticalSlider->value()) return;
else value = NOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEVerticalSliderChanged()
-{
+{
static int value=-1;
if (value == NEVerticalSlider->value()) return;
else value = NEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOVerticalSliderChanged()
-{
+{
static int value=-1;
if (value == SOVerticalSlider->value()) return;
else value = SOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEVerticalSliderChanged()
-{
+{
static int value=-1;
if (value == SEVerticalSlider->value()) return;
else value = SEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlice(int slicer, int slice)
-{
+{
// DD("vvMainWindow::UpdateSlice");
// DD(slicer);
// DD(slice);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
-{
+{
//FusionSequence: the slider value should be updated for slicers which show the same sequence as requested
bool doUpdate=false;
if (code==-1) doUpdate=true;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
-{
+{
//int position = int((min+max)/2);
int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
if (slicer == 0) {
//------------------------------------------------------------------------------
void vvMainWindow::SaveNOScreenshot()
-{
+{
SaveScreenshot(NOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveNEScreenshot()
-{
+{
SaveScreenshot(NEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSOScreenshot()
-{
+{
SaveScreenshot(SOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSEScreenshot()
-{
+{
SaveScreenshot(SEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveScreenshotAllSlices()
-{
+{
QVTKWidget *widget = NOViewWidget;
int index = 0;// GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
fn = itksys::SystemTools::GetFilenamePath(filename.toStdString()) + "/"+ fn
+ "_" + num + itksys::SystemTools::GetFilenameLastExtension(filename.toStdString());
writer->SetFileName(fn.c_str());
+#if VTK_MAJOR_VERSION <= 5
writer->SetInput(windowToImageFilter->GetOutput());
+#else
+ writer->SetInputConnection(windowToImageFilter->GetOutputPort());
+#endif
writer->Write();
}
}
//------------------------------------------------------------------------------
void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
-{
+{
QString Extensions = "Images( *.png);;";
Extensions += "Images( *.jpg);;";
Extensions += "Images( *.bmp);;";
// Snapshot image if not null
if(imgwriter!=NULL) {
+#if VTK_MAJOR_VERSION <= 5
imgwriter->SetInput(image);
+#else
+ imgwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
imgwriter->SetFileName(fileName.toStdString().c_str());
imgwriter->Write();
return;
// FPS
bool ok;
- int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
+ int fps = QInputDialog::getInt(this, tr("Number of frames per second"),
tr("FPS:"), 5, 0, 1000, 1, &ok);
if(ok)
gif->SetRate(fps);
// Loops
- int loops = QInputDialog::getInteger(this, tr("Loops"),
+ int loops = QInputDialog::getInt(this, tr("Loops"),
tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
if(ok)
gif->SetLoops(loops);
// Take video if not null
if(vidwriter!=NULL){
+#if VTK_MAJOR_VERSION <= 5
vidwriter->SetInput(image);
+#else
+ vidwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
vidwriter->SetFileName(fileName.toStdString().c_str());
vidwriter->Start();
int nSlice = mSlicerManagers[smIndex]->GetSlicer(0)->GetTMax();
vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
w2i->SetInput(widget->GetRenderWindow());
w2i->Update();
+#if VTK_MAJOR_VERSION <= 5
vidwriter->SetInput(w2i->GetOutput());
+#else
+ vidwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
vidwriter->Write();
}
vidwriter->End();
//------------------------------------------------------------------------------
void vvMainWindow::GoToCursor()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
for (int column = 1; column < 5; column++) {
if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
//------------------------------------------------------------------------------
void vvMainWindow::GoToLandmark()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
for (int column = 1; column < 5; column++) {
if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
//------------------------------------------------------------------------------
void vvMainWindow::PlayPause()
-{
+{
if (playMode) {
playMode = 0;
playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_play.png")));
//------------------------------------------------------------------------------
void vvMainWindow::PlayNext()
-{
+{
if (playMode && !this->isHidden()) {
int image_number=DataTree->topLevelItemCount();
///Only play one slicer per SM, and only if the SM is being displayed
//------------------------------------------------------------------------------
void vvMainWindow::ShowLastImage()
-{
+{
if (mSlicerManagers.size() > 1) {
QTreeWidgetItem * item=DataTree->topLevelItem(DataTree->topLevelItemCount()-1);
CurrentImageChanged(mSlicerManagers.back()->GetId()); //select new image
item->setData(1,Qt::CheckStateRole,2); //show the new image in the first panel
+ //mSlicerManagers[GetSlicerIndexFromItem(item)]->GetSlicer(0)->SetActorVisibility("image", 0, 1); //Set the Last Image visibles
DisplayChanged(item,1);
}
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateRenderWindows()
-{
+{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
- mSlicerManagers[i]->GetSlicer(0)->UpdateLandmarks();
- mSlicerManagers[i]->GetSlicer(1)->UpdateLandmarks();
- mSlicerManagers[i]->GetSlicer(2)->UpdateLandmarks();
- mSlicerManagers[i]->GetSlicer(3)->UpdateLandmarks();
+ for (unsigned int j = 0; j < 4; ++j) {
+ mSlicerManagers[i]->GetSlicer(j)->RemoveLandmarks();
+ mSlicerManagers[i]->GetSlicer(j)->DisplayLandmarks();
+ }
}
if (NOViewWidget->GetRenderWindow()) NOViewWidget->GetRenderWindow()->Render();
if (NEViewWidget->GetRenderWindow()) NEViewWidget->GetRenderWindow()->Render();
//------------------------------------------------------------------------------
void vvMainWindow::SegmentationOnCurrentImage()
-{
+{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvSegmentationDialog segmentation;
//------------------------------------------------------------------------------
void vvMainWindow::SurfaceViewerLaunch()
-{
+{
vvSurfaceViewerDialog surfaceViewer;
surfaceViewer.exec();
}
//------------------------------------------------------------------------------
int vvMainWindow::GetImageDuplicateFilenameNumber(std::string filename)
-{
+{
int number=0;
for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
vvSlicerManager * v = mSlicerManagers[l];
//------------------------------------------------------------------------------
vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filename)
-{
+{
// Change filename if another image exist with the same name
int number = GetImageDuplicateFilenameNumber(filename);
connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
+
+ InitSlicers();
UpdateTree();
qApp->processEvents();
- InitSlicers();
- ShowLastImage();
InitDisplay();
+ ShowLastImage();
qApp->processEvents();
-
// End
ImageInfoChanged();
return slicer_manager;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateCurrentSlicer()
-{
+{
int index = -1;
if (DataTree->selectedItems().size() > 0) {
index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
void LoadImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type);
vvSlicerManager * AddImage(vvImage::Pointer image,std::string filename);
void AddField(QString file,int index);
+ bool CheckAddedImage(int index, QString imageType);
void AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type);
void AddFusionImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type);
void AddROI(int index, QString filename);
#include <itksys/SystemTools.hxx>
// vtk
+#include <vtkVersion.h>
#include <vtkSmartPointer.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
double *bounds=mesh->GetBounds();
vtkSmartPointer<vtkImageData> binary_image=vtkSmartPointer<vtkImageData>::New();
+#if VTK_MAJOR_VERSION <= 5
binary_image->SetScalarTypeToUnsignedChar();
+#endif
///Use the smallest mask in which the mesh fits
// Add two voxels on each side to make sure the mesh fits
double * samp_origin=sample->GetOrigin();
binary_image->SetExtent(0,ceil((bounds[1]-origin[0])/spacing[0]+4),
0,ceil((bounds[3]-origin[1])/spacing[1]+4),
0,ceil((bounds[5]-origin[2])/spacing[2])+4);
+#if VTK_MAJOR_VERSION <= 5
binary_image->AllocateScalars();
+#else
+ binary_image->AllocateScalars(VTK_UNSIGNED_CHAR, 1);
+#endif
memset(binary_image->GetScalarPointer(),0,binary_image->GetDimensions()[0]*binary_image->GetDimensions()[1]*binary_image->GetDimensions()[2]*sizeof(unsigned char));
if (extrude) {
vtkSmartPointer<vtkLinearExtrusionFilter> extrude=vtkSmartPointer<vtkLinearExtrusionFilter>::New();
+#if VTK_MAJOR_VERSION <= 5
extrude->SetInput(mesh);
+#else
+ extrude->SetInputData(mesh);
+#endif
///We extrude in the -slice_spacing direction to respect the FOCAL convention
extrude->SetVector(0, 0, -slice_spacing);
+#if VTK_MAJOR_VERSION <= 5
sts->SetInput(extrude->GetOutput());
- } else
+#else
+ sts->SetInputConnection(extrude->GetOutputPort());
+#endif
+ } else {
+#if VTK_MAJOR_VERSION <= 5
sts->SetInput(mesh);
+#else
+ sts->SetInputData(mesh);
+#endif
+ }
vtkSmartPointer<vtkImageStencil> stencil=vtkSmartPointer<vtkImageStencil>::New();
+#if VTK_MAJOR_VERSION <= 5
stencil->SetStencil(sts->GetOutput());
stencil->SetInput(binary_image);
+#else
+ stencil->SetStencilConnection(sts->GetOutputPort());
+ stencil->SetInputData(binary_image);
+#endif
stencil->Update();
this->AddMask(stencil->GetOutput());
this->RemoveMeshes();
for (std::vector<vtkImageData*>::iterator i=masks.begin(); i!=masks.end(); i++) {
vtkSmartPointer<vtkMarchingCubes> marching = vtkSmartPointer<vtkMarchingCubes>::New();
+#if VTK_MAJOR_VERSION <= 5
marching->SetInput(*i);
+#else
+ marching->SetInputData(*i);
+#endif
marching->SetValue(0,0.5);
marching->Update();
this->AddMesh(marching->GetOutput());
===========================================================================**/
#include "vvMeshActor.h"
#include "clitkCommon.h"
+#include <vtkVersion.h>
#include <vtkPolyDataMapper.h>
#include <vtkMarchingSquares.h>
#include <vtkImageData.h>
mMarching=vtkMarchingSquares::New();
mTimeSlice=time_slice;
- if (static_cast<unsigned int>(time_slice)<mMesh->GetNumberOfMeshes())
+ if (static_cast<unsigned int>(time_slice)<mMesh->GetNumberOfMeshes()) {
+#if VTK_MAJOR_VERSION <= 5
mMarching->SetInput(mMesh->GetMask(time_slice));
- else
+#else
+ mMarching->SetInputData(mMesh->GetMask(time_slice));
+#endif
+ } else {
+#if VTK_MAJOR_VERSION <= 5
mMarching->SetInput(mMesh->GetMask(0));
+#else
+ mMarching->SetInputData(mMesh->GetMask(0));
+#endif
+ }
mMarching->SetValue(0,0.5);
//mMarching->Update();
mMapper=vtkPolyDataMapper::New();
+#if VTK_MAJOR_VERSION <= 5
mMapper->SetInput(mMarching->GetOutput());
+#else
+ mMapper->SetInputConnection(mMarching->GetOutputPort());
+#endif
//The following line allows to display the contour over the image
//(http://www.nabble.com/What-happens-when-two-actors-are-at-the-same-depth--td23175458.html)
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
mActor->GetProperty()->EdgeVisibilityOn();
mActor->GetProperty()->SetEdgeColor(mMesh->r,mMesh->g,mMesh->b);
mActor->GetProperty()->SetLineWidth(2.);
+ mActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
}
void vvMeshActor::SetCutSlice(double slice)
void vvMeshActor::SetTimeSlice(int time)
{
mTimeSlice=time;
- if (static_cast<unsigned int>(time)<mMesh->GetNumberOfMasks())
+ if (static_cast<unsigned int>(time)<mMesh->GetNumberOfMasks()) {
+#if VTK_MAJOR_VERSION <= 5
mMarching->SetInput(mMesh->GetMask(time));
- else
+#else
+ mMarching->SetInputData(mMesh->GetMask(time));
+#endif
+ } else {
+#if VTK_MAJOR_VERSION <= 5
mMarching->SetInput(mMesh->GetMask(0));
+#else
+ mMarching->SetInputData(mMesh->GetMask(0));
+#endif
+ }
SetCutSlice(mCutSlice); //We need to find the new mask cut slice,
//since masks do not all have the same origin
}
#endif
// vtk
+#include <vtkVersion.h>
#include <vtkSmartPointer.h>
#include <vtkAppendPolyData.h>
#include <vtkCellArray.h>
{
std::vector<vvMesh::Pointer> result;
#if GDCM_MAJOR_VERSION == 2
-
-#if CLITK_USE_SYSTEM_GDCM == 0
-
- clitkExceptionMacro("ERROR ! You need to compile vv with itk4 + system_gdcm to use this function");
-
-#endif
-
gdcm::Reader reader;
reader.SetFileName(filename.c_str());
reader.Read();
ids[1] = (ids[0] + 1) % tpoint_number.GetValue(); //0-1,1-2,...,n-1-0
contour->GetLines()->InsertNextCell(2, ids);
}
+#if VTK_MAJOR_VERSION <= 5
append->AddInput(contour);
+#else
+ append->AddInputData(contour);
+#endif
}
else
if (contour_type == "POINT ")
typename FilterType::Pointer warp_filter = FilterType::New();
warp_filter->SetInput(input);
-#if ITK_VERSION_MAJOR >= 4
warp_filter->SetDisplacementField(resampler->GetOutput());
-#else
- warp_filter->SetDeformationField(resampler->GetOutput());
-#endif
warp_filter->SetOutputSpacing(input->GetSpacing());
warp_filter->SetOutputOrigin(input->GetOrigin());
warp_filter->SetOutputSize(input->GetLargestPossibleRegion().GetSize());
--- /dev/null
+#ifndef _OSX_HELPER_
+#define _OSX_HELPER_
+
+// For retina displays, see
+// http://public.kitware.com/pipermail/vtkusers/2015-February/090117.html
+void disableGLHiDPI( long a_id );
+
+#endif
+
--- /dev/null
+#include <Cocoa/Cocoa.h>
+#include "vvOSXHelper.h"
+
+// For retina displays, see
+// http://public.kitware.com/pipermail/vtkusers/2015-February/090117.html
+void disableGLHiDPI( long a_id ){
+ NSView *view = reinterpret_cast<NSView*>( a_id );
+ [view setWantsBestResolutionOpenGLSurface:NO];
+}
+
void vvDicomSeriesSelector::BrowseButtonRelease()
{
QFileDialog dialog(this);
+ QStringList filters;
+ filters << "DICOM files (*.dcm)"
+ << "All files (*)";
dialog.setFileMode(QFileDialog::AnyFile);
- dialog.setFilter("DICOM files (*.dcm); All files (*)");
+ dialog.setNameFilters(filters);
+ //dialog.setFilter(tr("DICOM files (*.dcm); All files (*)"));
mFoldername = dialog.getExistingDirectory(this,
"Select a folder to find DICOM image",
mPreviousPath);
//------------------------------------------------------------------------------
vvROIActor::vvROIActor()
-{
+{
mIsVisible = true;
mIsContourVisible = false;
mOpacity = 0.5;
//------------------------------------------------------------------------------
vvROIActor::~vvROIActor()
-{
+{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::RemoveActors()
-{
+{
for(unsigned int i= 0; i<mOverlayActors.size(); i++) {
mOverlayActors[i]->RemoveActors();
}
}
Update(true);
- mImageContour.clear();
- mOverlayActors.clear();
+ //mImageContour.clear();
+ //mOverlayActors.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::SetROI(clitk::DicomRT_ROI * s)
-{
+{
mROI = s;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetContourWidth(int n) {
+void vvROIActor::SetContourWidth(int n)
+{
mContourWidth = n;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetSlicerManager(vvSlicerManager * s) {
+void vvROIActor::SetSlicerManager(vvSlicerManager * s)
+{
mSlicerManager = s;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::UpdateImage()
-{
+{
mOverlayActors.clear();
mImageContour.clear();
Initialize(mDepth, mIsVisible);
//------------------------------------------------------------------------------
void vvROIActor::SetVisible(bool b)
-{
+{
mIsVisible = b;
if (!b) { // remove actor
for(unsigned int i= 0; i<mOverlayActors.size(); i++)
//------------------------------------------------------------------------------
-void vvROIActor::SetContourVisible(bool b) {
+void vvROIActor::SetContourVisible(bool b)
+{
mIsContourVisible = b;
if (!b) { // remove actor
for(unsigned int i= 0; i<mImageContour.size(); i++) {
//------------------------------------------------------------------------------
-bool vvROIActor::IsVisible() {
+bool vvROIActor::IsVisible()
+{
return mIsVisible;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-bool vvROIActor::IsContourVisible() {
+bool vvROIActor::IsContourVisible()
+{
return mIsContourVisible;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::Initialize(double depth, bool IsVisible) {
+void vvROIActor::Initialize(double depth, bool IsVisible)
+{
if (mROI->GetImage()) {
mImageContour.clear();
mOverlayActors.clear();
mImageContour[i]->SetLineWidth(mContourWidth);
mImageContour[i]->SetPreserveMemoryModeEnabled(true);
mImageContour[i]->SetDepth(mDepth+0.5);
- mImageContour[i]->HideActors();
+ mImageContour[i]->ShowActors();
mOverlayActors.push_back(vvBinaryImageOverlayActor::New());
mOverlayActors[i]->Initialize(IsVisible);
mOverlayActors[i]->SetDepth(mDepth);
}
-
connect(mSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
- //connect(mSlicerManager,SIGNAL(UpdateTSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
+ connect(mSlicerManager,SIGNAL(UpdateTSlice(int,int,int)),this,SLOT(UpdateSlice(int, int, int)));
connect(mSlicerManager, SIGNAL(AVerticalSliderHasChanged(int, int)), SLOT(UpdateSlice(int, int)));
}
}
//------------------------------------------------------------------------------
void vvROIActor::SetDepth(double d)
-{
+{
mDepth = d;
if (!mSlicerManager) return;
for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
//------------------------------------------------------------------------------
void vvROIActor::Update(bool force)
-{
+{
if (!mSlicerManager) return;
for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
UpdateSlice(i, mSlicerManager->GetSlicer(i)->GetSlice(), force);
//------------------------------------------------------------------------------
-void vvROIActor::UpdateSlice(int slicer, int slices, bool force)
-{
+void vvROIActor::UpdateSlice(int slicer, int slices, int force)
+{
if (!mROI->GetImage()) return;
if ((!mIsVisible) && (!mIsContourVisible)) return;
if (!mSlicerManager) {
}
// Refresh overlays
- mOverlayActors[slicer]->UpdateSlice(slicer, slices, force);
+ if (mIsVisible) {
+ mOverlayActors[slicer]->UpdateSlice(slicer, slices, force);
+ }
+ mSlicerManager->GetSlicer(slicer)->Render();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::SetOpacity(double d)
-{
+{
mOpacity = d;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetContourColor(double r, double v, double b) {
+void vvROIActor::SetContourColor(double r, double v, double b)
+{
mContourColor[0] = r;
mContourColor[1] = v;
mContourColor[2] = b;
//------------------------------------------------------------------------------
-void vvROIActor::SetOverlayColor(double r, double v, double b) {
+void vvROIActor::SetOverlayColor(double r, double v, double b)
+{
if (mROI)
mROI->SetDisplayColor(r,v,b);
}
//------------------------------------------------------------------------------
-std::vector<double> & vvROIActor::GetContourColor() {
+std::vector<double> & vvROIActor::GetContourColor()
+{
return mContourColor;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-std::vector<double> & vvROIActor::GetOverlayColor() {
+std::vector<double> & vvROIActor::GetOverlayColor()
+{
return mROI->GetDisplayColor();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::UpdateColor() {
+void vvROIActor::UpdateColor()
+{
for(unsigned int i=0; i<mOverlayActors.size(); i++) {
mOverlayActors[i]->SetOpacity(mOpacity);
mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
//------------------------------------------------------------------------------
double vvROIActor::GetOpacity()
-{
+{
return mOpacity;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::SetSelected(bool b)
-{
+{
mIsSelected = b;
if (b) {
for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
//------------------------------------------------------------------------------
void vvROIActor::CopyParameters(QSharedPointer<vvROIActor> roi)
-{
+{
// Overlay
SetVisible(roi->IsVisible());
SetOpacity(roi->GetOpacity());
void RemoveActors();
public slots:
- void UpdateSlice(int slicer, int slices, bool force=false);
+ void UpdateSlice(int slicer, int slices, int force=0);
void UpdateColor();
void UpdateImage();
#include "vvRegisterForm.h"
#include <QNetworkRequest>
#include <QDir>
+#if QT_VERSION >= 0x050000
+#include <QUrlQuery>
+#endif
#include <QPalette>
#include "clitkConfiguration.h"
#include "vvConfiguration.h"
void vvRegisterForm::sendData(){
QUrl url2(url);
+
+#if QT_VERSION < 0x050000
url2.addQueryItem("name", firstName->text().toUtf8());
url2.addQueryItem("lastName", lastName->text().toUtf8());
url2.addQueryItem("email", email->text().toUtf8());
url2.addQueryItem("architecture", ARCHITECTURE);
url2.addQueryItem("adressing", QString::number(sizeof(char*)*8)+"-bit");
url2.addQueryItem("compilationDate", QString(__DATE__) + ", " + QString(__TIME__) );
-
+#else
+ QUrlQuery url2Query;
+
+ url2Query.addQueryItem("name", firstName->text().toUtf8());
+ url2Query.addQueryItem("lastName", lastName->text().toUtf8());
+ url2Query.addQueryItem("email", email->text().toUtf8());
+ url2Query.addQueryItem("group", group->text().toUtf8());
+ url2Query.addQueryItem("os", OS_NAME);
+ url2Query.addQueryItem("vvVersion", VV_VERSION);
+ url2Query.addQueryItem("architecture", ARCHITECTURE);
+ url2Query.addQueryItem("adressing", QString::number(sizeof(char*)*8)+"-bit");
+ url2Query.addQueryItem("compilationDate", QString(__DATE__) + ", " + QString(__TIME__) );
+ url2.setQuery(url2Query);
+#endif
+
manager->get(QNetworkRequest(url2));
}
void vvRegisterForm::accept(){
#include "vvInteractorStyleNavigator.h"
#include "vvSlicer.h"
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include "vtkMarchingCubes.h"
#include "vtkMarchingSquares.h"
#include "vtkImageClip.h"
#include <vtkPolyDataWriter.h>
#include <QMessageBox>
+#include <QFileDialog>
+
+#ifdef Q_OS_OSX
+# include "vvOSXHelper.h"
+#endif
//====================================================================
vvSegmentationDialog::vvSegmentationDialog(QWidget * parent, Qt::WindowFlags f)
erodeButton->setEnabled(0);
dilateButton->setEnabled(0);
infoLabel->setText("Select Up and Down threshold before clicking binarise !");
+
+#ifdef Q_OS_OSX
+ disableGLHiDPI(viewWidget->winId());
+#endif
}
vvSegmentationDialog::~vvSegmentationDialog()
clipping1Slider->setValue(range[0]);
clipping2Slider->setValue(range[1]);
+#if VTK_MAJOR_VERSION <= 5
mClipper->SetInput(mManager->GetSlicer(0)->GetInput());
+#else
+ mClipper->SetInputData(mManager->GetSlicer(0)->GetInput());
+#endif
mSquares1->SetValue(0,clipping1Slider->value());
mSquares2->SetValue(0,clipping2Slider->value());
+
+#if VTK_MAJOR_VERSION <= 5
mSquares1->SetInput(mClipper->GetOutput());
mSquares2->SetInput(mClipper->GetOutput());
mSquaresMapper1->SetInput(mSquares1->GetOutput());
mSquaresMapper2->SetInput(mSquares2->GetOutput());
+#else
+ mSquares1->SetInputData(mClipper->GetOutput());
+ mSquares2->SetInputData(mClipper->GetOutput());
+
+ mSquaresMapper1->SetInputData(mSquares1->GetOutput());
+ mSquaresMapper2->SetInputData(mSquares2->GetOutput());
+#endif
mSquaresMapper1->ScalarVisibilityOff();
mSquaresMapper2->ScalarVisibilityOff();
{
int slice = mManager->GetSlicer(0)->GetSlice();
int tslice = mManager->GetSlicer(0)->GetTSlice();
+#if VTK_MAJOR_VERSION <= 5
mClipper->SetInput(mManager->GetSlicer(0)->GetInput());
+#else
+ mClipper->SetInputData(mManager->GetSlicer(0)->GetInput());
+#endif
int* extent = mManager->GetSlicer(0)->GetImageActor()->GetDisplayExtent();
mClipper->SetOutputWholeExtent(extent[0],extent[1],extent[2],extent[3],extent[4],extent[5]);
int i;
for (unsigned int numImage = 0; numImage < mManager->GetSlicer(0)->GetImage()->GetVTKImages().size(); numImage++) {
vtkImageData* image = mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage];
int ext[6];
+#if VTK_MAJOR_VERSION <= 5
image->GetWholeExtent(ext);
+#else
+ image->GetExtent(ext);
+#endif
void *in1Ptr;
in1Ptr = image->GetScalarPointerForExtent(ext);
outputImage->SetExtent(ext);
outputImage->SetOrigin(image->GetOrigin());
outputImage->SetSpacing(image->GetSpacing());
+#if VTK_MAJOR_VERSION <= 5
outputImage->SetScalarTypeToUnsignedChar();
+#else
+ outputImage->AllocateScalars(VTK_UNSIGNED_CHAR, 1);
+#endif
outputImage->CopyAndCastFrom(image,ext);
+#if VTK_MAJOR_VERSION <= 5
outputImage->Update();
+#else
+ //outputImage->Update();
+#endif
image->DeepCopy(outputImage);
+#if VTK_MAJOR_VERSION <= 5
image->UpdateInformation();
image->PropagateUpdateExtent();
+#else
+ //image->UpdateInformation();
+ //image->PropagateUpdateExtent();
+#endif
vtkImageData* imageBin = vtkImageData::New();
imageBin->DeepCopy(image);
+#if VTK_MAJOR_VERSION <= 5
imageBin->Update();
+#else
+ //imageBin->Update();
+#endif
mBinaireImages.push_back(imageBin);
}
erode->SetKernelSize(mKernelValue,mKernelValue,mKernelValue);
for (unsigned int numImage = 0; numImage < mManager->GetSlicer(0)->GetImage()->GetVTKImages().size(); numImage++) {
vtkImageData* image = mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage];
+#if VTK_MAJOR_VERSION <= 5
erode->SetInput(image);
erode->Update();
+#else
+ erode->SetInputData(image);
+ //erode->Update();
+#endif
image->DeepCopy(erode->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
image->Update();
+#else
+ //image->Update();
+#endif
}
erode->Delete();
dilateButton->setEnabled(1);
dilate->SetKernelSize(mKernelValue,mKernelValue,mKernelValue);
for (unsigned int numImage = 0; numImage < mManager->GetSlicer(0)->GetImage()->GetVTKImages().size(); numImage++) {
vtkImageData* image = mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage];
+#if VTK_MAJOR_VERSION <= 5
dilate->SetInput(image);
+#else
+ dilate->SetInputData(image);
+#endif
vtkImageData* mask = mBinaireImages[numImage];
+#if VTK_MAJOR_VERSION <= 5
And->SetInput1(dilate->GetOutput());
And->SetInput2(mask);
+#else
+ And->SetInput1Data(dilate->GetOutput());
+ And->SetInput2Data(mask);
+#endif
And->Update();
image->DeepCopy(And->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
image->Update();
+#else
+ //image->Update();
+#endif
}
And->Delete();
dilate->Delete();
for (unsigned int numImage = 0; numImage < mManager->GetSlicer(0)->GetImage()->GetVTKImages().size(); numImage++) {
vtkImageData* image = mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage];
+#if VTK_MAJOR_VERSION <= 5
seed->SetInput(image);
+#else
+ seed->SetInputData(image);
+#endif
seed->Update();
image->DeepCopy(seed->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
image->Update();
+#else
+ //image->Update();
+#endif
}
seed->Delete();
m3DExtractor->SetValue(0,0.5);
for (unsigned int numImage = 0; numImage < mManager->GetSlicer(0)->GetImage()->GetVTKImages().size(); numImage++) {
vtkActor* actor = vtkActor::New();
+#if VTK_MAJOR_VERSION <= 5
m3DExtractor->SetInput(mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage]);
+#else
+ m3DExtractor->SetInputData(mManager->GetSlicer(0)->GetImage()->GetVTKImages()[numImage]);
+#endif
m3DExtractor->Update();
vtkPolyDataMapper* mapper = vtkPolyDataMapper::New();
+#if VTK_MAJOR_VERSION <= 5
mapper->SetInput(m3DExtractor->GetOutput());
+#else
+ mapper->SetInputData(m3DExtractor->GetOutput());
+#endif
m3DMappers.push_back(mapper);
actor->SetMapper(mapper);
"Mesh Files (*.vtk *.vtp)");
if (!fileName.isEmpty()) {
vtkSmartPointer<vtkPolyDataWriter> w = vtkSmartPointer<vtkPolyDataWriter>::New();
+#if VTK_MAJOR_VERSION <= 5
w->SetInput(m3DExtractor->GetOutput());
+#else
+ w->SetInputData(m3DExtractor->GetOutput());
+#endif
w->SetFileName(fileName.toStdString().c_str());
w->Write();
}
#include "vtkPolyData.h"
#include <vtkPolyDataMapper.h>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QTreeWidget>
//====================================================================
#include "vvGlyphSource.h"
#include "vvGlyph2D.h"
+#include <vtkVersion.h>
+#include <vtkExtentTranslator.h>
+#include <vtkAlgorithm.h>
+#include <vtkExecutive.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include <vtkTextProperty.h>
#include <vtkTextActor.h>
#include <vtkTextSource.h>
#include <vtkImageAccumulate.h>
#include <vtkImageReslice.h>
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+# include <vtkOpenGLImageSliceMapper.h>
# include <vtkImageMapper3D.h>
# include <vtkImageSliceMapper.h>
#endif
-vtkCxxRevisionMacro(vvSlicer, "DummyRevision");
vtkStandardNewMacro(vvSlicer);
static void copyExtent(int* in, int* to){
- for(int i=0; i<6; ++i) to[i]=in[i];
+ for(int i=0; i<6; ++i)
+ {
+ to[i]=in[i];
+ }
}
//------------------------------------------------------------------------------
vvSlicer::vvSlicer()
-{
+{
mFusionSequenceCode = -1;
this->UnInstallPipeline();
mImage = NULL;
mReducedExtent = new int[6];
+ mRegisterExtent = NULL;
mCurrentTSlice = 0;
mCurrentFusionTSlice = 0;
mCurrentOverlayTSlice = 0;
crossCursor->SetRadius(2);
pdm = vtkSmartPointer<vtkPolyDataMapper2D>::New();
+#if VTK_MAJOR_VERSION <= 5
pdm->SetInput(crossCursor->GetOutput());
+#else
+ pdm->SetInputConnection(crossCursor->GetOutputPort(0));
+#endif
pdmA = vtkSmartPointer<vtkActor2D>::New();
pdmA->SetMapper(pdm);
//------------------------------------------------------------------------------
vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper()
-{
+{
return mOverlayMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvBlendImageActor* vvSlicer::GetOverlayActor()
-{
+{
return mOverlayActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageMapToColors* vvSlicer::GetFusionMapper()
-{
+{
return mFusionMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageActor* vvSlicer::GetFusionActor()
-{
+{
return mFusionActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkActor* vvSlicer::GetVFActor()
-{
+{
return mVFActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkCornerAnnotation* vvSlicer::GetAnnotation()
-{
+{
return ca.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::EnableReducedExtent(bool b)
-{
+{
mUseReducedExtent = b;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetReducedExtent(int * ext)
-{
+{
copyExtent(ext, mReducedExtent);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
-{
+{
mSurfaceCutActors.push_back(new vvMeshActor());
if (propagate)
//------------------------------------------------------------------------------
void vvSlicer::ToggleContourSuperposition()
-{
+{
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
(*i)->ToggleSuperposition();
//------------------------------------------------------------------------------
void vvSlicer::SetCursorColor(int r,int g, int b)
-{
+{
pdmA->GetProperty()->SetColor(r,g,b);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCursorVisibility(bool s)
-{
+{
pdmA->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCursorVisibility()
-{
+{
return pdmA->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCornerAnnotationVisibility(bool s)
-{
+{
ca->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCornerAnnotationVisibility()
-{
+{
return ca->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvSlicer::~vvSlicer()
-{
+{
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
delete (*i);
//------------------------------------------------------------------------------
double* vvSlicer::GetCurrentPosition()
-{
+{
return mCurrentBeforeSlicingTransform;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
-{
+{
mCurrentBeforeSlicingTransform[0]=x;
mCurrentBeforeSlicingTransform[1]=y;
mCurrentBeforeSlicingTransform[2]=z;
//------------------------------------------------------------------------------
void vvSlicer::SetImage(vvImage::Pointer image)
-{
+{
if (image->GetVTKImages().size()) {
mImage = image;
mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
mConcatenatedTransform->Concatenate(mSlicingTransform);
mImageReslice->SetResliceTransform(mConcatenatedTransform);
+#if VTK_MAJOR_VERSION <= 5
mImageReslice->SetInput(0, mImage->GetFirstVTKImageData());
+#else
+ mImageReslice->SetInputData(0, mImage->GetFirstVTKImageData());
+#endif
mImageReslice->UpdateInformation();
+#if VTK_MAJOR_VERSION <= 5
this->Superclass::SetInput(mImageReslice->GetOutput());
+#else
+ this->Superclass::SetInputConnection(mImageReslice->GetOutputPort());
+#endif
int extent[6];
+#if VTK_MAJOR_VERSION <= 5
this->GetInput()->GetWholeExtent(extent);
+#else
+ int* ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
+ copyExtent(ext, extent);
+#endif
// Prevent crash when reload -> change slice if outside extent
if (Slice < extent[SliceOrientation*2] || Slice>=extent[SliceOrientation*2+1]) {
// Make sure that the required part image has been computed
extent[SliceOrientation*2] = Slice;
- extent[SliceOrientation*2+1] = Slice;
+ extent[SliceOrientation*2+1] = Slice;
+#if VTK_MAJOR_VERSION <= 5
mImageReslice->GetOutput()->SetUpdateExtent(extent);
mImageReslice->GetOutput()->Update();
+#else
+ //mImageReslice->SetUpdateExtent(extent);
+ mImageReslice->Update();
+#endif
this->UpdateDisplayExtent();
//------------------------------------------------------------------------------
void vvSlicer::SetOverlay(vvImage::Pointer overlay)
-{
+{
if (overlay->GetVTKImages().size()) {
mOverlay = overlay;
mOverlayVisibility = true;
mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[0]);
mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform);
+#if VTK_MAJOR_VERSION <= 5
mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
mImageReslice->UpdateInformation();
+#else
+ mOverlayReslice->SetInputData(0, mOverlay->GetFirstVTKImageData());
+#endif
+ mOverlayReslice->Update();
if (!mOverlayMapper)
mOverlayMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+#if VTK_MAJOR_VERSION <= 5
mOverlayMapper->SetInput(mOverlayReslice->GetOutput());
+#else
+ mOverlayMapper->SetInputConnection(mOverlayReslice->GetOutputPort(0));
+#endif
if (!mOverlayActor) {
mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
+#if VTK_MAJOR_VERSION <= 5
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
+#else
+ mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
+#endif
mOverlayActor->SetPickable(0);
mOverlayActor->SetVisibility(true);
mOverlayActor->SetOpacity(0.5);
//------------------------------------------------------------------------------
void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
-{
+{
mFusionSequenceCode = fusionSequenceCode;
if (fusion->GetVTKImages().size()) {
mFusion = fusion;
mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[0]);
mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform);
+#if VTK_MAJOR_VERSION <= 5
mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
mFusionReslice->UpdateInformation();
+#else
+ mFusionReslice->SetInputData(0, mFusion->GetFirstVTKImageData());
+#endif
+ mFusionReslice->Update();
if (!mFusionMapper)
mFusionMapper = vtkSmartPointer<vtkImageMapToColors>::New();
lut->SetSaturationRange(0, 0);
lut->Build();
mFusionMapper->SetLookupTable(lut);
+#if VTK_MAJOR_VERSION <= 5
mFusionMapper->SetInput(mFusionReslice->GetOutput());
-
+#else
+ mFusionMapper->SetInputConnection(mFusionReslice->GetOutputPort(0));
+#endif
+
if (!mFusionActor) {
mFusionActor = vtkSmartPointer<vtkImageActor>::New();
+#if VTK_MAJOR_VERSION <= 5
mFusionActor->SetInput(mFusionMapper->GetOutput());
+#else
+ mFusionActor->GetMapper()->SetInputConnection(mFusionMapper->GetOutputPort());
+#endif
mFusionActor->SetPickable(0);
mFusionActor->SetVisibility(true);
mFusionActor->SetOpacity(0.7);
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
mFusionActor->GetMapper()->BorderOn();
#endif
+
this->GetRenderer()->AddActor(mFusionActor);
}
//------------------------------------------------------------------------------
bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
-{
+{
bool vis = false;
if (actor_type == "image")
vis = mImageVisibility;
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
-{
+{
if (actor_type == "image")
mImageVisibility = vis;
else if (actor_type == "vector")
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
-{
+{
if (vf->GetVTKImages().size()) {
mVF = vf;
mVFVisibility = true;
mVOIFilter = vtkSmartPointer<vtkExtractVOI>::New();
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
}
+#if VTK_MAJOR_VERSION <= 5
mVOIFilter->SetInput(vf->GetFirstVTKImageData());
mAAFilter->SetInput(mVOIFilter->GetOutput());
+#else
+ mVOIFilter->SetInputData(vf->GetFirstVTKImageData());
+ mAAFilter->SetInputConnection(mVOIFilter->GetOutputPort());
+#endif
///This tells VTK to use the scalar (pixel) data of the image to draw the little arrows
mAAFilter->Assign(vtkDataSetAttributes::SCALARS, vtkDataSetAttributes::VECTORS, vtkAssignAttribute::POINT_DATA);
// Glyph the gradient vector (with arrows)
if (!mGlyphFilter)
mGlyphFilter = vtkSmartPointer<vvGlyph2D>::New();
+#if VTK_MAJOR_VERSION <= 5
mGlyphFilter->SetInput(mAAFilter->GetOutput());
mGlyphFilter->SetSource(mArrow->GetOutput());
+#else
+ mGlyphFilter->SetInputConnection(mAAFilter->GetOutputPort());
+ mGlyphFilter->SetSourceConnection(mArrow->GetOutputPort());
+#endif
mGlyphFilter->ScalingOn();
mGlyphFilter->SetScaleModeToScaleByVector();
mGlyphFilter->OrientOn();
if (!mVFMapper)
mVFMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+#if VTK_MAJOR_VERSION <= 5
mVFMapper->SetInput(mGlyphFilter->GetOutput());
+#else
+ mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
+#endif
mVFMapper->ImmediateModeRenderingOn();
mVFMapper->SetLookupTable(mVFColorLUT);
//------------------------------------------------------------------------------
void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
-{
+{
mLandmarks = landmarks;
if (landmarks) {
mLandClipper->SetClipFunction(mClipBox);
mLandClipper->InsideOutOn();
- mLandClipper->SetInput(mLandmarks->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
+ mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+ mLandmarkTransform->SetInput(mLandmarks->GetOutput());
+ mConcatenatedTransform->Identity();
+ mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+ mConcatenatedTransform->Concatenate(mSlicingTransform);
+ mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
+ mLandClipper->SetInput(mLandmarkTransform->GetOutput());
mLandGlyph->SetSource(mCross->GetOutput());
mLandGlyph->SetInput(mLandClipper->GetOutput());
+#else
+ mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+ mLandmarkTransform->SetInputData(mLandmarks->GetOutput());
+ mConcatenatedTransform->Identity();
+ mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+ mConcatenatedTransform->Concatenate(mSlicingTransform);
+ mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
+ mLandClipper->SetInputConnection(mLandmarkTransform->GetOutputPort());
+
+ mLandGlyph->SetSourceConnection(mCross->GetOutputPort());
+ mLandGlyph->SetInputConnection(mLandClipper->GetOutputPort());
+#endif
//mLandGlyph->SetIndexModeToScalar();
//mLandGlyph->SetRange(0,1);
//mLandGlyph->ScalingOff();
//mLandMapper->ScalarVisibilityOff();
mLandActor->SetMapper(mLandMapper);
+ mLandActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
mLandActor->GetProperty()->SetColor(255,10,212);
mLandActor->SetPickable(0);
mLandActor->SetVisibility(true);
this->UpdateDisplayExtent();
- this->GetRenderer()->AddActor(mLandActor);
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//FIXME: this function leaks memory, we should fix it someday :)
void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index)
-{
+{
if (actor_type == "vector") {
Renderer->RemoveActor(mVFActor);
mGlyphFilter=NULL;
//------------------------------------------------------------------------------
void vvSlicer::SetVFSubSampling(int sub)
-{
+{
if (mVOIFilter) {
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
mSubSampling = sub;
//------------------------------------------------------------------------------
void vvSlicer::SetVFScale(int scale)
-{
+{
mScale = scale;
if (mArrow)
mArrow->SetScale(mScale);
//------------------------------------------------------------------------------
void vvSlicer::SetVFWidth(int width)
-{
+{
mVFWidth = width;
if (mVFActor)
mVFActor->GetProperty()->SetLineWidth(mVFWidth);
//------------------------------------------------------------------------------
void vvSlicer::SetVFLog(int log)
-{
+{
mVFLog = log;
if (mGlyphFilter) {
mGlyphFilter->SetUseLog(mVFLog);
//------------------------------------------------------------------------------
void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
-{
+{
if (!updateLinkedImages) {
mCurrentTSlice = t;
- mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
+#if VTK_MAJOR_VERSION <= 5
+ mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
+#else
+ mImageReslice->SetInputData( mImage->GetVTKImages()[mCurrentTSlice] );
+#endif
// Update transform
mConcatenatedTransform->Identity();
mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]);
UpdateDisplayExtent();
return;
}
-
if (t < 0)
mCurrentTSlice = 0;
else if ((unsigned int)t >= mImage->GetVTKImages().size())
mConcatenatedTransform->Concatenate(mSlicingTransform);
// Update image data
- mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
+#if VTK_MAJOR_VERSION <= 5
+ mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
+#else
+ mImageReslice->SetInputData( mImage->GetVTKImages()[mCurrentTSlice] );
+#endif
if (mVF && mVFActor->GetVisibility()) {
if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
+#if VTK_MAJOR_VERSION <= 5
mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
+#else
+ mVOIFilter->SetInputData(mVF->GetVTKImages()[mCurrentTSlice]);
+#endif
}
//update the overlay
if (mOverlay && mOverlayActor->GetVisibility()) {
if (mOverlay->GetVTKImages().size() > (unsigned int)t) {
mCurrentOverlayTSlice = t;
+#if VTK_MAJOR_VERSION <= 5
mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] );
-
+#else
+ mOverlayReslice->SetInputData( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] );
+#endif
// Update overlay transform
mConcatenatedOverlayTransform->Identity();
mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[mCurrentOverlayTSlice]);
if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode<0)) {
if (mFusion->GetVTKImages().size() > (unsigned int)t) {
mCurrentFusionTSlice = t;
+#if VTK_MAJOR_VERSION <= 5
mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
+#else
+ mFusionReslice->SetInputData( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
+#endif
// Update fusion transform
mConcatenatedFusionTransform->Identity();
//------------------------------------------------------------------------------
void vvSlicer::SetFusionSequenceTSlice(int t)
-{
+{
if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) {
if (mFusion->GetVTKImages().size() > (unsigned int)t) {
mCurrentFusionTSlice = t;
+#if VTK_MAJOR_VERSION <= 5
mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice] );
+#else
+ mFusionReslice->SetInputData( mFusion->GetVTKImages()[mCurrentFusionTSlice] );
+#endif
// Update fusion transform
mConcatenatedFusionTransform->Identity();
mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]); //not really useful...
//------------------------------------------------------------------------------
int vvSlicer::GetTSlice()
-{
+{
return mCurrentTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetMaxCurrentTSlice()
-{
+{
int t = mCurrentTSlice;
if(mOverlay)
t = std::max(t, mCurrentOverlayTSlice);
//------------------------------------------------------------------------------
int vvSlicer::GetFusionTSlice()
-{
+{
return mCurrentFusionTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetOverlayTSlice()
-{
+{
return mCurrentOverlayTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetSliceOrientation(int orientation)
-{
+{
//if 2D image, force to watch in Axial View
int extent[6];
- this->GetInput()->GetWholeExtent(extent);
+#if VTK_MAJOR_VERSION <= 5
+ this->GetInput()->GetWholeExtent(extent);
+#else
+ int* ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
+ copyExtent(ext, extent);
+#endif
+
if (extent[5]-extent[4] <= 2)
orientation = vtkImageViewer2::SLICE_ORIENTATION_XY;
int *range = this->GetSliceRange();
if (range)
this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
- mFirstSetSliceOrientation = false;
+#if VTK_MAJOR_VERSION <= 5
+ mFirstSetSliceOrientation = false;
+#endif
}
else if (this->Renderer && this->GetInput()) {
double s = mCursor[orientation];
}
this->UpdateOrientation();
+
this->UpdateDisplayExtent();
-
+
+ if (mFirstSetSliceOrientation) {
+ mFirstSetSliceOrientation = false;
+ }
+
if (this->Renderer && this->GetInput()) {
double scale = this->Renderer->GetActiveCamera()->GetParallelScale();
this->Renderer->ResetCamera();
// In other words, we change the grid of the reslice in the same way as the grid
// of the displayed image in the slicing direction.
void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice)
-{
+{
// Reset autocrop and update output information
reslice->SetOutputOriginToDefault();
reslice->SetOutputSpacingToDefault();
+#if VTK_MAJOR_VERSION <= 5
reslice->GetOutput()->UpdateInformation();
+#else
+ reslice->UpdateInformation();
+#endif
// Ge new origin / spacing
double origin[3];
reslice->SetOutputOrigin(origin);
reslice->SetOutputSpacing(spacing);
reslice->UpdateInformation();
+#if VTK_MAJOR_VERSION <= 5
reslice->GetOutput()->UpdateInformation();
+#endif
}
//------------------------------------------------------------------------------
//----------------------------------------------------------------------------
-int * vvSlicer::GetExtent(){
+int * vvSlicer::GetExtent()
+{
int *w_ext;
if (mUseReducedExtent) {
w_ext = mReducedExtent;
- } else w_ext = GetInput()->GetWholeExtent();
+ }
+ else {
+#if VTK_MAJOR_VERSION <= 5
+ w_ext = GetInput()->GetWholeExtent();
+#else
+ w_ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
+#endif
+ }
return w_ext;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int vvSlicer::GetOrientation()
-{
+{
return this->SliceOrientation;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::UpdateDisplayExtent()
-{
+{
+ emit UpdateDisplayExtentBegin(mSlicerNumber);
vtkImageData *input = this->GetInput();
if (!input || !this->ImageActor) {
return;
}
+
+#if VTK_MAJOR_VERSION <= 5
input->UpdateInformation();
+#else
+ mRegisterExtent = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
+#endif
this->SetSlice( this->GetSlice() ); //SR: make sure the update let the slice in extents
// Local copy of extent
int w_ext[6];
+#if VTK_MAJOR_VERSION <= 5
int* ext = GetExtent();
+#else
+ int* ext = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
+#endif
copyExtent(ext, w_ext);
+ if (mUseReducedExtent) {
+ copyExtent(mReducedExtent, w_ext);
+ }
// Set slice value
+
w_ext[ this->SliceOrientation*2 ] = this->Slice;
w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
// Image actor
this->ImageActor->SetVisibility(mImageVisibility);
this->ImageActor->SetDisplayExtent(w_ext);
+
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
// Fix for bug #1882
dynamic_cast<vtkImageSliceMapper *>(this->ImageActor->GetMapper())->SetOrientation(this->GetOrientation());
if (mOverlay && mOverlayVisibility) {
AdjustResliceToSliceOrientation(mOverlayReslice);
int overExtent[6];
+#if VTK_MAJOR_VERSION <= 5
this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
+#else
+ this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mOverlayReslice->GetOutput(), overExtent);
+ bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
+#endif
mOverlayActor->SetVisibility(!out);
mOverlayActor->SetDisplayExtent( overExtent );
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
if (mFusion && mFusionVisibility) {
AdjustResliceToSliceOrientation(mFusionReslice);
int fusExtent[6];
+#if VTK_MAJOR_VERSION <= 5
this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
+#else
+ this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mFusionReslice->GetOutput(), fusExtent);
+ bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
+#endif
mFusionActor->SetVisibility(!out);
mFusionActor->SetDisplayExtent( fusExtent );
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
}
else if(mFusion)
mFusionActor->SetVisibility(false);
-
// Vector field actor
double* camera = Renderer->GetActiveCamera()->GetPosition();
double* image_bounds = ImageActor->GetBounds();
if (mVF && mVFVisibility) {
int vfExtent[6];
+#if VTK_MAJOR_VERSION <= 5
mVF->GetVTKImages()[0]->UpdateInformation();
this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent);
bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
+#else
+ //this->UpdateInformation();
+ this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVF->GetVTKImages()[0], vfExtent);
+ bool out = ClipDisplayedExtent(vfExtent, mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
+#endif
mVFActor->SetVisibility(!out);
mVOIFilter->SetVOI(vfExtent);
int orientation[3] = {1,1,1};
orientation[this->SliceOrientation] = 0;
mGlyphFilter->SetOrientation(orientation[0], orientation[1], orientation[2]);
- mVFMapper->Update();
-
position[this->SliceOrientation] += offset;
mVFActor->SetPosition(position);
+ mVFActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
+ mVFMapper->Update();
+
}
else if(mVF)
mVFActor->SetVisibility(false);
+
+
+ double boundsT [6];
+ for(unsigned int i=0; i<6; i++)
+ boundsT[i] = ImageActor->GetBounds()[i];
+ boundsT[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
+ boundsT[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
+
// Landmarks actor
if (mLandActor) {
if (mClipBox) {
- double bounds [6];
- for(unsigned int i=0; i<6; i++)
- bounds[i] = ImageActor->GetBounds()[i];
- bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
- bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
- mClipBox->SetBounds(bounds);
- UpdateLandmarks();
+ RemoveLandmarks();
}
position[this->SliceOrientation] = offset;
cam->SetClippingRange(range - sumSpacing, range + sumSpacing);
}
}
+
+ if (mLandActor) {
+ if (mClipBox) {
+ DisplayLandmarks();
+ }
+ }
+ }
+ emit UpdateDisplayExtentEnd(mSlicerNumber);
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6],
+ vtkImageData *targetImage, int targetExtent[6])
+{
+ double dExtents[6];
+ double *origin, *spacing;
+ origin = sourceImage->Get(vtkDataObject::ORIGIN());
+ spacing = sourceImage->Get(vtkDataObject::SPACING());
+ for(unsigned int i=0; i<6; i++) {
+ // From source voxel coordinates to world coordinates
+ dExtents[i] = origin[i/2] + spacing[i/2] * sourceExtent[i];
+
+ // From world coordinates to floating point target voxel coordinates
+ dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
+
+ // Round to current slice or larger extent
+ if(i/2==this->GetOrientation())
+ targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
+ else if(i%2==1)
+ targetExtent[i] = itk::Math::Ceil<double>(dExtents[i]);
+ else
+ targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
-{
+{
bool out = false;
int maxBound = 6;
//----------------------------------------------------------------------------
void vvSlicer::UpdateOrientation()
-{
+{
// Set the camera position
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
//----------------------------------------------------------------------------
void vvSlicer::SetOpacity(double s)
-{
+{
this->GetImageActor()->SetOpacity(s);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
-{
+{
this->Superclass::SetRenderWindow(rw);
this->SetupInteractor(rw->GetInteractor());
ca->SetImageActor(this->GetImageActor());
bounds[3] = max;
bounds[4] = -max;
bounds[5] = max;
-
crossCursor->SetModelBounds(bounds);
+
this->GetRenderer()->AddActor(pdmA);
this->GetRenderer()->AddActor(ca);
this->GetRenderer()->ResetCamera();
//----------------------------------------------------------------------------
void vvSlicer::ResetCamera()
-{
+{
this->GetRenderer()->ResetCamera();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
-{
+{
this->GetRenderer()->SetDraw(i);
if (i) UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
void vvSlicer::FlipHorizontalView()
-{
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
//----------------------------------------------------------------------------
void vvSlicer::FlipVerticalView()
-{
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
FlipHorizontalView();
//----------------------------------------------------------------------------
void vvSlicer::SetColorWindow(double window)
-{
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double level = this->GetWindowLevel()->GetLevel();
//----------------------------------------------------------------------------
void vvSlicer::SetColorLevel(double level)
-{
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double window = this->GetWindowLevel()->GetWindow();
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorWindow()
-{
+{
if(mOverlayMapper)
return mOverlayMapper->GetWindow();
else
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorLevel()
-{
+{
if(mOverlayMapper)
return mOverlayMapper->GetLevel();
else
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorWindow(double window)
-{
+{
if(mOverlayMapper)
mOverlayMapper->SetWindow(window);
}
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorLevel(double level)
-{
+{
if(mOverlayMapper)
mOverlayMapper->SetLevel(level);
}
//----------------------------------------------------------------------------
// Returns the min an the max value in a 20%x20% region around the mouse pointer
void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform)
-{
+{
//Get mouse pointer position in view coordinates
double corner1[3];
double corner2[3];
if(iLocalExtents[i*2 ]>iLocalExtents[i*2+1])
std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]);
+
+#if VTK_MAJOR_VERSION > 5
+ for(int j=0;j<2; j++) {
+ if(iLocalExtents[i*2+j]< mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i])
+ iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i];
+
+ if(iLocalExtents[i*2+j]> mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1])
+ iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1];
+ }
+#endif
}
vtkSmartPointer<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
+#if VTK_MAJOR_VERSION <= 5
voiFilter->SetInput(image);
+#else
+ voiFilter->SetInputData(image);
+#endif
voiFilter->SetVOI(iLocalExtents);
voiFilter->Update();
if (!voiFilter->GetOutput()->GetNumberOfPoints()) {
}
vtkSmartPointer<vtkImageAccumulate> accFilter = vtkSmartPointer<vtkImageAccumulate>::New();
+#if VTK_MAJOR_VERSION <= 5
accFilter->SetInput(voiFilter->GetOutput());
+#else
+ accFilter->SetInputConnection(voiFilter->GetOutputPort(0));
+#endif
accFilter->Update();
min = *(accFilter->GetMin());
//----------------------------------------------------------------------------
double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int &ix, int &iy, int &iz, int component)
-{
+{
ix = lrint(X);
iy = lrint(Y);
iz = lrint(Z);
-
+#if VTK_MAJOR_VERSION <= 5
if (ix < image->GetWholeExtent()[0] ||
ix > image->GetWholeExtent()[1] ||
iy < image->GetWholeExtent()[2] ||
iz < image->GetWholeExtent()[4] ||
iz > image->GetWholeExtent()[5] )
return std::numeric_limits<double>::quiet_NaN();
-
image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
image->Update();
+#else
+ if (ix < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0] ||
+ ix > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1] ||
+ iy < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2] ||
+ iy > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3] ||
+ iz < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4] ||
+ iz > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5] )
+ return std::numeric_limits<double>::quiet_NaN();
+ //image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
+ //image->Update();
+#endif
+
return image->GetScalarComponentAsDouble(ix, iy, iz, component);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::Render()
-{
+{
if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
legend->UseOpacityOn();
} else legend->SetVisibility(0);
if (ca->GetVisibility()) {
- std::stringstream worldPos;
+
+ std::stringstream worldPos(" ");
double pt[3];
mConcatenatedTransform->TransformPoint(mCurrent, pt);
double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0];
double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1];
double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2];
-
+#if VTK_MAJOR_VERSION <= 5
if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 &&
X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 &&
Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 &&
<< mCurrentTSlice
<< std::endl;
}
+#else
+ if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
+ X <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
+ Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
+ Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
+ Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
+ Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) {
+
+ int ix, iy, iz;
+ double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
+
+ if(ImageActor->GetVisibility())
+ worldPos << "data value : " << value << std::endl;
+
+ worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
+ << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
+ << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
+ << mCurrentTSlice
+ << std::endl;
+ worldPos << "pixel : " << ix << ' '
+ << iy << ' '
+ << iz << ' '
+ << mCurrentTSlice
+ << std::endl;
+
+ }
+#endif
ca->SetText(1,worldPos.str().c_str());
std::stringstream slicePos;
double xCursor = (x - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
-
+#if VTK_MAJOR_VERSION <= 5
if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0]-0.5 &&
xCursor < this->GetImageActor()->GetDisplayExtent()[1]+0.5 &&
yCursor >= this->GetImageActor()->GetDisplayExtent()[2]-0.5 &&
crossCursor->SetFocalPoint(x,y,z);
} else
crossCursor->SetFocalPoint(-1,-1,z);
+ crossCursor->Update();
}
+#else
+ vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+ try {
+ mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(GetImageActor()->GetMapper());
+ } catch (const std::bad_cast& e) {
+ std::cerr << e.what() << std::endl;
+ std::cerr << "Conversion error" << std::endl;
+ return;
+ }
+
+ if (xCursor >= mapperOpenGL->GetCroppingRegion()[0]-0.5 &&
+ xCursor < mapperOpenGL->GetCroppingRegion()[1]+0.5 &&
+ yCursor >= mapperOpenGL->GetCroppingRegion()[2]-0.5 &&
+ yCursor < mapperOpenGL->GetCroppingRegion()[3]+0.5 &&
+ zCursor >= mapperOpenGL->GetCroppingRegion()[4]-0.5 &&
+ zCursor < mapperOpenGL->GetCroppingRegion()[5]+0.5 ) {
+ vtkRenderer * renderer = this->Renderer;
+ renderer->WorldToView(x,y,z);
+ renderer->ViewToNormalizedViewport(x,y,z);
+ renderer->NormalizedViewportToViewport(x,y);
+ renderer->ViewportToNormalizedDisplay(x,y);
+ renderer->NormalizedDisplayToDisplay(x,y);
+ crossCursor->SetFocalPoint(x,y,z);
+ } else
+ crossCursor->SetFocalPoint(-1,-1,z);
+ crossCursor->Update();
+ }
+#endif
if (mOverlay && mOverlayActor->GetVisibility()) {
if(mLinkOverlayWindowLevel) {
mOverlayMapper->SetWindow(this->GetColorWindow());
mOverlayMapper->SetLevel(this->GetColorLevel());
}
+#if VTK_MAJOR_VERSION <= 5
mOverlayMapper->GetOutput()->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
- mOverlayMapper->GetOutput()->Update();
+#else
+ mOverlayMapper->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
+#endif
mOverlayMapper->Update();
}
- if (mLandMapper)
- UpdateLandmarks();
+ if (mFusion && mFusionActor->GetVisibility()) {
+#if VTK_MAJOR_VERSION <= 5
+ mFusionMapper->GetOutput()->SetUpdateExtent(mFusionActor->GetDisplayExtent());
+#else
+ mFusionMapper->SetUpdateExtent(mFusionActor->GetDisplayExtent());
+#endif
+ mFusionMapper->Update();
+ }
+ if (mLandMapper) {
+ RemoveLandmarks();
+ DisplayLandmarks();
+ }
- this->GetRenderWindow()->Render();
+ this->GetRenderWindow()->Render();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
-{
+{
pdmA->SetVisibility(true);
mCursor[0] = mCurrent[0];
mCursor[1] = mCurrent[1];
//----------------------------------------------------------------------------
-void vvSlicer::UpdateLandmarks()
-{
- vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
+void vvSlicer::RemoveLandmarks()
+{
+ vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
if (pd->GetPoints()) {
- //mLandGlyph->SetRange(0,1);
- //mLandGlyph->Modified();
- //mLandGlyph->Update();
- mClipBox->Modified();
- mLandClipper->Update();
- mLandMapper->Update();
- //Let's add the captions
//First remove all captions:
for(unsigned int i=0;i<mLandLabelActors.size();i++) {
this->Renderer->RemoveActor2D(mLandLabelActors[i]);
//allActors2D->Remove (mLandLabelActors[i]);
}
mLandLabelActors.clear();
+ }
+}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicer::DisplayLandmarks()
+{
+
+ double bounds [6];
+ for(unsigned int i=0; i<6; i++)
+ bounds[i] = ImageActor->GetBounds()[i];
+ bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
+ bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
+ mClipBox->SetBounds(bounds);
+
+
+ vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
+ if (pd->GetPoints()) {
+ this->GetRenderer()->AddActor(mLandActor);
+ //mLandGlyph->SetRange(0,1);
+ //mLandGlyph->Modified();
+ //mLandGlyph->Update();
+ mClipBox->Modified();
+ mLandClipper->Update();
+ mLandMapper->Update();
//Next add the captions to the displayed points
for (vtkIdType id=0; id<mLandClipper->GetOutput()->GetNumberOfPoints(); id++) {
double *position = mLandClipper->GetOutput()->GetPoint(id);
//----------------------------------------------------------------------------
void vvSlicer::SetSlice(int slice)
-{
+{
int *range = this->GetSliceRange();
if (range) {
if (slice < range[0]) {
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-int vvSlicer::GetTMax() {
+int vvSlicer::GetTMax()
+{
int tmax = (int)mImage->GetVTKImages().size() - 1;
if(mOverlay)
tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
//----------------------------------------------------------------------------
void vvSlicer::SetContourSlice()
-{
+{
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++) {
//----------------------------------------------------------------------------
void vvSlicer::ForceUpdateDisplayExtent()
-{
+{
this->UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int* vvSlicer::GetDisplayExtent()
-{
+{
return this->GetImageActor()->GetDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
-{
+{
this->Superclass::PrintSelf(os, indent);
}
//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicer::SetVFColor(double r, double g, double b)
-{
+{
double mVFColorHSV[3];
mVFColor[0] = r;
mVFColor[1] = g;
this->Render();
}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicer::SetRegisterExtent(int ext[6])
+{
+ copyExtent(ext, mRegisterExtent);
+}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicer::GetRegisterExtent(int ext[6])
+{
+ copyExtent(mRegisterExtent, ext);
+}
+//----------------------------------------------------------------------------
#include <iostream>
#include <vector>
+#include <QObject>
#include <QString> //TODO delete
#include <QMessageBox>
#include <vtkImageReslice.h>
#include <vtkImageMapToColors.h>
#include <vtkCaptionActor2D.h>
+#include <vtkTransformPolyDataFilter.h>
class vtkActor;
class vtkActor2D;
class vtkTransform;
class vtkImageReslice;
-class vvSlicer: public vtkImageViewer2
-{
+class vvSlicer: public QObject, public vtkImageViewer2 {
+
+Q_OBJECT
+
public:
static vvSlicer *New();
- vtkTypeRevisionMacro(vvSlicer,vtkImageViewer2);
+ vtkTypeMacro(vvSlicer,vtkImageViewer2);
void PrintSelf(ostream& os, vtkIndent indent);
void SetImage(vvImage::Pointer inputImages);
double* GetCursorPosition() {
return mCursor;
}
-
vtkTransform * GetSlicingTransform() { return mSlicingTransform; }
vtkTransform * GetConcatenatedTransform() { return mConcatenatedTransform; }
vtkTransform * GetConcatenatedFusionTransform() { return mConcatenatedFusionTransform; }
void GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform);
- void UpdateLandmarks();
+ void RemoveLandmarks();
+ void DisplayLandmarks();
void ForceUpdateDisplayExtent();
int* GetDisplayExtent();
return mVFColor;
}
void SetVFColor(double r, double g, double b);
-
+
//necessary to flag the secondary sequence
void SetFusionSequenceCode(int code) {mFusionSequenceCode=code;}
+ void SetRegisterExtent(int [6]);
+ void GetRegisterExtent(int [6]);
+
+ void SetSlicerNumber(const int nbSlicer) {mSlicerNumber = nbSlicer;}
+ int GetSlicerNumber() const {return mSlicerNumber;}
+
+signals:
+ void UpdateDisplayExtentBegin(int);
+ void UpdateDisplayExtentEnd(int);
+
protected:
vvSlicer();
~vvSlicer();
// ___|__|___ VTK world coordinates (mm) (never displayed) mCurrent
vtkSmartPointer<vtkTransform> mSlicingTransform;
+ vtkSmartPointer<vtkTransformPolyDataFilter> mLandmarkTransform;
vtkSmartPointer<vtkImageReslice> mImageReslice;
vtkSmartPointer<vtkTransform> mConcatenatedTransform;
vtkSmartPointer<vtkImageReslice> mOverlayReslice;
vtkSmartPointer<vtkScalarBarActor> legend;
std::vector<vvMeshActor*> mSurfaceCutActors;
+ int mSlicerNumber;
int mCurrentTSlice;
int mCurrentFusionTSlice;
int mCurrentOverlayTSlice;
double mVFColor[3];
bool mUseReducedExtent;
int * mReducedExtent;
- int * mInitialExtent;
+ int * mRegisterExtent;
bool mLinkOverlayWindowLevel;
bool showFusionLegend;
private:
void UpdateOrientation();
void UpdateDisplayExtent();
+ void ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6],
+ vtkImageData *targetImage, int targetExtent[6]);
void ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6],
vtkImageData *targetImage, int targetExtent[6]);
///Sets the surfaces to be cut on the image slice: update the vtkCutter
#include "vvMesh.h"\r
#include "vvBlendImageActor.h"\r
\r
+#include <vtkVersion.h>\r
+#include <vtkStreamingDemandDrivenPipeline.h>\r
+#include <vtkInformation.h>\r
#include <vtkImageActor.h>\r
#include <vtkImageData.h>\r
#include <vtkRenderWindow.h>\r
#include <QMessageBox>\r
//----------------------------------------------------------------------------\r
vvSlicerManager::vvSlicerManager(int numberOfSlicers)\r
-{\r
+{ \r
+\r
+ connect(this, SIGNAL(callAddLandmark(float,float,float,float)), this, SLOT(AddLandmark(float,float,float,float)));\r
+\r
mFileName = "";\r
mId = "";\r
mVFName = "";\r
mLandmarks = NULL;\r
mLinkedId.resize(0);\r
\r
- for ( int i = 0; i < numberOfSlicers; i++)\r
+ for ( int i = 0; i < numberOfSlicers; i++) {\r
mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());\r
+ mSlicers[i]->SetSlicerNumber(i);\r
+ }\r
mSelectedSlicer = -1;\r
\r
mPreviousSlice.resize(numberOfSlicers, 0);\r
\r
//----------------------------------------------------------------------------\r
vvSlicerManager::~vvSlicerManager()\r
-{\r
+{ \r
if (mLandmarks)\r
delete mLandmarks;\r
}\r
\r
//------------------------------------------------------------------------------\r
void vvSlicerManager::SetFilename(std::string filename, int number)\r
-{\r
+{ \r
mFileName = filename;\r
mFileName = vtksys::SystemTools::GetFilenameName(mFileName);\r
mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->AddContour(contour,propagate);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::ToggleContourSuperposition()\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++)\r
mSlicers[i]->ToggleContourSuperposition();\r
}\r
\r
//----------------------------------------------------------------------------\r
std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)\r
-{\r
+{ \r
vvImageReader *reader = NULL;\r
\r
if(actorType=="image")\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)\r
-{\r
+{ \r
mType = type;\r
if (mReader.IsNull())\r
mReader = vvImageReader::New();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetImage(vvImage::Pointer image)\r
-{\r
+{ \r
mImage=image;\r
for (unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetImage(image);\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)\r
-{\r
+{ \r
mType = type;\r
std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);\r
if (type == vvImageReader::DICOM)\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{\r
+{ \r
mOverlayName = filenames[0];\r
mOverlayComponent = component;\r
if (dim > mImage->GetNumberOfDimensions()) {\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetFusion(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{\r
+{ \r
mFusionName = filenames[0];\r
mFusionComponent = component;\r
if (dim > mImage->GetNumberOfDimensions()) {\r
//----------------------------------------------------------------------------\r
//this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence.\r
bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{\r
+{ \r
mFusionSequenceInvolvementCode = 0;\r
\r
mFusionName = filenames[0];\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetVF(std::string filename)\r
-{\r
+{ \r
if (mVectorReader.IsNull())\r
mVectorReader = vvImageReader::New();\r
mVectorReader->SetInputFilename(filename);\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)\r
-{\r
+{ \r
if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {\r
mLastError = "Sorry, vector field dimension cannot be greater then reference image.";\r
return false;\r
\r
//----------------------------------------------------------------------------\r
vvSlicer* vvSlicerManager::GetSlicer(int i)\r
-{\r
+{ \r
return mSlicers[i];\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSlicer(int num, bool state)\r
-{\r
+{ \r
if (mSlicers[num]->GetImage()) {\r
mSlicers[num]->SetDisplayMode(state);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)\r
-{\r
+{ \r
mSlicers[i]->SetRenderWindow(i,RW);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)\r
-{\r
+{ \r
vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();\r
smc->SM = this;\r
smc->SetSlicerNumber(i);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::LeftButtonReleaseEvent(int slicer)\r
-{\r
+{ \r
emit LeftButtonReleaseSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitMousePositionUpdated(int slicer)\r
-{\r
+{ \r
emit MousePositionUpdatedSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitKeyPressed(std::string KeyPress)\r
-{\r
+{ \r
emit KeyPressedSignal(KeyPress);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)\r
-{\r
+{ \r
mSlicers[slicer]->SetSliceOrientation(orientation);\r
emit UpdateOrientation(slicer, orientation);\r
}\r
\r
//----------------------------------------------------------------------------\r
int vvSlicerManager::GetTSlice()\r
-{\r
+{ \r
return mSlicers[0]->GetTSlice();\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)\r
-{\r
+{ \r
if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant.\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetTSlice(slice, updateLinkedImages);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetFusionSequenceTSlice(int slice)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetFusionSequenceTSlice(slice);\r
UpdateTSlice(i);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetNextTSlice(int originating_slicer)\r
-{\r
+{ \r
int t = mSlicers[0]->GetMaxCurrentTSlice();\r
t++;\r
if (t > mSlicers[0]->GetTMax())\r
t = 0;\r
- //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;\r
emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetPreviousTSlice(int originating_slicer)\r
-{\r
+{ \r
int t = mSlicers[0]->GetMaxCurrentTSlice();\r
t--;\r
if (t < 0)\r
t = mSlicers[0]->GetTMax();\r
- //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;\r
emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::ToggleInterpolation()\r
-{\r
+{ \r
bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)\r
-{\r
+{ \r
if (tslice < 0)\r
tslice = 0;\r
else if (tslice > mSlicers[slicer]->GetTMax())\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetColorWindow(double s)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetColorWindow(s);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetColorLevel(double s)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetColorLevel(s);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetOverlayColorWindow(double s)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetOverlayColorWindow(s);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetOverlayColorLevel(double s)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetOverlayColorLevel(s);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetLinkOverlayWindowLevel(b);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetCursorVisibility(s);\r
mSlicers[i]->SetCornerAnnotationVisibility(s);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetOpacity(int i, double factor)\r
-{\r
+{ \r
mSlicers[i]->SetOpacity(1/factor);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateViews(int current,int slicer)\r
-{\r
+{ \r
double p[3], pt[3];\r
p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
/mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])\r
/mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
-\r
+#if VTK_MAJOR_VERSION <= 5\r
if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
}\r
}\r
}\r
+#else\r
+int extentImageReslice[6];\r
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
+ if (x >= extentImageReslice[0]-0.5 &&\r
+ x <= extentImageReslice[1]+0.5 &&\r
+ y >= extentImageReslice[2]-0.5 &&\r
+ y <= extentImageReslice[3]+0.5 &&\r
+ z >= extentImageReslice[4]-0.5 &&\r
+ z <= extentImageReslice[5]+0.5) {\r
+ mSlicers[slicer]->UpdateCursorPosition();\r
+ mSlicers[slicer]->SetCursorColor(10,212,255);\r
+ mSelectedSlicer = slicer;\r
+\r
+ switch (mSlicers[slicer]->GetSliceOrientation()) {\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(z))\r
+ mSlicers[slicer]->SetSlice((int)lrint(z));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(y))\r
+ mSlicers[slicer]->SetSlice((int)lrint(y));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(x))\r
+ mSlicers[slicer]->SetSlice((int)lrint(x));\r
+ break;\r
+ }\r
+ mSlicers[slicer]->Render();\r
+\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ if (i != (unsigned int)slicer\r
+ && mSlicers[i]->GetRenderer()->GetDraw()\r
+ && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2\r
+ && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {\r
+ mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ mSlicers[i]->UpdateCursorPosition();\r
+ if (current) { //do not display corner annotation if image is the one picked\r
+ mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,\r
+ -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ mSlicers[i]->SetCursorColor(255,10,212);\r
+ } else {\r
+ mSlicers[i]->SetCursorColor(150,10,282);\r
+ }\r
+ switch (mSlicers[i]->GetSliceOrientation()) {\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(z))\r
+ mSlicers[i]->SetSlice((int)lrint(z));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(y))\r
+ mSlicers[i]->SetSlice((int)lrint(y));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(x))\r
+ mSlicers[i]->SetSlice((int)lrint(x));\r
+ break;\r
+ }\r
+ \r
+ mSlicers[i]->Render();\r
+ \r
+ UpdateSlice(i);\r
+ UpdateTSlice(i);\r
+ }\r
+ }\r
+ }\r
+#endif\r
}\r
//----------------------------------------------------------------------------\r
\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateLinked(int slicer)\r
-{\r
+{ \r
double p[3], pt[3];\r
p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];\r
double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
-\r
+#if VTK_MAJOR_VERSION <= 5\r
if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
}\r
}\r
}\r
+#else\r
+int extentImageReslice[6];\r
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
+ if (x >= extentImageReslice[0]-0.5 &&\r
+ x <= extentImageReslice[1]+0.5 &&\r
+ y >= extentImageReslice[2]-0.5 &&\r
+ y <= extentImageReslice[3]+0.5 &&\r
+ z >= extentImageReslice[4]-0.5 &&\r
+ z <= extentImageReslice[5]+0.5) {\r
+ for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {\r
+ if (this->IsInvolvedInFusionSequence()) {\r
+ //this SlicerManager is involved in fusionSequence => do not synchronize the times\r
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);\r
+ }\r
+ else {\r
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ }\r
+ }\r
+ }\r
+#endif\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)\r
-{\r
+{ \r
vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();\r
\r
double refPosition[3];\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorWindow() const\r
-{\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorLevel() const\r
-{\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorWindow() const\r
-{\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorLevel() const\r
-{\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::GetLinkOverlayWindowLevel() const\r
-{\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetLinkOverlayWindowLevel();\r
return -1;\r
\r
//------------------------------------------------------------------------------\r
void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)\r
-{\r
+{ \r
if(actorType == "image")\r
for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
this->GetImage()->GetTransform()[i]->Identity();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Render()\r
-{\r
+{ \r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->Render();\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::GenerateDefaultLookupTable()\r
-{\r
+{ \r
SetPreset(mPreset);\r
SetColorMap(mColorMap);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Reload()\r
-{\r
+{ \r
mReader->Update(mType);\r
mImage=mReader->GetOutput();\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::ReloadFusion()\r
-{\r
+{ \r
mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);\r
\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
//----------------------------------------------------------------------------\r
//the secondary sequence is being reloaded.\r
void vvSlicerManager::ReloadFusionSequence()\r
-{\r
+{ \r
// this is to keep the slice thickness, which needs to be artificially increased for visualization\r
double sp_x, sp_y, sp_z;\r
this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::ReloadOverlay()\r
-{\r
+{ \r
mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::ReloadVF()\r
-{\r
+{ \r
mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function\r
mVF=mVectorReader->GetOutput();\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)\r
-{\r
+{ \r
if (actor_type =="overlay")\r
mOverlayReader = NULL;\r
\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::RemoveActors()\r
-{\r
+{ \r
///This method leaks a few objects. See RemoveActor for what a\r
///correct implementation would look like\r
//DS -> probably due to the reader (now released in the\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)\r
-{\r
+{ \r
// int view = mSlicers[slicer]->GetSliceOrientation();\r
// int slice = mSlicers[slicer]->GetSlice();\r
double x = mSlicers[slicer]->GetCursorPosition()[0];\r
mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/\r
mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
+ double xyz[3], xyzTransform[3];\r
+ xyz[0] = x;\r
+ xyz[1] = y;\r
+ xyz[2] = z;\r
+ mSlicers[slicer]->GetConcatenatedTransform()->TransformPoint(xyz, xyzTransform);\r
+ double XTransform = (xyzTransform[0] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[0])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[0];\r
+ double YTransform = (xyzTransform[1] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[1])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[1];\r
+ double ZTransform = (xyzTransform[2] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[2])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[2];\r
double value = -VTK_DOUBLE_MAX;\r
int displayVec = 0;\r
double xVec=0, yVec=0, zVec=0, valueVec=0;\r
int displayOver = 0;\r
int displayFus = 0;\r
double valueOver=0, valueFus=0;\r
- if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&\r
- X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&\r
- Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&\r
- Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&\r
- Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&\r
- Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {\r
+#if VTK_MAJOR_VERSION <= 5\r
+ if (XTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&\r
+ XTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&\r
+ YTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&\r
+ YTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&\r
+ ZTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&\r
+ ZTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {\r
\r
value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);\r
\r
}\r
\r
emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),\r
- x,y,z,X,Y,Z,value);\r
+ x,y,z,XTransform,YTransform,ZTransform,value);\r
emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);\r
emit UpdateOverlay(displayOver,valueOver,value);\r
emit UpdateFusion(displayFus,valueFus);\r
}\r
+#else\r
+int extentImageReslice[6];\r
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
+ if (XTransform >= extentImageReslice[0] &&\r
+ XTransform <= extentImageReslice[1] &&\r
+ YTransform >= extentImageReslice[2] &&\r
+ YTransform <= extentImageReslice[3] &&\r
+ ZTransform >= extentImageReslice[4] &&\r
+ ZTransform <= extentImageReslice[5]) {\r
+\r
+ value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);\r
+\r
+ if (mSlicers[slicer]->GetVFActor() ) {\r
+ displayVec = 1;\r
+ unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();\r
+ vtkImageData *vf = NULL;\r
+\r
+ if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)\r
+ vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];\r
+ else\r
+ vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];\r
+\r
+ if (vf) {\r
+ double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];\r
+ double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];\r
+ double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];\r
+ xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);\r
+ yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);\r
+ zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);\r
+ valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);\r
+ }\r
+ }\r
+ if (mSlicers[slicer]->GetOverlayActor() ) {\r
+ displayOver = 1;\r
+ vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());\r
+ double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];\r
+ double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];\r
+ double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];\r
+ valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);\r
+ }\r
+\r
+ if ( mSlicers[slicer]->GetFusionActor() ) {\r
+ displayFus = 1;\r
+ vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());\r
+ double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];\r
+ double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];\r
+ double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];\r
+ valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);\r
+ }\r
+ else if (this->IsInvolvedInFusionSequence()) { \r
+ //if the cursor moves over the 'independent' version of the secondary sequence\r
+ //do not update the panel, just keep it as it is.\r
+ displayFus = 1;\r
+ valueFus = std::numeric_limits<double>::quiet_NaN();\r
+ }\r
+\r
+ emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),\r
+ x,y,z,XTransform,YTransform,ZTransform,value);\r
+ emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);\r
+ emit UpdateOverlay(displayOver,valueOver,value);\r
+ emit UpdateFusion(displayFus,valueFus);\r
+ }\r
+#endif\r
}\r
//----------------------------------------------------------------------------\r
\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Activated()\r
-{\r
+{ \r
emit currentImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Picked()\r
-{\r
+{ \r
emit currentPickedImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateWindowLevel()\r
-{\r
+{ \r
emit WindowLevelChanged();\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSlice(int slicer)\r
-{\r
+{ \r
if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {\r
//DD("============= NOTHING");\r
return;\r
}\r
- //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;\r
emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());\r
mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...\r
mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateTSlice(int slicer)\r
-{\r
+{ \r
int slice = mSlicers[slicer]->GetSlice();\r
\r
int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSliceRange(int slicer)\r
-{\r
+{ \r
emit UpdateSliceRange(slicer,\r
mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],\r
0,mSlicers[slicer]->GetTMax());\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)\r
-{\r
+{ \r
if(mSlicingPreset==preset)\r
return;\r
\r
return;\r
}\r
s->ForceUpdateDisplayExtent();\r
+#if VTK_MAJOR_VERSION <= 5\r
s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]\r
+s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);\r
+#else\r
+ int extentImageReslice[6];\r
+ s->GetRegisterExtent(extentImageReslice);\r
+ s->SetSlice((extentImageReslice[s->GetSliceOrientation()*2+1]\r
+ +extentImageReslice[s->GetSliceOrientation()*2])/2.0);\r
+#endif\r
s->ResetCamera();\r
s->Render();\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetPreset(int preset)\r
-{\r
+{ \r
\r
//vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());\r
double window = mSlicers[0]->GetColorWindow();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)\r
-{\r
+{ \r
double min, max;\r
if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {\r
int t = mSlicers[slicer]->GetFusionTSlice();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetColorMap(int colormap)\r
-{\r
+{ \r
double range[2];\r
\r
range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];\r
\r
fusLUT->ForceBuild();\r
double v[4];\r
-\r
// set color table transparency\r
//double alpha_range=(double)mFusionThresOpacity/10;\r
double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;\r
\r
//----------------------------------------------------------------------------\r
vvLandmarks* vvSlicerManager::GetLandmarks()\r
-{\r
+{ \r
if (mLandmarks == NULL) {\r
mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);\r
for (unsigned int i = 0; i < mSlicers.size(); i++)\r
return mLandmarks;\r
}\r
//----------------------------------------------------------------------------\r
-\r
+void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t)\r
+{ \r
+ emit callAddLandmark(x,y,z,t);\r
+}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::AddLandmark(float x,float y,float z,float t)\r
-{\r
+{ \r
double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];\r
double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];\r
double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];\r
+#if VTK_MAJOR_VERSION <= 5\r
if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {\r
- double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
emit LandmarkAdded();\r
}\r
+#else\r
+ int extentImageReslice[6];\r
+ mSlicers[0]->GetRegisterExtent(extentImageReslice);\r
+ if (x_index >= extentImageReslice[0]-0.5 &&\r
+ x_index <= extentImageReslice[1]+0.5 &&\r
+ y_index >= extentImageReslice[2]-0.5 &&\r
+ y_index <= extentImageReslice[3]+0.5 &&\r
+ z_index >= extentImageReslice[4]-0.5 &&\r
+ z_index <= extentImageReslice[5]+0.5) {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+ emit LandmarkAdded();\r
+ }\r
+#endif\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t)\r
+{ \r
+ double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];\r
+ double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];\r
+ double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];\r
+#if VTK_MAJOR_VERSION <= 5\r
+ if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
+ x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
+ y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
+ y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
+ z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
+ z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+ }\r
+#else\r
+ int extentImageReslice[6];\r
+ mSlicers[0]->GetRegisterExtent(extentImageReslice);\r
+ if (x_index >= extentImageReslice[0]-0.5 &&\r
+ x_index <= extentImageReslice[1]+0.5 &&\r
+ y_index >= extentImageReslice[2]-0.5 &&\r
+ y_index <= extentImageReslice[3]+0.5 &&\r
+ z_index >= extentImageReslice[4]-0.5 &&\r
+ z_index <= extentImageReslice[5]+0.5) {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+ }\r
+#endif\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::PrevImage(int slicer)\r
-{\r
+{ \r
emit ChangeImageWithIndexOffset(this, slicer, -1);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::NextImage(int slicer)\r
-{\r
+{ \r
emit ChangeImageWithIndexOffset(this, slicer, 1);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)\r
-{\r
+{ \r
emit AVerticalSliderHasChanged(slicer, slice);\r
}\r
\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)\r
-{\r
+{ \r
int ix, iy, iz;\r
return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);\r
}\r
void SetSlicingPreset(SlicingPresetType preset);
vvLandmarks *GetLandmarks();
- void AddLandmark(float x,float y,float z,float t);
+ void AddNewLandmark(float x,float y,float z,float t);
+ void AddLandmarkProfile(float x,float y,float z,float t);
void NextImage(int slicer);
void PrevImage(int slicer);
void VerticalSliderHasChanged(int slicer, int slice);
double GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component=0);
+public slots:
+ void AddLandmark(float x,float y,float z,float t);
+
signals :
+ void callAddLandmark(float x,float y,float z,float t);
void currentImageChanged(std::string id);
void currentPickedImageChanged(std::string id);
void UpdatePosition(int visibility,double x, double y, double z, double X, double Y, double Z, double value);
#include "vtkTransform.h"
#include <cmath>
-
//------------------------------------------------------------------------------
vvSlicerManagerCommand::vvSlicerManagerCommand()
{
this->SM->SetLocalColorWindowing(VisibleInWindow, bCtrlKey);
return;
}
- if (KeyPress == "0") {
+ if (KeyPress == "0" || KeyPress == "KP_0") {
this->SM->SetPreset(WL_AUTO);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "1") {
+ if (KeyPress == "1" || KeyPress == "KP_1") {
this->SM->SetPreset(WL_HOUNSFIELD);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "2") {
+ if (KeyPress == "2" || KeyPress == "KP_2") {
this->SM->SetPreset(WL_SOFTTISSUE);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "3") {
+ if (KeyPress == "3" || KeyPress == "KP_3") {
this->SM->SetPreset(WL_LUNGS);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "4") {
+ if (KeyPress == "4" || KeyPress == "KP_4") {
this->SM->SetPreset(WL_BONES);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "5") {
+ if (KeyPress == "5" || KeyPress == "KP_5") {
this->SM->SetPreset(WL_HEAD);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "6") {
+ if (KeyPress == "6" || KeyPress == "KP_6") {
this->SM->SetColorMap(0);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "7") {
+ if (KeyPress == "7" || KeyPress == "KP_7") {
this->SM->SetColorMap(1);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "8") {
+ if (KeyPress == "8" || KeyPress == "KP_8") {
this->SM->SetColorMap(2);
this->SM->UpdateWindowLevel();
return;
}
- if (KeyPress == "9") {
+ if (KeyPress == "9" || KeyPress == "KP_9") {
this->SM->SetColorMap(3);
this->SM->UpdateWindowLevel();
return;
//>>>>>>> 921642d767beba2442dacc8fdb40dc36396e1b7d
if (newLandmark) {
- this->SM->AddLandmark(xWorld,yWorld,zWorld,
+ double pLand[3]; pLand[0] = xWorld; pLand[1] = yWorld; pLand[2] = zWorld;
+ double ptLand[3];
+ this->SM->GetSlicer(VisibleInWindow)->GetConcatenatedTransform()->TransformPoint(pLand, ptLand);
+ this->SM->AddNewLandmark(ptLand[0],ptLand[1],ptLand[2],
this->SM->GetSlicer(VisibleInWindow)->GetTSlice());
- this->SM->GetSlicer(VisibleInWindow)->UpdateLandmarks();
+ this->SM->GetSlicer(VisibleInWindow)->RemoveLandmarks();
+ //this->SM->GetSlicer(VisibleInWindow)->DisplayLandmarks();
this->SM->Render();
}
if (event == vtkCommand::PickEvent || event == vtkCommand::StartPickEvent) {
#include "vtkOBJReader.h"
#include "vtkInteractorStyle.h"
-
+#include <vtkVersion.h>
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
#include "vtkPolyData.h"
#include "vtkRenderer.h"
#include <QMessageBox>
+#include <QFileDialog>
+
+#ifdef Q_OS_OSX
+# include "vvOSXHelper.h"
+#endif
//----------------------------------------------------------------------------
class vvManagerCallback : public vtkCommand
mCurrentTime = 0;
connect(loadButton,SIGNAL(clicked()),this,SLOT(LoadSurface()));
+
+#ifdef Q_OS_OSX
+ disableGLHiDPI(renderWidget->winId());
+#endif
}
vvSurfaceViewerDialog::~vvSurfaceViewerDialog()
reader->Update();
mReaders.push_back(reader);
}
-
+#if VTK_MAJOR_VERSION <= 5
mMapper->SetInput(mReaders[mCurrentTime]->GetOutput());
+#else
+ mMapper->SetInputConnection(mReaders[mCurrentTime]->GetOutputPort());
+#endif
if (!mActor) {
mActor = vtkActor::New();
mCurrentTime++;
if (mCurrentTime >= mReaders.size())
mCurrentTime = 0;
+#if VTK_MAJOR_VERSION <= 5
mMapper->SetInput(mReaders[mCurrentTime]->GetOutput());
+#else
+ mMapper->SetInputConnection(mReaders[mCurrentTime]->GetOutputPort());
+#endif
mMapper->Modified();
renderWidget->GetRenderWindow()->Render();
}
mCurrentTime--;
if (mCurrentTime < 0)
mCurrentTime = (unsigned int) mReaders.size() - 1;
+#if VTK_MAJOR_VERSION <= 5
mMapper->SetInput(mReaders[mCurrentTime]->GetOutput());
+#else
+ mMapper->SetInputConnection(mReaders[mCurrentTime]->GetOutputPort());
+#endif
mMapper->Modified();
renderWidget->GetRenderWindow()->Render();
}
class vtkActor;
class vtkOBJReader;
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QTreeWidget>
//====================================================================
#include <vtkImageClip.h>
#include <vtkRenderWindow.h>
+
//------------------------------------------------------------------------------
// Create the tool and automagically (I like this word) insert it in
// the main window menu.
//------------------------------------------------------------------------------
void vvToolBinarize::Initialize()
-{
+{
SetToolName("Binarize");
SetToolMenuName("Binarize");
SetToolIconFilename(":/common/icons/binarize.png");
:vvToolWidgetBase(parent,f),
vvToolBase<vvToolBinarize>(parent),
Ui::vvToolBinarize()
-{
+{
// GUI Initialization
Ui_vvToolBinarize::setupUi(mToolWidget);
mInteractiveDisplayIsEnabled = mCheckBoxInteractiveDisplay->isChecked();
//------------------------------------------------------------------------------
vvToolBinarize::~vvToolBinarize()
-{
+{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::InteractiveDisplayToggled(bool b)
-{
+{
mInteractiveDisplayIsEnabled = b;
if (!mInteractiveDisplayIsEnabled) {
RemoveVTKObjects();
//------------------------------------------------------------------------------
void vvToolBinarize::RemoveVTKObjects()
-{
+{
for(unsigned int i=0; i<mImageContour.size(); i++) {
mImageContour[i]->HideActors();
mImageContourLower[i]->HideActors();
//------------------------------------------------------------------------------
bool vvToolBinarize::close()
-{
+{
// RemoveVTKObjects();
return vvToolWidgetBase::close();
}
//------------------------------------------------------------------------------
-void vvToolBinarize::closeEvent(QCloseEvent *event) {
+void vvToolBinarize::closeEvent(QCloseEvent *event)
+{
RemoveVTKObjects();
event->accept();
}
//------------------------------------------------------------------------------
void vvToolBinarize::reject()
-{
+{
// DD("vvToolBinarize::reject");
RemoveVTKObjects();
return vvToolWidgetBase::reject();
//------------------------------------------------------------------------------
void vvToolBinarize::enableLowerThan(bool b)
-{
+{
if (!b) {
mThresholdSlider1->resetMaximum();
for(unsigned int i=0; i<mImageContour.size(); i++) {
//------------------------------------------------------------------------------
void vvToolBinarize::useFGBGtoggled(bool)
-{
+{
if (!mCheckBoxUseBG->isChecked() && !mCheckBoxUseFG->isChecked())
mCheckBoxUseBG->toggle();
}
// DD(m.size());
// }
void vvToolBinarize::InputIsSelected(vvSlicerManager * m)
-{
+{
mCurrentSlicerManager = m;
// Specific for this gui
mImageContour.push_back(vvImageContour::New());
mImageContour[i]->SetSlicer(mCurrentSlicerManager->GetSlicer(i));
mImageContour[i]->SetColor(1.0, 0.0, 0.0);
- mImageContour[i]->SetDepth(100); // to be in front of (whe used with ROI tool)
+ mImageContour[i]->SetDepth(0); // to be in front of (whe used with ROI tool)
mImageContourLower.push_back(vvImageContour::New());
mImageContourLower[i]->SetSlicer(mCurrentSlicerManager->GetSlicer(i));
mImageContourLower[i]->SetColor(0.0, 0.0, 1.0);
connect(mThresholdSlider2, SIGNAL(valueChanged(double)), this, SLOT(valueChangedT2(double)));
connect(mCurrentSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
- connect(mCurrentSlicerManager,SIGNAL(UpdateTSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
+ connect(mCurrentSlicerManager,SIGNAL(UpdateTSlice(int,int, int)),this,SLOT(UpdateSlice(int, int, int)));
connect(mCurrentSlicerManager,SIGNAL(UpdateOrientation(int,int)),this,SLOT(UpdateOrientation(int, int)));
// connect(mCurrentSlicerManager, SIGNAL(LeftButtonReleaseSignal(int)), SLOT(LeftButtonReleaseEvent(int)));
-
InteractiveDisplayToggled(mInteractiveDisplayIsEnabled);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::UpdateOrientation(int slicer,int orientation)
-{
+{
Update(slicer);
}
//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
-void vvToolBinarize::UpdateSlice(int slicer,int slices)
-{
+void vvToolBinarize::UpdateSlice(int slicer,int slices, int code)
+{
Update(slicer);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::Update(int slicer)
-{
+{
if (!mInteractiveDisplayIsEnabled) return;
if (!mCurrentSlicerManager) close();
mImageContour[slicer]->Update(mThresholdSlider1->GetValue());
//------------------------------------------------------------------------------
void vvToolBinarize::GetArgsInfoFromGUI()
-{
+{
/* //KEEP THIS FOR READING GGO FROM FILE
int argc=1;
//------------------------------------------------------------------------------
void vvToolBinarize::apply()
-{
+{
if (!mCurrentSlicerManager) close();
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
- GetArgsInfoFromGUI();
-
+ GetArgsInfoFromGUI();
+
// Main filter
clitk::BinarizeImageGenericFilter::Pointer filter =
clitk::BinarizeImageGenericFilter::New();
filter->SetArgsInfo(mArgsInfo);
filter->Update();
+
// Output
- vvImage::Pointer output = filter->GetOutputVVImage();
+ vvImage::Pointer output = filter->GetOutputVVImage();
std::ostringstream osstream;
osstream << "Binarized_" << mCurrentSlicerManager->GetSlicer(0)->GetFileName() << ".mhd";
AddImage(output,osstream.str());
//------------------------------------------------------------------------------
void vvToolBinarize::valueChangedT2(double v)
-{
+{
// DD("valueChangedT2");
if (mRadioButtonLowerThan->isChecked()) {
mThresholdSlider1->SetMaximum(v);
//------------------------------------------------------------------------------
void vvToolBinarize::valueChangedT1(double v)
-{
+{
// DD("valueChangedT1");
if (!mCurrentSlicerManager) close();
mThresholdSlider2->SetMinimum(v);
#ifndef VVTOOLBINARIZE_H
#define VVTOOLBINARIZE_H
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
void valueChangedT1(double v);
void valueChangedT2(double v);
void UpdateOrientation(int slicer, int orientation);
- void UpdateSlice(int slicer,int slices);
+ void UpdateSlice(int slicer,int slices, int code=0);
void enableLowerThan(bool b);
void useFGBGtoggled(bool);
void InteractiveDisplayToggled(bool b);
#include <QSignalMapper>
// vtk
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include <vtkImageClip.h>
#include <vtkImageTranslateExtent.h>
#include <vtkImageData.h>
{
if(mCurrentSlicerManager){
// Reset extends
- for(int i=0; i<mExtentSize; i++){
+ for(int i=0; i<6; i++){
mReducedExtent[i] = mInitialExtent[i];
}
+ for(int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
+ mCurrentSlicerManager->GetSlicer(i)->EnableReducedExtent(false);
UpdateExtent();
}
+ mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(mConcatenedTransform);
+ for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mCurrentSlicerManager->GetSlicer(i)->ResetCamera();
+ mCurrentSlicerManager->GetSlicer(i)->Render();
+ mCurrentSlicerManager->UpdateLinkedNavigation( mCurrentSlicerManager->GetSlicer(i) );
+ }
vvToolWidgetBase::closeEvent(event);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolCropImage::reject()
{
- for(int i=0; i<mExtentSize; i++) mReducedExtent[i] = mInitialExtent[i];
+ for(int i=0; i<mExtentSize; i++)
+ mReducedExtent[i] = mInitialExtent[i];
+ for(int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
+ mCurrentSlicerManager->GetSlicer(i)->EnableReducedExtent(false);
UpdateExtent();
return vvToolWidgetBase::reject();
}
//------------------------------------------------------------------------------
void vvToolCropImage::InputIsSelected(vvSlicerManager * slicer)
{
+ //Save the current transformation
+ mConcatenedTransform = vtkSmartPointer<vtkMatrix4x4>::New();
+ mConcatenedTransform->DeepCopy(slicer->GetSlicer(0)->GetConcatenatedTransform()->GetMatrix());
+ vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
+ matrix->Identity();
+ mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix);
+ for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mCurrentSlicerManager->GetSlicer(i)->ResetCamera();
+ mCurrentSlicerManager->GetSlicer(i)->Render();
+ mCurrentSlicerManager->UpdateLinkedNavigation( mCurrentSlicerManager->GetSlicer(i) );
+ }
+
// Change interface according to number of dimension
mExtentSize = 2*slicer->GetDimension();
if (slicer->GetDimension()<4) {
spin_zmin->setHidden(true);
spin_zmax->setHidden(true);
}
-
+#if VTK_MAJOR_VERSION <= 5
int *a = mCurrentImage->GetFirstVTKImageData()->GetWholeExtent();
+#else
+ int *a = mCurrentImage->GetFirstVTKImageData()->GetInformation()->Get(vtkDataObject::DATA_EXTENT());
+#endif
for(int i=0; i<6; i++){
mInitialExtent[i] = a[i];
mReducedExtent[i] = a[i];
}
// Set initial sliders values
- std::vector<int> imsize = mCurrentSlicerManager->GetImage()->GetSize();
+ int w_ext[6], imsize[3];
+ mCurrentSlicerManager->GetSlicer(0)->GetRegisterExtent(w_ext);
for(int dim=0; dim<slicer->GetDimension() && dim<3; ++dim){
+ imsize[dim] = w_ext[2*dim+1] - w_ext[2*dim] +1;
mSliders[dim*2]->setMaximum(imsize[dim]-1);
mSliders[dim*2+1]->setMaximum(imsize[dim]-1);
mSliders[dim*2+1]->setValue(imsize[dim]-1);
}
// We MUST reset initial extend to input image before using the
// filter to retrieve the correct image size
- for(int i=0; i<mExtentSize; i++) {
+ for(int i=0; i<6; i++) {
mReducedExtent[i] = mInitialExtent[i];
}
// Retrieve result and display it
vvImage::Pointer output = filter->GetOutputVVImage();
+ output->GetTransform()[0]->SetMatrix(mConcatenedTransform);
+
AddImage(output,croppedImageName.str());
// End
#define VVTOOLCROPIMAGE_H
//qt
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QDialog>
#include <QSlider>
// vv
#include "vvToolWidgetBase.h"
#include "vvMainWindowBase.h"
#include "ui_vvToolCropImage.h"
+//vtk
+#include <vtkTransform.h>
//------------------------------------------------------------------------------
class vvToolCropImage:
virtual void closeEvent(QCloseEvent *event);
std::vector<QSlider*> mSliders;
+ vtkSmartPointer<vtkMatrix4x4> mConcatenedTransform;
}; // end class vvToolCropImage
//------------------------------------------------------------------------------
===========================================================================**/
#ifndef VVTOOLImageArithm_H
#define VVTOOLImageArithm_H
+
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
#define VVTOOLINPUTSELECTORWIDGET_H
// qt
+#include <QObject>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QDialog>
// vv
#include <vvImage.h>
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "vvToolBase.h"
#include "QWidget"
#include "vvToolWidgetBase.h"
#ifndef VVTOOLMedianFilter_H
#define VVTOOLMedianFilter_H
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+ #include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "vvToolBase.h"
#include "QWidget"
#include "vvToolWidgetBase.h"
--- /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 <QFileDialog>
+#include <QShortcut>
+
+#include <algorithm>
+
+// vv
+#include "vvToolProfile.h"
+#include "vvProgressDialog.h"
+#include "vvSlicerManager.h"
+#include "vvSlicer.h"
+#include "vvToolInputSelectorWidget.h"
+
+// vtk
+#include <vtkAxis.h>
+#include <vtkImageActor.h>
+#include <vtkCamera.h>
+#include <vtkImageClip.h>
+#include <vtkRenderWindow.h>
+#include <vtkChartXY.h>
+#include <vtkPlot.h>
+#include <vtkRendererCollection.h>
+#include <vtkRenderer.h>
+
+#include <vtkLine.h>
+#include <vtkCellArray.h>
+#include <vtkCellData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
+#include <vtkBox.h>
+#include <vtkInformation.h>
+
+#ifdef Q_OS_OSX
+# include "vvOSXHelper.h"
+#endif
+
+//------------------------------------------------------------------------------
+// Create the tool and automagically (I like this word) insert it in
+// the main window menu.
+ADD_TOOL(vvToolProfile);
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::Initialize()
+{
+ SetToolName("Profile");
+ SetToolMenuName("Intensity Profile");
+ SetToolIconFilename(":/common/icons/profile.png");
+ SetToolTip("Display the intensity profile between 2 points of the image.");
+ SetToolExperimental(false);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+vvToolProfile::vvToolProfile(vvMainWindowBase * parent, Qt::WindowFlags f)
+ :vvToolWidgetBase(parent,f),
+ vvToolBase<vvToolProfile>(parent),
+ Ui::vvToolProfile()
+{
+ // GUI Initialization
+ Ui_vvToolProfile::setupUi(mToolWidget);
+
+ QShortcut *shortcutPoint1 = new QShortcut(QKeySequence("Ctrl+1"), parent);
+ shortcutPoint1->setContext(Qt::ApplicationShortcut);
+ QObject::connect(shortcutPoint1, SIGNAL(activated()), this, SLOT(selectPoint1()));
+ QShortcut *shortcutPoint2 = new QShortcut(QKeySequence("Ctrl+2"), parent);
+ shortcutPoint2->setContext(Qt::ApplicationShortcut);
+ QObject::connect(shortcutPoint2, SIGNAL(activated()), this, SLOT(selectPoint2()));
+
+ // Connect signals & slots
+ connect(mSelectPoint1Button, SIGNAL(clicked()), this, SLOT(selectPoint1()));
+ connect(mSelectPoint2Button, SIGNAL(clicked()), this, SLOT(selectPoint2()));
+ connect(mCancelPointsButton, SIGNAL(clicked()), this, SLOT(cancelPoints()));
+ connect(mSaveProfileButton, SIGNAL(clicked()), this, SLOT(SaveAs()));
+
+ // Initialize some widget
+ ProfileWidget->hide();
+ mPoint1 = NULL;
+ mPoint2 = NULL;
+
+ mPoint1Selected = false;
+ mPoint2Selected = false;
+
+ mView = vtkSmartPointer<vtkContextView>::New();
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ chart->SetAutoSize(false);
+ chart->SetRenderEmpty(true);
+ mView->GetScene()->AddItem(chart);
+ this->ProfileWidget->GetRenderWindow()->GetRenderers()->RemoveAllItems();
+ this->ProfileWidget->GetRenderWindow()->AddRenderer(mView->GetRenderer());
+ ProfileWidget->show();
+
+#ifdef Q_OS_OSX
+ disableGLHiDPI(ProfileWidget->winId());
+#endif
+
+ // Main filter
+ mFilter = clitk::ProfileImageGenericFilter::New();
+
+ // Set how many inputs are needed for this tool
+ AddInputSelector("Select one image", mFilter);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+vvToolProfile::~vvToolProfile()
+{
+ delete [] mPoint1;
+ delete [] mPoint2;
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::selectPoint1()
+{
+ QString position = "";
+
+ if(mCurrentSlicerManager) {
+ if (mPoint1Selected) {
+ ProfileWidget->hide();
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ chart->SetAutoSize(false);
+ chart->SetRenderEmpty(true);
+ mView->GetScene()->ClearItems();
+ mView->GetScene()->AddItem(chart);
+ this->ProfileWidget->GetRenderWindow()->GetRenderers()->RemoveAllItems();
+ this->ProfileWidget->GetRenderWindow()->AddRenderer(mView->GetRenderer());
+ ProfileWidget->show();
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P1", mPoint1[3]);
+ }
+
+ mPoint1Selected = false;
+
+ if(mCurrentSlicerManager->GetSelectedSlicer() != -1) {
+ double *pos;
+ pos = new double [4];
+ pos[0] = pos[1] = pos[2] = pos[3] = 0;
+
+ int i(0);
+ while (i<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() && i<3) {
+ pos[i] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetCursorPosition()[i];
+ ++i;
+ }
+ double posTransformed[3];
+ mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetConcatenatedTransform()->TransformPoint(pos, posTransformed);
+ i = 0;
+ while (i<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() && i<3) {
+ pos[i] = posTransformed[i];
+ mPoint1[i] = round((pos[i] - mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[i])/mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[i]);
+ pos[i] = mPoint1[i]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[i] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[i]; //Ensure to be at the center of the voxel
+ position += QString::number(mPoint1[i],'f',0) + " ";
+ ++i;
+ }
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() == 4) {
+ pos[3] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetTSlice();
+ mPoint1[3] = pos[3];
+ position += QString::number(mPoint1[3],'f',0) + " ";
+ }
+ mPoint1Selected = true;
+ mCurrentSlicerManager->AddLandmarkProfile(pos[0], pos[1], pos[2], pos[3]);
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->SetNumberOfValues(mCurrentSlicerManager->GetLandmarks()->GetLabels()->GetNumberOfValues()-1);
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->Modified();
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->InsertNextValue("P1");
+ }
+ }
+ mPosPoint1Label->setText(position);
+ isPointsSelected();
+ mCurrentSlicerManager->Render();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::selectPoint2()
+{
+ QString position = "";
+
+ if(mCurrentSlicerManager) {
+ if (mPoint2Selected) {
+ ProfileWidget->hide();
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ chart->SetAutoSize(false);
+ chart->SetRenderEmpty(true);
+ mView->GetScene()->ClearItems();
+ mView->GetScene()->AddItem(chart);
+ this->ProfileWidget->GetRenderWindow()->GetRenderers()->RemoveAllItems();
+ this->ProfileWidget->GetRenderWindow()->AddRenderer(mView->GetRenderer());
+ ProfileWidget->show();
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P2", mPoint2[3]);
+ }
+
+ mPoint2Selected = false;
+
+ if(mCurrentSlicerManager->GetSelectedSlicer() != -1) {
+ double *pos;
+ pos = new double [4];
+ pos[0] = pos[1] = pos[2] = pos[3] = 0;;
+
+ int i(0);
+ while (i<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() && i<3) {
+ pos[i] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetCursorPosition()[i];
+ ++i;
+ }
+ double posTransformed[3];
+ mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetConcatenatedTransform()->TransformPoint(pos, posTransformed);
+ i = 0;
+ while (i<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() && i<3) {
+ pos[i] = posTransformed[i];
+ mPoint2[i] = round((pos[i] - mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[i])/mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[i]);
+ pos[i] = mPoint2[i]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[i] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[i]; //Ensure to be at the center of the voxel
+ position += QString::number(mPoint2[i],'f',0) + " ";
+ ++i;
+ }
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() == 4) {
+ pos[3] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetTSlice();
+ mPoint2[3] = pos[3];
+ position += QString::number(mPoint2[3],'f',0) + " ";
+ }
+ mPoint2Selected = true;
+ mCurrentSlicerManager->AddLandmarkProfile(pos[0], pos[1], pos[2], pos[3]);
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->SetNumberOfValues(mCurrentSlicerManager->GetLandmarks()->GetLabels()->GetNumberOfValues()-1);
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->Modified();
+ mCurrentSlicerManager->GetLandmarks()->GetLabels()->InsertNextValue("P2");
+ }
+ }
+ mPosPoint2Label->setText(position);
+ isPointsSelected();
+ mCurrentSlicerManager->Render();
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+bool vvToolProfile::isPointsSelected()
+{
+ if (mPoint1Selected && mPoint2Selected) {
+ mSaveProfileButton->setEnabled(true);
+ computeProfile();
+ SetPoints();
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ DisplayLine(i);
+ connect(mCurrentSlicerManager->GetSlicer(i), SIGNAL(UpdateDisplayExtentBegin(int)), this, SLOT(DeleteLine(int)));
+ connect(mCurrentSlicerManager->GetSlicer(i), SIGNAL(UpdateDisplayExtentEnd(int)), this, SLOT(DisplayLine(int)));
+ }
+ mCurrentSlicerManager->Render();
+ }
+ else {
+ mSaveProfileButton->setEnabled(false);
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ disconnect(mCurrentSlicerManager->GetSlicer(i), SIGNAL(UpdateDisplayExtentBegin(int)), this, SLOT(DeleteLine(int)));
+ disconnect(mCurrentSlicerManager->GetSlicer(i), SIGNAL(UpdateDisplayExtentEnd(int)), this, SLOT(DisplayLine(int)));
+ mCurrentSlicerManager->GetSlicer(i)->GetRenderer()->RemoveActor(mLineActors[i]);
+ }
+
+ }
+ return (mPoint1Selected && mPoint2Selected);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::computeProfile()
+{
+ if (!mCurrentSlicerManager) close();
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ GetArgsInfoFromGUI();
+ ProfileWidget->hide();
+
+ // Main filter
+ mFilter->SetInputVVImage(mCurrentImage);
+ mFilter->SetArgsInfo(mArgsInfo);
+ mFilter->Update();
+
+ //Creation of the XY chart
+ vtkSmartPointer<vtkTable> table = vtkSmartPointer<vtkTable>::New();
+ vtkSmartPointer<vtkFloatArray> arrX = vtkSmartPointer<vtkFloatArray>::New();
+ vtkSmartPointer<vtkFloatArray> arrY = vtkSmartPointer<vtkFloatArray>::New();
+ arrX = mFilter->GetArrayX();
+ arrY = mFilter->GetArrayY();
+ arrX->SetName("Distance (mm)");
+ arrY->SetName("Intensity");
+
+ table->AddColumn(arrX);
+ table->AddColumn(arrY);
+
+ mView->GetRenderer()->SetBackground(1.0, 1.0, 1.0);
+
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ chart->SetAutoSize(true);
+ mView->GetScene()->ClearItems();
+ mView->GetScene()->AddItem(chart);
+ vtkPlot *line = chart->AddPlot(vtkChart::LINE);
+#if VTK_MAJOR_VERSION <= 5
+ line->SetInput(table, 0, 1);
+#else
+ line->SetInputData(table, 0, 1);
+#endif
+ line->SetColor(0, 255, 0, 255);
+ line->SetWidth(1.0);
+ chart->GetAxis(vtkAxis::LEFT)->SetTitle("Intensity");
+ chart->GetAxis(vtkAxis::BOTTOM)->SetTitle("Distance (mm)");
+
+ this->ProfileWidget->GetRenderWindow()->GetRenderers()->RemoveAllItems();
+ this->ProfileWidget->GetRenderWindow()->AddRenderer(mView->GetRenderer());
+ ProfileWidget->show();
+
+ QApplication::restoreOverrideCursor();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::cancelPoints()
+{
+ if (mPoint1Selected)
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P1", mPoint1[3]);
+ if (mPoint2Selected)
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P2", mPoint2[3]);
+ ProfileWidget->hide();
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ chart->SetAutoSize(false);
+ chart->SetRenderEmpty(true);
+ mView->GetScene()->ClearItems();
+ mView->GetScene()->AddItem(chart);
+ this->ProfileWidget->GetRenderWindow()->GetRenderers()->RemoveAllItems();
+ this->ProfileWidget->GetRenderWindow()->AddRenderer(mView->GetRenderer());
+ ProfileWidget->show();
+
+ QString position = "";
+ mPosPoint1Label->setText(position);
+ mPosPoint2Label->setText(position);
+ mPoint1Selected = false;
+ mPoint2Selected = false;
+ mSaveProfileButton->setEnabled(false);
+ isPointsSelected();
+ mCurrentSlicerManager->Render();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::RemoveVTKObjects()
+{
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mCurrentSlicerManager->GetSlicer(i)->GetRenderer()->RemoveActor(mLineActors[i]);
+ }
+
+ if (mPoint1Selected)
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P1", mPoint1[3]);
+ if (mPoint2Selected)
+ mCurrentSlicerManager->GetLandmarks()->RemoveLandmarkWithLabel("P2", mPoint2[3]);
+
+
+ if (mCurrentSlicerManager)
+ mCurrentSlicerManager->Render();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+bool vvToolProfile::close()
+{
+ //RemoveVTKObjects();
+
+ connect(mCurrentSlicerManager, SIGNAL(callAddLandmark(float,float,float,float)), mCurrentSlicerManager, SLOT(AddLandmark(float,float,float,float)));
+ return vvToolWidgetBase::close();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::closeEvent(QCloseEvent *event)
+{
+ RemoveVTKObjects();
+ event->accept();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::reject()
+{
+ // DD("vvToolProfile::reject");
+ RemoveVTKObjects();
+ return vvToolWidgetBase::reject();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::InputIsSelected(vvSlicerManager * m)
+{
+ mCurrentSlicerManager = m;
+
+ mPoint1 = new double[4];
+ mPoint1[0] = mPoint1[1] = mPoint1[2] = mPoint1[3] = 0;
+ mPoint2 = new double[4];
+ mPoint2[0] = mPoint2[1] = mPoint2[2] = mPoint2[3] = 0;
+
+ mSaveProfileButton->setEnabled(false);
+ mTextFileName = "Profile.txt";
+ InitializeLine();
+
+ disconnect(mCurrentSlicerManager, SIGNAL(callAddLandmark(float,float,float,float)), mCurrentSlicerManager, SLOT(AddLandmark(float,float,float,float)));
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::GetArgsInfoFromGUI()
+{
+
+ /* //KEEP THIS FOR READING GGO FROM FILE
+ int argc=1;
+ std::string a = "toto";
+ char * const* argv = new char*;
+ //a.c_str();
+ struct cmdline_parser_params p;
+ p.check_required = 0;
+ int good = cmdline_parser_ext(argc, argv, &args_info, &p);
+ DD(good);
+ */
+ cmdline_parser_clitkProfileImage_init(&mArgsInfo); // Initialisation to default
+
+ mArgsInfo.verbose_flag = false;
+
+ mArgsInfo.point1_arg = mPoint1;
+ mArgsInfo.point2_arg = mPoint2;
+ mArgsInfo.point1_given = mCurrentSlicerManager->GetImage()->GetNumberOfDimensions();
+ mArgsInfo.point2_given = mCurrentSlicerManager->GetImage()->GetNumberOfDimensions();
+
+ // Required (even if not used)
+ mArgsInfo.input_given = 0;
+ mArgsInfo.output_given = 0;
+
+ mArgsInfo.input_arg = new char;
+ mArgsInfo.output_arg = new char;
+
+
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::apply()
+{
+ close();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::SaveAs()
+{
+ QStringList OutputListeFormat;
+ OutputListeFormat.clear();
+ OutputListeFormat.push_back(".txt");
+
+ QString Extensions = "AllFiles(*.*)";
+ for (int i = 0; i < OutputListeFormat.count(); i++) {
+ Extensions += ";;Text File ( *";
+ Extensions += OutputListeFormat[i];
+ Extensions += ")";
+ }
+ QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"), mTextFileName.c_str(), Extensions);
+ if (!fileName.isEmpty()) {
+ std::string fileformat = itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString());
+ QString fileQFormat = fileformat.c_str();
+ if (OutputListeFormat.contains(fileformat.c_str()) || fileQFormat.isEmpty()) {
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ std::string action = "Saving";
+ vvProgressDialog progress("Saving "+fileName.toStdString());
+ qApp->processEvents();
+
+ if (!mCurrentSlicerManager || !isPointsSelected()) {
+ close();
+ return;
+ }
+
+ // Output
+ mTextFileName = fileName.toStdString();
+ if (fileQFormat.isEmpty())
+ mTextFileName += ".txt";
+ ofstream fileOpen(mTextFileName.c_str(), std::ofstream::trunc);
+
+ if(!fileOpen) {
+ cerr << "Error during saving" << endl;
+ QApplication::restoreOverrideCursor();
+ close();
+ return;
+ }
+
+ vtkSmartPointer<vtkFloatArray> arrX = vtkSmartPointer<vtkFloatArray>::New();
+ vtkSmartPointer<vtkFloatArray> arrY = vtkSmartPointer<vtkFloatArray>::New();
+ vtkSmartPointer<vtkFloatArray> coords = vtkSmartPointer<vtkFloatArray>::New();
+ arrX = mFilter->GetArrayX();
+ arrY = mFilter->GetArrayY();
+ coords = mFilter->GetCoord();
+ double *tuple;
+ tuple = new double[mCurrentSlicerManager->GetImage()->GetNumberOfDimensions()];
+ int i(0);
+ fileOpen << "The Bresenham algorithm is used to travel along the line. Values represent the center of each crossed voxel (in voxel and mm)" << endl;
+ fileOpen << "Id" << "\t" << "Value" << "\t" ;
+ fileOpen << "x(vox)" << "\t" << "y(vox)" << "\t";
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() >=3)
+ fileOpen << "z(vox)" << "\t";
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() >=4)
+ fileOpen << "t" << "\t";
+ fileOpen << "x(mm)" << "\t" << "y(mm)" << "\t";
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() >=3)
+ fileOpen << "z(mm)" << "\t";
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() >=4)
+ fileOpen << "t" << "\t";
+ fileOpen << endl;
+
+ while (i<arrX->GetNumberOfTuples()) {
+ fileOpen << i << "\t" << arrY->GetTuple(i)[0] << "\t" ;
+
+ coords->GetTuple(i, tuple);
+ for (int j=0; j<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() ; ++j) {
+ fileOpen << tuple[j] << "\t" ;
+ }
+ int j(0);
+ while (j<mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() && j<3) {
+ fileOpen << tuple[j]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[j]+mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[j] << "\t" ;
+ ++j;
+ }
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() == 4) {
+ fileOpen << tuple[3] << "\t" ;
+ }
+ fileOpen << endl;
+ ++i;
+ }
+
+ delete [] tuple;
+
+ fileOpen.close();
+ QApplication::restoreOverrideCursor();
+ } else {
+ QString error = fileformat.c_str();
+ error += " format unknown !!!\n";
+ QMessageBox::information(this,tr("Saving Problem"),error);
+ SaveAs();
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::DeleteLine(int slicer)
+{
+ if (!mPoint1Selected && !mPoint2Selected)
+ return;
+
+ if(mCurrentSlicerManager) {
+ if(mCurrentSlicerManager->GetSelectedSlicer() != -1) {
+ mCurrentSlicerManager->GetSlicer(slicer)->GetRenderer()->RemoveActor(mLineActors[slicer]);
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::DisplayLine(int slicer)
+{
+ if (!mPoint1Selected && !mPoint2Selected)
+ return;
+
+ if(mCurrentSlicerManager) {
+ if(mCurrentSlicerManager->GetSelectedSlicer() != -1) {
+ double currentSlice = (mCurrentSlicerManager->GetSlicer(slicer)->GetSlice()*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetInput()->GetSpacing()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetInput()->GetOrigin()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()] - mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()] )/ mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()];
+ if (std::min(mPoint1[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()],mPoint2[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()]) <= currentSlice && std::max(mPoint1[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()],mPoint2[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()]) >= currentSlice) {
+ vtkSmartPointer<vtkBox> clippingBox = vtkSmartPointer<vtkBox>::New();
+ double extent[6];
+ for (int j=0; j<6; ++j) {
+ extent[j] = mCurrentSlicerManager->GetSlicer(slicer)->GetExtent()[j];
+ }
+ extent[2*mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()] = mCurrentSlicerManager->GetSlicer(slicer)->GetImageActor()->GetBounds()[ mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()*2 ]-fabs(mCurrentSlicerManager->GetSlicer(slicer)->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()]);
+ extent[2*mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()+1] = mCurrentSlicerManager->GetSlicer(slicer)->GetImageActor()->GetBounds()[ mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()*2+1 ]+fabs(mCurrentSlicerManager->GetSlicer(slicer)->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[mCurrentSlicerManager->GetSlicer(slicer)->GetOrientation()]);
+ clippingBox->SetBounds(extent);
+
+ vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
+ clipper->SetClipFunction(clippingBox);
+#if VTK_MAJOR_VERSION <= 5
+ clipper->SetInput(mLinesPolyData);
+#else
+ mLineTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+ mLineTransform->SetInputData(mLinesPolyData);
+ mLineTransform->SetTransform(mCurrentSlicerManager->GetSlicer(slicer)->GetConcatenatedTransform()->GetInverse());
+ clipper->SetInputConnection(mLineTransform->GetOutputPort());
+#endif
+ clipper->InsideOutOff();
+ clipper->Update();
+ vtkSmartPointer<vtkPolyDataMapper> lineMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+#if VTK_MAJOR_VERSION <= 5
+ lineMapper->SetInput(clipper->GetOutput());
+#else
+ lineMapper->SetInputData(clipper->GetOutput());
+#endif
+
+ mLineActors[slicer]->SetMapper(lineMapper);
+ mLineActors[slicer]->GetProperty()->SetOpacity(0.995);
+
+ mCurrentSlicerManager->GetSlicer(slicer)->GetRenderer()->AddActor(mLineActors[slicer]);
+ }
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::InitializeLine()
+{
+ if(mCurrentSlicerManager) {
+
+ mLinesPolyData = vtkSmartPointer<vtkPolyData>::New();
+
+ vtkSmartPointer<vtkPoints> pts = vtkSmartPointer<vtkPoints>::New();
+ double pos[4];
+ pos[0] = pos[1] = pos[2] = pos[3] = 0;
+ pts->InsertNextPoint(pos);
+ pts->InsertNextPoint(pos);
+ mLinesPolyData->SetPoints(pts);
+
+ vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
+ vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
+ line->GetPointIds()->SetId(0, 0); // the second 0 is the index of the 1st point in mLinesPolyData's points (pts)
+ line->GetPointIds()->SetId(1, 1); // the second 1 is the index of the 2nd point in mLinesPolyData's points (pts)
+ lines->InsertNextCell(line);
+ mLinesPolyData->SetLines(lines);
+
+ unsigned char red[3] = { 255, 0, 0 };
+ vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New();
+ colors->SetNumberOfComponents(3);
+ colors->InsertNextTupleValue(red);
+ mLinesPolyData->GetCellData()->SetScalars(colors);
+
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mLineActors.push_back(vtkSmartPointer<vtkActor>::New());
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolProfile::SetPoints()
+{
+ if (!mPoint1Selected && !mPoint2Selected)
+ return;
+
+ if(mCurrentSlicerManager) {
+ if(mCurrentSlicerManager->GetSelectedSlicer() != -1) {
+ /*double *pos;
+ pos = new double [4];
+ pos[0] = pos[1] = pos[2] = pos[3] = 0;
+
+ int i(0);
+ while (i<3) {
+ pos[i] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetCursorPosition()[i];
+ ++i;
+ }
+ if (mCurrentSlicerManager->GetImage()->GetNumberOfDimensions() == 4) {
+ pos[3] = mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetTSlice();
+ } */
+
+ double p0[4], p1[4];
+ p0[0] = mPoint1[0]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[0] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[0];
+ p0[1] = mPoint1[1]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[1] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[1];
+ p0[2] = mPoint1[2]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[2] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[2];
+ p0[3] = mPoint1[3];
+
+ p1[0] = mPoint2[0]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[0] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[0];
+ p1[1] = mPoint2[1]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[1] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[1];
+ p1[2] = mPoint2[2]*mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetSpacing()[2] + mCurrentSlicerManager->GetSlicer(mCurrentSlicerManager->GetSelectedSlicer())->GetImage()->GetVTKImages()[mCurrentSlicerManager->GetTSlice()]->GetOrigin()[2];
+ p1[3] = mPoint2[3];
+
+ vtkSmartPointer<vtkPoints> pts = mLinesPolyData->GetPoints();
+ pts->SetPoint(0,p0);
+ pts->SetPoint(1,p1);
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
+
--- /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
+===========================================================================**/
+#ifndef VVTOOLPROFILE_H
+#define VVTOOLPROFILE_H
+
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
+#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
+
+#include "vvToolBase.h"
+#include "vvToolWidgetBase.h"
+#include "vvImageContour.h"
+#include "vvLandmarks.h"
+#include "ui_vvToolProfile.h"
+#include "vvBinaryImageOverlayActor.h"
+
+#include "clitkProfileImage_ggo.h"
+#include "clitkProfileImageGenericFilter.h"
+#include <vtkTable.h>
+#include <vtkContextView.h>
+#include <vtkContextScene.h>
+#include <vtkTransformPolyDataFilter.h>
+
+//------------------------------------------------------------------------------
+class vvToolProfile:
+ public vvToolWidgetBase,
+ public vvToolBase<vvToolProfile>,
+ private Ui::vvToolProfile
+{
+ Q_OBJECT
+ public:
+ vvToolProfile(vvMainWindowBase * parent=0, Qt::WindowFlags f=0);
+ ~vvToolProfile();
+
+ //-----------------------------------------------------
+ static void Initialize();
+ void InitializeLine();
+ void GetArgsInfoFromGUI();
+ virtual void InputIsSelected(vvSlicerManager * m);
+
+ bool isPointsSelected();
+ void computeProfile();
+ void SetPoints();
+
+ //-----------------------------------------------------
+ public slots:
+ virtual void apply();
+ virtual bool close();
+ virtual void reject();
+
+ void selectPoint1();
+ void selectPoint2();
+ void cancelPoints();
+ void SaveAs();
+ void DisplayLine(int);
+ void DeleteLine(int);
+
+ protected:
+ void RemoveVTKObjects();
+ virtual void closeEvent(QCloseEvent *event);
+ Ui::vvToolProfile ui;
+ args_info_clitkProfileImage mArgsInfo;
+
+ double* mPoint1;
+ double* mPoint2;
+ bool mPoint1Selected;
+ bool mPoint2Selected;
+ vtkSmartPointer<vtkContextView> mView;
+ clitk::ProfileImageGenericFilter::Pointer mFilter;
+ std::string mTextFileName;
+ std::vector<vtkSmartPointer<vtkActor> > mLineActors;
+ vtkSmartPointer<vtkPolyData> mLinesPolyData;
+ vtkSmartPointer<vtkTransformPolyDataFilter> mLineTransform;
+
+
+}; // end class vvToolProfile
+//------------------------------------------------------------------------------
+
+#endif
+
#include "vvImageWriter.h"
#include "vvROIActor.h"
#include "vvSlicer.h"
-#include "vvROIActor.h"
#include "vvMeshReader.h"
#include "vvStructSelector.h"
#include "vvToolManager.h"
ADD_TOOL(vvToolROIManager);
//------------------------------------------------------------------------------
+int vvToolROIManager::nbTotalROI = 0;
+
//------------------------------------------------------------------------------
vvToolROIManager::vvToolROIManager(vvMainWindowBase * parent, Qt::WindowFlags f):
QWidget(parent->GetTab()),
vvToolBase<vvToolROIManager>(parent),
Ui::vvToolROIManager()
-{
+{
// Store parent
mMainWindow = parent;
//------------------------------------------------------------------------------
vvToolROIManager::~vvToolROIManager()
-{
+{
mROIActorsList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// STATIC
-void vvToolROIManager::Initialize() {
+void vvToolROIManager::Initialize()
+{
SetToolName("ROIManager");
SetToolMenuName("Open ROI (binary image or RT-STRUCT)");
SetToolIconFilename(":/common/icons/tool-roi.png");
//------------------------------------------------------------------------------
void vvToolROIManager::InitializeNewTool(bool ReadStateFlag)
-{
+{
// Check if we need to start a new tool or read in the state file to load
if (ReadStateFlag == false) {
// Select the current image as the target
}
// Display tool in the correct tab
- QWidget * tab = qFindChild<QWidget*>(mMainWindow->GetTab(), "ROItab");
+ QWidget * tab = mMainWindow->GetTab()->findChild<QWidget*>("ROItab");
tab->layout()->addWidget(this);
// If not read in a file we start automatically the browser to load
connect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
connect(mReloadButton, SIGNAL(clicked()), this, SLOT(ReloadCurrentROI()));
connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
- connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
+ connect(mContourCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleContourROIToggled(int)));
connect(mCloseButton, SIGNAL(clicked()), this, SLOT(close()));
+ connect(mRemoveButton, SIGNAL(clicked()), this, SLOT(RemoveROI()));
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolROIManager::InputIsSelected(vvSlicerManager *m)
-{
+{
// Initialization
mCurrentSlicerManager = m;
mCurrentImage = mCurrentSlicerManager->GetImage();
- // Refuse if non 3D image
- if (mCurrentImage->GetNumberOfDimensions() != 3) {
- QMessageBox::information(this,tr("Warning"), tr("Warning 3D ROI on a 4D image will results in some display bugs"));
- //close();
- //return;
- }
-
// Change gui
mLabelInputInfo->setText(QString("%1").arg(m->GetFileName().c_str()));
//------------------------------------------------------------------------------
void vvToolROIManager::AnImageIsBeingClosed(vvSlicerManager * m)
-{
+{
if (m == mCurrentSlicerManager) {
close();
return;
}
//------------------------------------------------------------------------------
+void vvToolROIManager::RemoveROI()
+{
+
+ // Search the indice of the selected ROI
+ QList<QTreeWidgetItem *> l = mTree->selectedItems();
+ if (l.size() == 0)
+ return;
+
+ QTreeWidgetItem * w = l[0];
+ if (w == NULL) return;
+ if (w == 0) return;
+ if (mMapTreeWidgetToROI.find(w) == mMapTreeWidgetToROI.end()) {
+ return;
+ }
+
+ clitk::DicomRT_ROI * roi = mMapTreeWidgetToROI[w];
+ if (roi == NULL) return;
+
+ // Get selected roi actor
+ int n = roi->GetROINumber();
+
+ disconnect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
+ mROIActorsList[n]->RemoveActors();
+ mROIActorsList.erase(mROIActorsList.begin()+n);
+ mROIList.erase(mROIList.begin()+n);
+ mTreeWidgetList.erase(mTreeWidgetList.begin()+n);
+
+ for (int i = n; i < mROIActorsList.size(); ++i) {
+ mROIList[i]->SetROINumber(i);
+ mTreeWidgetList[i].data()->setText(0, QString("%1").arg(mROIList[i]->GetROINumber()));
+ }
+ connect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
+ for(int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mCurrentSlicerManager->GetSlicer(i)->Render();
+ }
+}
+//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolROIManager::close()
-{
+{
disconnect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
disconnect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
disconnect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
disconnect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
disconnect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
disconnect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
+ disconnect(mRemoveButton, SIGNAL(clicked()), this, SLOT(RemoveROI()));
// Remove actors
for (unsigned int i = 0; i < mROIActorsList.size(); i++) {
//------------------------------------------------------------------------------
-void vvToolROIManager::SelectedImageHasChanged(vvSlicerManager * m) {
-
+void vvToolROIManager::SelectedImageHasChanged(vvSlicerManager * m)
+{
if (mCurrentSlicerManager == NULL) return;
if (m == NULL) return;
if (m != mCurrentSlicerManager) hide();
//------------------------------------------------------------------------------
void vvToolROIManager::Open()
-{
+{
// Open images
QString Extensions = "Images or Dicom-Struct files ( *.mha *.mhd *.hdr *.his *.dcm RS*)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvToolROIManager::OpenBinaryImage(QStringList & filename)
-{
+{
if (filename.size() == 0) return;
vvProgressDialog p("Reading ROI ...", true);
//------------------------------------------------------------------------------
void vvToolROIManager::OpenDicomImage(std::string filename)
-{
+{
// GUI selector of roi
vvMeshReader reader;
reader.SetFilename(filename);
std::string name,
std::string filename,
double BG, bool modeBG)
-{
+{
// Check Dimension
int dim = mCurrentImage->GetNumberOfDimensions();
int bin_dim = binaryImage->GetNumberOfDimensions();
}
// Compute roi index
- int n = mROIList.size();
-
+
+ int n = nbTotalROI;
+ ++nbTotalROI;
// Compute the name of the new ROI
// std::ostringstream oss;
// oss << vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
// Create ROI
clitk::DicomRT_ROI::Pointer roi = clitk::DicomRT_ROI::New();
- roi->SetFromBinaryImage(binaryImage, n, name, color, filename);
+ roi->SetFromBinaryImage(binaryImage, mROIList.size(), name, color, filename);
// Add a new roi to the list
mROIList.push_back(roi);
// CheckBox for "All"
if (actor->IsVisible()) mNumberOfVisibleROI++;
if (actor->IsContourVisible()) mNumberOfVisibleContourROI++;
-
+ AllVisibleContourROIToggled(1);
+
// Add ROI in tree
mTreeWidgetList.push_back(QSharedPointer<QTreeWidgetItem>(new QTreeWidgetItem(mTree)));
QTreeWidgetItem * w = mTreeWidgetList.back().data();
// Update
UpdateAllROIStatus();
+
+ if (mCurrentImage->GetNumberOfDimensions() > 3) {
+
+ //Modifications to avoid display bug with a 4D image
+ QSharedPointer<vvROIActor> CurrentROIActorTemp;
+ CurrentROIActorTemp = mCurrentROIActor;
+ mCurrentROIActor = actor;
+
+ int VisibleInWindow(0);
+ mCurrentSlicerManager->GetSlicer(VisibleInWindow)->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,mCurrentSlicerManager->GetSlicer(VisibleInWindow)->GetMaxCurrentTSlice());
+ mCurrentSlicerManager->GetSlicer(VisibleInWindow)->Render();
+
+ VisibleROIToggled(false);
+ VisibleROIToggled(true);
+
+ mCurrentROIActor = CurrentROIActorTemp;
+
+ }
+
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolROIManager::UpdateAllContours()
-{
+{
if (mCurrentSlicerManager == NULL) return;
// Render loaded ROIs (the first is sufficient)
for(unsigned int i=0; i<mROIList.size(); i++) {
//------------------------------------------------------------------------------
-void vvToolROIManager::UpdateAllROIStatus() {
+void vvToolROIManager::UpdateAllROIStatus()
+{
int nbVisible = 0;
+ int nbContourVisible = 0;
int nb = mROIList.size();
for(int i=0; i<nb; i++) {
if (mROIActorsList[i]->IsVisible()) {
nbVisible++;
}
+ if (mROIActorsList[i]->IsContourVisible()) {
+ nbContourVisible++;
+ }
}
// change the states
disconnect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
- disconnect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
+ disconnect(mContourCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleContourROIToggled(int)));
if (nbVisible == nb) mCheckBoxShowAll->setCheckState(Qt::Checked);
else {
if (nbVisible == 0) mCheckBoxShowAll->setCheckState(Qt::Unchecked);
else mCheckBoxShowAll->setCheckState(Qt::PartiallyChecked);
}
- connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
+ if (nbContourVisible == nb) mContourCheckBoxShowAll->setCheckState(Qt::Checked);
+ else {
+ if (nbContourVisible == 0) mContourCheckBoxShowAll->setCheckState(Qt::Unchecked);
+ else mContourCheckBoxShowAll->setCheckState(Qt::PartiallyChecked);
+ }
+ connect(mContourCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleContourROIToggled(int)));
connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvToolROIManager::SelectedItemChangedInTree() {
+void vvToolROIManager::SelectedItemChangedInTree()
+{
// Search which roi is selected
QList<QTreeWidgetItem *> l = mTree->selectedItems();
if (l.size() == 0) {
disconnect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
disconnect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
disconnect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
+ disconnect(mRemoveButton, SIGNAL(clicked()), this, SLOT(RemoveROI()));
mROInameLabel->setText(roi->GetName().c_str());
mCheckBoxShow->setChecked(actor->IsVisible());
connect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
connect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
connect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
+ connect(mRemoveButton, SIGNAL(clicked()), this, SLOT(RemoveROI()));
// Set the current color to the selected ROI name
//------------------------------------------------------------------------------
-void vvToolROIManager::VisibleROIToggled(bool b) {
+void vvToolROIManager::VisibleROIToggled(bool b)
+{
if (mCurrentROIActor == NULL) return;
if (b == mCurrentROIActor->IsVisible()) return; // nothing to do
mCurrentROIActor->SetVisible(b);
//------------------------------------------------------------------------------
-void vvToolROIManager::VisibleContourROIToggled(bool b) {
+void vvToolROIManager::VisibleContourROIToggled(bool b)
+{
if (mCurrentROIActor == NULL) return;
if (mCurrentROIActor->IsContourVisible() == b) return; // nothing to do
mCurrentROIActor->SetContourVisible(b);
mCurrentROIActor->UpdateColor();
+ UpdateAllROIStatus();
mCurrentSlicerManager->Render();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvToolROIManager::OpacityChanged(int v) {
+void vvToolROIManager::OpacityChanged(int v)
+{
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetOpacity((double)v/100.0);
mCurrentROIActor->UpdateColor();
//------------------------------------------------------------------------------
-void vvToolROIManager::AllVisibleROIToggled(int b) {
+void vvToolROIManager::AllVisibleROIToggled(int b)
+{
bool status = false;
if ((mCheckBoxShowAll->checkState() == Qt::Checked) ||
(mCheckBoxShowAll->checkState() == Qt::PartiallyChecked)) status = true;
//------------------------------------------------------------------------------
-void vvToolROIManager::AllVisibleContourROIToggled(bool b) {
+void vvToolROIManager::AllVisibleContourROIToggled(int b)
+{
bool status = false;
if ((mContourCheckBoxShowAll->checkState() == Qt::Checked) ||
(mContourCheckBoxShowAll->checkState() == Qt::PartiallyChecked)) status = true;
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeColor() {
+void vvToolROIManager::ChangeColor()
+{
if (mCurrentROIActor == NULL) return;
QColor color;
color.setRgbF(mCurrentROIActor->GetROI()->GetDisplayColor()[0],
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeContourColor() {
+void vvToolROIManager::ChangeContourColor()
+{
if (mCurrentROIActor == NULL) return;
QColor color;
color.setRgbF(mCurrentROIActor->GetContourColor()[0],
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeContourWidth(int n) {
+void vvToolROIManager::ChangeContourWidth(int n)
+{
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetContourWidth(n);
mCurrentROIActor->UpdateColor();
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeDepth(int n) {
+void vvToolROIManager::ChangeDepth(int n)
+{
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetDepth(n);
// mCurrentROIActor->UpdateImage(); // FIXME
//------------------------------------------------------------------------------
-void vvToolROIManager::ReloadCurrentROI() {
+void vvToolROIManager::ReloadCurrentROI()
+{
if (mCurrentROI->GetFilename() == "") {
return; // do nothing (contour from rt struct do not reload)
}
//------------------------------------------------------------------------------
void vvToolROIManager::SaveState(std::auto_ptr<QXmlStreamWriter> & m_XmlWriter)
-{
+{
// Get index of the image
int n = mMainWindow->GetSlicerManagers().size();
int index=-1;
//------------------------------------------------------------------------------
void vvToolROIManager::ReadXMLInformation()
-{
+{
std::string value="";
mInitialImageIndex = -1;
while (!(m_XmlReader->isEndElement() && value == GetToolName().toStdString())) {
//------------------------------------------------------------------------------
void vvToolROIManager::ReadXMLInformation_ROI()
-{
+{
QString s;
std::string value="";
QSharedPointer<vvROIActor> param = QSharedPointer<vvROIActor>(new vvROIActor);
#ifndef VVTOOLROIMANAGER_H
#define VVTOOLROIMANAGER_H
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QSharedPointer>
#include "vvToolBase.h"
void ChangeContourWidth(int n);
void ChangeDepth(int n);
void AllVisibleROIToggled(int b);
- void AllVisibleContourROIToggled(bool b);
+ void AllVisibleContourROIToggled(int b);
void ReloadCurrentROI();
void close();
+ void RemoveROI();
vvSlicerManager * GetCurrentSlicerManager() { return mCurrentSlicerManager; }
protected:
int mNumberOfVisibleROI;
int mNumberOfVisibleContourROI;
+ static int nbTotalROI;
vtkSmartPointer<vtkLookupTable> mDefaultLUTColor;
// Go !
mFilter->Update();
mOutput = mFilter->GetOutputVVImage();
+ mOutput->GetTransform()[0]->SetMatrix(mCurrentSlicerManager->GetSlicer(0)->GetConcatenatedTransform()->GetMatrix());
AddImage(mOutput,GetOutputFileName());
close();
}
#include "vvToolBase.h"
// qt
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QTreeWidget>
//------------------------------------------------------------------------------
// vv
#include "vvToolRigidReg.h"
#include "vvSlicer.h"
+#include <vvBlendImageActor.h>
// vtk
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
+#include <vtkInformation.h>
#include <vtkTransform.h>
+#include <vtkImageActor.h>
+#include <vtkImageMapper3D.h>
+#include <vtkOpenGLImageSliceMapper.h>
// itk
#include <itkEuler3DTransform.h>
itk::Euler3DTransform<double>::Pointer euler;
euler = itk::Euler3DTransform<double>::New();
euler->SetCenter(center);
- euler->SetMatrix(rotMat);
+ try {
+#if ITK_VERSION_MAJOR > 4 || (ITK_VERSION_MAJOR == 4 && ITK_VERSION_MINOR > 6)
+ euler->SetMatrix(rotMat,0.00001);
+#else
+ euler->SetMatrix(rotMat);
+#endif
+ } catch (itk::ExceptionObject) {
+ QString warning = "The matrice is a non-orthogonal rotation matrix.\nThe manual registration doesn't work.";
+ QMessageBox msgBox(QMessageBox::Warning, tr("Reset transform"),warning, 0, this);
+ msgBox.addButton(tr("OK"), QMessageBox::AcceptRole);
+ if (msgBox.exec() == QMessageBox::AcceptRole) {
+ //SetTransform(mInitialMatrix);
+ vvToolWidgetBase::close();
+ }
+ }
euler->SetOffset(transVec);
// Modify GUI according to the new parameters
double rad = (checkBoxDegrees->checkState()==Qt::Checked)?180./itk::Math::pi:1.;
double angleDiff = euler->GetParameters()[i]-rotSBs[i]->value()/rad+2*itk::Math::pi;
angleDiff = angleDiff - 2*itk::Math::pi*itk::Math::Round<double,double>(angleDiff/(2*itk::Math::pi));
- if(angleDiff>1.e-4) {
+ if(abs(angleDiff)>1.e-4) {
rotSBs[i]->blockSignals(true);
rotSBs[i]->setValue( euler->GetParameters()[i]*rad );
rotSBs[i]->blockSignals(false);
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvToolRigidReg::ExtentMax(const double pointExtent[8][4], double maxExtent[2][3])
+{
+ double max, min;
+ for (int i=0; i<3; ++i) {
+ max = pointExtent[0][i];
+ min = pointExtent[0][i];
+ for (int j=1; j<8; ++j) {
+ if (pointExtent[j][i] > max) {
+ max = pointExtent[j][i];
+ }
+ if (pointExtent[j][i] < min) {
+ min = pointExtent[j][i];
+ }
+ }
+ maxExtent[0][i] = min;
+ maxExtent[1][i] = max;
+ }
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvToolRigidReg::Render()
{
- for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
- {
+for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
mCurrentSlicerManager->GetSlicer(i)->ForceUpdateDisplayExtent();
mCurrentSlicerManager->GetSlicer(i)->Render();
- }
+}
}
//------------------------------------------------------------------------------
Ui::vvToolRigidReg ui;
vvSlicerManager * mInput;
vtkSmartPointer<vtkMatrix4x4> mInitialMatrix;
+ void ExtentMax(const double [8][4], double [2][3]);
void SetTransform(vtkMatrix4x4 * matrix);
void GetSlidersAndSpinBoxes(std::vector<QSlider *>&transSliders, std::vector<QSlider *>&rotSliders,
std::vector<QDoubleSpinBox *>&transSBs, std::vector<QDoubleSpinBox *>&rotSBs);
#include <QMessageBox>
// vtk
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include "vtkImageContinuousErode3D.h"
#include "vtkImageContinuousDilate3D.h"
#include "vtkRenderWindow.h"
vtkImageContinuousErode3D* erode = vtkImageContinuousErode3D::New();
erode->SetKernelSize(mKernelValue,mKernelValue,mKernelValue);
vtkImageData* image = mCurrentMaskImage->GetVTKImages()[0];
+#if VTK_MAJOR_VERSION <= 5
erode->SetInput(image);
+#else
+ erode->SetInputData(image);
+#endif
erode->Update();
image->DeepCopy(erode->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
image->Update();
+#else
+ //image->Update();
+#endif
UpdateAndRenderNewMask();
erode->Delete();
QApplication::restoreOverrideCursor();
vtkImageContinuousDilate3D* dilate = vtkImageContinuousDilate3D::New();
dilate->SetKernelSize(mKernelValue,mKernelValue,mKernelValue);
vtkImageData* image = mCurrentMaskImage->GetVTKImages()[0];
+#if VTK_MAJOR_VERSION <= 5
dilate->SetInput(image);
+#else
+ dilate->SetInputData(image);
+#endif
dilate->Update();
image->DeepCopy(dilate->GetOutput());
+#if VTK_MAJOR_VERSION <= 5
image->Update();
+#else
+ //image->Update();
+#endif
UpdateAndRenderNewMask();
dilate->Delete();
QApplication::restoreOverrideCursor();
// mCurrentMousePositionInPixel[1] = Yover;
// mCurrentMousePositionInPixel[2] = Zover;
// DDV(mCurrentMousePositionInPixel, 3);
-
+#if VTK_MAJOR_VERSION <= 5
if (Xover >= image->GetWholeExtent()[0] &&
Xover <= image->GetWholeExtent()[1] &&
Yover >= image->GetWholeExtent()[2] &&
// DD("out of mask");
mCurrentLabelUnderMousePointer = 0; // BG is always 0 in CCL
}
+#else
+ if (Xover >= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0] &&
+ Xover <= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1] &&
+ Yover >= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2] &&
+ Yover <= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3] &&
+ Zover >= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4] &&
+ Zover <= image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]) {
+ if (mCurrentState == State_Default) { // inside the mask
+ mCurrentLabelUnderMousePointer = 1;
+ return;
+ }
+ else { // inside the label image
+ vtkImageData * image = mCurrentCCLImage->GetFirstVTKImageData();
+ mCurrentLabelUnderMousePointer =
+ mCurrentSlicerManager->GetSlicer(0)->GetScalarComponentAsDouble(image, Xover, Yover, Zover, ix, iy, iz, 0);
+ return;
+ }
+ }
+ else {
+ // DD("out of mask");
+ mCurrentLabelUnderMousePointer = 0; // BG is always 0 in CCL
+ }
+#endif
}
//------------------------------------------------------------------------------
#ifndef VVTOOLSEGMENTATION_H
#define VVTOOLSEGMENTATION_H
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
===========================================================================**/
#ifndef VVTOOLSIMPLEINPUTSELECTORWIDGET_H
#define VVTOOLSIMPLEINPUTSELECTORWIDGET_H
+
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include <QDialog>
#include "ui_vvToolSimpleInputSelectorWidget.h"
--- /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
+ ===========================================================================**/
+
+// vv
+#include "vvToolTest.h"
+#include "vvSlicerManager.h"
+#include "vvSlicer.h"
+#include "vvToolInputSelectorWidget.h"
+
+// clitk
+#include "clitkBinarizeImageGenericFilter.h"
+
+// vtk
+#include <vtkImageActor.h>
+#include <vtkCamera.h>
+#include <vtkImageClip.h>
+#include <vtkRenderWindow.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkRenderer.h>
+#include <vtkSphereSource.h>
+#include <vtkProperty.h>
+
+#include <itkGDCMImageIO.h>
+
+//------------------------------------------------------------------------------
+// Create the tool and automagically (I like this word) insert it in
+// the main window menu.
+ADD_TOOL(vvToolTest);
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolTest::Initialize()
+{ cout << __func__ << endl;
+ SetToolName("Test");
+ SetToolMenuName("Test");
+ SetToolIconFilename(":/common/icons/binarize.png");
+ SetToolTip("try to display a sphere.");
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+vvToolTest::vvToolTest(vvMainWindowBase * parent, Qt::WindowFlags f)
+ :vvToolWidgetBase(parent,f),
+ vvToolBase<vvToolTest>(parent),
+ Ui::vvToolTest()
+{ cout << __func__ << endl;
+ // GUI Initialization
+
+ // Connect signals & slots
+
+ // Main filter
+ mFilter = clitk::BinarizeImageGenericFilter::New();
+
+ // Set how many inputs are needed for this tool
+ AddInputSelector("Select one image", mFilter);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+vvToolTest::~vvToolTest()
+{ cout << __func__ << endl;
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+/*
+void vvToolTest::InteractiveDisplayToggled(bool b)
+{ cout << __func__ << endl;
+ mInteractiveDisplayIsEnabled = b;
+ if (!mInteractiveDisplayIsEnabled) {
+ RemoveVTKObjects();
+ } else {
+ for(unsigned int i=0; i<mImageContour.size(); i++) {
+ mImageContour[i]->ShowActors();
+ if (mRadioButtonLowerThan->isChecked())
+ mImageContourLower[i]->ShowActors();
+ }
+ if (mCurrentSlicerManager)
+ mCurrentSlicerManager->Render();
+ }
+}
+*/
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+bool vvToolTest::close()
+{ cout << __func__ << endl;
+ return vvToolWidgetBase::close();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolTest::reject()
+{ cout << __func__ << endl;
+ // DD("vvToolBinarize::reject");
+ return vvToolWidgetBase::reject();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+void vvToolTest::InputIsSelected(vvSlicerManager * m)
+{ cout << __func__ << endl;
+ mCurrentSlicerManager = m;
+
+
+ vtkSmartPointer<vtkSphereSource> sphereSource =
+ vtkSmartPointer<vtkSphereSource>::New();
+ sphereSource->SetCenter(0, 0, 0);
+ //sphereSource->SetCenter(235.351, 175.781, 141.0);
+ sphereSource->SetRadius(10.0);
+ sphereSource->Update();
+ vtkSmartPointer<vtkPolyDataMapper> sphereMapper =
+ vtkSmartPointer<vtkPolyDataMapper>::New();
+ sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
+ vtkSmartPointer<vtkActor> sphereActor =
+ vtkSmartPointer<vtkActor>::New();
+ sphereActor->SetMapper(sphereMapper);
+ sphereActor->GetProperty()->SetColor(1.0, 0.0, 0.0);
+ sphereActor->GetProperty()->SetOpacity(0.995);
+ sphereActor->SetPosition(235.351, 175.781, -10);
+
+
+ // VTK Renderer
+ vtkSmartPointer<vtkRenderer> sphereRenderer =
+ vtkSmartPointer<vtkRenderer>::New();
+ // Add Actor to renderer
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ mCurrentSlicerManager->GetSlicer(i)->GetRenderer()->AddActor(sphereActor);
+ }
+ //sphereRenderer->AddActor(sphereActor); //mettre le vvSlicer
+
+ // VTK/Qt wedded
+ //this->qvtkWidgetLeft->GetRenderWindow()->AddRenderer(leftRenderer);
+
+
+
+
+
+ // VTK objects for interactive display
+ valueChangedT1();
+
+ //connect(mThresholdSlider1, SIGNAL(valueChanged(double)), this, SLOT(valueChangedT1()));
+
+ connect(mCurrentSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
+ connect(mCurrentSlicerManager,SIGNAL(UpdateTSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
+
+ connect(mCurrentSlicerManager,SIGNAL(UpdateOrientation(int,int)),this,SLOT(UpdateSlice(int, int)));
+
+ // connect(mCurrentSlicerManager, SIGNAL(LeftButtonReleaseSignal(int)), SLOT(LeftButtonReleaseEvent(int)));
+ //InteractiveDisplayToggled(mInteractiveDisplayIsEnabled);
+
+
+
+typedef signed short InputPixelType;
+const unsigned int Dimension = 3;
+typedef itk::Image< InputPixelType, Dimension > InputImageType;
+typedef itk::ImageFileReader< InputImageType > ReaderType;
+ReaderType::Pointer reader = ReaderType::New();
+reader->SetFileName( "/home/tbaudier/BJ13/RTSTRUCT/1.2.840.113704.1.111.4140.1439902720.30/20160201/160325.000000_/2.16.840.1.113669.1919.1454339005/2.16.840.1.113669.1919.1454339005/1.2.840.10008.5.1.4.1.1.481.3.1454339000.dcm" );
+typedef itk::GDCMImageIO ImageIOType;
+ImageIOType::Pointer gdcmImageIO = ImageIOType::New();
+reader->SetImageIO( gdcmImageIO );
+try
+{
+reader->Update();
+}
+catch (itk::ExceptionObject & e)
+{
+std::cerr << "exception in file reader " << std::endl;
+std::cerr << e.GetDescription() << std::endl;
+std::cerr << e.GetLocation() << std::endl;
+return;
+}
+
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+// void vvToolBinarize::LeftButtonReleaseEvent(int slicer) {
+// DD("LeftButtonReleaseEvent");
+// for(int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+// if (i == slicer);
+// mCurrentSlicerManager->GetSlicer(i)->GetRenderWindow()->Render();
+// }
+// }
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolTest::apply()
+{ cout << __func__ << endl;
+ if (!mCurrentSlicerManager) close();
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ //GetArgsInfoFromGUI();
+
+ // Main filter
+
+
+
+ // Output
+ QApplication::restoreOverrideCursor();
+ close();
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvToolTest::UpdateSlice(int slicer,int slices)
+{ cout << __func__ << endl;
+ Update(slicer);
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvToolTest::Update(int slicer)
+{ cout << __func__ << endl;
+ if (!mCurrentSlicerManager) close();
+ mCurrentSlicerManager->Render();
+ //mImageContour[slicer]->Update(mThresholdSlider1->GetValue());
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+/* void vvToolTest::GetArgsInfoFromGUI()
+{ cout << __func__ << endl;
+
+ /* //KEEP THIS FOR READING GGO FROM FILE
+ int argc=1;
+ std::string a = "toto";
+ char * const* argv = new char*;
+ //a.c_str();
+ struct cmdline_parser_params p;
+ p.check_required = 0;
+ int good = cmdline_parser_ext(argc, argv, &args_info, &p);
+ DD(good);
+ */
+/* cmdline_parser_clitkBinarizeImage_init(&mArgsInfo); // Initialisation to default
+ bool inverseBGandFG = false;
+
+ mArgsInfo.lower_given = 1;
+ mArgsInfo.lower_arg = mThresholdSlider1->GetValue();
+ if (mRadioButtonLowerThan->isChecked()) {
+ mArgsInfo.upper_given = 1;
+ mArgsInfo.upper_arg = mThresholdSlider2->GetValue();
+ if (mArgsInfo.upper_arg<mArgsInfo.lower_arg) {
+ mArgsInfo.upper_given = 0;
+ DD("TODO : lower thres greater than greater thres ! Ignoring ");
+ }
+ }
+
+ mArgsInfo.fg_arg = mFGSlider->GetValue();
+ mArgsInfo.bg_arg = mBGSlider->GetValue();
+
+ if (inverseBGandFG) {
+ mArgsInfo.fg_arg = mFGSlider->GetValue();
+ mArgsInfo.bg_arg = mBGSlider->GetValue();
+ }
+ mArgsInfo.fg_given = 1;
+ mArgsInfo.bg_given = 1;
+
+ if (mCheckBoxUseBG->isChecked()) {
+ if (mCheckBoxUseFG->isChecked()) mArgsInfo.mode_arg = (char*)"both";
+ else mArgsInfo.mode_arg = (char*)"BG";
+ } else mArgsInfo.mode_arg = (char*)"FG";
+
+ mArgsInfo.verbose_flag = false;
+
+ // // Required (even if not used)
+ // mArgsInfo.input_given = 0;
+ // mArgsInfo.output_given = 0;
+
+ // mArgsInfo.input_arg = new char;
+ // mArgsInfo.output_arg = new char;
+} */
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvToolTest::valueChangedT1()
+{ cout << __func__ << endl;
+ // DD("valueChangedT1");
+ if (!mCurrentSlicerManager) close();
+ for(int i=0;i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+ //mImageContour[i]->Update(v);
+ }
+ mCurrentSlicerManager->Render();
+}
+//------------------------------------------------------------------------------
--- /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
+===========================================================================**/
+#ifndef VVTOOLTEST_H
+#define VVTOOLTEST_H
+
+#include <QtUiPlugin/QDesignerExportWidget>
+
+#include "vvToolBase.h"
+#include "vvToolWidgetBase.h"
+#include "vvImageContour.h"
+#include "ui_vvToolTest.h"
+
+
+//------------------------------------------------------------------------------
+class vvToolTest:
+ public vvToolWidgetBase,
+ public vvToolBase<vvToolTest>,
+ private Ui::vvToolTest
+{
+ Q_OBJECT
+ public:
+ vvToolTest(vvMainWindowBase * parent=0, Qt::WindowFlags f=0);
+ ~vvToolTest();
+
+ //-----------------------------------------------------
+ static void Initialize();
+ //void GetArgsInfoFromGUI();
+ virtual void InputIsSelected(vvSlicerManager * m);
+
+ //-----------------------------------------------------
+ public slots:
+ virtual bool close();
+ virtual void reject();
+ virtual void apply();
+ void UpdateSlice(int slicer,int slices);
+ void valueChangedT1();
+
+ protected:
+ Ui::vvToolTest ui;
+
+ void Update(int slicer);
+
+}; // end class vvToolTest
+//------------------------------------------------------------------------------
+
+#endif
+
vvToolWidgetBase::vvToolWidgetBase(vvMainWindowBase * parent, Qt::WindowFlags f, bool initialize):
QWidget(parent, f),
Ui::vvToolWidgetBase()
-{
+{
mMainWindow = parent;
setAttribute(Qt::WA_DeleteOnClose);
if (initialize) Initialization();
//------------------------------------------------------------------------------
void vvToolWidgetBase::Initialization()
-{
+{
mCurrentSlicerManager = 0;
mIsInitialized = false;
mFilter = 0;
//------------------------------------------------------------------------------
vvToolWidgetBase::~vvToolWidgetBase()
-{
+{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::keyPressEvent(QKeyEvent *event)
-{
+{
if (event->key() == Qt::Key_Escape) {
reject();
event->accept();
//------------------------------------------------------------------------------
void vvToolWidgetBase::accept()
-{
+{
apply();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::reject()
-{
+{
close();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::AddInputSelector(QString s, clitk::ImageToImageGenericFilterBase * f, bool allowSkip)
-{
+{
int j=0;
mFilter = f;
mSlicerManagersCompatible.clear();
//------------------------------------------------------------------------------
void vvToolWidgetBase::AddInputSelector(QString s, bool allowSkip)
-{
+{
mSlicerManagersCompatible.clear();
for(unsigned int i=0; i<mMainWindow->GetSlicerManagers().size(); i++) {
mSlicerManagersCompatible.push_back(mMainWindow->GetSlicerManagers()[i]);
//------------------------------------------------------------------------------
void vvToolWidgetBase::HideInputSelector()
-{
+{
mToolInputSelectionWidget->hide();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::show()
-{
+{
if (!mIsInitialized) {
mToolInputSelectionWidget->Initialize();
mIsInitialized = true;
//------------------------------------------------------------------------------
void vvToolWidgetBase::closeEvent(QCloseEvent *event)
-{
+{
mIsAnotherToolWaitInput = false;
if (isWindow()) {
event->accept();//return QWidget::close();
//------------------------------------------------------------------------------
bool vvToolWidgetBase::close()
-{
+{
QApplication::restoreOverrideCursor();
return QWidget::close();
}
//------------------------------------------------------------------------------
void vvToolWidgetBase::AnImageIsBeingClosed(vvSlicerManager * m)
-{
+{
mToolInputSelectionWidget->AnImageIsBeingClosed(m);
if (m == mCurrentSlicerManager) {
close();
//------------------------------------------------------------------------------
void vvToolWidgetBase::SwapCurrentWidget()
-{
+{
mStaticWidgetForTab->setUpdatesEnabled(false);
QList<QObject*> l =mStaticWidgetForTab->children();
for(int i=1; i<l.size(); i++) {
//------------------------------------------------------------------------------
void vvToolWidgetBase::SelectedImageHasChanged(vvSlicerManager * m)
-{
+{
if (!isWindow()) { // When the tool is not in a window, it is in a tab : we only display if needed
if (mCurrentSlicerManager == NULL) return;
if (mToolWidget == NULL) return;
//------------------------------------------------------------------------------
void vvToolWidgetBase::InitializeInputs()
-{
+{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::InputIsSelected()
-{
+{
mMainButtonBox->setEnabled(true);
std::vector<vvSlicerManager*> & l = mToolInputSelectionWidget->GetSelectedInputs();
mCurrentSlicerManager = l[0];
//------------------------------------------------------------------------------
void vvToolWidgetBase::InputIsSelected(vvSlicerManager * m)
-{
+{
std::cerr << "You MUST overwrite this method vvToolWidgetBase::InputIsSelected(vvSlicerManager * m) if you use one single input" << std::endl;
exit(0);
}
//------------------------------------------------------------------------------
void vvToolWidgetBase::InputIsSelected(std::vector<vvSlicerManager*> & l)
-{
+{
mMainButtonBox->setEnabled(true);
if (l.size() == 1) InputIsSelected(l[0]);
else {
#ifndef VVTOOLWIDGETBASE_H
#define VVTOOLWIDGETBASE_H
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
#include <QtDesigner/QDesignerExportWidget>
+#else
+#include <QtUiPlugin/QDesignerExportWidget>
+#endif
#include "ui_vvToolWidgetBase.h"
#include "clitkImageToImageGenericFilter.h"
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff
