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 "vtkRenderingLICOpenGL2Module.h" // for export macro
#include "vtkPixelExtent.h" // for pixel extent
#include <deque> // for deque
#include <vector> // for vector

class vtkFloatArray;
class vtkOpenGLRenderWindow;
class vtkTextureObject;
class vtkPainterCommunicator;

class VTKRENDERINGLICOPENGL2_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