vtkHierarchicalFractal.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    vtkHierarchicalFractal.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 vtkHierarchicalFractal_h
#define vtkHierarchicalFractal_h

#include "vtkCompositeDataSetAlgorithm.h"
#include "vtkPVVTKExtensionsFiltersGeneralModule.h" //needed for exports
#include "vtkSmartPointer.h"                        //for ivars

class vtkIntArray;
class vtkUniformGrid;
class vtkRectilinearGrid;
class vtkDataSet;
class vtkHierarchicalBoxDataSet;
class HierarchicalFractalOutputUtil;

class VTKPVVTKEXTENSIONSFILTERSGENERAL_EXPORT vtkHierarchicalFractal
  : public vtkCompositeDataSetAlgorithm
{
public:
  static vtkHierarchicalFractal* New();

  vtkTypeMacro(vtkHierarchicalFractal, vtkCompositeDataSetAlgorithm);
  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, int);
  vtkGetMacro(GhostLevels, int);
  vtkBooleanMacro(GhostLevels, int);


  vtkSetMacro(TimeStep, int);
  vtkGetMacro(TimeStep, int);
  vtkGetVector2Macro(TimeStepRange, int);


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


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


  vtkSetMacro(Asymetric, int);
  vtkGetMacro(Asymetric, int);


  vtkSetMacro(Overlap, int);
  vtkGetMacro(Overlap, int);

protected:
  vtkHierarchicalFractal();
  ~vtkHierarchicalFractal() override;

  int StartBlock;
  int EndBlock;
  int BlockCount;
  int TimeStep;
  int TimeStepRange[2];

  // Create either vtkHierarchicalBoxDataSet or vtkMultiBlockDataSet based on
  // the GenerateRectilinearGrids flag.
  int RequestDataObject(
    vtkInformation* req, vtkInformationVector** inV, vtkInformationVector* outV) override;

  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  void Traverse(int& blockId, int level, vtkCompositeDataSet* 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(vtkCompositeDataSet* output);
  void AddTestArray(vtkCompositeDataSet* output);
  void AddFractalArray(vtkCompositeDataSet* output);
  void AddBlockIdArray(vtkCompositeDataSet* 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(vtkHierarchicalFractal* src);

  int Overlap;
  int Asymetric;
  int MaximumLevel;
  int Dimensions;
  float FractalValue;
  int GhostLevels;
  vtkIntArray* Levels;
  int TwoDimensional;

  // New method of specifying blocks.
  double TopLevelSpacing[3];
  double TopLevelOrigin[3];

  int GenerateRectilinearGrids;

  vtkSmartPointer<HierarchicalFractalOutputUtil>
    OutputUtil; // convenient class to create composite output

private:
  vtkHierarchicalFractal(const vtkHierarchicalFractal&) = delete;
  void operator=(const vtkHierarchicalFractal&) = delete;
};

#endif