vtkTemporalFractal.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   ParaView
  Module:    vtkTemporalFractal.h
 
  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html 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 vtkTemporalFractal_h
#define vtkTemporalFractal_h
 
#include "vtkAlgorithm.h"
#include "vtkFiltersHybridModule.h" // For export macro
#include "vtkSmartPointer.h"        //for ivars
 
class vtkCompositeDataSet;
class vtkDataSet;
class vtkHierarchicalBoxDataSet;
class vtkIntArray;
class vtkRectilinearGrid;
class vtkUniformGrid;
class TemporalFractalOutputUtil;
 
class VTKFILTERSHYBRID_EXPORT vtkTemporalFractal : public vtkAlgorithm
{
public:
 
  static vtkTemporalFractal* New();
  vtkTypeMacro(vtkTemporalFractal, vtkAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(FractalValue, float);
  vtkGetMacro(FractalValue, float);
 
 
  vtkSetMacro(MaximumLevel, int);
  vtkGetMacro(MaximumLevel, int);
 
 
  vtkSetMacro(Dimensions, int);
  vtkGetMacro(Dimensions, int);
 
 
  vtkSetMacro(GhostLevels, vtkTypeBool);
  vtkGetMacro(GhostLevels, vtkTypeBool);
  vtkBooleanMacro(GhostLevels, vtkTypeBool);
 
 
  vtkSetMacro(GenerateRectilinearGrids, vtkTypeBool);
  vtkGetMacro(GenerateRectilinearGrids, vtkTypeBool);
  vtkBooleanMacro(GenerateRectilinearGrids, vtkTypeBool);
 
 
  vtkSetMacro(DiscreteTimeSteps, vtkTypeBool);
  vtkGetMacro(DiscreteTimeSteps, vtkTypeBool);
  vtkBooleanMacro(DiscreteTimeSteps, vtkTypeBool);
 
 
  vtkSetMacro(TwoDimensional, vtkTypeBool);
  vtkGetMacro(TwoDimensional, vtkTypeBool);
  vtkBooleanMacro(TwoDimensional, vtkTypeBool);
 
 
  vtkSetMacro(Asymmetric, int);
  vtkGetMacro(Asymmetric, int);
 
 
  vtkSetMacro(AdaptiveSubdivision, vtkTypeBool);
  vtkGetMacro(AdaptiveSubdivision, vtkTypeBool);
  vtkBooleanMacro(AdaptiveSubdivision, vtkTypeBool);
 
protected:
  vtkTemporalFractal();
  ~vtkTemporalFractal() override;
 
  int FillOutputPortInformation(int vtkNotUsed(port), vtkInformation* info) override;
 
  int StartBlock;
  int EndBlock;
  int BlockCount;
 
  vtkTypeBool ProcessRequest(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
 
  virtual int RequestDataObject(vtkInformation*, vtkInformationVector**, vtkInformationVector*);
 
  virtual int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
 
 
  virtual int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
  virtual int RequestOneTimeStep(vtkCompositeDataSet* output, vtkInformation* request,
    vtkInformationVector** inputVector, vtkInformationVector* outputVector);
 
  void Traverse(int& blockId, int level, vtkDataObject* output, int x0, int x1, int y0, int y1,
    int z0, int z1, int onFace[6]);
 
  int LineTest2(float x0, float y0, float z0, float x1, float y1, float z1, double bds[6]);
  int LineTest(float x0, float y0, float z0, float x1, float y1, float z1, double bds[6], int level,
    int target);
 
  void SetBlockInfo(vtkUniformGrid* grid, int level, int* ext, int onFace[6]);
  void SetRBlockInfo(vtkRectilinearGrid* grid, int level, int* ext, int onFace[6]);
 
  void AddVectorArray(vtkHierarchicalBoxDataSet* output);
  void AddTestArray(vtkHierarchicalBoxDataSet* output);
  void AddFractalArray(vtkCompositeDataSet* output);
  void AddBlockIdArray(vtkHierarchicalBoxDataSet* output);
  void AddDepthArray(vtkHierarchicalBoxDataSet* output);
 
  void AddGhostLevelArray(vtkDataSet* grid, int dim[3], int onFace[6]);
 
  int MandelbrotTest(double x, double y);
  int TwoDTest(double bds[6], int level, int target);
 
  void CellExtentToBounds(int level, int ext[6], double bds[6]);
 
  void ExecuteRectilinearMandelbrot(vtkRectilinearGrid* grid, double* ptr);
  double EvaluateSet(double p[4]);
  void GetContinuousIncrements(int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
 
  // Dimensions:
  // Specify blocks relative to this top level block.
  // For now this has to be set before the blocks are defined.
  vtkSetVector3Macro(TopLevelSpacing, double);
  vtkGetVector3Macro(TopLevelSpacing, double);
  vtkSetVector3Macro(TopLevelOrigin, double);
  vtkGetVector3Macro(TopLevelOrigin, double);
 
  void InternalImageDataCopy(vtkTemporalFractal* src);
 
  int Asymmetric;
  int MaximumLevel;
  int Dimensions;
  float FractalValue;
  vtkTypeBool GhostLevels;
  vtkIntArray* Levels;
  vtkTypeBool TwoDimensional;
  vtkTypeBool DiscreteTimeSteps;
 
  // New method of specifying blocks.
  double TopLevelSpacing[3];
  double TopLevelOrigin[3];
 
  vtkTypeBool GenerateRectilinearGrids;
 
  double CurrentTime;
 
  vtkTypeBool AdaptiveSubdivision;
  vtkSmartPointer<TemporalFractalOutputUtil> OutputUtil;
 
private:
  vtkTemporalFractal(const vtkTemporalFractal&) = delete;
  void operator=(const vtkTemporalFractal&) = delete;
};
 
#endif