"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkImplicitTextureCoords(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkImplicitTextureCoords - generate 1D, 2D, or 3D texture coordinates
    based on implicit function(s)
    
    Superclass: vtkDataSetAlgorithm
    
    vtkImplicitTextureCoords is a filter to generate 1D, 2D, or 3D
    texture coordinates from one, two, or three implicit functions,
    respectively. In combinations with a vtkBooleanTexture map (or
    another texture map of your own creation), the texture coordinates
    can be used to highlight (via color or intensity) or cut (via
    transparency) dataset geometry without any complex geometric
    processing. (Note: the texture coordinates are referred to as r-s-t
    coordinates.)
    
    The texture coordinates are automatically normalized to lie between
    (0,1). Thus, no matter what the implicit functions evaluate to, the
    resulting texture coordinates lie between (0,1), with the zero
    implicit function value mapped to the 0.5 texture coordinates value.
    Depending upon the maximum negative/positive implicit function
    values, the full (0,1) range may not be occupied (i.e., the
    positive/negative ranges are mapped using the same scale factor).
    
    A boolean variable InvertTexture is available to flip the texture
    coordinates around 0.5 (value 1.0 becomes 0.0, 0.25->0.75). This is
    equivalent to flipping the texture map (but a whole lot easier).
    
    @warning
    You can use the transformation capabilities of vtkImplicitFunction to
    orient, translate, and scale the implicit functions. Also, the
    dimension of the texture coordinates is implicitly defined by the
    number of implicit functions defined.
    
    @sa
    vtkImplicitFunction vtkTexture vtkBooleanTexture vtkTransformTexture
    """
    def FlipTextureOff(self):
        """
        V.FlipTextureOff()
        C++: virtual void FlipTextureOff()
        
        If enabled, this will flip the sense of inside and outside the
        implicit function (i.e., a rotation around the r-s-t=0.5 axis).
        """
        ...
    
    def FlipTextureOn(self):
        """
        V.FlipTextureOn()
        C++: virtual void FlipTextureOn()
        
        If enabled, this will flip the sense of inside and outside the
        implicit function (i.e., a rotation around the r-s-t=0.5 axis).
        """
        ...
    
    def GetFlipTexture(self):
        """
        V.GetFlipTexture() -> int
        C++: virtual vtkTypeBool GetFlipTexture()
        
        If enabled, this will flip the sense of inside and outside the
        implicit function (i.e., a rotation around the r-s-t=0.5 axis).
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetRFunction(self):
        """
        V.GetRFunction() -> vtkImplicitFunction
        C++: virtual vtkImplicitFunction *GetRFunction()
        
        Specify an implicit function to compute the r texture coordinate.
        """
        ...
    
    def GetSFunction(self):
        """
        V.GetSFunction() -> vtkImplicitFunction
        C++: virtual vtkImplicitFunction *GetSFunction()
        
        Specify an implicit function to compute the s texture coordinate.
        """
        ...
    
    def GetTFunction(self):
        """
        V.GetTFunction() -> vtkImplicitFunction
        C++: virtual vtkImplicitFunction *GetTFunction()
        
        Specify an implicit function to compute the t texture coordinate.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkImplicitTextureCoords
        C++: vtkImplicitTextureCoords *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkImplicitTextureCoords
        C++: static vtkImplicitTextureCoords *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetFlipTexture(self, p_int):
        """
        V.SetFlipTexture(int)
        C++: virtual void SetFlipTexture(vtkTypeBool _arg)
        
        If enabled, this will flip the sense of inside and outside the
        implicit function (i.e., a rotation around the r-s-t=0.5 axis).
        """
        ...
    
    def SetRFunction(self, vtkImplicitFunction):
        """
        V.SetRFunction(vtkImplicitFunction)
        C++: virtual void SetRFunction(vtkImplicitFunction *)
        
        Specify an implicit function to compute the r texture coordinate.
        """
        ...
    
    def SetSFunction(self, vtkImplicitFunction):
        """
        V.SetSFunction(vtkImplicitFunction)
        C++: virtual void SetSFunction(vtkImplicitFunction *)
        
        Specify an implicit function to compute the s texture coordinate.
        """
        ...
    
    def SetTFunction(self, vtkImplicitFunction):
        """
        V.SetTFunction(vtkImplicitFunction)
        C++: virtual void SetTFunction(vtkImplicitFunction *)
        
        Specify an implicit function to compute the t texture coordinate.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkScalarsToTextureFilter(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkScalarsToTextureFilter - generate texture coordinates and a
    texture image based on a scalar field
    
    Superclass: vtkPolyDataAlgorithm
    
    This filter computes texture coordinates and a 2D texture image based
    on a polydata, a color transfer function and an array. The output
    port 0 will contain the input polydata with computed texture
    coordinates. The output port 1 will contain the texture. The computed
    texture coordinates is based on vtkTextureMapToPlane which computes
    them using 3D positions projected on the best fitting plane.
    @sa vtkTextureMapToPlane vtkResampleToImage
    """
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetTextureDimensions(self):
        """
        V.GetTextureDimensions() -> (int, int)
        C++: virtual int *GetTextureDimensions()
        
        Get/Set the width and height of the generated texture. Default is
        128x128. The width and height must be greater than 1.
        """
        ...
    
    def GetTransferFunction(self):
        """
        V.GetTransferFunction() -> vtkScalarsToColors
        C++: vtkScalarsToColors *GetTransferFunction()
        
        Set/Get a color transfer function. This transfer function will be
        used to determine the pixel colors of the texture. If not
        specified, the filter use a default one (blue/white/red) based on
        the range of the input array.
        """
        ...
    
    def GetUseTransferFunction(self):
        """
        V.GetUseTransferFunction() -> bool
        C++: virtual bool GetUseTransferFunction()
        
        Specify if a new point array containing RGBA values have to be
        computed by the specified color transfer function.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkScalarsToTextureFilter
        C++: vtkScalarsToTextureFilter *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkScalarsToTextureFilter
        C++: static vtkScalarsToTextureFilter *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetTextureDimensions(self, p_int, p_int_1):
        """
        V.SetTextureDimensions(int, int)
        C++: virtual void SetTextureDimensions(int _arg1, int _arg2)
        V.SetTextureDimensions((int, int))
        C++: void SetTextureDimensions(const int _arg[2])
        
        Get/Set the width and height of the generated texture. Default is
        128x128. The width and height must be greater than 1.
        """
        ...
    
    def SetTransferFunction(self, vtkScalarsToColors):
        """
        V.SetTransferFunction(vtkScalarsToColors)
        C++: void SetTransferFunction(vtkScalarsToColors *stc)
        
        Set/Get a color transfer function. This transfer function will be
        used to determine the pixel colors of the texture. If not
        specified, the filter use a default one (blue/white/red) based on
        the range of the input array.
        """
        ...
    
    def SetUseTransferFunction(self, bool):
        """
        V.SetUseTransferFunction(bool)
        C++: virtual void SetUseTransferFunction(bool _arg)
        
        Specify if a new point array containing RGBA values have to be
        computed by the specified color transfer function.
        """
        ...
    
    def UseTransferFunctionOff(self):
        """
        V.UseTransferFunctionOff()
        C++: virtual void UseTransferFunctionOff()
        
        Specify if a new point array containing RGBA values have to be
        computed by the specified color transfer function.
        """
        ...
    
    def UseTransferFunctionOn(self):
        """
        V.UseTransferFunctionOn()
        C++: virtual void UseTransferFunctionOn()
        
        Specify if a new point array containing RGBA values have to be
        computed by the specified color transfer function.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkTextureMapToCylinder(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkTextureMapToCylinder - generate texture coordinates by mapping
    points to cylinder
    
    Superclass: vtkDataSetAlgorithm
    
    vtkTextureMapToCylinder is a filter that generates 2D texture
    coordinates by mapping input dataset points onto a cylinder. The
    cylinder can either be user specified or generated automatically.
    (The cylinder is generated automatically by computing the axis of the
    cylinder.)  Note that the generated texture coordinates for the
    s-coordinate ranges from (0-1) (corresponding to angle of 0->360
    around axis), while the mapping of the t-coordinate is controlled by
    the projection of points along the axis.
    
    To specify a cylinder manually, you must provide two points that
    define the axis of the cylinder. The length of the axis will affect
    the t-coordinates.
    
    A special ivar controls how the s-coordinate is generated. If
    PreventSeam is set to true, the s-texture varies from 0->1 and then
    1->0 (corresponding to angles of 0->180 and 180->360).
    
    @warning
    Since the resulting texture s-coordinate will lie between (0,1), and
    the origin of the texture coordinates is not user-controllable, you
    may want to use the class vtkTransformTexture to linearly scale and
    shift the origin of the texture coordinates.
    
    @sa
    vtkTextureMapToPlane vtkTextureMapToSphere vtkTransformTexture
    vtkThresholdTextureCoords
    """
    def AutomaticCylinderGenerationOff(self):
        """
        V.AutomaticCylinderGenerationOff()
        C++: virtual void AutomaticCylinderGenerationOff()
        
        Turn on/off automatic cylinder generation. This means it
        automatically finds the cylinder center and axis.
        """
        ...
    
    def AutomaticCylinderGenerationOn(self):
        """
        V.AutomaticCylinderGenerationOn()
        C++: virtual void AutomaticCylinderGenerationOn()
        
        Turn on/off automatic cylinder generation. This means it
        automatically finds the cylinder center and axis.
        """
        ...
    
    def GetAutomaticCylinderGeneration(self):
        """
        V.GetAutomaticCylinderGeneration() -> int
        C++: virtual vtkTypeBool GetAutomaticCylinderGeneration()
        
        Turn on/off automatic cylinder generation. This means it
        automatically finds the cylinder center and axis.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetPoint1(self):
        """
        V.GetPoint1() -> (float, float, float)
        C++: virtual double *GetPoint1()
        
        Specify the first point defining the cylinder axis,
        """
        ...
    
    def GetPoint2(self):
        """
        V.GetPoint2() -> (float, float, float)
        C++: virtual double *GetPoint2()
        
        Specify the second point defining the cylinder axis,
        """
        ...
    
    def GetPreventSeam(self):
        """
        V.GetPreventSeam() -> int
        C++: virtual vtkTypeBool GetPreventSeam()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the angle variation from 0->180 and 180->0. Otherwise, the
        s-coordinate ranges from 0->1 from 0->360 degrees.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkTextureMapToCylinder
        C++: vtkTextureMapToCylinder *NewInstance()
        """
        ...
    
    def PreventSeamOff(self):
        """
        V.PreventSeamOff()
        C++: virtual void PreventSeamOff()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the angle variation from 0->180 and 180->0. Otherwise, the
        s-coordinate ranges from 0->1 from 0->360 degrees.
        """
        ...
    
    def PreventSeamOn(self):
        """
        V.PreventSeamOn()
        C++: virtual void PreventSeamOn()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the angle variation from 0->180 and 180->0. Otherwise, the
        s-coordinate ranges from 0->1 from 0->360 degrees.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkTextureMapToCylinder
        C++: static vtkTextureMapToCylinder *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetAutomaticCylinderGeneration(self, p_int):
        """
        V.SetAutomaticCylinderGeneration(int)
        C++: virtual void SetAutomaticCylinderGeneration(vtkTypeBool _arg)
        
        Turn on/off automatic cylinder generation. This means it
        automatically finds the cylinder center and axis.
        """
        ...
    
    def SetPoint1(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint1(float, float, float)
        C++: virtual void SetPoint1(double _arg1, double _arg2,
            double _arg3)
        V.SetPoint1((float, float, float))
        C++: virtual void SetPoint1(const double _arg[3])
        
        Specify the first point defining the cylinder axis,
        """
        ...
    
    def SetPoint2(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint2(float, float, float)
        C++: virtual void SetPoint2(double _arg1, double _arg2,
            double _arg3)
        V.SetPoint2((float, float, float))
        C++: virtual void SetPoint2(const double _arg[3])
        
        Specify the second point defining the cylinder axis,
        """
        ...
    
    def SetPreventSeam(self, p_int):
        """
        V.SetPreventSeam(int)
        C++: virtual void SetPreventSeam(vtkTypeBool _arg)
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the angle variation from 0->180 and 180->0. Otherwise, the
        s-coordinate ranges from 0->1 from 0->360 degrees.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkTextureMapToPlane(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkTextureMapToPlane - generate texture coordinates by mapping points
    to plane
    
    Superclass: vtkDataSetAlgorithm
    
    vtkTextureMapToPlane is a filter that generates 2D texture
    coordinates by mapping input dataset points onto a plane. The plane
    can either be user specified or generated automatically. (A least
    squares method is used to generate the plane automatically.)
    
    There are two ways you can specify the plane. The first is to provide
    a plane normal. In this case the points are projected to a plane, and
    the points are then mapped into the user specified s-t coordinate
    range. For more control, you can specify a plane with three points:
    an origin and two points defining the two axes of the plane. (This is
    compatible with the vtkPlaneSource.) Using the second method, the
    SRange and TRange vectors are ignored, since the presumption is that
    the user does not want to scale the texture coordinates; and you can
    adjust the origin and axes points to achieve the texture coordinate
    scaling you need. Note also that using the three point method the
    axes do not have to be orthogonal.
    
    @sa
     vtkPlaneSource vtkTextureMapToCylinder vtkTextureMapToSphere
    vtkThresholdTextureCoords
    """
    def AutomaticPlaneGenerationOff(self):
        """
        V.AutomaticPlaneGenerationOff()
        C++: virtual void AutomaticPlaneGenerationOff()
        
        Turn on/off automatic plane generation.
        """
        ...
    
    def AutomaticPlaneGenerationOn(self):
        """
        V.AutomaticPlaneGenerationOn()
        C++: virtual void AutomaticPlaneGenerationOn()
        
        Turn on/off automatic plane generation.
        """
        ...
    
    def GetAutomaticPlaneGeneration(self):
        """
        V.GetAutomaticPlaneGeneration() -> int
        C++: virtual vtkTypeBool GetAutomaticPlaneGeneration()
        
        Turn on/off automatic plane generation.
        """
        ...
    
    def GetNormal(self):
        """
        V.GetNormal() -> (float, float, float)
        C++: virtual double *GetNormal()
        
        Specify plane normal. An alternative way to specify a map plane.
        Using this method, the object will scale the resulting texture
        coordinate between the SRange and TRange specified.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetOrigin(self):
        """
        V.GetOrigin() -> (float, float, float)
        C++: virtual double *GetOrigin()
        
        Specify a point defining the origin of the plane. Used in
        conjunction with the Point1 and Point2 ivars to specify a map
        plane.
        """
        ...
    
    def GetPoint1(self):
        """
        V.GetPoint1() -> (float, float, float)
        C++: virtual double *GetPoint1()
        
        Specify a point defining the first axis of the plane.
        """
        ...
    
    def GetPoint2(self):
        """
        V.GetPoint2() -> (float, float, float)
        C++: virtual double *GetPoint2()
        
        Specify a point defining the second axis of the plane.
        """
        ...
    
    def GetSRange(self):
        """
        V.GetSRange() -> (float, float)
        C++: virtual double *GetSRange()
        
        Specify s-coordinate range for texture s-t coordinate pair.
        """
        ...
    
    def GetTRange(self):
        """
        V.GetTRange() -> (float, float)
        C++: virtual double *GetTRange()
        
        Specify t-coordinate range for texture s-t coordinate pair.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkTextureMapToPlane
        C++: vtkTextureMapToPlane *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkTextureMapToPlane
        C++: static vtkTextureMapToPlane *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAutomaticPlaneGeneration(self, p_int):
        """
        V.SetAutomaticPlaneGeneration(int)
        C++: virtual void SetAutomaticPlaneGeneration(vtkTypeBool _arg)
        
        Turn on/off automatic plane generation.
        """
        ...
    
    def SetNormal(self, p_float, p_float_1, p_float_2):
        """
        V.SetNormal(float, float, float)
        C++: virtual void SetNormal(double _arg1, double _arg2,
            double _arg3)
        V.SetNormal((float, float, float))
        C++: virtual void SetNormal(const double _arg[3])
        
        Specify plane normal. An alternative way to specify a map plane.
        Using this method, the object will scale the resulting texture
        coordinate between the SRange and TRange specified.
        """
        ...
    
    def SetOrigin(self, p_float, p_float_1, p_float_2):
        """
        V.SetOrigin(float, float, float)
        C++: virtual void SetOrigin(double _arg1, double _arg2,
            double _arg3)
        V.SetOrigin((float, float, float))
        C++: virtual void SetOrigin(const double _arg[3])
        
        Specify a point defining the origin of the plane. Used in
        conjunction with the Point1 and Point2 ivars to specify a map
        plane.
        """
        ...
    
    def SetPoint1(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint1(float, float, float)
        C++: virtual void SetPoint1(double _arg1, double _arg2,
            double _arg3)
        V.SetPoint1((float, float, float))
        C++: virtual void SetPoint1(const double _arg[3])
        
        Specify a point defining the first axis of the plane.
        """
        ...
    
    def SetPoint2(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint2(float, float, float)
        C++: virtual void SetPoint2(double _arg1, double _arg2,
            double _arg3)
        V.SetPoint2((float, float, float))
        C++: virtual void SetPoint2(const double _arg[3])
        
        Specify a point defining the second axis of the plane.
        """
        ...
    
    def SetSRange(self, p_float, p_float_1):
        """
        V.SetSRange(float, float)
        C++: virtual void SetSRange(double _arg1, double _arg2)
        V.SetSRange((float, float))
        C++: void SetSRange(const double _arg[2])
        
        Specify s-coordinate range for texture s-t coordinate pair.
        """
        ...
    
    def SetTRange(self, p_float, p_float_1):
        """
        V.SetTRange(float, float)
        C++: virtual void SetTRange(double _arg1, double _arg2)
        V.SetTRange((float, float))
        C++: void SetTRange(const double _arg[2])
        
        Specify t-coordinate range for texture s-t coordinate pair.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkTextureMapToSphere(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkTextureMapToSphere - generate texture coordinates by mapping
    points to sphere
    
    Superclass: vtkDataSetAlgorithm
    
    vtkTextureMapToSphere is a filter that generates 2D texture
    coordinates by mapping input dataset points onto a sphere. The sphere
    can either be user specified or generated automatically. (The sphere
    is generated automatically by computing the center (i.e., averaged
    coordinates) of the sphere.)  Note that the generated texture
    coordinates range between (0,1). The s-coordinate lies in the angular
    direction around the z-axis, measured counter-clockwise from the
    x-axis. The t-coordinate lies in the angular direction measured down
    from the north pole towards the south pole.
    
    A special ivar controls how the s-coordinate is generated. If
    PreventSeam is set to true, the s-texture varies from 0->1 and then
    1->0 (corresponding to angles of 0->180 and 180->360).
    
    @warning
    The resulting texture coordinates will lie between (0,1), and the
    texture coordinates are determined with respect to the modeler's
    x-y-z coordinate system. Use the class vtkTransformTextureCoords to
    linearly scale and shift the origin of the texture coordinates (if
    necessary).
    
    @sa
    vtkTextureMapToPlane vtkTextureMapToCylinder vtkTransformTexture
    vtkThresholdTextureCoords
    """
    def AutomaticSphereGenerationOff(self):
        """
        V.AutomaticSphereGenerationOff()
        C++: virtual void AutomaticSphereGenerationOff()
        
        Turn on/off automatic sphere generation. This means it
        automatically finds the sphere center.
        """
        ...
    
    def AutomaticSphereGenerationOn(self):
        """
        V.AutomaticSphereGenerationOn()
        C++: virtual void AutomaticSphereGenerationOn()
        
        Turn on/off automatic sphere generation. This means it
        automatically finds the sphere center.
        """
        ...
    
    def ComputeCenter(self, vtkDataSet):
        """
        V.ComputeCenter(vtkDataSet)
        C++: virtual void ComputeCenter(vtkDataSet *input)
        """
        ...
    
    def GetAutomaticSphereGeneration(self):
        """
        V.GetAutomaticSphereGeneration() -> int
        C++: virtual vtkTypeBool GetAutomaticSphereGeneration()
        
        Turn on/off automatic sphere generation. This means it
        automatically finds the sphere center.
        """
        ...
    
    def GetCenter(self):
        """
        V.GetCenter() -> (float, float, float)
        C++: virtual double *GetCenter()
        
        Specify a point defining the center of the sphere.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetPreventSeam(self):
        """
        V.GetPreventSeam() -> int
        C++: virtual vtkTypeBool GetPreventSeam()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the theta angle variation between 0->180 and 180->0 degrees.
        Otherwise, the s-coordinate ranges from 0->1 between 0->360
        degrees.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkTextureMapToSphere
        C++: vtkTextureMapToSphere *NewInstance()
        """
        ...
    
    def PreventSeamOff(self):
        """
        V.PreventSeamOff()
        C++: virtual void PreventSeamOff()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the theta angle variation between 0->180 and 180->0 degrees.
        Otherwise, the s-coordinate ranges from 0->1 between 0->360
        degrees.
        """
        ...
    
    def PreventSeamOn(self):
        """
        V.PreventSeamOn()
        C++: virtual void PreventSeamOn()
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the theta angle variation between 0->180 and 180->0 degrees.
        Otherwise, the s-coordinate ranges from 0->1 between 0->360
        degrees.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkTextureMapToSphere
        C++: static vtkTextureMapToSphere *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAutomaticSphereGeneration(self, p_int):
        """
        V.SetAutomaticSphereGeneration(int)
        C++: virtual void SetAutomaticSphereGeneration(vtkTypeBool _arg)
        
        Turn on/off automatic sphere generation. This means it
        automatically finds the sphere center.
        """
        ...
    
    def SetCenter(self, p_float, p_float_1, p_float_2):
        """
        V.SetCenter(float, float, float)
        C++: virtual void SetCenter(double _arg1, double _arg2,
            double _arg3)
        V.SetCenter((float, float, float))
        C++: virtual void SetCenter(const double _arg[3])
        
        Specify a point defining the center of the sphere.
        """
        ...
    
    def SetPreventSeam(self, p_int):
        """
        V.SetPreventSeam(int)
        C++: virtual void SetPreventSeam(vtkTypeBool _arg)
        
        Control how the texture coordinates are generated. If PreventSeam
        is set, the s-coordinate ranges from 0->1 and 1->0 corresponding
        to the theta angle variation between 0->180 and 180->0 degrees.
        Otherwise, the s-coordinate ranges from 0->1 between 0->360
        degrees.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkThresholdTextureCoords(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkThresholdTextureCoords - compute 1D, 2D, or 3D texture coordinates
    based on scalar threshold
    
    Superclass: vtkDataSetAlgorithm
    
    vtkThresholdTextureCoords is a filter that generates texture
    coordinates for any input dataset type given a threshold criterion.
    The criterion can take three forms: 1) greater than a particular
    value (ThresholdByUpper());
    2) less than a particular value (ThresholdByLower(); or 3) between
       two values (ThresholdBetween(). If the threshold criterion is
       satisfied, the "in" texture coordinate will be set (this can be
       specified by the user). If the threshold criterion is not
       satisfied the "out" is set.
    
    @warning
    There is a texture map - texThres.vtk - that can be used in
    conjunction with this filter. This map defines a "transparent" region
    for texture coordinates 0<=r<0.5, and an opaque full intensity map
    for texture coordinates 0.5<r<=1.0. There is a small transition
    region for r=0.5.
    
    @sa
    vtkThreshold vtkThresholdPoints vtkTextureMapToPlane
    vtkTextureMapToSphere vtkTextureMapToCylinder
    """
    def GetInTextureCoord(self):
        """
        V.GetInTextureCoord() -> (float, float, float)
        C++: virtual double *GetInTextureCoord()
        
        Set the texture coordinate value for point satisfying threshold
        criterion.
        """
        ...
    
    def GetLowerThreshold(self):
        """
        V.GetLowerThreshold() -> float
        C++: virtual double GetLowerThreshold()
        
        Return the upper and lower thresholds.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetOutTextureCoord(self):
        """
        V.GetOutTextureCoord() -> (float, float, float)
        C++: virtual double *GetOutTextureCoord()
        
        Set the texture coordinate value for point NOT satisfying
        threshold criterion.
        """
        ...
    
    def GetTextureDimension(self):
        """
        V.GetTextureDimension() -> int
        C++: virtual int GetTextureDimension()
        
        Set the desired dimension of the texture map.
        """
        ...
    
    def GetTextureDimensionMaxValue(self):
        """
        V.GetTextureDimensionMaxValue() -> int
        C++: virtual int GetTextureDimensionMaxValue()
        
        Set the desired dimension of the texture map.
        """
        ...
    
    def GetTextureDimensionMinValue(self):
        """
        V.GetTextureDimensionMinValue() -> int
        C++: virtual int GetTextureDimensionMinValue()
        
        Set the desired dimension of the texture map.
        """
        ...
    
    def GetUpperThreshold(self):
        """
        V.GetUpperThreshold() -> float
        C++: virtual double GetUpperThreshold()
        
        Return the upper and lower thresholds.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkThresholdTextureCoords
        C++: vtkThresholdTextureCoords *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkThresholdTextureCoords
        C++: static vtkThresholdTextureCoords *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetInTextureCoord(self, p_float, p_float_1, p_float_2):
        """
        V.SetInTextureCoord(float, float, float)
        C++: virtual void SetInTextureCoord(double _arg1, double _arg2,
            double _arg3)
        V.SetInTextureCoord((float, float, float))
        C++: virtual void SetInTextureCoord(const double _arg[3])
        
        Set the texture coordinate value for point satisfying threshold
        criterion.
        """
        ...
    
    def SetOutTextureCoord(self, p_float, p_float_1, p_float_2):
        """
        V.SetOutTextureCoord(float, float, float)
        C++: virtual void SetOutTextureCoord(double _arg1, double _arg2,
            double _arg3)
        V.SetOutTextureCoord((float, float, float))
        C++: virtual void SetOutTextureCoord(const double _arg[3])
        
        Set the texture coordinate value for point NOT satisfying
        threshold criterion.
        """
        ...
    
    def SetTextureDimension(self, p_int):
        """
        V.SetTextureDimension(int)
        C++: virtual void SetTextureDimension(int _arg)
        
        Set the desired dimension of the texture map.
        """
        ...
    
    def ThresholdBetween(self, p_float, p_float_1):
        """
        V.ThresholdBetween(float, float)
        C++: void ThresholdBetween(double lower, double upper)
        
        Criterion is cells whose scalars are between lower and upper
        thresholds.
        """
        ...
    
    def ThresholdByLower(self, p_float):
        """
        V.ThresholdByLower(float)
        C++: void ThresholdByLower(double lower)
        
        Criterion is cells whose scalars are less than lower threshold.
        """
        ...
    
    def ThresholdByUpper(self, p_float):
        """
        V.ThresholdByUpper(float)
        C++: void ThresholdByUpper(double upper)
        
        Criterion is cells whose scalars are less than upper threshold.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkTransformTextureCoords(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkTransformTextureCoords - transform (scale, rotate, translate)
    texture coordinates
    
    Superclass: vtkDataSetAlgorithm
    
    vtkTransformTextureCoords is a filter that operates on texture
    coordinates. It ingests any type of dataset, and outputs a dataset of
    the same type. The filter lets you scale, translate, and rotate
    texture coordinates. For example, by using the Scale ivar, you can
    shift texture coordinates that range from (0->1) to range from
    (0->10) (useful for repeated patterns).
    
    The filter operates on texture coordinates of dimension 1->3. The
    texture coordinates are referred to as r-s-t. If the texture map is
    two dimensional, the t-coordinate (and operations on the
    t-coordinate) are ignored.
    
    @sa
    vtkTextureMapToPlane  vtkTextureMapToCylinder vtkTextureMapToSphere
    vtkThresholdTextureCoords vtkTexture
    """
    def AddPosition(self, p_float, p_float_1, p_float_2):
        """
        V.AddPosition(float, float, float)
        C++: void AddPosition(double deltaR, double deltaS, double deltaT)
        V.AddPosition([float, float, float])
        C++: void AddPosition(double deltaPosition[3])
        
        Incrementally change the position of the texture map (i.e., does
        a translate or shift of the texture coordinates).
        """
        ...
    
    def FlipROff(self):
        """
        V.FlipROff()
        C++: virtual void FlipROff()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def FlipROn(self):
        """
        V.FlipROn()
        C++: virtual void FlipROn()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def FlipSOff(self):
        """
        V.FlipSOff()
        C++: virtual void FlipSOff()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def FlipSOn(self):
        """
        V.FlipSOn()
        C++: virtual void FlipSOn()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def FlipTOff(self):
        """
        V.FlipTOff()
        C++: virtual void FlipTOff()
        
        Boolean indicates whether the texture map should be flipped
        around the t-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def FlipTOn(self):
        """
        V.FlipTOn()
        C++: virtual void FlipTOn()
        
        Boolean indicates whether the texture map should be flipped
        around the t-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def GetFlipR(self):
        """
        V.GetFlipR() -> int
        C++: virtual vtkTypeBool GetFlipR()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def GetFlipS(self):
        """
        V.GetFlipS() -> int
        C++: virtual vtkTypeBool GetFlipS()
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def GetFlipT(self):
        """
        V.GetFlipT() -> int
        C++: virtual vtkTypeBool GetFlipT()
        
        Boolean indicates whether the texture map should be flipped
        around the t-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetOrigin(self):
        """
        V.GetOrigin() -> (float, float, float)
        C++: virtual double *GetOrigin()
        
        Set/Get the origin of the texture map. This is the point about
        which the texture map is flipped (e.g., rotated). Since a typical
        texture map ranges from (0,1) in the r-s-t coordinates, the
        default origin is set at (0.5,0.5,0.5).
        """
        ...
    
    def GetPosition(self):
        """
        V.GetPosition() -> (float, float, float)
        C++: virtual double *GetPosition()
        
        Set/Get the position of the texture map. Setting the position
        translates the texture map by the amount specified.
        """
        ...
    
    def GetScale(self):
        """
        V.GetScale() -> (float, float, float)
        C++: virtual double *GetScale()
        
        Set/Get the scale of the texture map. Scaling in performed
        independently on the r, s and t axes.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkTransformTextureCoords
        C++: vtkTransformTextureCoords *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkTransformTextureCoords
        C++: static vtkTransformTextureCoords *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetFlipR(self, p_int):
        """
        V.SetFlipR(int)
        C++: virtual void SetFlipR(vtkTypeBool _arg)
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def SetFlipS(self, p_int):
        """
        V.SetFlipS(int)
        C++: virtual void SetFlipS(vtkTypeBool _arg)
        
        Boolean indicates whether the texture map should be flipped
        around the s-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def SetFlipT(self, p_int):
        """
        V.SetFlipT(int)
        C++: virtual void SetFlipT(vtkTypeBool _arg)
        
        Boolean indicates whether the texture map should be flipped
        around the t-axis. Note that the flips occur around the texture
        origin.
        """
        ...
    
    def SetOrigin(self, p_float, p_float_1, p_float_2):
        """
        V.SetOrigin(float, float, float)
        C++: virtual void SetOrigin(double _arg1, double _arg2,
            double _arg3)
        V.SetOrigin((float, float, float))
        C++: virtual void SetOrigin(const double _arg[3])
        
        Set/Get the origin of the texture map. This is the point about
        which the texture map is flipped (e.g., rotated). Since a typical
        texture map ranges from (0,1) in the r-s-t coordinates, the
        default origin is set at (0.5,0.5,0.5).
        """
        ...
    
    def SetPosition(self, p_float, p_float_1, p_float_2):
        """
        V.SetPosition(float, float, float)
        C++: virtual void SetPosition(double _arg1, double _arg2,
            double _arg3)
        V.SetPosition((float, float, float))
        C++: virtual void SetPosition(const double _arg[3])
        
        Set/Get the position of the texture map. Setting the position
        translates the texture map by the amount specified.
        """
        ...
    
    def SetScale(self, p_float, p_float_1, p_float_2):
        """
        V.SetScale(float, float, float)
        C++: virtual void SetScale(double _arg1, double _arg2,
            double _arg3)
        V.SetScale((float, float, float))
        C++: virtual void SetScale(const double _arg[3])
        
        Set/Get the scale of the texture map. Scaling in performed
        independently on the r, s and t axes.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkTriangularTCoords(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkTriangularTCoords - 2D texture coordinates based for triangles.
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkTriangularTCoords is a filter that generates texture coordinates
    for triangles. Texture coordinates for each triangle are: (0,0),
    (1,0) and (.5,sqrt(3)/2). This filter assumes that the triangle
    texture map is symmetric about the center of the triangle. Thus the
    order Of the texture coordinates is not important. The procedural
    texture in vtkTriangularTexture is designed with this symmetry. For
    more information see the paper "Opacity-modulating Triangular
    Textures for Irregular Surfaces,"  by Penny Rheingans, IEEE
    Visualization '96, pp. 219-225.
    @sa
    vtkTriangularTexture vtkThresholdPoints vtkTextureMapToPlane
    vtkTextureMapToSphere vtkTextureMapToCylinder
    """
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkTriangularTCoords
        C++: vtkTriangularTCoords *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkTriangularTCoords
        C++: static vtkTriangularTCoords *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


__loader__ = ...
__spec__ = ...
