Gf module#

Summary: The Gf (Graphics Foundations) library contains classes and functions for working with basic mathematical aspects of graphics.

Graphics Foundation This package defines classes for fundamental graphics types and operations.

Classes:

`BBox3d`	Arbitrarily oriented 3D bounding box
`Camera`
`DualQuatd`
`DualQuatf`
`DualQuath`
`Frustum`	Basic view frustum
`Interval`	Basic mathematical interval class
`Line`	Line class
`LineSeg`	Line segment class
`Matrix2d`
`Matrix2f`
`Matrix3d`
`Matrix3f`
`Matrix4d`
`Matrix4f`
`MultiInterval`
`Plane`
`Quatd`
`Quaternion`	Quaternion class
`Quatf`
`Quath`
`Range1d`
`Range1f`
`Range2d`
`Range2f`
`Range3d`
`Range3f`
`Ray`
`Rect2i`
`Rotation`	3-space rotation
`Size2`	A 2D size class
`Size3`	A 3D size class
`Transform`
`Vec2d`
`Vec2f`
`Vec2h`
`Vec2i`
`Vec3d`
`Vec3f`
`Vec3h`
`Vec3i`
`Vec4d`
`Vec4f`
`Vec4h`
`Vec4i`

class pxr.Gf.BBox3d#

Arbitrarily oriented 3D bounding box

Methods:

`Combine`	classmethod Combine(b1, b2) -> BBox3d
`ComputeAlignedBox`()	Returns the axis-aligned range (as a `GfRange3d` ) that results from applying the transformation matrix to the axis-aligned box and aligning the result.
`ComputeAlignedRange`()	Returns the axis-aligned range (as a `GfRange3d` ) that results from applying the transformation matrix to the wxis-aligned box and aligning the result.
`ComputeCentroid`()	Returns the centroid of the bounding box.
`GetBox`()	Returns the range of the axis-aligned untransformed box.
`GetInverseMatrix`()	Returns the inverse of the transformation matrix.
`GetMatrix`()	Returns the transformation matrix.
`GetRange`()	Returns the range of the axis-aligned untransformed box.
`GetVolume`()	Returns the volume of the box (0 for an empty box).
`HasZeroAreaPrimitives`()	Returns the current state of the zero-area primitives flag".
`Set`(box, matrix)	Sets the axis-aligned box and transformation matrix.
`SetHasZeroAreaPrimitives`(hasThem)	Sets the zero-area primitives flag to the given value.
`SetMatrix`(matrix)	Sets the transformation matrix only.
`SetRange`(box)	Sets the range of the axis-aligned box only.
`Transform`(matrix)	Transforms the bounding box by the given matrix, which is assumed to be a global transformation to apply to the box.

Attributes:

`box`
`hasZeroAreaPrimitives`
`matrix`

static Combine()#

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)

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.

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.

ComputeCentroid() → Vec3d#

Returns the centroid of the bounding box.

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

GetBox() → Range3d#

Returns the range of the axis-aligned untransformed box.

This synonym of GetRange exists for compatibility purposes.

GetInverseMatrix() → Matrix4d#

Returns the inverse of the transformation matrix.

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

GetMatrix() → Matrix4d#: Returns the transformation matrix.

GetRange() → Range3d#: Returns the range of the axis-aligned untransformed box.

GetVolume() → float#: Returns the volume of the box (0 for an empty box).

HasZeroAreaPrimitives() → bool#: Returns the current state of the zero-area primitives flag”.

Set(box, matrix) → None#

Sets the axis-aligned box and transformation matrix.

Parameters:

box (Range3d)
matrix (Matrix4d)

SetHasZeroAreaPrimitives(hasThem) → None#

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

Parameters:: hasThem (bool)

SetMatrix(matrix) → None#

Sets the transformation matrix only.

The axis-aligned box is not modified.

Parameters:: matrix (Matrix4d)

SetRange(box) → None#

Sets the range of the axis-aligned box only.

The transformation matrix is not modified.

Parameters:: box (Range3d)

Transform(matrix) → None#

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

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

Parameters:: matrix (Matrix4d)

property box#

property hasZeroAreaPrimitives#

property matrix#

class pxr.Gf.Camera#

Classes:

`FOVDirection`	Direction used for Field of View or orthographic size.
`Projection`	Projection type.

Methods:

`GetFieldOfView`(direction)	Returns the horizontal or vertical field of view in degrees.
`SetFromViewAndProjectionMatrix`(viewMatrix, ...)	Sets the camera from a view and projection matrix.
`SetOrthographicFromAspectRatioAndSize`(...)	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).
`SetPerspectiveFromAspectRatioAndFieldOfView`(...)	Sets the frustum to be projective with the given `aspectRatio` and horizontal, respectively, vertical field of view `fieldOfView` (similar to gluPerspective when direction = FOVVertical).

Attributes:

`APERTURE_UNIT`
`DEFAULT_HORIZONTAL_APERTURE`
`DEFAULT_VERTICAL_APERTURE`
`FOCAL_LENGTH_UNIT`
`FOVHorizontal`
`FOVVertical`
`Orthographic`
`Perspective`
`aspectRatio`	float
`clippingPlanes`	list[Vec4f]
`clippingRange`	Range1f
`fStop`	float
`focalLength`	float
`focusDistance`	float
`frustum`	Frustum
`horizontalAperture`	float
`horizontalApertureOffset`	float
`horizontalFieldOfView`
`projection`	Projection
`transform`	Matrix4d
`verticalAperture`	float
`verticalApertureOffset`	float
`verticalFieldOfView`

class FOVDirection#

Direction used for Field of View or orthographic size.

Methods:

GetValueFromName

Attributes:

allValues

static GetValueFromName()#

allValues = (Gf.Camera.FOVHorizontal, Gf.Camera.FOVVertical)#

class Projection#

Projection type.

Methods:

GetValueFromName

Attributes:

allValues

static GetValueFromName()#

allValues = (Gf.Camera.Perspective, Gf.Camera.Orthographic)#

GetFieldOfView(direction) → float#

Returns the horizontal or vertical field of view in degrees.

Parameters:: direction (FOVDirection)

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)

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)

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)

APERTURE_UNIT = 0.1#

DEFAULT_HORIZONTAL_APERTURE = 20.955#

DEFAULT_VERTICAL_APERTURE = 15.290799999999999#

FOCAL_LENGTH_UNIT = 0.1#

FOVHorizontal = Gf.Camera.FOVHorizontal#

FOVVertical = Gf.Camera.FOVVertical#

Orthographic = Gf.Camera.Orthographic#

Perspective = Gf.Camera.Perspective#

property aspectRatio#

float

Returns the projector aperture aspect ratio.

Type:: type

property clippingPlanes#

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.

Type:: type

property clippingRange#

Range1f

Returns the clipping range in world units.

type : None

Sets the clipping range in world units.

Type:: type

property fStop#

float

Returns the lens aperture.

type : None

Sets the lens aperture, unitless.

Type:: type

property focalLength#

float

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

type : None

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

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

Type:: type

property focusDistance#

float

Returns the focus distance in world units.

type : None

Sets the focus distance in world units.

Type:: type

property frustum#

Frustum

Returns the computed, world-space camera frustum.

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

Type:: type

property horizontalAperture#

float

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

type : None

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

Type:: type

property horizontalApertureOffset#

float

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

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

type : None

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

Type:: type

property horizontalFieldOfView#

property projection#

Projection

Returns the projection type.

type : None

Sets the projection type.

Type:: type

property transform#

Matrix4d

Returns the transform of the filmback in world space.

This is exactly the transform specified via SetTransform() .

type : None

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

Type:: type

property verticalAperture#

float

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

type : None

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

Type:: type

property verticalApertureOffset#

float

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

type : None

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

Type:: type

property verticalFieldOfView#

class pxr.Gf.DualQuatd#

Methods:

`GetConjugate`()	Returns the conjugate of this dual quaternion.
`GetDual`()	Returns the dual part of the dual quaternion.
`GetIdentity`	classmethod GetIdentity() -> DualQuatd
`GetInverse`()	Returns the inverse of this dual quaternion.
`GetLength`()	Returns geometric length of this dual quaternion.
`GetNormalized`(eps)	Returns a normalized (unit-length) version of this dual quaternion.
`GetReal`()	Returns the real part of the dual quaternion.
`GetTranslation`()	Get the translation component of this dual quaternion.
`GetZero`	classmethod GetZero() -> DualQuatd
`Normalize`(eps)	Normalizes this dual quaternion in place.
`SetDual`(dual)	Sets the dual part of the dual quaternion.
`SetReal`(real)	Sets the real part of the dual quaternion.
`SetTranslation`(translation)	Set the translation component of this dual quaternion.
`Transform`(vec)	Transforms the row vector vec by the dual quaternion.

Attributes:

`dual`
`real`

GetConjugate() → DualQuatd#: Returns the conjugate of this dual quaternion.

GetDual() → Quatd#: Returns the dual part of the dual quaternion.

static GetIdentity()#

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).

GetInverse() → DualQuatd#: Returns the inverse of this dual quaternion.

GetLength() → tuple[float, float]#: Returns geometric length of this dual quaternion.

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)

GetReal() → Quatd#: Returns the real part of the dual quaternion.

GetTranslation() → Vec3d#: Get the translation component of this dual quaternion.

static GetZero()#

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).

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)

SetDual(dual) → None#

Sets the dual part of the dual quaternion.

Parameters:: dual (Quatd)

SetReal(real) → None#

Sets the real part of the dual quaternion.

Parameters:: real (Quatd)

SetTranslation(translation) → None#

Set the translation component of this dual quaternion.

Parameters:: translation (Vec3d)

Transform(vec) → Vec3d#

Transforms the row vector vec by the dual quaternion.

Parameters:: vec (Vec3d)

property dual#

property real#

class pxr.Gf.DualQuatf#

Methods:

