from __future__ import annotations
import pxr.Gf._gf
import typing
import Boost.Python
import pxr.Gf

__all__ = [
    "Abs",
    "Absf",
    "ApplyGamma",
    "BBox3d",
    "Camera",
    "Ceil",
    "Ceilf",
    "Clamp",
    "Clampf",
    "CompDiv",
    "CompMult",
    "ConvertDisplayToLinear",
    "ConvertLinearToDisplay",
    "Cross",
    "DegreesToRadians",
    "Dot",
    "DualQuatd",
    "DualQuatf",
    "DualQuath",
    "Exp",
    "Expf",
    "FindClosestPoints",
    "FitPlaneToPoints",
    "Floor",
    "Floorf",
    "Frustum",
    "GetComplement",
    "GetDisplayGamma",
    "GetHomogenized",
    "GetLength",
    "GetNormalized",
    "GetProjection",
    "HomogeneousCross",
    "Interval",
    "IsClose",
    "Lerp",
    "Lerpf",
    "Line",
    "LineSeg",
    "Log",
    "Logf",
    "MIN_ORTHO_TOLERANCE",
    "MIN_VECTOR_LENGTH",
    "Matrix2d",
    "Matrix2f",
    "Matrix3d",
    "Matrix3f",
    "Matrix4d",
    "Matrix4f",
    "Max",
    "Min",
    "Mod",
    "Modf",
    "MultiInterval",
    "Normalize",
    "Plane",
    "Pow",
    "Powf",
    "Project",
    "Quatd",
    "Quaternion",
    "Quatf",
    "Quath",
    "RadiansToDegrees",
    "Range1d",
    "Range1f",
    "Range2d",
    "Range2f",
    "Range3d",
    "Range3f",
    "Ray",
    "Rect2i",
    "Rotation",
    "Round",
    "Roundf",
    "Sgn",
    "Size2",
    "Size3",
    "Slerp",
    "Sqr",
    "Sqrt",
    "Sqrtf",
    "Transform",
    "Vec2d",
    "Vec2f",
    "Vec2h",
    "Vec2i",
    "Vec3d",
    "Vec3f",
    "Vec3h",
    "Vec3i",
    "Vec4d",
    "Vec4f",
    "Vec4h",
    "Vec4i"
]


