vtkSurfaceLICComposite.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkSurfaceLICComposite.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkSurfaceLICComposite_h
#define vtkSurfaceLICComposite_h
 
#include "vtkObject.h"
#include "vtkRenderingLICModule.h" // for export macro
#include "vtkPixelExtent.h" // for pixel extent
#include <deque> // for deque
#include <vector> // for vector
 
class vtkFloatArray;
class vtkOpenGLRenderWindow;
class vtkPainterCommunicator;
class vtkTextureObject;
 
class VTKRENDERINGLIC_EXPORT vtkSurfaceLICComposite : public vtkObject
{
public:
  static vtkSurfaceLICComposite *New();
  vtkTypeMacro(vtkSurfaceLICComposite, vtkObject);
  virtual void PrintSelf(ostream &os, vtkIndent indent);
 
 
  void Initialize(
        const vtkPixelExtent &winExt,
        const std::deque<vtkPixelExtent> &blockExts,
        int strategy,
        double stepSize,
        int nSteps,
        int normalizeVectors,
        int enhancedLIC,
        int anitalias);
 
 
  enum {
    COMPOSITE_INPLACE=0,
    COMPOSITE_INPLACE_DISJOINT,
    COMPOSITE_BALANCED,
    COMPOSITE_AUTO
    };
  void SetStrategy(int val){ this->Strategy = val; }
  int GetStrategy(){ return this->Strategy; }
 
 
  int GetNumberOfCompositeExtents() const
    { return static_cast<int>(this->CompositeExt.size()); }
 
 
  const vtkPixelExtent &GetGuardExtent(int i=0) const
    { return this->GuardExt[i]; }
 
  const std::deque<vtkPixelExtent> &GetGuardExtents() const
    { return this->GuardExt; }
 
 
  const vtkPixelExtent &GetDisjointGuardExtent(int i=0) const
    { return this->DisjointGuardExt[i]; }
 
  const std::deque<vtkPixelExtent> &GetDisjointGuardExtents() const
    { return this->GuardExt; }
 
 
  const vtkPixelExtent &GetCompositeExtent(int i=0) const
    { return this->CompositeExt[i]; }
 
  const std::deque<vtkPixelExtent> &GetCompositeExtents() const
    { return this->CompositeExt; }
 
 
  const vtkPixelExtent &GetDataSetExtent() const
    { return this->DataSetExt; }
 
 
  const vtkPixelExtent &GetWindowExtent() const
    { return this->WindowExt; }
 
  int InitializeCompositeExtents(float *vectors);
 
 
  virtual void SetContext(vtkOpenGLRenderWindow *){}
  virtual vtkOpenGLRenderWindow *GetContext(){ return NULL; }
 
  virtual void SetCommunicator(vtkPainterCommunicator*){}
 
  virtual void RestoreDefaultCommunicator(){}
 
  virtual int BuildProgram(float*){ return -1; }
 
 
  virtual int Gather(void *, int, int, vtkTextureObject *&)
    { return -1; }
 
 
  virtual int Scatter(void *, int, int, vtkTextureObject *&)
    { return -1; }
 
 
  static
  int MakeDecompDisjoint(
        std::deque<vtkPixelExtent> &in,
        std::deque<vtkPixelExtent> &out);
 
protected:
  vtkSurfaceLICComposite();
  ~vtkSurfaceLICComposite();
 
 
  int MakeDecompDisjoint(
        const std::deque<vtkPixelExtent> &in,
        std::deque<vtkPixelExtent> &out,
        float *vectors);
 
 
  float VectorMax(
        const vtkPixelExtent &ext,
        float *vectors);
 
 
  int VectorMax(
        const std::deque<vtkPixelExtent> &exts,
        float *vectors,
        std::vector<float> &vMax);
 
 
  int AddGuardPixels(
      const std::deque<vtkPixelExtent> &exts,
      std::deque<vtkPixelExtent> &guardExts,
      std::deque<vtkPixelExtent> &disjointGuardExts,
      float *vectors);
 
 
  void GetPixelBounds(
      float *rgba,
      int ni,
      vtkPixelExtent &ext);
 
  float GetFudgeFactor(int nx[2]);
 
protected:
  int Pass;                                    // id for mpi tagging
 
  vtkPixelExtent WindowExt;                    // screen extent (screen size)
  vtkPixelExtent DataSetExt;                   // screen extent of the dataset
  std::deque<vtkPixelExtent> BlockExts;        // screen extents of blocks
 
  std::deque<vtkPixelExtent> CompositeExt;     // screen extents after decomp
  std::deque<vtkPixelExtent> GuardExt;         // screen extents w/ guard cells
  std::deque<vtkPixelExtent> DisjointGuardExt; // screen extents w/ guard cells
 
  int Strategy;                                // control for parallel composite
 
  double StepSize;                             // window coordinates step size
  int NumberOfSteps;                           // number of integration steps
  int NormalizeVectors;                        // does integrator normailze
  int NumberOfGuardLevels;                     // 1.5 if enhanced LIC 1 otherwise
  int NumberOfEEGuardPixels;                   // 1 if enhanced LIC 0 otherwise
  int NumberOfAAGuardPixels;                   // n antialias passes
 
private:
  vtkSurfaceLICComposite(const vtkSurfaceLICComposite&); // Not implemented
  void operator=(const vtkSurfaceLICComposite&); // Not implemented
 
  friend
  ostream &operator<<(ostream &os, vtkSurfaceLICComposite &ss);
};
 
ostream &operator<<(ostream &os, vtkSurfaceLICComposite &ss);
 
#endif