`GetConjugate`()	Returns the conjugate of this dual quaternion.
`GetDual`()	Returns the dual part of the dual quaternion.
`GetIdentity`	classmethod GetIdentity() -> DualQuatf
`GetInverse`()	Returns the inverse of this dual quaternion.
`GetLength`()	Returns geometric length of this dual quaternion.
`GetNormalized`(eps)	Returns a normalized (unit-length) version of this dual quaternion.
`GetReal`()	Returns the real part of the dual quaternion.
`GetTranslation`()	Get the translation component of this dual quaternion.
`GetZero`	classmethod GetZero() -> DualQuatf
`Normalize`(eps)	Normalizes this dual quaternion in place.
`SetDual`(dual)	Sets the dual part of the dual quaternion.
`SetReal`(real)	Sets the real part of the dual quaternion.
`SetTranslation`(translation)	Set the translation component of this dual quaternion.
`Transform`(vec)	Transforms the row vector vec by the dual quaternion.

Attributes:

`dual`
`real`

GetConjugate() → DualQuatf#: Returns the conjugate of this dual quaternion.

GetDual() → Quatf#: Returns the dual part of the dual quaternion.

static GetIdentity()#

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).

GetInverse() → DualQuatf#: Returns the inverse of this dual quaternion.

GetLength() → tuple[float, float]#: Returns geometric length of this dual quaternion.

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)

GetReal() → Quatf#: Returns the real part of the dual quaternion.

GetTranslation() → Vec3f#: Get the translation component of this dual quaternion.

static GetZero()#

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).

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)

SetDual(dual) → None#

Sets the dual part of the dual quaternion.

Parameters:: dual (Quatf)

SetReal(real) → None#

Sets the real part of the dual quaternion.

Parameters:: real (Quatf)

SetTranslation(translation) → None#

Set the translation component of this dual quaternion.

Parameters:: translation (Vec3f)

Transform(vec) → Vec3f#

Transforms the row vector vec by the dual quaternion.

Parameters:: vec (Vec3f)

property dual#

property real#

class pxr.Gf.DualQuath#

Methods:

`GetConjugate`()	Returns the conjugate of this dual quaternion.
`GetDual`()	Returns the dual part of the dual quaternion.
`GetIdentity`	classmethod GetIdentity() -> DualQuath
`GetInverse`()	Returns the inverse of this dual quaternion.
`GetLength`()	Returns geometric length of this dual quaternion.
`GetNormalized`(eps)	Returns a normalized (unit-length) version of this dual quaternion.
`GetReal`()	Returns the real part of the dual quaternion.
`GetTranslation`()	Get the translation component of this dual quaternion.
`GetZero`	classmethod GetZero() -> DualQuath
`Normalize`(eps)	Normalizes this dual quaternion in place.
`SetDual`(dual)	Sets the dual part of the dual quaternion.
`SetReal`(real)	Sets the real part of the dual quaternion.
`SetTranslation`(translation)	Set the translation component of this dual quaternion.
`Transform`(vec)	Transforms the row vector vec by the dual quaternion.

Attributes:

`dual`
`real`

GetConjugate() → DualQuath#: Returns the conjugate of this dual quaternion.

GetDual() → Quath#: Returns the dual part of the dual quaternion.

static GetIdentity()#

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).

GetInverse() → DualQuath#: Returns the inverse of this dual quaternion.

GetLength() → tuple[GfHalf, GfHalf]#: Returns geometric length of this dual quaternion.

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)

GetReal() → Quath#: Returns the real part of the dual quaternion.

GetTranslation() → Vec3h#: Get the translation component of this dual quaternion.

static GetZero()#

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).

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)

SetDual(dual) → None#

Sets the dual part of the dual quaternion.

Parameters:: dual (Quath)

SetReal(real) → None#

Sets the real part of the dual quaternion.

Parameters:: real (Quath)

SetTranslation(translation) → None#

Set the translation component of this dual quaternion.

Parameters:: translation (Vec3h)

Transform(vec) → Vec3h#

Transforms the row vector vec by the dual quaternion.

Parameters:: vec (Vec3h)

property dual#

property real#

class pxr.Gf.Frustum#

Basic view frustum

Classes:

ProjectionType

This enum is used to determine the type of projection represented by a frustum.

Methods:

`ComputeAspectRatio`()	Returns the aspect ratio of the frustum, defined as the width of the window divided by the height.
`ComputeCorners`()	Returns the world-space corners of the frustum as a vector of 8 points, ordered as:
`ComputeCornersAtDistance`(d)	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:
`ComputeLookAtPoint`()	Computes and returns the world-space look-at point from the eye point (position), view direction (rotation), and view distance.
`ComputeNarrowedFrustum`(windowPos, size)	Returns a frustum that is a narrowed-down version of this frustum.
`ComputePickRay`(windowPos)	Builds and returns a `GfRay` that can be used for picking at the given normalized (-1 to +1 in both dimensions) window position.
`ComputeProjectionMatrix`()	Returns a GL-style projection matrix corresponding to the frustum's projection.
`ComputeUpVector`()	Returns the normalized world-space up vector, which is computed by rotating the y axis by the frustum's rotation.
`ComputeViewDirection`()	Returns the normalized world-space view direction vector, which is computed by rotating the -z axis by the frustum's rotation.
`ComputeViewFrame`(side, up, view)	Computes the view frame defined by this frustum.
`ComputeViewInverse`()	Returns a matrix that represents the inverse viewing transformation for this frustum.
`ComputeViewMatrix`()	Returns a matrix that represents the viewing transformation for this frustum.
`FitToSphere`(center, radius, slack)	Modifies the frustum to tightly enclose a sphere with the given center and radius, using the current view direction.
`GetFOV`	Returns the horizontal fov of the frustum.
`GetNearFar`()	Returns the near/far interval.
`GetOrthographic`(left, right, bottom, top, ...)	Returns the current frustum in the format used by `SetOrthographic()` .
`GetPerspective`	Returns the current perspective frustum values suitable for use by SetPerspective.
`GetPosition`()	Returns the position of the frustum in world space.
`GetProjectionType`()	Returns the projection type.
`GetReferencePlaneDepth`	classmethod GetReferencePlaneDepth() -> float
`GetRotation`()	Returns the orientation of the frustum in world space as a rotation to apply to the -z axis.
`GetViewDistance`()	Returns the view distance.
`GetWindow`()	Returns the window rectangle in the reference plane.
`Intersects`(bbox)	Returns true if the given axis-aligned bbox is inside or intersecting the frustum.
`IntersectsViewVolume`	classmethod IntersectsViewVolume(bbox, vpMat) -> bool
`SetNearFar`(nearFar)	Sets the near/far interval.
`SetOrthographic`(left, right, bottom, top, ...)	Sets up the frustum in a manner similar to `glOrtho()` .
`SetPerspective`(fieldOfViewHeight, ...)	Sets up the frustum in a manner similar to `gluPerspective()` .
`SetPosition`(position)	Sets the position of the frustum in world space.
`SetPositionAndRotationFromMatrix`(camToWorldXf)	Sets the position and rotation of the frustum from a camera matrix (always from a y-Up camera).
`SetProjectionType`(projectionType)	Sets the projection type.
`SetRotation`(rotation)	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".
`SetViewDistance`(viewDistance)	Sets the view distance.
`SetWindow`(window)	Sets the window rectangle in the reference plane that defines the left, right, top, and bottom planes of the frustum.
`Transform`(matrix)	Transforms the frustum by the given matrix.

Attributes:

`Orthographic`
`Perspective`
`nearFar`
`position`
`projectionType`
`rotation`
`viewDistance`
`window`

class ProjectionType#

This enum is used to determine the type of projection represented by a frustum.

Methods:

GetValueFromName

Attributes:

allValues

static GetValueFromName()#

allValues = (Gf.Frustum.Orthographic, Gf.Frustum.Perspective)#

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.

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

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)

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

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)

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)

ComputeProjectionMatrix() → Matrix4d#: Returns a GL-style projection matrix corresponding to the frustum’s projection.

ComputeUpVector() → Vec3d#: Returns the normalized world-space up vector, which is computed by rotating the y axis by the frustum’s rotation.

ComputeViewDirection() → Vec3d#: Returns the normalized world-space view direction vector, which is computed by rotating the -z axis by the frustum’s rotation.

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.

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

Parameters:

side (Vec3d)
up (Vec3d)
view (Vec3d)

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.

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.

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)

GetFOV()#

Returns the horizontal fov of the frustum. The fov of the frustum is not necessarily the same value as displayed in the viewer. The displayed fov is a function of the focal length or FOV avar. The frustum’s fov may be different due to things like lens breathing.

If the frustum is not of type GfFrustum::Perspective, the returned FOV will be 0.0.

GetNearFar() → Range1d#: Returns the near/far interval.

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)

GetPerspective()#: Returns the current perspective frustum values suitable for use by SetPerspective. If the current frustum is a perspective projection, the return value is a tuple of fieldOfView, aspectRatio, nearDistance, farDistance). If the current frustum is not perspective, the return value is None.

GetPosition() → Vec3d#: Returns the position of the frustum in world space.

GetProjectionType() → Frustum.ProjectionType#: Returns the projection type.

static GetReferencePlaneDepth()#

classmethod GetReferencePlaneDepth() -> float

Returns the depth of the reference plane.

GetRotation() → Rotation#: Returns the orientation of the frustum in world space as a rotation to apply to the -z axis.

GetViewDistance() → float#: Returns the view distance.

GetWindow() → Range2d#: Returns the window rectangle in the reference plane.

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)

static IntersectsViewVolume()#

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)

SetNearFar(nearFar) → None#

Sets the near/far interval.

Parameters:: nearFar (Range1d)

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)

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:

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)

SetPosition(position) → None#

Sets the position of the frustum in world space.

Parameters:: position (Vec3d)

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)

SetProjectionType(projectionType) → None#

Sets the projection type.

Parameters:: projectionType (Frustum.ProjectionType)

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)

SetViewDistance(viewDistance) → None#

Sets the view distance.

Parameters:: viewDistance (float)

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)

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)

Orthographic = Gf.Frustum.Orthographic#

Perspective = Gf.Frustum.Perspective#

property nearFar#

property position#

property projectionType#

property rotation#

property viewDistance#

property window#

class pxr.Gf.Interval#

Basic mathematical interval class

Methods:

