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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkRuledSurfaceFilter(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkRuledSurfaceFilter - generates a surface from a set of lines
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkRuledSurfaceFilter is a filter that generates a surface from a set
    of lines. The lines are assumed to be "parallel" in the sense that
    they do not intersect and remain somewhat close to one another. A
    surface is generated by connecting the points defining each pair of
    lines with straight lines. This creates a strip for each pair of
    lines (i.e., a triangulation is created from two generating lines).
    The filter can handle an arbitrary number of lines, with lines i and
    i+1 assumed connected. Note that there are several different
    approaches for creating the ruled surface, the method for creating
    the surface can either use the input points or resample from the
    polylines (using a user-specified resolution).
    
    This filter offers some other important features. A DistanceFactor
    ivar is used to decide when two lines are too far apart to connect.
    (The factor is a multiple of the distance between the first two
    points of the two lines defining the strip.) If the distance between
    the two generating lines becomes too great, then the surface is not
    generated in that region. (Note: if the lines separate and then
    merge, then a hole can be generated in the surface.) In addition, the
    Offset and OnRation ivars can be used to create nifty striped
    surfaces. Closed surfaces (e.g., tubes) can be created by setting the
    CloseSurface ivar. (The surface can be closed in the other direction
    by repeating the first and last point in the polylines defining the
    surface.)
    
    An important use of this filter is to combine it with vtkStreamTracer
    to generate stream surfaces. It can also be used to create surfaces
    from contours.
    
    @warning
    The number of lines must be greater than two if a surface is to be
    generated.  sides (i.e., a ribbon), use vtkRibbonFilter.
    
    @sa
    vtkRibbonFilter vtkStreamTracer
    """
    def CloseSurfaceOff(self):
        """
        V.CloseSurfaceOff()
        C++: virtual void CloseSurfaceOff()
        
        Indicate whether the surface is to be closed. If this boolean is
        on, then the first and last polyline are used to generate a
        stripe that closes the surface. (Note: to close the surface in
        the other direction, repeat the first point in the polyline as
        the last point in the polyline.)
        """
        ...
    
    def CloseSurfaceOn(self):
        """
        V.CloseSurfaceOn()
        C++: virtual void CloseSurfaceOn()
        
        Indicate whether the surface is to be closed. If this boolean is
        on, then the first and last polyline are used to generate a
        stripe that closes the surface. (Note: to close the surface in
        the other direction, repeat the first point in the polyline as
        the last point in the polyline.)
        """
        ...
    
    def GetCloseSurface(self):
        """
        V.GetCloseSurface() -> int
        C++: virtual vtkTypeBool GetCloseSurface()
        
        Indicate whether the surface is to be closed. If this boolean is
        on, then the first and last polyline are used to generate a
        stripe that closes the surface. (Note: to close the surface in
        the other direction, repeat the first point in the polyline as
        the last point in the polyline.)
        """
        ...
    
    def GetDistanceFactor(self):
        """
        V.GetDistanceFactor() -> float
        C++: virtual double GetDistanceFactor()
        
        Set/Get the factor that controls tearing of the surface.
        """
        ...
    
    def GetDistanceFactorMaxValue(self):
        """
        V.GetDistanceFactorMaxValue() -> float
        C++: virtual double GetDistanceFactorMaxValue()
        
        Set/Get the factor that controls tearing of the surface.
        """
        ...
    
    def GetDistanceFactorMinValue(self):
        """
        V.GetDistanceFactorMinValue() -> float
        C++: virtual double GetDistanceFactorMinValue()
        
        Set/Get the factor that controls tearing of the surface.
        """
        ...
    
    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 GetOffset(self):
        """
        V.GetOffset() -> int
        C++: virtual int GetOffset()
        
        Control the striping of the ruled surface. The offset sets the
        first stripe that is visible. Offset is generally used with
        OnRatio to create nifty striping effects.
        """
        ...
    
    def GetOffsetMaxValue(self):
        """
        V.GetOffsetMaxValue() -> int
        C++: virtual int GetOffsetMaxValue()
        
        Control the striping of the ruled surface. The offset sets the
        first stripe that is visible. Offset is generally used with
        OnRatio to create nifty striping effects.
        """
        ...
    
    def GetOffsetMinValue(self):
        """
        V.GetOffsetMinValue() -> int
        C++: virtual int GetOffsetMinValue()
        
        Control the striping of the ruled surface. The offset sets the
        first stripe that is visible. Offset is generally used with
        OnRatio to create nifty striping effects.
        """
        ...
    
    def GetOnRatio(self):
        """
        V.GetOnRatio() -> int
        C++: virtual int GetOnRatio()
        
        Control the striping of the ruled surface. If OnRatio is greater
        than 1, then every nth strip is turned on, beginning with the
        Offset strip.
        """
        ...
    
    def GetOnRatioMaxValue(self):
        """
        V.GetOnRatioMaxValue() -> int
        C++: virtual int GetOnRatioMaxValue()
        
        Control the striping of the ruled surface. If OnRatio is greater
        than 1, then every nth strip is turned on, beginning with the
        Offset strip.
        """
        ...
    
    def GetOnRatioMinValue(self):
        """
        V.GetOnRatioMinValue() -> int
        C++: virtual int GetOnRatioMinValue()
        
        Control the striping of the ruled surface. If OnRatio is greater
        than 1, then every nth strip is turned on, beginning with the
        Offset strip.
        """
        ...
    
    def GetOrientLoops(self):
        """
        V.GetOrientLoops() -> int
        C++: virtual vtkTypeBool GetOrientLoops()
        
        Indicate whether the starting points of the loops need to be
        determined. If set to 0, then its assumes that the 0th point of
        each loop should be always connected By default the loops are not
        oriented.
        """
        ...
    
    def GetPassLines(self):
        """
        V.GetPassLines() -> int
        C++: virtual vtkTypeBool GetPassLines()
        
        Indicate whether the generating lines are to be passed to the
        output. By default lines are not passed to the output.
        """
        ...
    
    def GetResolution(self):
        """
        V.GetResolution() -> (int, int)
        C++: virtual int *GetResolution()
        
        If the ruled surface generation mode is RESAMPLE, then these
        parameters are used to determine the resample rate. Resolution[0]
        defines the resolution in the direction of the polylines;
        Resolution[1] defines the resolution across the polylines (i.e.,
        direction orthogonal to Resolution[0]).
        """
        ...
    
    def GetRuledMode(self):
        """
        V.GetRuledMode() -> int
        C++: virtual int GetRuledMode()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    def GetRuledModeAsString(self):
        """
        V.GetRuledModeAsString() -> string
        C++: const char *GetRuledModeAsString()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    def GetRuledModeMaxValue(self):
        """
        V.GetRuledModeMaxValue() -> int
        C++: virtual int GetRuledModeMaxValue()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    def GetRuledModeMinValue(self):
        """
        V.GetRuledModeMinValue() -> int
        C++: virtual int GetRuledModeMinValue()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    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() -> vtkRuledSurfaceFilter
        C++: vtkRuledSurfaceFilter *NewInstance()
        """
        ...
    
    def OrientLoopsOff(self):
        """
        V.OrientLoopsOff()
        C++: virtual void OrientLoopsOff()
        
        Indicate whether the starting points of the loops need to be
        determined. If set to 0, then its assumes that the 0th point of
        each loop should be always connected By default the loops are not
        oriented.
        """
        ...
    
    def OrientLoopsOn(self):
        """
        V.OrientLoopsOn()
        C++: virtual void OrientLoopsOn()
        
        Indicate whether the starting points of the loops need to be
        determined. If set to 0, then its assumes that the 0th point of
        each loop should be always connected By default the loops are not
        oriented.
        """
        ...
    
    def PassLinesOff(self):
        """
        V.PassLinesOff()
        C++: virtual void PassLinesOff()
        
        Indicate whether the generating lines are to be passed to the
        output. By default lines are not passed to the output.
        """
        ...
    
    def PassLinesOn(self):
        """
        V.PassLinesOn()
        C++: virtual void PassLinesOn()
        
        Indicate whether the generating lines are to be passed to the
        output. By default lines are not passed to the output.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkRuledSurfaceFilter
        C++: static vtkRuledSurfaceFilter *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetCloseSurface(self, p_int):
        """
        V.SetCloseSurface(int)
        C++: virtual void SetCloseSurface(vtkTypeBool _arg)
        
        Indicate whether the surface is to be closed. If this boolean is
        on, then the first and last polyline are used to generate a
        stripe that closes the surface. (Note: to close the surface in
        the other direction, repeat the first point in the polyline as
        the last point in the polyline.)
        """
        ...
    
    def SetDistanceFactor(self, p_float):
        """
        V.SetDistanceFactor(float)
        C++: virtual void SetDistanceFactor(double _arg)
        
        Set/Get the factor that controls tearing of the surface.
        """
        ...
    
    def SetOffset(self, p_int):
        """
        V.SetOffset(int)
        C++: virtual void SetOffset(int _arg)
        
        Control the striping of the ruled surface. The offset sets the
        first stripe that is visible. Offset is generally used with
        OnRatio to create nifty striping effects.
        """
        ...
    
    def SetOnRatio(self, p_int):
        """
        V.SetOnRatio(int)
        C++: virtual void SetOnRatio(int _arg)
        
        Control the striping of the ruled surface. If OnRatio is greater
        than 1, then every nth strip is turned on, beginning with the
        Offset strip.
        """
        ...
    
    def SetOrientLoops(self, p_int):
        """
        V.SetOrientLoops(int)
        C++: virtual void SetOrientLoops(vtkTypeBool _arg)
        
        Indicate whether the starting points of the loops need to be
        determined. If set to 0, then its assumes that the 0th point of
        each loop should be always connected By default the loops are not
        oriented.
        """
        ...
    
    def SetPassLines(self, p_int):
        """
        V.SetPassLines(int)
        C++: virtual void SetPassLines(vtkTypeBool _arg)
        
        Indicate whether the generating lines are to be passed to the
        output. By default lines are not passed to the output.
        """
        ...
    
    def SetResolution(self, p_int, p_int_1):
        """
        V.SetResolution(int, int)
        C++: virtual void SetResolution(int _arg1, int _arg2)
        V.SetResolution((int, int))
        C++: void SetResolution(const int _arg[2])
        
        If the ruled surface generation mode is RESAMPLE, then these
        parameters are used to determine the resample rate. Resolution[0]
        defines the resolution in the direction of the polylines;
        Resolution[1] defines the resolution across the polylines (i.e.,
        direction orthogonal to Resolution[0]).
        """
        ...
    
    def SetRuledMode(self, p_int):
        """
        V.SetRuledMode(int)
        C++: virtual void SetRuledMode(int _arg)
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    def SetRuledModeToPointWalk(self):
        """
        V.SetRuledModeToPointWalk()
        C++: void SetRuledModeToPointWalk()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    def SetRuledModeToResample(self):
        """
        V.SetRuledModeToResample()
        C++: void SetRuledModeToResample()
        
        Set the mode by which to create the ruled surface. (Dramatically
        different results are possible depending on the chosen mode.) The
        resample mode evenly resamples the polylines (based on length)
        and generates triangle strips. The point walk mode uses the
        existing points and walks around the polyline using existing
        points.
        """
        ...
    
    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__ = ...


