# 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 .vtkImplicitFunction import vtkImplicitFunction class vtkPlane(vtkImplicitFunction): """ vtkPlane - perform various plane computations Superclass: vtkImplicitFunction vtkPlane provides methods for various plane computations. These include projecting points onto a plane, evaluating the plane equation, and returning plane normal. vtkPlane is a concrete implementation of the abstract class vtkImplicitFunction. """ def ComputeBestFittingPlane(self, pts, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeBestFittingPlane(pts:vtkPoints, origin:[float, ...], normal:[float, ...]) -> bool C++: static bool ComputeBestFittingPlane(vtkPoints *pts, double *origin, double *normal) Given a set of points calculate the best-fitting origin and normal for the plane. The origin will be the centroid of the points. The normal is determined by using the covariance matrix of the points relative to the centroid. Returns true if successful. If not successful the origin will still contain the centroid and the normal will point into z-direction. """ pass def DistanceToPlane(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ DistanceToPlane(x:[float, float, float], n:[float, float, float], p0:[float, float, float]) -> float C++: static double DistanceToPlane(double x[3], double n[3], double p0[3]) DistanceToPlane(self, x:[float, float, float]) -> float C++: double DistanceToPlane(double x[3]) Return the distance of a point x to a plane defined by n(x-p0) = 0. The normal n[3] must be magnitude=1. """ pass def Evaluate(self, normal, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Evaluate(normal:[float, float, float], origin:[float, float, float], x:[float, float, float]) -> float C++: static double Evaluate(double normal[3], double origin[3], double x[3]) Quick evaluation of plane equation n(x-origin)=0. """ pass def EvaluateFunction(self, input, output): # real signature unknown; restored from __doc__ """ EvaluateFunction(self, input:vtkDataArray, output:vtkDataArray) -> None C++: void EvaluateFunction(vtkDataArray *input, vtkDataArray *output) override; EvaluateFunction(self, x:[float, float, float]) -> float C++: double EvaluateFunction(double x[3]) override; EvaluateFunction(self, x:float, y:float, z:float) -> float C++: virtual double EvaluateFunction(double x, double y, double z) """ pass def EvaluateGradient(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EvaluateGradient(self, x:[float, float, float], g:[float, float, float]) -> None C++: void EvaluateGradient(double x[3], double g[3]) override; Evaluate function gradient at point x[3]. """ pass def GeneralizedProjectPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GeneralizedProjectPoint(x:(float, float, float), origin:(float, float, float), normal:(float, float, float), xproj:[float, float, float]) -> None C++: static void GeneralizedProjectPoint(const double x[3], const double origin[3], const double normal[3], double xproj[3]) GeneralizedProjectPoint(self, x:(float, float, float), xproj:[float, float, float]) -> None C++: void GeneralizedProjectPoint(const double x[3], double xproj[3]) Project a point x onto plane defined by origin and normal. The projected point is returned in xproj. NOTE : normal does NOT have to have magnitude 1. """ pass def GetNormal(self): # real signature unknown; restored from __doc__ """ GetNormal(self) -> (float, float, float) C++: virtual double *GetNormal() """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetOrigin(self): # real signature unknown; restored from __doc__ """ GetOrigin(self) -> (float, float, float) C++: virtual double *GetOrigin() """ pass def IntersectWithFinitePlane(self, n, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectWithFinitePlane(n:[float, float, float], o:[float, float, float], pOrigin:[float, float, float], px:[float, float, float], py:[float, float, float], x0:[float, float, float], x1:[float, float, float]) -> int C++: static int IntersectWithFinitePlane(double n[3], double o[3], double pOrigin[3], double px[3], double py[3], double x0[3], double x1[3]) IntersectWithFinitePlane(self, pOrigin:[float, float, float], px:[float, float, float], py:[float, float, float], x0:[float, float, float], x1:[float, float, float]) -> int C++: int IntersectWithFinitePlane(double pOrigin[3], double px[3], double py[3], double x0[3], double x1[3]) Given two planes, one infinite and one finite, defined by the normal n and point o (infinite plane), and the second finite plane1 defined by the three points (pOrigin,px,py), compute a line of intersection (if any). The line of intersection is defined by the return values (x0,x1). If there is no intersection, then zero is returned; otherwise non-zero. There are two variants of this method. The static function operates on the supplied function parameters; the non-static operates on this instance of vtkPlane (and its associated origin and normal). """ pass def IntersectWithLine(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectWithLine(p1:(float, float, float), p2:(float, float, float), n:[float, float, float], p0:[float, float, float], t:float, x:[float, float, float]) -> int C++: static int IntersectWithLine(const double p1[3], const double p2[3], double n[3], double p0[3], double &t, double x[3]) IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), t:float, x:[float, float, float]) -> int C++: int IntersectWithLine(const double p1[3], const double p2[3], double &t, double x[3]) Given a line defined by the two points p1,p2; and a plane defined by the normal n and point p0, compute an intersection. The parametric coordinate along the line is returned in t, and the coordinates of intersection are returned in x. A zero is returned if the plane and line do not intersect between (0<=t<=1). If the plane and line are parallel, zero is returned and t is set to VTK_LARGE_DOUBLE. """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkPlane C++: vtkPlane *NewInstance() """ return vtkPlane def ProjectPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ProjectPoint(x:(float, float, float), origin:(float, float, float) , normal:(float, float, float), xproj:[float, float, float]) -> None C++: static void ProjectPoint(const double x[3], const double origin[3], const double normal[3], double xproj[3]) ProjectPoint(self, x:(float, float, float), xproj:[float, float, float]) -> None C++: void ProjectPoint(const double x[3], double xproj[3]) Project a point x onto plane defined by origin and normal. The projected point is returned in xproj. NOTE : normal assumed to have magnitude 1. """ pass def ProjectVector(self, v, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ProjectVector(v:(float, float, float), origin:(float, float, float), normal:(float, float, float), vproj:[float, float, float]) -> None C++: static void ProjectVector(const double v[3], const double origin[3], const double normal[3], double vproj[3]) ProjectVector(self, v:(float, float, float), vproj:[float, float, float]) -> None C++: void ProjectVector(const double v[3], double vproj[3]) Project a vector v onto plane defined by origin and normal. The projected vector is returned in vproj. """ pass def Push(self, distance): # real signature unknown; restored from __doc__ """ Push(self, distance:float) -> None C++: void Push(double distance) Translate the plane in the direction of the normal by the distance specified. Negative values move the plane in the opposite direction. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPlane C++: static vtkPlane *SafeDownCast(vtkObjectBase *o) """ return vtkPlane def SetNormal(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetNormal(self, _arg1:float, _arg2:float, _arg3:float) -> None C++: virtual void SetNormal(double _arg1, double _arg2, double _arg3) SetNormal(self, _arg:(float, float, float)) -> None C++: virtual void SetNormal(const double _arg[3]) Set/get plane normal. Plane is defined by point and normal. """ pass def SetOrigin(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None C++: virtual void SetOrigin(double _arg1, double _arg2, double _arg3) SetOrigin(self, _arg:(float, float, float)) -> None C++: virtual void SetOrigin(const double _arg[3]) Set/get point through which plane passes. Plane is defined by point and normal. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkPlane', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'EvaluateFunction': , 'EvaluateGradient': , 'SetNormal': , 'GetNormal': , 'SetOrigin': , 'GetOrigin': , 'Push': , 'ProjectPoint': , 'ProjectVector': , 'GeneralizedProjectPoint': , 'Evaluate': , 'DistanceToPlane': , 'IntersectWithLine': , 'IntersectWithFinitePlane': , 'ComputeBestFittingPlane': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkPlane - perform various plane computations\\n\\nSuperclass: vtkImplicitFunction\\n\\nvtkPlane provides methods for various plane computations. These\\ninclude projecting points onto a plane, evaluating the plane\\nequation, and returning plane normal. vtkPlane is a concrete\\nimplementation of the abstract class vtkImplicitFunction.\\n\\n'})" __vtkname__ = 'vtkPlane'