/*# --------------------------------------------------------------------- # # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image # pour la Sant�) # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton # Previous Authors : Laurent Guigues, Jean-Pierre Roux # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil # # This software is governed by the CeCILL-B license under French law and # abiding by the rules of distribution of free software. You can use, # modify and/ or redistribute the software under the terms of the CeCILL-B # license as circulated by CEA, CNRS and INRIA at the following URL # http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html # or in the file LICENSE.txt. # # As a counterpart to the access to the source code and rights to copy, # modify and redistribute granted by the license, users are provided only # with a limited warranty and the software's author, the holder of the # economic rights, and the successive licensors have only limited # liability. # # The fact that you are presently reading this means that you have had # knowledge of the CeCILL-B license and that you accept its terms. # ------------------------------------------------------------------------ */ #include "vtkImageViewer2_XYZ.h" #include "vtkRenderer.h" #include "vtkImageActor.h" #include "vtkImageData.h" #include "vtkLookupTable.h" #include "vtkObjectFactory.h" class /*VTK_COMMON_EXPORT*/ vtkLookupTableDirectionVector2 : public vtkScalarsToColors { public: // Description: // Construct with range=[0,1]; and hsv ranges set up for rainbow color table // (from red to blue). static vtkLookupTableDirectionVector2 *New(); vtkTypeMacro(vtkLookupTableDirectionVector2,vtkScalarsToColors); void PrintSelf(ostream& os, vtkIndent indent); double *GetRange() { return this->GetTableRange(); }; void SetRange(double min, double max) { this->SetTableRange(min, max); }; void SetRange(double rng[2]) { this->SetRange(rng[0], rng[1]); }; void SetTableRange(double r[2]); virtual void SetTableRange(double min, double max); vtkGetVectorMacro(TableRange,double,2); unsigned char *MapValue(double v); void GetColor(double x, double rgb[3]); void MapScalarsThroughTable2(void *input, unsigned char *output, int inputDataType, int numberOfValues, int inputIncrement, int outputIncrement); protected: double TableRange[2]; vtkLookupTableDirectionVector2(int sze=256, int ext=256); ~vtkLookupTableDirectionVector2(); private: vtkLookupTableDirectionVector2(const vtkLookupTableDirectionVector2&); // Not implemented. void operator=(const vtkLookupTableDirectionVector2&); // Not implemented. }; vtkStandardNewMacro(vtkLookupTableDirectionVector2); // Construct with range=(0,1); and hsv ranges set up for rainbow color table // (from red to blue). vtkLookupTableDirectionVector2::vtkLookupTableDirectionVector2(int sze, int ext) { this->TableRange[0] = 0.0; this->TableRange[1] = 1.0; } //---------------------------------------------------------------------------- vtkLookupTableDirectionVector2::~vtkLookupTableDirectionVector2() { } unsigned char *vtkLookupTableDirectionVector2::MapValue(double v) { //int idx = this->GetIndex(v); //return (this->Table->GetPointer(0) + 4*idx); return 0; } void vtkLookupTableDirectionVector2::GetColor(double v, double rgb[3]) { // unsigned char *rgb8 = this->MapValue(v); // rgb[0] = rgb8[0]/255.0; // rgb[1] = rgb8[1]/255.0; // rgb[2] = rgb8[2]/255.0; rgb[0] = 1; rgb[1] = 1; rgb[2] = 0; } void vtkLookupTableDirectionVector2::SetTableRange(double r[2]) { this->SetTableRange(r[0],r[1]); } //---------------------------------------------------------------------------- // Set the minimum/maximum scalar values for scalar mapping. Scalar values // less than minimum range value are clamped to minimum range value. // Scalar values greater than maximum range value are clamped to maximum // range value. void vtkLookupTableDirectionVector2::SetTableRange(double rmin, double rmax) { if (rmax < rmin) { vtkErrorMacro("Bad table range: ["<TableRange[0] == rmin && this->TableRange[1] == rmax) { return; } this->TableRange[0] = rmin; this->TableRange[1] = rmax; this->Modified(); } //---------------------------------------------------------------------------- // Although this is a relatively expensive calculation, // it is only done on the first render. Colors are cached // for subsequent renders. template void vtkLookupTableMapDirVectorEED2(vtkLookupTableDirectionVector2 *self, T *input, unsigned char *output, int length, int inIncr, int outFormat) { int i; for (i = 0; i < length; ++i) { *output++ = static_cast(input[0]); // red *output++ = static_cast(input[1]); // green *output++ = static_cast(input[2]); // blue // *output++ = 255; input = input+inIncr; } // for } //---------------------------------------------------------------------------- void vtkLookupTableDirectionVector2::MapScalarsThroughTable2(void *input, unsigned char *output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { // if (this->UseMagnitude && inputIncrement > 1) // { switch (inputDataType) { vtkTemplateMacro( vtkLookupTableMapDirVectorEED2(this,static_cast(input),output, numberOfValues,inputIncrement,outputFormat); return ); case VTK_BIT: vtkErrorMacro("Cannot comput magnitude of bit array."); break; default: vtkErrorMacro(<< "MapImageThroughTable: Unknown input ScalarType"); } /// switch // } //if } //---------------------------------------------------------------------------- void vtkLookupTableDirectionVector2::PrintSelf(ostream& os, vtkIndent indent) { this->Superclass::PrintSelf(os,indent); } //------------------------------------------------------------------- //------------------------------------------------------------------- //------------------------------------------------------------------- vtkImageViewer2_XYZ::vtkImageViewer2_XYZ() { _vtkimageviewer2 = vtkImageViewer2::New(); _vtkimageviewer2->GetRenderer()->GradientBackgroundOn(); _vtkimageviewer2->GetRenderer()->SetBackground( 0.33 , 0.33 , 0.33 ); _vtkimageviewer2->GetRenderer()->SetBackground2( 0.66 , 0.66 , 0.66 ); _colortable = NULL; } //------------------------------------------------------------------- vtkImageViewer2_XYZ::~vtkImageViewer2_XYZ() { //_vtkimageviewer2->Delete(); } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::SetExtentDimension(int x1,int x2, int y1,int y2, int z1,int z2) { _x1 = x1; _x2 = x2; _y1 = y1; _y2 = y2; _z1 = z1; _z2 = z2; } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::SetXSlice(int slice) { vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor(); imageActor->SetDisplayExtent(slice, slice, _y1, _y2, _z1, _z2 ); } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::SetYSlice(int slice) { vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor(); imageActor->SetDisplayExtent(_x1, _x2, slice, slice, _z1, _z2 ); } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::SetZSlice(int slice) { #if (VTK_MAJOR_VERSION >= 5) // _vtkimageviewer2->SetSlice( slice ); vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor(); imageActor->SetDisplayExtent(_x1, _x2, _y1, _y2, slice, slice ); #else _vtkimageviewer2->SetZSlice( slice ); #endif } //------------------------------------------------------------------- int vtkImageViewer2_XYZ::GetXSlice() { vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor(); return imageActor->GetDisplayExtent()[0]; } //------------------------------------------------------------------- int vtkImageViewer2_XYZ::GetYSlice() { vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor(); return imageActor->GetDisplayExtent()[2]; } //------------------------------------------------------------------- int vtkImageViewer2_XYZ::GetZSlice() { int result; #if (VTK_MAJOR_VERSION >= 5) result= _vtkimageviewer2->GetSlice( ); #else result= _vtkimageviewer2->GetZSlice( ); #endif return result; } //------------------------------------------------------------------- vtkImageViewer2 *vtkImageViewer2_XYZ::GetVtkImageViewer2() { return _vtkimageviewer2; } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::setColorTransferFunction(vtkColorTransferFunction* colortable) { if(colortable!=NULL && colortable->GetSize()>0 && _colortable!=colortable) { _colortable = colortable; vtkImageMapToWindowLevelColors* imagemaptowindowlevel = _vtkimageviewer2->GetWindowLevel(); imagemaptowindowlevel->SetLookupTable(_colortable); } // if colortable } //------------------------------------------------------------------- void vtkImageViewer2_XYZ::setScalarsToColors(vtkScalarsToColors* colortable, int outputformat) { /* outputformat VTK-8.1.1/Common/Core/vtkSystemIncludes.h VTK_LUMINANCE 1 VTK_LUMINANCE_ALPHA 2 VTK_RGB 3 VTK_RGBA 4 */ if( _colortable!=colortable) { _colortable = colortable; _vtkimageviewer2->GetWindowLevel()->SetOutputFormat( outputformat ); _vtkimageviewer2->GetWindowLevel()->SetLookupTable(colortable); // _vtkimageviewer2->GetWindowLevel()->SetOutputFormatToRGB(); // vtkLookupTableDirectionVector2 *_LutEED = vtkLookupTableDirectionVector2::New(); // _LutEED->SetVectorModeToRGBColors(); // _vtkimageviewer2->GetWindowLevel()->SetLookupTable(_LutEED); } // if colortable }