diff --git "a/Gf.md" "b/Gf.md" new file mode 100644--- /dev/null +++ "b/Gf.md" @@ -0,0 +1,7034 @@ + + +Gf module — pxr-usd-api 105.1 documentation + +pxr-usd-api + + » +Modules » +Gf module + +  + +# 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. +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) + +param p0 + +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) + +param 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. +Returns true if x is inside the multi-interval. +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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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) + +param 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) + +param 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) + +param 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) + +param 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) + +param 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) + +param 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) + +param 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) + +param 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) + +param 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 + +© Copyright 2019-2023, NVIDIA. + Last updated on Nov 14, 2023. + + +