vtkStaticCellLocator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkStaticCellLocator.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 vtkStaticCellLocator_h
#define vtkStaticCellLocator_h
 
#include "vtkAbstractCellLocator.h"
#include "vtkCommonDataModelModule.h" // For export macro
 
// Forward declarations for PIMPL
struct vtkCellBinner;
struct vtkCellProcessor;
 
class VTKCOMMONDATAMODEL_EXPORT vtkStaticCellLocator : public vtkAbstractCellLocator
{
  friend struct vtkCellBinner;
  friend struct vtkCellProcessor;
 
public:
 
  static vtkStaticCellLocator* New();
  vtkTypeMacro(vtkStaticCellLocator, vtkAbstractCellLocator);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetVector3Macro(Divisions, int);
  vtkGetVectorMacro(Divisions, int, 3);
 
  using vtkAbstractCellLocator::FindClosestPoint;
  using vtkAbstractCellLocator::FindClosestPointWithinRadius;
 
  vtkIdType FindCell(double pos[3], double vtkNotUsed(tol2), vtkGenericCell* cell,
    double pcoords[3], double* weights) override;
 
  vtkIdType FindCell(double x[3]) override { return this->Superclass::FindCell(x); }
 
  void FindCellsWithinBounds(double* bbox, vtkIdList* cells) override;
 
  void FindCellsAlongLine(
    const double p1[3], const double p2[3], double tolerance, vtkIdList* cells) override;
 
 
  void FindCellsAlongPlane(
    const double o[3], const double n[3], double tolerance, vtkIdList* cells);
 
  void FindClosestPoint(const double x[3], double closestPoint[3], vtkGenericCell* cell,
    vtkIdType& cellId, int& subId, double& dist2) override;
 
  vtkIdType FindClosestPointWithinRadius(double x[3], double radius, double closestPoint[3],
    vtkGenericCell* cell, vtkIdType& cellId, int& subId, double& dist2, int& inside) override;
 
  int IntersectWithLine(const double a0[3], const double a1[3], double tol, double& t, double x[3],
    double pcoords[3], int& subId, vtkIdType& cellId, vtkGenericCell* cell) override;
 
  int IntersectWithLine(const double p1[3], const double p2[3], double tol, double& t, double x[3],
    double pcoords[3], int& subId) override
  {
    return this->Superclass::IntersectWithLine(p1, p2, tol, t, x, pcoords, subId);
  }
 
  int IntersectWithLine(const double p1[3], const double p2[3], double tol, double& t, double x[3],
    double pcoords[3], int& subId, vtkIdType& cellId) override
  {
    return this->Superclass::IntersectWithLine(p1, p2, tol, t, x, pcoords, subId, cellId);
  }
 
  int IntersectWithLine(
    const double p1[3], const double p2[3], vtkPoints* points, vtkIdList* cellIds) override
  {
    return this->Superclass::IntersectWithLine(p1, p2, points, cellIds);
  }
 
 
  void GenerateRepresentation(int level, vtkPolyData* pd) override;
  void FreeSearchStructure() override;
  void BuildLocator() override;
 
 
  vtkSetClampMacro(MaxNumberOfBuckets, vtkIdType, 1000, VTK_ID_MAX);
  vtkGetMacro(MaxNumberOfBuckets, vtkIdType);
 
  bool GetLargeIds() { return this->LargeIds; }
 
 
  vtkSetMacro(UseDiagonalLengthTolerance, bool);
  vtkGetMacro(UseDiagonalLengthTolerance, bool);
  vtkBooleanMacro(UseDiagonalLengthTolerance, bool);
 
protected:
  vtkStaticCellLocator();
  ~vtkStaticCellLocator() override;
 
  double Bounds[6]; // Bounding box of the whole dataset
  int Divisions[3]; // Number of sub-divisions in x-y-z directions
  double H[3];      // Width of each bin in x-y-z directions
 
  vtkIdType MaxNumberOfBuckets; // Maximum number of buckets in locator
  bool LargeIds;                // indicate whether integer ids are small or large
  bool UseDiagonalLengthTolerance = false;
 
  // Support PIMPLd implementation
  vtkCellBinner* Binner;       // Does the binning
  vtkCellProcessor* Processor; // Invokes methods (templated subclasses)
 
  // Support query operations
  unsigned char* CellHasBeenVisited;
  unsigned char QueryNumber;
 
private:
  vtkStaticCellLocator(const vtkStaticCellLocator&) = delete;
  void operator=(const vtkStaticCellLocator&) = delete;
};
 
#endif