# encoding: utf-8 # module vtkmodules.vtkCommonDataModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms from .object import object class vtkBoundingBox(object): """ vtkBoundingBox() -> vtkBoundingBox C++: vtkBoundingBox() vtkBoundingBox(bounds:(float, float, float, float, float, float)) -> vtkBoundingBox C++: vtkBoundingBox(const double bounds[6]) vtkBoundingBox(xMin:float, xMax:float, yMin:float, yMax:float, zMin:float, zMax:float) -> vtkBoundingBox C++: vtkBoundingBox(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) vtkBoundingBox(bbox:vtkBoundingBox) -> vtkBoundingBox C++: vtkBoundingBox(const vtkBoundingBox &bbox) vtkBoundingBox - Fast, simple class for representing and operating on 3D bounds vtkBoundingBox maintains and performs operations on a 3D axis aligned bounding box. It is very light weight and many of the member functions are in-lined so it is very fast. It is not derived from vtkObject so it can be allocated on the stack. @sa vtkBox """ def AddBounds(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddBounds(self, bounds:(float, ...)) -> None C++: void AddBounds(const double bounds[]) Adjust the bounding box so it contains the specified bounds (defined by the VTK representation (xmin,xmax, ymin,ymax, zmin,zmax). """ pass def AddBox(self, bbox): # real signature unknown; restored from __doc__ """ AddBox(self, bbox:vtkBoundingBox) -> None C++: void AddBox(const vtkBoundingBox &bbox) Change the bounding box to be the union of itself and the specified bbox. """ pass def AddPoint(self, p, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddPoint(self, p:[float, float, float]) -> None C++: void AddPoint(double p[3]) AddPoint(self, px:float, py:float, pz:float) -> None C++: void AddPoint(double px, double py, double pz) Change bounding box so it includes the point p. Note that the bounding box may have 0 volume if its bounds were just initialized. """ pass def ClampDivisions(self, targetBins, divs, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ClampDivisions(targetBins:int, divs:[int, int, int]) -> None C++: static void ClampDivisions(vtkIdType targetBins, int divs[3]) Clamp the number of divisions to be less than or equal to a target number of bins, and the divs[i] >= 1. """ pass def ComputeBounds(self, pts, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeBounds(pts:vtkPoints, bounds:[float, float, float, float, float, float]) -> None C++: static void ComputeBounds(vtkPoints *pts, double bounds[6]) ComputeBounds(pts:vtkPoints, ptUses:(int, ...), bounds:[float, float, float, float, float, float]) -> None C++: static void ComputeBounds(vtkPoints *pts, const unsigned char *ptUses, double bounds[6]) ComputeBounds(self, pts:vtkPoints) -> None C++: void ComputeBounds(vtkPoints *pts) ComputeBounds(self, pts:vtkPoints, ptUses:[int, ...]) -> None C++: void ComputeBounds(vtkPoints *pts, unsigned char *ptUses) Compute the bounding box from an array of vtkPoints. It uses a fast (i.e., threaded) path when possible. The second signature (with point uses) only considers points with ptUses[i] != 0 in the bounds calculation. The non-static ComputeBounds() methods update the current bounds of an instance of this class. """ pass def ComputeDivisions(self, totalBins, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeDivisions(self, totalBins:int, bounds:[float, float, float, float, float, float], divs:[int, int, int]) -> int C++: vtkIdType ComputeDivisions(vtkIdType totalBins, double bounds[6], int divs[3]) Compute the number of divisions in the x-y-z directions given a psoitive, target number of total bins (i.e., product of divisions in the x-y-z directions). The computation is done in such a way as to create near cuboid bins. Also note that the returned bounds may be different than the bounds defined in this class, as the bounds in the x-y-z directions can never be <= 0. Note that the total number of divisions (divs[0]*divs[1]*divs[2]) will be less than or equal to the target number of bins (as long as totalBins>=1). """ pass def ComputeInnerDimension(self): # real signature unknown; restored from __doc__ """ ComputeInnerDimension(self) -> int C++: int ComputeInnerDimension() Returns the inner dimension of the bounding box. """ return 0 def ComputeLocalBounds(self, points, u, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeLocalBounds(points:vtkPoints, u:[float, float, float], v:[float, float, float], w:[float, float, float], outputBounds:[float, float, float, float, float, float]) -> None C++: static void ComputeLocalBounds(vtkPoints *points, double u[3], double v[3], double w[3], double outputBounds[6]) Compute local bounds. Not as fast as vtkPoints.getBounds() if u, v, w form a natural basis. """ pass def Contains(self, bbox): # real signature unknown; restored from __doc__ """ Contains(self, bbox:vtkBoundingBox) -> int C++: int Contains(const vtkBoundingBox &bbox) Returns 1 if the min and max points of bbox are contained within the bounds of the specified box, else returns 0. """ return 0 def ContainsPoint(self, p, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ContainsPoint(self, p:(float, float, float)) -> int C++: vtkTypeBool ContainsPoint(const double p[3]) ContainsPoint(self, px:float, py:float, pz:float) -> int C++: vtkTypeBool ContainsPoint(double px, double py, double pz) Returns 1 if the point is contained in the box else 0. """ pass def GetBound(self, i): # real signature unknown; restored from __doc__ """ GetBound(self, i:int) -> float C++: double GetBound(int i) Return the ith bounds of the box (defined by VTK style). """ return 0.0 def GetBounds(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetBounds(self, bounds:[float, float, float, float, float, float]) -> None C++: void GetBounds(double bounds[6]) GetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float, zMin:float, zMax:float) -> None C++: void GetBounds(double &xMin, double &xMax, double &yMin, double &yMax, double &zMin, double &zMax) Get the bounds of the box (defined by VTK style). """ pass def GetCenter(self, center, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCenter(self, center:[float, float, float]) -> None C++: void GetCenter(double center[3]) Get the center of the bounding box. """ pass def GetCorner(self, corner, p, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCorner(self, corner:int, p:[float, float, float]) -> None C++: void GetCorner(int corner, double p[3]) Get the ith corner of the bounding box. The points are ordered with i, then j, then k increasing. """ pass def GetDiagonalLength(self): # real signature unknown; restored from __doc__ """ GetDiagonalLength(self) -> float C++: double GetDiagonalLength() Return the length of the diagonal. \pre not_empty: this->IsValid() """ return 0.0 def GetLength(self, i): # real signature unknown; restored from __doc__ """ GetLength(self, i:int) -> float C++: double GetLength(int i) Return the length of the bounding box in the ith direction. """ return 0.0 def GetLengths(self, lengths, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetLengths(self, lengths:[float, float, float]) -> None C++: void GetLengths(double lengths[3]) Get the length of each side of the box. """ pass def GetMaxLength(self): # real signature unknown; restored from __doc__ """ GetMaxLength(self) -> float C++: double GetMaxLength() Return the maximum length of the box. """ return 0.0 def GetMaxPoint(self): # real signature unknown; restored from __doc__ """ GetMaxPoint(self) -> (float, float, float) C++: const double *GetMaxPoint() GetMaxPoint(self, x:float, y:float, z:float) -> None C++: void GetMaxPoint(double &x, double &y, double &z) GetMaxPoint(self, x:[float, float, float]) -> None C++: void GetMaxPoint(double x[3]) Get the maximum point of the bounding box. """ pass def GetMinPoint(self): # real signature unknown; restored from __doc__ """ GetMinPoint(self) -> (float, float, float) C++: const double *GetMinPoint() GetMinPoint(self, x:float, y:float, z:float) -> None C++: void GetMinPoint(double &x, double &y, double &z) GetMinPoint(self, x:[float, float, float]) -> None C++: void GetMinPoint(double x[3]) Get the minimum point of the bounding box. """ pass def Inflate(self, delta): # real signature unknown; restored from __doc__ """ Inflate(self, delta:float) -> None C++: void Inflate(double delta) Inflate(self, deltaX:float, deltaY:float, deltaZ:float) -> None C++: void Inflate(double deltaX, double deltaY, double deltaZ) Inflate(self) -> None C++: void Inflate() Expand the bounding box. Inflate(delta) expands by delta on each side, the box will grow by 2*delta in x, y, and z. Inflate(dx,dy,dz) expands by the given amounts in each of the x, y, z directions. Inflate() expands the bounds so that it has non-zero volume. Sides that are inflated are adjusted by 1% of the longest edge. Or if an edge is zero length, the bounding box is inflated by 1 unit in that direction. Finally, InflateSlice(delta) will expand any side of the bounding box by +/- delta if that side has length <2*delta (i.e., it is a slice as measured by the user-specified delta)). """ pass def InflateSlice(self, delta): # real signature unknown; restored from __doc__ """ InflateSlice(self, delta:float) -> None C++: void InflateSlice(double delta) """ pass def IntersectBox(self, bbox): # real signature unknown; restored from __doc__ """ IntersectBox(self, bbox:vtkBoundingBox) -> int C++: int IntersectBox(const vtkBoundingBox &bbox) Intersect this box with bbox. The method returns 1 if both boxes are valid and they do have overlap else it will return 0. If 0 is returned the box has not been modified. """ return 0 def IntersectPlane(self, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectPlane(self, origin:[float, float, float], normal:[float, float, float]) -> bool C++: bool IntersectPlane(double origin[3], double normal[3]) Intersect this box with the half space defined by plane. Returns true if there is intersection---which implies that the box has been modified Returns false otherwise. """ pass def Intersects(self, bbox): # real signature unknown; restored from __doc__ """ Intersects(self, bbox:vtkBoundingBox) -> int C++: int Intersects(const vtkBoundingBox &bbox) Returns 1 if the boxes intersect else returns 0. """ return 0 def IntersectsLine(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectsLine(self, p1:(float, float, float), p2:(float, float, float)) -> bool C++: bool IntersectsLine(const double p1[3], const double p2[3]) Returns true if any part of segment [p1,p2] lies inside the bounding box, as well as on its boundaries. It returns false otherwise. """ pass def IntersectsSphere(self, center, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectsSphere(self, center:[float, float, float], squaredRadius:float) -> bool C++: bool IntersectsSphere(double center[3], double squaredRadius) Intersect this box with a sphere. Parameters involve the center of the sphere and the squared radius. """ pass def IsSubsetOf(self, bbox): # real signature unknown; restored from __doc__ """ IsSubsetOf(self, bbox:vtkBoundingBox) -> bool C++: bool IsSubsetOf(const vtkBoundingBox &bbox) Returns true if this instance is entirely contained by bbox. """ return False def IsValid(self): # real signature unknown; restored from __doc__ """ IsValid(self) -> int C++: int IsValid() IsValid(bounds:(float, float, float, float, float, float)) -> int C++: static int IsValid(const double bounds[6]) Returns 1 if the bounds have been set and 0 if the box is in its initialized state which is an inverted state. """ return 0 def Reset(self): # real signature unknown; restored from __doc__ """ Reset(self) -> None C++: void Reset() Returns the box to its initialized state. """ pass def Scale(self, s, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Scale(self, s:[float, float, float]) -> None C++: void Scale(double s[3]) Scale(self, sx:float, sy:float, sz:float) -> None C++: void Scale(double sx, double sy, double sz) Scale each dimension of the box by some given factor. If the box is not valid, it stays unchanged. If the scalar factor is negative, bounds are flipped: for example, if (xMin,xMax)=(-2,4) and sx=-3, (xMin,xMax) becomes (-12,6). """ pass def ScaleAboutCenter(self, s): # real signature unknown; restored from __doc__ """ ScaleAboutCenter(self, s:float) -> None C++: void ScaleAboutCenter(double s) ScaleAboutCenter(self, s:[float, float, float]) -> None C++: void ScaleAboutCenter(double s[3]) ScaleAboutCenter(self, sx:float, sy:float, sz:float) -> None C++: void ScaleAboutCenter(double sx, double sy, double sz) Scale each dimension of the box by some given factor, with the origin of the bounding box the center of the scaling. If the box is not valid, it is not changed. """ pass def SetBounds(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetBounds(self, bounds:(float, float, float, float, float, float)) -> None C++: void SetBounds(const double bounds[6]) SetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float, zMin:float, zMax:float) -> None C++: void SetBounds(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) Set the bounds explicitly of the box (using the VTK convention for representing a bounding box). Returns 1 if the box was changed else 0. """ pass def SetMaxPoint(self, x, y, z): # real signature unknown; restored from __doc__ """ SetMaxPoint(self, x:float, y:float, z:float) -> None C++: void SetMaxPoint(double x, double y, double z) SetMaxPoint(self, p:[float, float, float]) -> None C++: void SetMaxPoint(double p[3]) Set the maximum point of the bounding box - if the max point is less than the min point then the min point will also be changed. """ pass def SetMinPoint(self, x, y, z): # real signature unknown; restored from __doc__ """ SetMinPoint(self, x:float, y:float, z:float) -> None C++: void SetMinPoint(double x, double y, double z) SetMinPoint(self, p:[float, float, float]) -> None C++: void SetMinPoint(double p[3]) Set the minimum point of the bounding box - if the min point is greater than the max point then the max point will also be changed. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __hash__(self, *args, **kwargs): # real signature unknown """ Return hash(self). """ pass def __init__(self): # real signature unknown; restored from __doc__ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self