def Execute(result):
   result["BBox3d"].__init__.func_doc = """__init__()


The default constructor leaves the box empty, the transformation
matrix identity, and the zero-area primitives flag" ``false`` .




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

__init__(rhs)


Copy constructor.


Parameters
----------
rhs : BBox3d



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

__init__(box)


This constructor takes a box and sets the matrix to identity.


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



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

__init__(box, matrix)


This constructor takes a box and a transformation matrix.


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

matrix : Matrix4d


"""
   result["BBox3d"].Set.func_doc = """Set(box, matrix) -> None


Sets the axis-aligned box and transformation matrix.


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

matrix : Matrix4d


"""
   result["BBox3d"].SetMatrix.func_doc = """SetMatrix(matrix) -> None


Sets the transformation matrix only.


The axis-aligned box is not modified.


Parameters
----------
matrix : Matrix4d


"""
   result["BBox3d"].SetRange.func_doc = """SetRange(box) -> None


Sets the range of the axis-aligned box only.


The transformation matrix is not modified.


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


"""
   result["BBox3d"].GetRange.func_doc = """GetRange() -> Range3d


Returns the range of the axis-aligned untransformed box.



"""
   result["BBox3d"].GetBox.func_doc = """GetBox() -> Range3d


Returns the range of the axis-aligned untransformed box.


This synonym of ``GetRange`` exists for compatibility purposes.



"""
   result["BBox3d"].GetMatrix.func_doc = """GetMatrix() -> Matrix4d


Returns the transformation matrix.



"""
   result["BBox3d"].GetInverseMatrix.func_doc = """GetInverseMatrix() -> Matrix4d


Returns the inverse of the transformation matrix.


This will be the identity matrix if the transformation matrix is not
invertible.



"""
   result["BBox3d"].SetHasZeroAreaPrimitives.func_doc = """SetHasZeroAreaPrimitives(hasThem) -> None


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


Parameters
----------
hasThem : bool


"""
   result["BBox3d"].HasZeroAreaPrimitives.func_doc = """HasZeroAreaPrimitives() -> bool


Returns the current state of the zero-area primitives flag".



"""
   result["BBox3d"].GetVolume.func_doc = """GetVolume() -> float


Returns the volume of the box (0 for an empty box).



"""
   result["BBox3d"].Transform.func_doc = """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


"""
   result["BBox3d"].ComputeAlignedRange.func_doc = """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.



"""
   result["BBox3d"].ComputeAlignedBox.func_doc = """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.



"""
   result["BBox3d"].ComputeCentroid.func_doc = """ComputeCentroid() -> Vec3d


Returns the centroid of the bounding box.


The centroid is computed as the transformed centroid of the range.



"""
   result["BBox3d"].Combine.func_doc = """**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


"""
   result["Camera"].__doc__ = """
Object-based representation of a camera.


This class provides a thin wrapper on the camera data model, with a
small number of computations.

"""
   result["Camera"].SetPerspectiveFromAspectRatioAndFieldOfView.func_doc = """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


"""
   result["Camera"].SetOrthographicFromAspectRatioAndSize.func_doc = """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


"""
   result["Camera"].SetFromViewAndProjectionMatrix.func_doc = """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


"""
   result["Camera"].Projection.__doc__ = """
Projection type.

"""
   result["Camera"].FOVDirection.__doc__ = """
Direction used for Field of View or orthographic size.

"""
   result["Camera"].__init__.func_doc = """__init__(transform, projection, horizontalAperture, verticalAperture, horizontalApertureOffset, verticalApertureOffset, focalLength, clippingRange, clippingPlanes, fStop, focusDistance)


Parameters
----------
transform : Matrix4d

projection : Projection

horizontalAperture : float

verticalAperture : float

horizontalApertureOffset : float

verticalApertureOffset : float

focalLength : float

clippingRange : Range1f

clippingPlanes : list[Vec4f]

fStop : float

focusDistance : float


"""
   result["Camera"].GetFieldOfView.func_doc = """GetFieldOfView(direction) -> float


Returns the horizontal or vertical field of view in degrees.


Parameters
----------
direction : FOVDirection


"""
   result["DualQuatd"].__doc__ = """
Basic type: a real part quaternion and a dual part quaternion.

This class represents a generalized dual quaternion that has a real
part and a dual part quaternions. Dual quaternions are used to
represent a combination of rotation and translation.

References:
https://www.cs.utah.edu/~ladislav/kavan06dual/kavan06dual.pdf
http://web.cs.iastate.edu/~cs577/handouts/dual-quaternion.pdf

"""
   result["DualQuatd"].__init__.func_doc = """__init__()


The default constructor leaves the dual quaternion undefined.




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

__init__(realVal)


Initialize the real part to ``realVal`` and the imaginary part to zero
quaternion.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : float



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

__init__(real)


Initialize the real part to ``real`` quaternion and the imaginary part
to zero quaternion.


Parameters
----------
real : Quatd



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

__init__(real, dual)


This constructor initializes the real and dual parts.


Parameters
----------
real : Quatd

dual : Quatd



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

__init__(rotation, translation)


This constructor initializes from a rotation and a translation
components.


Parameters
----------
rotation : Quatd

translation : Vec3d



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

__init__(other)


Implicitly convert from GfDualQuatf.


Parameters
----------
other : DualQuatf



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

__init__(other)


Implicitly convert from GfDualQuath.


Parameters
----------
other : DualQuath


"""
   result["DualQuatd"].SetReal.func_doc = """SetReal(real) -> None


Sets the real part of the dual quaternion.


Parameters
----------
real : Quatd


"""
   result["DualQuatd"].SetDual.func_doc = """SetDual(dual) -> None


Sets the dual part of the dual quaternion.


Parameters
----------
dual : Quatd


"""
   result["DualQuatd"].GetReal.func_doc = """GetReal() -> Quatd


Returns the real part of the dual quaternion.



"""
   result["DualQuatd"].GetDual.func_doc = """GetDual() -> Quatd


Returns the dual part of the dual quaternion.



"""
   result["DualQuatd"].GetLength.func_doc = """GetLength() -> tuple[float, float]


Returns geometric length of this dual quaternion.



"""
   result["DualQuatd"].GetNormalized.func_doc = """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


"""
   result["DualQuatd"].Normalize.func_doc = """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


"""
   result["DualQuatd"].GetConjugate.func_doc = """GetConjugate() -> DualQuatd


Returns the conjugate of this dual quaternion.



"""
   result["DualQuatd"].GetInverse.func_doc = """GetInverse() -> DualQuatd


Returns the inverse of this dual quaternion.



"""
   result["DualQuatd"].SetTranslation.func_doc = """SetTranslation(translation) -> None


Set the translation component of this dual quaternion.


Parameters
----------
translation : Vec3d


"""
   result["DualQuatd"].GetTranslation.func_doc = """GetTranslation() -> Vec3d


Get the translation component of this dual quaternion.



"""
   result["DualQuatd"].Transform.func_doc = """Transform(vec) -> Vec3d


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


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


"""
   result["DualQuatd"].GetZero.func_doc = """**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).



"""
   result["DualQuatd"].GetIdentity.func_doc = """**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).



"""
   result["DualQuatf"].__doc__ = """
Basic type: a real part quaternion and a dual part quaternion.

This class represents a generalized dual quaternion that has a real
part and a dual part quaternions. Dual quaternions are used to
represent a combination of rotation and translation.

References:
https://www.cs.utah.edu/~ladislav/kavan06dual/kavan06dual.pdf
http://web.cs.iastate.edu/~cs577/handouts/dual-quaternion.pdf

"""
   result["DualQuatf"].__init__.func_doc = """__init__()


The default constructor leaves the dual quaternion undefined.




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

__init__(realVal)


Initialize the real part to ``realVal`` and the imaginary part to zero
quaternion.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : float



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

__init__(real)


Initialize the real part to ``real`` quaternion and the imaginary part
to zero quaternion.


Parameters
----------
real : Quatf



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

__init__(real, dual)


This constructor initializes the real and dual parts.


Parameters
----------
real : Quatf

dual : Quatf



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

__init__(rotation, translation)


This constructor initializes from a rotation and a translation
components.


Parameters
----------
rotation : Quatf

translation : Vec3f



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

__init__(other)


Construct from GfDualQuatd.


Parameters
----------
other : DualQuatd



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

__init__(other)


Implicitly convert from GfDualQuath.


Parameters
----------
other : DualQuath


"""
   result["DualQuatf"].SetReal.func_doc = """SetReal(real) -> None


Sets the real part of the dual quaternion.


Parameters
----------
real : Quatf


"""
   result["DualQuatf"].SetDual.func_doc = """SetDual(dual) -> None


Sets the dual part of the dual quaternion.


Parameters
----------
dual : Quatf


"""
   result["DualQuatf"].GetReal.func_doc = """GetReal() -> Quatf


Returns the real part of the dual quaternion.



"""
   result["DualQuatf"].GetDual.func_doc = """GetDual() -> Quatf


Returns the dual part of the dual quaternion.



"""
   result["DualQuatf"].GetLength.func_doc = """GetLength() -> tuple[float, float]


Returns geometric length of this dual quaternion.



"""
   result["DualQuatf"].GetNormalized.func_doc = """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


"""
   result["DualQuatf"].Normalize.func_doc = """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


"""
   result["DualQuatf"].GetConjugate.func_doc = """GetConjugate() -> DualQuatf


Returns the conjugate of this dual quaternion.



"""
   result["DualQuatf"].GetInverse.func_doc = """GetInverse() -> DualQuatf


Returns the inverse of this dual quaternion.



"""
   result["DualQuatf"].SetTranslation.func_doc = """SetTranslation(translation) -> None


Set the translation component of this dual quaternion.


Parameters
----------
translation : Vec3f


"""
   result["DualQuatf"].GetTranslation.func_doc = """GetTranslation() -> Vec3f


Get the translation component of this dual quaternion.



"""
   result["DualQuatf"].Transform.func_doc = """Transform(vec) -> Vec3f


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


Parameters
----------
vec : Vec3f


"""
   result["DualQuatf"].GetZero.func_doc = """**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).



"""
   result["DualQuatf"].GetIdentity.func_doc = """**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).



"""
   result["DualQuath"].__doc__ = """
Basic type: a real part quaternion and a dual part quaternion.

This class represents a generalized dual quaternion that has a real
part and a dual part quaternions. Dual quaternions are used to
represent a combination of rotation and translation.

References:
https://www.cs.utah.edu/~ladislav/kavan06dual/kavan06dual.pdf
http://web.cs.iastate.edu/~cs577/handouts/dual-quaternion.pdf

"""
   result["DualQuath"].__init__.func_doc = """__init__()


The default constructor leaves the dual quaternion undefined.




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

__init__(realVal)


Initialize the real part to ``realVal`` and the imaginary part to zero
quaternion.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : GfHalf



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

__init__(real)


Initialize the real part to ``real`` quaternion and the imaginary part
to zero quaternion.


Parameters
----------
real : Quath



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

__init__(real, dual)


This constructor initializes the real and dual parts.


Parameters
----------
real : Quath

dual : Quath



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

__init__(rotation, translation)


This constructor initializes from a rotation and a translation
components.


Parameters
----------
rotation : Quath

translation : Vec3h



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

__init__(other)


Construct from GfDualQuatd.


Parameters
----------
other : DualQuatd



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

__init__(other)


Construct from GfDualQuatf.


Parameters
----------
other : DualQuatf


"""
   result["DualQuath"].SetReal.func_doc = """SetReal(real) -> None


Sets the real part of the dual quaternion.


Parameters
----------
real : Quath


"""
   result["DualQuath"].SetDual.func_doc = """SetDual(dual) -> None


Sets the dual part of the dual quaternion.


Parameters
----------
dual : Quath


"""
   result["DualQuath"].GetReal.func_doc = """GetReal() -> Quath


Returns the real part of the dual quaternion.



"""
   result["DualQuath"].GetDual.func_doc = """GetDual() -> Quath


Returns the dual part of the dual quaternion.



"""
   result["DualQuath"].GetLength.func_doc = """GetLength() -> tuple[GfHalf, GfHalf]


Returns geometric length of this dual quaternion.



"""
   result["DualQuath"].GetNormalized.func_doc = """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


"""
   result["DualQuath"].Normalize.func_doc = """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


"""
   result["DualQuath"].GetConjugate.func_doc = """GetConjugate() -> DualQuath


Returns the conjugate of this dual quaternion.



"""
   result["DualQuath"].GetInverse.func_doc = """GetInverse() -> DualQuath


Returns the inverse of this dual quaternion.



"""
   result["DualQuath"].SetTranslation.func_doc = """SetTranslation(translation) -> None


Set the translation component of this dual quaternion.


Parameters
----------
translation : Vec3h


"""
   result["DualQuath"].GetTranslation.func_doc = """GetTranslation() -> Vec3h


Get the translation component of this dual quaternion.



"""
   result["DualQuath"].Transform.func_doc = """Transform(vec) -> Vec3h


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


Parameters
----------
vec : Vec3h


"""
   result["DualQuath"].GetZero.func_doc = """**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).



"""
   result["DualQuath"].GetIdentity.func_doc = """**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).



"""
   result["Frustum"].SetPosition.func_doc = """SetPosition(position) -> None


Sets the position of the frustum in world space.


Parameters
----------
position : Vec3d


"""
   result["Frustum"].GetPosition.func_doc = """GetPosition() -> Vec3d


Returns the position of the frustum in world space.



"""
   result["Frustum"].SetRotation.func_doc = """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


"""
   result["Frustum"].GetRotation.func_doc = """GetRotation() -> Rotation


Returns the orientation of the frustum in world space as a rotation to
apply to the -z axis.



"""
   result["Frustum"].SetPositionAndRotationFromMatrix.func_doc = """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


"""
   result["Frustum"].SetWindow.func_doc = """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


"""
   result["Frustum"].GetWindow.func_doc = """GetWindow() -> Range2d


Returns the window rectangle in the reference plane.



"""
   result["Frustum"].SetNearFar.func_doc = """SetNearFar(nearFar) -> None


Sets the near/far interval.


Parameters
----------
nearFar : Range1d


"""
   result["Frustum"].GetNearFar.func_doc = """GetNearFar() -> Range1d


Returns the near/far interval.



"""
   result["Frustum"].SetViewDistance.func_doc = """SetViewDistance(viewDistance) -> None


Sets the view distance.


Parameters
----------
viewDistance : float


"""
   result["Frustum"].GetViewDistance.func_doc = """GetViewDistance() -> float


Returns the view distance.



"""
   result["Frustum"].SetProjectionType.func_doc = """SetProjectionType(projectionType) -> None


Sets the projection type.


Parameters
----------
projectionType : Frustum.ProjectionType


"""
   result["Frustum"].GetProjectionType.func_doc = """GetProjectionType() -> Frustum.ProjectionType


Returns the projection type.



"""
   result["Frustum"].GetReferencePlaneDepth.func_doc = """**classmethod** GetReferencePlaneDepth() -> float


Returns the depth of the reference plane.



"""
   result["Frustum"].SetPerspective.func_doc = """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



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

SetPerspective(fieldOfView, isFovVertical, 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:

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


"""
   result["Frustum"].SetOrthographic.func_doc = """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


"""
   result["Frustum"].GetOrthographic.func_doc = """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


"""
   result["Frustum"].FitToSphere.func_doc = """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


"""
   result["Frustum"].Transform.func_doc = """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


"""
   result["Frustum"].ComputeViewDirection.func_doc = """ComputeViewDirection() -> Vec3d


Returns the normalized world-space view direction vector, which is
computed by rotating the -z axis by the frustum's rotation.



"""
   result["Frustum"].ComputeUpVector.func_doc = """ComputeUpVector() -> Vec3d


Returns the normalized world-space up vector, which is computed by
rotating the y axis by the frustum's rotation.



"""
   result["Frustum"].ComputeViewFrame.func_doc = """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


"""
   result["Frustum"].ComputeLookAtPoint.func_doc = """ComputeLookAtPoint() -> Vec3d


Computes and returns the world-space look-at point from the eye point
(position), view direction (rotation), and view distance.



"""
   result["Frustum"].ComputeViewMatrix.func_doc = """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.



"""
   result["Frustum"].ComputeViewInverse.func_doc = """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.



"""
   result["Frustum"].ComputeProjectionMatrix.func_doc = """ComputeProjectionMatrix() -> Matrix4d


Returns a GL-style projection matrix corresponding to the frustum's
projection.



"""
   result["Frustum"].ComputeAspectRatio.func_doc = """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.



"""
   result["Frustum"].ComputeCorners.func_doc = """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




"""
   result["Frustum"].ComputeCornersAtDistance.func_doc = """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


"""
   result["Frustum"].ComputeNarrowedFrustum.func_doc = """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



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

ComputeNarrowedFrustum(worldPoint, 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 ``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


"""
   result["Frustum"].ComputePickRay.func_doc = """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



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

ComputePickRay(worldSpacePos) -> Ray


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


"""
   result["Frustum"].Intersects.func_doc = """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



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

Intersects(point) -> bool


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


Otherwise, it returns false.


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



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

Intersects(p0, p1) -> bool


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



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

Intersects(p0, p1, p2) -> bool


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


"""
   result["Frustum"].IntersectsViewVolume.func_doc = """**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


"""
   result["Frustum"].ProjectionType.__doc__ = """
This enum is used to determine the type of projection represented by a
frustum.

"""
   result["Frustum"].__init__.func_doc = """__init__()


This constructor creates an instance with default viewing parameters:



   - The position is the origin.

   - The rotation is the identity rotation. (The view is along the -z
     axis, with the +y axis as"up").

   - The window is -1 to +1 in both dimensions.

   - The near/far interval is (1, 10).

   - The view distance is 5.0.

   - The projection type is ``GfFrustum::Perspective`` .





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

__init__(o)


Copy constructor.


Parameters
----------
o : Frustum



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

__init__(o)


Move constructor.


Parameters
----------
o : Frustum



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

__init__(position, rotation, window, nearFar, projectionType, viewDistance)


This constructor creates an instance with the given viewing
parameters.


Parameters
----------
position : Vec3d

rotation : Rotation

window : Range2d

nearFar : Range1d

projectionType : Frustum.ProjectionType

viewDistance : float



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

__init__(camToWorldXf, window, nearFar, projectionType, viewDistance)


This constructor creates an instance from a camera matrix (always of a
y-Up camera, also see SetPositionAndRotationFromMatrix) and the given
viewing parameters.


Parameters
----------
camToWorldXf : Matrix4d

window : Range2d

nearFar : Range1d

projectionType : Frustum.ProjectionType

viewDistance : float


"""
   result["Interval"].IsMinClosed.func_doc = """IsMinClosed() -> bool


Minimum boundary condition.



"""
   result["Interval"].IsMaxClosed.func_doc = """IsMaxClosed() -> bool


Maximum boundary condition.



"""
   result["Interval"].IsMinOpen.func_doc = """IsMinOpen() -> bool


Minimum boundary condition.



"""
   result["Interval"].IsMaxOpen.func_doc = """IsMaxOpen() -> bool


Maximum boundary condition.



"""
   result["Interval"].IsMaxFinite.func_doc = """IsMaxFinite() -> bool


Returns true if the maximum value is finite.



"""
   result["Interval"].IsMinFinite.func_doc = """IsMinFinite() -> bool


Returns true if the minimum value is finite.



"""
   result["Interval"].IsFinite.func_doc = """IsFinite() -> bool


Returns true if both the maximum and minimum value are finite.



"""
   result["Interval"].Intersects.func_doc = """Intersects(i) -> bool


Return true iff the given interval i intersects this interval.


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


"""
   result["Interval"].GetFullInterval.func_doc = """**classmethod** GetFullInterval() -> Interval


Returns the full interval (-inf, inf).



"""
   result["Line"].__init__.func_doc = """__init__()


The default constructor leaves line parameters undefined.




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

__init__(p0, dir)


Construct a line from a point and a direction.


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

dir : Vec3d


"""
   result["Line"].Set.func_doc = """Set(p0, dir) -> float


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

dir : Vec3d


"""
   result["Line"].GetPoint.func_doc = """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


"""
   result["Line"].GetDirection.func_doc = """GetDirection() -> Vec3d


Return the normalized direction of the line.



"""
   result["Line"].FindClosestPoint.func_doc = """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


"""
   result["LineSeg"].__init__.func_doc = """__init__()


The default constructor leaves line parameters undefined.




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

__init__(p0, p1)


Construct a line segment that spans two points.


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

p1 : Vec3d


"""
   result["LineSeg"].GetPoint.func_doc = """GetPoint(t) -> Vec3d


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


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


Parameters
----------
t : float


"""
   result["LineSeg"].GetDirection.func_doc = """GetDirection() -> Vec3d


Return the normalized direction of the line.



"""
   result["LineSeg"].GetLength.func_doc = """GetLength() -> float


Return the length of the line.



"""
   result["LineSeg"].FindClosestPoint.func_doc = """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


"""
   result["Matrix2d"].__doc__ = """
Stores a 2x2 matrix of ``double`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

"""
   result["Matrix2d"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m10, m11)


