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 "vtkPixelExtent.h"               // for pixel extent
#include "vtkRenderingLICOpenGL2Module.h" // for export macro
#include <deque>                          // for deque
#include <vector>                         // for vector
 
VTK_ABI_NAMESPACE_BEGIN
class vtkFloatArray;
class vtkOpenGLRenderWindow;
class vtkTextureObject;
class vtkPainterCommunicator;
 
class VTKRENDERINGLICOPENGL2_EXPORT vtkSurfaceLICComposite : public vtkObject
{
public:
  static vtkSurfaceLICComposite* New();
  vtkTypeMacro(vtkSurfaceLICComposite, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  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 nullptr; }
 
  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() override;
 
  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]);
 
  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&) = delete;
  void operator=(const vtkSurfaceLICComposite&) = delete;
 
  friend ostream& operator<<(ostream& os, vtkSurfaceLICComposite& ss);
};
 
ostream& operator<<(ostream& os, vtkSurfaceLICComposite& ss);
 
VTK_ABI_NAMESPACE_END
 
#endif