`Contains`	Returns true if x is inside the interval.
`GetFullInterval`	classmethod GetFullInterval() -> Interval
`GetMax`	Get the maximum value.
`GetMin`	Get the minimum value.
`GetSize`	The width of the interval
`In`	Returns true if x is inside the interval.
`Intersects`(i)	Return true iff the given interval i intersects this interval.
`IsEmpty`	True if the interval is empty.
`IsFinite`()	Returns true if both the maximum and minimum value are finite.
`IsMaxClosed`()	Maximum boundary condition.
`IsMaxFinite`()	Returns true if the maximum value is finite.
`IsMaxOpen`()	Maximum boundary condition.
`IsMinClosed`()	Minimum boundary condition.
`IsMinFinite`()	Returns true if the minimum value is finite.
`IsMinOpen`()	Minimum boundary condition.
`SetMax`	Set the maximum value.
`SetMin`	Set the minimum value.

Attributes:

`finite`
`isEmpty`	True if the interval is empty.
`max`	The maximum value.
`maxClosed`
`maxFinite`
`maxOpen`
`min`	The minimum value.
`minClosed`
`minFinite`
`minOpen`
`size`	The width of the interval.

Contains()#

Returns true if x is inside the interval.

static GetFullInterval()#

classmethod GetFullInterval() -> Interval

Returns the full interval (-inf, inf).

GetMax()#: Get the maximum value.

GetMin()#: Get the minimum value.

GetSize()#: The width of the interval

In()#: Returns true if x is inside the interval.

Intersects(i) → bool#

Return true iff the given interval i intersects this interval.

Parameters:: i (Interval)

IsEmpty()#: True if the interval is empty.

IsFinite() → bool#: Returns true if both the maximum and minimum value are finite.

IsMaxClosed() → bool#: Maximum boundary condition.

IsMaxFinite() → bool#: Returns true if the maximum value is finite.

IsMaxOpen() → bool#: Maximum boundary condition.

IsMinClosed() → bool#: Minimum boundary condition.

IsMinFinite() → bool#: Returns true if the minimum value is finite.

IsMinOpen() → bool#: Minimum boundary condition.

SetMax()#

Set the maximum value.

Set the maximum value and boundary condition.

SetMin()#

Set the minimum value.

Set the minimum value and boundary condition.

property finite#

property isEmpty#: True if the interval is empty.

property max#: The maximum value.

property maxClosed#

property maxFinite#

property maxOpen#

property min#: The minimum value.

property minClosed#

property minFinite#

property minOpen#

property size#: The width of the interval.

class pxr.Gf.Line#

Line class

Methods:

`FindClosestPoint`(point, t)	Returns the point on the line that is closest to `point` .
`GetDirection`()	Return the normalized direction of the line.
`GetPoint`(t)	Return the point on the line at ```` ( p0 + t * dir).
`Set`(p0, dir)

Attributes:

direction

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)

GetDirection() → Vec3d#: Return the normalized direction of the line.

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)

Set(p0, dir) → float#

Parameters:

p0 (Vec3d)
dir (Vec3d)

property direction#

class pxr.Gf.LineSeg#

Line segment class

Methods:

`FindClosestPoint`(point, t)	Returns the point on the line that is closest to `point` .
`GetDirection`()	Return the normalized direction of the line.
`GetLength`()	Return the length of the line.
`GetPoint`(t)	Return the point on the segment specified by the parameter t.

Attributes:

`direction`
`length`

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)

GetDirection() → Vec3d#: Return the normalized direction of the line.

GetLength() → float#: Return the length of the line.

GetPoint(t) → Vec3d#

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

p = p0 + t * (p1 - p0)

Parameters:: t (float)

property direction#

property length#

class pxr.Gf.Matrix2d#

Methods:

`GetColumn`(i)	Gets a column of the matrix as a Vec2.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetRow`(i)	Gets a row of the matrix as a Vec2.
`GetTranspose`()	Returns the transpose of the matrix.
`Set`(m00, m01, m10, m11)	Sets the matrix from 4 independent `double` values, specified in row-major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec2.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetRow`(i, v)	Sets a row of the matrix from a Vec2.
`SetZero`()	Sets the matrix to zero.

Attributes:

dimension

GetColumn(i) → Vec2d#

Gets a column of the matrix as a Vec2.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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)

GetRow(i) → Vec2d#

Gets a row of the matrix as a Vec2.

Parameters:: i (int)

GetTranspose() → Matrix2d#: Returns the transpose of the matrix.

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec2.

Parameters:

i (int)
v (Vec2d)

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)

SetIdentity() → Matrix2d#: Sets the matrix to the identity matrix.

SetRow(i, v) → None#

Sets a row of the matrix from a Vec2.

Parameters:

i (int)
v (Vec2d)

SetZero() → Matrix2d#: Sets the matrix to zero.

dimension = (2, 2)#

class pxr.Gf.Matrix2f#

Methods:

`GetColumn`(i)	Gets a column of the matrix as a Vec2.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetRow`(i)	Gets a row of the matrix as a Vec2.
`GetTranspose`()	Returns the transpose of the matrix.
`Set`(m00, m01, m10, m11)	Sets the matrix from 4 independent `float` values, specified in row- major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec2.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetRow`(i, v)	Sets a row of the matrix from a Vec2.
`SetZero`()	Sets the matrix to zero.

Attributes:

dimension

GetColumn(i) → Vec2f#

Gets a column of the matrix as a Vec2.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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)

GetRow(i) → Vec2f#

Gets a row of the matrix as a Vec2.

Parameters:: i (int)

GetTranspose() → Matrix2f#: Returns the transpose of the matrix.

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec2.

Parameters:

i (int)
v (Vec2f)

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)

SetIdentity() → Matrix2f#: Sets the matrix to the identity matrix.

SetRow(i, v) → None#

Sets a row of the matrix from a Vec2.

Parameters:

i (int)
v (Vec2f)

SetZero() → Matrix2f#: Sets the matrix to zero.

dimension = (2, 2)#

class pxr.Gf.Matrix3d#

Methods:

`ExtractRotation`()	Returns the rotation corresponding to this matrix.
`GetColumn`(i)	Gets a column of the matrix as a Vec3.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetHandedness`()	Returns the sign of the determinant of the matrix, i.e.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetOrthonormalized`(issueWarning)	Returns an orthonormalized copy of the matrix.
`GetRow`(i)	Gets a row of the matrix as a Vec3.
`GetTranspose`()	Returns the transpose of the matrix.
`IsLeftHanded`()	Returns true if the vectors in matrix form a left-handed coordinate system.
`IsRightHanded`()	Returns true if the vectors in the matrix form a right-handed coordinate system.
`Orthonormalize`(issueWarning)	Makes the matrix orthonormal in place.
`Set`(m00, m01, m02, m10, m11, m12, m20, m21, m22)	Sets the matrix from 9 independent `double` values, specified in row-major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec3.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetRotate`(rot)	Sets the matrix to specify a rotation equivalent to rot.
`SetRow`(i, v)	Sets a row of the matrix from a Vec3.
`SetScale`(scaleFactors)	Sets the matrix to specify a nonuniform scaling in x, y, and z by the factors in vector scaleFactors.
`SetZero`()	Sets the matrix to zero.

Attributes:

dimension

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.

GetColumn(i) → Vec3d#

Gets a column of the matrix as a Vec3.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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.

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)

GetOrthonormalized(issueWarning) → Matrix3d#

Returns an orthonormalized copy of the matrix.

Parameters:: issueWarning (bool)

GetRow(i) → Vec3d#

Gets a row of the matrix as a Vec3.

Parameters:: i (int)

GetTranspose() → Matrix3d#: Returns the transpose of the matrix.

IsLeftHanded() → bool#: Returns true if the vectors in matrix form a left-handed coordinate system.

IsRightHanded() → bool#: Returns true if the vectors in the matrix form a right-handed coordinate system.

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)

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec3.

Parameters:

i (int)
v (Vec3d)

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)

SetIdentity() → Matrix3d#: Sets the matrix to the identity matrix.

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)

SetRow(i, v) → None#

Sets a row of the matrix from a Vec3.

Parameters:

i (int)
v (Vec3d)

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)

SetZero() → Matrix3d#: Sets the matrix to zero.

dimension = (3, 3)#

class pxr.Gf.Matrix3f#

Methods:

`ExtractRotation`()	Returns the rotation corresponding to this matrix.
`GetColumn`(i)	Gets a column of the matrix as a Vec3.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetHandedness`()	Returns the sign of the determinant of the matrix, i.e.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetOrthonormalized`(issueWarning)	Returns an orthonormalized copy of the matrix.
`GetRow`(i)	Gets a row of the matrix as a Vec3.
`GetTranspose`()	Returns the transpose of the matrix.
`IsLeftHanded`()	Returns true if the vectors in matrix form a left-handed coordinate system.
`IsRightHanded`()	Returns true if the vectors in the matrix form a right-handed coordinate system.
`Orthonormalize`(issueWarning)	Makes the matrix orthonormal in place.
`Set`(m00, m01, m02, m10, m11, m12, m20, m21, m22)	Sets the matrix from 9 independent `float` values, specified in row- major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec3.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetRotate`(rot)	Sets the matrix to specify a rotation equivalent to rot.
`SetRow`(i, v)	Sets a row of the matrix from a Vec3.
`SetScale`(scaleFactors)	Sets the matrix to specify a nonuniform scaling in x, y, and z by the factors in vector scaleFactors.
`SetZero`()	Sets the matrix to zero.

Attributes:

dimension

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.

GetColumn(i) → Vec3f#

Gets a column of the matrix as a Vec3.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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.

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)

GetOrthonormalized(issueWarning) → Matrix3f#

Returns an orthonormalized copy of the matrix.

Parameters:: issueWarning (bool)

GetRow(i) → Vec3f#

Gets a row of the matrix as a Vec3.

Parameters:: i (int)

GetTranspose() → Matrix3f#: Returns the transpose of the matrix.

IsLeftHanded() → bool#: Returns true if the vectors in matrix form a left-handed coordinate system.

IsRightHanded() → bool#: Returns true if the vectors in the matrix form a right-handed coordinate system.

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)

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec3.

Parameters:

i (int)
v (Vec3f)

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)

SetIdentity() → Matrix3f#: Sets the matrix to the identity matrix.

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)

SetRow(i, v) → None#

Sets a row of the matrix from a Vec3.

Parameters:

i (int)
v (Vec3f)

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)

SetZero() → Matrix3f#: Sets the matrix to zero.

dimension = (3, 3)#

class pxr.Gf.Matrix4d#

Methods:

