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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkLineSource(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkLineSource - create a line defined by two end points
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkLineSource is a source object that creates a polyline defined by
    two endpoints or a collection of connected line segments. To define
    the line by end points, use `SetPoint1` and `SetPoint2` methods. To
    define a broken line comprising of multiple line segments, use
    `SetPoints` to provide the corner points that for the line.
    
    Intermediate points within line segment (when specifying end points
    alone) or each of the individual line segments (when specifying
    broken line) can be specified in two ways. First, when
    `UseRegularRefinement` is true (default), the `Resolution` is used to
    determine how many intermediate points to add using regular
    refinement. Thus, if `Resolution` is set to 1, a mid point will be
    added for each of the line segments resulting in a line with 3
    points: the two end points and the mid point. Second, when
    `UseRegularRefinement` is false, refinement ratios for points per
    segment are specified using `SetRefinementRatio` and
    `SetNumberOfRefinementRatios`. To generate same points as
    `Resolution` set to 1, the refinement ratios will be `[0, 0.5, 1.0]`.
    To add the end points of the line segment `0.0` and `1.0` must be
    included in the collection of refinement ratios.
    
    @section ChangesVTK9 Changes in VTK 9.0
    
    Prior to VTK 9.0, when broken line was being generated, the texture
    coordinates for each of the individual breaks in the line ranged from
    [0.0, 1.0]. This has been changed to generate texture coordinates in
    the range [0.0, 1.0] over the entire output line irrespective of
    whether the line was generated by simply specifying the end points or
    multiple line segments.
    
    @par Thanks: This class was extended by Philippe Pebay, Kitware SAS
    2011, to support broken lines as well as simple lines.
    """
    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 GetNumberOfRefinementRatios(self):
        """
        V.GetNumberOfRefinementRatios() -> int
        C++: int GetNumberOfRefinementRatios()
        
        API for setting/getting refinement ratios for points added to the
        line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
        the start of the line segment and 1.0 is the end. When generating
        broken lines i.e. using `SetPoints`, this specifies refinement
        points for each of the individual line segment. Note that `0.0`
        and `1.0` must be explicitly included to generate a point and the
        start and/or end of the line segment. This is used only when
        `UseRegularRefinement` is false.
        """
        ...
    
    def GetOutputPointsPrecision(self):
        """
        V.GetOutputPointsPrecision() -> int
        C++: virtual int GetOutputPointsPrecision()
        
        Set/get the desired precision for the output points.
        vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
        point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
        floating point.
        """
        ...
    
    def GetPoint1(self):
        """
        V.GetPoint1() -> (float, float, float)
        C++: virtual double *GetPoint1()
        
        Set position of first end point.
        """
        ...
    
    def GetPoint2(self):
        """
        V.GetPoint2() -> (float, float, float)
        C++: virtual double *GetPoint2()
        
        Set position of other end point.
        """
        ...
    
    def GetPoints(self):
        """
        V.GetPoints() -> vtkPoints
        C++: virtual vtkPoints *GetPoints()
        
        Set/Get the list of points defining a broken line
        """
        ...
    
    def GetRefinementRatio(self, p_int):
        """
        V.GetRefinementRatio(int) -> float
        C++: double GetRefinementRatio(int index)
        
        API for setting/getting refinement ratios for points added to the
        line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
        the start of the line segment and 1.0 is the end. When generating
        broken lines i.e. using `SetPoints`, this specifies refinement
        points for each of the individual line segment. Note that `0.0`
        and `1.0` must be explicitly included to generate a point and the
        start and/or end of the line segment. This is used only when
        `UseRegularRefinement` is false.
        """
        ...
    
    def GetResolution(self):
        """
        V.GetResolution() -> int
        C++: virtual int GetResolution()
        
        Divide line into Resolution number of pieces. This is used when
        `UseRegularRefinement` is true.
        """
        ...
    
    def GetResolutionMaxValue(self):
        """
        V.GetResolutionMaxValue() -> int
        C++: virtual int GetResolutionMaxValue()
        
        Divide line into Resolution number of pieces. This is used when
        `UseRegularRefinement` is true.
        """
        ...
    
    def GetResolutionMinValue(self):
        """
        V.GetResolutionMinValue() -> int
        C++: virtual int GetResolutionMinValue()
        
        Divide line into Resolution number of pieces. This is used when
        `UseRegularRefinement` is true.
        """
        ...
    
    def GetUseRegularRefinement(self):
        """
        V.GetUseRegularRefinement() -> bool
        C++: virtual bool GetUseRegularRefinement()
        
        Set/Get how the line segment is to be refined. One can choose to
        add points at regular intervals per segment (defined using
        `Resolution`) or explicit locations (defined using
        `SetRefinementRatio`). Default is true i.e `Resolution` will be
        used to determine placement of points within each line segment.
        """
        ...
    
    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() -> vtkLineSource
        C++: vtkLineSource *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkLineSource
        C++: static vtkLineSource *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetNumberOfRefinementRatios(self, p_int):
        """
        V.SetNumberOfRefinementRatios(int)
        C++: void SetNumberOfRefinementRatios(int)
        
        API for setting/getting refinement ratios for points added to the
        line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
        the start of the line segment and 1.0 is the end. When generating
        broken lines i.e. using `SetPoints`, this specifies refinement
        points for each of the individual line segment. Note that `0.0`
        and `1.0` must be explicitly included to generate a point and the
        start and/or end of the line segment. This is used only when
        `UseRegularRefinement` is false.
        """
        ...
    
    def SetOutputPointsPrecision(self, p_int):
        """
        V.SetOutputPointsPrecision(int)
        C++: virtual void SetOutputPointsPrecision(int _arg)
        
        Set/get the desired precision for the output points.
        vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
        point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
        floating point.
        """
        ...
    
    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])
        
        Set position of first end point.
        """
        ...
    
    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])
        
        Set position of other end point.
        """
        ...
    
    def SetPoints(self, vtkPoints):
        """
        V.SetPoints(vtkPoints)
        C++: virtual void SetPoints(vtkPoints *)
        
        Set/Get the list of points defining a broken line
        """
        ...
    
    def SetRefinementRatio(self, p_int, p_float):
        """
        V.SetRefinementRatio(int, float)
        C++: void SetRefinementRatio(int index, double value)
        
        API for setting/getting refinement ratios for points added to the
        line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
        the start of the line segment and 1.0 is the end. When generating
        broken lines i.e. using `SetPoints`, this specifies refinement
        points for each of the individual line segment. Note that `0.0`
        and `1.0` must be explicitly included to generate a point and the
        start and/or end of the line segment. This is used only when
        `UseRegularRefinement` is false.
        """
        ...
    
    def SetResolution(self, p_int):
        """
        V.SetResolution(int)
        C++: virtual void SetResolution(int _arg)
        
        Divide line into Resolution number of pieces. This is used when
        `UseRegularRefinement` is true.
        """
        ...
    
    def SetUseRegularRefinement(self, bool):
        """
        V.SetUseRegularRefinement(bool)
        C++: virtual void SetUseRegularRefinement(bool _arg)
        
        Set/Get how the line segment is to be refined. One can choose to
        add points at regular intervals per segment (defined using
        `Resolution`) or explicit locations (defined using
        `SetRefinementRatio`). Default is true i.e `Resolution` will be
        used to determine placement of points within each line segment.
        """
        ...
    
    def UseRegularRefinementOff(self):
        """
        V.UseRegularRefinementOff()
        C++: virtual void UseRegularRefinementOff()
        
        Set/Get how the line segment is to be refined. One can choose to
        add points at regular intervals per segment (defined using
        `Resolution`) or explicit locations (defined using
        `SetRefinementRatio`). Default is true i.e `Resolution` will be
        used to determine placement of points within each line segment.
        """
        ...
    
    def UseRegularRefinementOn(self):
        """
        V.UseRegularRefinementOn()
        C++: virtual void UseRegularRefinementOn()
        
        Set/Get how the line segment is to be refined. One can choose to
        add points at regular intervals per segment (defined using
        `Resolution`) or explicit locations (defined using
        `SetRefinementRatio`). Default is true i.e `Resolution` will be
        used to determine placement of points within each line segment.
        """
        ...
    
    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__ = ...


