You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
168 lines
5.1 KiB
C++
168 lines
5.1 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkBSPCuts.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.
|
|
|
|
=========================================================================*/
|
|
/*----------------------------------------------------------------------------
|
|
Copyright (c) Sandia Corporation
|
|
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* @class vtkBSPCuts
|
|
* @brief This class represents an axis-aligned Binary Spatial
|
|
* Partitioning of a 3D space.
|
|
*
|
|
*
|
|
* This class converts between the vtkKdTree
|
|
* representation of a tree of vtkKdNodes (used by vtkDistributedDataFilter)
|
|
* and a compact array representation that might be provided by a
|
|
* graph partitioning library like Zoltan. Such a representation
|
|
* could be used in message passing.
|
|
*
|
|
* @sa
|
|
* vtkKdTree vtkKdNode vtkDistributedDataFilter
|
|
*/
|
|
|
|
#ifndef vtkBSPCuts_h
|
|
#define vtkBSPCuts_h
|
|
|
|
#include "vtkCommonDataModelModule.h" // For export macro
|
|
#include "vtkDataObject.h"
|
|
|
|
class vtkKdNode;
|
|
|
|
class VTKCOMMONDATAMODEL_EXPORT vtkBSPCuts : public vtkDataObject
|
|
{
|
|
public:
|
|
static vtkBSPCuts* New();
|
|
vtkTypeMacro(vtkBSPCuts, vtkDataObject);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
/**
|
|
* Initialize the cuts with arrays of information. This type of
|
|
* information would be obtained from a graph partitioning software
|
|
* package like Zoltan.
|
|
|
|
* bounds - the bounds (xmin, xmax, ymin, ymax, zmin, zmax) of the
|
|
* space being partitioned
|
|
* ncuts - the number cuts, also the size of the following arrays
|
|
* dim - the dimension along which the cut is made (x/y/z - 0/1/2)
|
|
* coord - the location of the cut along the axis
|
|
* lower - array index for the lower region bounded by the cut
|
|
* upper - array index for the upper region bounded by the cut
|
|
* lowerDataCoord - optional upper bound of the data in the lower region
|
|
* upperDataCoord - optional lower bound of the data in the upper region
|
|
* npoints - optional number of points in the spatial region
|
|
*/
|
|
|
|
void CreateCuts(double* bounds, int ncuts, int* dim, double* coord, int* lower, int* upper,
|
|
double* lowerDataCoord, double* upperDataCoord, int* npoints);
|
|
|
|
/**
|
|
* Initialize the cuts from a tree of vtkKdNode's
|
|
*/
|
|
|
|
void CreateCuts(vtkKdNode* kd);
|
|
|
|
/**
|
|
* Return a tree of vtkKdNode's representing the cuts specified
|
|
* in this object. This is our copy, don't delete it.
|
|
*/
|
|
|
|
vtkKdNode* GetKdNodeTree() { return this->Top; }
|
|
|
|
/**
|
|
* Get the number of cuts in the partitioning, which also the size of
|
|
* the arrays in the array representation of the partitioning.
|
|
*/
|
|
|
|
vtkGetMacro(NumberOfCuts, int);
|
|
|
|
/**
|
|
* Get the arrays representing the cuts in the partitioning.
|
|
*/
|
|
|
|
int GetArrays(int len, int* dim, double* coord, int* lower, int* upper, double* lowerDataCoord,
|
|
double* upperDataCoord, int* npoints);
|
|
|
|
/**
|
|
* Compare these cuts with those of the other tree. Returns true if
|
|
* the two trees are the same.
|
|
*/
|
|
int Equals(vtkBSPCuts* other, double tolerance = 0.0);
|
|
|
|
void PrintTree();
|
|
void PrintArrays();
|
|
|
|
//@{
|
|
/**
|
|
* Retrieve an instance of this class from an information object.
|
|
*/
|
|
static vtkBSPCuts* GetData(vtkInformation* info);
|
|
static vtkBSPCuts* GetData(vtkInformationVector* v, int i = 0);
|
|
//@}
|
|
|
|
/**
|
|
* Restore data object to initial state,
|
|
*/
|
|
void Initialize() override;
|
|
|
|
//@{
|
|
/**
|
|
* Shallow copy. These copy the data, but not any of the
|
|
* pipeline connections.
|
|
*/
|
|
void ShallowCopy(vtkDataObject* src) override;
|
|
void DeepCopy(vtkDataObject* src) override;
|
|
//@}
|
|
|
|
protected:
|
|
vtkBSPCuts();
|
|
~vtkBSPCuts() override;
|
|
|
|
static void DeleteAllDescendants(vtkKdNode* kd);
|
|
|
|
static int CountNodes(vtkKdNode* kd);
|
|
static void SetMinMaxId(vtkKdNode* kd);
|
|
static void _PrintTree(vtkKdNode* kd, int depth);
|
|
|
|
void BuildTree(vtkKdNode* kd, int idx);
|
|
int WriteArray(vtkKdNode* kd, int loc);
|
|
|
|
void ResetArrays();
|
|
void AllocateArrays(int size);
|
|
|
|
vtkKdNode* Top;
|
|
|
|
// required cut information
|
|
|
|
int NumberOfCuts; // number of cuts, also length of each array
|
|
int* Dim; // dimension (x/y/z - 0/1/2) where cut occurs
|
|
double* Coord; // location of cut along axis
|
|
int* Lower; // location in arrays of left (lower) child info
|
|
int* Upper; // location in arrays of right (lower) child info
|
|
|
|
// optional cut information
|
|
|
|
double* LowerDataCoord; // coordinate of uppermost data in lower half
|
|
double* UpperDataCoord; // coordinate of lowermost data in upper half
|
|
int* Npoints; // number of data values in partition
|
|
|
|
double Bounds[6];
|
|
|
|
vtkBSPCuts(const vtkBSPCuts&) = delete;
|
|
void operator=(const vtkBSPCuts&) = delete;
|
|
};
|
|
|
|
#endif
|