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();
mBinaryImage->SetOrigin(&origin[0]);
mBinaryImage->SetSpacing(&mSpacing[0]);
0, extend[1],
0, extend[2]);
mBinaryImage->AllocateScalars();
+#else
+ mBinaryImage->SetOrigin(&origin[0]);
+ mBinaryImage->SetSpacing(&mSpacing[0]);
+ mBinaryImage->SetExtent(0, extend[0],
+ 0, extend[1],
+ 0, extend[2]);
+ 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->SetInputData(extrude->GetOutput());
+#endif
//sts->SetInput(mesh);
vtkSmartPointer<vtkImageStencil> stencil=vtkSmartPointer<vtkImageStencil>::New();
+#if VTK_MAJOR_VERSION <= 5
stencil->SetStencil(sts->GetOutput());
+#else
+ stencil->SetStencilData(sts->GetOutput());
+#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"
{
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();
// vtk
#include <vtkImageData.h>
#include <vtkTransform.h>
+#include <vtkDataObject.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
+#include <vtkVersion.h>
// std
#include <cassert>
// 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])
#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 "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();
vvToolROIManager
vvToolSegmentation
## these ones are for tests (not working)
+ # vvToolTest
# vvToolFoo
# vvToolFooWithWidgetBase
# vvToolPlastimatch
#=========================================================
# Qt related commands
-find_package(Qt4 REQUIRED)
-link_directories(${QT_LIBRARY_DIR})
+find_package(Qt5Widgets REQUIRED)
+find_package(Qt5Network REQUIRED)
+find_package(Qt5Designer REQUIRED)
+link_directories(${QT5Widgets_LIBRARIES})
+link_directories(${QT5Network_LIBRARIES})
+link_directories(${QT5Designer_LIBRARIES})
-
-QT4_WRAP_CPP(vv_SRCS
+qt5_wrap_cpp(vv_SRCS
vvMainWindowBase.h
QTreePushButton.h
vvDocumentation.h
vvToolCreatorBase.h
)
-QT4_WRAP_UI(vv_UI_CXX
+qt5_wrap_ui(vv_UI_CXX
qt_ui/vvHelpDialog.ui
qt_ui/vvDocumentation.ui
qt_ui/vvDicomSeriesSelector.ui
qt_ui/vvDummyWindow.ui #For testing
)
-QT4_ADD_RESOURCES(vv_SRCS vvIcons.qrc)
+QT5_add_resources(vv_SRCS vvIcons.qrc)
# Add the autotools in the header vvToolsList.h for initialization of the dummy
# variables in vv.cxx for the tools contained in vvLib
# 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)
+ QT5_WRAP_CPP(vv_SRCS ${tool}.h)
+ QT5_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)
+ QT5_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(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 ${QT_LIBRARY_DIR}/QtCore.prl)
+ endif(EXISTS ${Qt5Widgets_LIBRARIES}/QtCore.prl)
endif(WIN32)
if(NOT QT_STATIC)
add_definitions(-DQT_DLL)
add_definitions(-DQT_THREAD_SUPPORT)
include_directories(
- ${QT_INCLUDES}
- ${QT_INCLUDE_DIR}
- ${QT_QTGUI_INCLUDE_DIR}
- ${QT_QTCORE_INCLUDE_DIR}
+ ${Qt5Widgets_INCLUDE_DIRS}
+ ${Qt5GUI_INCLUDE_DIRS}
+ ${Qt5CORE_INCLUDE_DIRS}
+ ${Qt5Network_INCLUDE_DIRS}
+ ${Qt5Designer_INCLUDE_DIRS}
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
)
#=========================================================
#Add Foundation Libraries (this should be after our libraries, since we depend
#on them)
-set(foundationLibraries clitkCommon ${ITK_LIBRARIES} QVTK vtkHybrid)
+#set(foundationLibraries clitkCommon ${ITK_LIBRARIES} QVTK vtkHybrid)
+set(foundationLibraries clitkCommon ${ITK_LIBRARIES} ${VTK_LIBRARIES})
#=========================================================
# Use CxImage to create animated gifs
endif()
#=========================================================
#Create binary and libs for tests
-set(vvExternalLibs clitkSegmentationGgoLib ${toolLibs} ${foundationLibraries} ${vvCxImage} ${QT_LIBRARIES} ${QT_QTNETWORK_LIBRARY} ${APPLE_FRAMEWORKS})
+#set(vvExternalLibs clitkSegmentationGgoLib ${toolLibs} ${foundationLibraries} ${vvCxImage} ${Qt5Widgets_LIBRARIES_DIRS} ${Qt5Network_LIBRARIES_DIRS} ${APPLE_FRAMEWORKS})
+set(vvExternalLibs clitkSegmentationGgoLib ${toolLibs} ${foundationLibraries} ${vvCxImage} Qt5::Widgets Qt5::Network Qt5::Designer ${APPLE_FRAMEWORKS})
# QtNetwork is required by vvRegisterForm
add_library(vvLib ${vv_SRCS} ${vv_UI_CXX})
--- /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>
#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:
#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()
-{
+{ //out << __func__ << endl;
mTSlice = -1;
mSlice = 0;
mColor.resize(3);
//------------------------------------------------------------------------------
vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
-{
+{ //out << __func__ << endl;
mImageActorList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::RemoveActors()
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mImageActorList.size(); i++) {
if (mSlicer != 0) {
if (mSlicer != NULL) {
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
-{
+{ //out << __func__ << endl;
mColor[0] = r;
mColor[1] = g;
mColor[2] = b;
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
-{
+{ //out << __func__ << endl;
mSlicer = slicer;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
-{
+{ //out << __func__ << endl;
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();
+#if VTK_MAJOR_VERSION <= 5
mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
+#else
+ mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
+#endif
double range[2];
mImage->GetVTKImages()[0]->GetScalarRange(range);
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);
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetOpacity(double d)
-{
+{ //out << __func__ << endl;
mAlpha = d;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
-{
+{ //out << __func__ << endl;
mImage = image;
if (modeBG) {
mBackgroundValue = bg;
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::HideActors()
-{
+{ //out << __func__ << endl;
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
for(unsigned int i=0; i<mImageActorList.size(); i++) {
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::ShowActors()
-{
+{ //out << __func__ << endl;
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
mTSlice = mSlicer->GetTSlice();
//------------------------------------------------------------------------------
void vvBinaryImageOverlayActor::UpdateColor()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if (!mSlicer) return;
if (!force) {
int maskExtent[6];
ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
+#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
SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
// set previous slice
int slice,
int * inExtent,
int * outExtent)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
/* 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() {
#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()
-{
+{ //out << __func__ << endl;
mTSlice = -1;
mSlice = 0;
mHiddenImageIsUsed = false;
//------------------------------------------------------------------------------
vvImageContour::~vvImageContour()
-{
+{ //out << __func__ << endl;
mSquaresActorList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::RemoveActors()
-{
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
// 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)
+{ //out << __func__ << endl;
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetColor(r,g,b);
+ mSquaresActorList[i]->GetProperty()->SetOpacity(0.995);
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::SetLineWidth(double w)
-{
+{ //out << __func__ << endl;
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetLineWidth(w);
}
//------------------------------------------------------------------------------
-void vvImageContour::HideActors() {
+void vvImageContour::HideActors()
+{ //out << __func__ << endl;
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
//------------------------------------------------------------------------------
-void vvImageContour::ShowActors() {
+void vvImageContour::ShowActors()
+{ //out << __func__ << endl;
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
mTSlice = mSlicer->GetTSlice();
//------------------------------------------------------------------------------
void vvImageContour::SetDepth(double d)
-{
+{ //out << __func__ << endl;
mDepth = d;
// Move the actor to be visible
double position[3] = {0, 0, 0};
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::Update(double value) {
+void vvImageContour::Update(double value)
+{ //out << __func__ << endl;
if (!mSlicer) return;
if (mPreviousValue == value) {
if (mPreviousSlice == mSlicer->GetSlice()) {
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithPreserveMemoryMode() {
+void vvImageContour::UpdateWithPreserveMemoryMode()
+{ //out << __func__ << endl;
// 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()
+{ //out << __func__ << endl;
clitkExceptionMacro("TODO : not implemented yet");
mPreviousSlice = mPreviousOrientation = 0;
int dim = mSlicer->GetImage()->GetNumberOfDimensions();
//------------------------------------------------------------------------------
-int vvImageContour::ComputeCurrentOrientation() {
+int vvImageContour::ComputeCurrentOrientation()
+{ //out << __func__ << endl;
// Get extent of image in the slicer
int* extent = mSlicer->GetImageActor()->GetDisplayExtent();
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithFastCacheMode() {
+void vvImageContour::UpdateWithFastCacheMode()
+{ //out << __func__ << endl;
clitkExceptionMacro("TODO : not implemented yet");
// Compute orientation
//------------------------------------------------------------------------------
-void vvImageContour::CreateNewActor(int numImage) {
+void vvImageContour::CreateNewActor(int numImage)
+{ //out << __func__ << endl;
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);
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)
+{ //out << __func__ << endl;
// 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();
}
//------------------------------------------------------------------------------
#define VVINTENSITYVALUESLIDER_H
// qt
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#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 <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include <QDialog>
#include "ui_vvLabelImageLoaderWidget.h"
#include <string>
#include <locale.h>
+#include <vtkVersion.h>
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkFloatArray.h"
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;
}
}
#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)
-{
+{ //out << __func__ << endl;
setupUi(this);
tableWidget->verticalHeader()->hide();
}
void vvLandmarksPanel::Load()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if (!mCurrentLandmarks->LoadFile(files))
return false;
- SetCurrentLandmarks(mCurrentLandmarks,2);
+ SetCurrentLandmarks(mCurrentLandmarks,0);
emit UpdateRenderWindows();
return true;
}
void vvLandmarksPanel::Save()
-{
+{ //out << __func__ << endl;
QString file = QFileDialog::getSaveFileName(this,
tr("Save Landmarks"),
mCurrentPath.c_str(),tr("Landmarks ( *.txt)"));
}
void vvLandmarksPanel::SelectPoint()
-{
+{ //out << __func__ << endl;
if (tableWidget->rowCount() > 0) {
QList<QTableWidgetItem *> items = tableWidget->selectedItems();
if (!items.empty()) {
void vvLandmarksPanel::RemoveSelectedPoints()
-{
+{ //out << __func__ << endl;
if (tableWidget->rowCount() > 0) {
QList<QTableWidgetItem *> items = tableWidget->selectedItems();
if (items.empty()) {
}
void vvLandmarksPanel::RemoveAllPoints()
-{
+{ //out << __func__ << endl;
mCurrentLandmarks->RemoveAll();
tableWidget->clearContents();
tableWidget->setRowCount(0);
}
void vvLandmarksPanel::AddPoint()
-{
+{ //out << __func__ << endl;
AddPoint(mCurrentLandmarks->GetNumberOfPoints()-1);
}
void vvLandmarksPanel::AddPoint(int landmarksIndex)
-{
+{ //out << __func__ << endl;
int rowIndex = tableWidget->rowCount();
// DD(rowIndex);
tableWidget->setRowCount(rowIndex+1);
}
void vvLandmarksPanel::SetCurrentLandmarks(vvLandmarks* lm,int time)
-{
+{ //out << __func__ << endl;
if (time != lm->GetTime())
return;
-
loadButton->setEnabled(1);
saveButton->setEnabled(1);
removeButton->setEnabled(1);
}
void vvLandmarksPanel::SetCurrentImage(std::string filename)
-{
+{ //out << __func__ << endl;
QString image = "<b>CurrentImage : </b>";
image += vtksys::SystemTools::GetFilenameWithoutLastExtension(filename).c_str();
nameLabel->setText(image);
}
void vvLandmarksPanel::CommentsChanged(int row, int column)
-{
+{ //out << __func__ << endl;
if (column == 6) {
mCurrentLandmarks->ChangeComments(row,std::string(tableWidget->item(row,column)->text().toStdString()));
tableWidget->resizeColumnsToContents();
#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()
-{
+{ //out << __func__ << endl;
setupUi(this); // this sets up the GUI
mInputPathName = "";
}
//------------------------------------------------------------------------------
void vvMainWindow::show()
-{
+{ //out << __func__ << endl;
vvMainWindowBase::show();
PopupRegisterForm(true);
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateMemoryUsage()
-{
+{ //out << __func__ << endl;
// clitk::PrintMemory(true);
if (clitk::GetMemoryUsageInMb() == 0) infoPanel->setMemoryInMb("NA");
else infoPanel->setMemoryInMb(QString::number(clitk::GetMemoryUsageInMb())+" MiB");
//------------------------------------------------------------------------------
void vvMainWindow::createRecentlyOpenedFilesMenu()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if(recentlyOpenedFilesMenu==NULL) {
createRecentlyOpenedFilesMenu();
} else {
//------------------------------------------------------------------------------
void vvMainWindow::ComputeMidPosition()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,"filename.vtk");
item->setData(1,Qt::UserRole,tr("contour"));
//------------------------------------------------------------------------------
void vvMainWindow::OpenVTKContour()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
QString Extensions = "Images ( *.vtk *.obj)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::AddDCStructContour(int index, QString file)
-{
+{ //out << __func__ << endl;
vvMeshReader reader;
reader.SetFilename(file.toStdString());
vvStructSelector selector;
//------------------------------------------------------------------------------
void vvMainWindow::OpenDCStructContour()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
QString Extensions = "Dicom Files ( *.dcm RS*)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::ComputeDeformableRegistration()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvDeformationDialog dialog(index,mSlicerManagers);
//------------------------------------------------------------------------------
void vvMainWindow::WarpImage()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if (!selected_slicer->GetVF().IsNull()) {
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QFileInfo info(selected_slicer->GetFileName().c_str());
//------------------------------------------------------------------------------
vvMainWindow::~vvMainWindow()
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] != NULL)
delete mSlicerManagers[i];
//------------------------------------------------------------------------------
QTabWidget * vvMainWindow::GetTab()
-{
+{ //out << __func__ << endl;
return tabWidget;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::MergeImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::SliceImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::MergeImagesWithTime()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images With Time"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::OpenDicom()
-{
+{ //out << __func__ << endl;
std::vector<std::string> files;
//std::cout << "dicomSeriesSelector " << std::endl;
//------------------------------------------------------------------------------
void vvMainWindow::OpenImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
}
//------------------------------------------------------------------------------
void vvMainWindow::OpenRecentImage()
-{
+{ //out << __func__ << endl;
QAction * caller = qobject_cast<QAction*>(sender());
std::vector<std::string> images;
images.push_back(caller->text().toStdString());
//------------------------------------------------------------------------------
void vvMainWindow::OpenImageWithTime()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::LoadedImageType filetype)
-{
+{ //out << __func__ << endl;
//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) {
+ if (!SetImageSucceed) {;
QApplication::restoreOverrideCursor();
QString error = "Cannot open file \n";
error += imageManager->GetLastError().c_str();
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()
-{
+{ //out << __func__ << endl;
DataTree->resizeColumnToContents(COLUMN_TREE);
DataTree->resizeColumnToContents(COLUMN_UL_VIEW);
DataTree->resizeColumnToContents(COLUMN_UR_VIEW);
//------------------------------------------------------------------------------
void vvMainWindow::CurrentImageChanged(std::string id)
-{
+{ //out << __func__ << endl;
if (id == mCurrentSelectedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::CurrentPickedImageChanged(std::string id)
-{
+{ //out << __func__ << endl;
if (id == mCurrentPickedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::ImageInfoChanged()
-{
+{ //out << __func__ << endl;
contextActions[6]->setEnabled(1);
contextActions[5]->setEnabled(1);
actionSave_As->setEnabled(1);
//------------------------------------------------------------------------------
void vvMainWindow::ShowDocumentation()
-{
+{ //out << __func__ << endl;
documentation->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::PopupRegisterForm(bool checkCanPush)
-{
+{ //out << __func__ << endl;
vvRegisterForm* registerForm = new vvRegisterForm(QUrl("http://www.creatis.insa-lyon.fr/~dsarrut/vvregister/write.php"), getVVSettingsPath(), getSettingsOptionFormat());
if(!checkCanPush) {
registerForm->show();
//------------------------------------------------------------------------------
void vvMainWindow::ShowHelpDialog()
-{
+{ //out << __func__ << endl;
help_dialog->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ChangeViewMode()
-{
+{ //out << __func__ << endl;
typedef struct _SIZE{
QSplitter* splitter;
QList<int> size1, size2;
//------------------------------------------------------------------------------
QString vvMainWindow::GetSizeInBytes(unsigned long size)
-{
+{ //out << __func__ << endl;
QString result = "";// QString::number(size);
//result += " bytes (";
if (size > 1000000000) {
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorDoubleAsString(std::vector<double> vectorDouble)
-{
+{ //out << __func__ << endl;
QString result;
for (unsigned int i= 0; i < vectorDouble.size(); i++) {
if (i != 0)
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorIntAsString(std::vector<int> vectorInt)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if ( column >= COLUMN_CLOSE_IMAGE || column <= 0)
return;
//------------------------------------------------------------------------------
void vvMainWindow::InitSlicers()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size()) {
mSlicerManagers.back()->GenerateDefaultLookupTable();
-
mSlicerManagers.back()->SetSlicerWindow(0,NOViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(1,NEViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(2,SOViewWidget->GetRenderWindow());
//------------------------------------------------------------------------------
void vvMainWindow::InitDisplay()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if(!mSlicerManagers[slicer]->GetSlicer(window)->GetRenderer()->GetDraw())
return;
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage(QTreeWidgetItem* item, int column)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(item);
if (DataTree->topLevelItem(index) != item) {
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage(QTreeWidgetItem* item, int column)
-{
+{ //out << __func__ << endl;
// 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)
-{
+{ //out << __func__ << endl;
infoPanel->setCurrentInfo(visibility,x,y,z,X,Y,Z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::VectorChanged(int visibility,double x, double y, double z, double value)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentVectorInfo(visibility,x,y,z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::OverlayChanged(int visibility, double valueOver, double valueRef)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentOverlayInfo(visibility,valueOver, valueRef);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::FusionChanged(int visibility, double value)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentFusionInfo(visibility,value);
}
//------------------------------------------------------------------------------
//or when UpdateWindowLevel() is called ; when slicerManager emits WindowLevelChanged
//when ImageInfoChanged() is called
void vvMainWindow::WindowLevelChanged()
-{
+{ //out << __func__ << endl;
// Base image
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if(index==-1) return;
//------------------------------------------------------------------------------
void vvMainWindow::WindowLevelEdited()
-{
+{ //out << __func__ << endl;
presetComboBox->setCurrentIndex(WL_USER);
UpdateWindowLevel();
}
//------------------------------------------------------------------------------
void vvMainWindow::SetWindowLevel(double w, double l)
-{
+{ //out << __func__ << endl;
windowSpinBox->setValue(w);
levelSpinBox->setValue(l);
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateWindowLevel()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
if (presetComboBox->currentIndex() == WL_VENTILATION) //For ventilation
colorMapComboBox->setCurrentIndex(5);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlicingPreset()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
//------------------------------------------------------------------------------
void vvMainWindow::UpdateColorMap()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetColorMap(colorMapComboBox->currentIndex());
}
//------------------------------------------------------------------------------
void vvMainWindow::SwitchWindowLevel()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
int window = mSlicerManagers[index]->GetColorWindow();
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::ApplyWindowLevelToAllImages()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
//------------------------------------------------------------------------------
void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
-{
+{ //out << __func__ << endl;
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (id == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->UpdateLinkedNavigation(refSlicer);
//------------------------------------------------------------------------------
void vvMainWindow::ShowContextMenu(QPoint point)
-{
+{ //out << __func__ << endl;
if (!DataTree->selectedItems().size()) {
contextActions[1]->setEnabled(0);
contextActions[2]->setEnabled(0);
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage()
-{
+{ //out << __func__ << endl;
CloseImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage()
-{
+{ //out << __func__ << endl;
ReloadImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SelectOverlayImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if one overlay image is added
for (int i = 0; i < files.size(); i++) {
vecFileNames.push_back(files[i].toStdString());
}
+
AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
void vvMainWindow::AddROI(int index, QString file)
-{
+{ //out << __func__ << endl;
/*
// Get slice manager
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if one fusion image is added
//------------------------------------------------------------------------------
void vvMainWindow::ResetTransformationToIdentity()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddLandmarks(int index, std::vector<std::string> files)
-{
+{ //out << __func__ << endl;
if (!landmarksPanel->LoadFromFile(files))
QMessageBox::information(this,tr("Problem reading Landmarks !"),"File doesn't exist!");
//------------------------------------------------------------------------------
void vvMainWindow::OpenField()
-{
+{ //out << __func__ << endl;
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++)
//------------------------------------------------------------------------------
void vvMainWindow::AddFieldEntry(QString filename,int index,bool from_disk)
-{
+{ //out << __func__ << endl;
//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)
-{
+{ //out << __func__ << endl;
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
vvSlicerManager* imageManager = mSlicerManagers[index];
if (imageManager->SetVF(vf,file.toStdString())) {
//------------------------------------------------------------------------------
void vvMainWindow::AddField(QString file,int index)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
mSlicerManagers[index]->SetFusionColorMap(colormap);
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionSequence()
-{
+{ //out << __func__ << endl;
//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
//------------------------------------------------------------------------------
-void vvMainWindow::SelectFusionSequenceCorrespondances() {
-
+void vvMainWindow::SelectFusionSequenceCorrespondances()
+{ //out << __func__ << endl;
//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)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
//fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
//------------------------------------------------------------------------------
void vvMainWindow::SaveAs()
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save Current Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::SaveCurrentStateAs(const std::string& stateFile)
-{
+{ //out << __func__ << endl;
vvSaveState save_state;
save_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedState()
-{
+{ //out << __func__ << endl;
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getOpenFileName(this,
tr("Load Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedStateFile(const std::string& stateFile)
-{
+{ //out << __func__ << endl;
vvReadState read_state;
read_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::LinkAllImages()
-{
+{ //out << __func__ << endl;
linkPanel->linkAll();
}
//------------------------------------------------------------------------------
void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
-{
+{ //out << __func__ << endl;
if (!fromPanel) {
// delegate to linkPanel if call came from elsewhere...
linkPanel->addLinkFromIds(image1, image2);
//------------------------------------------------------------------------------
void vvMainWindow::RemoveLink(QString image1,QString image2)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if(mSlicerManagers.size()==1)
return;
}
//------------------------------------------------------------------------------
void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == NOHorizontalSlider->value()) return;
HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
// mCurrentTime = NOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == NEHorizontalSlider->value()) return;
HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
// mCurrentTime = NEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == SOHorizontalSlider->value()) return;
HorizontalSliderMoved(SOHorizontalSlider->value(),COLUMN_DL_VIEW,2);
// mCurrentTime = SOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == SEHorizontalSlider->value()) return;
HorizontalSliderMoved(SEHorizontalSlider->value(),COLUMN_DR_VIEW,3);
// mCurrentTime = SEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NOVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == NOVerticalSlider->value()) return;
else value = NOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == NEVerticalSlider->value()) return;
else value = NEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == SOVerticalSlider->value()) return;
else value = SOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == SEVerticalSlider->value()) return;
else value = SEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlice(int slicer, int slice)
-{
+{ //out << __func__ << endl;
// DD("vvMainWindow::UpdateSlice");
// DD(slicer);
// DD(slice);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
-{
+{ //out << __func__ << endl;
//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)
-{
+{ //out << __func__ << endl;
//int position = int((min+max)/2);
int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
if (slicer == 0) {
//------------------------------------------------------------------------------
void vvMainWindow::SaveNOScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(NOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveNEScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(NEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSOScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(SOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSEScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(SEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveScreenshotAllSlices()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
if (playMode) {
playMode = 0;
playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_play.png")));
//------------------------------------------------------------------------------
void vvMainWindow::PlayNext()
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
mSlicerManagers[i]->GetSlicer(0)->UpdateLandmarks();
mSlicerManagers[i]->GetSlicer(1)->UpdateLandmarks();
//------------------------------------------------------------------------------
void vvMainWindow::SegmentationOnCurrentImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvSegmentationDialog segmentation;
//------------------------------------------------------------------------------
void vvMainWindow::SurfaceViewerLaunch()
-{
+{ //out << __func__ << endl;
vvSurfaceViewerDialog surfaceViewer;
surfaceViewer.exec();
}
//------------------------------------------------------------------------------
int vvMainWindow::GetImageDuplicateFilenameNumber(std::string filename)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
// 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()
-{
+{ //out << __func__ << endl;
int index = -1;
if (DataTree->selectedItems().size() > 0) {
index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
#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();
///Use the smallest mask in which the mesh fits
// Add two voxels on each side to make sure the mesh fits
0,ceil((bounds[3]-origin[1])/spacing[1]+4),
0,ceil((bounds[5]-origin[2])/spacing[2])+4);
binary_image->AllocateScalars();
+#else
+ ///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();
+ double * spacing=sample->GetSpacing();
+ binary_image->SetSpacing(spacing);
+
+ /// Put the origin on a voxel to avoid small skips
+ binary_image->SetOrigin(floor((bounds[0]-samp_origin[0])/spacing[0]-2)*spacing[0]+samp_origin[0],
+ floor((bounds[2]-samp_origin[1])/spacing[1]-2)*spacing[1]+samp_origin[1],
+ floor((bounds[4]-samp_origin[2])/spacing[2]-2)*spacing[2]+samp_origin[2]);
+ double * origin=binary_image->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);
+ 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->SetStencilData(sts->GetOutput());
+ 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();
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>
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 ")
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()
-{
+{ //out << __func__ << endl;
mIsVisible = true;
mIsContourVisible = false;
mOpacity = 0.5;
//------------------------------------------------------------------------------
vvROIActor::~vvROIActor()
-{
+{ //out << __func__ << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::RemoveActors()
-{
+{ //out << __func__ << endl;
for(unsigned int i= 0; i<mOverlayActors.size(); i++) {
mOverlayActors[i]->RemoveActors();
}
//------------------------------------------------------------------------------
void vvROIActor::SetROI(clitk::DicomRT_ROI * s)
-{
+{ //out << __func__ << endl;
mROI = s;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetContourWidth(int n) {
+void vvROIActor::SetContourWidth(int n)
+{ //out << __func__ << endl;
mContourWidth = n;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetSlicerManager(vvSlicerManager * s) {
+void vvROIActor::SetSlicerManager(vvSlicerManager * s)
+{ //out << __func__ << endl;
mSlicerManager = s;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::UpdateImage()
-{
+{ //out << __func__ << endl;
mOverlayActors.clear();
mImageContour.clear();
Initialize(mDepth, mIsVisible);
//------------------------------------------------------------------------------
void vvROIActor::SetVisible(bool b)
-{
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
mIsContourVisible = b;
if (!b) { // remove actor
for(unsigned int i= 0; i<mImageContour.size(); i++) {
//------------------------------------------------------------------------------
-bool vvROIActor::IsVisible() {
+bool vvROIActor::IsVisible()
+{ //out << __func__ << endl;
return mIsVisible;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-bool vvROIActor::IsContourVisible() {
+bool vvROIActor::IsContourVisible()
+{ //out << __func__ << endl;
return mIsContourVisible;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::Initialize(double depth, bool IsVisible) {
+void vvROIActor::Initialize(double depth, bool IsVisible)
+{ //out << __func__ << endl;
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(AVerticalSliderHasChanged(int, int)), SLOT(UpdateSlice(int, int)));
//------------------------------------------------------------------------------
void vvROIActor::SetDepth(double d)
-{
+{ //out << __func__ << endl;
mDepth = d;
if (!mSlicerManager) return;
for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
//------------------------------------------------------------------------------
void vvROIActor::Update(bool force)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
if (!mROI->GetImage()) return;
if ((!mIsVisible) && (!mIsContourVisible)) return;
if (!mSlicerManager) {
//------------------------------------------------------------------------------
void vvROIActor::SetOpacity(double d)
-{
+{ //out << __func__ << endl;
mOpacity = d;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::SetContourColor(double r, double v, double b) {
+void vvROIActor::SetContourColor(double r, double v, double b)
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
if (mROI)
mROI->SetDisplayColor(r,v,b);
}
//------------------------------------------------------------------------------
-std::vector<double> & vvROIActor::GetContourColor() {
+std::vector<double> & vvROIActor::GetContourColor()
+{ //out << __func__ << endl;
return mContourColor;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-std::vector<double> & vvROIActor::GetOverlayColor() {
+std::vector<double> & vvROIActor::GetOverlayColor()
+{ //out << __func__ << endl;
return mROI->GetDisplayColor();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvROIActor::UpdateColor() {
+void vvROIActor::UpdateColor()
+{ //out << __func__ << endl;
for(unsigned int i=0; i<mOverlayActors.size(); i++) {
mOverlayActors[i]->SetOpacity(mOpacity);
mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
//------------------------------------------------------------------------------
double vvROIActor::GetOpacity()
-{
+{ //out << __func__ << endl;
return mOpacity;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvROIActor::SetSelected(bool b)
-{
+{ //out << __func__ << endl;
mIsSelected = b;
if (b) {
for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
//------------------------------------------------------------------------------
void vvROIActor::CopyParameters(QSharedPointer<vvROIActor> roi)
-{
+{ //out << __func__ << endl;
// Overlay
SetVisible(roi->IsVisible());
SetOpacity(roi->GetOpacity());
#include "vvRegisterForm.h"
#include <QNetworkRequest>
#include <QDir>
+#include <QUrlQuery>
#include <QPalette>
#include "clitkConfiguration.h"
#include "vvConfiguration.h"
void vvRegisterForm::sendData(){
QUrl url2(url);
- url2.addQueryItem("name", firstName->text().toUtf8());
- url2.addQueryItem("lastName", lastName->text().toUtf8());
- url2.addQueryItem("email", email->text().toUtf8());
- url2.addQueryItem("group", group->text().toUtf8());
- url2.addQueryItem("os", OS_NAME);
- url2.addQueryItem("vvVersion", VV_VERSION);
- url2.addQueryItem("architecture", ARCHITECTURE);
- url2.addQueryItem("adressing", QString::number(sizeof(char*)*8)+"-bit");
- url2.addQueryItem("compilationDate", QString(__DATE__) + ", " + QString(__TIME__) );
-
+ 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);
+
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>
//====================================================================
vvSegmentationDialog::vvSegmentationDialog(QWidget * parent, Qt::WindowFlags f)
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>
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#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 <vtkAssignAttribute.h>
#include <vtkImageAccumulate.h>
#include <vtkImageReslice.h>
+#include <vtkOpenGLImageSliceMapper.h>
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
# 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()
-{
+{ //out << __func__ << endl;
mFusionSequenceCode = -1;
this->UnInstallPipeline();
mImage = NULL;
mReducedExtent = new int[6];
+ mRegisterExtent = new int[6];
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()
-{
+{ //out << __func__ << endl;
return mOverlayMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvBlendImageActor* vvSlicer::GetOverlayActor()
-{
+{ //out << __func__ << endl;
return mOverlayActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageMapToColors* vvSlicer::GetFusionMapper()
-{
+{ //out << __func__ << endl;
return mFusionMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageActor* vvSlicer::GetFusionActor()
-{
+{ //out << __func__ << endl;
return mFusionActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkActor* vvSlicer::GetVFActor()
-{
+{ //out << __func__ << endl;
return mVFActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkCornerAnnotation* vvSlicer::GetAnnotation()
-{
+{ //out << __func__ << endl;
return ca.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::EnableReducedExtent(bool b)
-{
+{ //out << __func__ << endl;
mUseReducedExtent = b;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetReducedExtent(int * ext)
-{
+{ //out << __func__ << endl;
copyExtent(ext, mReducedExtent);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
-{
+{ //out << __func__ << endl;
mSurfaceCutActors.push_back(new vvMeshActor());
if (propagate)
//------------------------------------------------------------------------------
void vvSlicer::ToggleContourSuperposition()
-{
+{ //out << __func__ << endl;
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
(*i)->ToggleSuperposition();
//------------------------------------------------------------------------------
void vvSlicer::SetCursorColor(int r,int g, int b)
-{
+{ //out << __func__ << endl;
pdmA->GetProperty()->SetColor(r,g,b);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCursorVisibility(bool s)
-{
+{ //out << __func__ << endl;
pdmA->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCursorVisibility()
-{
+{ //out << __func__ << endl;
return pdmA->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCornerAnnotationVisibility(bool s)
-{
+{ //out << __func__ << endl;
ca->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCornerAnnotationVisibility()
-{
+{ //out << __func__ << endl;
return ca->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvSlicer::~vvSlicer()
-{
+{ //out << __func__ << endl;
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
delete (*i);
delete [] mReducedExtent;
+ delete [] mRegisterExtent;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double* vvSlicer::GetCurrentPosition()
-{
+{ //out << __func__ << endl;
return mCurrentBeforeSlicingTransform;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
-{
+{ //out << __func__ << endl;
mCurrentBeforeSlicingTransform[0]=x;
mCurrentBeforeSlicingTransform[1]=y;
mCurrentBeforeSlicingTransform[2]=z;
//------------------------------------------------------------------------------
void vvSlicer::SetImage(vvImage::Pointer image)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
bool vis = false;
if (actor_type == "image")
vis = mImageVisibility;
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
-{
+{ //out << __func__ << endl;
if (actor_type == "image")
mImageVisibility = vis;
else if (actor_type == "vector")
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
mLandmarks = landmarks;
if (landmarks) {
mLandClipper->SetClipFunction(mClipBox);
mLandClipper->InsideOutOn();
+#if VTK_MAJOR_VERSION <= 5
mLandClipper->SetInput(mLandmarks->GetOutput());
mLandGlyph->SetSource(mCross->GetOutput());
mLandGlyph->SetInput(mLandClipper->GetOutput());
+#else
+ mLandClipper->SetInputData(mLandmarks->GetOutput());
+
+ 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);
mLandActor->GetProperty()->SetColor(255,10,212);
mLandActor->SetPickable(0);
mLandActor->SetVisibility(true);
//------------------------------------------------------------------------------
//FIXME: this function leaks memory, we should fix it someday :)
void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index)
-{
+{ //out << __func__ << endl;
if (actor_type == "vector") {
Renderer->RemoveActor(mVFActor);
mGlyphFilter=NULL;
//------------------------------------------------------------------------------
void vvSlicer::SetVFSubSampling(int sub)
-{
+{ //out << __func__ << endl;
if (mVOIFilter) {
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
mSubSampling = sub;
//------------------------------------------------------------------------------
void vvSlicer::SetVFScale(int scale)
-{
+{ //out << __func__ << endl;
mScale = scale;
if (mArrow)
mArrow->SetScale(mScale);
//------------------------------------------------------------------------------
void vvSlicer::SetVFWidth(int width)
-{
+{ //out << __func__ << endl;
mVFWidth = width;
if (mVFActor)
mVFActor->GetProperty()->SetLineWidth(mVFWidth);
//------------------------------------------------------------------------------
void vvSlicer::SetVFLog(int log)
-{
+{ //out << __func__ << endl;
mVFLog = log;
if (mGlyphFilter) {
mGlyphFilter->SetUseLog(mVFLog);
//------------------------------------------------------------------------------
void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
return mCurrentTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetMaxCurrentTSlice()
-{
+{ //out << __func__ << endl;
int t = mCurrentTSlice;
if(mOverlay)
t = std::max(t, mCurrentOverlayTSlice);
//------------------------------------------------------------------------------
int vvSlicer::GetFusionTSlice()
-{
+{ //out << __func__ << endl;
return mCurrentFusionTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetOverlayTSlice()
-{
+{ //out << __func__ << endl;
return mCurrentOverlayTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetSliceOrientation(int orientation)
-{
+{ //out << __func__ << endl;
//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)
-{
+{ //out << __func__ << endl;
// 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();
- reslice->GetOutput()->UpdateInformation();
}
//------------------------------------------------------------------------------
//----------------------------------------------------------------------------
-int * vvSlicer::GetExtent(){
+int * vvSlicer::GetExtent()
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
return this->SliceOrientation;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::UpdateDisplayExtent()
-{
+{ //out << __func__ << endl;
vtkImageData *input = this->GetInput();
+
if (!input || !this->ImageActor) {
return;
}
+
+#if VTK_MAJOR_VERSION <= 5
input->UpdateInformation();
+#endif
this->SetSlice( this->GetSlice() ); //SR: make sure the update let the slice in extents
// Local copy of extent
int w_ext[6];
int* ext = GetExtent();
copyExtent(ext, 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
+ 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 (mFirstSetSliceOrientation) {
+ copyExtent(ext, mRegisterExtent);
+ } else {
+ int w_croppingRegion[6];
+ if (mUseReducedExtent) {
+ copyExtent(mReducedExtent, w_croppingRegion);
+ } else {
+ copyExtent(mRegisterExtent, w_croppingRegion);
+ }
+ this->ImageActor->SetDisplayExtent(w_ext);
+ w_croppingRegion[ this->SliceOrientation*2 ] = this->Slice;
+ w_croppingRegion[ this->SliceOrientation*2+1 ] = this->Slice;
+ mapperOpenGL->SetCroppingRegion(w_croppingRegion);
+ }
+#endif
+
#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());
AdjustResliceToSliceOrientation(mOverlayReslice);
int overExtent[6];
this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
+#if VTK_MAJOR_VERSION <= 5
bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
+#else
+ bool out = ClipDisplayedExtent(overExtent, mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
+#endif
mOverlayActor->SetVisibility(!out);
mOverlayActor->SetDisplayExtent( overExtent );
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
AdjustResliceToSliceOrientation(mFusionReslice);
int fusExtent[6];
this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
+#if VTK_MAJOR_VERSION <= 5
bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
+#else
+ bool out = ClipDisplayedExtent(fusExtent, mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_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();
+#else
+ //this->UpdateInformation();
+#endif
this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent);
+#if VTK_MAJOR_VERSION <= 5
bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
+#else
+ 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);
+ mVFMapper->Update();
+
}
else if(mVF)
mVFActor->SetVisibility(false);
//----------------------------------------------------------------------------
void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6],
vtkImageData *targetImage, int targetExtent[6])
-{
+{ //out << __func__ << endl;
double dExtents[6];
for(unsigned int i=0; i<6; i++) {
// From source voxel coordinates to world coordinates
//----------------------------------------------------------------------------
bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
-{
+{ //out << __func__ << endl;
bool out = false;
int maxBound = 6;
//----------------------------------------------------------------------------
void vvSlicer::UpdateOrientation()
-{
+{ //out << __func__ << endl;
// Set the camera position
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
//----------------------------------------------------------------------------
void vvSlicer::SetOpacity(double s)
-{
+{ //out << __func__ << endl;
this->GetImageActor()->SetOpacity(s);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
this->GetRenderer()->ResetCamera();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
-{
+{ //out << __func__ << endl;
this->GetRenderer()->SetDraw(i);
if (i) UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
void vvSlicer::FlipHorizontalView()
-{
+{ //out << __func__ << endl;
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
//----------------------------------------------------------------------------
void vvSlicer::FlipVerticalView()
-{
+{ //out << __func__ << endl;
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
FlipHorizontalView();
//----------------------------------------------------------------------------
void vvSlicer::SetColorWindow(double window)
-{
+{ //out << __func__ << endl;
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double level = this->GetWindowLevel()->GetLevel();
//----------------------------------------------------------------------------
void vvSlicer::SetColorLevel(double level)
-{
+{ //out << __func__ << endl;
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double window = this->GetWindowLevel()->GetWindow();
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorWindow()
-{
+{ //out << __func__ << endl;
if(mOverlayMapper)
return mOverlayMapper->GetWindow();
else
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorLevel()
-{
+{ //out << __func__ << endl;
if(mOverlayMapper)
return mOverlayMapper->GetLevel();
else
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorWindow(double window)
-{
+{ //out << __func__ << endl;
if(mOverlayMapper)
mOverlayMapper->SetWindow(window);
}
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorLevel(double level)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
//Get mouse pointer position in view coordinates
double corner1[3];
double corner2[3];
}
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)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
+
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 (mFusion && mFusionActor->GetVisibility()) {
+#if VTK_MAJOR_VERSION <= 5
+ mFusionMapper->GetOutput()->SetUpdateExtent(mFusionActor->GetDisplayExtent());
+#else
+ mFusionMapper->SetUpdateExtent(mFusionActor->GetDisplayExtent());
+#endif
+ mFusionMapper->Update();
+ }
if (mLandMapper)
UpdateLandmarks();
- this->GetRenderWindow()->Render();
+ this->GetRenderWindow()->Render();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
-{
+{ //out << __func__ << endl;
pdmA->SetVisibility(true);
mCursor[0] = mCurrent[0];
mCursor[1] = mCurrent[1];
//----------------------------------------------------------------------------
void vvSlicer::UpdateLandmarks()
-{
+{ //out << __func__ << endl;
vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
if (pd->GetPoints()) {
//mLandGlyph->SetRange(0,1);
//----------------------------------------------------------------------------
void vvSlicer::SetSlice(int slice)
-{
+{ //out << __func__ << endl;
int *range = this->GetSliceRange();
if (range) {
if (slice < range[0]) {
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-int vvSlicer::GetTMax() {
+int vvSlicer::GetTMax()
+{ //out << __func__ << endl;
int tmax = (int)mImage->GetVTKImages().size() - 1;
if(mOverlay)
tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
//----------------------------------------------------------------------------
void vvSlicer::SetContourSlice()
-{
+{ //out << __func__ << endl;
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++) {
//----------------------------------------------------------------------------
void vvSlicer::ForceUpdateDisplayExtent()
-{
+{ //out << __func__ << endl;
this->UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int* vvSlicer::GetDisplayExtent()
-{
+{ //out << __func__ << endl;
return this->GetImageActor()->GetDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
-{
+{ //out << __func__ << endl;
this->Superclass::PrintSelf(os, indent);
}
//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicer::SetVFColor(double r, double g, double b)
-{
+{ //out << __func__ << endl;
double mVFColorHSV[3];
mVFColor[0] = r;
mVFColor[1] = g;
this->Render();
}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicer::SetRegisterExtent(int ext[6])
+{ //out << __func__ << endl;
+ copyExtent(ext, mRegisterExtent);
+}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicer::GetRegisterExtent(int ext[6])
+{ //out << __func__ << endl;
+ copyExtent(mRegisterExtent, ext);
+}
+//----------------------------------------------------------------------------
{
public:
static vvSlicer *New();
- vtkTypeRevisionMacro(vvSlicer,vtkImageViewer2);
+ vtkTypeMacro(vvSlicer,vtkImageViewer2);
void PrintSelf(ostream& os, vtkIndent indent);
void SetImage(vvImage::Pointer inputImages);
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]);
+
protected:
vvSlicer();
~vvSlicer();
double mVFColor[3];
bool mUseReducedExtent;
int * mReducedExtent;
- int * mInitialExtent;
+ int * mRegisterExtent;
bool mLinkOverlayWindowLevel;
bool showFusionLegend;
#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
+{ //out << __func__ << endl;\r
mFileName = "";\r
mId = "";\r
mVFName = "";\r
\r
//----------------------------------------------------------------------------\r
vvSlicerManager::~vvSlicerManager()\r
-{\r
+{ //out << __func__ << endl;\r
if (mLandmarks)\r
delete mLandmarks;\r
}\r
\r
//------------------------------------------------------------------------------\r
void vvSlicerManager::SetFilename(std::string filename, int number)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
mType = type;\r
if (mReader.IsNull())\r
mReader = vvImageReader::New();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetImage(vvImage::Pointer image)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
mFusionSequenceInvolvementCode = 0;\r
\r
mFusionName = filenames[0];\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::SetVF(std::string filename)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
return mSlicers[i];\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSlicer(int num, bool state)\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers[num]->GetImage()) {\r
mSlicers[num]->SetDisplayMode(state);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)\r
-{\r
+{ //out << __func__ << endl;\r
mSlicers[i]->SetRenderWindow(i,RW);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)\r
-{\r
+{ //out << __func__ << endl;\r
vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();\r
smc->SM = this;\r
smc->SetSlicerNumber(i);\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::LeftButtonReleaseEvent(int slicer)\r
-{\r
+{ //out << __func__ << endl;\r
emit LeftButtonReleaseSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitMousePositionUpdated(int slicer)\r
-{\r
+{ //out << __func__ << endl;\r
emit MousePositionUpdatedSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitKeyPressed(std::string KeyPress)\r
-{\r
+{ //out << __func__ << endl;\r
emit KeyPressedSignal(KeyPress);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)\r
-{\r
+{ //out << __func__ << endl;\r
mSlicers[slicer]->SetSliceOrientation(orientation);\r
emit UpdateOrientation(slicer, orientation);\r
}\r
\r
//----------------------------------------------------------------------------\r
int vvSlicerManager::GetTSlice()\r
-{\r
+{ //out << __func__ << endl;\r
return mSlicers[0]->GetTSlice();\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
if (tslice < 0)\r
tslice = 0;\r
else if (tslice > mSlicers[slicer]->GetTMax())\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetColorWindow(double s)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
mSlicers[i]->SetOpacity(1/factor);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateViews(int current,int slicer)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();\r
\r
double refPosition[3];\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorWindow() const\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers.size())\r
return mSlicers[0]->GetColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorLevel() const\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers.size())\r
return mSlicers[0]->GetColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorWindow() const\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorLevel() const\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::GetLinkOverlayWindowLevel() const\r
-{\r
+{ //out << __func__ << endl;\r
if (mSlicers.size())\r
return mSlicers[0]->GetLinkOverlayWindowLevel();\r
return -1;\r
\r
//------------------------------------------------------------------------------\r
void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
mSlicers[i]->Render();\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::GenerateDefaultLookupTable()\r
-{\r
+{ //out << __func__ << endl;\r
SetPreset(mPreset);\r
SetColorMap(mColorMap);\r
}\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Reload()\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
if (actor_type =="overlay")\r
mOverlayReader = NULL;\r
\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::RemoveActors()\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
// int view = mSlicers[slicer]->GetSliceOrientation();\r
// int slice = mSlicers[slicer]->GetSlice();\r
double x = mSlicers[slicer]->GetCursorPosition()[0];\r
int displayOver = 0;\r
int displayFus = 0;\r
double valueOver=0, valueFus=0;\r
- if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&\r
+#if VTK_MAJOR_VERSION <= 5\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
emit UpdateOverlay(displayOver,valueOver,value);\r
emit UpdateFusion(displayFus,valueFus);\r
}\r
+#else\r
+int extentImageReslice[6];\r
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
+ if (X >= extentImageReslice[0] &&\r
+ X <= extentImageReslice[1] &&\r
+ Y >= extentImageReslice[2] &&\r
+ Y <= extentImageReslice[3] &&\r
+ Z >= extentImageReslice[4] &&\r
+ Z <= 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,X,Y,Z,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
+{ //out << __func__ << endl;\r
emit currentImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Picked()\r
-{\r
+{ //out << __func__ << endl;\r
emit currentPickedImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateWindowLevel()\r
-{\r
+{ //out << __func__ << endl;\r
emit WindowLevelChanged();\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSlice(int slicer)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
int slice = mSlicers[slicer]->GetSlice();\r
\r
int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateSliceRange(int slicer)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
if (mLandmarks == NULL) {\r
mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);\r
for (unsigned int i = 0; i < mSlicers.size(); i++)\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::AddLandmark(float x,float y,float z,float t)\r
-{\r
+{ //out << __func__ << endl;\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
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(mImage->GetVTKImages()[mSlicers[0]->GetTSlice()], x_index, y_index, z_index);\r
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+ emit LandmarkAdded();\r
+ }\r
+#endif\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::PrevImage(int slicer)\r
-{\r
+{ //out << __func__ << endl;\r
emit ChangeImageWithIndexOffset(this, slicer, -1);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::NextImage(int slicer)\r
-{\r
+{ //out << __func__ << endl;\r
emit ChangeImageWithIndexOffset(this, slicer, 1);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)\r
-{\r
+{ //out << __func__ << endl;\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
+{ //out << __func__ << endl;\r
int ix, iy, iz;\r
return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);\r
}\r
#include "vtkTransform.h"
#include <cmath>
-
//------------------------------------------------------------------------------
vvSlicerManagerCommand::vvSlicerManagerCommand()
{
#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>
//----------------------------------------------------------------------------
class vvManagerCallback : public vtkCommand
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;
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#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()
-{
+{ //out << __func__ << endl;
SetToolName("Binarize");
SetToolMenuName("Binarize");
SetToolIconFilename(":/common/icons/binarize.png");
:vvToolWidgetBase(parent,f),
vvToolBase<vvToolBinarize>(parent),
Ui::vvToolBinarize()
-{
+{ //out << __func__ << endl;
// GUI Initialization
Ui_vvToolBinarize::setupUi(mToolWidget);
mInteractiveDisplayIsEnabled = mCheckBoxInteractiveDisplay->isChecked();
//------------------------------------------------------------------------------
vvToolBinarize::~vvToolBinarize()
-{
+{ //out << __func__ << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::InteractiveDisplayToggled(bool b)
-{
+{ //out << __func__ << endl;
mInteractiveDisplayIsEnabled = b;
if (!mInteractiveDisplayIsEnabled) {
RemoveVTKObjects();
//------------------------------------------------------------------------------
void vvToolBinarize::RemoveVTKObjects()
-{
+{ //out << __func__ << endl;
for(unsigned int i=0; i<mImageContour.size(); i++) {
mImageContour[i]->HideActors();
mImageContourLower[i]->HideActors();
//------------------------------------------------------------------------------
bool vvToolBinarize::close()
-{
+{ //out << __func__ << endl;
// RemoveVTKObjects();
return vvToolWidgetBase::close();
}
//------------------------------------------------------------------------------
-void vvToolBinarize::closeEvent(QCloseEvent *event) {
+void vvToolBinarize::closeEvent(QCloseEvent *event)
+{ //out << __func__ << endl;
RemoveVTKObjects();
event->accept();
}
//------------------------------------------------------------------------------
void vvToolBinarize::reject()
-{
+{ //out << __func__ << endl;
// DD("vvToolBinarize::reject");
RemoveVTKObjects();
return vvToolWidgetBase::reject();
//------------------------------------------------------------------------------
void vvToolBinarize::enableLowerThan(bool b)
-{
+{ //out << __func__ << endl;
if (!b) {
mThresholdSlider1->resetMaximum();
for(unsigned int i=0; i<mImageContour.size(); i++) {
//------------------------------------------------------------------------------
void vvToolBinarize::useFGBGtoggled(bool)
-{
+{ //out << __func__ << endl;
if (!mCheckBoxUseBG->isChecked() && !mCheckBoxUseFG->isChecked())
mCheckBoxUseBG->toggle();
}
// DD(m.size());
// }
void vvToolBinarize::InputIsSelected(vvSlicerManager * m)
-{
+{ //out << __func__ << endl;
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(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)
-{
+{ //out << __func__ << endl;
Update(slicer);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::UpdateSlice(int slicer,int slices)
-{
+{ //out << __func__ << endl;
Update(slicer);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolBinarize::Update(int slicer)
-{
+{ //out << __func__ << endl;
if (!mInteractiveDisplayIsEnabled) return;
if (!mCurrentSlicerManager) close();
mImageContour[slicer]->Update(mThresholdSlider1->GetValue());
//------------------------------------------------------------------------------
void vvToolBinarize::GetArgsInfoFromGUI()
-{
+{ //out << __func__ << endl;
/* //KEEP THIS FOR READING GGO FROM FILE
int argc=1;
//------------------------------------------------------------------------------
void vvToolBinarize::apply()
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
// DD("valueChangedT2");
if (mRadioButtonLowerThan->isChecked()) {
mThresholdSlider1->SetMaximum(v);
//------------------------------------------------------------------------------
void vvToolBinarize::valueChangedT1(double v)
-{
+{ //out << __func__ << endl;
// DD("valueChangedT1");
if (!mCurrentSlicerManager) close();
mThresholdSlider2->SetMinimum(v);
#ifndef VVTOOLBINARIZE_H
#define VVTOOLBINARIZE_H
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
#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];
}
UpdateExtent();
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);
#define VVTOOLCROPIMAGE_H
//qt
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include <QDialog>
#include <QSlider>
// vv
===========================================================================**/
#ifndef VVTOOLImageArithm_H
#define VVTOOLImageArithm_H
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
#define VVTOOLINPUTSELECTORWIDGET_H
// qt
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include <QDialog>
// vv
#include <vvImage.h>
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include "vvToolBase.h"
#include "QWidget"
#include "vvToolWidgetBase.h"
#ifndef VVTOOLMedianFilter_H
#define VVTOOLMedianFilter_H
- #include <QtDesigner/QDesignerExportWidget>
+ #include <QtUiPlugin/QDesignerExportWidget>
#include "vvToolBase.h"
#include "QWidget"
#include "vvToolWidgetBase.h"
#include "vvImageWriter.h"
#include "vvROIActor.h"
#include "vvSlicer.h"
-#include "vvROIActor.h"
#include "vvMeshReader.h"
#include "vvStructSelector.h"
#include "vvToolManager.h"
QWidget(parent->GetTab()),
vvToolBase<vvToolROIManager>(parent),
Ui::vvToolROIManager()
-{
+{ //out << __func__ << endl;
// Store parent
mMainWindow = parent;
//------------------------------------------------------------------------------
vvToolROIManager::~vvToolROIManager()
-{
+{ //out << __func__ << endl;
mROIActorsList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// STATIC
-void vvToolROIManager::Initialize() {
+void vvToolROIManager::Initialize()
+{ //out << __func__ << endl;
SetToolName("ROIManager");
SetToolMenuName("Open ROI (binary image or RT-STRUCT)");
SetToolIconFilename(":/common/icons/tool-roi.png");
//------------------------------------------------------------------------------
void vvToolROIManager::InitializeNewTool(bool ReadStateFlag)
-{
+{ //out << __func__ << endl;
// 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
//------------------------------------------------------------------------------
void vvToolROIManager::InputIsSelected(vvSlicerManager *m)
-{
+{ //out << __func__ << endl;
// Initialization
mCurrentSlicerManager = m;
mCurrentImage = mCurrentSlicerManager->GetImage();
//------------------------------------------------------------------------------
void vvToolROIManager::AnImageIsBeingClosed(vvSlicerManager * m)
-{
+{ //out << __func__ << endl;
if (m == mCurrentSlicerManager) {
close();
return;
//------------------------------------------------------------------------------
void vvToolROIManager::close()
-{
+{ //out << __func__ << endl;
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)));
//------------------------------------------------------------------------------
-void vvToolROIManager::SelectedImageHasChanged(vvSlicerManager * m) {
-
+void vvToolROIManager::SelectedImageHasChanged(vvSlicerManager * m)
+{ //out << __func__ << endl;
if (mCurrentSlicerManager == NULL) return;
if (m == NULL) return;
if (m != mCurrentSlicerManager) hide();
//------------------------------------------------------------------------------
void vvToolROIManager::Open()
-{
+{ //out << __func__ << endl;
// Open images
QString Extensions = "Images or Dicom-Struct files ( *.mha *.mhd *.hdr *.his *.dcm RS*)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvToolROIManager::OpenBinaryImage(QStringList & filename)
-{
+{ //out << __func__ << endl;
if (filename.size() == 0) return;
vvProgressDialog p("Reading ROI ...", true);
//------------------------------------------------------------------------------
void vvToolROIManager::OpenDicomImage(std::string filename)
-{
+{ //out << __func__ << endl;
// GUI selector of roi
vvMeshReader reader;
reader.SetFilename(filename);
std::string name,
std::string filename,
double BG, bool modeBG)
-{
+{ //out << __func__ << endl;
// Check Dimension
int dim = mCurrentImage->GetNumberOfDimensions();
int bin_dim = binaryImage->GetNumberOfDimensions();
// CheckBox for "All"
if (actor->IsVisible()) mNumberOfVisibleROI++;
if (actor->IsContourVisible()) mNumberOfVisibleContourROI++;
-
+ AllVisibleContourROIToggled(true);
+
// Add ROI in tree
mTreeWidgetList.push_back(QSharedPointer<QTreeWidgetItem>(new QTreeWidgetItem(mTree)));
QTreeWidgetItem * w = mTreeWidgetList.back().data();
//------------------------------------------------------------------------------
void vvToolROIManager::UpdateAllContours()
-{
+{ //out << __func__ << endl;
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()
+{ //out << __func__ << endl;
int nbVisible = 0;
int nb = mROIList.size();
for(int i=0; i<nb; i++) {
//------------------------------------------------------------------------------
-void vvToolROIManager::SelectedItemChangedInTree() {
+void vvToolROIManager::SelectedItemChangedInTree()
+{ //out << __func__ << endl;
// Search which roi is selected
QList<QTreeWidgetItem *> l = mTree->selectedItems();
if (l.size() == 0) {
//------------------------------------------------------------------------------
-void vvToolROIManager::VisibleROIToggled(bool b) {
+void vvToolROIManager::VisibleROIToggled(bool b)
+{ //out << __func__ << endl;
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)
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
if (mCurrentROIActor->IsContourVisible() == b) return; // nothing to do
mCurrentROIActor->SetContourVisible(b);
//------------------------------------------------------------------------------
-void vvToolROIManager::OpacityChanged(int v) {
+void vvToolROIManager::OpacityChanged(int v)
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetOpacity((double)v/100.0);
mCurrentROIActor->UpdateColor();
//------------------------------------------------------------------------------
-void vvToolROIManager::AllVisibleROIToggled(int b) {
+void vvToolROIManager::AllVisibleROIToggled(int b)
+{ //out << __func__ << endl;
bool status = false;
if ((mCheckBoxShowAll->checkState() == Qt::Checked) ||
(mCheckBoxShowAll->checkState() == Qt::PartiallyChecked)) status = true;
//------------------------------------------------------------------------------
-void vvToolROIManager::AllVisibleContourROIToggled(bool b) {
+void vvToolROIManager::AllVisibleContourROIToggled(bool b)
+{ //out << __func__ << endl;
bool status = false;
if ((mContourCheckBoxShowAll->checkState() == Qt::Checked) ||
(mContourCheckBoxShowAll->checkState() == Qt::PartiallyChecked)) status = true;
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeColor() {
+void vvToolROIManager::ChangeColor()
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
QColor color;
color.setRgbF(mCurrentROIActor->GetROI()->GetDisplayColor()[0],
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeContourColor() {
+void vvToolROIManager::ChangeContourColor()
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
QColor color;
color.setRgbF(mCurrentROIActor->GetContourColor()[0],
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeContourWidth(int n) {
+void vvToolROIManager::ChangeContourWidth(int n)
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetContourWidth(n);
mCurrentROIActor->UpdateColor();
//------------------------------------------------------------------------------
-void vvToolROIManager::ChangeDepth(int n) {
+void vvToolROIManager::ChangeDepth(int n)
+{ //out << __func__ << endl;
if (mCurrentROIActor == NULL) return;
mCurrentROIActor->SetDepth(n);
// mCurrentROIActor->UpdateImage(); // FIXME
//------------------------------------------------------------------------------
-void vvToolROIManager::ReloadCurrentROI() {
+void vvToolROIManager::ReloadCurrentROI()
+{ //out << __func__ << endl;
if (mCurrentROI->GetFilename() == "") {
return; // do nothing (contour from rt struct do not reload)
}
//------------------------------------------------------------------------------
void vvToolROIManager::SaveState(std::auto_ptr<QXmlStreamWriter> & m_XmlWriter)
-{
+{ //out << __func__ << endl;
// Get index of the image
int n = mMainWindow->GetSlicerManagers().size();
int index=-1;
//------------------------------------------------------------------------------
void vvToolROIManager::ReadXMLInformation()
-{
+{ //out << __func__ << endl;
std::string value="";
mInitialImageIndex = -1;
while (!(m_XmlReader->isEndElement() && value == GetToolName().toStdString())) {
//------------------------------------------------------------------------------
void vvToolROIManager::ReadXMLInformation_ROI()
-{
+{ //out << __func__ << endl;
QString s;
std::string value="";
QSharedPointer<vvROIActor> param = QSharedPointer<vvROIActor>(new vvROIActor);
#ifndef VVTOOLROIMANAGER_H
#define VVTOOLROIMANAGER_H
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include <QSharedPointer>
#include "vvToolBase.h"
#include "vvToolBase.h"
// qt
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include <QTreeWidget>
//------------------------------------------------------------------------------
// 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>
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvToolRigidReg::Render()
+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()
+{ //out << __func__ << endl;
+#if VTK_MAJOR_VERSION > 5
+vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
+vtkMatrix4x4* matrixTranspose = matrix->NewInstance();
+for (int i=0; i<3; ++i) {
+ for (int j=0; j<3; ++j)
+ {
+ matrixTranspose->SetElement(i,j,matrix->GetElement(j,i));
+ }
+}
+for (int i=0; i<4; ++i) {
+ matrixTranspose->SetElement(3,i,matrix->GetElement(3,i));
+}
+for (int i=0; i<4; ++i) {
+ matrixTranspose->SetElement(i,3,matrix->GetElement(i,3));
+}
+#endif
for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
{
+#if VTK_MAJOR_VERSION > 5
+ double pointExtent[8][4], pointExtentUpdate[8][4];
+ std::vector<int> w_ext;
+ w_ext=mCurrentSlicerManager->GetImage()->GetSize();
+ pointExtent[0][0] = 0.0;
+ pointExtent[0][1] = 0.0;
+ pointExtent[0][2] = 0.0;
+ pointExtent[0][3] = 1.0;
+ pointExtent[1][0] = w_ext[0]-1;
+ pointExtent[1][1] = w_ext[1]-1;
+ pointExtent[1][2] = w_ext[2]-1;
+ pointExtent[1][3] = 1.0;
+ pointExtent[2][0] = 0.0;
+ pointExtent[2][1] = w_ext[1]-1;
+ pointExtent[2][2] = w_ext[2]-1;
+ pointExtent[2][3] = 1.0;
+ pointExtent[3][0] = w_ext[0]-1;
+ pointExtent[3][1] = 0.0;
+ pointExtent[3][2] = w_ext[2]-1;
+ pointExtent[3][3] = 1.0;
+ pointExtent[4][0] = w_ext[0]-1;
+ pointExtent[4][1] = w_ext[1]-1;
+ pointExtent[4][2] = 0.0;
+ pointExtent[4][3] = 1.0;
+ pointExtent[5][0] = 0.0;
+ pointExtent[5][1] = 0.0;
+ pointExtent[5][2] = w_ext[2]-1;
+ pointExtent[5][3] = 1.0;
+ pointExtent[6][0] = 0.0;
+ pointExtent[6][1] = w_ext[1]-1;
+ pointExtent[6][2] = 0.0;
+ pointExtent[6][3] = 1.0;
+ pointExtent[7][0] = w_ext[0]-1;
+ pointExtent[7][1] = 0.0;
+ pointExtent[7][2] = 0.0;
+ pointExtent[7][3] = 1.0;
+
+ for (int k=0; k<8; ++k) {
+ for (int j=0; j<3; ++j)
+ {
+ pointExtent[k][j] = mCurrentSlicerManager->GetImage()->GetOrigin()[j] + mCurrentSlicerManager->GetImage()->GetSpacing()[j] * pointExtent[k][j];
+ }
+ matrixTranspose->MultiplyPoint(pointExtent[k], pointExtentUpdate[k]);
+ for (int j=0; j<3; ++j)
+ {
+ pointExtentUpdate[k][j] = (pointExtentUpdate[k][j] - mCurrentSlicerManager->GetImage()->GetOrigin()[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ }
+ }
+double extUpdateTemp[2][3];
+int extUpdate[6];
+ExtentMax(pointExtentUpdate, extUpdateTemp);
+for (int j=0; j<3; ++j) {
+ extUpdate[2*j] = 0;
+ extUpdate[2*j+1] = itk::Math::Round<double>(extUpdateTemp[1][j] - extUpdateTemp[0][j]);
+}
+ mCurrentSlicerManager->GetSlicer(i)->SetRegisterExtent(extUpdate);
+ extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+ extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+
+ vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+ try {
+ mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(mCurrentSlicerManager->GetSlicer(i)->GetImageActor()->GetMapper());
+ } catch (const std::bad_cast& e) {
+ std::cerr << e.what() << std::endl;
+ std::cerr << "Conversion error" << std::endl;
+ return;
+ }
+ mapperOpenGL->SetCroppingRegion(extUpdate);
+#endif
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 <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include "vvToolBase.h"
#include "vvToolWidgetBase.h"
===========================================================================**/
#ifndef VVTOOLSIMPLEINPUTSELECTORWIDGET_H
#define VVTOOLSIMPLEINPUTSELECTORWIDGET_H
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#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>
+
+
+//------------------------------------------------------------------------------
+// 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);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+// 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()
-{
+{ //out << __func__ << endl;
mMainWindow = parent;
setAttribute(Qt::WA_DeleteOnClose);
if (initialize) Initialization();
//------------------------------------------------------------------------------
void vvToolWidgetBase::Initialization()
-{
+{ //out << __func__ << endl;
mCurrentSlicerManager = 0;
mIsInitialized = false;
mFilter = 0;
//------------------------------------------------------------------------------
vvToolWidgetBase::~vvToolWidgetBase()
-{
+{ //out << __func__ << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::keyPressEvent(QKeyEvent *event)
-{
+{ //out << __func__ << endl;
if (event->key() == Qt::Key_Escape) {
reject();
event->accept();
//------------------------------------------------------------------------------
void vvToolWidgetBase::accept()
-{
+{ //out << __func__ << endl;
apply();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::reject()
-{
+{ //out << __func__ << endl;
close();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::AddInputSelector(QString s, clitk::ImageToImageGenericFilterBase * f, bool allowSkip)
-{
+{ //out << __func__ << endl;
int j=0;
mFilter = f;
mSlicerManagersCompatible.clear();
//------------------------------------------------------------------------------
void vvToolWidgetBase::AddInputSelector(QString s, bool allowSkip)
-{
+{ //out << __func__ << endl;
mSlicerManagersCompatible.clear();
for(unsigned int i=0; i<mMainWindow->GetSlicerManagers().size(); i++) {
mSlicerManagersCompatible.push_back(mMainWindow->GetSlicerManagers()[i]);
//------------------------------------------------------------------------------
void vvToolWidgetBase::HideInputSelector()
-{
+{ //out << __func__ << endl;
mToolInputSelectionWidget->hide();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::show()
-{
+{ //out << __func__ << endl;
if (!mIsInitialized) {
mToolInputSelectionWidget->Initialize();
mIsInitialized = true;
//------------------------------------------------------------------------------
void vvToolWidgetBase::closeEvent(QCloseEvent *event)
-{
+{ //out << __func__ << endl;
mIsAnotherToolWaitInput = false;
if (isWindow()) {
event->accept();//return QWidget::close();
//------------------------------------------------------------------------------
bool vvToolWidgetBase::close()
-{
+{ //out << __func__ << endl;
QApplication::restoreOverrideCursor();
return QWidget::close();
}
//------------------------------------------------------------------------------
void vvToolWidgetBase::AnImageIsBeingClosed(vvSlicerManager * m)
-{
+{ //out << __func__ << endl;
mToolInputSelectionWidget->AnImageIsBeingClosed(m);
if (m == mCurrentSlicerManager) {
close();
//------------------------------------------------------------------------------
void vvToolWidgetBase::SwapCurrentWidget()
-{
+{ //out << __func__ << endl;
mStaticWidgetForTab->setUpdatesEnabled(false);
QList<QObject*> l =mStaticWidgetForTab->children();
for(int i=1; i<l.size(); i++) {
//------------------------------------------------------------------------------
void vvToolWidgetBase::SelectedImageHasChanged(vvSlicerManager * m)
-{
+{ //out << __func__ << endl;
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()
-{
+{ //out << __func__ << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvToolWidgetBase::InputIsSelected()
-{
+{ //out << __func__ << endl;
mMainButtonBox->setEnabled(true);
std::vector<vvSlicerManager*> & l = mToolInputSelectionWidget->GetSelectedInputs();
mCurrentSlicerManager = l[0];
//------------------------------------------------------------------------------
void vvToolWidgetBase::InputIsSelected(vvSlicerManager * m)
-{
+{ //out << __func__ << endl;
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)
-{
+{ //out << __func__ << endl;
mMainButtonBox->setEnabled(true);
if (l.size() == 1) InputIsSelected(l[0]);
else {
#ifndef VVTOOLWIDGETBASE_H
#define VVTOOLWIDGETBASE_H
-#include <QtDesigner/QDesignerExportWidget>
+#include <QtUiPlugin/QDesignerExportWidget>
#include "ui_vvToolWidgetBase.h"
#include "clitkImageToImageGenericFilter.h"
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff