# 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 vtkImplicitFunction(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkImplicitFunction - abstract interface for implicit functions
    
    Superclass: vtkObject
    
    vtkImplicitFunction specifies an abstract interface for implicit
    functions. Implicit functions are real valued functions defined in 3D
    space, w = F(x,y,z). Two primitive operations are required: the
    ability to evaluate the function, and the function gradient at a
    given point. The implicit function divides space into three regions:
    on the surface (F(x,y,z)=w), outside of the surface (F(x,y,z)>c), and
    inside the surface (F(x,y,z)<c). (When c is zero, positive values are
    outside, negative values are inside, and zero is on the surface. Note
    also that the function gradient points from inside to outside.)
    
    Implicit functions are very powerful. It is possible to represent
    almost any type of geometry with the level sets w = const, especially
    if you use boolean combinations of implicit functions (see
    vtkImplicitBoolean).
    
    vtkImplicitFunction provides a mechanism to transform the implicit
    function(s) via a vtkAbstractTransform.  This capability can be used
    to translate, orient, scale, or warp implicit functions.  For
    example, a sphere implicit function can be transformed into an
    oriented ellipse.
    
    @warning
    The transformation transforms a point into the space of the implicit
    function (i.e., the model space). Typically we want to transform the
    implicit model into world coordinates. In this case the inverse of
    the transformation is required.
    
    @sa
    vtkAbstractTransform vtkSphere vtkCylinder vtkImplicitBoolean
    vtkPlane vtkPlanes vtkQuadric vtkImplicitVolume vtkSampleFunction
    vtkCutter vtkClipPolyData
    """
    def EvaluateFunction(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        EvaluateFunction(self, x:[float, float, float]) -> float
        C++: virtual double EvaluateFunction(double x[3])
        EvaluateFunction(self, input:vtkDataArray, output:vtkDataArray)
            -> None
        C++: virtual void EvaluateFunction(vtkDataArray *input,
            vtkDataArray *output)
        EvaluateFunction(self, x:float, y:float, z:float) -> float
        C++: virtual double EvaluateFunction(double x, double y, double z)
        
        Evaluate function at position x-y-z and return value.  You should
        generally not call this method directly, you should use
        FunctionValue() instead.  This method must be implemented by any
        derived class.
        """
        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++: virtual void EvaluateGradient(double x[3], double g[3])
        
        Evaluate function gradient at position x-y-z and pass back
        vector. You should generally not call this method directly, you
        should use FunctionGradient() instead.  This method must be
        implemented by any derived class.
        """
        pass

    def FunctionGradient(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FunctionGradient(self, x:(float, float, float), g:[float, float,
            float]) -> None
        C++: void FunctionGradient(const double x[3], double g[3])
        FunctionGradient(self, x:(float, float, float)) -> (float, float,
            float)
        C++: double *FunctionGradient(const double x[3])
        FunctionGradient(self, x:float, y:float, z:float) -> (float,
            float, float)
        C++: double *FunctionGradient(double x, double y, double z)
        
        Evaluate function gradient at position x-y-z and pass back
        vector. Point x[3] is transformed through transform (if
        provided).
        """
        pass

    def FunctionValue(self, input, output): # real signature unknown; restored from __doc__
        """
        FunctionValue(self, input:vtkDataArray, output:vtkDataArray)
            -> None
        C++: virtual void FunctionValue(vtkDataArray *input,
            vtkDataArray *output)
        FunctionValue(self, x:(float, float, float)) -> float
        C++: double FunctionValue(const double x[3])
        FunctionValue(self, x:float, y:float, z:float) -> float
        C++: double FunctionValue(double x, double y, double z)
        
        Evaluate function at position x-y-z and return value. Point x[3]
        is transformed through transform (if provided).
        """
        pass

    def GetMTime(self): # real signature unknown; restored from __doc__
        """
        GetMTime(self) -> int
        C++: vtkMTimeType GetMTime() override;
        
        Overload standard modified time function. If Transform is
        modified, then this object is modified as well.
        """
        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 GetTransform(self): # real signature unknown; restored from __doc__
        """
        GetTransform(self) -> vtkAbstractTransform
        C++: virtual vtkAbstractTransform *GetTransform()
        """
        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) -> vtkImplicitFunction
        C++: vtkImplicitFunction *NewInstance()
        """
        return vtkImplicitFunction

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkImplicitFunction
        C++: static vtkImplicitFunction *SafeDownCast(vtkObjectBase *o)
        """
        return vtkImplicitFunction

    def SetTransform(self, __a): # real signature unknown; restored from __doc__
        """
        SetTransform(self, __a:vtkAbstractTransform) -> None
        C++: virtual void SetTransform(vtkAbstractTransform *)
        SetTransform(self, elements:(float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float)) -> None
        C++: virtual void SetTransform(const double elements[16])
        
        Set/Get a transformation to apply to input points before
        executing the implicit function.
        """
        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__': 'vtkImplicitFunction', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'GetMTime': <method 'GetMTime' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'FunctionValue': <method 'FunctionValue' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'FunctionGradient': <method 'FunctionGradient' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'SetTransform': <method 'SetTransform' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'GetTransform': <method 'GetTransform' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'EvaluateFunction': <method 'EvaluateFunction' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, 'EvaluateGradient': <method 'EvaluateGradient' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF81D631AC0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonDataModel.vtkImplicitFunction' objects>, '__doc__': 'vtkImplicitFunction - abstract interface for implicit functions\\n\\nSuperclass: vtkObject\\n\\nvtkImplicitFunction specifies an abstract interface for implicit\\nfunctions. Implicit functions are real valued functions defined in 3D\\nspace, w = F(x,y,z). Two primitive operations are required: the\\nability to evaluate the function, and the function gradient at a\\ngiven point. The implicit function divides space into three regions:\\non the surface (F(x,y,z)=w), outside of the surface (F(x,y,z)>c), and\\ninside the surface (F(x,y,z)<c). (When c is zero, positive values are\\noutside, negative values are inside, and zero is on the surface. Note\\nalso that the function gradient points from inside to outside.)\\n\\nImplicit functions are very powerful. It is possible to represent\\nalmost any type of geometry with the level sets w = const, especially\\nif you use boolean combinations of implicit functions (see\\nvtkImplicitBoolean).\\n\\nvtkImplicitFunction provides a mechanism to transform the implicit\\nfunction(s) via a vtkAbstractTransform.  This capability can be used\\nto translate, orient, scale, or warp implicit functions.  For\\nexample, a sphere implicit function can be transformed into an\\noriented ellipse.\\n\\n@warning\\nThe transformation transforms a point into the space of the implicit\\nfunction (i.e., the model space). Typically we want to transform the\\nimplicit model into world coordinates. In this case the inverse of\\nthe transformation is required.\\n\\n@sa\\nvtkAbstractTransform vtkSphere vtkCylinder vtkImplicitBoolean\\nvtkPlane vtkPlanes vtkQuadric vtkImplicitVolume vtkSampleFunction\\nvtkCutter vtkClipPolyData\\n\\n'})"
    __vtkname__ = 'vtkImplicitFunction'