Return a transformation matrix containing only a translation. You can build more complex transformations by multiplying the result with another transformation matrix.

See hou.Geometry.transformPrims() and hou.Matrix4.explode() for examples.

Return a transformation matrix containing only a rotation, given an axis and a rotation amount. You can build more complex transformations by multiplying the result with another transformation matrix.

See hou.Geometry.transformPrims() and hou.Matrix4.explode() for examples.

If you want to convert Euler angles into a corresponding axis and angle, you can use the following code:

def extractAxisAndAngleFromRotateMatrix(m):
    '''Given a matrix, return an (Vector3, float) tuple containing the
       axis and angle.  See Wikipedia's rotation represention page for
       more details.'''
    import math

    acos_input = (m.at(0, 0) + m.at(1, 1) + m.at(2, 2) - 1.0) * 0.5
    if acos_input < -1.0 or acos_input > 1.0:
        return None

    angle = math.acos(acos_input)
    if angle >= -1e-6 and angle <= 1e-6:
        # There is no rotation.  Choose an arbitrary axis and a rotation of 0.
        return hou.Vector3(1, 0, 0), 0.0

    inv_sin = 1.0 / (2.0 * math.sin(angle))
    axis = hou.Vector3(
        (m.at(1, 2) - m.at(2, 1)) * inv_sin,
        (m.at(2, 0) - m.at(0, 2)) * inv_sin,
        (m.at(0, 1) - m.at(1, 0)) * inv_sin)
    return axis, hou.hmath.radToDeg(angle)

def eulerToAxisAndAngle(angles):
    return extractAxisAndAngleFromRotateMatrix(hou.hmath.buildRotate(angles))

See Wikipedia’s axis angle page and rotation representation page for more information.

Return a transformation matrix containing only a rotation, given a sequence of Euler angles. You can build more complex transformations by multiplying the result with another transformation matrix.

See Wikipedia’s Euler angles page for more information.

See hou.Matrix4.explode() for an example. See also hou.hmath.buildRotateAboutAxis() and hou.hmath.radToDeg().

Return a transformation matrix containing only a scale, given a sequence of scale values for x, y, and z. You can build more complex transformations by multiplying the result with another transformation matrix.

To apply a uniform scale, use the same value for x, y, and z.

See hou.Geometry.createNURBSSurface() and hou.Matrix4.explode() for examples.

Return a transformation matrix containing only a shear, given a sequence of shear values for x, y, and z. You can build more complex transformations by multiplying the result with another transformation matrix.

See Wikipedia’s shear matrix page for more information.

See hou.Matrix4.explode() for an example.

Given a set of translate, rotate, scale, shear, pivot, and pivot_rotate values; and transform rotate orders, return a corresponding matrix. This function is the inverse of hou.Matrix4.explode().

This function can be approximately implemented as follows:

def buildTransform(values_dict, transform_order="srt", rotate_order="xyz"):
    # Take the return value from explode, along with the transform and
    # rotate order, and rebuild the original matrix.
    result = hou.hmath.identityTransform()
    for operation_type in transform_order:
        if operation_type == "t":
            result *= hou.hmath.buildTranslate(values_dict["translate"])
        elif operation_type == "s":
            result *= hou.hmath.buildScale(values_dict["scale"])
            if "shear" in values_dict:
                result *= hou.hmath.buildShear(values_dict["shear"])
        elif operation_type == "r":
            result *= hou.hmath.buildRotate(values_dict["rotate"], rotate_order)
        else:
            raise ValueError("Invalid transform order")
    return result

Returns the identity matrix. This is the same as calling hou.Matrix4(1).

>>> hou.hmath.identityTransform()
<hou.Matrix4 [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]>

See also hou.Matrix4.__init__().

Given a value in degrees, return the corresponding value in radians.

This function is equivalent to degrees * math.pi / 180.0.

Given a value in radians, return the corresponding value in degrees.

This function is equivalent to radians * 180.0 / math.pi.

Returns the value clamped to the range min to max. See also hou.hmath.wrap(). This function is useful in expressions to prevent a value from going outside the specified range.

Similar to the hou.hmath.clamp() function in that the resulting value will always fall between the specified minimum and maximum value. However, it will create a saw-tooth wave for continuously increasing or decreasing parameter values.

Returns 1.0 if value is positive, -1.0 if negative and 0.0 if value is zero.

Note that you can achieve the same effect with Python’s built-in cmp function: float(cmp(value, 0)).

Takes a value and range and returns a smooth interpolation between 0 and 1.

When value is less than min, the return value is 0. If value is greater than max, the return value is 1.

>>> hou.hmath.smooth(5, 0, 20)
0.15625
>>> hou.hmath.smooth(10, 0, 20)
0.5
>>> hou.hmath.smooth(15, 0, 20)
0.84375

# Visualize the output of this function by positioning geometry objects at  various locations.
def createSpheres(num_spheres=40):
    for i in range(num_spheres):
        sphere = hou.node("/obj").createNode("geo").createNode("sphere")
        sphere.parmTuple("rad").set((0.1, 0.1, 0.1))
        sphere.setDisplayFlag(True)

        # Given a value between 0 and 5, we'll call smooth with a range
        # of 0 to 3, and the resulting y value will be between 0 and 1.
        x = 5.0 * i / num_spheres
        y = hou.hmath.smooth(x, 0, 3)
        sphere.parent().setParmTransform(hou.hmath.buildTranslate((x, y, 0)))

Returns a number between new_min and new_max that is relative to the value between the range old_min and old_max. If the value is outside the old_min to old_max range, it will be clamped to the new range.

>>> hou.hmath.fit(3, 1, 4, 5, 20)
15.0

Returns a number between new_min and new_max that is relative to the value between the range 0 and 1. If the value is outside the 0 to 1 range, it will be clamped to the new range.

This function is a shortcut for hou.hmath.fit(value, 0.0, 1.0, new_min, new_max).

Returns a number between new_min and new_max that is relative to the value between the range 1 to 0. If the value is outside the 1 to 0 range, it will be clamped to the new range.

This function is a shortcut for hou.hmath.fit(value, 1.0, 0.0, new_min, new_max).

Returns a number between new_min and new_max that is relative to the value between the range -1 to 1. If the value is outside the -1 to 1 range, it will be clamped to the new range.

This function is a shortcut for hou.hmath.fit(value, -1.0, 1.0, new_min, new_max).

Returns a pseudo-random number from 0 to 1. Using the same seed will always give the same result.

Given a sequence of 1 to 4 floats representing a position in N-dimensional space, return a single float corresponding to 1 dimensional noise.

This function matches the output of the noise function from VEX.

Given a sequence of 1 to 4 floats representing a position in N-dimensional space, return a hou.Vector3 object representing the vector noise at the given position.

This function matches the output of the noise function from VEX.

Performs an adaptive exact sidedness test of the 2d point against the line defined by pa and pb.

See https://www.cs.cmu.edu/~quake/robust.html for details of the implementation.

Performs an adaptive exact sidedness test of the 3d point against the plane defined by pa, pb, and pc.

See https://www.cs.cmu.edu/~quake/robust.html for details of the implementation.

Performs an adaptive exact inside test of the 2d point against the circle defined by pa, pb, and pc. pa, pb, and pc must be in counter-clockwise order to get a positive value for interior points.

See https://www.cs.cmu.edu/~quake/robust.html for details of the implementation.

Performs an adaptive exact inside test of the 3d point against the sphere defined by pa, pb, pc, and pd. Note that inconsistent orientation of the four sphere defining points will reverse the sign of the result.

See https://www.cs.cmu.edu/~quake/robust.html for details of the implementation.