# 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 class vtkSpline(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSpline - spline abstract class for interpolating splines Superclass: vtkObject vtkSpline interpolates a set of data points (i.e., interpolation means that the spline passes through the points). vtkSpline is an abstract class: its subclasses vtkCardinalSpline and vtkKochanekSpline do the interpolation. Note that this spline maps the 1D parametric coordinate t into a single value x. Thus if you want to use the spline to interpolate points (i.e. x[3]), you have to create three splines for each of the x-y-z coordinates. Fortunately, the vtkParametricSpline class does this for you. Typically a spline is used by adding a sequence of parametric coordinate / data (t,x) values followed by use of an evaluation function (e.g., vtkCardinalSpline::Evaluate()). Since these splines are 1D, a point in this context is an independent / dependent variable pair. Splines can also be set up to be closed or open. Closed splines continue from the last point to the first point with continuous function and derivative values. (You don't need to duplicate the first point to close the spline, just set ClosedOn.) This implementation of splines does not use a normalized parametric coordinate. If the spline is open, then the parameter space is (tMin <= t <= tMax) where tMin and tMax are the minimum and maximum parametric values seen when performing AddPoint(). If the spline is closed, then the parameter space is (tMin <= t <= (tMax+1)) where tMin and tMax are the minimum and maximum parametric values seen when performing AddPoint(). Note, however, that this behavior can be changed by explicitly setting the ParametricRange(tMin,tMax). If set, the parameter space remains (tMin <= t <= tMax), except that additions of data with parametric values outside this range are clamped within this range. @sa vtkCardinalSpline vtkKochanekSpline vtkParametricSpline vtkParametricFunctionSource """ def AddPoint(self, t, x): # real signature unknown; restored from __doc__ """ AddPoint(self, t:float, x:float) -> None C++: void AddPoint(double t, double x) Add a pair of points to be fit with the spline. """ pass def ClampValueOff(self): # real signature unknown; restored from __doc__ """ ClampValueOff(self) -> None C++: virtual void ClampValueOff() """ pass def ClampValueOn(self): # real signature unknown; restored from __doc__ """ ClampValueOn(self) -> None C++: virtual void ClampValueOn() """ pass def ClosedOff(self): # real signature unknown; restored from __doc__ """ ClosedOff(self) -> None C++: virtual void ClosedOff() """ pass def ClosedOn(self): # real signature unknown; restored from __doc__ """ ClosedOn(self) -> None C++: virtual void ClosedOn() """ pass def Compute(self): # real signature unknown; restored from __doc__ """ Compute(self) -> None C++: virtual void Compute() Compute the coefficients for the spline. """ pass def DeepCopy(self, s): # real signature unknown; restored from __doc__ """ DeepCopy(self, s:vtkSpline) -> None C++: virtual void DeepCopy(vtkSpline *s) Deep copy of spline data. """ pass def Evaluate(self, t): # real signature unknown; restored from __doc__ """ Evaluate(self, t:float) -> float C++: virtual double Evaluate(double t) Interpolate the value of the spline at parametric location of t. """ return 0.0 def GetClampValue(self): # real signature unknown; restored from __doc__ """ GetClampValue(self) -> int C++: virtual vtkTypeBool GetClampValue() """ return 0 def GetClosed(self): # real signature unknown; restored from __doc__ """ GetClosed(self) -> int C++: virtual vtkTypeBool GetClosed() """ return 0 def GetLeftConstraint(self): # real signature unknown; restored from __doc__ """ GetLeftConstraint(self) -> int C++: virtual int GetLeftConstraint() """ return 0 def GetLeftConstraintMaxValue(self): # real signature unknown; restored from __doc__ """ GetLeftConstraintMaxValue(self) -> int C++: virtual int GetLeftConstraintMaxValue() """ return 0 def GetLeftConstraintMinValue(self): # real signature unknown; restored from __doc__ """ GetLeftConstraintMinValue(self) -> int C++: virtual int GetLeftConstraintMinValue() """ return 0 def GetLeftValue(self): # real signature unknown; restored from __doc__ """ GetLeftValue(self) -> float C++: virtual double GetLeftValue() """ return 0.0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Return the MTime also considering the Piecewise function. """ return 0 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 GetNumberOfPoints(self): # real signature unknown; restored from __doc__ """ GetNumberOfPoints(self) -> int C++: int GetNumberOfPoints() Return the number of points inserted thus far. """ return 0 def GetParametricRange(self, tRange, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetParametricRange(self, tRange:[float, float]) -> None C++: void GetParametricRange(double tRange[2]) """ pass def GetRightConstraint(self): # real signature unknown; restored from __doc__ """ GetRightConstraint(self) -> int C++: virtual int GetRightConstraint() """ return 0 def GetRightConstraintMaxValue(self): # real signature unknown; restored from __doc__ """ GetRightConstraintMaxValue(self) -> int C++: virtual int GetRightConstraintMaxValue() """ return 0 def GetRightConstraintMinValue(self): # real signature unknown; restored from __doc__ """ GetRightConstraintMinValue(self) -> int C++: virtual int GetRightConstraintMinValue() """ return 0 def GetRightValue(self): # real signature unknown; restored from __doc__ """ GetRightValue(self) -> float C++: virtual double GetRightValue() """ return 0.0 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) -> vtkSpline C++: vtkSpline *NewInstance() """ return vtkSpline def RemoveAllPoints(self): # real signature unknown; restored from __doc__ """ RemoveAllPoints(self) -> None C++: void RemoveAllPoints() Remove all points from the data. """ pass def RemovePoint(self, t): # real signature unknown; restored from __doc__ """ RemovePoint(self, t:float) -> None C++: void RemovePoint(double t) Remove a point from the data to be fit with the spline. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSpline C++: static vtkSpline *SafeDownCast(vtkObjectBase *o) """ return vtkSpline def SetClampValue(self, _arg): # real signature unknown; restored from __doc__ """ SetClampValue(self, _arg:int) -> None C++: virtual void SetClampValue(vtkTypeBool _arg) Set/Get ClampValue. If On, results of the interpolation will be clamped to the min/max of the input data. """ pass def SetClosed(self, _arg): # real signature unknown; restored from __doc__ """ SetClosed(self, _arg:int) -> None C++: virtual void SetClosed(vtkTypeBool _arg) Control whether the spline is open or closed. A closed spline forms a continuous loop: the first and last points are the same, and derivatives are continuous. """ pass def SetLeftConstraint(self, _arg): # real signature unknown; restored from __doc__ """ SetLeftConstraint(self, _arg:int) -> None C++: virtual void SetLeftConstraint(int _arg) Set the type of constraint of the left(right) end points. Four constraints are available: * 0: the first derivative at left(right) most point is determined * from the line defined from the first(last) two points. * 1: the first derivative at left(right) most point is set to * Left(Right)Value. * 2: the second derivative at left(right) most point is set to * Left(Right)Value. * 3: the second derivative at left(right)most points is Left(Right)Value * times second derivative at first interior point. """ pass def SetLeftValue(self, _arg): # real signature unknown; restored from __doc__ """ SetLeftValue(self, _arg:float) -> None C++: virtual void SetLeftValue(double _arg) The values of the derivative on the left and right sides. The value is used only if the left(right) constraint is type 1-3. """ pass def SetParametricRange(self, tMin, tMax): # real signature unknown; restored from __doc__ """ SetParametricRange(self, tMin:float, tMax:float) -> None C++: void SetParametricRange(double tMin, double tMax) SetParametricRange(self, tRange:[float, float]) -> None C++: void SetParametricRange(double tRange[2]) Set/Get the parametric range. If not set, the range is determined implicitly by keeping track of the (min,max) parameter values for t. If set, the AddPoint() method will clamp the t value to lie within the specified range. """ pass def SetRightConstraint(self, _arg): # real signature unknown; restored from __doc__ """ SetRightConstraint(self, _arg:int) -> None C++: virtual void SetRightConstraint(int _arg) """ pass def SetRightValue(self, _arg): # real signature unknown; restored from __doc__ """ SetRightValue(self, _arg:float) -> None C++: virtual void SetRightValue(double _arg) """ 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__\': \'vtkSpline\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetParametricRange\': , \'GetParametricRange\': , \'SetClampValue\': , \'GetClampValue\': , \'ClampValueOn\': , \'ClampValueOff\': , \'Compute\': , \'Evaluate\': , \'GetNumberOfPoints\': , \'AddPoint\': , \'RemovePoint\': , \'RemoveAllPoints\': , \'SetClosed\': , \'GetClosed\': , \'ClosedOn\': , \'ClosedOff\': , \'SetLeftConstraint\': , \'GetLeftConstraintMinValue\': , \'GetLeftConstraintMaxValue\': , \'GetLeftConstraint\': , \'SetRightConstraint\': , \'GetRightConstraintMinValue\': , \'GetRightConstraintMaxValue\': , \'GetRightConstraint\': , \'SetLeftValue\': , \'GetLeftValue\': , \'SetRightValue\': , \'GetRightValue\': , \'GetMTime\': , \'DeepCopy\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSpline - spline abstract class for interpolating splines\\n\\nSuperclass: vtkObject\\n\\nvtkSpline interpolates a set of data points (i.e., interpolation\\nmeans that the spline passes through the points). vtkSpline is an\\nabstract class: its subclasses vtkCardinalSpline and\\nvtkKochanekSpline do the interpolation. Note that this spline maps\\nthe 1D parametric coordinate t into a single value x. Thus if you\\nwant to use the spline to interpolate points (i.e. x[3]), you have to\\ncreate three splines for each of the x-y-z coordinates. Fortunately,\\nthe vtkParametricSpline class does this for you.\\n\\nTypically a spline is used by adding a sequence of parametric\\ncoordinate / data (t,x) values followed by use of an evaluation\\nfunction (e.g., vtkCardinalSpline::Evaluate()). Since these splines\\nare 1D, a point in this context is an independent / dependent\\nvariable pair.\\n\\nSplines can also be set up to be closed or open. Closed splines\\ncontinue from the last point to the first point with continuous\\nfunction and derivative values. (You don\'t need to duplicate the\\nfirst point to close the spline, just set ClosedOn.)\\n\\nThis implementation of splines does not use a normalized parametric\\ncoordinate. If the spline is open, then the parameter space is (tMin\\n<= t <= tMax) where tMin and tMax are the minimum and maximum\\nparametric values seen when performing AddPoint(). If the spline is\\nclosed, then the parameter space is (tMin <= t <= (tMax+1)) where\\ntMin and tMax are the minimum and maximum parametric values seen when\\nperforming AddPoint(). Note, however, that this behavior can be\\nchanged by explicitly setting the ParametricRange(tMin,tMax). If set,\\nthe parameter space remains (tMin <= t <= tMax), except that\\nadditions of data with parametric values outside this range are\\nclamped within this range.\\n\\n@sa\\nvtkCardinalSpline vtkKochanekSpline vtkParametricSpline\\nvtkParametricFunctionSource\\n\\n"})' __vtkname__ = 'vtkSpline'