class BBox3d(Boost.Python.instance):
    """
    Arbitrarily oriented 3D bounding box
    """
    @staticmethod
    def Combine(*args, **kwargs) -> None: 
        """
        **classmethod** Combine(b1, b2) -> BBox3d


        Combines two bboxes, returning a new bbox that contains both.


        This uses the coordinate space of one of the two original boxes as the
        space of the result; it uses the one that produces whe smaller of the
        two resulting boxes.


        Parameters
        ----------
        b1 : BBox3d

        b2 : BBox3d
        """
    @staticmethod
    def ComputeAlignedBox() -> Range3d: 
        """
        ComputeAlignedBox() -> Range3d


        Returns the axis-aligned range (as a ``GfRange3d`` ) that results from
        applying the transformation matrix to the axis-aligned box and
        aligning the result.


        This synonym for ``ComputeAlignedRange`` exists for compatibility
        purposes.
        """
    @staticmethod
    def ComputeAlignedRange() -> Range3d: 
        """
        ComputeAlignedRange() -> Range3d


        Returns the axis-aligned range (as a ``GfRange3d`` ) that results from
        applying the transformation matrix to the wxis-aligned box and
        aligning the result.
        """
    @staticmethod
    def ComputeCentroid() -> Vec3d: 
        """
        ComputeCentroid() -> Vec3d


        Returns the centroid of the bounding box.


        The centroid is computed as the transformed centroid of the range.
        """
    @staticmethod
    def GetBox() -> Range3d: 
        """
        GetBox() -> Range3d


        Returns the range of the axis-aligned untransformed box.


        This synonym of ``GetRange`` exists for compatibility purposes.
        """
    @staticmethod
    def GetInverseMatrix() -> Matrix4d: 
        """
        GetInverseMatrix() -> Matrix4d


        Returns the inverse of the transformation matrix.


        This will be the identity matrix if the transformation matrix is not
        invertible.
        """
    @staticmethod
    def GetMatrix() -> Matrix4d: 
        """
        GetMatrix() -> Matrix4d


        Returns the transformation matrix.
        """
    @staticmethod
    def GetRange() -> Range3d: 
        """
        GetRange() -> Range3d


        Returns the range of the axis-aligned untransformed box.
        """
    @staticmethod
    def GetVolume() -> float: 
        """
        GetVolume() -> float


        Returns the volume of the box (0 for an empty box).
        """
    @staticmethod
    def HasZeroAreaPrimitives() -> bool: 
        """
        HasZeroAreaPrimitives() -> bool


        Returns the current state of the zero-area primitives flag".
        """
    @staticmethod
    def Set(box, matrix) -> None: 
        """
        Set(box, matrix) -> None


        Sets the axis-aligned box and transformation matrix.


        Parameters
        ----------
        box : Range3d

        matrix : Matrix4d
        """
    @staticmethod
    def SetHasZeroAreaPrimitives(hasThem) -> None: 
        """
        SetHasZeroAreaPrimitives(hasThem) -> None


        Sets the zero-area primitives flag to the given value.


        Parameters
        ----------
        hasThem : bool
        """
    @staticmethod
    def SetMatrix(matrix) -> None: 
        """
        SetMatrix(matrix) -> None


        Sets the transformation matrix only.


        The axis-aligned box is not modified.


        Parameters
        ----------
        matrix : Matrix4d
        """
    @staticmethod
    def SetRange(box) -> None: 
        """
        SetRange(box) -> None


        Sets the range of the axis-aligned box only.


        The transformation matrix is not modified.


        Parameters
        ----------
        box : Range3d
        """
    @staticmethod
    def Transform(matrix) -> None: 
        """
        Transform(matrix) -> None


        Transforms the bounding box by the given matrix, which is assumed to
        be a global transformation to apply to the box.


        Therefore, this just post-multiplies the box's matrix by ``matrix`` .


        Parameters
        ----------
        matrix : Matrix4d
        """
    @property
    def box(self) -> None:
        """
        :type: None
        """
    @property
    def hasZeroAreaPrimitives(self) -> None:
        """
        :type: None
        """
    @property
    def matrix(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 328
    pass
class Camera(Boost.Python.instance):
    class FOVDirection(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Direction used for Field of View or orthographic size.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'Camera'
        allValues: tuple # value = (Gf.Camera.FOVHorizontal, Gf.Camera.FOVVertical)
        pass
    class Projection(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Projection type.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'Camera'
        allValues: tuple # value = (Gf.Camera.Perspective, Gf.Camera.Orthographic)
        pass
    @staticmethod
    def GetFieldOfView(direction) -> float: 
        """
        GetFieldOfView(direction) -> float


        Returns the horizontal or vertical field of view in degrees.


        Parameters
        ----------
        direction : FOVDirection
        """
    @staticmethod
    def SetFromViewAndProjectionMatrix(viewMatrix, projMatix, focalLength) -> None: 
        """
        SetFromViewAndProjectionMatrix(viewMatrix, projMatix, focalLength) -> None


        Sets the camera from a view and projection matrix.


        Note that the projection matrix does only determine the ratio of
        aperture to focal length, so there is a choice which defaults to 50mm
        (or more accurately, 50 tenths of a world unit).


        Parameters
        ----------
        viewMatrix : Matrix4d

        projMatix : Matrix4d

        focalLength : float
        """
    @staticmethod
    def SetOrthographicFromAspectRatioAndSize(aspectRatio, orthographicSize, direction) -> None: 
        """
        SetOrthographicFromAspectRatioAndSize(aspectRatio, orthographicSize, direction) -> None


        Sets the frustum to be orthographic such that it has the given
        ``aspectRatio`` and such that the orthographic width, respectively,
        orthographic height (in cm) is equal to ``orthographicSize``
        (depending on direction).


        Parameters
        ----------
        aspectRatio : float

        orthographicSize : float

        direction : FOVDirection
        """
    @staticmethod
    def SetPerspectiveFromAspectRatioAndFieldOfView(aspectRatio, fieldOfView, direction, horizontalAperture) -> None: 
        """
        SetPerspectiveFromAspectRatioAndFieldOfView(aspectRatio, fieldOfView, direction, horizontalAperture) -> None


        Sets the frustum to be projective with the given ``aspectRatio`` and
        horizontal, respectively, vertical field of view ``fieldOfView``
        (similar to gluPerspective when direction = FOVVertical).


        Do not pass values for ``horionztalAperture`` unless you care about
        DepthOfField.


        Parameters
        ----------
        aspectRatio : float

        fieldOfView : float

        direction : FOVDirection

        horizontalAperture : float
        """
    @property
    def aspectRatio(self) -> None:
        """
        type : float


        Returns the projector aperture aspect ratio.

        :type: None
        """
    @property
    def clippingPlanes(self) -> None:
        """
        type : list[Vec4f]


        Returns additional clipping planes.

        ----------------------------------------------------------------------

        type : None


        Sets additional arbitrarily oriented clipping planes.


        A vector (a,b,c,d) encodes a clipping plane that clips off points
        (x,y,z) with a \* x + b \* y + c \* z + d \* 1<0

        :type: None
        """
    @property
    def clippingRange(self) -> None:
        """
        type : Range1f


        Returns the clipping range in world units.

        ----------------------------------------------------------------------

        type : None


        Sets the clipping range in world units.

        :type: None
        """
    @property
    def fStop(self) -> None:
        """
        type : float


        Returns the lens aperture.

        ----------------------------------------------------------------------

        type : None


        Sets the lens aperture, unitless.

        :type: None
        """
    @property
    def focalLength(self) -> None:
        """
        type : float


        Returns the focal length in tenths of a world unit (e.g., mm if the
        world unit is assumed to be cm).

        ----------------------------------------------------------------------

        type : None


        These are the values actually stored in the class and they correspond
        to measurements of an actual physical camera (in mm).


        Together with the clipping range, they determine the camera frustum.
        Sets the focal length in tenths of a world unit (e.g., mm if the world
        unit is assumed to be cm).

        :type: None
        """
    @property
    def focusDistance(self) -> None:
        """
        type : float


        Returns the focus distance in world units.

        ----------------------------------------------------------------------

        type : None


        Sets the focus distance in world units.

        :type: None
        """
    @property
    def frustum(self) -> None:
        """
        type : Frustum


        Returns the computed, world-space camera frustum.


        The frustum will always be that of a Y-up, -Z-looking camera.

        :type: None
        """
    @property
    def horizontalAperture(self) -> None:
        """
        type : float


        Returns the width of the projector aperture in tenths of a world unit
        (e.g., mm if the world unit is assumed to be cm).

        ----------------------------------------------------------------------

        type : None


        Sets the width of the projector aperture in tenths of a world unit
        (e.g., mm if the world unit is assumed to be cm).

        :type: None
        """
    @property
    def horizontalApertureOffset(self) -> None:
        """
        type : float


        Returns the horizontal offset of the projector aperture in tenths of a
        world unit (e.g., mm if the world unit is assumed to be cm).


        In particular, an offset is necessary when writing out a stereo camera
        with finite convergence distance as two cameras.

        ----------------------------------------------------------------------

        type : None


        Sets the horizontal offset of the projector aperture in tenths of a
        world unit (e.g., mm if the world unit is assumed to be cm).

        :type: None
        """
    @property
    def horizontalFieldOfView(self) -> None:
        """
        :type: None
        """
    @property
    def projection(self) -> None:
        """
        type : Projection


        Returns the projection type.

        ----------------------------------------------------------------------

        type : None


        Sets the projection type.

        :type: None
        """
    @property
    def transform(self) -> None:
        """
        type : Matrix4d


        Returns the transform of the filmback in world space.


        This is exactly the transform specified via SetTransform() .

        ----------------------------------------------------------------------

        type : None


        Sets the transform of the filmback in world space to ``val`` .

        :type: None
        """
    @property
    def verticalAperture(self) -> None:
        """
        type : float


        Returns the height of the projector aperture in tenths of a world unit
        (e.g., mm if the world unit is assumed to be cm).

        ----------------------------------------------------------------------

        type : None


        Sets the height of the projector aperture in tenths of a world unit
        (e.g., mm if the world unit is assumed to be cm).

        :type: None
        """
    @property
    def verticalApertureOffset(self) -> None:
        """
        type : float


        Returns the vertical offset of the projector aperture in tenths of a
        world unit (e.g., mm if the world unit is assumed to be cm).

        ----------------------------------------------------------------------

        type : None


        Sets the vertical offset of the projector aperture in tenths of a
        world unit (e.g., mm if the world unit is assumed to be cm).

        :type: None
        """
    @property
    def verticalFieldOfView(self) -> None:
        """
        :type: None
        """
    APERTURE_UNIT = 0.1
    DEFAULT_HORIZONTAL_APERTURE = 20.955
    DEFAULT_VERTICAL_APERTURE = 15.290799999999999
    FOCAL_LENGTH_UNIT = 0.1
    FOVHorizontal: pxr.Gf.FOVDirection # value = Gf.Camera.FOVHorizontal
    FOVVertical: pxr.Gf.FOVDirection # value = Gf.Camera.FOVVertical
    Orthographic: pxr.Gf.Projection # value = Gf.Camera.Orthographic
    Perspective: pxr.Gf.Projection # value = Gf.Camera.Perspective
    __instance_size__ = 208
    pass
class DualQuatd(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> DualQuatd: 
        """
        GetConjugate() -> DualQuatd


        Returns the conjugate of this dual quaternion.
        """
    @staticmethod
    def GetDual() -> Quatd: 
        """
        GetDual() -> Quatd


        Returns the dual part of the dual quaternion.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> DualQuatd


        Returns the identity dual quaternion, which has a real part of
        (1,0,0,0) and a dual part of (0,0,0,0).
        """
    @staticmethod
    def GetInverse() -> DualQuatd: 
        """
        GetInverse() -> DualQuatd


        Returns the inverse of this dual quaternion.
        """
    @staticmethod
    def GetLength() -> tuple[float, float]: 
        """
        GetLength() -> tuple[float, float]


        Returns geometric length of this dual quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> DualQuatd: 
        """
        GetNormalized(eps) -> DualQuatd


        Returns a normalized (unit-length) version of this dual quaternion.


        If the length of this dual quaternion is smaller than ``eps`` , this
        returns the identity dual quaternion.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetReal() -> Quatd: 
        """
        GetReal() -> Quatd


        Returns the real part of the dual quaternion.
        """
    @staticmethod
    def GetTranslation() -> Vec3d: 
        """
        GetTranslation() -> Vec3d


        Get the translation component of this dual quaternion.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> DualQuatd


        Returns the zero dual quaternion, which has a real part of (0,0,0,0)
        and a dual part of (0,0,0,0).
        """
    @staticmethod
    def Normalize(eps) -> tuple[float, float]: 
        """
        Normalize(eps) -> tuple[float, float]


        Normalizes this dual quaternion in place.


        Normalizes this dual quaternion in place to unit length, returning the
        length before normalization. If the length of this dual quaternion is
        smaller than ``eps`` , this sets the dual quaternion to identity.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def SetDual(dual) -> None: 
        """
        SetDual(dual) -> None


        Sets the dual part of the dual quaternion.


        Parameters
        ----------
        dual : Quatd
        """
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Sets the real part of the dual quaternion.


        Parameters
        ----------
        real : Quatd
        """
    @staticmethod
    def SetTranslation(translation) -> None: 
        """
        SetTranslation(translation) -> None


        Set the translation component of this dual quaternion.


        Parameters
        ----------
        translation : Vec3d
        """
    @staticmethod
    def Transform(vec) -> Vec3d: 
        """
        Transform(vec) -> Vec3d


        Transforms the row vector *vec* by the dual quaternion.


        Parameters
        ----------
        vec : Vec3d
        """
    @property
    def dual(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class DualQuatf(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> DualQuatf: 
        """
        GetConjugate() -> DualQuatf


        Returns the conjugate of this dual quaternion.
        """
    @staticmethod
    def GetDual() -> Quatf: 
        """
        GetDual() -> Quatf


        Returns the dual part of the dual quaternion.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> DualQuatf


        Returns the identity dual quaternion, which has a real part of
        (1,0,0,0) and a dual part of (0,0,0,0).
        """
    @staticmethod
    def GetInverse() -> DualQuatf: 
        """
        GetInverse() -> DualQuatf


        Returns the inverse of this dual quaternion.
        """
    @staticmethod
    def GetLength() -> tuple[float, float]: 
        """
        GetLength() -> tuple[float, float]


        Returns geometric length of this dual quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> DualQuatf: 
        """
        GetNormalized(eps) -> DualQuatf


        Returns a normalized (unit-length) version of this dual quaternion.


        If the length of this dual quaternion is smaller than ``eps`` , this
        returns the identity dual quaternion.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetReal() -> Quatf: 
        """
        GetReal() -> Quatf


        Returns the real part of the dual quaternion.
        """
    @staticmethod
    def GetTranslation() -> Vec3f: 
        """
        GetTranslation() -> Vec3f


        Get the translation component of this dual quaternion.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> DualQuatf


        Returns the zero dual quaternion, which has a real part of (0,0,0,0)
        and a dual part of (0,0,0,0).
        """
    @staticmethod
    def Normalize(eps) -> tuple[float, float]: 
        """
        Normalize(eps) -> tuple[float, float]


        Normalizes this dual quaternion in place.


        Normalizes this dual quaternion in place to unit length, returning the
        length before normalization. If the length of this dual quaternion is
        smaller than ``eps`` , this sets the dual quaternion to identity.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def SetDual(dual) -> None: 
        """
        SetDual(dual) -> None


        Sets the dual part of the dual quaternion.


        Parameters
        ----------
        dual : Quatf
        """
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Sets the real part of the dual quaternion.


        Parameters
        ----------
        real : Quatf
        """
    @staticmethod
    def SetTranslation(translation) -> None: 
        """
        SetTranslation(translation) -> None


        Set the translation component of this dual quaternion.


        Parameters
        ----------
        translation : Vec3f
        """
    @staticmethod
    def Transform(vec) -> Vec3f: 
        """
        Transform(vec) -> Vec3f


        Transforms the row vector *vec* by the dual quaternion.


        Parameters
        ----------
        vec : Vec3f
        """
    @property
    def dual(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class DualQuath(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> DualQuath: 
        """
        GetConjugate() -> DualQuath


        Returns the conjugate of this dual quaternion.
        """
    @staticmethod
    def GetDual() -> Quath: 
        """
        GetDual() -> Quath


        Returns the dual part of the dual quaternion.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> DualQuath


        Returns the identity dual quaternion, which has a real part of
        (1,0,0,0) and a dual part of (0,0,0,0).
        """
    @staticmethod
    def GetInverse() -> DualQuath: 
        """
        GetInverse() -> DualQuath


        Returns the inverse of this dual quaternion.
        """
    @staticmethod
    def GetLength() -> tuple[GfHalf, GfHalf]: 
        """
        GetLength() -> tuple[GfHalf, GfHalf]


        Returns geometric length of this dual quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> DualQuath: 
        """
        GetNormalized(eps) -> DualQuath


        Returns a normalized (unit-length) version of this dual quaternion.


        If the length of this dual quaternion is smaller than ``eps`` , this
        returns the identity dual quaternion.


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def GetReal() -> Quath: 
        """
        GetReal() -> Quath


        Returns the real part of the dual quaternion.
        """
    @staticmethod
    def GetTranslation() -> Vec3h: 
        """
        GetTranslation() -> Vec3h


        Get the translation component of this dual quaternion.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> DualQuath


        Returns the zero dual quaternion, which has a real part of (0,0,0,0)
        and a dual part of (0,0,0,0).
        """
    @staticmethod
    def Normalize(eps) -> tuple[GfHalf, GfHalf]: 
        """
        Normalize(eps) -> tuple[GfHalf, GfHalf]


        Normalizes this dual quaternion in place.


        Normalizes this dual quaternion in place to unit length, returning the
        length before normalization. If the length of this dual quaternion is
        smaller than ``eps`` , this sets the dual quaternion to identity.


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def SetDual(dual) -> None: 
        """
        SetDual(dual) -> None


        Sets the dual part of the dual quaternion.


        Parameters
        ----------
        dual : Quath
        """
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Sets the real part of the dual quaternion.


        Parameters
        ----------
        real : Quath
        """
    @staticmethod
    def SetTranslation(translation) -> None: 
        """
        SetTranslation(translation) -> None


        Set the translation component of this dual quaternion.


        Parameters
        ----------
        translation : Vec3h
        """
    @staticmethod
    def Transform(vec) -> Vec3h: 
        """
        Transform(vec) -> Vec3h


        Transforms the row vector *vec* by the dual quaternion.


        Parameters
        ----------
        vec : Vec3h
        """
    @property
    def dual(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class Frustum(Boost.Python.instance):
    """
    Basic view frustum
    """
    class ProjectionType(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        This enum is used to determine the type of projection represented by a
        frustum.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'Frustum'
        allValues: tuple # value = (Gf.Frustum.Orthographic, Gf.Frustum.Perspective)
        pass
    @staticmethod
    def ComputeAspectRatio() -> float: 
        """
        ComputeAspectRatio() -> float


        Returns the aspect ratio of the frustum, defined as the width of the
        window divided by the height.


        If the height is zero or negative, this returns 0.
        """
    @staticmethod
    def ComputeCorners() -> list[Vec3d]: 
        """
        ComputeCorners() -> list[Vec3d]


        Returns the world-space corners of the frustum as a vector of 8
        points, ordered as:



           - Left bottom near

           - Right bottom near

           - Left top near

           - Right top near

           - Left bottom far

           - Right bottom far

           - Left top far

           - Right top far
        """
    @staticmethod
    def ComputeCornersAtDistance(d) -> list[Vec3d]: 
        """
        ComputeCornersAtDistance(d) -> list[Vec3d]


        Returns the world-space corners of the intersection of the frustum
        with a plane parallel to the near/far plane at distance d from the
        apex, ordered as:



           - Left bottom

           - Right bottom

           - Left top

           - Right top In particular, it gives the partial result of
             ComputeCorners when given near or far distance.



        Parameters
        ----------
        d : float
        """
    @staticmethod
    def ComputeLookAtPoint() -> Vec3d: 
        """
        ComputeLookAtPoint() -> Vec3d


        Computes and returns the world-space look-at point from the eye point
        (position), view direction (rotation), and view distance.
        """
    @staticmethod
    @typing.overload
    def ComputeNarrowedFrustum(windowPos, size) -> Frustum: 
        """
        ComputeNarrowedFrustum(windowPos, size) -> Frustum


        Returns a frustum that is a narrowed-down version of this frustum.


        The new frustum has the same near and far planes, but the other planes
        are adjusted to be centered on ``windowPos`` with the new width and
        height obtained from the existing width and height by multiplying by
        ``size`` [0] and ``size`` [1], respectively. Finally, the new frustum
        is clipped against this frustum so that it is completely contained in
        the existing frustum.

        ``windowPos`` is given in normalized coords (-1 to +1 in both
        dimensions). ``size`` is given as a scalar (0 to 1 in both
        dimensions).

        If the ``windowPos`` or ``size`` given is outside these ranges, it may
        result in returning a collapsed frustum.

        This method is useful for computing a volume to use for interactive
        picking.


        Parameters
        ----------
        windowPos : Vec2d

        size : Vec2d



        ----------------------------------------------------------------------


        Returns a frustum that is a narrowed-down version of this frustum.


        The new frustum has the same near and far planes, but the other planes
        are adjusted to be centered on ``worldPoint`` with the new width and
        height obtained from the existing width and height by multiplying by
        ``size`` [0] and ``size`` [1], respectively. Finally, the new frustum
        is clipped against this frustum so that it is completely contained in
        the existing frustum.

        ``worldPoint`` is given in world space coordinates. ``size`` is given
        as a scalar (0 to 1 in both dimensions).

        If the ``size`` given is outside this range, it may result in
        returning a collapsed frustum.

        If the ``worldPoint`` is at or behind the eye of the frustum, it will
        return a frustum equal to this frustum.

        This method is useful for computing a volume to use for interactive
        picking.


        Parameters
        ----------
        worldPoint : Vec3d

        size : Vec2d
        """
    @staticmethod
    @typing.overload
    def ComputeNarrowedFrustum(worldPoint, size) -> Frustum: ...
    @staticmethod
    @typing.overload
    def ComputePickRay(windowPos) -> Ray: 
        """
        ComputePickRay(windowPos) -> Ray


        Builds and returns a ``GfRay`` that can be used for picking at the
        given normalized (-1 to +1 in both dimensions) window position.


        Contrasted with ComputeRay() , that method returns a ray whose origin
        is the eyepoint, while this method returns a ray whose origin is on
        the near plane.


        Parameters
        ----------
        windowPos : Vec2d



        ----------------------------------------------------------------------


        Builds and returns a ``GfRay`` that can be used for picking that
        connects the viewpoint to the given 3d point in worldspace.


        Parameters
        ----------
        worldSpacePos : Vec3d
        """
    @staticmethod
    @typing.overload
    def ComputePickRay(worldSpacePos) -> Ray: ...
    @staticmethod
    def ComputeProjectionMatrix() -> Matrix4d: 
        """
        ComputeProjectionMatrix() -> Matrix4d


        Returns a GL-style projection matrix corresponding to the frustum's
        projection.
        """
    @staticmethod
    def ComputeUpVector() -> Vec3d: 
        """
        ComputeUpVector() -> Vec3d


        Returns the normalized world-space up vector, which is computed by
        rotating the y axis by the frustum's rotation.
        """
    @staticmethod
    def ComputeViewDirection() -> Vec3d: 
        """
        ComputeViewDirection() -> Vec3d


        Returns the normalized world-space view direction vector, which is
        computed by rotating the -z axis by the frustum's rotation.
        """
    @staticmethod
    def ComputeViewFrame(side, up, view) -> None: 
        """
        ComputeViewFrame(side, up, view) -> None


        Computes the view frame defined by this frustum.


        The frame consists of the view direction, up vector and side vector,
        as shown in this diagram.

        .. code-block:: text

          up
          ^   ^
          |  / 
          | / view
          |/
          +- - - - > side



        Parameters
        ----------
        side : Vec3d

        up : Vec3d

        view : Vec3d
        """
    @staticmethod
    def ComputeViewInverse() -> Matrix4d: 
        """
        ComputeViewInverse() -> Matrix4d


        Returns a matrix that represents the inverse viewing transformation
        for this frustum.


        That is, it returns the matrix that converts points from eye (frustum)
        space to world space.
        """
    @staticmethod
    def ComputeViewMatrix() -> Matrix4d: 
        """
        ComputeViewMatrix() -> Matrix4d


        Returns a matrix that represents the viewing transformation for this
        frustum.


        That is, it returns the matrix that converts points from world space
        to eye (frustum) space.
        """
    @staticmethod
    def FitToSphere(center, radius, slack) -> None: 
        """
        FitToSphere(center, radius, slack) -> None


        Modifies the frustum to tightly enclose a sphere with the given center
        and radius, using the current view direction.


        The planes of the frustum are adjusted as necessary. The given amount
        of slack is added to the sphere's radius is used around the sphere to
        avoid boundary problems.


        Parameters
        ----------
        center : Vec3d

        radius : float

        slack : float
        """
    @staticmethod
    def GetFOV(*args, **kwargs) -> None: 
        """
        Returns the horizontal fov of the frustum. The fov of the
        frustum is not necessarily the same value as displayed in
        the viewer. The displayed fov is a function of the focal
        length or FOV avar. The frustum's fov may be different due
        to things like lens breathing.

        If the frustum is not of type GfFrustum::Perspective, the
        returned FOV will be 0.0.
        """
    @staticmethod
    def GetNearFar() -> Range1d: 
        """
        GetNearFar() -> Range1d


        Returns the near/far interval.
        """
    @staticmethod
    def GetOrthographic(left, right, bottom, top, nearPlane, farPlane) -> bool: 
        """
        GetOrthographic(left, right, bottom, top, nearPlane, farPlane) -> bool


        Returns the current frustum in the format used by
        ``SetOrthographic()`` .


        If the current frustum is not an orthographic projection, this returns
        ``false`` and leaves the parameters untouched.


        Parameters
        ----------
        left : float

        right : float

        bottom : float

        top : float

        nearPlane : float

        farPlane : float
        """
    @staticmethod
    def GetPerspective(*args, **kwargs) -> None: 
        """
        Returns the current perspective frustum values suitable
        for use by SetPerspective.  If the current frustum is a
        perspective projection, the return value is a tuple of
        fieldOfView, aspectRatio, nearDistance, farDistance).
        If the current frustum is not perspective, the return
        value is None.
        """
    @staticmethod
    def GetPosition() -> Vec3d: 
        """
        GetPosition() -> Vec3d


        Returns the position of the frustum in world space.
        """
    @staticmethod
    def GetProjectionType() -> Frustum.ProjectionType: 
        """
        GetProjectionType() -> Frustum.ProjectionType


        Returns the projection type.
        """
    @staticmethod
    def GetReferencePlaneDepth(*args, **kwargs) -> None: 
        """
        **classmethod** GetReferencePlaneDepth() -> float


        Returns the depth of the reference plane.
        """
    @staticmethod
    def GetRotation() -> Rotation: 
        """
        GetRotation() -> Rotation


        Returns the orientation of the frustum in world space as a rotation to
        apply to the -z axis.
        """
    @staticmethod
    def GetViewDistance() -> float: 
        """
        GetViewDistance() -> float


        Returns the view distance.
        """
    @staticmethod
    def GetWindow() -> Range2d: 
        """
        GetWindow() -> Range2d


        Returns the window rectangle in the reference plane.
        """
    @staticmethod
    @typing.overload
    def Intersects(bbox) -> bool: 
        """
        Intersects(bbox) -> bool


        Returns true if the given axis-aligned bbox is inside or intersecting
        the frustum.


        Otherwise, it returns false. Useful when doing picking or frustum
        culling.


        Parameters
        ----------
        bbox : BBox3d



        ----------------------------------------------------------------------


        Returns true if the given point is inside or intersecting the frustum.


        Otherwise, it returns false.


        Parameters
        ----------
        point : Vec3d



        ----------------------------------------------------------------------


        Returns ``true`` if the line segment formed by the given points is
        inside or intersecting the frustum.


        Otherwise, it returns false.


        Parameters
        ----------
        p0 : Vec3d

        p1 : Vec3d



        ----------------------------------------------------------------------


        Returns ``true`` if the triangle formed by the given points is inside
        or intersecting the frustum.


        Otherwise, it returns false.


        Parameters
        ----------
        p0 : Vec3d

        p1 : Vec3d

        p2 : Vec3d
        """
    @staticmethod
    @typing.overload
    def Intersects(point) -> bool: ...
    @staticmethod
    @typing.overload
    def Intersects(p0, p1) -> bool: ...
    @staticmethod
    @typing.overload
    def Intersects(p0, p1, p2) -> bool: ...
    @staticmethod
    def IntersectsViewVolume(*args, **kwargs) -> None: 
        """
        **classmethod** IntersectsViewVolume(bbox, vpMat) -> bool


        Returns ``true`` if the bbox volume intersects the view volume given
        by the view-projection matrix, erring on the side of false positives
        for efficiency.


        This method is intended for cases where a GfFrustum is not available
        or when the view-projection matrix yields a view volume that is not
        expressable as a GfFrustum.

        Because it errs on the side of false positives, it is suitable for
        early-out tests such as draw or intersection culling.


        Parameters
        ----------
        bbox : BBox3d

        vpMat : Matrix4d
        """
    @staticmethod
    def SetNearFar(nearFar) -> None: 
        """
        SetNearFar(nearFar) -> None


        Sets the near/far interval.


        Parameters
        ----------
        nearFar : Range1d
        """
    @staticmethod
    def SetOrthographic(left, right, bottom, top, nearPlane, farPlane) -> None: 
        """
        SetOrthographic(left, right, bottom, top, nearPlane, farPlane) -> None


        Sets up the frustum in a manner similar to ``glOrtho()`` .


        Sets the projection to ``GfFrustum::Orthographic`` and sets the window
        and near/far specifications based on the given values.


        Parameters
        ----------
        left : float

        right : float

        bottom : float

        top : float

        nearPlane : float

        farPlane : float
        """
    @staticmethod
    @typing.overload
    def SetPerspective(fieldOfViewHeight, aspectRatio, nearDistance, farDistance) -> None: 
        """
        SetPerspective(fieldOfViewHeight, aspectRatio, nearDistance, farDistance) -> None


        Sets up the frustum in a manner similar to ``gluPerspective()`` .


        It sets the projection type to ``GfFrustum::Perspective`` and sets the
        window specification so that the resulting symmetric frustum encloses
        an angle of ``fieldOfViewHeight`` degrees in the vertical direction,
        with ``aspectRatio`` used to figure the angle in the horizontal
        direction. The near and far distances are specified as well. The
        window coordinates are computed as:

        .. code-block:: text

          top    = tan(fieldOfViewHeight / 2)
          bottom = -top
          right  = top \* aspectRatio
          left   = -right
          near   = nearDistance
          far    = farDistance



        Parameters
        ----------
        fieldOfViewHeight : float

        aspectRatio : float

        nearDistance : float

        farDistance : float



        ----------------------------------------------------------------------


        Sets up the frustum in a manner similar to gluPerspective().


        It sets the projection type to ``GfFrustum::Perspective`` and sets the
        window specification so that:

        If *isFovVertical* is true, the resulting symmetric frustum encloses
        an angle of ``fieldOfView`` degrees in the vertical direction, with
        ``aspectRatio`` used to figure the angle in the horizontal direction.

        If *isFovVertical* is false, the resulting symmetric frustum encloses
        an angle of ``fieldOfView`` degrees in the horizontal direction, with
        ``aspectRatio`` used to figure the angle in the vertical direction.

        The near and far distances are specified as well. The window
        coordinates are computed as follows:

           - if isFovVertical:

           - top = tan(fieldOfView / 2)

           - right = top \* aspectRatio

           - if NOT isFovVertical:

           - right = tan(fieldOfView / 2)

           - top = right / aspectRation

           - bottom = -top

           - left = -right

           - near = nearDistance

           - far = farDistance



        Parameters
        ----------
        fieldOfView : float

        isFovVertical : bool

        aspectRatio : float

        nearDistance : float

        farDistance : float
        """
    @staticmethod
    @typing.overload
    def SetPerspective(fieldOfView, isFovVertical, aspectRatio, nearDistance, farDistance) -> None: ...
    @staticmethod
    def SetPosition(position) -> None: 
        """
        SetPosition(position) -> None


        Sets the position of the frustum in world space.


        Parameters
        ----------
        position : Vec3d
        """
    @staticmethod
    def SetPositionAndRotationFromMatrix(camToWorldXf) -> None: 
        """
        SetPositionAndRotationFromMatrix(camToWorldXf) -> None


        Sets the position and rotation of the frustum from a camera matrix
        (always from a y-Up camera).


        The resulting frustum's transform will always represent a right-handed
        and orthonormal coordinate sytem (scale, shear, and projection are
        removed from the given ``camToWorldXf`` ).


        Parameters
        ----------
        camToWorldXf : Matrix4d
        """
    @staticmethod
    def SetProjectionType(projectionType) -> None: 
        """
        SetProjectionType(projectionType) -> None


        Sets the projection type.


        Parameters
        ----------
        projectionType : Frustum.ProjectionType
        """
    @staticmethod
    def SetRotation(rotation) -> None: 
        """
        SetRotation(rotation) -> None


        Sets the orientation of the frustum in world space as a rotation to
        apply to the default frame: looking along the -z axis with the +y axis
        as"up".


        Parameters
        ----------
        rotation : Rotation
        """
    @staticmethod
    def SetViewDistance(viewDistance) -> None: 
        """
        SetViewDistance(viewDistance) -> None


        Sets the view distance.


        Parameters
        ----------
        viewDistance : float
        """
    @staticmethod
    def SetWindow(window) -> None: 
        """
        SetWindow(window) -> None


        Sets the window rectangle in the reference plane that defines the
        left, right, top, and bottom planes of the frustum.


        Parameters
        ----------
        window : Range2d
        """
    @staticmethod
    def Transform(matrix) -> Frustum: 
        """
        Transform(matrix) -> Frustum


        Transforms the frustum by the given matrix.


        The transformation matrix is applied as follows: the position and the
        direction vector are transformed with the given matrix. Then the
        length of the new direction vector is used to rescale the near and far
        plane and the view distance. Finally, the points that define the
        reference plane are transformed by the matrix. This method assures
        that the frustum will not be sheared or perspective-projected.

        Note that this definition means that the transformed frustum does not
        preserve scales very well. Do *not* use this function to transform a
        frustum that is to be used for precise operations such as intersection
        testing.


        Parameters
        ----------
        matrix : Matrix4d
        """
    @property
    def nearFar(self) -> None:
        """
        :type: None
        """
    @property
    def position(self) -> None:
        """
        :type: None
        """
    @property
    def projectionType(self) -> None:
        """
        :type: None
        """
    @property
    def rotation(self) -> None:
        """
        :type: None
        """
    @property
    def viewDistance(self) -> None:
        """
        :type: None
        """
    @property
    def window(self) -> None:
        """
        :type: None
        """
    Orthographic: pxr.Gf.ProjectionType # value = Gf.Frustum.Orthographic
    Perspective: pxr.Gf.ProjectionType # value = Gf.Frustum.Perspective
    __instance_size__ = 144
    pass
class Interval(Boost.Python.instance):
    """
    Basic mathematical interval class
    """
    @staticmethod
    def Contains(*args, **kwargs) -> None: 
        """
        Returns true if x is inside the interval.

        Returns true if x is inside the interval.
        """
    @staticmethod
    def GetFullInterval(*args, **kwargs) -> None: 
        """
        **classmethod** GetFullInterval() -> Interval


        Returns the full interval (-inf, inf).
        """
    @staticmethod
    def GetMax(*args, **kwargs) -> None: 
        """
        Get the maximum value.
        """
    @staticmethod
    def GetMin(*args, **kwargs) -> None: 
        """
        Get the minimum value.
        """
    @staticmethod
    def GetSize(*args, **kwargs) -> None: 
        """
        The width of the interval
        """
    @staticmethod
    def In(*args, **kwargs) -> None: 
        """
        Returns true if x is inside the interval.
        """
    @staticmethod
    def Intersects(i) -> bool: 
        """
        Intersects(i) -> bool


        Return true iff the given interval i intersects this interval.


        Parameters
        ----------
        i : Interval
        """
    @staticmethod
    def IsEmpty(*args, **kwargs) -> None: 
        """
        True if the interval is empty.
        """
    @staticmethod
    def IsFinite() -> bool: 
        """
        IsFinite() -> bool


        Returns true if both the maximum and minimum value are finite.
        """
    @staticmethod
    def IsMaxClosed() -> bool: 
        """
        IsMaxClosed() -> bool


        Maximum boundary condition.
        """
    @staticmethod
    def IsMaxFinite() -> bool: 
        """
        IsMaxFinite() -> bool


        Returns true if the maximum value is finite.
        """
    @staticmethod
    def IsMaxOpen() -> bool: 
        """
        IsMaxOpen() -> bool


        Maximum boundary condition.
        """
    @staticmethod
    def IsMinClosed() -> bool: 
        """
        IsMinClosed() -> bool


        Minimum boundary condition.
        """
    @staticmethod
    def IsMinFinite() -> bool: 
        """
        IsMinFinite() -> bool


        Returns true if the minimum value is finite.
        """
    @staticmethod
    def IsMinOpen() -> bool: 
        """
        IsMinOpen() -> bool


        Minimum boundary condition.
        """
    @staticmethod
    def SetMax(*args, **kwargs) -> None: 
        """
        Set the maximum value.

        Set the maximum value and boundary condition.
        """
    @staticmethod
    def SetMin(*args, **kwargs) -> None: 
        """
        Set the minimum value.

        Set the minimum value and boundary condition.
        """
    @property
    def finite(self) -> None:
        """
        :type: None
        """
    @property
    def isEmpty(self) -> None:
        """
        True if the interval is empty.

        :type: None
        """
    @property
    def max(self) -> None:
        """
        The maximum value.

        :type: None
        """
    @property
    def maxClosed(self) -> None:
        """
        :type: None
        """
    @property
    def maxFinite(self) -> None:
        """
        :type: None
        """
    @property
    def maxOpen(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        The minimum value.

        :type: None
        """
    @property
    def minClosed(self) -> None:
        """
        :type: None
        """
    @property
    def minFinite(self) -> None:
        """
        :type: None
        """
    @property
    def minOpen(self) -> None:
        """
        :type: None
        """
    @property
    def size(self) -> None:
        """
        The width of the interval.

        :type: None
        """
    __instance_size__ = 48
    pass
class Line(Boost.Python.instance):
    """
    Line class
    """
    @staticmethod
    def FindClosestPoint(point, t) -> Vec3d: 
        """
        FindClosestPoint(point, t) -> Vec3d


        Returns the point on the line that is closest to ``point`` .


        If ``t`` is not ``None`` , it will be set to the parametric distance
        along the line of the returned point.


        Parameters
        ----------
        point : Vec3d

        t : float
        """
    @staticmethod
    def GetDirection() -> Vec3d: 
        """
        GetDirection() -> Vec3d


        Return the normalized direction of the line.
        """
    @staticmethod
    def GetPoint(t) -> Vec3d: 
        """
        GetPoint(t) -> Vec3d


        Return the point on the line at ```` ( p0 + t \* dir).


        Remember dir has been normalized so t represents a unit distance.


        Parameters
        ----------
        t : float
        """
    @staticmethod
    def Set(p0, dir) -> float: 
        """
        Set(p0, dir) -> float


        Parameters
        ----------
        p0 : Vec3d

        dir : Vec3d
        """
    @property
    def direction(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 64
    pass
class LineSeg(Boost.Python.instance):
    """
    Line segment class
    """
    @staticmethod
    def FindClosestPoint(point, t) -> Vec3d: 
        """
        FindClosestPoint(point, t) -> Vec3d


        Returns the point on the line that is closest to ``point`` .


        If ``t`` is not ``None`` , it will be set to the parametric distance
        along the line of the closest point.


        Parameters
        ----------
        point : Vec3d

        t : float
        """
    @staticmethod
    def GetDirection() -> Vec3d: 
        """
        GetDirection() -> Vec3d


        Return the normalized direction of the line.
        """
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Return the length of the line.
        """
    @staticmethod
    def GetPoint(t) -> Vec3d: 
        """
        GetPoint(t) -> Vec3d


        Return the point on the segment specified by the parameter t.


        p = p0 + t \* (p1 - p0)


        Parameters
        ----------
        t : float
        """
    @property
    def direction(self) -> None:
        """
        :type: None
        """
    @property
    def length(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 72
    pass
class Matrix2d(Boost.Python.instance):
    @staticmethod
    def GetColumn(i) -> Vec2d: 
        """
        GetColumn(i) -> Vec2d


        Gets a column of the matrix as a Vec2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix2d: 
        """
        GetInverse(det, eps) -> Matrix2d


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetRow(i) -> Vec2d: 
        """
        GetRow(i) -> Vec2d


        Gets a row of the matrix as a Vec2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix2d: 
        """
        GetTranspose() -> Matrix2d


        Returns the transpose of the matrix.
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m10, m11) -> Matrix2d: 
        """
        Set(m00, m01, m10, m11) -> Matrix2d


        Sets the matrix from 4 independent ``double`` values, specified in
        row-major order.


        For example, parameter *m10* specifies the value in row 1 and column
        0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m10 : float

        m11 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 2x2 array of ``double`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix2d: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec2.


        Parameters
        ----------
        i : int

        v : Vec2d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix2d: 
        """
        SetDiagonal(s) -> Matrix2d


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1]`` ).


        Parameters
        ----------
        arg1 : Vec2d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix2d: ...
    @staticmethod
    def SetIdentity() -> Matrix2d: 
        """
        SetIdentity() -> Matrix2d


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec2.


        Parameters
        ----------
        i : int

        v : Vec2d
        """
    @staticmethod
    def SetZero() -> Matrix2d: 
        """
        SetZero() -> Matrix2d


        Sets the matrix to zero.
        """
    __safe_for_unpickling__ = True
    dimension = (2, 2)
    pass
class Matrix2f(Boost.Python.instance):
    @staticmethod
    def GetColumn(i) -> Vec2f: 
        """
        GetColumn(i) -> Vec2f


        Gets a column of the matrix as a Vec2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix2f: 
        """
        GetInverse(det, eps) -> Matrix2f


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetRow(i) -> Vec2f: 
        """
        GetRow(i) -> Vec2f


        Gets a row of the matrix as a Vec2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix2f: 
        """
        GetTranspose() -> Matrix2f


        Returns the transpose of the matrix.
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m10, m11) -> Matrix2f: 
        """
        Set(m00, m01, m10, m11) -> Matrix2f


        Sets the matrix from 4 independent ``float`` values, specified in row-
        major order.


        For example, parameter *m10* specifies the value in row 1 and column
        0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m10 : float

        m11 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 2x2 array of ``float`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix2f: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec2.


        Parameters
        ----------
        i : int

        v : Vec2f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix2f: 
        """
        SetDiagonal(s) -> Matrix2f


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1]`` ).


        Parameters
        ----------
        arg1 : Vec2f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix2f: ...
    @staticmethod
    def SetIdentity() -> Matrix2f: 
        """
        SetIdentity() -> Matrix2f


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec2.


        Parameters
        ----------
        i : int

        v : Vec2f
        """
    @staticmethod
    def SetZero() -> Matrix2f: 
        """
        SetZero() -> Matrix2f


        Sets the matrix to zero.
        """
    __safe_for_unpickling__ = True
    dimension = (2, 2)
    pass
class Matrix3d(Boost.Python.instance):
    @staticmethod
    def ExtractRotation() -> Rotation: 
        """
        ExtractRotation() -> Rotation


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def GetColumn(i) -> Vec3d: 
        """
        GetColumn(i) -> Vec3d


        Gets a column of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetHandedness() -> float: 
        """
        GetHandedness() -> float


        Returns the sign of the determinant of the matrix, i.e.


        1 for a right-handed matrix, -1 for a left-handed matrix, and 0 for a
        singular matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix3d: 
        """
        GetInverse(det, eps) -> Matrix3d


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetOrthonormalized(issueWarning) -> Matrix3d: 
        """
        GetOrthonormalized(issueWarning) -> Matrix3d


        Returns an orthonormalized copy of the matrix.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def GetRow(i) -> Vec3d: 
        """
        GetRow(i) -> Vec3d


        Gets a row of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix3d: 
        """
        GetTranspose() -> Matrix3d


        Returns the transpose of the matrix.
        """
    @staticmethod
    def IsLeftHanded() -> bool: 
        """
        IsLeftHanded() -> bool


        Returns true if the vectors in matrix form a left-handed coordinate
        system.
        """
    @staticmethod
    def IsRightHanded() -> bool: 
        """
        IsRightHanded() -> bool


        Returns true if the vectors in the matrix form a right-handed
        coordinate system.
        """
    @staticmethod
    def Orthonormalize(issueWarning) -> bool: 
        """
        Orthonormalize(issueWarning) -> bool


        Makes the matrix orthonormal in place.


        This is an iterative method that is much more stable than the previous
        cross/cross method. If the iterative method does not converge, a
        warning is issued.

        Returns true if the iteration converged, false otherwise. Leaves any
        translation part of the matrix unchanged. If *issueWarning* is true,
        this method will issue a warning if the iteration does not converge,
        otherwise it will be silent.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m02, m10, m11, m12, m20, m21, m22) -> Matrix3d: 
        """
        Set(m00, m01, m02, m10, m11, m12, m20, m21, m22) -> Matrix3d


        Sets the matrix from 9 independent ``double`` values, specified in
        row-major order.


        For example, parameter *m10* specifies the value in row 1 and column
        0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m02 : float

        m10 : float

        m11 : float

        m12 : float

        m20 : float

        m21 : float

        m22 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 3x3 array of ``double`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix3d: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec3.


        Parameters
        ----------
        i : int

        v : Vec3d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix3d: 
        """
        SetDiagonal(s) -> Matrix3d


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1], v[2]`` ).


        Parameters
        ----------
        arg1 : Vec3d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix3d: ...
    @staticmethod
    def SetIdentity() -> Matrix3d: 
        """
        SetIdentity() -> Matrix3d


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    def SetRotate(rot) -> Matrix3d: 
        """
        SetRotate(rot) -> Matrix3d


        Sets the matrix to specify a rotation equivalent to *rot*.


        Parameters
        ----------
        rot : Quatd



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*.


        Parameters
        ----------
        rot : Rotation
        """
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec3.


        Parameters
        ----------
        i : int

        v : Vec3d
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactors) -> Matrix3d: 
        """
        SetScale(scaleFactors) -> Matrix3d


        Sets the matrix to specify a nonuniform scaling in x, y, and z by the
        factors in vector *scaleFactors*.


        Parameters
        ----------
        scaleFactors : Vec3d



        ----------------------------------------------------------------------


        Sets matrix to specify a uniform scaling by *scaleFactor*.


        Parameters
        ----------
        scaleFactor : float
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactor) -> Matrix3d: ...
    @staticmethod
    def SetZero() -> Matrix3d: 
        """
        SetZero() -> Matrix3d


        Sets the matrix to zero.
        """
    __safe_for_unpickling__ = True
    dimension = (3, 3)
    pass
class Matrix3f(Boost.Python.instance):
    @staticmethod
    def ExtractRotation() -> Rotation: 
        """
        ExtractRotation() -> Rotation


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def GetColumn(i) -> Vec3f: 
        """
        GetColumn(i) -> Vec3f


        Gets a column of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetHandedness() -> float: 
        """
        GetHandedness() -> float


        Returns the sign of the determinant of the matrix, i.e.


        1 for a right-handed matrix, -1 for a left-handed matrix, and 0 for a
        singular matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix3f: 
        """
        GetInverse(det, eps) -> Matrix3f


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetOrthonormalized(issueWarning) -> Matrix3f: 
        """
        GetOrthonormalized(issueWarning) -> Matrix3f


        Returns an orthonormalized copy of the matrix.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def GetRow(i) -> Vec3f: 
        """
        GetRow(i) -> Vec3f


        Gets a row of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix3f: 
        """
        GetTranspose() -> Matrix3f


        Returns the transpose of the matrix.
        """
    @staticmethod
    def IsLeftHanded() -> bool: 
        """
        IsLeftHanded() -> bool


        Returns true if the vectors in matrix form a left-handed coordinate
        system.
        """
    @staticmethod
    def IsRightHanded() -> bool: 
        """
        IsRightHanded() -> bool


        Returns true if the vectors in the matrix form a right-handed
        coordinate system.
        """
    @staticmethod
    def Orthonormalize(issueWarning) -> bool: 
        """
        Orthonormalize(issueWarning) -> bool


        Makes the matrix orthonormal in place.


        This is an iterative method that is much more stable than the previous
        cross/cross method. If the iterative method does not converge, a
        warning is issued.

        Returns true if the iteration converged, false otherwise. Leaves any
        translation part of the matrix unchanged. If *issueWarning* is true,
        this method will issue a warning if the iteration does not converge,
        otherwise it will be silent.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m02, m10, m11, m12, m20, m21, m22) -> Matrix3f: 
        """
        Set(m00, m01, m02, m10, m11, m12, m20, m21, m22) -> Matrix3f


        Sets the matrix from 9 independent ``float`` values, specified in row-
        major order.


        For example, parameter *m10* specifies the value in row 1 and column
        0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m02 : float

        m10 : float

        m11 : float

        m12 : float

        m20 : float

        m21 : float

        m22 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 3x3 array of ``float`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix3f: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec3.


        Parameters
        ----------
        i : int

        v : Vec3f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix3f: 
        """
        SetDiagonal(s) -> Matrix3f


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1], v[2]`` ).


        Parameters
        ----------
        arg1 : Vec3f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix3f: ...
    @staticmethod
    def SetIdentity() -> Matrix3f: 
        """
        SetIdentity() -> Matrix3f


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    def SetRotate(rot) -> Matrix3f: 
        """
        SetRotate(rot) -> Matrix3f


        Sets the matrix to specify a rotation equivalent to *rot*.


        Parameters
        ----------
        rot : Quatf



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*.


        Parameters
        ----------
        rot : Rotation
        """
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec3.


        Parameters
        ----------
        i : int

        v : Vec3f
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactors) -> Matrix3f: 
        """
        SetScale(scaleFactors) -> Matrix3f


        Sets the matrix to specify a nonuniform scaling in x, y, and z by the
        factors in vector *scaleFactors*.


        Parameters
        ----------
        scaleFactors : Vec3f



        ----------------------------------------------------------------------


        Sets matrix to specify a uniform scaling by *scaleFactor*.


        Parameters
        ----------
        scaleFactor : float
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactor) -> Matrix3f: ...
    @staticmethod
    def SetZero() -> Matrix3f: 
        """
        SetZero() -> Matrix3f


        Sets the matrix to zero.
        """
    __safe_for_unpickling__ = True
    dimension = (3, 3)
    pass
class Matrix4d(Boost.Python.instance):
    @staticmethod
    def ExtractRotation() -> Rotation: 
        """
        ExtractRotation() -> Rotation


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractRotationMatrix() -> Matrix3d: 
        """
        ExtractRotationMatrix() -> Matrix3d


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractRotationQuat() -> Quatd: 
        """
        ExtractRotationQuat() -> Quatd


        Return the rotation corresponding to this matrix as a quaternion.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractTranslation() -> Vec3d: 
        """
        ExtractTranslation() -> Vec3d


        Returns the translation part of the matrix, defined as the first three
        elements of the last row.
        """
    @staticmethod
    def Factor(r, s, u, t, p, eps) -> bool: 
        """
        Factor(r, s, u, t, p, eps) -> bool


        Factors the matrix into 5 components:



           - ``*M* = r \* s \* -r \* u \* t`` where

           - *t* is a translation.

           - *u* and *r* are rotations, and *-r* is the transpose (inverse) of
             *r*. The *u* matrix may contain shear information.

           - *s* is a scale. Any projection information could be returned in
             matrix *p*, but currently p is never modified.
             Returns ``false`` if the matrix is singular (as determined by *eps*).
             In that case, any zero scales in *s* are clamped to *eps* to allow
             computation of *u*.


        Parameters
        ----------
        r : Matrix4d

        s : Vec3d

        u : Matrix4d

        t : Vec3d

        p : Matrix4d

        eps : float
        """
    @staticmethod
    def GetColumn(i) -> Vec4d: 
        """
        GetColumn(i) -> Vec4d


        Gets a column of the matrix as a Vec4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetDeterminant3() -> float: 
        """
        GetDeterminant3() -> float


        Returns the determinant of the upper 3x3 matrix.


        This method is useful when the matrix describes a linear
        transformation such as a rotation or scale because the other values in
        the 4x4 matrix are not important.
        """
    @staticmethod
    def GetHandedness() -> float: 
        """
        GetHandedness() -> float


        Returns the sign of the determinant of the upper 3x3 matrix, i.e.


        1 for a right-handed matrix, -1 for a left-handed matrix, and 0 for a
        singular matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix4d: 
        """
        GetInverse(det, eps) -> Matrix4d


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetOrthonormalized(issueWarning) -> Matrix4d: 
        """
        GetOrthonormalized(issueWarning) -> Matrix4d


        Returns an orthonormalized copy of the matrix.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def GetRow(i) -> Vec4d: 
        """
        GetRow(i) -> Vec4d


        Gets a row of the matrix as a Vec4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetRow3(i) -> Vec3d: 
        """
        GetRow3(i) -> Vec3d


        Gets a row of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix4d: 
        """
        GetTranspose() -> Matrix4d


        Returns the transpose of the matrix.
        """
    @staticmethod
    def HasOrthogonalRows3() -> bool: 
        """
        HasOrthogonalRows3() -> bool


        Returns true, if the row vectors of the upper 3x3 matrix form an
        orthogonal basis.


        Note they do not have to be unit length for this test to return true.
        """
    @staticmethod
    def IsLeftHanded() -> bool: 
        """
        IsLeftHanded() -> bool


        Returns true if the vectors in the upper 3x3 matrix form a left-handed
        coordinate system.
        """
    @staticmethod
    def IsRightHanded() -> bool: 
        """
        IsRightHanded() -> bool


        Returns true if the vectors in the upper 3x3 matrix form a right-
        handed coordinate system.
        """
    @staticmethod
    def Orthonormalize(issueWarning) -> bool: 
        """
        Orthonormalize(issueWarning) -> bool


        Makes the matrix orthonormal in place.


        This is an iterative method that is much more stable than the previous
        cross/cross method. If the iterative method does not converge, a
        warning is issued.

        Returns true if the iteration converged, false otherwise. Leaves any
        translation part of the matrix unchanged. If *issueWarning* is true,
        this method will issue a warning if the iteration does not converge,
        otherwise it will be silent.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def RemoveScaleShear() -> Matrix4d: 
        """
        RemoveScaleShear() -> Matrix4d


        Returns the matrix with any scaling or shearing removed, leaving only
        the rotation and translation.


        If the matrix cannot be decomposed, returns the original matrix.
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) -> Matrix4d: 
        """
        Set(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) -> Matrix4d


        Sets the matrix from 16 independent ``double`` values, specified in
        row-major order.


        For example, parameter *m10* specifies the value in row 1 and column
        0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m02 : float

        m03 : float

        m10 : float

        m11 : float

        m12 : float

        m13 : float

        m20 : float

        m21 : float

        m22 : float

        m23 : float

        m30 : float

        m31 : float

        m32 : float

        m33 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 4x4 array of ``double`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix4d: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec4.


        Parameters
        ----------
        i : int

        v : Vec4d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix4d: 
        """
        SetDiagonal(s) -> Matrix4d


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1], v[2], v[3]`` ).


        Parameters
        ----------
        arg1 : Vec4d
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix4d: ...
    @staticmethod
    def SetIdentity() -> Matrix4d: 
        """
        SetIdentity() -> Matrix4d


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    @typing.overload
    def SetLookAt(eyePoint, centerPoint, upDirection) -> Matrix4d: 
        """
        SetLookAt(eyePoint, centerPoint, upDirection) -> Matrix4d


        Sets the matrix to specify a viewing matrix from parameters similar to
        those used by ``gluLookAt(3G)`` .


        *eyePoint* represents the eye point in world space. *centerPoint*
        represents the world-space center of attention. *upDirection* is a
        vector indicating which way is up.


        Parameters
        ----------
        eyePoint : Vec3d

        centerPoint : Vec3d

        upDirection : Vec3d



        ----------------------------------------------------------------------


        Sets the matrix to specify a viewing matrix from a world-space
        *eyePoint* and a world-space rotation that rigidly rotates the
        orientation from its canonical frame, which is defined to be looking
        along the ``-z`` axis with the ``+y`` axis as the up direction.


        Parameters
        ----------
        eyePoint : Vec3d

        orientation : Rotation
        """
    @staticmethod
    @typing.overload
    def SetLookAt(eyePoint, orientation) -> Matrix4d: ...
    @staticmethod
    @typing.overload
    def SetRotate(rot) -> Matrix4d: 
        """
        SetRotate(rot) -> Matrix4d


        Sets the matrix to specify a rotation equivalent to *rot*, and clears
        the translation.


        Parameters
        ----------
        rot : Quatd



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*, and clears
        the translation.


        Parameters
        ----------
        rot : Rotation



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *mx*, and clears
        the translation.


        Parameters
        ----------
        mx : Matrix3d
        """
    @staticmethod
    @typing.overload
    def SetRotate(mx) -> Matrix4d: ...
    @staticmethod
    @typing.overload
    def SetRotateOnly(rot) -> Matrix4d: 
        """
        SetRotateOnly(rot) -> Matrix4d


        Sets the matrix to specify a rotation equivalent to *rot*, without
        clearing the translation.


        Parameters
        ----------
        rot : Quatd



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*, without
        clearing the translation.


        Parameters
        ----------
        rot : Rotation



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *mx*, without
        clearing the translation.


        Parameters
        ----------
        mx : Matrix3d
        """
    @staticmethod
    @typing.overload
    def SetRotateOnly(mx) -> Matrix4d: ...
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec4.


        Parameters
        ----------
        i : int

        v : Vec4d
        """
    @staticmethod
    def SetRow3(i, v) -> None: 
        """
        SetRow3(i, v) -> None


        Sets a row of the matrix from a Vec3.


        The fourth element of the row is ignored.


        Parameters
        ----------
        i : int

        v : Vec3d
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactors) -> Matrix4d: 
        """
        SetScale(scaleFactors) -> Matrix4d


        Sets the matrix to specify a nonuniform scaling in x, y, and z by the
        factors in vector *scaleFactors*.


        Parameters
        ----------
        scaleFactors : Vec3d



        ----------------------------------------------------------------------


        Sets matrix to specify a uniform scaling by *scaleFactor*.


        Parameters
        ----------
        scaleFactor : float
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactor) -> Matrix4d: ...
    @staticmethod
    @typing.overload
    def SetTransform(rotate, translate) -> Matrix4d: 
        """
        SetTransform(rotate, translate) -> Matrix4d


        Sets matrix to specify a rotation by *rotate* and a translation by
        *translate*.


        Parameters
        ----------
        rotate : Rotation

        translate : Vec3d



        ----------------------------------------------------------------------


        Sets matrix to specify a rotation by *rotmx* and a translation by
        *translate*.


        Parameters
        ----------
        rotmx : Matrix3d

        translate : Vec3d
        """
    @staticmethod
    @typing.overload
    def SetTransform(rotmx, translate) -> Matrix4d: ...
    @staticmethod
    def SetTranslate(trans) -> Matrix4d: 
        """
        SetTranslate(trans) -> Matrix4d


        Sets matrix to specify a translation by the vector *trans*, and clears
        the rotation.


        Parameters
        ----------
        trans : Vec3d
        """
    @staticmethod
    def SetTranslateOnly(t) -> Matrix4d: 
        """
        SetTranslateOnly(t) -> Matrix4d


        Sets matrix to specify a translation by the vector *trans*, without
        clearing the rotation.


        Parameters
        ----------
        t : Vec3d
        """
    @staticmethod
    def SetZero() -> Matrix4d: 
        """
        SetZero() -> Matrix4d


        Sets the matrix to zero.
        """
    @staticmethod
    @typing.overload
    def Transform(vec) -> Vec3d: 
        """
        Transform(vec) -> Vec3d


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1.


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1. This is an overloaded method; it differs from the other version
        in that it returns a different value type.


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def Transform(vec) -> Vec3f: ...
    @staticmethod
    @typing.overload
    def TransformAffine(vec) -> Vec3d: 
        """
        TransformAffine(vec) -> Vec3d


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1 and ignores the fourth column of the matrix (i.e. assumes it is
        (0, 0, 0, 1)).


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1 and ignores the fourth column of the matrix (i.e. assumes it is
        (0, 0, 0, 1)).


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def TransformAffine(vec) -> Vec3f: ...
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3d: 
        """
        TransformDir(vec) -> Vec3d


        Transforms row vector *vec* by the matrix, returning the result.


        This treats the vector as a direction vector, so the translation
        information in the matrix is ignored. That is, it treats the vector as
        a 4-component vector whose fourth component is 0.


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms row vector *vec* by the matrix, returning the result.


        This treats the vector as a direction vector, so the translation
        information in the matrix is ignored. That is, it treats the vector as
        a 4-component vector whose fourth component is 0. This is an
        overloaded method; it differs from the other version in that it
        returns a different value type.


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3f: ...
    __safe_for_unpickling__ = True
    dimension = (4, 4)
    pass
class Matrix4f(Boost.Python.instance):
    @staticmethod
    def ExtractRotation() -> Rotation: 
        """
        ExtractRotation() -> Rotation


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractRotationMatrix() -> Matrix3f: 
        """
        ExtractRotationMatrix() -> Matrix3f


        Returns the rotation corresponding to this matrix.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractRotationQuat() -> Quatf: 
        """
        ExtractRotationQuat() -> Quatf


        Return the rotation corresponding to this matrix as a quaternion.


        This works well only if the matrix represents a rotation.

        For good results, consider calling Orthonormalize() before calling
        this method.
        """
    @staticmethod
    def ExtractTranslation() -> Vec3f: 
        """
        ExtractTranslation() -> Vec3f


        Returns the translation part of the matrix, defined as the first three
        elements of the last row.
        """
    @staticmethod
    def Factor(r, s, u, t, p, eps) -> bool: 
        """
        Factor(r, s, u, t, p, eps) -> bool


        Factors the matrix into 5 components:



           - ``*M* = r \* s \* -r \* u \* t`` where

           - *t* is a translation.

           - *u* and *r* are rotations, and *-r* is the transpose (inverse) of
             *r*. The *u* matrix may contain shear information.

           - *s* is a scale. Any projection information could be returned in
             matrix *p*, but currently p is never modified.
             Returns ``false`` if the matrix is singular (as determined by *eps*).
             In that case, any zero scales in *s* are clamped to *eps* to allow
             computation of *u*.


        Parameters
        ----------
        r : Matrix4f

        s : Vec3f

        u : Matrix4f

        t : Vec3f

        p : Matrix4f

        eps : float
        """
    @staticmethod
    def GetColumn(i) -> Vec4f: 
        """
        GetColumn(i) -> Vec4f


        Gets a column of the matrix as a Vec4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDeterminant() -> float: 
        """
        GetDeterminant() -> float


        Returns the determinant of the matrix.
        """
    @staticmethod
    def GetDeterminant3() -> float: 
        """
        GetDeterminant3() -> float


        Returns the determinant of the upper 3x3 matrix.


        This method is useful when the matrix describes a linear
        transformation such as a rotation or scale because the other values in
        the 4x4 matrix are not important.
        """
    @staticmethod
    def GetHandedness() -> float: 
        """
        GetHandedness() -> float


        Returns the sign of the determinant of the upper 3x3 matrix, i.e.


        1 for a right-handed matrix, -1 for a left-handed matrix, and 0 for a
        singular matrix.
        """
    @staticmethod
    def GetInverse(det, eps) -> Matrix4f: 
        """
        GetInverse(det, eps) -> Matrix4f


        Returns the inverse of the matrix, or FLT_MAX \* SetIdentity() if the
        matrix is singular.


        (FLT_MAX is the largest value a ``float`` can have, as defined by the
        system.) The matrix is considered singular if the determinant is less
        than or equal to the optional parameter *eps*. If *det* is non-null,
        ``\*det`` is set to the determinant.


        Parameters
        ----------
        det : float

        eps : float
        """
    @staticmethod
    def GetOrthonormalized(issueWarning) -> Matrix4f: 
        """
        GetOrthonormalized(issueWarning) -> Matrix4f


        Returns an orthonormalized copy of the matrix.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def GetRow(i) -> Vec4f: 
        """
        GetRow(i) -> Vec4f


        Gets a row of the matrix as a Vec4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetRow3(i) -> Vec3f: 
        """
        GetRow3(i) -> Vec3f


        Gets a row of the matrix as a Vec3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetTranspose() -> Matrix4f: 
        """
        GetTranspose() -> Matrix4f


        Returns the transpose of the matrix.
        """
    @staticmethod
    def HasOrthogonalRows3() -> bool: 
        """
        HasOrthogonalRows3() -> bool


        Returns true, if the row vectors of the upper 3x3 matrix form an
        orthogonal basis.


        Note they do not have to be unit length for this test to return true.
        """
    @staticmethod
    def IsLeftHanded() -> bool: 
        """
        IsLeftHanded() -> bool


        Returns true if the vectors in the upper 3x3 matrix form a left-handed
        coordinate system.
        """
    @staticmethod
    def IsRightHanded() -> bool: 
        """
        IsRightHanded() -> bool


        Returns true if the vectors in the upper 3x3 matrix form a right-
        handed coordinate system.
        """
    @staticmethod
    def Orthonormalize(issueWarning) -> bool: 
        """
        Orthonormalize(issueWarning) -> bool


        Makes the matrix orthonormal in place.


        This is an iterative method that is much more stable than the previous
        cross/cross method. If the iterative method does not converge, a
        warning is issued.

        Returns true if the iteration converged, false otherwise. Leaves any
        translation part of the matrix unchanged. If *issueWarning* is true,
        this method will issue a warning if the iteration does not converge,
        otherwise it will be silent.


        Parameters
        ----------
        issueWarning : bool
        """
    @staticmethod
    def RemoveScaleShear() -> Matrix4f: 
        """
        RemoveScaleShear() -> Matrix4f


        Returns the matrix with any scaling or shearing removed, leaving only
        the rotation and translation.


        If the matrix cannot be decomposed, returns the original matrix.
        """
    @staticmethod
    @typing.overload
    def Set(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) -> Matrix4f: 
        """
        Set(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) -> Matrix4f


        Sets the matrix from 16 independent ``float`` values, specified in
        row-major order.


        For example, parameter *m10* specifies the value in row1 and column 0.


        Parameters
        ----------
        m00 : float

        m01 : float

        m02 : float

        m03 : float

        m10 : float

        m11 : float

        m12 : float

        m13 : float

        m20 : float

        m21 : float

        m22 : float

        m23 : float

        m30 : float

        m31 : float

        m32 : float

        m33 : float



        ----------------------------------------------------------------------


        Sets the matrix from a 4x4 array of ``float`` values, specified in
        row-major order.


        Parameters
        ----------
        m : float
        """
    @staticmethod
    @typing.overload
    def Set(m) -> Matrix4f: ...
    @staticmethod
    def SetColumn(i, v) -> None: 
        """
        SetColumn(i, v) -> None


        Sets a column of the matrix from a Vec4.


        Parameters
        ----------
        i : int

        v : Vec4f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(s) -> Matrix4f: 
        """
        SetDiagonal(s) -> Matrix4f


        Sets the matrix to *s* times the identity matrix.


        Parameters
        ----------
        s : float



        ----------------------------------------------------------------------


        Sets the matrix to have diagonal ( ``v[0], v[1], v[2], v[3]`` ).


        Parameters
        ----------
        arg1 : Vec4f
        """
    @staticmethod
    @typing.overload
    def SetDiagonal(arg1) -> Matrix4f: ...
    @staticmethod
    def SetIdentity() -> Matrix4f: 
        """
        SetIdentity() -> Matrix4f


        Sets the matrix to the identity matrix.
        """
    @staticmethod
    @typing.overload
    def SetLookAt(eyePoint, centerPoint, upDirection) -> Matrix4f: 
        """
        SetLookAt(eyePoint, centerPoint, upDirection) -> Matrix4f


        Sets the matrix to specify a viewing matrix from parameters similar to
        those used by ``gluLookAt(3G)`` .


        *eyePoint* represents the eye point in world space. *centerPoint*
        represents the world-space center of attention. *upDirection* is a
        vector indicating which way is up.


        Parameters
        ----------
        eyePoint : Vec3f

        centerPoint : Vec3f

        upDirection : Vec3f



        ----------------------------------------------------------------------


        Sets the matrix to specify a viewing matrix from a world-space
        *eyePoint* and a world-space rotation that rigidly rotates the
        orientation from its canonical frame, which is defined to be looking
        along the ``-z`` axis with the ``+y`` axis as the up direction.


        Parameters
        ----------
        eyePoint : Vec3f

        orientation : Rotation
        """
    @staticmethod
    @typing.overload
    def SetLookAt(eyePoint, orientation) -> Matrix4f: ...
    @staticmethod
    @typing.overload
    def SetRotate(rot) -> Matrix4f: 
        """
        SetRotate(rot) -> Matrix4f


        Sets the matrix to specify a rotation equivalent to *rot*, and clears
        the translation.


        Parameters
        ----------
        rot : Quatf



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*, and clears
        the translation.


        Parameters
        ----------
        rot : Rotation



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *mx*, and clears
        the translation.


        Parameters
        ----------
        mx : Matrix3f
        """
    @staticmethod
    @typing.overload
    def SetRotate(mx) -> Matrix4f: ...
    @staticmethod
    @typing.overload
    def SetRotateOnly(rot) -> Matrix4f: 
        """
        SetRotateOnly(rot) -> Matrix4f


        Sets the matrix to specify a rotation equivalent to *rot*, without
        clearing the translation.


        Parameters
        ----------
        rot : Quatf



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *rot*, without
        clearing the translation.


        Parameters
        ----------
        rot : Rotation



        ----------------------------------------------------------------------


        Sets the matrix to specify a rotation equivalent to *mx*, without
        clearing the translation.


        Parameters
        ----------
        mx : Matrix3f
        """
    @staticmethod
    @typing.overload
    def SetRotateOnly(mx) -> Matrix4f: ...
    @staticmethod
    def SetRow(i, v) -> None: 
        """
        SetRow(i, v) -> None


        Sets a row of the matrix from a Vec4.


        Parameters
        ----------
        i : int

        v : Vec4f
        """
    @staticmethod
    def SetRow3(i, v) -> None: 
        """
        SetRow3(i, v) -> None


        Sets a row of the matrix from a Vec3.


        The fourth element of the row is ignored.


        Parameters
        ----------
        i : int

        v : Vec3f
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactors) -> Matrix4f: 
        """
        SetScale(scaleFactors) -> Matrix4f


        Sets the matrix to specify a nonuniform scaling in x, y, and z by the
        factors in vector *scaleFactors*.


        Parameters
        ----------
        scaleFactors : Vec3f



        ----------------------------------------------------------------------


        Sets matrix to specify a uniform scaling by *scaleFactor*.


        Parameters
        ----------
        scaleFactor : float
        """
    @staticmethod
    @typing.overload
    def SetScale(scaleFactor) -> Matrix4f: ...
    @staticmethod
    @typing.overload
    def SetTransform(rotate, translate) -> Matrix4f: 
        """
        SetTransform(rotate, translate) -> Matrix4f


        Sets matrix to specify a rotation by *rotate* and a translation by
        *translate*.


        Parameters
        ----------
        rotate : Rotation

        translate : Vec3f



        ----------------------------------------------------------------------


        Sets matrix to specify a rotation by *rotmx* and a translation by
        *translate*.


        Parameters
        ----------
        rotmx : Matrix3f

        translate : Vec3f
        """
    @staticmethod
    @typing.overload
    def SetTransform(rotmx, translate) -> Matrix4f: ...
    @staticmethod
    def SetTranslate(trans) -> Matrix4f: 
        """
        SetTranslate(trans) -> Matrix4f


        Sets matrix to specify a translation by the vector *trans*, and clears
        the rotation.


        Parameters
        ----------
        trans : Vec3f
        """
    @staticmethod
    def SetTranslateOnly(t) -> Matrix4f: 
        """
        SetTranslateOnly(t) -> Matrix4f


        Sets matrix to specify a translation by the vector *trans*, without
        clearing the rotation.


        Parameters
        ----------
        t : Vec3f
        """
    @staticmethod
    def SetZero() -> Matrix4f: 
        """
        SetZero() -> Matrix4f


        Sets the matrix to zero.
        """
    @staticmethod
    @typing.overload
    def Transform(vec) -> Vec3d: 
        """
        Transform(vec) -> Vec3d


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1.


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1. This is an overloaded method; it differs from the other version
        in that it returns a different value type.


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def Transform(vec) -> Vec3f: ...
    @staticmethod
    @typing.overload
    def TransformAffine(vec) -> Vec3d: 
        """
        TransformAffine(vec) -> Vec3d


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1 and ignores the fourth column of the matrix (i.e. assumes it is
        (0, 0, 0, 1)).


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms the row vector *vec* by the matrix, returning the result.


        This treats the vector as a 4-component vector whose fourth component
        is 1 and ignores the fourth column of the matrix (i.e. assumes it is
        (0, 0, 0, 1)).


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def TransformAffine(vec) -> Vec3f: ...
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3d: 
        """
        TransformDir(vec) -> Vec3d


        Transforms row vector *vec* by the matrix, returning the result.


        This treats the vector as a direction vector, so the translation
        information in the matrix is ignored. That is, it treats the vector as
        a 4-component vector whose fourth component is 0.


        Parameters
        ----------
        vec : Vec3d



        ----------------------------------------------------------------------


        Transforms row vector *vec* by the matrix, returning the result.


        This treats the vector as a direction vector, so the translation
        information in the matrix is ignored. That is, it treats the vector as
        a 4-component vector whose fourth component is 0. This is an
        overloaded method; it differs from the other version in that it
        returns a different value type.


        Parameters
        ----------
        vec : Vec3f
        """
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3f: ...
    __safe_for_unpickling__ = True
    dimension = (4, 4)
    pass
class MultiInterval(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Add(i) -> None: 
        """
        Add(i) -> None


        Add the given interval to the multi-interval.


        Parameters
        ----------
        i : Interval



        ----------------------------------------------------------------------


        Add the given multi-interval to the multi-interval.


        Sets this object to the union of the two sets.


        Parameters
        ----------
        s : MultiInterval
        """
    @staticmethod
    @typing.overload
    def Add(s) -> None: ...
    @staticmethod
    def ArithmeticAdd(i) -> None: 
        """
        ArithmeticAdd(i) -> None


        Uses the given interval to extend the multi-interval in the interval
        arithmetic sense.


        Parameters
        ----------
        i : Interval
        """
    @staticmethod
    def Clear() -> None: 
        """
        Clear() -> None


        Clear the multi-interval.
        """
    @staticmethod
    def Contains(*args, **kwargs) -> None: 
        """
        Returns true if x is inside the multi-interval.

        Returns true if x is inside the multi-interval.

        Returns true if x is inside the multi-interval.
        """
    @staticmethod
    def GetBounds() -> Interval: 
        """
        GetBounds() -> Interval


        Returns an interval bounding the entire multi-interval.


        Returns an empty interval if the multi-interval is empty.
        """
    @staticmethod
    def GetComplement() -> MultiInterval: 
        """
        GetComplement() -> MultiInterval


        Return the complement of this set.
        """
    @staticmethod
    def GetFullInterval(*args, **kwargs) -> None: 
        """
        **classmethod** GetFullInterval() -> MultiInterval


        Returns the full interval (-inf, inf).
        """
    @staticmethod
    def GetSize() -> int: 
        """
        GetSize() -> int


        Returns the number of intervals in the set.
        """
    @staticmethod
    @typing.overload
    def Intersect(i) -> None: 
        """
        Intersect(i) -> None


        Parameters
        ----------
        i : Interval



        ----------------------------------------------------------------------


        Parameters
        ----------
        s : MultiInterval
        """
    @staticmethod
    @typing.overload
    def Intersect(s) -> None: ...
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns true if the multi-interval is empty.
        """
    @staticmethod
    @typing.overload
    def Remove(i) -> None: 
        """
        Remove(i) -> None


        Remove the given interval from this multi-interval.


        Parameters
        ----------
        i : Interval



        ----------------------------------------------------------------------


        Remove the given multi-interval from this multi-interval.


        Parameters
        ----------
        s : MultiInterval
        """
    @staticmethod
    @typing.overload
    def Remove(s) -> None: ...
    @property
    def bounds(self) -> None:
        """
        :type: None
        """
    @property
    def isEmpty(self) -> None:
        """
        :type: None
        """
    @property
    def size(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    pass
class Plane(Boost.Python.instance):
    @staticmethod
    def GetDistance(p) -> float: 
        """
        GetDistance(p) -> float


        Returns the distance of point ``from`` the plane.


        This distance will be positive if the point is on the side of the
        plane containing the normal.


        Parameters
        ----------
        p : Vec3d
        """
    @staticmethod
    def GetDistanceFromOrigin() -> float: 
        """
        GetDistanceFromOrigin() -> float


        Returns the distance of the plane from the origin.
        """
    @staticmethod
    def GetEquation() -> Vec4d: 
        """
        GetEquation() -> Vec4d


        Give the coefficients of the equation of the plane.


        Suitable to OpenGL calls to set the clipping plane.
        """
    @staticmethod
    def GetNormal() -> Vec3d: 
        """
        GetNormal() -> Vec3d


        Returns the unit-length normal vector of the plane.
        """
    @staticmethod
    @typing.overload
    def IntersectsPositiveHalfSpace(box) -> bool: 
        """
        IntersectsPositiveHalfSpace(box) -> bool


        Returns ``true`` if the given aligned bounding box is at least
        partially on the positive side (the one the normal points into) of the
        plane.


        Parameters
        ----------
        box : Range3d



        ----------------------------------------------------------------------


        Returns true if the given point is on the plane or within its positive
        half space.


        Parameters
        ----------
        pt : Vec3d
        """
    @staticmethod
    @typing.overload
    def IntersectsPositiveHalfSpace(pt) -> bool: ...
    @staticmethod
    def Project(p) -> Vec3d: 
        """
        Project(p) -> Vec3d


        Return the projection of ``p`` onto the plane.


        Parameters
        ----------
        p : Vec3d
        """
    @staticmethod
    def Reorient(p) -> None: 
        """
        Reorient(p) -> None


        Flip the plane normal (if necessary) so that ``p`` is in the positive
        halfspace.


        Parameters
        ----------
        p : Vec3d
        """
    @staticmethod
    @typing.overload
    def Set(normal, distanceToOrigin) -> None: 
        """
        Set(normal, distanceToOrigin) -> None


        Sets this to the plane perpendicular to ``normal`` and at ``distance``
        units from the origin.


        The passed-in normal is normalized to unit length first.


        Parameters
        ----------
        normal : Vec3d

        distanceToOrigin : float



        ----------------------------------------------------------------------


        This constructor sets this to the plane perpendicular to ``normal``
        and that passes through ``point`` .


        The passed-in normal is normalized to unit length first.


        Parameters
        ----------
        normal : Vec3d

        point : Vec3d



        ----------------------------------------------------------------------


        This constructor sets this to the plane that contains the three given
        points.


        The normal is constructed from the cross product of ( ``p1`` - ``p0``
        ) ( ``p2`` - ``p0`` ). Results are undefined if the points are
        collinear.


        Parameters
        ----------
        p0 : Vec3d

        p1 : Vec3d

        p2 : Vec3d



        ----------------------------------------------------------------------


        This method sets this to the plane given by the equation ``eqn`` [0]
        \* x + ``eqn`` [1] \* y + ``eqn`` [2] \* z + ``eqn`` [3] = 0.


        Parameters
        ----------
        eqn : Vec4d
        """
    @staticmethod
    @typing.overload
    def Set(normal, point) -> None: ...
    @staticmethod
    @typing.overload
    def Set(p0, p1, p2) -> None: ...
    @staticmethod
    @typing.overload
    def Set(eqn) -> None: ...
    @staticmethod
    def Transform(matrix) -> Plane: 
        """
        Transform(matrix) -> Plane


        Transforms the plane by the given matrix.


        Parameters
        ----------
        matrix : Matrix4d
        """
    @property
    def distanceFromOrigin(self) -> None:
        """
        :type: None
        """
    @property
    def normal(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 48
    pass
class Quatd(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> Quatd: 
        """
        GetConjugate() -> Quatd


        Return this quaternion's conjugate, which is the quaternion with the
        same real coefficient and negated imaginary coefficients.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> Quatd


        Return the identity quaternion, with real coefficient 1 and an
        imaginary coefficients all zero.
        """
    @staticmethod
    def GetImaginary() -> Vec3d: 
        """
        GetImaginary() -> Vec3d


        Return the imaginary coefficient.
        """
    @staticmethod
    def GetInverse() -> Quatd: 
        """
        GetInverse() -> Quatd


        Return this quaternion's inverse, or reciprocal.


        This is the quaternion's conjugate divided by it's squared length.
        """
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Return geometric length of this quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> Quatd: 
        """
        GetNormalized(eps) -> Quatd


        length of this quaternion is smaller than ``eps`` , return the
        identity quaternion.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetReal() -> float: 
        """
        GetReal() -> float


        Return the real coefficient.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> Quatd


        Return the zero quaternion, with real coefficient 0 and an imaginary
        coefficients all zero.
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes this quaternion in place to unit length, returning the
        length before normalization.


        If the length of this quaternion is smaller than ``eps`` , this sets
        the quaternion to identity.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    @typing.overload
    def SetImaginary(imaginary) -> None: 
        """
        SetImaginary(imaginary) -> None


        Set the imaginary coefficients.


        Parameters
        ----------
        imaginary : Vec3d



        ----------------------------------------------------------------------


        Set the imaginary coefficients.


        Parameters
        ----------
        i : float

        j : float

        k : float
        """
    @staticmethod
    @typing.overload
    def SetImaginary(i, j, k) -> None: ...
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Set the real coefficient.


        Parameters
        ----------
        real : float
        """
    @staticmethod
    def Transform(point) -> Vec3d: 
        """
        Transform(point) -> Vec3d


        Transform the GfVec3d point.


        If the quaternion is normalized, the transformation is a rotation.
        Given a GfQuatd q, q.Transform(point) is equivalent to: (q \*
        GfQuatd(0, point) \* q.GetInverse()).GetImaginary()

        but is more efficient.


        Parameters
        ----------
        point : Vec3d
        """
    @property
    def imaginary(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class Quaternion(Boost.Python.instance):
    """
    Quaternion class
    """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> Quaternion


        Returns the identity quaternion, which has a real part of 1 and an
        imaginary part of (0,0,0).
        """
    @staticmethod
    def GetImaginary() -> Vec3d: 
        """
        GetImaginary() -> Vec3d


        Returns the imaginary part of the quaternion.
        """
    @staticmethod
    def GetInverse() -> Quaternion: 
        """
        GetInverse() -> Quaternion


        Returns the inverse of this quaternion.
        """
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Returns geometric length of this quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> Quaternion: 
        """
        GetNormalized(eps) -> Quaternion


        Returns a normalized (unit-length) version of this quaternion.


        direction as this. If the length of this quaternion is smaller than
        ``eps`` , this returns the identity quaternion.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetReal() -> float: 
        """
        GetReal() -> float


        Returns the real part of the quaternion.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> Quaternion


        Returns the zero quaternion, which has a real part of 0 and an
        imaginary part of (0,0,0).
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes this quaternion in place to unit length, returning the
        length before normalization.


        If the length of this quaternion is smaller than ``eps`` , this sets
        the quaternion to identity.


        Parameters
        ----------
        eps : float
        """
    @property
    def imaginary(self) -> None:
        """
        type : None


        Sets the imaginary part of the quaternion.

        :type: None
        """
    @property
    def real(self) -> None:
        """
        type : None


        Sets the real part of the quaternion.

        :type: None
        """
    __instance_size__ = 48
    pass
class Quatf(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> Quatf: 
        """
        GetConjugate() -> Quatf


        Return this quaternion's conjugate, which is the quaternion with the
        same real coefficient and negated imaginary coefficients.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> Quatf


        Return the identity quaternion, with real coefficient 1 and an
        imaginary coefficients all zero.
        """
    @staticmethod
    def GetImaginary() -> Vec3f: 
        """
        GetImaginary() -> Vec3f


        Return the imaginary coefficient.
        """
    @staticmethod
    def GetInverse() -> Quatf: 
        """
        GetInverse() -> Quatf


        Return this quaternion's inverse, or reciprocal.


        This is the quaternion's conjugate divided by it's squared length.
        """
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Return geometric length of this quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> Quatf: 
        """
        GetNormalized(eps) -> Quatf


        length of this quaternion is smaller than ``eps`` , return the
        identity quaternion.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetReal() -> float: 
        """
        GetReal() -> float


        Return the real coefficient.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> Quatf


        Return the zero quaternion, with real coefficient 0 and an imaginary
        coefficients all zero.
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes this quaternion in place to unit length, returning the
        length before normalization.


        If the length of this quaternion is smaller than ``eps`` , this sets
        the quaternion to identity.


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    @typing.overload
    def SetImaginary(imaginary) -> None: 
        """
        SetImaginary(imaginary) -> None


        Set the imaginary coefficients.


        Parameters
        ----------
        imaginary : Vec3f



        ----------------------------------------------------------------------


        Set the imaginary coefficients.


        Parameters
        ----------
        i : float

        j : float

        k : float
        """
    @staticmethod
    @typing.overload
    def SetImaginary(i, j, k) -> None: ...
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Set the real coefficient.


        Parameters
        ----------
        real : float
        """
    @staticmethod
    def Transform(point) -> Vec3f: 
        """
        Transform(point) -> Vec3f


        Transform the GfVec3f point.


        If the quaternion is normalized, the transformation is a rotation.
        Given a GfQuatf q, q.Transform(point) is equivalent to: (q \*
        GfQuatf(0, point) \* q.GetInverse()).GetImaginary()

        but is more efficient.


        Parameters
        ----------
        point : Vec3f
        """
    @property
    def imaginary(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class Quath(Boost.Python.instance):
    @staticmethod
    def GetConjugate() -> Quath: 
        """
        GetConjugate() -> Quath


        Return this quaternion's conjugate, which is the quaternion with the
        same real coefficient and negated imaginary coefficients.
        """
    @staticmethod
    def GetIdentity(*args, **kwargs) -> None: 
        """
        **classmethod** GetIdentity() -> Quath


        Return the identity quaternion, with real coefficient 1 and an
        imaginary coefficients all zero.
        """
    @staticmethod
    def GetImaginary() -> Vec3h: 
        """
        GetImaginary() -> Vec3h


        Return the imaginary coefficient.
        """
    @staticmethod
    def GetInverse() -> Quath: 
        """
        GetInverse() -> Quath


        Return this quaternion's inverse, or reciprocal.


        This is the quaternion's conjugate divided by it's squared length.
        """
    @staticmethod
    def GetLength() -> GfHalf: 
        """
        GetLength() -> GfHalf


        Return geometric length of this quaternion.
        """
    @staticmethod
    def GetNormalized(eps) -> Quath: 
        """
        GetNormalized(eps) -> Quath


        length of this quaternion is smaller than ``eps`` , return the
        identity quaternion.


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def GetReal() -> GfHalf: 
        """
        GetReal() -> GfHalf


        Return the real coefficient.
        """
    @staticmethod
    def GetZero(*args, **kwargs) -> None: 
        """
        **classmethod** GetZero() -> Quath


        Return the zero quaternion, with real coefficient 0 and an imaginary
        coefficients all zero.
        """
    @staticmethod
    def Normalize(eps) -> GfHalf: 
        """
        Normalize(eps) -> GfHalf


        Normalizes this quaternion in place to unit length, returning the
        length before normalization.


        If the length of this quaternion is smaller than ``eps`` , this sets
        the quaternion to identity.


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    @typing.overload
    def SetImaginary(imaginary) -> None: 
        """
        SetImaginary(imaginary) -> None


        Set the imaginary coefficients.


        Parameters
        ----------
        imaginary : Vec3h



        ----------------------------------------------------------------------


        Set the imaginary coefficients.


        Parameters
        ----------
        i : GfHalf

        j : GfHalf

        k : GfHalf
        """
    @staticmethod
    @typing.overload
    def SetImaginary(i, j, k) -> None: ...
    @staticmethod
    def SetReal(real) -> None: 
        """
        SetReal(real) -> None


        Set the real coefficient.


        Parameters
        ----------
        real : GfHalf
        """
    @staticmethod
    def Transform(point) -> Vec3h: 
        """
        Transform(point) -> Vec3h


        Transform the GfVec3h point.


        If the quaternion is normalized, the transformation is a rotation.
        Given a GfQuath q, q.Transform(point) is equivalent to: (q \*
        GfQuath(0, point) \* q.GetInverse()).GetImaginary()

        but is more efficient.


        Parameters
        ----------
        point : Vec3h
        """
    @property
    def imaginary(self) -> None:
        """
        :type: None
        """
    @property
    def real(self) -> None:
        """
        :type: None
        """
    pass
class Range1d(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : float



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range1d
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : float
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range1d


        Returns a ``GfRange1d`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range1d

        b : Range1d
        """
    @staticmethod
    def GetMax() -> float: 
        """
        GetMax() -> float


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> float: 
        """
        GetMidpoint() -> float


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> float: 
        """
        GetMin() -> float


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetSize() -> float: 
        """
        GetSize() -> float


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range1d


        Returns the smallest ``GfRange1d`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range1d

        b : Range1d
        """
    @staticmethod
    def IntersectWith(b) -> Range1d: 
        """
        IntersectWith(b) -> Range1d


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range1d
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : float
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : float
        """
    @staticmethod
    def UnionWith(b) -> Range1d: 
        """
        UnionWith(b) -> Range1d


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range1d



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : float
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    dimension = 1
    pass
class Range1f(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : float



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range1f
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : float
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range1f


        Returns a ``GfRange1f`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range1f

        b : Range1f
        """
    @staticmethod
    def GetMax() -> float: 
        """
        GetMax() -> float


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> float: 
        """
        GetMidpoint() -> float


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> float: 
        """
        GetMin() -> float


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetSize() -> float: 
        """
        GetSize() -> float


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range1f


        Returns the smallest ``GfRange1f`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range1f

        b : Range1f
        """
    @staticmethod
    def IntersectWith(b) -> Range1f: 
        """
        IntersectWith(b) -> Range1f


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range1f
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : float
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : float
        """
    @staticmethod
    def UnionWith(b) -> Range1f: 
        """
        UnionWith(b) -> Range1f


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range1f



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : float
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 24
    dimension = 1
    pass
class Range2d(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : Vec2d



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range2d
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetCorner(i) -> Vec2d: 
        """
        GetCorner(i) -> Vec2d


        Returns the ith corner of the range, in the following order: SW, SE,
        NW, NE.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : Vec2d
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range2d


        Returns a ``GfRange2d`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range2d

        b : Range2d
        """
    @staticmethod
    def GetMax() -> Vec2d: 
        """
        GetMax() -> Vec2d


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> Vec2d: 
        """
        GetMidpoint() -> Vec2d


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> Vec2d: 
        """
        GetMin() -> Vec2d


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetQuadrant(i) -> Range2d: 
        """
        GetQuadrant(i) -> Range2d


        Returns the ith quadrant of the range, in the following order: SW, SE,
        NW, NE.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetSize() -> Vec2d: 
        """
        GetSize() -> Vec2d


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range2d


        Returns the smallest ``GfRange2d`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range2d

        b : Range2d
        """
    @staticmethod
    def IntersectWith(b) -> Range2d: 
        """
        IntersectWith(b) -> Range2d


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range2d
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : Vec2d
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : Vec2d
        """
    @staticmethod
    def UnionWith(b) -> Range2d: 
        """
        UnionWith(b) -> Range2d


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range2d



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Vec2d
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 48
    dimension = 2
    unitSquare: pxr.Gf.Range2d # value = Gf.Range2d(Gf.Vec2d(0.0, 0.0), Gf.Vec2d(1.0, 1.0))
    pass
class Range2f(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : Vec2f



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range2f
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetCorner(i) -> Vec2f: 
        """
        GetCorner(i) -> Vec2f


        Returns the ith corner of the range, in the following order: SW, SE,
        NW, NE.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : Vec2f
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range2f


        Returns a ``GfRange2f`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range2f

        b : Range2f
        """
    @staticmethod
    def GetMax() -> Vec2f: 
        """
        GetMax() -> Vec2f


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> Vec2f: 
        """
        GetMidpoint() -> Vec2f


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> Vec2f: 
        """
        GetMin() -> Vec2f


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetQuadrant(i) -> Range2f: 
        """
        GetQuadrant(i) -> Range2f


        Returns the ith quadrant of the range, in the following order: SW, SE,
        NW, NE.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetSize() -> Vec2f: 
        """
        GetSize() -> Vec2f


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range2f


        Returns the smallest ``GfRange2f`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range2f

        b : Range2f
        """
    @staticmethod
    def IntersectWith(b) -> Range2f: 
        """
        IntersectWith(b) -> Range2f


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range2f
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : Vec2f
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : Vec2f
        """
    @staticmethod
    def UnionWith(b) -> Range2f: 
        """
        UnionWith(b) -> Range2f


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range2f



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Vec2f
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    dimension = 2
    unitSquare: pxr.Gf.Range2f # value = Gf.Range2f(Gf.Vec2f(0.0, 0.0), Gf.Vec2f(1.0, 1.0))
    pass
class Range3d(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : Vec3d



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range3d
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetCorner(i) -> Vec3d: 
        """
        GetCorner(i) -> Vec3d


        Returns the ith corner of the range, in the following order: LDB, RDB,
        LUB, RUB, LDF, RDF, LUF, RUF.


        Where L/R is left/right, D/U is down/up, and B/F is back/front.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : Vec3d
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range3d


        Returns a ``GfRange3d`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range3d

        b : Range3d
        """
    @staticmethod
    def GetMax() -> Vec3d: 
        """
        GetMax() -> Vec3d


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> Vec3d: 
        """
        GetMidpoint() -> Vec3d


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> Vec3d: 
        """
        GetMin() -> Vec3d


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetOctant(i) -> Range3d: 
        """
        GetOctant(i) -> Range3d


        Returns the ith octant of the range, in the following order: LDB, RDB,
        LUB, RUB, LDF, RDF, LUF, RUF.


        Where L/R is left/right, D/U is down/up, and B/F is back/front.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetSize() -> Vec3d: 
        """
        GetSize() -> Vec3d


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range3d


        Returns the smallest ``GfRange3d`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range3d

        b : Range3d
        """
    @staticmethod
    def IntersectWith(b) -> Range3d: 
        """
        IntersectWith(b) -> Range3d


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range3d
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : Vec3d
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : Vec3d
        """
    @staticmethod
    def UnionWith(b) -> Range3d: 
        """
        UnionWith(b) -> Range3d


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range3d



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Vec3d
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 64
    dimension = 3
    unitCube: pxr.Gf.Range3d # value = Gf.Range3d(Gf.Vec3d(0.0, 0.0, 0.0), Gf.Vec3d(1.0, 1.0, 1.0))
    pass
class Range3f(Boost.Python.instance):
    @staticmethod
    @typing.overload
    def Contains(point) -> bool: 
        """
        Contains(point) -> bool


        Returns true if the ``point`` is located inside the range.


        As with all operations of this type, the range is assumed to include
        its extrema.


        Parameters
        ----------
        point : Vec3f



        ----------------------------------------------------------------------


        Returns true if the ``range`` is located entirely inside the range.


        As with all operations of this type, the ranges are assumed to include
        their extrema.


        Parameters
        ----------
        range : Range3f
        """
    @staticmethod
    @typing.overload
    def Contains(range) -> bool: ...
    @staticmethod
    def GetCorner(i) -> Vec3f: 
        """
        GetCorner(i) -> Vec3f


        Returns the ith corner of the range, in the following order: LDB, RDB,
        LUB, RUB, LDF, RDF, LUF, RUF.


        Where L/R is left/right, D/U is down/up, and B/F is back/front.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDistanceSquared(p) -> float: 
        """
        GetDistanceSquared(p) -> float


        Compute the squared distance from a point to the range.


        Parameters
        ----------
        p : Vec3f
        """
    @staticmethod
    def GetIntersection(*args, **kwargs) -> None: 
        """
        **classmethod** GetIntersection(a, b) -> Range3f


        Returns a ``GfRange3f`` that describes the intersection of ``a`` and
        ``b`` .


        Parameters
        ----------
        a : Range3f

        b : Range3f
        """
    @staticmethod
    def GetMax() -> Vec3f: 
        """
        GetMax() -> Vec3f


        Returns the maximum value of the range.
        """
    @staticmethod
    def GetMidpoint() -> Vec3f: 
        """
        GetMidpoint() -> Vec3f


        Returns the midpoint of the range, that is, 0.5\*(min+max).


        Note: this returns zero in the case of default-constructed ranges, or
        ranges set via SetEmpty() .
        """
    @staticmethod
    def GetMin() -> Vec3f: 
        """
        GetMin() -> Vec3f


        Returns the minimum value of the range.
        """
    @staticmethod
    def GetOctant(i) -> Range3f: 
        """
        GetOctant(i) -> Range3f


        Returns the ith octant of the range, in the following order: LDB, RDB,
        LUB, RUB, LDF, RDF, LUF, RUF.


        Where L/R is left/right, D/U is down/up, and B/F is back/front.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetSize() -> Vec3f: 
        """
        GetSize() -> Vec3f


        Returns the size of the range.
        """
    @staticmethod
    def GetUnion(*args, **kwargs) -> None: 
        """
        **classmethod** GetUnion(a, b) -> Range3f


        Returns the smallest ``GfRange3f`` which contains both ``a`` and ``b``
        .


        Parameters
        ----------
        a : Range3f

        b : Range3f
        """
    @staticmethod
    def IntersectWith(b) -> Range3f: 
        """
        IntersectWith(b) -> Range3f


        Modifies this range to hold its intersection with ``b`` and returns
        the result.


        Parameters
        ----------
        b : Range3f
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns whether the range is empty (max<min).
        """
    @staticmethod
    def SetEmpty() -> None: 
        """
        SetEmpty() -> None


        Sets the range to an empty interval.
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the maximum value of the range.


        Parameters
        ----------
        max : Vec3f
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the minimum value of the range.


        Parameters
        ----------
        min : Vec3f
        """
    @staticmethod
    def UnionWith(b) -> Range3f: 
        """
        UnionWith(b) -> Range3f


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Range3f



        ----------------------------------------------------------------------


        Extend ``this`` to include ``b`` .


        Parameters
        ----------
        b : Vec3f
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 40
    dimension = 3
    unitCube: pxr.Gf.Range3f # value = Gf.Range3f(Gf.Vec3f(0.0, 0.0, 0.0), Gf.Vec3f(1.0, 1.0, 1.0))
    pass
class Ray(Boost.Python.instance):
    @staticmethod
    def FindClosestPoint(point, rayDistance) -> Vec3d: 
        """
        FindClosestPoint(point, rayDistance) -> Vec3d


        Returns the point on the ray that is closest to ``point`` .


        If ``rayDistance`` is not ``None`` , it will be set to the parametric
        distance along the ray of the closest point.


        Parameters
        ----------
        point : Vec3d

        rayDistance : float
        """
    @staticmethod
    def GetPoint(distance) -> Vec3d: 
        """
        GetPoint(distance) -> Vec3d


        Returns the point that is ``distance`` units from the starting point
        along the direction vector, expressed in parametic distance.


        Parameters
        ----------
        distance : float
        """
    @staticmethod
    def Intersect(*args, **kwargs) -> typing.Any: 
        """
        Intersects the ray with the triangle formed by points p0,
        p1, and p2.  The first item in the tuple is true if the ray
        intersects the triangle. dist is the the parametric
        distance to the intersection point, the barycentric
        coordinates of the intersection point, and the front-facing
        flag. The barycentric coordinates are defined with respect
        to the three vertices taken in order.  The front-facing
        flag is True if the intersection hit the side of the
        triangle that is formed when the vertices are ordered
        counter-clockwise (right-hand rule).

        Barycentric coordinates are defined to sum to 1 and satisfy
        this relationsip:

            intersectionPoint = (barycentricCoords[0] * p0 +
                                 barycentricCoords[1] * p1 +
                                 barycentricCoords[2] * p2);
        ----------------------------------------------------------------------

        Intersects the ray with the Gf.Plane.  The first item in
        the returned tuple is true if the ray intersects the plane.
        dist is the parametric distance to the intersection point
        and frontfacing is true if the intersection is on the side
        of the plane toward which the plane's normal points.
        ----------------------------------------------------------------------

        Intersects the plane with an sphere. intersects is true if
        the ray intersects it at all within the sphere. If there is
        an intersection then enterDist and exitDist will be the
        parametric distances to the two intersection points.
        ----------------------------------------------------------------------

        Intersects the plane with an infinite cylinder. intersects
        is true if the ray intersects it at all within the
        sphere. If there is an intersection then enterDist and
        exitDist will be the parametric distances to the two
        intersection points.
        ----------------------------------------------------------------------

        Intersects the plane with an cylinder. intersects
        is true if the ray intersects it at all within the
        sphere. If there is an intersection then enterDist and
        exitDist will be the parametric distances to the two
        intersection points.
        ----------------------------------------------------------------------
        """
    @staticmethod
    def SetEnds(startPoint, endPoint) -> None: 
        """
        SetEnds(startPoint, endPoint) -> None


        Sets the ray by specifying a starting point and an ending point.


        Parameters
        ----------
        startPoint : Vec3d

        endPoint : Vec3d
        """
    @staticmethod
    def SetPointAndDirection(startPoint, direction) -> None: 
        """
        SetPointAndDirection(startPoint, direction) -> None


        Sets the ray by specifying a starting point and a direction.


        Parameters
        ----------
        startPoint : Vec3d

        direction : Vec3d
        """
    @staticmethod
    def Transform(matrix) -> Ray: 
        """
        Transform(matrix) -> Ray


        Transforms the ray by the given matrix.


        Parameters
        ----------
        matrix : Matrix4d
        """
    @property
    def direction(self) -> None:
        """
        type : Vec3d


        Returns the direction vector of the segment.


        This is not guaranteed to be unit length.

        :type: None
        """
    @property
    def startPoint(self) -> None:
        """
        type : Vec3d


        Returns the starting point of the segment.

        :type: None
        """
    __instance_size__ = 64
    pass
class Rect2i(Boost.Python.instance):
    @staticmethod
    def Contains(p) -> bool: 
        """
        Contains(p) -> bool


        Returns true if the specified point in the rectangle.


        Parameters
        ----------
        p : Vec2i
        """
    @staticmethod
    def GetArea() -> int: 
        """
        GetArea() -> int


        Return the area of the rectangle.
        """
    @staticmethod
    def GetCenter() -> Vec2i: 
        """
        GetCenter() -> Vec2i


        Returns the center point of the rectangle.
        """
    @staticmethod
    def GetHeight() -> int: 
        """
        GetHeight() -> int


        Returns the height of the rectangle.



        If the min and max y-coordinates are coincident, the height is one.
        """
    @staticmethod
    def GetIntersection(that) -> Rect2i: 
        """
        GetIntersection(that) -> Rect2i


        Computes the intersection of two rectangles.


        Parameters
        ----------
        that : Rect2i
        """
    @staticmethod
    def GetMax() -> Vec2i: 
        """
        GetMax() -> Vec2i


        Returns the max corner of the rectangle.
        """
    @staticmethod
    def GetMaxX() -> int: 
        """
        GetMaxX() -> int


        Return the X value of the max corner.
        """
    @staticmethod
    def GetMaxY() -> int: 
        """
        GetMaxY() -> int


        Return the Y value of the max corner.
        """
    @staticmethod
    def GetMin() -> Vec2i: 
        """
        GetMin() -> Vec2i


        Returns the min corner of the rectangle.
        """
    @staticmethod
    def GetMinX() -> int: 
        """
        GetMinX() -> int


        Return the X value of min corner.
        """
    @staticmethod
    def GetMinY() -> int: 
        """
        GetMinY() -> int


        Return the Y value of the min corner.
        """
    @staticmethod
    def GetNormalized() -> Rect2i: 
        """
        GetNormalized() -> Rect2i


        Returns a normalized rectangle, i.e.


        one that has a non-negative width and height.

        ``GetNormalized()`` swaps the min and max x-coordinates to ensure a
        non-negative width, and similarly for the y-coordinates.
        """
    @staticmethod
    def GetSize() -> Vec2i: 
        """
        GetSize() -> Vec2i


        Returns the size of the rectangle as a vector (width,height).
        """
    @staticmethod
    def GetUnion(that) -> Rect2i: 
        """
        GetUnion(that) -> Rect2i


        Computes the union of two rectangles.


        Parameters
        ----------
        that : Rect2i
        """
    @staticmethod
    def GetWidth() -> int: 
        """
        GetWidth() -> int


        Returns the width of the rectangle.



        If the min and max x-coordinates are coincident, the width is one.
        """
    @staticmethod
    def IsEmpty() -> bool: 
        """
        IsEmpty() -> bool


        Returns true if the rectangle is empty.


        An empty rectangle has one or both of its min coordinates strictly
        greater than the corresponding max coordinate.

        An empty rectangle is not valid.
        """
    @staticmethod
    def IsNull() -> bool: 
        """
        IsNull() -> bool


        Returns true if the rectangle is a null rectangle.


        A null rectangle has both the width and the height set to 0, that is

        .. code-block:: text

          GetMaxX() == GetMinX() - 1

         and

        .. code-block:: text

          GetMaxY() == GetMinY() - 1

         Remember that if ``GetMinX()`` and ``GetMaxX()`` return the same
        value then the rectangle has width 1, and similarly for the height.

        A null rectangle is both empty, and not valid.
        """
    @staticmethod
    def IsValid() -> bool: 
        """
        IsValid() -> bool


        Return true if the rectangle is valid (equivalently, not empty).
        """
    @staticmethod
    def SetMax(max) -> None: 
        """
        SetMax(max) -> None


        Sets the max corner of the rectangle.


        Parameters
        ----------
        max : Vec2i
        """
    @staticmethod
    def SetMaxX(x) -> None: 
        """
        SetMaxX(x) -> None


        Set the X value of the max corner.


        Parameters
        ----------
        x : int
        """
    @staticmethod
    def SetMaxY(y) -> None: 
        """
        SetMaxY(y) -> None


        Set the Y value of the max corner.


        Parameters
        ----------
        y : int
        """
    @staticmethod
    def SetMin(min) -> None: 
        """
        SetMin(min) -> None


        Sets the min corner of the rectangle.


        Parameters
        ----------
        min : Vec2i
        """
    @staticmethod
    def SetMinX(x) -> None: 
        """
        SetMinX(x) -> None


        Set the X value of the min corner.


        Parameters
        ----------
        x : int
        """
    @staticmethod
    def SetMinY(y) -> None: 
        """
        SetMinY(y) -> None


        Set the Y value of the min corner.


        Parameters
        ----------
        y : int
        """
    @staticmethod
    def Translate(displacement) -> None: 
        """
        Translate(displacement) -> None


        Move the rectangle by ``displ`` .


        Parameters
        ----------
        displacement : Vec2i
        """
    @property
    def max(self) -> None:
        """
        :type: None
        """
    @property
    def maxX(self) -> None:
        """
        :type: None
        """
    @property
    def maxY(self) -> None:
        """
        :type: None
        """
    @property
    def min(self) -> None:
        """
        :type: None
        """
    @property
    def minX(self) -> None:
        """
        :type: None
        """
    @property
    def minY(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    pass
class Rotation(Boost.Python.instance):
    """
    3-space rotation
    """
    @staticmethod
    def Decompose(axis0, axis1, axis2) -> Vec3d: 
        """
        Decompose(axis0, axis1, axis2) -> Vec3d


        Decompose rotation about 3 orthogonal axes.


        If the axes are not orthogonal, warnings will be spewed.


        Parameters
        ----------
        axis0 : Vec3d

        axis1 : Vec3d

        axis2 : Vec3d
        """
    @staticmethod
    def DecomposeRotation(*args, **kwargs) -> None: 
        """
        **classmethod** DecomposeRotation(rot, TwAxis, FBAxis, LRAxis, handedness, thetaTw, thetaFB, thetaLR, thetaSw, useHint, swShift) -> None


        Parameters
        ----------
        rot : Matrix4d

        TwAxis : Vec3d

        FBAxis : Vec3d

        LRAxis : Vec3d

        handedness : float

        thetaTw : float

        thetaFB : float

        thetaLR : float

        thetaSw : float

        useHint : bool

        swShift : float
        """
    @staticmethod
    def DecomposeRotation3(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAngle() -> float: 
        """
        GetAngle() -> float


        Returns the rotation angle in degrees.
        """
    @staticmethod
    def GetAxis() -> Vec3d: 
        """
        GetAxis() -> Vec3d


        Returns the axis of rotation.
        """
    @staticmethod
    def GetInverse() -> Rotation: 
        """
        GetInverse() -> Rotation


        Returns the inverse of this rotation.
        """
    @staticmethod
    def GetQuat() -> Quatd: 
        """
        GetQuat() -> Quatd


        Returns the rotation expressed as a quaternion.
        """
    @staticmethod
    def GetQuaternion() -> Quaternion: 
        """
        GetQuaternion() -> Quaternion


        Returns the rotation expressed as a quaternion.
        """
    @staticmethod
    def MatchClosestEulerRotation(*args, **kwargs) -> None: 
        """
        **classmethod** MatchClosestEulerRotation(targetTw, targetFB, targetLR, targetSw, thetaTw, thetaFB, thetaLR, thetaSw) -> None


        Replace the hint angles with the closest rotation of the given
        rotation to the hint.


        Each angle in the rotation will be within Pi of the corresponding hint
        angle and the sum of the differences with the hint will be minimized.
        If a given rotation value is null then that angle will be treated as
        0.0 and ignored in the calculations.

        All angles are in radians. The rotation order is Tw/FB/LR/Sw.


        Parameters
        ----------
        targetTw : float

        targetFB : float

        targetLR : float

        targetSw : float

        thetaTw : float

        thetaFB : float

        thetaLR : float

        thetaSw : float
        """
    @staticmethod
    def RotateOntoProjected(*args, **kwargs) -> None: 
        """
        **classmethod** RotateOntoProjected(v1, v2, axis) -> Rotation


        Parameters
        ----------
        v1 : Vec3d

        v2 : Vec3d

        axis : Vec3d
        """
    @staticmethod
    def SetAxisAngle(axis, angle) -> Rotation: 
        """
        SetAxisAngle(axis, angle) -> Rotation


        Sets the rotation to be ``angle`` degrees about ``axis`` .


        Parameters
        ----------
        axis : Vec3d

        angle : float
        """
    @staticmethod
    def SetIdentity() -> Rotation: 
        """
        SetIdentity() -> Rotation


        Sets the rotation to an identity rotation.


        (This is chosen to be 0 degrees around the positive X axis.)
        """
    @staticmethod
    def SetQuat(quat) -> Rotation: 
        """
        SetQuat(quat) -> Rotation


        Sets the rotation from a quaternion.


        Note that this method accepts GfQuatf and GfQuath since they
        implicitly convert to GfQuatd.


        Parameters
        ----------
        quat : Quatd
        """
    @staticmethod
    def SetQuaternion(quat) -> Rotation: 
        """
        SetQuaternion(quat) -> Rotation


        Sets the rotation from a quaternion.


        Parameters
        ----------
        quat : Quaternion
        """
    @staticmethod
    def SetRotateInto(rotateFrom, rotateTo) -> Rotation: 
        """
        SetRotateInto(rotateFrom, rotateTo) -> Rotation


        Sets the rotation to one that brings the ``rotateFrom`` vector to
        align with ``rotateTo`` .


        The passed vectors need not be unit length.


        Parameters
        ----------
        rotateFrom : Vec3d

        rotateTo : Vec3d
        """
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3f: 
        """
        TransformDir(vec) -> Vec3f


        Transforms row vector ``vec`` by the rotation, returning the result.


        Parameters
        ----------
        vec : Vec3f



        ----------------------------------------------------------------------


        This is an overloaded member function, provided for convenience. It
        differs from the above function only in what argument(s) it accepts.


        Parameters
        ----------
        vec : Vec3d
        """
    @staticmethod
    @typing.overload
    def TransformDir(vec) -> Vec3d: ...
    @property
    def angle(self) -> None:
        """
        :type: None
        """
    @property
    def axis(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 48
    pass
class Size2(Boost.Python.instance):
    """
    A 2D size class
    """
    @staticmethod
    @typing.overload
    def Set(v) -> Size2: 
        """
        Set(v) -> Size2


        Set to the values in a given array.


        Parameters
        ----------
        v : int



        ----------------------------------------------------------------------


        Set to values passed directly.


        Parameters
        ----------
        v0 : int

        v1 : int
        """
    @staticmethod
    @typing.overload
    def Set(v0, v1) -> Size2: ...
    __instance_size__ = 32
    dimension = 2
    pass
class Size3(Boost.Python.instance):
    """
    A 3D size class
    """
    @staticmethod
    @typing.overload
    def Set(v) -> Size3: 
        """
        Set(v) -> Size3


        Set to the values in ``v`` .


        Parameters
        ----------
        v : int



        ----------------------------------------------------------------------


        Set to values passed directly.


        Parameters
        ----------
        v0 : int

        v1 : int

        v2 : int
        """
    @staticmethod
    @typing.overload
    def Set(v0, v1, v2) -> Size3: ...
    __instance_size__ = 40
    dimension = 3
    pass
class Transform(Boost.Python.instance):
    @staticmethod
    def GetMatrix() -> Matrix4d: 
        """
        GetMatrix() -> Matrix4d


        Returns a ``GfMatrix4d`` that implements the cumulative
        transformation.
        """
    @staticmethod
    def GetPivotOrientation() -> Rotation: 
        """
        GetPivotOrientation() -> Rotation


        Returns the pivot orientation component.
        """
    @staticmethod
    def GetPivotPosition() -> Vec3d: 
        """
        GetPivotPosition() -> Vec3d


        Returns the pivot position component.
        """
    @staticmethod
    def GetRotation() -> Rotation: 
        """
        GetRotation() -> Rotation


        Returns the rotation component.
        """
    @staticmethod
    def GetScale() -> Vec3d: 
        """
        GetScale() -> Vec3d


        Returns the scale component.
        """
    @staticmethod
    def GetTranslation() -> Vec3d: 
        """
        GetTranslation() -> Vec3d


        Returns the translation component.
        """
    @staticmethod
    def Set(*args, **kwargs) -> None: 
        """
        Set method used by old 2x code. (Deprecated)
        """
    @staticmethod
    def SetIdentity() -> Transform: 
        """
        SetIdentity() -> Transform


        Sets the transformation to the identity transformation.
        """
    @staticmethod
    def SetMatrix(m) -> Transform: 
        """
        SetMatrix(m) -> Transform


        Sets the transform components to implement the transformation
        represented by matrix ``m`` , ignoring any projection.


        This tries to leave the current center unchanged.


        Parameters
        ----------
        m : Matrix4d
        """
    @staticmethod
    def SetPivotOrientation(pivotOrient) -> None: 
        """
        SetPivotOrientation(pivotOrient) -> None


        Sets the pivot orientation component, leaving all others untouched.


        Parameters
        ----------
        pivotOrient : Rotation
        """
    @staticmethod
    def SetPivotPosition(pivPos) -> None: 
        """
        SetPivotPosition(pivPos) -> None


        Sets the pivot position component, leaving all others untouched.


        Parameters
        ----------
        pivPos : Vec3d
        """
    @staticmethod
    def SetRotation(rotation) -> None: 
        """
        SetRotation(rotation) -> None


        Sets the rotation component, leaving all others untouched.


        Parameters
        ----------
        rotation : Rotation
        """
    @staticmethod
    def SetScale(scale) -> None: 
        """
        SetScale(scale) -> None


        Sets the scale component, leaving all others untouched.


        Parameters
        ----------
        scale : Vec3d
        """
    @staticmethod
    def SetTranslation(translation) -> None: 
        """
        SetTranslation(translation) -> None


        Sets the translation component, leaving all others untouched.


        Parameters
        ----------
        translation : Vec3d
        """
    @property
    def pivotOrientation(self) -> None:
        """
        :type: None
        """
    @property
    def pivotPosition(self) -> None:
        """
        :type: None
        """
    @property
    def rotation(self) -> None:
        """
        :type: None
        """
    @property
    def scale(self) -> None:
        """
        :type: None
        """
    @property
    def translation(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 152
    pass
class Vec2d(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec2d


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec2d: 
        """
        GetComplement(b) -> Vec2d


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec2d
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec2d: 
        """
        GetNormalized(eps) -> Vec2d


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec2d: 
        """
        GetProjection(v) -> Vec2d


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec2d
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec2d


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec2d


        Create a unit vector along the Y-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 2
    pass
class Vec2f(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec2f


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec2f: 
        """
        GetComplement(b) -> Vec2f


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec2f
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec2f: 
        """
        GetNormalized(eps) -> Vec2f


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec2f: 
        """
        GetProjection(v) -> Vec2f


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec2f
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec2f


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec2f


        Create a unit vector along the Y-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 2
    pass
class Vec2h(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec2h


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec2h: 
        """
        GetComplement(b) -> Vec2h


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec2h
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> GfHalf: 
        """
        GetLength() -> GfHalf


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec2h: 
        """
        GetNormalized(eps) -> Vec2h


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def GetProjection(v) -> Vec2h: 
        """
        GetProjection(v) -> Vec2h


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec2h
        """
    @staticmethod
    def Normalize(eps) -> GfHalf: 
        """
        Normalize(eps) -> GfHalf


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec2h


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec2h


        Create a unit vector along the Y-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 2
    pass
class Vec2i(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec2i


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 2.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec2i


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec2i


        Create a unit vector along the Y-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 2
    pass
class Vec3d(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec3d


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def BuildOrthonormalFrame(v1, v2, eps) -> None: 
        """
        BuildOrthonormalFrame(v1, v2, eps) -> None


        Sets ``v1`` and ``v2`` to unit vectors such that v1, v2 and \*this
        are mutually orthogonal.


        If the length L of \*this is smaller than ``eps`` , then v1 and v2
        will have magnitude L/eps. As a result, the function delivers a
        continuous result as \*this shrinks in length.


        Parameters
        ----------
        v1 : Vec3d

        v2 : Vec3d

        eps : float
        """
    @staticmethod
    def GetComplement(b) -> Vec3d: 
        """
        GetComplement(b) -> Vec3d


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec3d
        """
    @staticmethod
    def GetCross(*args, **kwargs) -> None: ...
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec3d: 
        """
        GetNormalized(eps) -> Vec3d


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec3d: 
        """
        GetProjection(v) -> Vec3d


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec3d
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def OrthogonalizeBasis(*args, **kwargs) -> None: 
        """
        **classmethod** OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool


        Orthogonalize and optionally normalize a set of basis vectors.


        This uses an iterative method that is very stable even when the
        vectors are far from orthogonal (close to colinear). The number of
        iterations and thus the computation time does increase as the vectors
        become close to colinear, however. Returns a bool specifying whether
        the solution converged after a number of iterations. If it did not
        converge, the returned vectors will be as close as possible to
        orthogonal within the iteration limit. Colinear vectors will be
        unaltered, and the method will return false.


        Parameters
        ----------
        tx : Vec3d

        ty : Vec3d

        tz : Vec3d

        normalize : bool

        eps : float
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec3d


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec3d


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec3d


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 3
    pass
class Vec3f(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec3f


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def BuildOrthonormalFrame(v1, v2, eps) -> None: 
        """
        BuildOrthonormalFrame(v1, v2, eps) -> None


        Sets ``v1`` and ``v2`` to unit vectors such that v1, v2 and \*this
        are mutually orthogonal.


        If the length L of \*this is smaller than ``eps`` , then v1 and v2
        will have magnitude L/eps. As a result, the function delivers a
        continuous result as \*this shrinks in length.


        Parameters
        ----------
        v1 : Vec3f

        v2 : Vec3f

        eps : float
        """
    @staticmethod
    def GetComplement(b) -> Vec3f: 
        """
        GetComplement(b) -> Vec3f


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec3f
        """
    @staticmethod
    def GetCross(*args, **kwargs) -> None: ...
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec3f: 
        """
        GetNormalized(eps) -> Vec3f


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec3f: 
        """
        GetProjection(v) -> Vec3f


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec3f
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def OrthogonalizeBasis(*args, **kwargs) -> None: 
        """
        **classmethod** OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool


        Orthogonalize and optionally normalize a set of basis vectors.


        This uses an iterative method that is very stable even when the
        vectors are far from orthogonal (close to colinear). The number of
        iterations and thus the computation time does increase as the vectors
        become close to colinear, however. Returns a bool specifying whether
        the solution converged after a number of iterations. If it did not
        converge, the returned vectors will be as close as possible to
        orthogonal within the iteration limit. Colinear vectors will be
        unaltered, and the method will return false.


        Parameters
        ----------
        tx : Vec3f

        ty : Vec3f

        tz : Vec3f

        normalize : bool

        eps : float
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec3f


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec3f


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec3f


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 3
    pass
class Vec3h(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec3h


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def BuildOrthonormalFrame(v1, v2, eps) -> None: 
        """
        BuildOrthonormalFrame(v1, v2, eps) -> None


        Sets ``v1`` and ``v2`` to unit vectors such that v1, v2 and \*this
        are mutually orthogonal.


        If the length L of \*this is smaller than ``eps`` , then v1 and v2
        will have magnitude L/eps. As a result, the function delivers a
        continuous result as \*this shrinks in length.


        Parameters
        ----------
        v1 : Vec3h

        v2 : Vec3h

        eps : GfHalf
        """
    @staticmethod
    def GetComplement(b) -> Vec3h: 
        """
        GetComplement(b) -> Vec3h


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec3h
        """
    @staticmethod
    def GetCross(*args, **kwargs) -> None: ...
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> GfHalf: 
        """
        GetLength() -> GfHalf


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec3h: 
        """
        GetNormalized(eps) -> Vec3h


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def GetProjection(v) -> Vec3h: 
        """
        GetProjection(v) -> Vec3h


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec3h
        """
    @staticmethod
    def Normalize(eps) -> GfHalf: 
        """
        Normalize(eps) -> GfHalf


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def OrthogonalizeBasis(*args, **kwargs) -> None: 
        """
        **classmethod** OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool


        Orthogonalize and optionally normalize a set of basis vectors.


        This uses an iterative method that is very stable even when the
        vectors are far from orthogonal (close to colinear). The number of
        iterations and thus the computation time does increase as the vectors
        become close to colinear, however. Returns a bool specifying whether
        the solution converged after a number of iterations. If it did not
        converge, the returned vectors will be as close as possible to
        orthogonal within the iteration limit. Colinear vectors will be
        unaltered, and the method will return false.


        Parameters
        ----------
        tx : Vec3h

        ty : Vec3h

        tz : Vec3h

        normalize : bool

        eps : float
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec3h


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec3h


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec3h


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 3
    pass
class Vec3i(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec3i


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 3.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec3i


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec3i


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec3i


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 3
    pass
class Vec4d(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec4d


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec4d: 
        """
        GetComplement(b) -> Vec4d


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec4d
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec4d: 
        """
        GetNormalized(eps) -> Vec4d


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec4d: 
        """
        GetProjection(v) -> Vec4d


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec4d
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def WAxis(*args, **kwargs) -> None: 
        """
        **classmethod** WAxis() -> Vec4d


        Create a unit vector along the W-axis.
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec4d


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec4d


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec4d


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 4
    pass
class Vec4f(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec4f


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec4f: 
        """
        GetComplement(b) -> Vec4f


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec4f
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> float: 
        """
        GetLength() -> float


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec4f: 
        """
        GetNormalized(eps) -> Vec4f


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def GetProjection(v) -> Vec4f: 
        """
        GetProjection(v) -> Vec4f


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec4f
        """
    @staticmethod
    def Normalize(eps) -> float: 
        """
        Normalize(eps) -> float


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : float
        """
    @staticmethod
    def WAxis(*args, **kwargs) -> None: 
        """
        **classmethod** WAxis() -> Vec4f


        Create a unit vector along the W-axis.
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec4f


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec4f


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec4f


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 4
    pass
class Vec4h(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec4h


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetComplement(b) -> Vec4h: 
        """
        GetComplement(b) -> Vec4h


        Returns the orthogonal complement of ``this->GetProjection(b)`` .


        That is:

        .. code-block:: text

          \*this - this->GetProjection(b)



        Parameters
        ----------
        b : Vec4h
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def GetLength() -> GfHalf: 
        """
        GetLength() -> GfHalf


        Length.
        """
    @staticmethod
    def GetNormalized(eps) -> Vec4h: 
        """
        GetNormalized(eps) -> Vec4h


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def GetProjection(v) -> Vec4h: 
        """
        GetProjection(v) -> Vec4h


        Returns the projection of ``this`` onto ``v`` .


        That is:

        .. code-block:: text

          v \* (\*this \* v)



        Parameters
        ----------
        v : Vec4h
        """
    @staticmethod
    def Normalize(eps) -> GfHalf: 
        """
        Normalize(eps) -> GfHalf


        Normalizes the vector in place to unit length, returning the length
        before normalization.


        If the length of the vector is smaller than ``eps`` , then the vector
        is set to vector/ ``eps`` . The original length of the vector is
        returned. See also GfNormalize() .


        Parameters
        ----------
        eps : GfHalf
        """
    @staticmethod
    def WAxis(*args, **kwargs) -> None: 
        """
        **classmethod** WAxis() -> Vec4h


        Create a unit vector along the W-axis.
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec4h


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec4h


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec4h


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 4
    pass
class Vec4i(Boost.Python.instance):
    @staticmethod
    def Axis(*args, **kwargs) -> None: 
        """
        **classmethod** Axis(i) -> Vec4i


        Create a unit vector along the i-th axis, zero-based.


        Return the zero vector if ``i`` is greater than or equal to 4.


        Parameters
        ----------
        i : int
        """
    @staticmethod
    def GetDot(*args, **kwargs) -> None: ...
    @staticmethod
    def WAxis(*args, **kwargs) -> None: 
        """
        **classmethod** WAxis() -> Vec4i


        Create a unit vector along the W-axis.
        """
    @staticmethod
    def XAxis(*args, **kwargs) -> None: 
        """
        **classmethod** XAxis() -> Vec4i


        Create a unit vector along the X-axis.
        """
    @staticmethod
    def YAxis(*args, **kwargs) -> None: 
        """
        **classmethod** YAxis() -> Vec4i


        Create a unit vector along the Y-axis.
        """
    @staticmethod
    def ZAxis(*args, **kwargs) -> None: 
        """
        **classmethod** ZAxis() -> Vec4i


        Create a unit vector along the Z-axis.
        """
    __isGfVec = True
    __safe_for_unpickling__ = True
    dimension = 4
    pass
def Abs(f) -> float:
    """
    Abs(f) -> float


    Return abs( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return abs( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Absf(f) -> float:
    """
    f : float

    Use instead of Abs() to return the absolute value of f as a float instead of a double.
    """
def ApplyGamma(*args, **kwargs) -> None:
    pass
def Ceil(f) -> float:
    """
    Ceil(f) -> float


    Return ceil( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return ceil( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Ceilf(f) -> float:
    """
    f : float

    Use instead of Ceil() to return the ceiling of f as a float instead of a double.
    """
def Clamp(value, min, max) -> float:
    """
    Clamp(value, min, max) -> float


    Return the resulting of clamping ``value`` to lie between ``min`` and
    ``max`` .


    This function is also defined for GfVecs.


    Parameters
    ----------
    value : float

    min : float

    max : float



    ----------------------------------------------------------------------


    This is an overloaded member function, provided for convenience. It
    differs from the above function only in what argument(s) it accepts.


    Parameters
    ----------
    value : float

    min : float

    max : float
    """
def Clampf(f) -> float:
    """
    f : float

    Use instead of Clamp() to return the clamped value of f as a float instead of a double.
    """
def CompDiv(left, right) -> decltype(declval[Left]()/declval[Right]()):
    """
    CompDiv(left, right) -> decltype(declval[Left]()/declval[Right]())


    Returns component-wise quotient of vectors.


    For scalar types, this is just the regular quotient.


    Parameters
    ----------
    left : Left

    right : Right
    """
def CompMult(*args, **kwargs) -> typing.Any:
    """
    CompMult(left, right) -> decltype(declval[Left]() declval[Right]())


    Returns component-wise multiplication of vectors.


    For scalar types, this is just the regular product.


    Parameters
    ----------
    left : Left

    right : Right
    """
def ConvertDisplayToLinear(*args, **kwargs) -> None:
    pass
def ConvertLinearToDisplay(*args, **kwargs) -> None:
    pass
def Cross(*args, **kwargs) -> None:
    pass
def DegreesToRadians(degrees) -> float:
    """
    DegreesToRadians(degrees) -> float


    Converts an angle in degrees to radians.


    Parameters
    ----------
    degrees : float
    """
def Dot(*args, **kwargs) -> typing.Any:
    """
    Dot(left, right) -> decltype(declval[Left]() declval[Right]())


    Returns the dot (inner) product of two vectors.


    For scalar types, this is just the regular product.


    Parameters
    ----------
    left : Left

    right : Right
    """
def Exp(f) -> float:
    """
    Exp(f) -> float


    Return exp( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return exp( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Expf(f) -> float:
    """
    f : float

    Use instead of Exp() to return the exponent of f as a float instead of a double.
    """
def FindClosestPoints(*args, **kwargs) -> typing.Any:
    """
    l1 : GfLine
    l2 : GfLine

    Computes the closest points between two lines, returning a tuple.  The first item in the tuple is true if the linesintersect.  The two points are returned in p1 and p2.  The parametric distance of each point on the lines is returned in t1 and t2.
    ----------------------------------------------------------------------

    l1 : GfLine
    s2 : GfLineSeg

    Computes the closest points between a line and a line segment, returning a tuple. The first item in the tuple is true if they intersect. The two points are returned in p1 and p2.  The parametric distance of each point on the line and line segment is returned in t1 and t2.
    ----------------------------------------------------------------------

    l1 : GfLineSeg
    l2 : GfLineSeg

    Computes the closest points between two line segments, returning a tuple.  The first item in the tuple is true if they intersect.  The two points are returned in p1 and p2.  The parametric distance of each point on the line and line segment is returned in t1 and t2.
    ----------------------------------------------------------------------

    r1 : GfRay
    l2 : GfLine

    Computes the closest points between a ray and a line,
    returning a tuple. The first item in the tuple is true if they intersect. The two points are returned in p1 and p2.
    The parametric distance of each point on the ray and line is
    returned in t1 and t2.
    ----------------------------------------------------------------------

    r1 : GfRay
    s2 : GfLineSeg

    Computes the closest points between a ray and a line segment,
    returning a tuple. The first item in the tuple is true if they intersect. The two points are returned in p1 and p2.
    The parametric distance of each point on the ray and line
    segment is returned in t1 and t2.
    ----------------------------------------------------------------------
    """
def FitPlaneToPoints(*args, **kwargs) -> None:
    pass
def Floor(f) -> float:
    """
    Floor(f) -> float


    Return floor( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return floor( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Floorf(f) -> float:
    """
    f : float

    Use instead of Floor() to return the floor of f as a float instead of a double.
    """
def GetComplement(*args, **kwargs) -> None:
    pass
def GetDisplayGamma(*args, **kwargs) -> None:
    pass
def GetHomogenized(v) -> Vec4f:
    """
    GetHomogenized(v) -> Vec4f


    Returns a vector which is ``v`` homogenized.


    If the fourth element of ``v`` is 0, it is set to 1.


    Parameters
    ----------
    v : Vec4f
    """
def GetLength(*args, **kwargs) -> None:
    pass
def GetNormalized(*args, **kwargs) -> None:
    pass
def GetProjection(*args, **kwargs) -> None:
    pass
@typing.overload
def HomogeneousCross(a, b) -> Vec4f:
    """
    HomogeneousCross(a, b) -> Vec4f


    Homogenizes ``a`` and ``b`` and then performs the cross product on the
    first three elements of each.


    Returns the cross product as a homogenized vector.


    Parameters
    ----------
    a : Vec4f

    b : Vec4f



    ----------------------------------------------------------------------


    Homogenizes ``a`` and ``b`` and then performs the cross product on the
    first three elements of each.


    Returns the cross product as a homogenized vector.


    Parameters
    ----------
    a : Vec4d

    b : Vec4d
    """
@typing.overload
def HomogeneousCross(a, b) -> Vec4d:
    pass
def IsClose(a, b, epsilon) -> bool:
    """
    IsClose(a, b, epsilon) -> bool


    Returns true if ``a`` and ``b`` are with ``epsilon`` of each other.


    Parameters
    ----------
    a : float

    b : float

    epsilon : float
    """
def Lerp(alpha, a, b) -> T:
    """
    Lerp(alpha, a, b) -> T


    Linear interpolation function.


    For any type that supports multiplication by a scalar and binary
    addition, returns

    .. code-block:: text

      (1-alpha) \* a + alpha \* b 



    Parameters
    ----------
    alpha : float

    a : T

    b : T
    """
def Lerpf(f) -> float:
    """
    f : float

    Use instead of Lerp() to return the linear interpolation of f as a float instead of a double.
    """
def Log(f) -> float:
    """
    Log(f) -> float


    Return log( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return log( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Logf(f) -> float:
    """
    f : float

    Use instead of Log() to return the logarithm of f as a float instead of a double.
    """
def Max(a1, a2) -> T:
    """
    Max(a1, a2) -> T


    Returns the largest of the given ``values`` .


    Parameters
    ----------
    a1 : T

    a2 : T
    """
def Min(a1, a2) -> T:
    """
    Min(a1, a2) -> T


    Returns the smallest of the given ``values`` .


    Parameters
    ----------
    a1 : T

    a2 : T
    """
def Mod(a, b) -> float:
    """
    Mod(a, b) -> float


    The mod function with"correct"behaviour for negative numbers.


    If ``a`` = ``n`` ``b`` for some integer ``n`` , zero is returned.
    Otherwise, for positive ``a`` , the value returned is ``fmod(a,b)`` ,
    and for negative ``a`` , the value returned is ``fmod(a,b)+b`` .


    Parameters
    ----------
    a : float

    b : float
    """
def Modf(f) -> float:
    """
    f : float

    Use instead of Mod() to return the modulus of f as a float instead of a double.
    """
def Normalize(*args, **kwargs) -> None:
    pass
def Pow(f, p) -> float:
    """
    Pow(f, p) -> float


    Return pow( ``f`` , ``p`` ).


    Parameters
    ----------
    f : float

    p : float



    ----------------------------------------------------------------------


    Return pow( ``f`` , ``p`` ).


    Parameters
    ----------
    f : float

    p : float
    """
def Powf(f) -> float:
    """
    f : float

    Use instead of Pow() to return the power of f as a float instead of a double.
    """
def Project(*args, **kwargs) -> None:
    pass
def RadiansToDegrees(radians) -> float:
    """
    RadiansToDegrees(radians) -> float


    Converts an angle in radians to degrees.


    Parameters
    ----------
    radians : float
    """
def Round(f) -> float:
    """
    Round(f) -> float


    Return round( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return round( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Roundf(f) -> float:
    """
    f : float

    Use instead of Round() to return the rounded value of f as a float instead of a double.
    """
def Sgn(v) -> T:
    """
    Sgn(v) -> T


    Return the signum of ``v`` (i.e.


    \-1, 0, or 1).

    The type ``T`` must implement the<and>operators; the function returns
    zero only if value neither positive, nor negative.


    Parameters
    ----------
    v : T
    """
def Slerp(*args, **kwargs) -> None:
    pass
def Sqr(x) -> float:
    """
    Sqr(x) -> float


    Returns the inner product of ``x`` with itself: specifically,
    ``x\*x`` .


    Defined for ``int`` , ``float`` , ``double`` , and all ``GfVec``
    types.


    Parameters
    ----------
    x : T
    """
def Sqrt(f) -> float:
    """
    Sqrt(f) -> float


    Return sqrt( ``f`` ).


    Parameters
    ----------
    f : float



    ----------------------------------------------------------------------


    Return sqrt( ``f`` ).


    Parameters
    ----------
    f : float
    """
def Sqrtf(f) -> float:
    """
    f : float

    Use instead of Sqrt() to return the square root of f as a float instead of a double.
    """
def _HalfRoundTrip(*args, **kwargs) -> None:
    pass
MIN_ORTHO_TOLERANCE = 1e-06
MIN_VECTOR_LENGTH = 1e-10
__MFB_FULL_PACKAGE_NAME = 'gf'
