zAlign (
        self,
        p0,
        p1,
        )

zAlign(p0: Point, p1: Point) -> Xform zAlign(p: Point, v: Vector) -> Xform

getTranslation ( self )

getTranslation() -> Vector

lookAt (
        self,
        eye,
        at,
        up,
        )

lookAt(eye: Point, at: Point, up: Point) -> Xform lookAt(eye: Point, at: Point, up: Vector) -> Xform

getRotation ( self )

getRotation() -> Vector, float

getCoordFrame ( self )

getCoordFrame() -> (Vector|None), (Vector|None), (Vector|None), (Point|None)

apply ( self,  p )

apply(p: Point) -> Point apply(p: Vector) -> Vector

rotation (
        self,
        xyz,
        angle,
        )

rotation(xyz: Vector, angle: float) -> Xform rotation(x: float, y: float, z: float, angle: float) -> Xform

premultiply ( self,  op )

premultiply(op: Xform)

inverse ( self )

inverse() -> Xform

invert ( self )

invert()

zRotate ( self,  angle )

zRotate(angle: float)

translate ( self,  xyz )

translate(xyz: Vector) translate(x: float, y: float, z: float)

getOpenGLMatrix ( self )

getOpenGLMatrix() -> 16-tuple of float

zRotation ( self,  angle )

zRotation(angle: float) -> Xform

xRotate ( self,  angle )

xRotate(angle: float)

xRotation ( self,  angle )

xRotation(angle: float) -> Xform

multiply ( self,  op )

multiply(op: Xform)

translation ( self,  xyz )

translation(xyz: Vector) -> Xform translation(x: float, y: float, z: float) -> Xform

coordFrame (
        self,
        x,
        y,
        z,
        origin,
        orthogonalize,
        )

coordFrame(x: Vector, y: Vector, z: Vector, origin: Point, orthogonalize: bool = false) -> Xform

identity ( self )

identity() -> Xform

xform (
        self,
        r00,
        r01,
        r02,
        t03,
        r10,
        r11,
        r12,
        t13,
        r20,
        r21,
        r22,
        t23,
        orthogonalize,
        )

xform(r00: float, r01: float, r02: float, t03: float, r10: float, r11: float, r12: float, t13: float, r20: float, r21: float, r22: float, t23: float, orthogonalize: bool = false) -> Xform

rotate (
        self,
        xyz,
        angle,
        )

rotate(xyz: Vector, angle: float) rotate(x: float, y: float, z: float, angle: float)

yRotation ( self,  angle )

yRotation(angle: float) -> Xform

yRotate ( self,  angle )

yRotate(angle: float)

isIdentity ( self )

isIdentity() -> bool

makeOrthogonal ( self,  modify )

makeOrthogonal(modify: bool)