svkOverlayView.h

Go to the documentation of this file.

/*
 *  Copyright © 2009-2014 The Regents of the University of California.
 *  All Rights Reserved.
 *
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions are met:
 *  •   Redistributions of source code must retain the above copyright notice, 
 *      this list of conditions and the following disclaimer.
 *  •   Redistributions in binary form must reproduce the above copyright notice, 
 *      this list of conditions and the following disclaimer in the documentation 
 *      and/or other materials provided with the distribution.
 *  •   None of the names of any campus of the University of California, the name 
 *      "The Regents of the University of California," or the names of any of its 
 *      contributors may be used to endorse or promote products derived from this 
 *      software without specific prior written permission.
 *  
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
 *  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
 *  OF SUCH DAMAGE.
 */



/*
 *  $URL$
 *  $Rev$
 *  $Author$
 *  $Date$
 *
 *  Authors:
 *      Jason C. Crane, Ph.D.
 *      Beck Olson
 */

#ifndef SVK_OVERLAY_VIEW_H
#define SVK_OVERLAY_VIEW_H


#include <vtkImageViewer2.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkImageMapToWindowLevelColors.h>
#include <vtkProp3DCollection.h>
#include <vtkAreaPicker.h>
#include <vtkImageActor.h>
#include <vtkObjectFactory.h>
#include <vtkExtractEdges.h>
#include <vtkCellData.h>
#include <vtkPointData.h>
#include <vtkPlane.h>
#include <vtkColorTransferFunction.h>
#include <vtkLookupTable.h>
#include <vtkScalarBarActor.h>
#include <vtkImageGaussianSmooth.h>
#include <vtkCleanPolyData.h>

#include <svkOverlayViewController.h>
#include <svkImageViewer2.h>
#include <svkDataView.h>
#include <svk4DImageData.h>
#include <svkDataValidator.h>
#include <svkObliqueReslice.h>
#include <svkImageMapToColors.h>
#include <svkLookupTable.h>
#include <svkSatBandSet.h>
#include <svkVoxelTaggingUtils.h>
#include <svkMrsTopoGenerator.h>

#include <svkBurnResearchPixels.h>
#include <svkSincInterpolationFilter.h>

#define SINC_MAX_EXTENT 512

namespace svk {


class svkDataViewController;
class svkOverlayViewController;

class svkOverlayView : public svkDataView
{
    friend class svkOverlayViewController;
    
    public:
        // vtk type revision macro
        vtkTypeMacro( svkOverlayView, svkDataView );

        static svkOverlayView*       New();
    
        svkOverlayView();
        ~svkOverlayView();

        // Methods:
        virtual void        SetInput( svkImageData* data, int index = 0);
        virtual void        SetInputPostReslice( svkImageData* data, int index );
        virtual void        RemoveInput( int index );
        virtual void        SetSlice(int slice);
        virtual void        SetSlice(int slice, bool centerImage );
        virtual void        SetSlice(int slice, svkDcmHeader::Orientation orientation);
        virtual void        SetActiveImageVolume( int volume );
        virtual void        SetActiveOverlayVolume( int volume );
        virtual void        SetRWInteractor( vtkRenderWindowInteractor* );    
        string              GetDataCompatibility( svkImageData* data, int targetIndex );
        void                TurnOrthogonalImagesOn();
        void                TurnOrthogonalImagesOff();
        bool                AreOrthogonalImagesOn();
        void                SetOrientation( svkDcmHeader::Orientation orientation );
        void                ToggleSelBoxVisibilityOn();
        void                ToggleSelBoxVisibilityOff();
        void                AlignCamera();
        bool                IsImageInsideSpectra();
        void                SetLevel(double level);
        double              GetLevel( );
        void                SetWindow(double window );
        double              GetWindow( );
        void                SetColorOverlayWindow( double window ); 
        void                SetColorOverlayLevel( double level ); 
        double              GetColorOverlayWindow( ); 
        double              GetColorOverlayLevel( );
        bool                CheckDataOrientations();
        void                SetCameraZoom( double zoom ); 


        svkLookupTable*     GetLookupTable( );

        enum DataInputs { 
            MRI = 0, 
            MR4D = 1,
            OVERLAY = 2
        };

