ThresholdImageView.cxx

Go to the documentation of this file.

#include "ThresholdImageView.h"

  //=========================================================================
        ThresholdImageView::ThresholdImageView( )
  {
          _actorPresent                         =       false;
          _Z                                            =       0;
          _minValue                                     =       0;
          _maxValue                                     =       1000;
          _image                                        =       NULL;
          _imageReslicer                        =       NULL;
          _thresholdTable                       =       NULL;
          _thresholdMapper                      =       NULL;
          _thresholdActor                       =       NULL;
          _baseColorR                           =       1;
          _baseColorG                           =       0;
          _baseColorB                           =       0;
  }

  //=========================================================================
  ThresholdImageView::~ThresholdImageView()
  {
  }
  //=========================================================================


//----------------------------------------------------------------------------
void ThresholdImageView::SetImage(vtkImageData* image)
{
        _image = image;
}

//----------------------------------------------------------------------------
void ThresholdImageView::SetwxVtkBaseView(wxVtkBaseView *baseview)
{
        _baseView = baseview;
}

//----------------------------------------------------------------------------
wxVtkBaseView *ThresholdImageView::GetwxVtkBaseView()
{
        return _baseView;
}

//----------------------------------------------------------------------------
void ThresholdImageView::SetZ(int z)
{
        _Z = z;
}

//----------------------------------------------------------------------------
void ThresholdImageView::SetminMaxValue(int min, int max)
{
        _minValue = min;
        _maxValue = max;
}

//----------------------------------------------------------------------------
void ThresholdImageView::onThreshold()
{
        int     z = _Z;
        double range[2];
        
        vtkImageData *img = _image;
        img->GetScalarRange(range);
        if (range[1]==0)
        {
                range[1]=255;
        }
        
        int minTot = floor (range[0]);
        int maxTot = ceil (range[1]);
        
        int minVal = floor (_minValue);
        int maxVal = floor (_maxValue);
        
        if (!_actorPresent)
        {
                if (_imageReslicer==NULL)
                {
                        _imageReslicer = vtkImageReslice::New();
                        _imageReslicer->SetInput( img );
                        _imageReslicer->SetInformationInput(img);                       
                        _imageReslicer->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
                        _imageReslicer->SetOutputDimensionality(2);
                        _imageReslicer->SetInterpolationModeToLinear();
                }
                
                _imageReslicer->SetResliceAxesOrigin(0,0,z);
                
                img = _imageReslicer->GetOutput();
                img->Update();
                img->UpdateInformation();
                
                wxVtkBaseView *baseView = _baseView;
                
                if (_thresholdTable==NULL)
                {
                        //Lookup Table
                        _thresholdTable = vtkLookupTable::New();
                        _thresholdTable->SetNumberOfTableValues(maxTot+1);
                        _thresholdTable->SetTableRange(range); 
                        _thresholdTable->SetAlphaRange(0, 1);
                        _thresholdTable->SetValueRange(0, 1);
                        _thresholdTable->SetSaturationRange(0, 0); 
                        _thresholdTable->SetRampToLinear( );
                }
                
                //Assign a fake color for the upper image, and set the white as transparent
                int i;
                for(i = minTot; i <= maxTot; i++)
                {
                        if( i >= minVal && i <= maxVal )
                        {
                                _thresholdTable->SetTableValue(i,_baseColorR,_baseColorG,_baseColorB, 1);
                        }
                        else if( i >= minTot && i < minVal )
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                        else if( i > maxVal && i < maxTot )
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                        else
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                }
                _thresholdTable->Build( );
                
                if (_thresholdMapper==NULL)
                {
                        _thresholdMapper = vtkImageMapToColors::New( );
                }
                
                _thresholdMapper->SetLookupTable( _thresholdTable );
                _thresholdMapper->SetInput( img );
                
                if (_thresholdActor==NULL)
                {
                        _thresholdActor = vtkImageActor::New( );
                        _thresholdActor->SetOpacity( 0.6 );
                        _thresholdActor->InterpolateOn(  );
                        _thresholdActor->SetPosition( 0,0, 900-1 );
                }
                
                _thresholdActor->SetInput( _thresholdMapper->GetOutput() );
                
                baseView->GetRenderer()->AddActor( _thresholdActor );
                _actorPresent = true;
        }
        else
        {
                _imageReslicer->SetResliceAxesOrigin(0,0,z);
                img = _imageReslicer->GetOutput();
                img->Update();
                img->UpdateInformation();
                
                //Assign a fake color for the upper image, and set the white as transparent
                int i;
                for(i = minTot; i <= maxTot; i++)
                {
                        if( i >= minVal && i <= maxVal )
                        {
                                _thresholdTable->SetTableValue(i,_baseColorR,_baseColorG,_baseColorB, 1);
                        }
                        else if( i >= minTot && i < minVal )
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                        else if( i > maxVal && i < maxTot )
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                        else
                        {
                                _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent
                        }
                }
                _thresholdTable->Build( );
                _thresholdMapper->SetLookupTable( _thresholdTable );
                _thresholdMapper->SetInput( img );
                _thresholdActor->SetInput( _thresholdMapper->GetOutput() );
        }
}


//----------------------------------------------------------------------------
void ThresholdImageView::onThresholdChange()
{
        if (_actorPresent)
        {
                onThreshold();
        }
}

//----------------------------------------------------------------------------
void ThresholdImageView::onThresholdInterpolation(bool interpolate)
{
        if (_thresholdActor!=NULL)
        {
                if (interpolate)
                {
                        _thresholdActor->InterpolateOn( );
                }
                else
                {
                        _thresholdActor->InterpolateOff( );
                }               
        }
}

//----------------------------------------------------------------------------
void ThresholdImageView::onThresholdChangeOpacity (int opacity)
{
        if (_actorPresent)
        {
                _thresholdActor->SetOpacity(opacity*0.1);
        }
}

//----------------------------------------------------------------------------
void ThresholdImageView::onThresholdRemove()
{
        if (_actorPresent)
        {
                wxVtkBaseView * baseView = _baseView;
                baseView->GetRenderer()->RemoveActor( _thresholdActor );
                _actorPresent = false;
        }       
}


//----------------------------------------------------------------------------
void ThresholdImageView::SetBaseColor(double r, double g, double b)
{
        _baseColorR = r;
        _baseColorG = g;
        _baseColorB = b;
}


// EOF