dox/VolumeRendering/vtkKWERepresentativeVolumeImageCreator.h

Go to the documentation of this file.

//=============================================================================
//   This file is part of VTKEdge. See vtkedge.org for more information.
//
//   Copyright (c) 2010 Kitware, Inc.
//
//   VTKEdge may be used under the terms of the BSD License
//   Please see the file Copyright.txt in the root directory of
//   VTKEdge for further information.
//
//   Alternatively, you may see: 
//
//   http://www.vtkedge.org/vtkedge/project/license.html
//
//
//   For custom extensions, consulting services, or training for
//   this or any other Kitware supported open source project, please
//   contact Kitware at sales@kitware.com.
//
//
//=============================================================================

//-----------------------------------------------------------------------------
#ifndef __vtkKWERepresentativeVolumeImageCreator_h
#define __vtkKWERepresentativeVolumeImageCreator_h

#include "vtkObject.h"
#include "VTKEdgeConfigure.h" // include configuration header

#include "vtkVolumeMapper.h" // for definition of blend modes

class vtkImageData;
class vtkMultiThreader;
class vtkMutexLock;
class vtkRenderWindow;
class vtkRenderWindowInteractor;
class vtkVolumeProperty;


// Forward declaration for friend
//BTX
VTK_THREAD_RETURN_TYPE vtkKWERVICGenerateImage(void *arg);
class vtkKWERVICFriend;
//ETX

class VTKEdge_VOLUMERENDERING_EXPORT vtkKWERepresentativeVolumeImageCreator : public vtkObject
{
public:
  static vtkKWERepresentativeVolumeImageCreator *New();
  vtkTypeRevisionMacro(vtkKWERepresentativeVolumeImageCreator,vtkObject);
  void PrintSelf( ostream& os, vtkIndent indent );

  void SetProperty(vtkVolumeProperty *p);


  vtkGetObjectMacro( Property, vtkVolumeProperty );


  vtkSetMacro( BlendMode, int );
  void SetBlendModeToComposite()
    { this->SetBlendMode( vtkVolumeMapper::COMPOSITE_BLEND ); }
  void SetBlendModeToMaximumIntensity()
    { this->SetBlendMode( vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND ); }
  void SetBlendModeToMinimumIntensity()
    { this->SetBlendMode( vtkVolumeMapper::MINIMUM_INTENSITY_BLEND ); }
  vtkGetMacro( BlendMode, int );

  void SetInput(vtkImageData *volume);


  vtkGetObjectMacro( Input, vtkImageData );

  void Start();

  void Stop();

  int IsProcessing();

  int IsValid();


  void SetRepresentativeImageSize( int w, int h );
  void SetRepresentativeImageSize( int size[2] )
    {this->SetRepresentativeImageSize(size[0], size[1]);}


  vtkGetVectorMacro( RepresentativeImageSize, int, 3 );


  vtkImageData *GetRepresentativeImage();


  vtkSetClampMacro( VisibleSide, int,
                    vtkKWERepresentativeVolumeImageCreator::XSideView,
                    vtkKWERepresentativeVolumeImageCreator::MinusZSideView );


  vtkGetMacro( VisibleSide, int );

//BTX
  enum
  {
    XSideView=0,
    MinusXSideView,
    YSideView,
    MinusYSideView,
    ZSideView,
    MinusZSideView
  };

  enum
  {
    LeftSideView=0,
    RightSideView,
    PosteriorSideView,
    AnteriorSideView,
    SuperiorSideView,
    InferiorSideView
  };
//ETX

protected:
  vtkKWERepresentativeVolumeImageCreator();
  ~vtkKWERepresentativeVolumeImageCreator();

  friend VTK_THREAD_RETURN_TYPE vtkKWERVICGenerateImage(void *arg);
  friend class vtkKWERVICFriend;

  void GenerateImage( int *flag,
                      vtkMutexLock *lock );

  void ClearInternalParameters();

  vtkVolumeProperty  *Property;
  int                 BlendMode;
  vtkImageData       *Input;

  vtkVolumeProperty  *InternalProperty;
  int                 InternalBlendMode;
  vtkImageData       *InternalInput;

  vtkImageData       *RepresentativeImage;
  vtkMutexLock       *RepresentativeImageIsValidLock;
  int                 RepresentativeImageIsValid;
  int                 RepresentativeImageSize[2];

  int                 VisibleSide;

  vtkMultiThreader   *Threader;

  int                 SpawnedThreadID;

  void ComputeFirstVoxel( int i, int j, float voxel[3] );
  void ComputeRayIncrement( float increment[3] );
  void CastRay( float voxel[3],
                float increment[3],
                unsigned char color[3] );

  void UpdateTransferFunctions(double sampleDistance);
  double ComputeSampleDistance(float rayIncrement[3]);

  float TableOffset[4];
  float TableScale[4];
  float ColorTable[4][1024*3];
  float OpacityTable[4][1024];
  int TableComponents;
  int TableIndependentComponents;

private:
  vtkKWERepresentativeVolumeImageCreator(const vtkKWERepresentativeVolumeImageCreator&);  // Not implemented.
  void operator=(const vtkKWERepresentativeVolumeImageCreator&);  // Not implemented.
};

#endif