dox/Hybrid/vtkKWEGPUArrayCalculator.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 __vtkKWEGPUArrayCalculator_h
#define __vtkKWEGPUArrayCalculator_h

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


class vtkKWEFunctionToGLSL;
class vtkRenderWindow;
class vtkFloatArray;

class VTKEdge_HYBRID_EXPORT vtkKWEGPUArrayCalculator : public vtkArrayCalculator
{
public:
  vtkTypeRevisionMacro(vtkKWEGPUArrayCalculator,vtkArrayCalculator);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkKWEGPUArrayCalculator *New();


  vtkGetObjectMacro(Context, vtkRenderWindow);
  void SetContext(vtkRenderWindow *);

  bool GetSupportedByHardware();

  virtual void SetFunction(const char* function);


  vtkSetMacro(SizeThreshold,vtkIdType);
  vtkGetMacro(SizeThreshold,vtkIdType);


  vtkGetMacro(UseCalibration,int);
  vtkSetMacro(UseCalibration,int);
  vtkBooleanMacro(UseCalibration,int);

  void Calibrate();


  vtkGetMacro(CalibratedSizeThreshold,vtkIdType);

  virtual void RemoveScalarVariables();

  virtual void RemoveVectorVariables();

  virtual void RemoveCoordinateScalarVariables();

  virtual void RemoveCoordinateVectorVariables();


  vtkSetMacro(MaxGPUMemorySizeInBytes,vtkIdType);
  vtkGetMacro(MaxGPUMemorySizeInBytes,vtkIdType);

protected:
  vtkKWEGPUArrayCalculator();
  virtual ~vtkKWEGPUArrayCalculator();

  void SimulateGPUComputation(vtkFloatArray *values);

  virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);

  virtual void ComputeSubRange(vtkDataArray *array,
                               vtkIdType first,
                               vtkIdType last,
                               double subRange[2]);

  vtkRenderWindow *Context;

  vtkKWEFunctionToGLSL *FunctionParserToGLSL;

  vtkIdType MaxGPUMemorySizeInBytes;

  vtkIdType SizeThreshold;
  int UseCalibration; // boolean
  vtkIdType CalibratedSizeThreshold;
  bool CalibrationDone;
  bool SupportedByHardware;

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

#endif