# 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 .vtkDataObject import vtkDataObject class vtkPiecewiseFunction(vtkDataObject): """ vtkPiecewiseFunction - Defines a 1D piecewise function. Superclass: vtkDataObject Defines a piecewise function mapping. This mapping allows the addition of control points, and allows the user to control the function between the control points. A piecewise hermite curve is used between control points, based on the sharpness and midpoint parameters. A sharpness of 0 yields a piecewise linear function and a sharpness of 1 yields a piecewise constant function. The midpoint is the normalized distance between control points at which the curve reaches the median Y value. The midpoint and sharpness values specified when adding a node are used to control the transition to the next node (the last node's values are ignored) Outside the range of nodes, the values are 0 if Clamping is off, or the nearest node point if Clamping is on. Using the legacy methods for adding points (which do not have Sharpness and Midpoint parameters) will default to Midpoint = 0.5 (halfway between the control points) and Sharpness = 0.0 (linear). """ def AddPoint(self, x, y): # real signature unknown; restored from __doc__ """ AddPoint(self, x:float, y:float) -> int C++: int AddPoint(double x, double y) AddPoint(self, x:float, y:float, midpoint:float, sharpness:float) -> int C++: int AddPoint(double x, double y, double midpoint, double sharpness) Add points to the function. If a duplicate point is added then the previous point is removed unless AllowDuplicateScalars is set to true Return the index of the point (0 based), or -1 on error. """ return 0 def AddSegment(self, x1, y1, x2, y2): # real signature unknown; restored from __doc__ """ AddSegment(self, x1:float, y1:float, x2:float, y2:float) -> None C++: void AddSegment(double x1, double y1, double x2, double y2) Add a line segment to the function. All points defined between the two points specified are removed from the function. To specify the sharpness and midpoint values, use AddPoint method instead. """ pass def AdjustRange(self, range, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AdjustRange(self, range:[float, float]) -> int C++: int AdjustRange(double range[2]) Remove all points out of the new range, and make sure there is a point at each end of that range. Return 1 on success, 0 otherwise. """ pass def AllowDuplicateScalarsOff(self): # real signature unknown; restored from __doc__ """ AllowDuplicateScalarsOff(self) -> None C++: virtual void AllowDuplicateScalarsOff() """ pass def AllowDuplicateScalarsOn(self): # real signature unknown; restored from __doc__ """ AllowDuplicateScalarsOn(self) -> None C++: virtual void AllowDuplicateScalarsOn() """ pass def BuildFunctionFromTable(self, x1, x2, size, table, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ BuildFunctionFromTable(self, x1:float, x2:float, size:int, table:[float, ...], stride:int=1) -> None C++: void BuildFunctionFromTable(double x1, double x2, int size, double *table, int stride=1) Constructs a piecewise function from a table. Function range is is set to [x1, x2], function size is set to size, and function points are regularly spaced between x1 and x2. Parameter "stride" is is step through the input table. """ pass def ClampingOff(self): # real signature unknown; restored from __doc__ """ ClampingOff(self) -> None C++: virtual void ClampingOff() """ pass def ClampingOn(self): # real signature unknown; restored from __doc__ """ ClampingOn(self) -> None C++: virtual void ClampingOn() """ pass def DeepCopy(self, f): # real signature unknown; restored from __doc__ """ DeepCopy(self, f:vtkDataObject) -> None C++: void DeepCopy(vtkDataObject *f) override; """ pass def EstimateMinNumberOfSamples(self, x1, x2): # real signature unknown; restored from __doc__ """ EstimateMinNumberOfSamples(self, x1:float, x2:float) -> int C++: int EstimateMinNumberOfSamples(double const &x1, double const &x2) Estimates the minimum size of a table such that it would correctly sample this function. The returned value should be passed as parameter 'n' when calling GetTable(). """ return 0 def FillFromDataPointer(self, __a, __b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FillFromDataPointer(self, __a:int, __b:[float, ...]) -> None C++: void FillFromDataPointer(int, double *) """ pass def GetAllowDuplicateScalars(self): # real signature unknown; restored from __doc__ """ GetAllowDuplicateScalars(self) -> int C++: virtual vtkTypeBool GetAllowDuplicateScalars() """ return 0 def GetClamping(self): # real signature unknown; restored from __doc__ """ GetClamping(self) -> int C++: virtual vtkTypeBool GetClamping() """ return 0 def GetData(self, info): # real signature unknown; restored from __doc__ """ GetData(info:vtkInformation) -> vtkPiecewiseFunction C++: static vtkPiecewiseFunction *GetData(vtkInformation *info) GetData(v:vtkInformationVector, i:int=0) -> vtkPiecewiseFunction C++: static vtkPiecewiseFunction *GetData(vtkInformationVector *v, int i=0) Retrieve an instance of this class from an information object. """ return vtkPiecewiseFunction def GetDataObjectType(self): # real signature unknown; restored from __doc__ """ GetDataObjectType(self) -> int C++: int GetDataObjectType() override; Return what type of dataset this is. """ return 0 def GetDataPointer(self): # real signature unknown; restored from __doc__ """ GetDataPointer(self) -> Pointer C++: double *GetDataPointer() Returns a pointer to the data stored in the table. Fills from a pointer to data stored in a similar table. These are legacy methods which will be maintained for compatibility - however, note that the vtkPiecewiseFunction no longer stores the nodes in a double array internally. """ pass def GetFirstNonZeroValue(self): # real signature unknown; restored from __doc__ """ GetFirstNonZeroValue(self) -> float C++: double GetFirstNonZeroValue() Returns the first point location which precedes a non-zero segment of the function. Note that the value at this point may be zero. """ return 0.0 def GetNodeValue(self, index, val, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetNodeValue(self, index:int, val:[float, float, float, float]) -> int C++: int GetNodeValue(int index, double val[4]) For the node specified by index, set/get the location (X), value (Y), midpoint, and sharpness values at the node. Returns -1 if the index is out of range, returns 1 otherwise. """ 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 GetRange(self): # real signature unknown; restored from __doc__ """ GetRange(self) -> (float, float) C++: virtual double *GetRange() Returns the min and max node locations of the function. """ pass def GetSize(self): # real signature unknown; restored from __doc__ """ GetSize(self) -> int C++: int GetSize() Get the number of points used to specify the function """ return 0 def GetTable(self, x1, x2, size, table, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetTable(self, x1:float, x2:float, size:int, table:[float, ...], stride:int=1, logIncrements:int=0) -> None C++: void GetTable(double x1, double x2, int size, double *table, int stride=1, int logIncrements=0) """ pass def GetType(self): # real signature unknown; restored from __doc__ """ GetType(self) -> str C++: const char *GetType() Return the type of function: Function Types: 0 : Constant (No change in slope between end points) 1 : NonDecreasing (Always increasing or zero slope) 2 : NonIncreasing (Always decreasing or zero slope) 3 : Varied (Contains both decreasing and increasing slopes) """ return "" def GetUseLogScale(self): # real signature unknown; restored from __doc__ """ GetUseLogScale(self) -> bool C++: virtual bool GetUseLogScale() """ return False def GetValue(self, x): # real signature unknown; restored from __doc__ """ GetValue(self, x:float) -> float C++: double GetValue(double x) Returns the value of the function at the specified location using the specified interpolation. """ return 0.0 def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Clears out the current function. A newly created vtkPiecewiseFunction is already initialized, so there is no need to call this method which in turn simply calls RemoveAllPoints() """ 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) -> vtkPiecewiseFunction C++: vtkPiecewiseFunction *NewInstance() """ return vtkPiecewiseFunction def RemoveAllPoints(self): # real signature unknown; restored from __doc__ """ RemoveAllPoints(self) -> None C++: void RemoveAllPoints() Removes all points from the function. """ pass def RemovePoint(self, x): # real signature unknown; restored from __doc__ """ RemovePoint(self, x:float) -> int C++: int RemovePoint(double x) RemovePoint(self, x:float, y:float) -> int C++: int RemovePoint(double x, double y) Remove the first point found at the given x location Return the index of the remove point if any, -1 otherwise """ return 0 def RemovePointByIndex(self, id): # real signature unknown; restored from __doc__ """ RemovePointByIndex(self, id:int) -> bool C++: bool RemovePointByIndex(size_t id) Remove a point from the function at a given id Return true if point has been found and removed, false other wise """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPiecewiseFunction C++: static vtkPiecewiseFunction *SafeDownCast(vtkObjectBase *o) """ return vtkPiecewiseFunction def SetAllowDuplicateScalars(self, _arg): # real signature unknown; restored from __doc__ """ SetAllowDuplicateScalars(self, _arg:int) -> None C++: virtual void SetAllowDuplicateScalars(vtkTypeBool _arg) Toggle whether to allow duplicate scalar values in the piecewise function (off by default). """ pass def SetClamping(self, _arg): # real signature unknown; restored from __doc__ """ SetClamping(self, _arg:int) -> None C++: virtual void SetClamping(vtkTypeBool _arg) When zero range clamping is Off, GetValue() returns 0.0 when a value is requested outside of the points specified. When zero range clamping is On, GetValue() returns the value at the value at the lowest point for a request below all points specified and returns the value at the highest point for a request above all points specified. On is the default. """ pass def SetNodeValue(self, index, val, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetNodeValue(self, index:int, val:[float, float, float, float]) -> int C++: int SetNodeValue(int index, double val[4]) """ pass def SetUseLogScale(self, _arg): # real signature unknown; restored from __doc__ """ SetUseLogScale(self, _arg:bool) -> None C++: virtual void SetUseLogScale(bool _arg) """ pass def ShallowCopy(self, f): # real signature unknown; restored from __doc__ """ ShallowCopy(self, f:vtkDataObject) -> None C++: void ShallowCopy(vtkDataObject *f) override; Shallow and Deep copy. These copy the data, but not any of the pipeline connections. """ pass def UseLogScaleOff(self): # real signature unknown; restored from __doc__ """ UseLogScaleOff(self) -> None C++: virtual void UseLogScaleOff() """ pass def UseLogScaleOn(self): # real signature unknown; restored from __doc__ """ UseLogScaleOn(self) -> None C++: virtual void UseLogScaleOn() """ 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__\': \'vtkPiecewiseFunction\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'DeepCopy\': , \'ShallowCopy\': , \'GetDataObjectType\': , \'GetSize\': , \'AddPoint\': , \'RemovePointByIndex\': , \'RemovePoint\': , \'RemoveAllPoints\': , \'AddSegment\': , \'GetValue\': , \'GetNodeValue\': , \'SetNodeValue\': , \'GetDataPointer\': , \'FillFromDataPointer\': , \'GetRange\': , \'AdjustRange\': , \'GetTable\': , \'BuildFunctionFromTable\': , \'SetClamping\': , \'GetClamping\': , \'ClampingOn\': , \'ClampingOff\': , \'SetUseLogScale\': , \'GetUseLogScale\': , \'UseLogScaleOn\': , \'UseLogScaleOff\': , \'GetType\': , \'GetFirstNonZeroValue\': , \'Initialize\': , \'GetData\': , \'SetAllowDuplicateScalars\': , \'GetAllowDuplicateScalars\': , \'AllowDuplicateScalarsOn\': , \'AllowDuplicateScalarsOff\': , \'EstimateMinNumberOfSamples\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkPiecewiseFunction - Defines a 1D piecewise function.\\n\\nSuperclass: vtkDataObject\\n\\nDefines a piecewise function mapping. This mapping allows the\\naddition of control points, and allows the user to control the\\nfunction between the control points. A piecewise hermite curve is\\nused between control points, based on the sharpness and midpoint\\nparameters. A sharpness of 0 yields a piecewise linear function and a\\nsharpness of 1 yields a piecewise constant function. The midpoint is\\nthe normalized distance between control points at which the curve\\nreaches the median Y value. The midpoint and sharpness values\\nspecified when adding a node are used to control the transition to\\nthe next node (the last node\'s values are ignored) Outside the range\\nof nodes, the values are 0 if Clamping is off, or the nearest node\\npoint if Clamping is on. Using the legacy methods for adding points \\n(which do not have Sharpness and Midpoint parameters) will default to\\nMidpoint = 0.5 (halfway between the control points) and Sharpness =\\n0.0 (linear).\\n\\n"})' __vtkname__ = 'vtkPiecewiseFunction'