`ExtractRotation`()	Returns the rotation corresponding to this matrix.
`ExtractRotationMatrix`()	Returns the rotation corresponding to this matrix.
`ExtractRotationQuat`()	Return the rotation corresponding to this matrix as a quaternion.
`ExtractTranslation`()	Returns the translation part of the matrix, defined as the first three elements of the last row.
`Factor`(r, s, u, t, p, eps)	Factors the matrix into 5 components:
`GetColumn`(i)	Gets a column of the matrix as a Vec4.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetDeterminant3`()	Returns the determinant of the upper 3x3 matrix.
`GetHandedness`()	Returns the sign of the determinant of the upper 3x3 matrix, i.e.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetOrthonormalized`(issueWarning)	Returns an orthonormalized copy of the matrix.
`GetRow`(i)	Gets a row of the matrix as a Vec4.
`GetRow3`(i)	Gets a row of the matrix as a Vec3.
`GetTranspose`()	Returns the transpose of the matrix.
`HasOrthogonalRows3`()	Returns true, if the row vectors of the upper 3x3 matrix form an orthogonal basis.
`IsLeftHanded`()	Returns true if the vectors in the upper 3x3 matrix form a left-handed coordinate system.
`IsRightHanded`()	Returns true if the vectors in the upper 3x3 matrix form a right- handed coordinate system.
`Orthonormalize`(issueWarning)	Makes the matrix orthonormal in place.
`RemoveScaleShear`()	Returns the matrix with any scaling or shearing removed, leaving only the rotation and translation.
`Set`(m00, m01, m02, m03, m10, m11, m12, m13, ...)	Sets the matrix from 16 independent `double` values, specified in row-major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec4.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetLookAt`(eyePoint, centerPoint, upDirection)	Sets the matrix to specify a viewing matrix from parameters similar to those used by `gluLookAt(3G)` .
`SetRotate`(rot)	Sets the matrix to specify a rotation equivalent to rot, and clears the translation.
`SetRotateOnly`(rot)	Sets the matrix to specify a rotation equivalent to rot, without clearing the translation.
`SetRow`(i, v)	Sets a row of the matrix from a Vec4.
`SetRow3`(i, v)	Sets a row of the matrix from a Vec3.
`SetScale`(scaleFactors)	Sets the matrix to specify a nonuniform scaling in x, y, and z by the factors in vector scaleFactors.
`SetTransform`(rotate, translate)	Sets matrix to specify a rotation by rotate and a translation by translate.
`SetTranslate`(trans)	Sets matrix to specify a translation by the vector trans, and clears the rotation.
`SetTranslateOnly`(t)	Sets matrix to specify a translation by the vector trans, without clearing the rotation.
`SetZero`()	Sets the matrix to zero.
`Transform`(vec)	Transforms the row vector vec by the matrix, returning the result.
`TransformAffine`(vec)	Transforms the row vector vec by the matrix, returning the result.
`TransformDir`(vec)	Transforms row vector vec by the matrix, returning the result.

Attributes:

dimension

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.

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.

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.

ExtractTranslation() → Vec3d#: Returns the translation part of the matrix, defined as the first three elements of the last row.

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)

GetColumn(i) → Vec4d#

Gets a column of the matrix as a Vec4.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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.

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.

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)

GetOrthonormalized(issueWarning) → Matrix4d#

Returns an orthonormalized copy of the matrix.

Parameters:: issueWarning (bool)

GetRow(i) → Vec4d#

Gets a row of the matrix as a Vec4.

Parameters:: i (int)

GetRow3(i) → Vec3d#

Gets a row of the matrix as a Vec3.

Parameters:: i (int)

GetTranspose() → Matrix4d#: Returns the transpose of the matrix.

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.

IsLeftHanded() → bool#: Returns true if the vectors in the upper 3x3 matrix form a left-handed coordinate system.

IsRightHanded() → bool#: Returns true if the vectors in the upper 3x3 matrix form a right- handed coordinate system.

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)

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.

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec4.

Parameters:

i (int)
v (Vec4d)

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)

SetIdentity() → Matrix4d#: Sets the matrix to the identity matrix.

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)

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)

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)

SetRow(i, v) → None#

Sets a row of the matrix from a Vec4.

Parameters:

i (int)
v (Vec4d)

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)

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)

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)

SetTranslate(trans) → Matrix4d#

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

Parameters:: trans (Vec3d)

SetTranslateOnly(t) → Matrix4d#

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

Parameters:: t (Vec3d)

SetZero() → Matrix4d#: Sets the matrix to zero.

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)

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)

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)

dimension = (4, 4)#

class pxr.Gf.Matrix4f#

Methods:

`ExtractRotation`()	Returns the rotation corresponding to this matrix.
`ExtractRotationMatrix`()	Returns the rotation corresponding to this matrix.
`ExtractRotationQuat`()	Return the rotation corresponding to this matrix as a quaternion.
`ExtractTranslation`()	Returns the translation part of the matrix, defined as the first three elements of the last row.
`Factor`(r, s, u, t, p, eps)	Factors the matrix into 5 components:
`GetColumn`(i)	Gets a column of the matrix as a Vec4.
`GetDeterminant`()	Returns the determinant of the matrix.
`GetDeterminant3`()	Returns the determinant of the upper 3x3 matrix.
`GetHandedness`()	Returns the sign of the determinant of the upper 3x3 matrix, i.e.
`GetInverse`(det, eps)	Returns the inverse of the matrix, or FLT_MAX * SetIdentity() if the matrix is singular.
`GetOrthonormalized`(issueWarning)	Returns an orthonormalized copy of the matrix.
`GetRow`(i)	Gets a row of the matrix as a Vec4.
`GetRow3`(i)	Gets a row of the matrix as a Vec3.
`GetTranspose`()	Returns the transpose of the matrix.
`HasOrthogonalRows3`()	Returns true, if the row vectors of the upper 3x3 matrix form an orthogonal basis.
`IsLeftHanded`()	Returns true if the vectors in the upper 3x3 matrix form a left-handed coordinate system.
`IsRightHanded`()	Returns true if the vectors in the upper 3x3 matrix form a right- handed coordinate system.
`Orthonormalize`(issueWarning)	Makes the matrix orthonormal in place.
`RemoveScaleShear`()	Returns the matrix with any scaling or shearing removed, leaving only the rotation and translation.
`Set`(m00, m01, m02, m03, m10, m11, m12, m13, ...)	Sets the matrix from 16 independent `float` values, specified in row-major order.
`SetColumn`(i, v)	Sets a column of the matrix from a Vec4.
`SetDiagonal`(s)	Sets the matrix to s times the identity matrix.
`SetIdentity`()	Sets the matrix to the identity matrix.
`SetLookAt`(eyePoint, centerPoint, upDirection)	Sets the matrix to specify a viewing matrix from parameters similar to those used by `gluLookAt(3G)` .
`SetRotate`(rot)	Sets the matrix to specify a rotation equivalent to rot, and clears the translation.
`SetRotateOnly`(rot)	Sets the matrix to specify a rotation equivalent to rot, without clearing the translation.
`SetRow`(i, v)	Sets a row of the matrix from a Vec4.
`SetRow3`(i, v)	Sets a row of the matrix from a Vec3.
`SetScale`(scaleFactors)	Sets the matrix to specify a nonuniform scaling in x, y, and z by the factors in vector scaleFactors.
`SetTransform`(rotate, translate)	Sets matrix to specify a rotation by rotate and a translation by translate.
`SetTranslate`(trans)	Sets matrix to specify a translation by the vector trans, and clears the rotation.
`SetTranslateOnly`(t)	Sets matrix to specify a translation by the vector trans, without clearing the rotation.
`SetZero`()	Sets the matrix to zero.
`Transform`(vec)	Transforms the row vector vec by the matrix, returning the result.
`TransformAffine`(vec)	Transforms the row vector vec by the matrix, returning the result.
`TransformDir`(vec)	Transforms row vector vec by the matrix, returning the result.

Attributes:

dimension

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.

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.

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.

ExtractTranslation() → Vec3f#: Returns the translation part of the matrix, defined as the first three elements of the last row.

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)

GetColumn(i) → Vec4f#

Gets a column of the matrix as a Vec4.

Parameters:: i (int)

GetDeterminant() → float#: Returns the determinant of the matrix.

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.

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.

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)

GetOrthonormalized(issueWarning) → Matrix4f#

Returns an orthonormalized copy of the matrix.

Parameters:: issueWarning (bool)

GetRow(i) → Vec4f#

Gets a row of the matrix as a Vec4.

Parameters:: i (int)

GetRow3(i) → Vec3f#

Gets a row of the matrix as a Vec3.

Parameters:: i (int)

GetTranspose() → Matrix4f#: Returns the transpose of the matrix.

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.

IsLeftHanded() → bool#: Returns true if the vectors in the upper 3x3 matrix form a left-handed coordinate system.

IsRightHanded() → bool#: Returns true if the vectors in the upper 3x3 matrix form a right- handed coordinate system.

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)

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.

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)

SetColumn(i, v) → None#

Sets a column of the matrix from a Vec4.

Parameters:

i (int)
v (Vec4f)

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)

SetIdentity() → Matrix4f#: Sets the matrix to the identity matrix.

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)

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)

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)

SetRow(i, v) → None#

Sets a row of the matrix from a Vec4.

Parameters:

i (int)
v (Vec4f)

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)

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)

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)

SetTranslate(trans) → Matrix4f#

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

Parameters:: trans (Vec3f)

SetTranslateOnly(t) → Matrix4f#

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

Parameters:: t (Vec3f)

SetZero() → Matrix4f#: Sets the matrix to zero.

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)

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)

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)

dimension = (4, 4)#

class pxr.Gf.MultiInterval#

Methods:

`Add`(i)	Add the given interval to the multi-interval.
`ArithmeticAdd`(i)	Uses the given interval to extend the multi-interval in the interval arithmetic sense.
`Clear`()	Clear the multi-interval.
`Contains`	Returns true if x is inside the multi-interval.
`GetBounds`()	Returns an interval bounding the entire multi-interval.
`GetComplement`()	Return the complement of this set.
`GetFullInterval`	classmethod GetFullInterval() -> MultiInterval
`GetSize`()	Returns the number of intervals in the set.
`Intersect`(i)
`IsEmpty`()	Returns true if the multi-interval is empty.
`Remove`(i)	Remove the given interval from this multi-interval.

Attributes:

`bounds`
`isEmpty`
`size`

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)

ArithmeticAdd(i) → None#

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

Parameters:: i (Interval)

Clear() → None#: Clear the multi-interval.

Contains()#

Returns true if x is inside the multi-interval.

GetBounds() → Interval#

Returns an interval bounding the entire multi-interval.

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

GetComplement() → MultiInterval#: Return the complement of this set.

static GetFullInterval()#

classmethod GetFullInterval() -> MultiInterval

Returns the full interval (-inf, inf).

GetSize() → int#: Returns the number of intervals in the set.

Intersect(i) → None#

Parameters:: i (Interval)

Intersect(s) -> None

Parameters:: s (MultiInterval)

IsEmpty() → bool#: Returns true if the multi-interval is empty.

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)

property bounds#

property isEmpty#

property size#

class pxr.Gf.Plane#

Methods:

`GetDistance`(p)	Returns the distance of point `from` the plane.
`GetDistanceFromOrigin`()	Returns the distance of the plane from the origin.
`GetEquation`()	Give the coefficients of the equation of the plane.
`GetNormal`()	Returns the unit-length normal vector of the plane.
`IntersectsPositiveHalfSpace`(box)	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.
`Project`(p)	Return the projection of `p` onto the plane.
`Reorient`(p)	Flip the plane normal (if necessary) so that `p` is in the positive halfspace.
`Set`(normal, distanceToOrigin)	Sets this to the plane perpendicular to `normal` and at `distance` units from the origin.
`Transform`(matrix)	Transforms the plane by the given matrix.

Attributes:

`distanceFromOrigin`
`normal`

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)

GetDistanceFromOrigin() → float#: Returns the distance of the plane from the origin.

GetEquation() → Vec4d#

Give the coefficients of the equation of the plane.

Suitable to OpenGL calls to set the clipping plane.

GetNormal() → Vec3d#: Returns the unit-length normal vector of the plane.

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)

Project(p) → Vec3d#

Return the projection of p onto the plane.

Parameters:: p (Vec3d)

Reorient(p) → None#

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

Parameters:: p (Vec3d)

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)

Transform(matrix) → Plane#

Transforms the plane by the given matrix.

Parameters:: matrix (Matrix4d)

property distanceFromOrigin#

property normal#

class pxr.Gf.Quatd#

Methods:

`GetConjugate`()	Return this quaternion's conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.
`GetIdentity`	classmethod GetIdentity() -> Quatd
`GetImaginary`()	Return the imaginary coefficient.
`GetInverse`()	Return this quaternion's inverse, or reciprocal.
`GetLength`()	Return geometric length of this quaternion.
`GetNormalized`(eps)	length of this quaternion is smaller than `eps` , return the identity quaternion.
`GetReal`()	Return the real coefficient.
`GetZero`	classmethod GetZero() -> Quatd
`Normalize`(eps)	Normalizes this quaternion in place to unit length, returning the length before normalization.
`SetImaginary`(imaginary)	Set the imaginary coefficients.
`SetReal`(real)	Set the real coefficient.
`Transform`(point)	Transform the GfVec3d point.

Attributes:

`imaginary`
`real`

GetConjugate() → Quatd#: Return this quaternion’s conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.

static GetIdentity()#

classmethod GetIdentity() -> Quatd

Return the identity quaternion, with real coefficient 1 and an imaginary coefficients all zero.

GetImaginary() → Vec3d#: Return the imaginary coefficient.

GetInverse() → Quatd#

Return this quaternion’s inverse, or reciprocal.

This is the quaternion’s conjugate divided by it’s squared length.

GetLength() → float#: Return geometric length of this quaternion.

GetNormalized(eps) → Quatd#

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

Parameters:: eps (float)

GetReal() → float#: Return the real coefficient.

static GetZero()#

classmethod GetZero() -> Quatd

Return the zero quaternion, with real coefficient 0 and an imaginary coefficients all zero.

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)

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)

SetReal(real) → None#

Set the real coefficient.

Parameters:: real (float)

Transform(point) → Vec3d#

Transform the GfVec3d point.

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

but is more efficient.

Parameters:: point (Vec3d)

property imaginary#

property real#

class pxr.Gf.Quaternion#

Quaternion class

Methods:

`GetIdentity`	classmethod GetIdentity() -> Quaternion
`GetImaginary`()	Returns the imaginary part of the quaternion.
`GetInverse`()	Returns the inverse of this quaternion.
`GetLength`()	Returns geometric length of this quaternion.
`GetNormalized`(eps)	Returns a normalized (unit-length) version of this quaternion.
`GetReal`()	Returns the real part of the quaternion.
`GetZero`	classmethod GetZero() -> Quaternion
`Normalize`(eps)	Normalizes this quaternion in place to unit length, returning the length before normalization.

Attributes:

`imaginary`	None
`real`	None

static GetIdentity()#

classmethod GetIdentity() -> Quaternion

Returns the identity quaternion, which has a real part of 1 and an imaginary part of (0,0,0).

GetImaginary() → Vec3d#: Returns the imaginary part of the quaternion.

GetInverse() → Quaternion#: Returns the inverse of this quaternion.

GetLength() → float#: Returns geometric length of this quaternion.

GetNormalized(eps) → Quaternion#

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

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

Parameters:: eps (float)

GetReal() → float#: Returns the real part of the quaternion.

static GetZero()#

classmethod GetZero() -> Quaternion

Returns the zero quaternion, which has a real part of 0 and an imaginary part of (0,0,0).

Normalize(eps) → float#

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

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

Parameters:: eps (float)

property imaginary#

None

Sets the imaginary part of the quaternion.

Type:: type

property real#

None

Sets the real part of the quaternion.

Type:: type

class pxr.Gf.Quatf#

Methods:

`GetConjugate`()	Return this quaternion's conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.
`GetIdentity`	classmethod GetIdentity() -> Quatf
`GetImaginary`()	Return the imaginary coefficient.
`GetInverse`()	Return this quaternion's inverse, or reciprocal.
`GetLength`()	Return geometric length of this quaternion.
`GetNormalized`(eps)	length of this quaternion is smaller than `eps` , return the identity quaternion.
`GetReal`()	Return the real coefficient.
`GetZero`	classmethod GetZero() -> Quatf
`Normalize`(eps)	Normalizes this quaternion in place to unit length, returning the length before normalization.
`SetImaginary`(imaginary)	Set the imaginary coefficients.
`SetReal`(real)	Set the real coefficient.
`Transform`(point)	Transform the GfVec3f point.

Attributes:

`imaginary`
`real`

GetConjugate() → Quatf#: Return this quaternion’s conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.

static GetIdentity()#

classmethod GetIdentity() -> Quatf

Return the identity quaternion, with real coefficient 1 and an imaginary coefficients all zero.

GetImaginary() → Vec3f#: Return the imaginary coefficient.

GetInverse() → Quatf#

Return this quaternion’s inverse, or reciprocal.

This is the quaternion’s conjugate divided by it’s squared length.

GetLength() → float#: Return geometric length of this quaternion.

GetNormalized(eps) → Quatf#

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

Parameters:: eps (float)

GetReal() → float#: Return the real coefficient.

static GetZero()#

classmethod GetZero() -> Quatf

Return the zero quaternion, with real coefficient 0 and an imaginary coefficients all zero.

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)

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)

SetReal(real) → None#

Set the real coefficient.

Parameters:: real (float)

Transform(point) → Vec3f#

Transform the GfVec3f point.

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

but is more efficient.

Parameters:: point (Vec3f)

property imaginary#

property real#

class pxr.Gf.Quath#

Methods:

`GetConjugate`()	Return this quaternion's conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.
`GetIdentity`	classmethod GetIdentity() -> Quath
`GetImaginary`()	Return the imaginary coefficient.
`GetInverse`()	Return this quaternion's inverse, or reciprocal.
`GetLength`()	Return geometric length of this quaternion.
`GetNormalized`(eps)	length of this quaternion is smaller than `eps` , return the identity quaternion.
`GetReal`()	Return the real coefficient.
`GetZero`	classmethod GetZero() -> Quath
`Normalize`(eps)	Normalizes this quaternion in place to unit length, returning the length before normalization.
`SetImaginary`(imaginary)	Set the imaginary coefficients.
`SetReal`(real)	Set the real coefficient.
`Transform`(point)	Transform the GfVec3h point.

Attributes:

`imaginary`
`real`

GetConjugate() → Quath#: Return this quaternion’s conjugate, which is the quaternion with the same real coefficient and negated imaginary coefficients.

static GetIdentity()#

classmethod GetIdentity() -> Quath

Return the identity quaternion, with real coefficient 1 and an imaginary coefficients all zero.

GetImaginary() → Vec3h#: Return the imaginary coefficient.

GetInverse() → Quath#

Return this quaternion’s inverse, or reciprocal.

This is the quaternion’s conjugate divided by it’s squared length.

GetLength() → GfHalf#: Return geometric length of this quaternion.

GetNormalized(eps) → Quath#

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

Parameters:: eps (GfHalf)

GetReal() → GfHalf#: Return the real coefficient.

static GetZero()#

classmethod GetZero() -> Quath

Return the zero quaternion, with real coefficient 0 and an imaginary coefficients all zero.

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)

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)

SetReal(real) → None#

Set the real coefficient.

Parameters:: real (GfHalf)

Transform(point) → Vec3h#

Transform the GfVec3h point.

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

but is more efficient.

Parameters:: point (Vec3h)

property imaginary#

property real#

class pxr.Gf.Range1d#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range1d
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range1d
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`

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)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (float)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range1d

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