        enum PropType {
            VOL_SELECTION = 0, 
            SAT_BANDS_AXIAL,
            SAT_BANDS_AXIAL_OUTLINE,
            SAT_BANDS_CORONAL,
            SAT_BANDS_SAGITTAL,
            SAT_BANDS_CORONAL_OUTLINE,
            SAT_BANDS_SAGITTAL_OUTLINE,
            PLOT_GRID,
            AXIAL_OVERLAY_FRONT,
            AXIAL_OVERLAY_BACK,
            CORONAL_OVERLAY_FRONT,
            CORONAL_OVERLAY_BACK,
            SAGITTAL_OVERLAY_FRONT,
            SAGITTAL_OVERLAY_BACK,
            COORDINATES,
            COLOR_BAR,
            LAST_PROP = COLOR_BAR
        };

        enum InterpolationType {
            NEAREST = 0,
            LINEAR,
            SINC 
        };

        enum RendererType {
            PRIMARY = 0, 
            MOUSE_LOCATION,
            LAST_RENDERER = MOUSE_LOCATION
        };



        enum {
            LIGHT_ON_DARK = 0,
            DARK_ON_LIGHT
        } ColorSchema;



    protected: 
        
        svkImageViewer2*                imageViewer;   

        vtkRenderWindow*                myRenderWindow;


        bool                            toggleSelBoxVisibility;
        bool                            imageInsideSpectra;

        svkImageMapToColors*            windowLevelerAxial;
        svkImageMapToColors*            windowLevelerCoronal;
        svkImageMapToColors*            windowLevelerSagittal;


        // Holds the sinc interpolated version of the overlay
        svkSincInterpolationFilter*     sincInterpolation;

        // Holds the interpolated overlay
        svkMriImageData*                interpOverlay;

        // Transfer function for rendering overlays
        svkLookupTable*                 colorTransfer;

        // Methods:
        void                            SetupMrInput( bool firstInput );
        void                            SetupMsInput( bool firstInput );
        void                            UpdateImageSlice( bool centerImage );
        void                            SetSelection( double* selectionArea, bool isWorldCords = 0 );
        void                            SetOverlayOpacity( double opacity );
        double                          GetOverlayOpacity( );
        void                            SetOverlayThreshold( double threshold );
        double                          GetOverlayThreshold( );
        void                            SetTlcBrc( int* tlcBrc );
        int*                            HighlightSelectionVoxels();
        void                            GenerateClippingPlanes( );
        void                            SetupOverlay();
        void                            SetInterpolationType( int interpolationType );
        void                                    UpdateSincInterpolation();
        void                            SetLUT( svkLookupTable::svkLookupTableType type );
        void                            ResetWindowLevel();
        int                             FindCenterImageSlice( int spectraSlice, svkDcmHeader::Orientation orientation );
        int                             FindSpectraSlice( int imageSlice, svkDcmHeader::Orientation orientation );
        int                             FindOverlaySlice( int slice, svkDcmHeader::Orientation orientation );
        bool                            IsSatBandForSliceOn( svkDcmHeader::Orientation orientation );
        bool                            IsSatBandOutlineForSliceOn( svkDcmHeader::Orientation orientation );
        bool                            AreAllSatBandsOn( svkDcmHeader::Orientation orientation );
        bool                            AreAllSatBandOutlinesOn( svkDcmHeader::Orientation orientation );

    private:

        void                            SetSliceOverlay();
        bool                            ResliceImage(svkImageData* input, svkImageData* target, int targetIndex);
        float                           GetImageToSpecSliceRatio(svkImageData* input, svkImageData* target); 
        bool                            OriginShiftRequired(svkImageData* input, svkImageData* target, double* targetOrigin); 


        double                          overlayOpacity;
        double                          overlayThreshold;

        InterpolationType               interpolationType; 

        svkSatBandSet*                 satBandsAxial;
        svkSatBandSet*                 satBandsCoronal;
        svkSatBandSet*                 satBandsSagittal;

        // Determines how close to the voxels things are clipped
        static const double            CLIP_TOLERANCE; 

        
};


}   //svk


#endif //SVK_OVERLAY_VIEW_H