Constructor.


Initializes 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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(s)


This explicit constructor initializes the matrix to ``s`` times the
identity matrix.


Parameters
----------
s : int



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec2d



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 2x2. If it is too big, only the first 2 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 2x2. If it is too big, only the first 2 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(m)


This explicit constructor converts a"float"matrix to a"double"matrix.


Parameters
----------
m : Matrix2f


"""
   result["Matrix2d"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec2.


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

v : Vec2d


"""
   result["Matrix2d"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec2.


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

v : Vec2d


"""
   result["Matrix2d"].GetRow.func_doc = """GetRow(i) -> Vec2d


Gets a row of the matrix as a Vec2.


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


"""
   result["Matrix2d"].GetColumn.func_doc = """GetColumn(i) -> Vec2d


Gets a column of the matrix as a Vec2.


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


"""
   result["Matrix2d"].Set.func_doc = """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



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

Set(m) -> Matrix2d


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


Parameters
----------
m : float


"""
   result["Matrix2d"].SetIdentity.func_doc = """SetIdentity() -> Matrix2d


Sets the matrix to the identity matrix.



"""
   result["Matrix2d"].SetZero.func_doc = """SetZero() -> Matrix2d


Sets the matrix to zero.



"""
   result["Matrix2d"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix2d


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


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



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

SetDiagonal(arg1) -> Matrix2d


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


Parameters
----------
arg1 : Vec2d


"""
   result["Matrix2d"].GetTranspose.func_doc = """GetTranspose() -> Matrix2d


Returns the transpose of the matrix.



"""
   result["Matrix2d"].GetInverse.func_doc = """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


"""
   result["Matrix2d"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix2f"].__doc__ = """
Stores a 2x2 matrix of ``float`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

"""
   result["Matrix2f"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m10, m11)


Constructor.


Initializes 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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(s)


This explicit constructor initializes the matrix to ``s`` times the
identity matrix.


Parameters
----------
s : int



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec2f



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 2x2. If it is too big, only the first 2 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 2x2. If it is too big, only the first 2 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(m)


This explicit constructor converts a"double"matrix to a"float"matrix.


Parameters
----------
m : Matrix2d


"""
   result["Matrix2f"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec2.


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

v : Vec2f


"""
   result["Matrix2f"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec2.


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

v : Vec2f


"""
   result["Matrix2f"].GetRow.func_doc = """GetRow(i) -> Vec2f


Gets a row of the matrix as a Vec2.


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


"""
   result["Matrix2f"].GetColumn.func_doc = """GetColumn(i) -> Vec2f


Gets a column of the matrix as a Vec2.


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


"""
   result["Matrix2f"].Set.func_doc = """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



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

Set(m) -> Matrix2f


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


Parameters
----------
m : float


"""
   result["Matrix2f"].SetIdentity.func_doc = """SetIdentity() -> Matrix2f


Sets the matrix to the identity matrix.



"""
   result["Matrix2f"].SetZero.func_doc = """SetZero() -> Matrix2f


Sets the matrix to zero.



"""
   result["Matrix2f"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix2f


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


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



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

SetDiagonal(arg1) -> Matrix2f


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


Parameters
----------
arg1 : Vec2f


"""
   result["Matrix2f"].GetTranspose.func_doc = """GetTranspose() -> Matrix2f


Returns the transpose of the matrix.



"""
   result["Matrix2f"].GetInverse.func_doc = """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


"""
   result["Matrix2f"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix3d"].__doc__ = """
Stores a 3x3 matrix of ``double`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

3D Transformations
==================

Three methods, SetRotate() , SetScale() , and ExtractRotation() ,
interpret a GfMatrix3d as a 3D transformation. By convention, vectors
are treated primarily as row vectors, implying the following:

   - Transformation matrices are organized to deal with row vectors,
     not column vectors.

   - Each of the Set() methods in this class completely rewrites the
     matrix; for example, SetRotate() yields a matrix which does nothing
     but rotate.

   - When multiplying two transformation matrices, the matrix on the
     left applies a more local transformation to a row vector. For example,
     if R represents a rotation matrix and S represents a scale matrix, the
     product R\\*S will rotate a row vector, then scale it.


"""
   result["Matrix3d"].SetRotate.func_doc = """SetRotate(rot) -> Matrix3d


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


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



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

SetRotate(rot) -> Matrix3d


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


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


"""
   result["Matrix3d"].SetScale.func_doc = """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



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

SetScale(scaleFactor) -> Matrix3d


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


Parameters
----------
scaleFactor : float


"""
   result["Matrix3d"].ExtractRotation.func_doc = """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.



"""
   result["Matrix3d"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m02, m10, m11, m12, m20, m21, m22)


Constructor.


Initializes 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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(s)


This explicit constructor initializes the matrix to ``s`` times the
identity matrix.


Parameters
----------
s : int



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec3d



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 3x3. If it is too big, only the first 3 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 3x3. If it is too big, only the first 3 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(rot)


Constructor. Initialize matrix from rotation.


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



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

__init__(rot)


Constructor. Initialize matrix from a quaternion.


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



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

__init__(m)


This explicit constructor converts a"float"matrix to a"double"matrix.


Parameters
----------
m : Matrix3f


"""
   result["Matrix3d"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec3.


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

v : Vec3d


"""
   result["Matrix3d"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec3.


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

v : Vec3d


"""
   result["Matrix3d"].GetRow.func_doc = """GetRow(i) -> Vec3d


Gets a row of the matrix as a Vec3.


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


"""
   result["Matrix3d"].GetColumn.func_doc = """GetColumn(i) -> Vec3d


Gets a column of the matrix as a Vec3.


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


"""
   result["Matrix3d"].Set.func_doc = """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



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

Set(m) -> Matrix3d


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


Parameters
----------
m : float


"""
   result["Matrix3d"].SetIdentity.func_doc = """SetIdentity() -> Matrix3d


Sets the matrix to the identity matrix.



"""
   result["Matrix3d"].SetZero.func_doc = """SetZero() -> Matrix3d


Sets the matrix to zero.



"""
   result["Matrix3d"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix3d


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


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



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

SetDiagonal(arg1) -> Matrix3d


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


Parameters
----------
arg1 : Vec3d


"""
   result["Matrix3d"].GetTranspose.func_doc = """GetTranspose() -> Matrix3d


Returns the transpose of the matrix.



"""
   result["Matrix3d"].GetInverse.func_doc = """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


"""
   result["Matrix3d"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix3d"].Orthonormalize.func_doc = """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


"""
   result["Matrix3d"].GetOrthonormalized.func_doc = """GetOrthonormalized(issueWarning) -> Matrix3d


Returns an orthonormalized copy of the matrix.


Parameters
----------
issueWarning : bool


"""
   result["Matrix3d"].GetHandedness.func_doc = """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.



"""
   result["Matrix3d"].IsRightHanded.func_doc = """IsRightHanded() -> bool


Returns true if the vectors in the matrix form a right-handed
coordinate system.



"""
   result["Matrix3d"].IsLeftHanded.func_doc = """IsLeftHanded() -> bool


Returns true if the vectors in matrix form a left-handed coordinate
system.



"""
   result["Matrix3f"].__doc__ = """
Stores a 3x3 matrix of ``float`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

3D Transformations
==================

Three methods, SetRotate() , SetScale() , and ExtractRotation() ,
interpret a GfMatrix3f as a 3D transformation. By convention, vectors
are treated primarily as row vectors, implying the following:

   - Transformation matrices are organized to deal with row vectors,
     not column vectors.

   - Each of the Set() methods in this class completely rewrites the
     matrix; for example, SetRotate() yields a matrix which does nothing
     but rotate.

   - When multiplying two transformation matrices, the matrix on the
     left applies a more local transformation to a row vector. For example,
     if R represents a rotation matrix and S represents a scale matrix, the
     product R\\*S will rotate a row vector, then scale it.


"""
   result["Matrix3f"].SetRotate.func_doc = """SetRotate(rot) -> Matrix3f


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


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



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

SetRotate(rot) -> Matrix3f


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


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


"""
   result["Matrix3f"].SetScale.func_doc = """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



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

SetScale(scaleFactor) -> Matrix3f


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


Parameters
----------
scaleFactor : float


"""
   result["Matrix3f"].ExtractRotation.func_doc = """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.



"""
   result["Matrix3f"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m02, m10, m11, m12, m20, m21, m22)


Constructor.


Initializes 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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(s)


This explicit constructor initializes the matrix to ``s`` times the
identity matrix.


Parameters
----------
s : int



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec3f



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 3x3. If it is too big, only the first 3 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 3x3. If it is too big, only the first 3 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(rot)


Constructor. Initialize matrix from rotation.


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



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

__init__(rot)


Constructor. Initialize matrix from a quaternion.


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



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

__init__(m)


This explicit constructor converts a"double"matrix to a"float"matrix.


Parameters
----------
m : Matrix3d


"""
   result["Matrix3f"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec3.


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

v : Vec3f


"""
   result["Matrix3f"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec3.


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

v : Vec3f


"""
   result["Matrix3f"].GetRow.func_doc = """GetRow(i) -> Vec3f


Gets a row of the matrix as a Vec3.


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


"""
   result["Matrix3f"].GetColumn.func_doc = """GetColumn(i) -> Vec3f


Gets a column of the matrix as a Vec3.


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


"""
   result["Matrix3f"].Set.func_doc = """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



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

Set(m) -> Matrix3f


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


Parameters
----------
m : float


"""
   result["Matrix3f"].SetIdentity.func_doc = """SetIdentity() -> Matrix3f


Sets the matrix to the identity matrix.



"""
   result["Matrix3f"].SetZero.func_doc = """SetZero() -> Matrix3f


Sets the matrix to zero.



"""
   result["Matrix3f"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix3f


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


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



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

SetDiagonal(arg1) -> Matrix3f


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


Parameters
----------
arg1 : Vec3f


"""
   result["Matrix3f"].GetTranspose.func_doc = """GetTranspose() -> Matrix3f


Returns the transpose of the matrix.



"""
   result["Matrix3f"].GetInverse.func_doc = """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


"""
   result["Matrix3f"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix3f"].Orthonormalize.func_doc = """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


"""
   result["Matrix3f"].GetOrthonormalized.func_doc = """GetOrthonormalized(issueWarning) -> Matrix3f


Returns an orthonormalized copy of the matrix.


Parameters
----------
issueWarning : bool


"""
   result["Matrix3f"].GetHandedness.func_doc = """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.



"""
   result["Matrix3f"].IsRightHanded.func_doc = """IsRightHanded() -> bool


Returns true if the vectors in the matrix form a right-handed
coordinate system.



"""
   result["Matrix3f"].IsLeftHanded.func_doc = """IsLeftHanded() -> bool


Returns true if the vectors in matrix form a left-handed coordinate
system.



"""
   result["Matrix4d"].__doc__ = """
Stores a 4x4 matrix of ``double`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

3D Transformations
==================

The following methods interpret a GfMatrix4d as a 3D transformation:
SetRotate() , SetScale() , SetTranslate() , SetLookAt() , Factor() ,
ExtractTranslation() , ExtractRotation() , Transform() ,
TransformDir() . By convention, vectors are treated primarily as row
vectors, implying the following:

   - Transformation matrices are organized to deal with row vectors,
     not column vectors. For example, the last row of a matrix contains the
     translation amounts.

   - Each of the Set() methods below completely rewrites the matrix;
     for example, SetTranslate() yields a matrix which does nothing but
     translate.

   - When multiplying two transformation matrices, the matrix on the
     left applies a more local transformation to a row vector. For example,
     if R represents a rotation matrix and T represents a translation
     matrix, the product R\\*T will rotate a row vector, then translate it.


"""
   result["Matrix4d"].SetRotate.func_doc = """SetRotate(rot) -> Matrix4d


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


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



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

SetRotate(rot) -> Matrix4d


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


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



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

SetRotate(mx) -> Matrix4d


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


Parameters
----------
mx : Matrix3d


"""
   result["Matrix4d"].SetRotateOnly.func_doc = """SetRotateOnly(rot) -> Matrix4d


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


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



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

SetRotateOnly(rot) -> Matrix4d


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


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



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

SetRotateOnly(mx) -> Matrix4d


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


Parameters
----------
mx : Matrix3d


"""
   result["Matrix4d"].SetScale.func_doc = """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



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

SetScale(scaleFactor) -> Matrix4d


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


Parameters
----------
scaleFactor : float


"""
   result["Matrix4d"].SetTranslate.func_doc = """SetTranslate(trans) -> Matrix4d


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


Parameters
----------
trans : Vec3d


"""
   result["Matrix4d"].SetTranslateOnly.func_doc = """SetTranslateOnly(t) -> Matrix4d


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


Parameters
----------
t : Vec3d


"""
   result["Matrix4d"].SetTransform.func_doc = """SetTransform(rotate, translate) -> Matrix4d


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


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

translate : Vec3d



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

SetTransform(rotmx, translate) -> Matrix4d


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


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

translate : Vec3d


"""
   result["Matrix4d"].SetLookAt.func_doc = """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



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

SetLookAt(eyePoint, orientation) -> Matrix4d


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


"""
   result["Matrix4d"].Factor.func_doc = """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


"""
   result["Matrix4d"].ExtractTranslation.func_doc = """ExtractTranslation() -> Vec3d


Returns the translation part of the matrix, defined as the first three
elements of the last row.



"""
   result["Matrix4d"].ExtractRotation.func_doc = """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.



"""
   result["Matrix4d"].ExtractRotationQuat.func_doc = """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.



"""
   result["Matrix4d"].ExtractRotationMatrix.func_doc = """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.



"""
   result["Matrix4d"].Transform.func_doc = """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



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

Transform(vec) -> Vec3f


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


"""
   result["Matrix4d"].TransformDir.func_doc = """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



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

TransformDir(vec) -> Vec3f


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


"""
   result["Matrix4d"].TransformAffine.func_doc = """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



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

TransformAffine(vec) -> Vec3f


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


"""
   result["Matrix4d"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)


Constructor.


Initializes 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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec4d



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 4x4. If it is too big, only the first 4 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 4x4. If it is too big, only the first 4 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(r0, r1, r2, r3)


Constructor.


Initialize the matrix from 4 row vectors of double. Each vector is
expected to length 4. If it is too big, only the first 4 items will be
used. If it is too small, uninitialized elements will be filled in
with the corresponding elements from an identity matrix.


Parameters
----------
r0 : list[float]

r1 : list[float]

r2 : list[float]

r3 : list[float]



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

__init__(r0, r1, r2, r3)


Constructor.


Initialize the matrix from 4 row vectors of float. Each vector is
expected to length 4. If it is too big, only the first 4 items will be
used. If it is too small, uninitialized elements will be filled in
with the corresponding elements from an identity matrix.


Parameters
----------
r0 : list[float]

r1 : list[float]

r2 : list[float]

r3 : list[float]



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

__init__(rotate, translate)


Constructor.


Initializes a transformation matrix to perform the indicated rotation
and translation.


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

translate : Vec3d



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

__init__(rotmx, translate)


Constructor.


Initializes a transformation matrix to perform the indicated rotation
and translation.


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

translate : Vec3d



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

__init__(m)


This explicit constructor converts a"float"matrix to a"double"matrix.


Parameters
----------
m : Matrix4f


"""
   result["Matrix4d"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec4.


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

v : Vec4d


"""
   result["Matrix4d"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec4.


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

v : Vec4d


"""
   result["Matrix4d"].GetRow.func_doc = """GetRow(i) -> Vec4d


Gets a row of the matrix as a Vec4.


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


"""
   result["Matrix4d"].GetColumn.func_doc = """GetColumn(i) -> Vec4d


Gets a column of the matrix as a Vec4.


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


"""
   result["Matrix4d"].Set.func_doc = """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



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

Set(m) -> Matrix4d


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


Parameters
----------
m : float


"""
   result["Matrix4d"].SetIdentity.func_doc = """SetIdentity() -> Matrix4d


Sets the matrix to the identity matrix.



"""
   result["Matrix4d"].SetZero.func_doc = """SetZero() -> Matrix4d


Sets the matrix to zero.



"""
   result["Matrix4d"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix4d


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


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



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

SetDiagonal(arg1) -> Matrix4d


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


Parameters
----------
arg1 : Vec4d


"""
   result["Matrix4d"].GetTranspose.func_doc = """GetTranspose() -> Matrix4d


Returns the transpose of the matrix.



"""
   result["Matrix4d"].GetInverse.func_doc = """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


"""
   result["Matrix4d"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix4d"].SetRow3.func_doc = """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


"""
   result["Matrix4d"].GetRow3.func_doc = """GetRow3(i) -> Vec3d


Gets a row of the matrix as a Vec3.


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


"""
   result["Matrix4d"].GetDeterminant3.func_doc = """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.



"""
   result["Matrix4d"].HasOrthogonalRows3.func_doc = """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.



"""
   result["Matrix4d"].Orthonormalize.func_doc = """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


"""
   result["Matrix4d"].GetOrthonormalized.func_doc = """GetOrthonormalized(issueWarning) -> Matrix4d


Returns an orthonormalized copy of the matrix.


Parameters
----------
issueWarning : bool


"""
   result["Matrix4d"].GetHandedness.func_doc = """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.



"""
   result["Matrix4d"].IsRightHanded.func_doc = """IsRightHanded() -> bool


Returns true if the vectors in the upper 3x3 matrix form a right-
handed coordinate system.



"""
   result["Matrix4d"].IsLeftHanded.func_doc = """IsLeftHanded() -> bool


Returns true if the vectors in the upper 3x3 matrix form a left-handed
coordinate system.



"""
   result["Matrix4d"].RemoveScaleShear.func_doc = """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.



"""
   result["Matrix4f"].__doc__ = """
Stores a 4x4 matrix of ``float`` elements. A basic type.

Matrices are defined to be in row-major order, so ``matrix[i][j]``
indexes the element in the *i* th row and the *j* th column.

3D Transformations
==================

The following methods interpret a GfMatrix4f as a 3D transformation:
SetRotate() , SetScale() , SetTranslate() , SetLookAt() , Factor() ,
ExtractTranslation() , ExtractRotation() , Transform() ,
TransformDir() . By convention, vectors are treated primarily as row
vectors, implying the following:

   - Transformation matrices are organized to deal with row vectors,
     not column vectors. For example, the last row of a matrix contains the
     translation amounts.

   - Each of the Set() methods below completely rewrites the matrix;
     for example, SetTranslate() yields a matrix which does nothing but
     translate.

   - When multiplying two transformation matrices, the matrix on the
     left applies a more local transformation to a row vector. For example,
     if R represents a rotation matrix and T represents a translation
     matrix, the product R\\*T will rotate a row vector, then translate it.


"""
   result["Matrix4f"].SetRotate.func_doc = """SetRotate(rot) -> Matrix4f


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


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



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

SetRotate(rot) -> Matrix4f


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


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



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

SetRotate(mx) -> Matrix4f


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


Parameters
----------
mx : Matrix3f


"""
   result["Matrix4f"].SetRotateOnly.func_doc = """SetRotateOnly(rot) -> Matrix4f


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


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



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

SetRotateOnly(rot) -> Matrix4f


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


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



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

SetRotateOnly(mx) -> Matrix4f


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


Parameters
----------
mx : Matrix3f


"""
   result["Matrix4f"].SetScale.func_doc = """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



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

SetScale(scaleFactor) -> Matrix4f


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


Parameters
----------
scaleFactor : float


"""
   result["Matrix4f"].SetTranslate.func_doc = """SetTranslate(trans) -> Matrix4f


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


Parameters
----------
trans : Vec3f


"""
   result["Matrix4f"].SetTranslateOnly.func_doc = """SetTranslateOnly(t) -> Matrix4f


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


Parameters
----------
t : Vec3f


"""
   result["Matrix4f"].SetTransform.func_doc = """SetTransform(rotate, translate) -> Matrix4f


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


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

translate : Vec3f



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

SetTransform(rotmx, translate) -> Matrix4f


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


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

translate : Vec3f


"""
   result["Matrix4f"].SetLookAt.func_doc = """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



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

SetLookAt(eyePoint, orientation) -> Matrix4f


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


"""
   result["Matrix4f"].Factor.func_doc = """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


"""
   result["Matrix4f"].ExtractTranslation.func_doc = """ExtractTranslation() -> Vec3f


Returns the translation part of the matrix, defined as the first three
elements of the last row.



"""
   result["Matrix4f"].ExtractRotation.func_doc = """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.



"""
   result["Matrix4f"].ExtractRotationQuat.func_doc = """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.



"""
   result["Matrix4f"].ExtractRotationMatrix.func_doc = """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.



"""
   result["Matrix4f"].Transform.func_doc = """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



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

Transform(vec) -> Vec3f


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


"""
   result["Matrix4f"].TransformDir.func_doc = """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



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

TransformDir(vec) -> Vec3f


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


"""
   result["Matrix4f"].TransformAffine.func_doc = """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



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

TransformAffine(vec) -> Vec3f


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


"""
   result["Matrix4f"].__init__.func_doc = """__init__()


Default constructor. Leaves the matrix component values undefined.




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

__init__(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)


Constructor.


Initializes the matrix from 16 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

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



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

__init__(m)


Constructor.


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


Parameters
----------
m : float



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

__init__(s)


Constructor.


Explicitly initializes the matrix to *s* times the identity matrix.


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



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

__init__(v)


Constructor.


Explicitly initializes the matrix to diagonal form, with the *i* th
element on the diagonal set to ``v[i]`` .


Parameters
----------
v : Vec4f



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of double. The vector
is expected to be 4x4. If it is too big, only the first 4 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(v)


Constructor.


Initialize the matrix from a vector of vectors of float. The vector is
expected to be 4x4. If it is too big, only the first 4 rows and/or
columns will be used. If it is too small, uninitialized elements will
be filled in with the corresponding elements from an identity matrix.


Parameters
----------
v : list[list[float]]



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

__init__(r0, r1, r2, r3)


Constructor.


Initialize the matrix from 4 row vectors of double. Each vector is
expected to length 4. If it is too big, only the first 4 items will be
used. If it is too small, uninitialized elements will be filled in
with the corresponding elements from an identity matrix.


Parameters
----------
r0 : list[float]

r1 : list[float]

r2 : list[float]

r3 : list[float]



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

__init__(r0, r1, r2, r3)


Constructor.


Initialize the matrix from 4 row vectors of float. Each vector is
expected to length 4. If it is too big, only the first 4 items will be
used. If it is too small, uninitialized elements will be filled in
with the corresponding elements from an identity matrix.


Parameters
----------
r0 : list[float]

r1 : list[float]

r2 : list[float]

r3 : list[float]



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

__init__(rotate, translate)


Constructor.


Initializes a transformation matrix to perform the indicated rotation
and translation.


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

translate : Vec3f



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

__init__(rotmx, translate)


Constructor.


Initializes a transformation matrix to perform the indicated rotation
and translation.


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

translate : Vec3f



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

__init__(m)


This explicit constructor converts a"double"matrix to a"float"matrix.


Parameters
----------
m : Matrix4d


"""
   result["Matrix4f"].SetRow.func_doc = """SetRow(i, v) -> None


Sets a row of the matrix from a Vec4.


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

v : Vec4f


"""
   result["Matrix4f"].SetColumn.func_doc = """SetColumn(i, v) -> None


Sets a column of the matrix from a Vec4.


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

v : Vec4f


"""
   result["Matrix4f"].GetRow.func_doc = """GetRow(i) -> Vec4f


Gets a row of the matrix as a Vec4.


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


"""
   result["Matrix4f"].GetColumn.func_doc = """GetColumn(i) -> Vec4f


Gets a column of the matrix as a Vec4.


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


"""
   result["Matrix4f"].Set.func_doc = """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



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

Set(m) -> Matrix4f


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


Parameters
----------
m : float


"""
   result["Matrix4f"].SetIdentity.func_doc = """SetIdentity() -> Matrix4f


Sets the matrix to the identity matrix.



"""
   result["Matrix4f"].SetZero.func_doc = """SetZero() -> Matrix4f


Sets the matrix to zero.



"""
   result["Matrix4f"].SetDiagonal.func_doc = """SetDiagonal(s) -> Matrix4f


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


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



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

SetDiagonal(arg1) -> Matrix4f


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


Parameters
----------
arg1 : Vec4f


"""
   result["Matrix4f"].GetTranspose.func_doc = """GetTranspose() -> Matrix4f


Returns the transpose of the matrix.



"""
   result["Matrix4f"].GetInverse.func_doc = """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


"""
   result["Matrix4f"].GetDeterminant.func_doc = """GetDeterminant() -> float


Returns the determinant of the matrix.



"""
   result["Matrix4f"].SetRow3.func_doc = """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


"""
   result["Matrix4f"].GetRow3.func_doc = """GetRow3(i) -> Vec3f


Gets a row of the matrix as a Vec3.


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


"""
   result["Matrix4f"].GetDeterminant3.func_doc = """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.



"""
   result["Matrix4f"].HasOrthogonalRows3.func_doc = """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.



"""
   result["Matrix4f"].Orthonormalize.func_doc = """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


"""
   result["Matrix4f"].GetOrthonormalized.func_doc = """GetOrthonormalized(issueWarning) -> Matrix4f


Returns an orthonormalized copy of the matrix.


Parameters
----------
issueWarning : bool


"""
   result["Matrix4f"].GetHandedness.func_doc = """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.



"""
   result["Matrix4f"].IsRightHanded.func_doc = """IsRightHanded() -> bool


Returns true if the vectors in the upper 3x3 matrix form a right-
handed coordinate system.



"""
   result["Matrix4f"].IsLeftHanded.func_doc = """IsLeftHanded() -> bool


Returns true if the vectors in the upper 3x3 matrix form a left-handed
coordinate system.



"""
   result["Matrix4f"].RemoveScaleShear.func_doc = """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.



"""
   result["MultiInterval"].__doc__ = """
GfMultiInterval represents a subset of the real number line as an
ordered set of non-intersecting GfIntervals.

"""
   result["MultiInterval"].__init__.func_doc = """__init__()




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

__init__(i)


Constructs an multi-interval with the single given interval.


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



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

__init__(intervals)


Constructs an multi-interval containing the given input intervals.


Parameters
----------
intervals : list[Interval]


"""
   result["MultiInterval"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns true if the multi-interval is empty.



"""
   result["MultiInterval"].GetSize.func_doc = """GetSize() -> int


Returns the number of intervals in the set.



"""
   result["MultiInterval"].GetBounds.func_doc = """GetBounds() -> Interval


Returns an interval bounding the entire multi-interval.


Returns an empty interval if the multi-interval is empty.



"""
   result["MultiInterval"].Clear.func_doc = """Clear() -> None


Clear the multi-interval.



"""
   result["MultiInterval"].Add.func_doc = """Add(i) -> None


Add the given interval to the multi-interval.


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



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

Add(s) -> None


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


Sets this object to the union of the two sets.


Parameters
----------
s : MultiInterval


"""
   result["MultiInterval"].ArithmeticAdd.func_doc = """ArithmeticAdd(i) -> None


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


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


"""
   result["MultiInterval"].Remove.func_doc = """Remove(i) -> None


Remove the given interval from this multi-interval.


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



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

Remove(s) -> None


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


Parameters
----------
s : MultiInterval


"""
   result["MultiInterval"].Intersect.func_doc = """Intersect(i) -> None


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



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

Intersect(s) -> None


Parameters
----------
s : MultiInterval


"""
   result["MultiInterval"].GetComplement.func_doc = """GetComplement() -> MultiInterval


Return the complement of this set.



"""
   result["MultiInterval"].GetFullInterval.func_doc = """**classmethod** GetFullInterval() -> MultiInterval


Returns the full interval (-inf, inf).



"""
   result["Plane"].__doc__ = """
Basic type: 3-dimensional plane

This class represents a three-dimensional plane as a normal vector and
the distance of the plane from the origin, measured along the normal.
The plane can also be used to represent a half-space: the side of the
plane in the direction of the normal.

"""
   result["Plane"].__init__.func_doc = """__init__()


The default constructor leaves the plane parameters undefined.




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

__init__(normal, distanceToOrigin)


This constructor 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



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

__init__(normal, point)


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



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

__init__(p0, p1, p2)


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



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

__init__(eqn)


This constructor creates a plane given by the equation ``eqn`` [0] \\*
x + ``eqn`` [1] \\* y + ``eqn`` [2] \\* z + ``eqn`` [3] = 0.


Parameters
----------
eqn : Vec4d


"""
   result["Plane"].Set.func_doc = """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



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

Set(normal, point) -> None


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



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

Set(p0, p1, p2) -> None


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



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

Set(eqn) -> None


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


"""
   result["Plane"].GetNormal.func_doc = """GetNormal() -> Vec3d


Returns the unit-length normal vector of the plane.



"""
   result["Plane"].GetDistanceFromOrigin.func_doc = """GetDistanceFromOrigin() -> float


Returns the distance of the plane from the origin.



"""
   result["Plane"].GetEquation.func_doc = """GetEquation() -> Vec4d


Give the coefficients of the equation of the plane.


Suitable to OpenGL calls to set the clipping plane.



"""
   result["Plane"].GetDistance.func_doc = """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


"""
   result["Plane"].Project.func_doc = """Project(p) -> Vec3d


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


Parameters
----------
p : Vec3d


"""
   result["Plane"].Transform.func_doc = """Transform(matrix) -> Plane


Transforms the plane by the given matrix.


Parameters
----------
matrix : Matrix4d


"""
   result["Plane"].Reorient.func_doc = """Reorient(p) -> None


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


Parameters
----------
p : Vec3d


"""
   result["Plane"].IntersectsPositiveHalfSpace.func_doc = """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



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

IntersectsPositiveHalfSpace(pt) -> bool


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


Parameters
----------
pt : Vec3d


"""
   result["Quatd"].__doc__ = """
Basic type: a quaternion, a complex number with a real coefficient and
three imaginary coefficients, stored as a 3-vector.

"""
   result["Quatd"].__init__.func_doc = """__init__()


Default constructor leaves the quaternion undefined.




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

__init__(realVal)


Initialize the real coefficient to ``realVal`` and the imaginary
coefficients to zero.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : float



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

__init__(real, i, j, k)


Initialize the real and imaginary coefficients.


Parameters
----------
real : float

i : float

j : float

k : float



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

__init__(real, imaginary)


Initialize the real and imaginary coefficients.


Parameters
----------
real : float

imaginary : Vec3d



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

__init__(other)


Implicitly convert from GfQuatf.


Parameters
----------
other : Quatf



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

__init__(other)


Implicitly convert from GfQuath.


Parameters
----------
other : Quath


"""
   result["Quatd"].GetReal.func_doc = """GetReal() -> float


Return the real coefficient.



"""
   result["Quatd"].SetReal.func_doc = """SetReal(real) -> None


Set the real coefficient.


Parameters
----------
real : float


"""
   result["Quatd"].GetImaginary.func_doc = """GetImaginary() -> Vec3d


Return the imaginary coefficient.



"""
   result["Quatd"].SetImaginary.func_doc = """SetImaginary(imaginary) -> None


Set the imaginary coefficients.


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



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

SetImaginary(i, j, k) -> None


Set the imaginary coefficients.


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

j : float

k : float


"""
   result["Quatd"].GetLength.func_doc = """GetLength() -> float


Return geometric length of this quaternion.



"""
   result["Quatd"].GetNormalized.func_doc = """GetNormalized(eps) -> Quatd


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


Parameters
----------
eps : float


"""
   result["Quatd"].Normalize.func_doc = """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


"""
   result["Quatd"].GetConjugate.func_doc = """GetConjugate() -> Quatd


Return this quaternion's conjugate, which is the quaternion with the
same real coefficient and negated imaginary coefficients.



"""
   result["Quatd"].GetInverse.func_doc = """GetInverse() -> Quatd


Return this quaternion's inverse, or reciprocal.


This is the quaternion's conjugate divided by it's squared length.



"""
   result["Quatd"].Transform.func_doc = """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


"""
   result["Quatd"].GetZero.func_doc = """**classmethod** GetZero() -> Quatd


Return the zero quaternion, with real coefficient 0 and an imaginary
coefficients all zero.



"""
   result["Quatd"].GetIdentity.func_doc = """**classmethod** GetIdentity() -> Quatd


Return the identity quaternion, with real coefficient 1 and an
imaginary coefficients all zero.



"""
   result["Quaternion"].__init__.func_doc = """__init__()


The default constructor leaves the quaternion undefined.




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

__init__(realVal)


This constructor initializes the real part to the argument and the
imaginary parts to zero.


Since quaternions typically need to be normalized, the only reasonable
values for ``realVal`` are -1, 0, or 1. Other values are legal but are
likely to be meaningless.


Parameters
----------
realVal : int



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

__init__(real, imaginary)


This constructor initializes the real and imaginary parts.


Parameters
----------
real : float

imaginary : Vec3d


"""
   result["Quaternion"].GetReal.func_doc = """GetReal() -> float


Returns the real part of the quaternion.



"""
   result["Quaternion"].GetImaginary.func_doc = """GetImaginary() -> Vec3d


Returns the imaginary part of the quaternion.



"""
   result["Quaternion"].GetLength.func_doc = """GetLength() -> float


Returns geometric length of this quaternion.



"""
   result["Quaternion"].GetNormalized.func_doc = """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


"""
   result["Quaternion"].Normalize.func_doc = """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


"""
   result["Quaternion"].GetInverse.func_doc = """GetInverse() -> Quaternion


Returns the inverse of this quaternion.



"""
   result["Quaternion"].GetZero.func_doc = """**classmethod** GetZero() -> Quaternion


Returns the zero quaternion, which has a real part of 0 and an
imaginary part of (0,0,0).



"""
   result["Quaternion"].GetIdentity.func_doc = """**classmethod** GetIdentity() -> Quaternion


Returns the identity quaternion, which has a real part of 1 and an
imaginary part of (0,0,0).



"""
   result["Quatf"].__doc__ = """
Basic type: a quaternion, a complex number with a real coefficient and
three imaginary coefficients, stored as a 3-vector.

"""
   result["Quatf"].__init__.func_doc = """__init__()


Default constructor leaves the quaternion undefined.




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

__init__(realVal)


Initialize the real coefficient to ``realVal`` and the imaginary
coefficients to zero.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : float



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

__init__(real, i, j, k)


Initialize the real and imaginary coefficients.


Parameters
----------
real : float

i : float

j : float

k : float



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

__init__(real, imaginary)


Initialize the real and imaginary coefficients.


Parameters
----------
real : float

imaginary : Vec3f



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

__init__(other)


Construct from GfQuatd.


Parameters
----------
other : Quatd



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

__init__(other)


Implicitly convert from GfQuath.


Parameters
----------
other : Quath


"""
   result["Quatf"].GetReal.func_doc = """GetReal() -> float


Return the real coefficient.



"""
   result["Quatf"].SetReal.func_doc = """SetReal(real) -> None


Set the real coefficient.


Parameters
----------
real : float


"""
   result["Quatf"].GetImaginary.func_doc = """GetImaginary() -> Vec3f


Return the imaginary coefficient.



"""
   result["Quatf"].SetImaginary.func_doc = """SetImaginary(imaginary) -> None


Set the imaginary coefficients.


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



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

SetImaginary(i, j, k) -> None


Set the imaginary coefficients.


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

j : float

k : float


"""
   result["Quatf"].GetLength.func_doc = """GetLength() -> float


Return geometric length of this quaternion.



"""
   result["Quatf"].GetNormalized.func_doc = """GetNormalized(eps) -> Quatf


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


Parameters
----------
eps : float


"""
   result["Quatf"].Normalize.func_doc = """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


"""
   result["Quatf"].GetConjugate.func_doc = """GetConjugate() -> Quatf


Return this quaternion's conjugate, which is the quaternion with the
same real coefficient and negated imaginary coefficients.



"""
   result["Quatf"].GetInverse.func_doc = """GetInverse() -> Quatf


Return this quaternion's inverse, or reciprocal.


This is the quaternion's conjugate divided by it's squared length.



"""
   result["Quatf"].Transform.func_doc = """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


"""
   result["Quatf"].GetZero.func_doc = """**classmethod** GetZero() -> Quatf


Return the zero quaternion, with real coefficient 0 and an imaginary
coefficients all zero.



"""
   result["Quatf"].GetIdentity.func_doc = """**classmethod** GetIdentity() -> Quatf


Return the identity quaternion, with real coefficient 1 and an
imaginary coefficients all zero.



"""
   result["Quath"].__doc__ = """
Basic type: a quaternion, a complex number with a real coefficient and
three imaginary coefficients, stored as a 3-vector.

"""
   result["Quath"].__init__.func_doc = """__init__()


Default constructor leaves the quaternion undefined.




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

__init__(realVal)


Initialize the real coefficient to ``realVal`` and the imaginary
coefficients to zero.


Since quaternions typically must be normalized, reasonable values for
``realVal`` are -1, 0, or 1. Other values are legal but are likely to
be meaningless.


Parameters
----------
realVal : GfHalf



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

__init__(real, i, j, k)


Initialize the real and imaginary coefficients.


Parameters
----------
real : GfHalf

i : GfHalf

j : GfHalf

k : GfHalf



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

__init__(real, imaginary)


Initialize the real and imaginary coefficients.


Parameters
----------
real : GfHalf

imaginary : Vec3h



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

__init__(other)


Construct from GfQuatd.


Parameters
----------
other : Quatd



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

__init__(other)


Construct from GfQuatf.


Parameters
----------
other : Quatf


"""
   result["Quath"].GetReal.func_doc = """GetReal() -> GfHalf


Return the real coefficient.



"""
   result["Quath"].SetReal.func_doc = """SetReal(real) -> None


Set the real coefficient.


Parameters
----------
real : GfHalf


"""
   result["Quath"].GetImaginary.func_doc = """GetImaginary() -> Vec3h


Return the imaginary coefficient.



"""
   result["Quath"].SetImaginary.func_doc = """SetImaginary(imaginary) -> None


Set the imaginary coefficients.


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



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

SetImaginary(i, j, k) -> None


Set the imaginary coefficients.


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

j : GfHalf

k : GfHalf


"""
   result["Quath"].GetLength.func_doc = """GetLength() -> GfHalf


Return geometric length of this quaternion.



"""
   result["Quath"].GetNormalized.func_doc = """GetNormalized(eps) -> Quath


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


Parameters
----------
eps : GfHalf


"""
   result["Quath"].Normalize.func_doc = """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


"""
   result["Quath"].GetConjugate.func_doc = """GetConjugate() -> Quath


Return this quaternion's conjugate, which is the quaternion with the
same real coefficient and negated imaginary coefficients.



"""
   result["Quath"].GetInverse.func_doc = """GetInverse() -> Quath


Return this quaternion's inverse, or reciprocal.


This is the quaternion's conjugate divided by it's squared length.



"""
   result["Quath"].Transform.func_doc = """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


"""
   result["Quath"].GetZero.func_doc = """**classmethod** GetZero() -> Quath


Return the zero quaternion, with real coefficient 0 and an imaginary
coefficients all zero.



"""
   result["Quath"].GetIdentity.func_doc = """**classmethod** GetIdentity() -> Quath


Return the identity quaternion, with real coefficient 1 and an
imaginary coefficients all zero.



"""
   result["Range1d"].__doc__ = """
Basic type: 1-dimensional floating point range.

This class represents a 1-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range1d"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range1d"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : float

max : float


"""
   result["Range1d"].GetMin.func_doc = """GetMin() -> float


Returns the minimum value of the range.



"""
   result["Range1d"].GetMax.func_doc = """GetMax() -> float


Returns the maximum value of the range.



"""
   result["Range1d"].GetSize.func_doc = """GetSize() -> float


Returns the size of the range.



"""
   result["Range1d"].GetMidpoint.func_doc = """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() .



"""
   result["Range1d"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : float


"""
   result["Range1d"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : float


"""
   result["Range1d"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range1d"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range1d"].UnionWith.func_doc = """UnionWith(b) -> Range1d


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


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



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

UnionWith(b) -> Range1d


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


Parameters
----------
b : float


"""
   result["Range1d"].IntersectWith.func_doc = """IntersectWith(b) -> Range1d


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


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


"""
   result["Range1d"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : float


"""
   result["Range1d"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range1d


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


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

b : Range1d


"""
   result["Range1d"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range1d


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


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

b : Range1d


"""
   result["Range1f"].__doc__ = """
Basic type: 1-dimensional floating point range.

This class represents a 1-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range1f"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range1f"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : float

max : float


"""
   result["Range1f"].GetMin.func_doc = """GetMin() -> float


Returns the minimum value of the range.



"""
   result["Range1f"].GetMax.func_doc = """GetMax() -> float


Returns the maximum value of the range.



"""
   result["Range1f"].GetSize.func_doc = """GetSize() -> float


Returns the size of the range.



"""
   result["Range1f"].GetMidpoint.func_doc = """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() .



"""
   result["Range1f"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : float


"""
   result["Range1f"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : float


"""
   result["Range1f"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range1f"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range1f"].UnionWith.func_doc = """UnionWith(b) -> Range1f


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


Parameters
----------
b : Range1f



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

UnionWith(b) -> Range1f


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


Parameters
----------
b : float


"""
   result["Range1f"].IntersectWith.func_doc = """IntersectWith(b) -> Range1f


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


Parameters
----------
b : Range1f


"""
   result["Range1f"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : float


"""
   result["Range1f"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range1f


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


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

b : Range1f


"""
   result["Range1f"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range1f


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


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

b : Range1f


"""
   result["Range2d"].__doc__ = """
Basic type: 2-dimensional floating point range.

This class represents a 2-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range2d"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range2d"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : Vec2d

max : Vec2d


"""
   result["Range2d"].GetMin.func_doc = """GetMin() -> Vec2d


Returns the minimum value of the range.



"""
   result["Range2d"].GetMax.func_doc = """GetMax() -> Vec2d


Returns the maximum value of the range.



"""
   result["Range2d"].GetSize.func_doc = """GetSize() -> Vec2d


Returns the size of the range.



"""
   result["Range2d"].GetMidpoint.func_doc = """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() .



"""
   result["Range2d"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : Vec2d


"""
   result["Range2d"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : Vec2d


"""
   result["Range2d"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range2d"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range2d"].UnionWith.func_doc = """UnionWith(b) -> Range2d


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


Parameters
----------
b : Range2d



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

UnionWith(b) -> Range2d


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


Parameters
----------
b : Vec2d


"""
   result["Range2d"].IntersectWith.func_doc = """IntersectWith(b) -> Range2d


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


Parameters
----------
b : Range2d


"""
   result["Range2d"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : Vec2d


"""
   result["Range2d"].GetCorner.func_doc = """GetCorner(i) -> Vec2d


Returns the ith corner of the range, in the following order: SW, SE,
NW, NE.


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


"""
   result["Range2d"].GetQuadrant.func_doc = """GetQuadrant(i) -> Range2d


Returns the ith quadrant of the range, in the following order: SW, SE,
NW, NE.


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


"""
   result["Range2d"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range2d


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


Parameters
----------
a : Range2d

b : Range2d


"""
   result["Range2d"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range2d


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


Parameters
----------
a : Range2d

b : Range2d


"""
   result["Range2f"].__doc__ = """
Basic type: 2-dimensional floating point range.

This class represents a 2-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range2f"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range2f"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : Vec2f

max : Vec2f


"""
   result["Range2f"].GetMin.func_doc = """GetMin() -> Vec2f


Returns the minimum value of the range.



"""
   result["Range2f"].GetMax.func_doc = """GetMax() -> Vec2f


Returns the maximum value of the range.



"""
   result["Range2f"].GetSize.func_doc = """GetSize() -> Vec2f


Returns the size of the range.



"""
   result["Range2f"].GetMidpoint.func_doc = """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() .



"""
   result["Range2f"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : Vec2f


"""
   result["Range2f"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : Vec2f


"""
   result["Range2f"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range2f"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range2f"].UnionWith.func_doc = """UnionWith(b) -> Range2f


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


Parameters
----------
b : Range2f



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

UnionWith(b) -> Range2f


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


Parameters
----------
b : Vec2f


"""
   result["Range2f"].IntersectWith.func_doc = """IntersectWith(b) -> Range2f


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


Parameters
----------
b : Range2f


"""
   result["Range2f"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : Vec2f


"""
   result["Range2f"].GetCorner.func_doc = """GetCorner(i) -> Vec2f


Returns the ith corner of the range, in the following order: SW, SE,
NW, NE.


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


"""
   result["Range2f"].GetQuadrant.func_doc = """GetQuadrant(i) -> Range2f


Returns the ith quadrant of the range, in the following order: SW, SE,
NW, NE.


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


"""
   result["Range2f"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range2f


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


Parameters
----------
a : Range2f

b : Range2f


"""
   result["Range2f"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range2f


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


Parameters
----------
a : Range2f

b : Range2f


"""
   result["Range3d"].__doc__ = """
Basic type: 3-dimensional floating point range.

This class represents a 3-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range3d"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range3d"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : Vec3d

max : Vec3d


"""
   result["Range3d"].GetMin.func_doc = """GetMin() -> Vec3d


Returns the minimum value of the range.



"""
   result["Range3d"].GetMax.func_doc = """GetMax() -> Vec3d


Returns the maximum value of the range.



"""
   result["Range3d"].GetSize.func_doc = """GetSize() -> Vec3d


Returns the size of the range.



"""
   result["Range3d"].GetMidpoint.func_doc = """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() .



"""
   result["Range3d"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : Vec3d


"""
   result["Range3d"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : Vec3d


"""
   result["Range3d"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range3d"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range3d"].UnionWith.func_doc = """UnionWith(b) -> Range3d


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


Parameters
----------
b : Range3d



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

UnionWith(b) -> Range3d


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


Parameters
----------
b : Vec3d


"""
   result["Range3d"].IntersectWith.func_doc = """IntersectWith(b) -> Range3d


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


Parameters
----------
b : Range3d


"""
   result["Range3d"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : Vec3d


"""
   result["Range3d"].GetCorner.func_doc = """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


"""
   result["Range3d"].GetOctant.func_doc = """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


"""
   result["Range3d"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range3d


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


Parameters
----------
a : Range3d

b : Range3d


"""
   result["Range3d"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range3d


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


Parameters
----------
a : Range3d

b : Range3d


"""
   result["Range3f"].__doc__ = """
Basic type: 3-dimensional floating point range.

This class represents a 3-dimensional range (or interval) All
operations are component-wise and conform to interval mathematics. An
empty range is one where max<min. The default empty is
[FLT_MAX,-FLT_MAX]

"""
   result["Range3f"].SetEmpty.func_doc = """SetEmpty() -> None


Sets the range to an empty interval.



"""
   result["Range3f"].__init__.func_doc = """__init__()


The default constructor creates an empty range.




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

__init__(min, max)


This constructor initializes the minimum and maximum points.


Parameters
----------
min : Vec3f

max : Vec3f


"""
   result["Range3f"].GetMin.func_doc = """GetMin() -> Vec3f


Returns the minimum value of the range.



"""
   result["Range3f"].GetMax.func_doc = """GetMax() -> Vec3f


Returns the maximum value of the range.



"""
   result["Range3f"].GetSize.func_doc = """GetSize() -> Vec3f


Returns the size of the range.



"""
   result["Range3f"].GetMidpoint.func_doc = """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() .



"""
   result["Range3f"].SetMin.func_doc = """SetMin(min) -> None


Sets the minimum value of the range.


Parameters
----------
min : Vec3f


"""
   result["Range3f"].SetMax.func_doc = """SetMax(max) -> None


Sets the maximum value of the range.


Parameters
----------
max : Vec3f


"""
   result["Range3f"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether the range is empty (max<min).



"""
   result["Range3f"].Contains.func_doc = """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



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

Contains(range) -> bool


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


"""
   result["Range3f"].UnionWith.func_doc = """UnionWith(b) -> Range3f


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


Parameters
----------
b : Range3f



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

UnionWith(b) -> Range3f


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


Parameters
----------
b : Vec3f


"""
   result["Range3f"].IntersectWith.func_doc = """IntersectWith(b) -> Range3f


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


Parameters
----------
b : Range3f


"""
   result["Range3f"].GetDistanceSquared.func_doc = """GetDistanceSquared(p) -> float


Compute the squared distance from a point to the range.


Parameters
----------
p : Vec3f


"""
   result["Range3f"].GetCorner.func_doc = """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


"""
   result["Range3f"].GetOctant.func_doc = """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


"""
   result["Range3f"].GetUnion.func_doc = """**classmethod** GetUnion(a, b) -> Range3f


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


Parameters
----------
a : Range3f

b : Range3f


"""
   result["Range3f"].GetIntersection.func_doc = """**classmethod** GetIntersection(a, b) -> Range3f


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


Parameters
----------
a : Range3f

b : Range3f


"""
   result["Ray"].__doc__ = """
Basic type: Ray used for intersection testing

This class represents a three-dimensional ray in space, typically used
for intersection testing. It consists of an origin and a direction.

Note that by default a ``GfRay`` does not normalize its direction
vector to unit length.

Note for ray intersections, the start point is included in the
computations, i.e., a distance of zero is defined to be intersecting.

"""
   result["Ray"].__init__.func_doc = """__init__()


The default constructor leaves the ray parameters undefined.




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

__init__(startPoint, direction)


This constructor takes a starting point and a direction.


Parameters
----------
startPoint : Vec3d

direction : Vec3d


"""
   result["Ray"].SetPointAndDirection.func_doc = """SetPointAndDirection(startPoint, direction) -> None


Sets the ray by specifying a starting point and a direction.


Parameters
----------
startPoint : Vec3d

direction : Vec3d


"""
   result["Ray"].SetEnds.func_doc = """SetEnds(startPoint, endPoint) -> None


Sets the ray by specifying a starting point and an ending point.


Parameters
----------
startPoint : Vec3d

endPoint : Vec3d


"""
   result["Ray"].GetPoint.func_doc = """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


"""
   result["Ray"].Transform.func_doc = """Transform(matrix) -> Ray


Transforms the ray by the given matrix.


Parameters
----------
matrix : Matrix4d


"""
   result["Ray"].FindClosestPoint.func_doc = """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


"""
   result["Rect2i"].__doc__ = """
A 2D rectangle with integer coordinates.

A rectangle is internally represented as two corners. We refer to
these as the min and max corner where the min's x-coordinate and
y-coordinate are assumed to be less than or equal to the max's
corresponding coordinates. Normally, it is expressed as a min corner
and a size.

Note that the max corner is included when computing the size (width
and height) of a rectangle as the number of integral points in the x-
and y-direction. In particular, if the min corner and max corner are
the same, then the width and the height of the rectangle will both be
one since we have exactly one integral point with coordinates greater
or equal to the min corner and less or equal to the max corner.

Specifically, *width = maxX - minX + 1* and *height = maxY - minY +
1.*

"""
   result["Rect2i"].__init__.func_doc = """__init__()


Constructs an empty rectangle.




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

__init__(min, max)


Constructs a rectangle with ``min`` and ``max`` corners.


Parameters
----------
min : Vec2i

max : Vec2i



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

__init__(min, width, height)


Constructs a rectangle with ``min`` corner and the indicated ``width``
and ``height`` .


Parameters
----------
min : Vec2i

width : int

height : int


"""
   result["Rect2i"].IsNull.func_doc = """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.



"""
   result["Rect2i"].IsEmpty.func_doc = """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.



"""
   result["Rect2i"].IsValid.func_doc = """IsValid() -> bool


Return true if the rectangle is valid (equivalently, not empty).



"""
   result["Rect2i"].GetNormalized.func_doc = """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.



"""
   result["Rect2i"].GetMin.func_doc = """GetMin() -> Vec2i


Returns the min corner of the rectangle.



"""
   result["Rect2i"].GetMax.func_doc = """GetMax() -> Vec2i


Returns the max corner of the rectangle.



"""
   result["Rect2i"].GetMinX.func_doc = """GetMinX() -> int


Return the X value of min corner.



"""
   result["Rect2i"].SetMinX.func_doc = """SetMinX(x) -> None


Set the X value of the min corner.


Parameters
----------
x : int


"""
   result["Rect2i"].GetMaxX.func_doc = """GetMaxX() -> int


Return the X value of the max corner.



"""
   result["Rect2i"].SetMaxX.func_doc = """SetMaxX(x) -> None


Set the X value of the max corner.


Parameters
----------
x : int


"""
   result["Rect2i"].GetMinY.func_doc = """GetMinY() -> int


Return the Y value of the min corner.



"""
   result["Rect2i"].SetMinY.func_doc = """SetMinY(y) -> None


Set the Y value of the min corner.


Parameters
----------
y : int


"""
   result["Rect2i"].GetMaxY.func_doc = """GetMaxY() -> int


Return the Y value of the max corner.



"""
   result["Rect2i"].SetMaxY.func_doc = """SetMaxY(y) -> None


Set the Y value of the max corner.


Parameters
----------
y : int


"""
   result["Rect2i"].SetMin.func_doc = """SetMin(min) -> None


Sets the min corner of the rectangle.


Parameters
----------
min : Vec2i


"""
   result["Rect2i"].SetMax.func_doc = """SetMax(max) -> None


Sets the max corner of the rectangle.


Parameters
----------
max : Vec2i


"""
   result["Rect2i"].GetCenter.func_doc = """GetCenter() -> Vec2i


Returns the center point of the rectangle.



"""
   result["Rect2i"].Translate.func_doc = """Translate(displacement) -> None


Move the rectangle by ``displ`` .


Parameters
----------
displacement : Vec2i


"""
   result["Rect2i"].GetArea.func_doc = """GetArea() -> int


Return the area of the rectangle.



"""
   result["Rect2i"].GetSize.func_doc = """GetSize() -> Vec2i


Returns the size of the rectangle as a vector (width,height).



"""
   result["Rect2i"].GetWidth.func_doc = """GetWidth() -> int


Returns the width of the rectangle.



If the min and max x-coordinates are coincident, the width is one.



"""
   result["Rect2i"].GetHeight.func_doc = """GetHeight() -> int


Returns the height of the rectangle.



If the min and max y-coordinates are coincident, the height is one.



"""
   result["Rect2i"].GetIntersection.func_doc = """GetIntersection(that) -> Rect2i


Computes the intersection of two rectangles.


Parameters
----------
that : Rect2i


"""
   result["Rect2i"].GetUnion.func_doc = """GetUnion(that) -> Rect2i


Computes the union of two rectangles.


Parameters
----------
that : Rect2i


"""
   result["Rect2i"].Contains.func_doc = """Contains(p) -> bool


Returns true if the specified point in the rectangle.


Parameters
----------
p : Vec2i


"""
   result["Rotation"].__init__.func_doc = """__init__()


The default constructor leaves the rotation undefined.




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

__init__(axis, angle)


This constructor initializes the rotation to be ``angle`` degrees
about ``axis`` .


Parameters
----------
axis : Vec3d

angle : float



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

__init__(quaternion)


This constructor initializes the rotation from a quaternion.


Parameters
----------
quaternion : Quaternion



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

__init__(quat)


This constructor initializes the rotation from a quaternion.


Note that this constructor accepts GfQuatf and GfQuath since they
implicitly convert to GfQuatd.


Parameters
----------
quat : Quatd



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

__init__(rotateFrom, rotateTo)


This constructor initializes 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


"""
   result["Rotation"].SetAxisAngle.func_doc = """SetAxisAngle(axis, angle) -> Rotation


Sets the rotation to be ``angle`` degrees about ``axis`` .


Parameters
----------
axis : Vec3d

angle : float


"""
   result["Rotation"].SetQuat.func_doc = """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


"""
   result["Rotation"].SetQuaternion.func_doc = """SetQuaternion(quat) -> Rotation


Sets the rotation from a quaternion.


Parameters
----------
quat : Quaternion


"""
   result["Rotation"].SetRotateInto.func_doc = """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


"""
   result["Rotation"].SetIdentity.func_doc = """SetIdentity() -> Rotation


Sets the rotation to an identity rotation.


(This is chosen to be 0 degrees around the positive X axis.)



"""
   result["Rotation"].GetAxis.func_doc = """GetAxis() -> Vec3d


Returns the axis of rotation.



"""
   result["Rotation"].GetAngle.func_doc = """GetAngle() -> float


Returns the rotation angle in degrees.



"""
   result["Rotation"].GetQuaternion.func_doc = """GetQuaternion() -> Quaternion


Returns the rotation expressed as a quaternion.



"""
   result["Rotation"].GetQuat.func_doc = """GetQuat() -> Quatd


Returns the rotation expressed as a quaternion.



"""
   result["Rotation"].GetInverse.func_doc = """GetInverse() -> Rotation


Returns the inverse of this rotation.



"""
   result["Rotation"].Decompose.func_doc = """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


"""
   result["Rotation"].TransformDir.func_doc = """TransformDir(vec) -> Vec3f


Transforms row vector ``vec`` by the rotation, returning the result.


Parameters
----------
vec : Vec3f



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

TransformDir(vec) -> Vec3d


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


"""
   result["Rotation"].DecomposeRotation.func_doc = """**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


"""
   result["Rotation"].RotateOntoProjected.func_doc = """**classmethod** RotateOntoProjected(v1, v2, axis) -> Rotation


Parameters
----------
v1 : Vec3d

v2 : Vec3d

axis : Vec3d


"""
   result["Rotation"].MatchClosestEulerRotation.func_doc = """**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


"""
   result["Size2"].__init__.func_doc = """__init__()


Default constructor initializes components to zero.




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

__init__(o)


Copy constructor.


Parameters
----------
o : Size2



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

__init__(o)


Conversion from GfVec2i.


Parameters
----------
o : Vec2i



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

__init__(v)


Construct from an array.


Parameters
----------
v : int



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

__init__(v0, v1)


Construct from two values.


Parameters
----------
v0 : int

v1 : int


"""
   result["Size2"].Set.func_doc = """Set(v) -> Size2


Set to the values in a given array.


Parameters
----------
v : int



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

Set(v0, v1) -> Size2


Set to values passed directly.


Parameters
----------
v0 : int

v1 : int


"""
   result["Size3"].__init__.func_doc = """__init__()


Default constructor initializes components to zero.




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

__init__(o)


Copy constructor.


Parameters
----------
o : Size3



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

__init__(o)


Conversion from GfVec3i.


Parameters
----------
o : Vec3i



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

__init__(v)


Construct from an array.


Parameters
----------
v : int



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

__init__(v0, v1, v2)


Construct from three values.


Parameters
----------
v0 : int

v1 : int

v2 : int


"""
   result["Size3"].Set.func_doc = """Set(v) -> Size3


Set to the values in ``v`` .


Parameters
----------
v : int



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

Set(v0, v1, v2) -> Size3


Set to values passed directly.


Parameters
----------
v0 : int

v1 : int

v2 : int


"""
   result["Transform"].__doc__ = """
Basic type: Compound linear transformation.

This class represents a linear transformation specified as a series of
individual components: a *translation*, a *rotation*, a *scale*, a
*pivotPosition*, and a *pivotOrientation*. When applied to a point,
the point will be transformed as follows (in order):

   - Scaled by the *scale* with respect to *pivotPosition* and the
     orientation specified by the *pivotOrientation*.

   - Rotated by the *rotation* about *pivotPosition*.

   - Translated by *Translation*
     That is, the cumulative matrix that this represents looks like this.

.. code-block:: text

  M = -P \\* -O \\* S \\* O \\* R \\* P \\* T

where

   - *T* is the *translation* matrix

   - *P* is the matrix that translates by *pivotPosition*

   - *R* is the *rotation* matrix

   - *O* is the matrix that rotates to *pivotOrientation*

   - *S* is the *scale* matrix


"""
   result["Transform"].SetMatrix.func_doc = """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


"""
   result["Transform"].SetIdentity.func_doc = """SetIdentity() -> Transform


Sets the transformation to the identity transformation.



"""
   result["Transform"].SetScale.func_doc = """SetScale(scale) -> None


Sets the scale component, leaving all others untouched.


Parameters
----------
scale : Vec3d


"""
   result["Transform"].SetPivotOrientation.func_doc = """SetPivotOrientation(pivotOrient) -> None


Sets the pivot orientation component, leaving all others untouched.


Parameters
----------
pivotOrient : Rotation


"""
   result["Transform"].SetRotation.func_doc = """SetRotation(rotation) -> None


Sets the rotation component, leaving all others untouched.


Parameters
----------
rotation : Rotation


"""
   result["Transform"].SetPivotPosition.func_doc = """SetPivotPosition(pivPos) -> None


Sets the pivot position component, leaving all others untouched.


Parameters
----------
pivPos : Vec3d


"""
   result["Transform"].SetTranslation.func_doc = """SetTranslation(translation) -> None


Sets the translation component, leaving all others untouched.


Parameters
----------
translation : Vec3d


"""
   result["Transform"].GetScale.func_doc = """GetScale() -> Vec3d


Returns the scale component.



"""
   result["Transform"].GetPivotOrientation.func_doc = """GetPivotOrientation() -> Rotation


Returns the pivot orientation component.



"""
   result["Transform"].GetRotation.func_doc = """GetRotation() -> Rotation


Returns the rotation component.



"""
   result["Transform"].GetPivotPosition.func_doc = """GetPivotPosition() -> Vec3d


Returns the pivot position component.



"""
   result["Transform"].GetTranslation.func_doc = """GetTranslation() -> Vec3d


Returns the translation component.



"""
   result["Transform"].GetMatrix.func_doc = """GetMatrix() -> Matrix4d


Returns a ``GfMatrix4d`` that implements the cumulative
transformation.



"""
   result["Vec2d"].__doc__ = """
Basic type for a vector of 2 double components.

Represents a vector of 2 components of type ``double`` . It is
intended to be fast and simple.

"""
   result["Vec2d"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Implicitly convert from GfVec2f.


Parameters
----------
other : Vec2f



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

__init__(other)


Implicitly convert from GfVec2h.


Parameters
----------
other : Vec2h



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

__init__(other)


Implicitly convert from GfVec2i.


Parameters
----------
other : Vec2i


"""
   result["Vec2d"].GetProjection.func_doc = """GetProjection(v) -> Vec2d


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec2d


"""
   result["Vec2d"].GetComplement.func_doc = """GetComplement(b) -> Vec2d


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec2d


"""
   result["Vec2d"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec2d"].Normalize.func_doc = """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


"""
   result["Vec2d"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec2d


Parameters
----------
eps : float


"""
   result["Vec2d"].XAxis.func_doc = """**classmethod** XAxis() -> Vec2d


Create a unit vector along the X-axis.



"""
   result["Vec2d"].YAxis.func_doc = """**classmethod** YAxis() -> Vec2d


Create a unit vector along the Y-axis.



"""
   result["Vec2d"].Axis.func_doc = """**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


"""
   result["Vec2f"].__doc__ = """
Basic type for a vector of 2 float components.

Represents a vector of 2 components of type ``float`` . It is intended
to be fast and simple.

"""
   result["Vec2f"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec2d.


Parameters
----------
other : Vec2d



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

__init__(other)


Implicitly convert from GfVec2h.


Parameters
----------
other : Vec2h



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

__init__(other)


Implicitly convert from GfVec2i.


Parameters
----------
other : Vec2i


"""
   result["Vec2f"].GetProjection.func_doc = """GetProjection(v) -> Vec2f


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec2f


"""
   result["Vec2f"].GetComplement.func_doc = """GetComplement(b) -> Vec2f


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec2f


"""
   result["Vec2f"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec2f"].Normalize.func_doc = """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


"""
   result["Vec2f"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec2f


Parameters
----------
eps : float


"""
   result["Vec2f"].XAxis.func_doc = """**classmethod** XAxis() -> Vec2f


Create a unit vector along the X-axis.



"""
   result["Vec2f"].YAxis.func_doc = """**classmethod** YAxis() -> Vec2f


Create a unit vector along the Y-axis.



"""
   result["Vec2f"].Axis.func_doc = """**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


"""
   result["Vec2h"].__doc__ = """
Basic type for a vector of 2 GfHalf components.

Represents a vector of 2 components of type ``GfHalf`` . It is
intended to be fast and simple.

"""
   result["Vec2h"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : GfHalf



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

__init__(s0, s1)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : GfHalf

s1 : GfHalf



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec2d.


Parameters
----------
other : Vec2d



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

__init__(other)


Construct from GfVec2f.


Parameters
----------
other : Vec2f



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

__init__(other)


Implicitly convert from GfVec2i.


Parameters
----------
other : Vec2i


"""
   result["Vec2h"].GetProjection.func_doc = """GetProjection(v) -> Vec2h


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec2h


"""
   result["Vec2h"].GetComplement.func_doc = """GetComplement(b) -> Vec2h


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec2h


"""
   result["Vec2h"].GetLength.func_doc = """GetLength() -> GfHalf


Length.



"""
   result["Vec2h"].Normalize.func_doc = """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


"""
   result["Vec2h"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec2h


Parameters
----------
eps : GfHalf


"""
   result["Vec2h"].XAxis.func_doc = """**classmethod** XAxis() -> Vec2h


Create a unit vector along the X-axis.



"""
   result["Vec2h"].YAxis.func_doc = """**classmethod** YAxis() -> Vec2h


Create a unit vector along the Y-axis.



"""
   result["Vec2h"].Axis.func_doc = """**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


"""
   result["Vec2i"].__doc__ = """
Basic type for a vector of 2 int components.

Represents a vector of 2 components of type ``int`` . It is intended
to be fast and simple.

"""
   result["Vec2i"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : int



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

__init__(s0, s1)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : int

s1 : int



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl


"""
   result["Vec2i"].XAxis.func_doc = """**classmethod** XAxis() -> Vec2i


Create a unit vector along the X-axis.



"""
   result["Vec2i"].YAxis.func_doc = """**classmethod** YAxis() -> Vec2i


Create a unit vector along the Y-axis.



"""
   result["Vec2i"].Axis.func_doc = """**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


"""
   result["Vec3d"].__doc__ = """
Basic type for a vector of 3 double components.

Represents a vector of 3 components of type ``double`` . It is
intended to be fast and simple.

"""
   result["Vec3d"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1, s2)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float

s2 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Implicitly convert from GfVec3f.


Parameters
----------
other : Vec3f



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

__init__(other)


Implicitly convert from GfVec3h.


Parameters
----------
other : Vec3h



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

__init__(other)


Implicitly convert from GfVec3i.


Parameters
----------
other : Vec3i


"""
   result["Vec3d"].GetProjection.func_doc = """GetProjection(v) -> Vec3d


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec3d


"""
   result["Vec3d"].GetComplement.func_doc = """GetComplement(b) -> Vec3d


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec3d


"""
   result["Vec3d"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec3d"].Normalize.func_doc = """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


"""
   result["Vec3d"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec3d


Parameters
----------
eps : float


"""
   result["Vec3d"].BuildOrthonormalFrame.func_doc = """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


"""
   result["Vec3d"].XAxis.func_doc = """**classmethod** XAxis() -> Vec3d


Create a unit vector along the X-axis.



"""
   result["Vec3d"].YAxis.func_doc = """**classmethod** YAxis() -> Vec3d


Create a unit vector along the Y-axis.



"""
   result["Vec3d"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec3d


Create a unit vector along the Z-axis.



"""
   result["Vec3d"].Axis.func_doc = """**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


"""
   result["Vec3d"].OrthogonalizeBasis.func_doc = """**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


"""
   result["Vec3f"].__doc__ = """
Basic type for a vector of 3 float components.

Represents a vector of 3 components of type ``float`` . It is intended
to be fast and simple.

"""
   result["Vec3f"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1, s2)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float

s2 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec3d.


Parameters
----------
other : Vec3d



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

__init__(other)


Implicitly convert from GfVec3h.


Parameters
----------
other : Vec3h



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

__init__(other)


Implicitly convert from GfVec3i.


Parameters
----------
other : Vec3i


"""
   result["Vec3f"].GetProjection.func_doc = """GetProjection(v) -> Vec3f


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec3f


"""
   result["Vec3f"].GetComplement.func_doc = """GetComplement(b) -> Vec3f


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec3f


"""
   result["Vec3f"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec3f"].Normalize.func_doc = """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


"""
   result["Vec3f"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec3f


Parameters
----------
eps : float


"""
   result["Vec3f"].BuildOrthonormalFrame.func_doc = """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


"""
   result["Vec3f"].XAxis.func_doc = """**classmethod** XAxis() -> Vec3f


Create a unit vector along the X-axis.



"""
   result["Vec3f"].YAxis.func_doc = """**classmethod** YAxis() -> Vec3f


Create a unit vector along the Y-axis.



"""
   result["Vec3f"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec3f


Create a unit vector along the Z-axis.



"""
   result["Vec3f"].Axis.func_doc = """**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


"""
   result["Vec3f"].OrthogonalizeBasis.func_doc = """**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


"""
   result["Vec3h"].__doc__ = """
Basic type for a vector of 3 GfHalf components.

Represents a vector of 3 components of type ``GfHalf`` . It is
intended to be fast and simple.

"""
   result["Vec3h"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : GfHalf



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

__init__(s0, s1, s2)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : GfHalf

s1 : GfHalf

s2 : GfHalf



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec3d.


Parameters
----------
other : Vec3d



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

__init__(other)


Construct from GfVec3f.


Parameters
----------
other : Vec3f



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

__init__(other)


Implicitly convert from GfVec3i.


Parameters
----------
other : Vec3i


"""
   result["Vec3h"].GetProjection.func_doc = """GetProjection(v) -> Vec3h


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec3h


"""
   result["Vec3h"].GetComplement.func_doc = """GetComplement(b) -> Vec3h


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec3h


"""
   result["Vec3h"].GetLength.func_doc = """GetLength() -> GfHalf


Length.



"""
   result["Vec3h"].Normalize.func_doc = """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


"""
   result["Vec3h"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec3h


Parameters
----------
eps : GfHalf


"""
   result["Vec3h"].BuildOrthonormalFrame.func_doc = """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


"""
   result["Vec3h"].XAxis.func_doc = """**classmethod** XAxis() -> Vec3h


Create a unit vector along the X-axis.



"""
   result["Vec3h"].YAxis.func_doc = """**classmethod** YAxis() -> Vec3h


Create a unit vector along the Y-axis.



"""
   result["Vec3h"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec3h


Create a unit vector along the Z-axis.



"""
   result["Vec3h"].Axis.func_doc = """**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


"""
   result["Vec3h"].OrthogonalizeBasis.func_doc = """**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


"""
   result["Vec3i"].__doc__ = """
Basic type for a vector of 3 int components.

Represents a vector of 3 components of type ``int`` . It is intended
to be fast and simple.

"""
   result["Vec3i"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : int



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

__init__(s0, s1, s2)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : int

s1 : int

s2 : int



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl


"""
   result["Vec3i"].XAxis.func_doc = """**classmethod** XAxis() -> Vec3i


Create a unit vector along the X-axis.



"""
   result["Vec3i"].YAxis.func_doc = """**classmethod** YAxis() -> Vec3i


Create a unit vector along the Y-axis.



"""
   result["Vec3i"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec3i


Create a unit vector along the Z-axis.



"""
   result["Vec3i"].Axis.func_doc = """**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


"""
   result["Vec4d"].__doc__ = """
Basic type for a vector of 4 double components.

Represents a vector of 4 components of type ``double`` . It is
intended to be fast and simple.

"""
   result["Vec4d"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1, s2, s3)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float

s2 : float

s3 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Implicitly convert from GfVec4f.


Parameters
----------
other : Vec4f



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

__init__(other)


Implicitly convert from GfVec4h.


Parameters
----------
other : Vec4h



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

__init__(other)


Implicitly convert from GfVec4i.


Parameters
----------
other : Vec4i


"""
   result["Vec4d"].GetProjection.func_doc = """GetProjection(v) -> Vec4d


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec4d


"""
   result["Vec4d"].GetComplement.func_doc = """GetComplement(b) -> Vec4d


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec4d


"""
   result["Vec4d"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec4d"].Normalize.func_doc = """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


"""
   result["Vec4d"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec4d


Parameters
----------
eps : float


"""
   result["Vec4d"].XAxis.func_doc = """**classmethod** XAxis() -> Vec4d


Create a unit vector along the X-axis.



"""
   result["Vec4d"].YAxis.func_doc = """**classmethod** YAxis() -> Vec4d


Create a unit vector along the Y-axis.



"""
   result["Vec4d"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec4d


Create a unit vector along the Z-axis.



"""
   result["Vec4d"].WAxis.func_doc = """**classmethod** WAxis() -> Vec4d


Create a unit vector along the W-axis.



"""
   result["Vec4d"].Axis.func_doc = """**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


"""
   result["Vec4f"].__doc__ = """
Basic type for a vector of 4 float components.

Represents a vector of 4 components of type ``float`` . It is intended
to be fast and simple.

"""
   result["Vec4f"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : float



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

__init__(s0, s1, s2, s3)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : float

s1 : float

s2 : float

s3 : float



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec4d.


Parameters
----------
other : Vec4d



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

__init__(other)


Implicitly convert from GfVec4h.


Parameters
----------
other : Vec4h



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

__init__(other)


Implicitly convert from GfVec4i.


Parameters
----------
other : Vec4i


"""
   result["Vec4f"].GetProjection.func_doc = """GetProjection(v) -> Vec4f


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec4f


"""
   result["Vec4f"].GetComplement.func_doc = """GetComplement(b) -> Vec4f


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec4f


"""
   result["Vec4f"].GetLength.func_doc = """GetLength() -> float


Length.



"""
   result["Vec4f"].Normalize.func_doc = """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


"""
   result["Vec4f"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec4f


Parameters
----------
eps : float


"""
   result["Vec4f"].XAxis.func_doc = """**classmethod** XAxis() -> Vec4f


Create a unit vector along the X-axis.



"""
   result["Vec4f"].YAxis.func_doc = """**classmethod** YAxis() -> Vec4f


Create a unit vector along the Y-axis.



"""
   result["Vec4f"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec4f


Create a unit vector along the Z-axis.



"""
   result["Vec4f"].WAxis.func_doc = """**classmethod** WAxis() -> Vec4f


Create a unit vector along the W-axis.



"""
   result["Vec4f"].Axis.func_doc = """**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


"""
   result["Vec4h"].__doc__ = """
Basic type for a vector of 4 GfHalf components.

Represents a vector of 4 components of type ``GfHalf`` . It is
intended to be fast and simple.

"""
   result["Vec4h"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : GfHalf



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

__init__(s0, s1, s2, s3)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : GfHalf

s1 : GfHalf

s2 : GfHalf

s3 : GfHalf



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl



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

__init__(other)


Construct from GfVec4d.


Parameters
----------
other : Vec4d



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

__init__(other)


Construct from GfVec4f.


Parameters
----------
other : Vec4f



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

__init__(other)


Implicitly convert from GfVec4i.


Parameters
----------
other : Vec4i


"""
   result["Vec4h"].GetProjection.func_doc = """GetProjection(v) -> Vec4h


Returns the projection of ``this`` onto ``v`` .


That is:

.. code-block:: text

  v \\* (\\*this \\* v)



Parameters
----------
v : Vec4h


"""
   result["Vec4h"].GetComplement.func_doc = """GetComplement(b) -> Vec4h


Returns the orthogonal complement of ``this->GetProjection(b)`` .


That is:

.. code-block:: text

  \\*this - this->GetProjection(b)



Parameters
----------
b : Vec4h


"""
   result["Vec4h"].GetLength.func_doc = """GetLength() -> GfHalf


Length.



"""
   result["Vec4h"].Normalize.func_doc = """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


"""
   result["Vec4h"].GetNormalized.func_doc = """GetNormalized(eps) -> Vec4h


Parameters
----------
eps : GfHalf


"""
   result["Vec4h"].XAxis.func_doc = """**classmethod** XAxis() -> Vec4h


Create a unit vector along the X-axis.



"""
   result["Vec4h"].YAxis.func_doc = """**classmethod** YAxis() -> Vec4h


Create a unit vector along the Y-axis.



"""
   result["Vec4h"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec4h


Create a unit vector along the Z-axis.



"""
   result["Vec4h"].WAxis.func_doc = """**classmethod** WAxis() -> Vec4h


Create a unit vector along the W-axis.



"""
   result["Vec4h"].Axis.func_doc = """**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


"""
   result["Vec4i"].__doc__ = """
Basic type for a vector of 4 int components.

Represents a vector of 4 components of type ``int`` . It is intended
to be fast and simple.

"""
   result["Vec4i"].__init__.func_doc = """__init__()


Default constructor does no initialization.




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

__init__(value)


Initialize all elements to a single value.


Parameters
----------
value : int



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

__init__(s0, s1, s2, s3)


Initialize all elements with explicit arguments.


Parameters
----------
s0 : int

s1 : int

s2 : int

s3 : int



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

__init__(p)


Construct with pointer to values.


Parameters
----------
p : Scl


"""
   result["Vec4i"].XAxis.func_doc = """**classmethod** XAxis() -> Vec4i


Create a unit vector along the X-axis.



"""
   result["Vec4i"].YAxis.func_doc = """**classmethod** YAxis() -> Vec4i


Create a unit vector along the Y-axis.



"""
   result["Vec4i"].ZAxis.func_doc = """**classmethod** ZAxis() -> Vec4i


Create a unit vector along the Z-axis.



"""
   result["Vec4i"].WAxis.func_doc = """**classmethod** WAxis() -> Vec4i


Create a unit vector along the W-axis.



"""
   result["Vec4i"].Axis.func_doc = """**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


"""
   result["DualQuatd"].__doc__ = """"""
   result["DualQuatf"].__doc__ = """"""
   result["DualQuath"].__doc__ = """"""
   result["Matrix2d"].__doc__ = """"""
   result["Matrix2f"].__doc__ = """"""
   result["Matrix3d"].__doc__ = """"""
   result["Matrix3f"].__doc__ = """"""
   result["Matrix4d"].__doc__ = """"""
   result["Matrix4f"].__doc__ = """"""
   result["Quatd"].__doc__ = """"""
   result["Quatf"].__doc__ = """"""
   result["Quath"].__doc__ = """"""
   result["Rect2i"].__doc__ = """"""
   result["Transform"].__doc__ = """"""
   result["Vec2d"].__doc__ = """"""
   result["Vec2f"].__doc__ = """"""
   result["Vec2h"].__doc__ = """"""
   result["Vec2i"].__doc__ = """"""
   result["Vec3d"].__doc__ = """"""
   result["Vec3f"].__doc__ = """"""
   result["Vec3h"].__doc__ = """"""
   result["Vec3i"].__doc__ = """"""
   result["Vec4d"].__doc__ = """"""
   result["Vec4f"].__doc__ = """"""
   result["Vec4h"].__doc__ = """"""
   result["Vec4i"].__doc__ = """"""
   result["GetHomogenized"].func_doc = """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


"""
   result["HomogeneousCross"].func_doc = """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



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

HomogeneousCross(a, b) -> Vec4d


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


"""
   result["MultiInterval"].__doc__ = """"""
   result["IsClose"].func_doc = """IsClose(a, b, epsilon) -> bool


Returns true if ``a`` and ``b`` are with ``epsilon`` of each other.


Parameters
----------
a : float

b : float

epsilon : float


"""
   result["RadiansToDegrees"].func_doc = """RadiansToDegrees(radians) -> float


Converts an angle in radians to degrees.


Parameters
----------
radians : float


"""
   result["DegreesToRadians"].func_doc = """DegreesToRadians(degrees) -> float


Converts an angle in degrees to radians.


Parameters
----------
degrees : float


"""
   result["Sqr"].func_doc = """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


"""
   result["Sgn"].func_doc = """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


"""
   result["Sqrt"].func_doc = """Sqrt(f) -> float


Return sqrt( ``f`` ).


Parameters
----------
f : float



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

Sqrt(f) -> float


Return sqrt( ``f`` ).


Parameters
----------
f : float


"""
   result["Exp"].func_doc = """Exp(f) -> float


Return exp( ``f`` ).


Parameters
----------
f : float



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

Exp(f) -> float


Return exp( ``f`` ).


Parameters
----------
f : float


"""
   result["Log"].func_doc = """Log(f) -> float


Return log( ``f`` ).


Parameters
----------
f : float



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

Log(f) -> float


Return log( ``f`` ).


Parameters
----------
f : float


"""
   result["Floor"].func_doc = """Floor(f) -> float


Return floor( ``f`` ).


Parameters
----------
f : float



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

Floor(f) -> float


Return floor( ``f`` ).


Parameters
----------
f : float


"""
   result["Ceil"].func_doc = """Ceil(f) -> float


Return ceil( ``f`` ).


Parameters
----------
f : float



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

Ceil(f) -> float


Return ceil( ``f`` ).


Parameters
----------
f : float


"""
   result["Abs"].func_doc = """Abs(f) -> float


Return abs( ``f`` ).


Parameters
----------
f : float



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

Abs(f) -> float


Return abs( ``f`` ).


Parameters
----------
f : float


"""
   result["Round"].func_doc = """Round(f) -> float


Return round( ``f`` ).


Parameters
----------
f : float



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

Round(f) -> float


Return round( ``f`` ).


Parameters
----------
f : float


"""
   result["Pow"].func_doc = """Pow(f, p) -> float


Return pow( ``f`` , ``p`` ).


Parameters
----------
f : float

p : float



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

Pow(f, p) -> float


Return pow( ``f`` , ``p`` ).


Parameters
----------
f : float

p : float


"""
   result["Clamp"].func_doc = """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



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

Clamp(value, min, 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


"""
   result["Mod"].func_doc = """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


"""
   result["Lerp"].func_doc = """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


"""
   result["Min"].func_doc = """Min(a1, a2) -> T


Returns the smallest of the given ``values`` .


Parameters
----------
a1 : T

a2 : T


"""
   result["Max"].func_doc = """Max(a1, a2) -> T


Returns the largest of the given ``values`` .


Parameters
----------
a1 : T

a2 : T


"""
   result["Dot"].func_doc = """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


"""
   result["CompMult"].func_doc = """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


"""
   result["CompDiv"].func_doc = """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


"""
   result["Camera"].__doc__ = """"""
   result["Plane"].__doc__ = """"""
   result["Range1d"].__doc__ = """"""
   result["Range1f"].__doc__ = """"""
   result["Range2d"].__doc__ = """"""
   result["Range2f"].__doc__ = """"""
   result["Range3d"].__doc__ = """"""
   result["Range3f"].__doc__ = """"""
   result["Ray"].__doc__ = """"""
   result["Camera"].focalLength = property(result["Camera"].focalLength.fget, result["Camera"].focalLength.fset, result["Camera"].focalLength.fdel, """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).

""")
   result["Camera"].horizontalAperture = property(result["Camera"].horizontalAperture.fget, result["Camera"].horizontalAperture.fset, result["Camera"].horizontalAperture.fdel, """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).

""")
   result["Camera"].verticalAperture = property(result["Camera"].verticalAperture.fget, result["Camera"].verticalAperture.fset, result["Camera"].verticalAperture.fdel, """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).

""")
   result["Camera"].horizontalApertureOffset = property(result["Camera"].horizontalApertureOffset.fget, result["Camera"].horizontalApertureOffset.fset, result["Camera"].horizontalApertureOffset.fdel, """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).

""")
   result["Camera"].verticalApertureOffset = property(result["Camera"].verticalApertureOffset.fget, result["Camera"].verticalApertureOffset.fset, result["Camera"].verticalApertureOffset.fdel, """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).

""")
   result["Camera"].transform = property(result["Camera"].transform.fget, result["Camera"].transform.fset, result["Camera"].transform.fdel, """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`` .

""")
   result["Camera"].projection = property(result["Camera"].projection.fget, result["Camera"].projection.fset, result["Camera"].projection.fdel, """type : Projection


Returns the projection type.

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

type : None


Sets the projection type.

""")
   result["Camera"].clippingRange = property(result["Camera"].clippingRange.fget, result["Camera"].clippingRange.fset, result["Camera"].clippingRange.fdel, """type : Range1f


Returns the clipping range in world units.

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

type : None


Sets the clipping range in world units.

""")
   result["Camera"].clippingPlanes = property(result["Camera"].clippingPlanes.fget, result["Camera"].clippingPlanes.fset, result["Camera"].clippingPlanes.fdel, """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

where (x,y,z) are the coordinates in the camera's space.

""")
   result["Camera"].fStop = property(result["Camera"].fStop.fget, result["Camera"].fStop.fset, result["Camera"].fStop.fdel, """type : float


Returns the lens aperture.

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

type : None


Sets the lens aperture, unitless.

""")
   result["Camera"].focusDistance = property(result["Camera"].focusDistance.fget, result["Camera"].focusDistance.fset, result["Camera"].focusDistance.fdel, """type : float


Returns the focus distance in world units.

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

type : None


Sets the focus distance in world units.

""")
   result["Camera"].aspectRatio = property(result["Camera"].aspectRatio.fget, result["Camera"].aspectRatio.fset, result["Camera"].aspectRatio.fdel, """type : float


Returns the projector aperture aspect ratio.

""")
   result["Camera"].frustum = property(result["Camera"].frustum.fget, result["Camera"].frustum.fset, result["Camera"].frustum.fdel, """type : Frustum


Returns the computed, world-space camera frustum.


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

""")
   result["Quaternion"].real = property(result["Quaternion"].real.fget, result["Quaternion"].real.fset, result["Quaternion"].real.fdel, """type : None


Sets the real part of the quaternion.

""")
   result["Quaternion"].imaginary = property(result["Quaternion"].imaginary.fget, result["Quaternion"].imaginary.fset, result["Quaternion"].imaginary.fdel, """type : None


Sets the imaginary part of the quaternion.

""")
   result["Ray"].startPoint = property(result["Ray"].startPoint.fget, result["Ray"].startPoint.fset, result["Ray"].startPoint.fdel, """type : Vec3d


Returns the starting point of the segment.

""")
   result["Ray"].direction = property(result["Ray"].direction.fget, result["Ray"].direction.fset, result["Ray"].direction.fdel, """type : Vec3d


Returns the direction vector of the segment.


This is not guaranteed to be unit length.

""")