Parameters:

a (Range1d)
b (Range1d)

GetMax() → float#: Returns the maximum value of the range.

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() .

GetMin() → float#: Returns the minimum value of the range.

GetSize() → float#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range1d

Returns the smallest GfRange1d which contains both a and b .

Parameters:

a (Range1d)
b (Range1d)

IntersectWith(b) → Range1d#

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

Parameters:: b (Range1d)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (float)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (float)

UnionWith(b) → Range1d#

Extend this to include b .

Parameters:: b (Range1d)

UnionWith(b) -> Range1d

Extend this to include b .

Parameters:: b (float)

dimension = 1#

property max#

property min#

class pxr.Gf.Range1f#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range1f
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range1f
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`

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)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (float)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range1f

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

Parameters:

a (Range1f)
b (Range1f)

GetMax() → float#: Returns the maximum value of the range.

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() .

GetMin() → float#: Returns the minimum value of the range.

GetSize() → float#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range1f

Returns the smallest GfRange1f which contains both a and b .

Parameters:

a (Range1f)
b (Range1f)

IntersectWith(b) → Range1f#

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

Parameters:: b (Range1f)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (float)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (float)

UnionWith(b) → Range1f#

Extend this to include b .

Parameters:: b (Range1f)

UnionWith(b) -> Range1f

Extend this to include b .

Parameters:: b (float)

dimension = 1#

property max#

property min#

class pxr.Gf.Range2d#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetCorner`(i)	Returns the ith corner of the range, in the following order: SW, SE, NW, NE.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range2d
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetQuadrant`(i)	Returns the ith quadrant of the range, in the following order: SW, SE, NW, NE.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range2d
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`
`unitSquare`

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)

