svkPlotLineGrid.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_PLOT_LINE_GRID_H_INCL
#define SVK_PLOT_LINE_GRID_H_INCL


#include <vector>
#include <vtkRenderer.h>
#include <vtkIdList.h>

#include <vtkImageData.h>
#include <vtkCellData.h>
#include <vtkCamera.h>
#include <vtkProp3DCollection.h>
#include <vtkDataSetCollection.h>
#include <vtkCallbackCommand.h>
#include <vtkAppendPolyData.h>
#include <vtkAreaPicker.h>
#include <vtkCollectionIterator.h>
#include <vtkTransform.h>
#include <svkPlotLine.h>
#include <svkImageData.h>
#include <svkDataView.h>
#include <svk4DImageData.h>
#include <svkMrsImageData.h>
#include <vtkPolyDataCollection.h>
#include <vtkPolyDataMapper.h>
#include <vtkLODActor.h>
#include <vtkProperty.h>


namespace svk {


using namespace std;

/*
 * Representation for 4D Image Data. It creates a vtkPolyData object to represent
 * the spatial location of the data acquired, and uses svkPlotLine objects
 * to modify point data for the individual cells. There are methods for controlling
 * the range, slice, etc.
 *
 */
class svkPlotLineGrid : public vtkObject
{

    public:
        // vtk type revision macro
        vtkTypeMacro( svkPlotLineGrid, vtkObject );

        static svkPlotLineGrid*       New();

        svkPlotLineGrid();
        ~svkPlotLineGrid();


        //  Methods
        void                    SetInput( svk4DImageData* data );
        svk4DImageData*        GetInput( );
        void                    Update(int tlcBrc[2]);
        void                    SetTlcBrc(int tlcBrc[2]);
        int*                    GetTlcBrc();
        void                    SetSlice(int slice);
        void                    SetPlotPoints();
        int                     GetSlice( );
        void                    SetFrequencyWLRange(int lower, int range, int tlcBrc[2]); 
        void                    GetFrequencyWLRange(int &lower, int &range); 
        void                    SetIntensityWLRange(double lower, double range, int tlcBrc[2]); 
        void                    GetIntensityWLRange(double &lower, double &range); 
        void                    AlignCamera( bool invertView = 1 );
        void                    SetComponent( svkPlotLine::PlotComponent component );
        svkPlotLine::PlotComponent                     GetComponent( );
        vtkstd::vector<int>     GetVolumeIndexVector( );
        void                    SetVolumeIndexVector( vtkstd::vector<int> );
        void                    SetVolumeIndex( int index, int volumeIndex = 0 );
        int                     GetVolumeIndex( int volumeIndex = 0 );
        void                    UpdateDataArrays(int tlc, int brc);
        void                    SetOrientation( svkDcmHeader::Orientation orientation );
        vtkActor*               GetPlotGridActor();
        void                    CalculateTlcBrcBounds( double bounds[6], int tlcBrc[2]);
        void                    SetColor( double rgb[3]);
        double*                 GetColor( );

    private:

        void                    ClearXYPlots();

        int                         slice;
        vtkstd::vector< int >      volumeIndexVector;

        int                         tlcBrc[2];

        vtkstd::vector< vtkstd::vector<double> > dcos;

        vtkstd::vector<svkPlotLine*>  xyPlots;

        vtkActor*                plotGridActor;

        vtkPolyData*                polyData;

        vtkPoints*                  points;

        vtkPolyDataMapper*          mapper;

        int                         plotRangeX1;     

        int                         plotRangeX2;     

        double                      plotRangeY1;     

        double                      plotRangeY2;     

        bool*                       freqUpToDate;

        int                         freqSelectionUpToDate[2];

        bool*                       ampUpToDate;

        int                         ampSelectionUpToDate[2];

        // Defines if the given volume for a given slice is up to date
        vtkstd::vector< vtkstd::vector<bool> >  volumeUpToDate;

        svk4DImageData*               data;

        vtkCallbackCommand*         dataModifiedCB;

        svkPlotLine::PlotComponent   plotComponent;

        svkDcmHeader::Orientation orientation;

        //  Methods:
        void                        RegeneratePlots();
        static void                 UpdateData(vtkObject* subject, unsigned long eid, void* thisObject, void *calldata);
        void                        AllocateXYPlots();        
        void                        AllocatePolyData();
        void                        UpdatePlotRange(int tlcBrc[2], bool generatePolyData = true);
        void                        UpdateComponent();
        void                        UpdateOrientation();
        void                        GenerateActor();
        void                        HighlightSelectionVoxels();
        bool                        IsSliceUpToDate( int slice );
        void                        SetSliceUpToDate( int slice );
        void                        SetSliceOutOfDate( int slice );
        void                        SetVolumeUpToDate( int volumeIndex );
        void                        SetVolumeOutOfDate( int volumeIndex );
        void                        InitializeVolumeUpToDateVector();
        void                                            TurnOffAllPlots();

};


}   //svk


#endif //SVK_PLOT_LINE_GRID_H_INCL