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

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore

class vtkViewport(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkViewport - abstract specification for Viewports
    
    Superclass: vtkObject
    
    vtkViewport provides an abstract specification for Viewports. A
    Viewport is an object that controls the rendering process for
    objects. Rendering is the process of converting geometry, a
    specification for lights, and a camera view into an image.
    vtkViewport also performs coordinate transformation between world
    coordinates, view coordinates (the computer graphics rendering
    coordinate system), and display coordinates (the actual screen
    coordinates on the display device). Certain advanced rendering
    features such as two-sided lighting can also be controlled.
    
    @sa
    vtkWindow vtkRenderer
    """
    def AddActor2D(self, vtkProp):
        """
        V.AddActor2D(vtkProp)
        C++: void AddActor2D(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def AddViewProp(self, vtkProp):
        """
        V.AddViewProp(vtkProp)
        C++: void AddViewProp(vtkProp *)
        
        Add a prop to the list of props. Does nothing if the prop is
        already present. Prop is the superclass of all actors, volumes,
        2D actors, composite props etc.
        """
        ...
    
    def ComputeAspect(self):
        """
        V.ComputeAspect()
        C++: virtual void ComputeAspect()
        
        Set the aspect ratio of the rendered image. This is computed
        automatically and should not be set by the user.
        """
        ...
    
    def DisplayToLocalDisplay(self, p_float, p_float_1):
        """
        V.DisplayToLocalDisplay(float, float)
        C++: virtual void DisplayToLocalDisplay(double &x, double &y)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def DisplayToNormalizedDisplay(self, p_float, p_float_1):
        """
        V.DisplayToNormalizedDisplay(float, float)
        C++: virtual void DisplayToNormalizedDisplay(double &u, double &v)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def DisplayToView(self):
        """
        V.DisplayToView()
        C++: virtual void DisplayToView()
        
        Convert display coordinates to view coordinates.
        """
        ...
    
    def DisplayToWorld(self):
        """
        V.DisplayToWorld()
        C++: void DisplayToWorld()
        
        Convert display (or screen) coordinates to world coordinates.
        """
        ...
    
    def GetActors2D(self):
        """
        V.GetActors2D() -> vtkActor2DCollection
        C++: vtkActor2DCollection *GetActors2D()
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def GetAspect(self):
        """
        V.GetAspect() -> (float, float)
        C++: virtual double *GetAspect()
        
        Set the aspect ratio of the rendered image. This is computed
        automatically and should not be set by the user.
        """
        ...
    
    def GetBackground(self):
        """
        V.GetBackground() -> (float, float, float)
        C++: virtual double *GetBackground()
        
        Set/Get the background color of the rendering screen using an rgb
        color specification.
        """
        ...
    
    def GetBackground2(self):
        """
        V.GetBackground2() -> (float, float, float)
        C++: virtual double *GetBackground2()
        
        Set/Get the second background color of the rendering screen for
        gradient backgrounds using an rgb color specification.
        """
        ...
    
    def GetBackgroundAlpha(self):
        """
        V.GetBackgroundAlpha() -> float
        C++: virtual double GetBackgroundAlpha()
        
        Set/Get the alpha value used to fill the background with. By
        default, this is set to 0.0.
        """
        ...
    
    def GetBackgroundAlphaMaxValue(self):
        """
        V.GetBackgroundAlphaMaxValue() -> float
        C++: virtual double GetBackgroundAlphaMaxValue()
        
        Set/Get the alpha value used to fill the background with. By
        default, this is set to 0.0.
        """
        ...
    
    def GetBackgroundAlphaMinValue(self):
        """
        V.GetBackgroundAlphaMinValue() -> float
        C++: virtual double GetBackgroundAlphaMinValue()
        
        Set/Get the alpha value used to fill the background with. By
        default, this is set to 0.0.
        """
        ...
    
    def GetCenter(self):
        """
        V.GetCenter() -> (float, float)
        C++: virtual double *GetCenter()
        
        Return the center of this viewport in display coordinates.
        """
        ...
    
    def GetDisplayPoint(self):
        """
        V.GetDisplayPoint() -> (float, float, float)
        C++: virtual double *GetDisplayPoint()
        
        Set/get a point location in display (or screen) coordinates. The
        lower left corner of the window is the origin and y increases as
        you go up the screen.
        """
        ...
    
    def GetEnvironmentalBG(self):
        """
        V.GetEnvironmentalBG() -> (float, float, float)
        C++: virtual double *GetEnvironmentalBG()
        
        Set/Get the constant environmental color using an rgb color
        specification. Note this is currently ignored outside of
        RayTracing.
        """
        ...
    
    def GetEnvironmentalBG2(self):
        """
        V.GetEnvironmentalBG2() -> (float, float, float)
        C++: virtual double *GetEnvironmentalBG2()
        
        Set/Get the second environmental gradient color using an rgb
        color specification. Note this is currently ignored outside of
        RayTracing.
        """
        ...
    
    def GetGradientBackground(self):
        """
        V.GetGradientBackground() -> bool
        C++: virtual bool GetGradientBackground()
        
        Set/Get whether this viewport should have a gradient background
        using the Background (bottom) and Background2 (top) colors.
        Default is off.
        """
        ...
    
    def GetGradientEnvironmentalBG(self):
        """
        V.GetGradientEnvironmentalBG() -> bool
        C++: virtual bool GetGradientEnvironmentalBG()
        
        Set/Get whether this viewport should enable the gradient
        environment using the EnvironmentalBG (bottom) and
        EnvironmentalBG2 (top) colors. Note this is currently ignored
        outside of RayTracing. Default is off.
        """
        ...
    
    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() -> (int, int)
        C++: virtual int *GetOrigin()
        
        Get the size and origin of the viewport in display coordinates.
        Note: if the window has not yet been realized, GetSize() and
        GetOrigin() return (0,0).
        """
        ...
    
    def GetPickedZ(self):
        """
        V.GetPickedZ() -> float
        C++: virtual double GetPickedZ()
        
        Return the Z value for the last picked Prop.
        """
        ...
    
    def GetPickHeight(self):
        """
        V.GetPickHeight() -> float
        C++: double GetPickHeight()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickResultProps(self):
        """
        V.GetPickResultProps() -> vtkPropCollection
        C++: virtual vtkPropCollection *GetPickResultProps()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickWidth(self):
        """
        V.GetPickWidth() -> float
        C++: double GetPickWidth()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickX(self):
        """
        V.GetPickX() -> float
        C++: double GetPickX()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickX1(self):
        """
        V.GetPickX1() -> float
        C++: double GetPickX1()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickX2(self):
        """
        V.GetPickX2() -> float
        C++: double GetPickX2()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickY(self):
        """
        V.GetPickY() -> float
        C++: double GetPickY()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickY1(self):
        """
        V.GetPickY1() -> float
        C++: double GetPickY1()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPickY2(self):
        """
        V.GetPickY2() -> float
        C++: double GetPickY2()
        
        Methods used to return the pick (x,y) in local display
        coordinates (i.e., it's that same as selectionX and selectionY).
        """
        ...
    
    def GetPixelAspect(self):
        """
        V.GetPixelAspect() -> (float, float)
        C++: virtual double *GetPixelAspect()
        
        Set the aspect ratio of a pixel in the rendered image. This
        factor permits the image to rendered anisotropically (i.e.,
        stretched in one direction or the other).
        """
        ...
    
    def GetSize(self):
        """
        V.GetSize() -> (int, int)
        C++: virtual int *GetSize()
        
        Get the size and origin of the viewport in display coordinates.
        Note: if the window has not yet been realized, GetSize() and
        GetOrigin() return (0,0).
        """
        ...
    
    def GetTiledSize(self, *int, **kwargs):
        """
        V.GetTiledSize([int, ...], [int, ...])
        C++: void GetTiledSize(int *width, int *height)
        
        Get the size and origin of the viewport in display coordinates.
        Note: if the window has not yet been realized, GetSize() and
        GetOrigin() return (0,0).
        """
        ...
    
    def GetTiledSizeAndOrigin(self, *int, **kwargs):
        """
        V.GetTiledSizeAndOrigin([int, ...], [int, ...], [int, ...], [int,
            ...])
        C++: virtual void GetTiledSizeAndOrigin(int *width, int *height,
            int *lowerLeftX, int *lowerLeftY)
        
        Get the size and origin of the viewport in display coordinates.
        Note: if the window has not yet been realized, GetSize() and
        GetOrigin() return (0,0).
        """
        ...
    
    def GetViewPoint(self):
        """
        V.GetViewPoint() -> (float, float, float)
        C++: virtual double *GetViewPoint()
        
        Specify a point location in view coordinates. The origin is in
        the middle of the viewport and it extends from -1 to 1 in all
        three dimensions.
        """
        ...
    
    def GetViewport(self):
        """
        V.GetViewport() -> (float, float, float, float)
        C++: virtual double *GetViewport()
        
        Specify the viewport for the Viewport to draw in the rendering
        window. Coordinates are expressed as (xmin,ymin,xmax,ymax), where
        each coordinate is 0 <= coordinate <= 1.0.
        """
        ...
    
    def GetViewProps(self):
        """
        V.GetViewProps() -> vtkPropCollection
        C++: vtkPropCollection *GetViewProps()
        
        Return any props in this viewport.
        """
        ...
    
    def GetVTKWindow(self):
        """
        V.GetVTKWindow() -> vtkWindow
        C++: virtual vtkWindow *GetVTKWindow()
        
        Return the vtkWindow that owns this vtkViewport.
        """
        ...
    
    def GetWorldPoint(self):
        """
        V.GetWorldPoint() -> (float, float, float, float)
        C++: virtual double *GetWorldPoint()
        
        Specify a point location in world coordinates. This method takes
        homogeneous coordinates.
        """
        ...
    
    def GradientBackgroundOff(self):
        """
        V.GradientBackgroundOff()
        C++: virtual void GradientBackgroundOff()
        
        Set/Get whether this viewport should have a gradient background
        using the Background (bottom) and Background2 (top) colors.
        Default is off.
        """
        ...
    
    def GradientBackgroundOn(self):
        """
        V.GradientBackgroundOn()
        C++: virtual void GradientBackgroundOn()
        
        Set/Get whether this viewport should have a gradient background
        using the Background (bottom) and Background2 (top) colors.
        Default is off.
        """
        ...
    
    def GradientEnvironmentalBGOff(self):
        """
        V.GradientEnvironmentalBGOff()
        C++: virtual void GradientEnvironmentalBGOff()
        
        Set/Get whether this viewport should enable the gradient
        environment using the EnvironmentalBG (bottom) and
        EnvironmentalBG2 (top) colors. Note this is currently ignored
        outside of RayTracing. Default is off.
        """
        ...
    
    def GradientEnvironmentalBGOn(self):
        """
        V.GradientEnvironmentalBGOn()
        C++: virtual void GradientEnvironmentalBGOn()
        
        Set/Get whether this viewport should enable the gradient
        environment using the EnvironmentalBG (bottom) and
        EnvironmentalBG2 (top) colors. Note this is currently ignored
        outside of RayTracing. Default is off.
        """
        ...
    
    def HasViewProp(self, vtkProp):
        """
        V.HasViewProp(vtkProp) -> int
        C++: int HasViewProp(vtkProp *)
        
        Query if a prop is in the list of props.
        """
        ...
    
    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 IsInViewport(self, p_int, p_int_1):
        """
        V.IsInViewport(int, int) -> int
        C++: virtual int IsInViewport(int x, int y)
        
        Is a given display point in this Viewport's viewport.
        """
        ...
    
    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 LocalDisplayToDisplay(self, p_float, p_float_1):
        """
        V.LocalDisplayToDisplay(float, float)
        C++: virtual void LocalDisplayToDisplay(double &x, double &y)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkViewport
        C++: vtkViewport *NewInstance()
        """
        ...
    
    def NormalizedDisplayToDisplay(self, p_float, p_float_1):
        """
        V.NormalizedDisplayToDisplay(float, float)
        C++: virtual void NormalizedDisplayToDisplay(double &u, double &v)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def NormalizedDisplayToViewport(self, p_float, p_float_1):
        """
        V.NormalizedDisplayToViewport(float, float)
        C++: virtual void NormalizedDisplayToViewport(double &x,
            double &y)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def NormalizedViewportToView(self, p_float, p_float_1, p_float_2):
        """
        V.NormalizedViewportToView(float, float, float)
        C++: virtual void NormalizedViewportToView(double &x, double &y,
            double &z)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def NormalizedViewportToViewport(self, p_float, p_float_1):
        """
        V.NormalizedViewportToViewport(float, float)
        C++: virtual void NormalizedViewportToViewport(double &u,
            double &v)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def PickProp(self, p_float, p_float_1):
        """
        V.PickProp(float, float) -> vtkAssemblyPath
        C++: virtual vtkAssemblyPath *PickProp(double selectionX,
            double selectionY)
        V.PickProp(float, float, float, float) -> vtkAssemblyPath
        C++: virtual vtkAssemblyPath *PickProp(double selectionX1,
            double selectionY1, double selectionX2, double selectionY2)
        
        Return the Prop that has the highest z value at the given x, y
        position in the viewport.  Basically, the top most prop that
        renders the pixel at selectionX, selectionY will be returned.  If
        no Props are there NULL is returned.  This method selects from
        the Viewports Prop list.
        """
        ...
    
    def PickPropFrom(self, p_float, p_float_1, vtkPropCollection):
        """
        V.PickPropFrom(float, float, vtkPropCollection) -> vtkAssemblyPath
        C++: vtkAssemblyPath *PickPropFrom(double selectionX,
            double selectionY, vtkPropCollection *)
        V.PickPropFrom(float, float, float, float, vtkPropCollection)
            -> vtkAssemblyPath
        C++: vtkAssemblyPath *PickPropFrom(double selectionX1,
            double selectionY1, double selectionX2, double selectionY2,
            vtkPropCollection *)
        
        Same as PickProp with two arguments, but selects from the given
        collection of Props instead of the Renderers props.  Make sure
        the Props in the collection are in this renderer.
        """
        ...
    
    def PoseToView(self, p_float, p_float_1, p_float_2):
        """
        V.PoseToView(float, float, float)
        C++: virtual void PoseToView(double &, double &, double &)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def PoseToWorld(self, p_float, p_float_1, p_float_2):
        """
        V.PoseToWorld(float, float, float)
        C++: virtual void PoseToWorld(double &, double &, double &)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def RemoveActor2D(self, vtkProp):
        """
        V.RemoveActor2D(vtkProp)
        C++: void RemoveActor2D(vtkProp *p)
        
        Add/Remove different types of props to the renderer. These
        methods are all synonyms to AddViewProp and RemoveViewProp. They
        are here for convenience and backwards compatibility.
        """
        ...
    
    def RemoveAllViewProps(self):
        """
        V.RemoveAllViewProps()
        C++: void RemoveAllViewProps(void)
        
        Remove all props from the list of props.
        """
        ...
    
    def RemoveViewProp(self, vtkProp):
        """
        V.RemoveViewProp(vtkProp)
        C++: void RemoveViewProp(vtkProp *)
        
        Remove a prop from the list of props. Does nothing if the prop is
        not already present.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkViewport
        C++: static vtkViewport *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAspect(self, p_float, p_float_1):
        """
        V.SetAspect(float, float)
        C++: virtual void SetAspect(double _arg1, double _arg2)
        V.SetAspect((float, float))
        C++: void SetAspect(const double _arg[2])
        
        Set the aspect ratio of the rendered image. This is computed
        automatically and should not be set by the user.
        """
        ...
    
    def SetBackground(self, p_float, p_float_1, p_float_2):
        """
        V.SetBackground(float, float, float)
        C++: virtual void SetBackground(double _arg1, double _arg2,
            double _arg3)
        V.SetBackground((float, float, float))
        C++: virtual void SetBackground(const double _arg[3])
        
        Set/Get the background color of the rendering screen using an rgb
        color specification.
        """
        ...
    
    def SetBackground2(self, p_float, p_float_1, p_float_2):
        """
        V.SetBackground2(float, float, float)
        C++: virtual void SetBackground2(double _arg1, double _arg2,
            double _arg3)
        V.SetBackground2((float, float, float))
        C++: virtual void SetBackground2(const double _arg[3])
        
        Set/Get the second background color of the rendering screen for
        gradient backgrounds using an rgb color specification.
        """
        ...
    
    def SetBackgroundAlpha(self, p_float):
        """
        V.SetBackgroundAlpha(float)
        C++: virtual void SetBackgroundAlpha(double _arg)
        
        Set/Get the alpha value used to fill the background with. By
        default, this is set to 0.0.
        """
        ...
    
    def SetDisplayPoint(self, p_float, p_float_1, p_float_2):
        """
        V.SetDisplayPoint(float, float, float)
        C++: virtual void SetDisplayPoint(double _arg1, double _arg2,
            double _arg3)
        V.SetDisplayPoint((float, float, float))
        C++: virtual void SetDisplayPoint(const double _arg[3])
        
        Set/get a point location in display (or screen) coordinates. The
        lower left corner of the window is the origin and y increases as
        you go up the screen.
        """
        ...
    
    def SetEnvironmentalBG(self, p_float, p_float_1, p_float_2):
        """
        V.SetEnvironmentalBG(float, float, float)
        C++: virtual void SetEnvironmentalBG(double _arg1, double _arg2,
            double _arg3)
        V.SetEnvironmentalBG((float, float, float))
        C++: virtual void SetEnvironmentalBG(const double _arg[3])
        
        Set/Get the constant environmental color using an rgb color
        specification. Note this is currently ignored outside of
        RayTracing.
        """
        ...
    
    def SetEnvironmentalBG2(self, p_float, p_float_1, p_float_2):
        """
        V.SetEnvironmentalBG2(float, float, float)
        C++: virtual void SetEnvironmentalBG2(double _arg1, double _arg2,
            double _arg3)
        V.SetEnvironmentalBG2((float, float, float))
        C++: virtual void SetEnvironmentalBG2(const double _arg[3])
        
        Set/Get the second environmental gradient color using an rgb
        color specification. Note this is currently ignored outside of
        RayTracing.
        """
        ...
    
    def SetGradientBackground(self, bool):
        """
        V.SetGradientBackground(bool)
        C++: virtual void SetGradientBackground(bool _arg)
        
        Set/Get whether this viewport should have a gradient background
        using the Background (bottom) and Background2 (top) colors.
        Default is off.
        """
        ...
    
    def SetGradientEnvironmentalBG(self, bool):
        """
        V.SetGradientEnvironmentalBG(bool)
        C++: virtual void SetGradientEnvironmentalBG(bool _arg)
        
        Set/Get whether this viewport should enable the gradient
        environment using the EnvironmentalBG (bottom) and
        EnvironmentalBG2 (top) colors. Note this is currently ignored
        outside of RayTracing. Default is off.
        """
        ...
    
    def SetPixelAspect(self, p_float, p_float_1):
        """
        V.SetPixelAspect(float, float)
        C++: virtual void SetPixelAspect(double _arg1, double _arg2)
        V.SetPixelAspect((float, float))
        C++: void SetPixelAspect(const double _arg[2])
        
        Set the aspect ratio of a pixel in the rendered image. This
        factor permits the image to rendered anisotropically (i.e.,
        stretched in one direction or the other).
        """
        ...
    
    def SetViewPoint(self, p_float, p_float_1, p_float_2):
        """
        V.SetViewPoint(float, float, float)
        C++: virtual void SetViewPoint(double _arg1, double _arg2,
            double _arg3)
        V.SetViewPoint((float, float, float))
        C++: virtual void SetViewPoint(const double _arg[3])
        
        Specify a point location in view coordinates. The origin is in
        the middle of the viewport and it extends from -1 to 1 in all
        three dimensions.
        """
        ...
    
    def SetViewport(self, p_float, p_float_1, p_float_2, p_float_3):
        """
        V.SetViewport(float, float, float, float)
        C++: virtual void SetViewport(double _arg1, double _arg2,
            double _arg3, double _arg4)
        V.SetViewport((float, float, float, float))
        C++: virtual void SetViewport(const double _arg[4])
        
        Specify the viewport for the Viewport to draw in the rendering
        window. Coordinates are expressed as (xmin,ymin,xmax,ymax), where
        each coordinate is 0 <= coordinate <= 1.0.
        """
        ...
    
    def SetWorldPoint(self, p_float, p_float_1, p_float_2, p_float_3):
        """
        V.SetWorldPoint(float, float, float, float)
        C++: virtual void SetWorldPoint(double _arg1, double _arg2,
            double _arg3, double _arg4)
        V.SetWorldPoint((float, float, float, float))
        C++: virtual void SetWorldPoint(const double _arg[4])
        
        Specify a point location in world coordinates. This method takes
        homogeneous coordinates.
        """
        ...
    
    def ViewportToNormalizedDisplay(self, p_float, p_float_1):
        """
        V.ViewportToNormalizedDisplay(float, float)
        C++: virtual void ViewportToNormalizedDisplay(double &x,
            double &y)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def ViewportToNormalizedViewport(self, p_float, p_float_1):
        """
        V.ViewportToNormalizedViewport(float, float)
        C++: virtual void ViewportToNormalizedViewport(double &u,
            double &v)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def ViewToDisplay(self):
        """
        V.ViewToDisplay()
        C++: virtual void ViewToDisplay()
        
        Convert view coordinates to display coordinates.
        """
        ...
    
    def ViewToNormalizedViewport(self, p_float, p_float_1, p_float_2):
        """
        V.ViewToNormalizedViewport(float, float, float)
        C++: virtual void ViewToNormalizedViewport(double &x, double &y,
            double &z)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def ViewToPose(self, p_float, p_float_1, p_float_2):
        """
        V.ViewToPose(float, float, float)
        C++: virtual void ViewToPose(double &, double &, double &)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def ViewToWorld(self):
        """
        V.ViewToWorld()
        C++: virtual void ViewToWorld()
        V.ViewToWorld(float, float, float)
        C++: virtual void ViewToWorld(double &, double &, double &)
        
        Convert view point coordinates to world coordinates.
        """
        ...
    
    def WorldToDisplay(self):
        """
        V.WorldToDisplay()
        C++: void WorldToDisplay()
        
        Convert world point coordinates to display (or screen)
        coordinates.
        """
        ...
    
    def WorldToPose(self, p_float, p_float_1, p_float_2):
        """
        V.WorldToPose(float, float, float)
        C++: virtual void WorldToPose(double &, double &, double &)
        
        These methods map from one coordinate system to another. They are
        primarily used by the vtkCoordinate object and are often strung
        together. These methods return valid information only if the
        window has been realized (e.g., GetSize() returns something other
        than (0,0)).
        """
        ...
    
    def WorldToView(self):
        """
        V.WorldToView()
        C++: virtual void WorldToView()
        V.WorldToView(float, float, float)
        C++: virtual void WorldToView(double &, double &, double &)
        
        Convert world point coordinates to view coordinates.
        """
        ...
    
    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__ = ...