GetCorner(i) → Vec2d#

Returns the ith corner of the range, in the following order: SW, SE, NW, NE.

Parameters:: i (int)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (Vec2d)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range2d

Returns a GfRange2d that describes the intersection of a and b .

Parameters:

a (Range2d)
b (Range2d)

GetMax() → Vec2d#: Returns the maximum value of the range.

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() .

GetMin() → Vec2d#: Returns the minimum value of the range.

GetQuadrant(i) → Range2d#

Returns the ith quadrant of the range, in the following order: SW, SE, NW, NE.

Parameters:: i (int)

GetSize() → Vec2d#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range2d

Returns the smallest GfRange2d which contains both a and b .

Parameters:

a (Range2d)
b (Range2d)

IntersectWith(b) → Range2d#

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

Parameters:: b (Range2d)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (Vec2d)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (Vec2d)

UnionWith(b) → Range2d#

Extend this to include b .

Parameters:: b (Range2d)

UnionWith(b) -> Range2d

Extend this to include b .

Parameters:: b (Vec2d)

dimension = 2#

property max#

property min#

unitSquare = Gf.Range2d(Gf.Vec2d(0.0, 0.0), Gf.Vec2d(1.0, 1.0))#

class pxr.Gf.Range2f#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetCorner`(i)	Returns the ith corner of the range, in the following order: SW, SE, NW, NE.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range2f
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetQuadrant`(i)	Returns the ith quadrant of the range, in the following order: SW, SE, NW, NE.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range2f
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`
`unitSquare`

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)

GetCorner(i) → Vec2f#

Returns the ith corner of the range, in the following order: SW, SE, NW, NE.

Parameters:: i (int)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (Vec2f)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range2f

Returns a GfRange2f that describes the intersection of a and b .

Parameters:

a (Range2f)
b (Range2f)

GetMax() → Vec2f#: Returns the maximum value of the range.

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() .

GetMin() → Vec2f#: Returns the minimum value of the range.

GetQuadrant(i) → Range2f#

Returns the ith quadrant of the range, in the following order: SW, SE, NW, NE.

Parameters:: i (int)

GetSize() → Vec2f#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range2f

Returns the smallest GfRange2f which contains both a and b .

Parameters:

a (Range2f)
b (Range2f)

IntersectWith(b) → Range2f#

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

Parameters:: b (Range2f)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (Vec2f)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (Vec2f)

UnionWith(b) → Range2f#

Extend this to include b .

Parameters:: b (Range2f)

UnionWith(b) -> Range2f

Extend this to include b .

Parameters:: b (Vec2f)

dimension = 2#

property max#

property min#

unitSquare = Gf.Range2f(Gf.Vec2f(0.0, 0.0), Gf.Vec2f(1.0, 1.0))#

class pxr.Gf.Range3d#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetCorner`(i)	Returns the ith corner of the range, in the following order: LDB, RDB, LUB, RUB, LDF, RDF, LUF, RUF.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range3d
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetOctant`(i)	Returns the ith octant of the range, in the following order: LDB, RDB, LUB, RUB, LDF, RDF, LUF, RUF.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range3d
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`
`unitCube`

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)

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)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (Vec3d)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range3d

Returns a GfRange3d that describes the intersection of a and b .

Parameters:

a (Range3d)
b (Range3d)

GetMax() → Vec3d#: Returns the maximum value of the range.

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() .

GetMin() → Vec3d#: Returns the minimum value of the range.

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)

GetSize() → Vec3d#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range3d

Returns the smallest GfRange3d which contains both a and b .

Parameters:

a (Range3d)
b (Range3d)

IntersectWith(b) → Range3d#

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

Parameters:: b (Range3d)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (Vec3d)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (Vec3d)

UnionWith(b) → Range3d#

Extend this to include b .

Parameters:: b (Range3d)

UnionWith(b) -> Range3d

Extend this to include b .

Parameters:: b (Vec3d)

dimension = 3#

property max#

property min#

unitCube = Gf.Range3d(Gf.Vec3d(0.0, 0.0, 0.0), Gf.Vec3d(1.0, 1.0, 1.0))#

class pxr.Gf.Range3f#

Methods:

`Contains`(point)	Returns true if the `point` is located inside the range.
`GetCorner`(i)	Returns the ith corner of the range, in the following order: LDB, RDB, LUB, RUB, LDF, RDF, LUF, RUF.
`GetDistanceSquared`(p)	Compute the squared distance from a point to the range.
`GetIntersection`	classmethod GetIntersection(a, b) -> Range3f
`GetMax`()	Returns the maximum value of the range.
`GetMidpoint`()	Returns the midpoint of the range, that is, 0.5*(min+max).
`GetMin`()	Returns the minimum value of the range.
`GetOctant`(i)	Returns the ith octant of the range, in the following order: LDB, RDB, LUB, RUB, LDF, RDF, LUF, RUF.
`GetSize`()	Returns the size of the range.
`GetUnion`	classmethod GetUnion(a, b) -> Range3f
`IntersectWith`(b)	Modifies this range to hold its intersection with `b` and returns the result.
`IsEmpty`()	Returns whether the range is empty (max<min).
`SetEmpty`()	Sets the range to an empty interval.
`SetMax`(max)	Sets the maximum value of the range.
`SetMin`(min)	Sets the minimum value of the range.
`UnionWith`(b)	Extend `this` to include `b` .

Attributes:

`dimension`
`max`
`min`
`unitCube`

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)

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)

GetDistanceSquared(p) → float#

Compute the squared distance from a point to the range.

Parameters:: p (Vec3f)

static GetIntersection()#

classmethod GetIntersection(a, b) -> Range3f

Returns a GfRange3f that describes the intersection of a and b .

Parameters:

a (Range3f)
b (Range3f)

GetMax() → Vec3f#: Returns the maximum value of the range.

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() .

GetMin() → Vec3f#: Returns the minimum value of the range.

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)

GetSize() → Vec3f#: Returns the size of the range.

static GetUnion()#

classmethod GetUnion(a, b) -> Range3f

Returns the smallest GfRange3f which contains both a and b .

Parameters:

a (Range3f)
b (Range3f)

IntersectWith(b) → Range3f#

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

Parameters:: b (Range3f)

IsEmpty() → bool#: Returns whether the range is empty (max<min).

SetEmpty() → None#: Sets the range to an empty interval.

SetMax(max) → None#

Sets the maximum value of the range.

Parameters:: max (Vec3f)

SetMin(min) → None#

Sets the minimum value of the range.

Parameters:: min (Vec3f)

UnionWith(b) → Range3f#

Extend this to include b .

Parameters:: b (Range3f)

UnionWith(b) -> Range3f

Extend this to include b .

Parameters:: b (Vec3f)

dimension = 3#

property max#

property min#

unitCube = Gf.Range3f(Gf.Vec3f(0.0, 0.0, 0.0), Gf.Vec3f(1.0, 1.0, 1.0))#

class pxr.Gf.Ray#

Methods:

`FindClosestPoint`(point, rayDistance)	Returns the point on the ray that is closest to `point` .
`GetPoint`(distance)	Returns the point that is `distance` units from the starting point along the direction vector, expressed in parametic distance.
`Intersect`(p0, p1, p2)	float, barycentric = GfVec3d, frontFacing = bool>
`SetEnds`(startPoint, endPoint)	Sets the ray by specifying a starting point and an ending point.
`SetPointAndDirection`(startPoint, direction)	Sets the ray by specifying a starting point and a direction.
`Transform`(matrix)	Transforms the ray by the given matrix.

Attributes:

`direction`	Vec3d
`startPoint`	Vec3d

FindClosestPoint(point, rayDistance) → Vec3d#

Returns the point on the ray that is closest to point .

If rayDistance is not None , it will be set to the parametric distance along the ray of the closest point.

Parameters:

point (Vec3d)
rayDistance (float)

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)

Intersect(p0, p1, p2) → tuple<intersects = bool, dist =#

float, barycentric = GfVec3d, frontFacing = bool>

Intersects the ray with the triangle formed by points p0, p1, and p2. The first item in the tuple is true if the ray intersects the triangle. dist is the the parametric distance to the intersection point, the barycentric coordinates of the intersection point, and the front-facing flag. The barycentric coordinates are defined with respect to the three vertices taken in order. The front-facing flag is True if the intersection hit the side of the triangle that is formed when the vertices are ordered counter-clockwise (right-hand rule).

Barycentric coordinates are defined to sum to 1 and satisfy this relationsip:

intersectionPoint = (barycentricCoords[0] * p0 +
barycentricCoords[1] * p1 + barycentricCoords[2] * p2);

Intersect( plane ) -> tuple<intersects = bool, dist = float, frontFacing = bool>

Intersects the ray with the Gf.Plane. The first item in the returned tuple is true if the ray intersects the plane. dist is the parametric distance to the intersection point and frontfacing is true if the intersection is on the side of the plane toward which the plane’s normal points. ———————————————————————-

Intersect( range3d ) -> tuple<intersects = bool, enterDist = float, exitDist = float> Intersects the plane with an axis-aligned box in a Gf.Range3d. intersects is true if the ray intersects it at all within bounds. If there is an intersection then enterDist and exitDist will be the parametric distances to the two intersection points. ———————————————————————-

Intersect( bbox3d ) -> tuple<intersects = bool, enterDist = float, exitDist = float> Intersects the plane with an oriented box in a Gf.BBox3d. intersects is true if the ray intersects it at all within bounds. If there is an intersection then enterDist and exitDist will be the parametric distances to the two intersection points. ———————————————————————-

Intersect( center, radius ) -> tuple<intersects = bool, enterDist = float, exitDist = float>

Intersects the plane with an sphere. intersects is true if the ray intersects it at all within the sphere. If there is an intersection then enterDist and exitDist will be the parametric distances to the two intersection points. ———————————————————————-

Intersect( origin, axis, radius ) -> tuple<intersects = bool, enterDist = float, exitDist = float>

Intersects the plane with an infinite cylinder. intersects is true if the ray intersects it at all within the sphere. If there is an intersection then enterDist and exitDist will be the parametric distances to the two intersection points. ———————————————————————-

Intersect( origin, axis, radius, height ) -> tuple<intersects = bool, enterDist = float, exitDist = float>

Intersects the plane with an cylinder. intersects is true if the ray intersects it at all within the sphere. If there is an intersection then enterDist and exitDist will be the parametric distances to the two intersection points. ———————————————————————-

SetEnds(startPoint, endPoint) → None#

Sets the ray by specifying a starting point and an ending point.

Parameters:

startPoint (Vec3d)
endPoint (Vec3d)

SetPointAndDirection(startPoint, direction) → None#

Sets the ray by specifying a starting point and a direction.

Parameters:

startPoint (Vec3d)
direction (Vec3d)

Transform(matrix) → Ray#

Transforms the ray by the given matrix.

Parameters:: matrix (Matrix4d)

property direction#

Vec3d

Returns the direction vector of the segment.

This is not guaranteed to be unit length.

Type:: type

property startPoint#

Vec3d

Returns the starting point of the segment.

Type:: type

class pxr.Gf.Rect2i#

Methods:

`Contains`(p)	Returns true if the specified point in the rectangle.
`GetArea`()	Return the area of the rectangle.
`GetCenter`()	Returns the center point of the rectangle.
`GetHeight`()	Returns the height of the rectangle.
`GetIntersection`(that)	Computes the intersection of two rectangles.
`GetMax`()	Returns the max corner of the rectangle.
`GetMaxX`()	Return the X value of the max corner.
`GetMaxY`()	Return the Y value of the max corner.
`GetMin`()	Returns the min corner of the rectangle.
`GetMinX`()	Return the X value of min corner.
`GetMinY`()	Return the Y value of the min corner.
`GetNormalized`()	Returns a normalized rectangle, i.e.
`GetSize`()	Returns the size of the rectangle as a vector (width,height).
`GetUnion`(that)	Computes the union of two rectangles.
`GetWidth`()	Returns the width of the rectangle.
`IsEmpty`()	Returns true if the rectangle is empty.
`IsNull`()	Returns true if the rectangle is a null rectangle.
`IsValid`()	Return true if the rectangle is valid (equivalently, not empty).
`SetMax`(max)	Sets the max corner of the rectangle.
`SetMaxX`(x)	Set the X value of the max corner.
`SetMaxY`(y)	Set the Y value of the max corner.
`SetMin`(min)	Sets the min corner of the rectangle.
`SetMinX`(x)	Set the X value of the min corner.
`SetMinY`(y)	Set the Y value of the min corner.
`Translate`(displacement)	Move the rectangle by `displ` .

Attributes:

`max`
`maxX`
`maxY`
`min`
`minX`
`minY`

Contains(p) → bool#

Returns true if the specified point in the rectangle.

Parameters:: p (Vec2i)

GetArea() → int#: Return the area of the rectangle.

GetCenter() → Vec2i#: Returns the center point of the rectangle.

GetHeight() → int#

Returns the height of the rectangle.

If the min and max y-coordinates are coincident, the height is one.

GetIntersection(that) → Rect2i#

Computes the intersection of two rectangles.

Parameters:: that (Rect2i)

GetMax() → Vec2i#: Returns the max corner of the rectangle.

GetMaxX() → int#: Return the X value of the max corner.

GetMaxY() → int#: Return the Y value of the max corner.

GetMin() → Vec2i#: Returns the min corner of the rectangle.

GetMinX() → int#: Return the X value of min corner.

GetMinY() → int#: Return the Y value of the min corner.

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.

GetSize() → Vec2i#: Returns the size of the rectangle as a vector (width,height).

GetUnion(that) → Rect2i#

Computes the union of two rectangles.

Parameters:: that (Rect2i)

GetWidth() → int#

Returns the width of the rectangle.

If the min and max x-coordinates are coincident, the width is one.

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.

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

 GetMaxX() == GetMinX() - 1

and

 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.

IsValid() → bool#: Return true if the rectangle is valid (equivalently, not empty).

SetMax(max) → None#

Sets the max corner of the rectangle.

Parameters:: max (Vec2i)

SetMaxX(x) → None#

Set the X value of the max corner.

Parameters:: x (int)

SetMaxY(y) → None#

Set the Y value of the max corner.

Parameters:: y (int)

SetMin(min) → None#

Sets the min corner of the rectangle.

Parameters:: min (Vec2i)

SetMinX(x) → None#

Set the X value of the min corner.

Parameters:: x (int)

SetMinY(y) → None#

Set the Y value of the min corner.

Parameters:: y (int)

Translate(displacement) → None#

Move the rectangle by displ .

Parameters:: displacement (Vec2i)

property max#

property maxX#

property maxY#

property min#

property minX#

property minY#

class pxr.Gf.Rotation#

3-space rotation

Methods:

`Decompose`(axis0, axis1, axis2)	Decompose rotation about 3 orthogonal axes.
`DecomposeRotation`	classmethod DecomposeRotation(rot, TwAxis, FBAxis, LRAxis, handedness, thetaTw, thetaFB, thetaLR, thetaSw, useHint, swShift) -> None
`DecomposeRotation3`
`GetAngle`()	Returns the rotation angle in degrees.
`GetAxis`()	Returns the axis of rotation.
`GetInverse`()	Returns the inverse of this rotation.
`GetQuat`()	Returns the rotation expressed as a quaternion.
`GetQuaternion`()	Returns the rotation expressed as a quaternion.
`MatchClosestEulerRotation`	classmethod MatchClosestEulerRotation(targetTw, targetFB, targetLR, targetSw, thetaTw, thetaFB, thetaLR, thetaSw) -> None
`RotateOntoProjected`	classmethod RotateOntoProjected(v1, v2, axis) -> Rotation
`SetAxisAngle`(axis, angle)	Sets the rotation to be `angle` degrees about `axis` .
`SetIdentity`()	Sets the rotation to an identity rotation.
`SetQuat`(quat)	Sets the rotation from a quaternion.
`SetQuaternion`(quat)	Sets the rotation from a quaternion.
`SetRotateInto`(rotateFrom, rotateTo)	Sets the rotation to one that brings the `rotateFrom` vector to align with `rotateTo` .
`TransformDir`(vec)	Transforms row vector `vec` by the rotation, returning the result.

Attributes:

`angle`
`axis`

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)

static DecomposeRotation()#

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)

static DecomposeRotation3()#

GetAngle() → float#: Returns the rotation angle in degrees.

GetAxis() → Vec3d#: Returns the axis of rotation.

GetInverse() → Rotation#: Returns the inverse of this rotation.

GetQuat() → Quatd#: Returns the rotation expressed as a quaternion.

GetQuaternion() → Quaternion#: Returns the rotation expressed as a quaternion.

static MatchClosestEulerRotation()#

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)

static RotateOntoProjected()#

classmethod RotateOntoProjected(v1, v2, axis) -> Rotation

Parameters:

v1 (Vec3d)
v2 (Vec3d)
axis (Vec3d)

SetAxisAngle(axis, angle) → Rotation#

Sets the rotation to be angle degrees about axis .

Parameters:

axis (Vec3d)
angle (float)

SetIdentity() → Rotation#

Sets the rotation to an identity rotation.

(This is chosen to be 0 degrees around the positive X axis.)

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)

SetQuaternion(quat) → Rotation#

Sets the rotation from a quaternion.

Parameters:: quat (Quaternion)

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)

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)

property angle#

property axis#

class pxr.Gf.Size2#

A 2D size class

Methods:

Set(v)

Set to the values in a given array.

Attributes:

dimension

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)

dimension = 2#

class pxr.Gf.Size3#

A 3D size class

Methods:

Set(v)

Set to the values in v .

Attributes:

dimension

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)

dimension = 3#

class pxr.Gf.Transform#

Methods:

`GetMatrix`()	Returns a `GfMatrix4d` that implements the cumulative transformation.
`GetPivotOrientation`()	Returns the pivot orientation component.
`GetPivotPosition`()	Returns the pivot position component.
`GetRotation`()	Returns the rotation component.
`GetScale`()	Returns the scale component.
`GetTranslation`()	Returns the translation component.
`Set`	Set method used by old 2x code.
`SetIdentity`()	Sets the transformation to the identity transformation.
`SetMatrix`(m)	Sets the transform components to implement the transformation represented by matrix `m` , ignoring any projection.
`SetPivotOrientation`(pivotOrient)	Sets the pivot orientation component, leaving all others untouched.
`SetPivotPosition`(pivPos)	Sets the pivot position component, leaving all others untouched.
`SetRotation`(rotation)	Sets the rotation component, leaving all others untouched.
`SetScale`(scale)	Sets the scale component, leaving all others untouched.
`SetTranslation`(translation)	Sets the translation component, leaving all others untouched.

Attributes:

`pivotOrientation`
`pivotPosition`
`rotation`
`scale`
`translation`

GetMatrix() → Matrix4d#: Returns a GfMatrix4d that implements the cumulative transformation.

GetPivotOrientation() → Rotation#: Returns the pivot orientation component.

GetPivotPosition() → Vec3d#: Returns the pivot position component.

GetRotation() → Rotation#: Returns the rotation component.

GetScale() → Vec3d#: Returns the scale component.

GetTranslation() → Vec3d#: Returns the translation component.

Set()#: Set method used by old 2x code. (Deprecated)

SetIdentity() → Transform#: Sets the transformation to the identity transformation.

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)

SetPivotOrientation(pivotOrient) → None#

Sets the pivot orientation component, leaving all others untouched.

Parameters:: pivotOrient (Rotation)

SetPivotPosition(pivPos) → None#

Sets the pivot position component, leaving all others untouched.

Parameters:: pivPos (Vec3d)

SetRotation(rotation) → None#

Sets the rotation component, leaving all others untouched.

Parameters:: rotation (Rotation)

SetScale(scale) → None#

Sets the scale component, leaving all others untouched.

Parameters:: scale (Vec3d)

SetTranslation(translation) → None#

Sets the translation component, leaving all others untouched.

Parameters:: translation (Vec3d)

property pivotOrientation#

property pivotPosition#

property rotation#

property scale#

property translation#

class pxr.Gf.Vec2d#

Methods:

`Axis`	classmethod Axis(i) -> Vec2d
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`XAxis`	classmethod XAxis() -> Vec2d
`YAxis`	classmethod YAxis() -> Vec2d

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec2d#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec2d)

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec2d#

Parameters:: eps (float)

GetProjection(v) → Vec2d#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec2d)

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)

static XAxis()#

classmethod XAxis() -> Vec2d

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec2d

Create a unit vector along the Y-axis.

dimension = 2#

class pxr.Gf.Vec2f#

Methods:

`Axis`	classmethod Axis(i) -> Vec2f
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`XAxis`	classmethod XAxis() -> Vec2f
`YAxis`	classmethod YAxis() -> Vec2f

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec2f#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec2f)

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec2f#

Parameters:: eps (float)

GetProjection(v) → Vec2f#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec2f)

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)

static XAxis()#

classmethod XAxis() -> Vec2f

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec2f

Create a unit vector along the Y-axis.

dimension = 2#

class pxr.Gf.Vec2h#

Methods:

`Axis`	classmethod Axis(i) -> Vec2h
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`XAxis`	classmethod XAxis() -> Vec2h
`YAxis`	classmethod YAxis() -> Vec2h

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec2h#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec2h)

GetDot()#

GetLength() → GfHalf#: Length.

GetNormalized(eps) → Vec2h#

Parameters:: eps (GfHalf)

GetProjection(v) → Vec2h#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec2h)

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)

static XAxis()#

classmethod XAxis() -> Vec2h

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec2h

Create a unit vector along the Y-axis.

dimension = 2#

class pxr.Gf.Vec2i#

Methods:

`Axis`	classmethod Axis(i) -> Vec2i
`GetDot`
`XAxis`	classmethod XAxis() -> Vec2i
`YAxis`	classmethod YAxis() -> Vec2i

Attributes:

dimension

static Axis()#

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)

GetDot()#

static XAxis()#

classmethod XAxis() -> Vec2i

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec2i

Create a unit vector along the Y-axis.

dimension = 2#

class pxr.Gf.Vec3d#

Methods:

`Axis`	classmethod Axis(i) -> Vec3d
`BuildOrthonormalFrame`(v1, v2, eps)	Sets `v1` and `v2` to unit vectors such that v1, v2 and *this are mutually orthogonal.
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetCross`
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`OrthogonalizeBasis`	classmethod OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool
`XAxis`	classmethod XAxis() -> Vec3d
`YAxis`	classmethod YAxis() -> Vec3d
`ZAxis`	classmethod ZAxis() -> Vec3d

Attributes:

dimension

static Axis()#

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)

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)

GetComplement(b) → Vec3d#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec3d)

GetCross()#

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec3d#

Parameters:: eps (float)

GetProjection(v) → Vec3d#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec3d)

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)

static OrthogonalizeBasis()#

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)

static XAxis()#

classmethod XAxis() -> Vec3d

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec3d

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec3d

Create a unit vector along the Z-axis.

dimension = 3#

class pxr.Gf.Vec3f#

Methods:

`Axis`	classmethod Axis(i) -> Vec3f
`BuildOrthonormalFrame`(v1, v2, eps)	Sets `v1` and `v2` to unit vectors such that v1, v2 and *this are mutually orthogonal.
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetCross`
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`OrthogonalizeBasis`	classmethod OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool
`XAxis`	classmethod XAxis() -> Vec3f
`YAxis`	classmethod YAxis() -> Vec3f
`ZAxis`	classmethod ZAxis() -> Vec3f

Attributes:

dimension

static Axis()#

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)

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)

GetComplement(b) → Vec3f#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec3f)

GetCross()#

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec3f#

Parameters:: eps (float)

GetProjection(v) → Vec3f#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec3f)

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)

static OrthogonalizeBasis()#

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)

static XAxis()#

classmethod XAxis() -> Vec3f

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec3f

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec3f

Create a unit vector along the Z-axis.

dimension = 3#

class pxr.Gf.Vec3h#

Methods:

`Axis`	classmethod Axis(i) -> Vec3h
`BuildOrthonormalFrame`(v1, v2, eps)	Sets `v1` and `v2` to unit vectors such that v1, v2 and *this are mutually orthogonal.
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetCross`
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`OrthogonalizeBasis`	classmethod OrthogonalizeBasis(tx, ty, tz, normalize, eps) -> bool
`XAxis`	classmethod XAxis() -> Vec3h
`YAxis`	classmethod YAxis() -> Vec3h
`ZAxis`	classmethod ZAxis() -> Vec3h

Attributes:

dimension

static Axis()#

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)

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)

GetComplement(b) → Vec3h#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec3h)

GetCross()#

GetDot()#

GetLength() → GfHalf#: Length.

GetNormalized(eps) → Vec3h#

Parameters:: eps (GfHalf)

GetProjection(v) → Vec3h#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec3h)

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)

static OrthogonalizeBasis()#

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)

static XAxis()#

classmethod XAxis() -> Vec3h

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec3h

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec3h

Create a unit vector along the Z-axis.

dimension = 3#

class pxr.Gf.Vec3i#

Methods:

`Axis`	classmethod Axis(i) -> Vec3i
`GetDot`
`XAxis`	classmethod XAxis() -> Vec3i
`YAxis`	classmethod YAxis() -> Vec3i
`ZAxis`	classmethod ZAxis() -> Vec3i

Attributes:

dimension

static Axis()#

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)

GetDot()#

static XAxis()#

classmethod XAxis() -> Vec3i

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec3i

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec3i

Create a unit vector along the Z-axis.

dimension = 3#

class pxr.Gf.Vec4d#

Methods:

`Axis`	classmethod Axis(i) -> Vec4d
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`WAxis`	classmethod WAxis() -> Vec4d
`XAxis`	classmethod XAxis() -> Vec4d
`YAxis`	classmethod YAxis() -> Vec4d
`ZAxis`	classmethod ZAxis() -> Vec4d

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec4d#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec4d)

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec4d#

Parameters:: eps (float)

GetProjection(v) → Vec4d#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec4d)

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)

static WAxis()#

classmethod WAxis() -> Vec4d

Create a unit vector along the W-axis.

static XAxis()#

classmethod XAxis() -> Vec4d

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec4d

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec4d

Create a unit vector along the Z-axis.

dimension = 4#

class pxr.Gf.Vec4f#

Methods:

`Axis`	classmethod Axis(i) -> Vec4f
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`WAxis`	classmethod WAxis() -> Vec4f
`XAxis`	classmethod XAxis() -> Vec4f
`YAxis`	classmethod YAxis() -> Vec4f
`ZAxis`	classmethod ZAxis() -> Vec4f

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec4f#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec4f)

GetDot()#

GetLength() → float#: Length.

GetNormalized(eps) → Vec4f#

Parameters:: eps (float)

GetProjection(v) → Vec4f#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec4f)

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)

static WAxis()#

classmethod WAxis() -> Vec4f

Create a unit vector along the W-axis.

static XAxis()#

classmethod XAxis() -> Vec4f

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec4f

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec4f

Create a unit vector along the Z-axis.

dimension = 4#

class pxr.Gf.Vec4h#

Methods:

`Axis`	classmethod Axis(i) -> Vec4h
`GetComplement`(b)	Returns the orthogonal complement of `this->GetProjection(b)` .
`GetDot`
`GetLength`()	Length.
`GetNormalized`(eps)
`GetProjection`(v)	Returns the projection of `this` onto `v` .
`Normalize`(eps)	Normalizes the vector in place to unit length, returning the length before normalization.
`WAxis`	classmethod WAxis() -> Vec4h
`XAxis`	classmethod XAxis() -> Vec4h
`YAxis`	classmethod YAxis() -> Vec4h
`ZAxis`	classmethod ZAxis() -> Vec4h

Attributes:

dimension

static Axis()#

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)

GetComplement(b) → Vec4h#

Returns the orthogonal complement of this->GetProjection(b) .

That is:

\*this - this->GetProjection(b)

Parameters:: b (Vec4h)

GetDot()#

GetLength() → GfHalf#: Length.

GetNormalized(eps) → Vec4h#

Parameters:: eps (GfHalf)

GetProjection(v) → Vec4h#

Returns the projection of this onto v .

That is:

v \* (\*this \* v)

Parameters:: v (Vec4h)

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)

static WAxis()#

classmethod WAxis() -> Vec4h

Create a unit vector along the W-axis.

static XAxis()#

classmethod XAxis() -> Vec4h

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec4h

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec4h

Create a unit vector along the Z-axis.

dimension = 4#

class pxr.Gf.Vec4i#

Methods:

`Axis`	classmethod Axis(i) -> Vec4i
`GetDot`
`WAxis`	classmethod WAxis() -> Vec4i
`XAxis`	classmethod XAxis() -> Vec4i
`YAxis`	classmethod YAxis() -> Vec4i
`ZAxis`	classmethod ZAxis() -> Vec4i

Attributes:

dimension

static Axis()#

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)

GetDot()#

static WAxis()#

classmethod WAxis() -> Vec4i

Create a unit vector along the W-axis.

static XAxis()#

classmethod XAxis() -> Vec4i

Create a unit vector along the X-axis.

static YAxis()#

classmethod YAxis() -> Vec4i

Create a unit vector along the Y-axis.

static ZAxis()#

classmethod ZAxis() -> Vec4i

Create a unit vector along the Z-axis.

dimension = 4#