hou.Geometry class

Look up a point attribute by name. Returns the corresponding hou.Attrib object, or None if no attribute exists with that name.

Note that the point position attribute is named P and is 3 floats in size. Also, the point weight attribute is named Pw and is 1 float in size. These attributes always exist in HOM, even though they are not listed by Houdini’s UI.

See hou.Point.attribValue for an example.

Look up a primitive attribute by name. Returns the corresponding hou.Attrib object, or None if no attribute exists with that name.

Look up a vertex attribute by name. Returns the corresponding hou.Attrib object, or None if no attribute exists with that name.

Look up a global (a.k.a. detail) attribute by name. Returns the corresponding hou.Attrib object, or None if no attribute exists with that name.

Return a tuple of all the point attributes.

Note that the point position attribute is named P and is 3 floats in size. Also, the point weight attribute is named Pw and is 1 float in size. These attributes always exist in HOM, even though they are not listed by Houdini’s UI.

Return a tuple of all the primitive attributes.

Return a tuple of all the vertex attributes.

Return a tuple of all the global (a.k.a. detail) attributes.

Create a new point, primitive, vertex, or global (a.k.a. detail) attribute. Returns a hou.Attrib object describing the newly created attribute. You would typically call this method from the code of a Python-defined SOP.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Raises hou.OperationFailed if an attribute with this name already exists. If you are familiar with the C++ Houdini Development Kit (HDK), you know that Houdini can support attributes with the same name but with different types. However, many SOPs do not let you distinguish between attributes that have the same name, and multiple attributes with the same name are discouraged. For this reason, you cannot create them with this method.

Raises hou.OperationFailed if transform_as_normal is True and the default value is not a sequence of 3 floats.

# Create an integer point attribute of size 1 named "population", and
# create 5 points with attribute values 0, 5, 10, 15, and 20.  This code
# will work from inside a Python SOP, but not from the Python shell.
geo = hou.pwd().geometry()
population_attrib = geo.addAttrib(hou.attribType.Point, "population", 0)
for i in range(5):
    point = geo.createPoint()
    point.setPosition((i, 0, 0))
    point.setAttribValue(population_attrib, i * 5)

See also:

• hou.Prim.setAttribValue

• hou.Point.setAttribValue

• hou.Prim.setAttribValue

• hou.Geometry.setGlobalAttribValue

Return the global (a.k.a. detail) attribute value for a particular attribute. The attribute may be specified by name or by hou.Attrib object.

Raises hou.OperationFailed if no attribute exists with this name.

Return the global (a.k.a. detail) attribute value for a particular floating point attribute. The attribute may be specified by name or by hou.Attrib object.

Raises hou.OperationFailed if no attribute exists with this name or the attribute is not a float of size 1.

In most cases, you’ll just use hou.Geometry.attribValue to access attribute values. Houdini uses this method internally to implement attribValue.

Return the global (a.k.a. detail) attribute value for a particular floating point attribute. The attribute may be specified by name or by hou.Attrib object. The return value is a list of floats.

It is valid to call this method when the attribute’s size is 1. In this case, a list with one element is returned.

See also:

• hou.Geometry.attribValue

Return the global (a.k.a. detail) attribute value for a particular integer attribute of size 1. The attribute may be specified by name or by hou.Attrib object. See hou.Geometry.floatAttribValue for more information.

Return the global (a.k.a. detail) attribute value for a particular integer attribute. The attribute may be specified by name or by hou.Attrib object. The return value is a list of ints. See hou.Geometry.floatListAttribValue for more information.

Return the global (a.k.a. detail) attribute value for a particular string attribute. The attribute may be specified by name or by hou.Attrib object. See hou.Geometry.floatAttribValue for more information.

Set a global (a.k.a. detail) attribute value. The attribute may be specified by name or by hou.Attrib object. You would typically call this method from the code of a Python-defined SOP.

Raises hou.OperationFailed if no attribute exists with this name or if the attribute’s data type does not match the value passed in. If the attribute’s size is more than 1, the attribute value must be a sequence of integers/floats, and the size of the sequence must match the attribute’s size.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

# This code will work from inside a Python SOP, but not from the Python
# shell.
geo = hou.pwd().geometry()
geo.addAttrib(hou.attribType.Global, "author", "")
geo.addAttrib(hou.attribType.Global, "version", (0, 0, 0))
geo.setGlobalAttribValue("author", "Joe")
geo.setGlobalAttribValue("version", (1, 0, 7))

See also:

• hou.Geometry.attribValue

• hou.Point.setAttribValue

• hou.Prim.setAttribValue

• hou.Vertex.setAttribValue

Return the enumerated value hou.attribType.Global. Points, primitives, vertices, and geometry support the same set of methods for querying their attributes, and this method is one of them.

See also:

• hou.Prim.attribType

• hou.Point.attribType

• hou.Vertex.attribType

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Return an axis-aligned 3D bounding box that is sized and positioned to be large enough to hold this geometry.

Not implemented yet

Create a new point located and (0, 0, 0) and return the corresponding hou.Point object. You would typically call this method from the code of a Python-defined SOP.

If the geometry contains point attributes, the new point receives the default values for those attributes.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

See hou.Geometry.addAttrib, hou.Geometry.createPolygon, and hou.Face.addVertex for examples.

Create a new polygon and return the corresponding hou.Polygon object. You would typically call this method from the code of a Python-defined SOP.

The newly created polygon has no vertices. Use hou.Face.addVertex to add them. The polygon is also closed (see hou.Face.isClosed for more information).

If the geometry contains primitive attributes, the new polygon receives the default values for those attributes.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

geo = hou.pwd().geometry()
poly = geo.createPolygon()
for position in (0,0,0), (1,0,0), (0,1,0):
    point = geo.createPoint()
    point.setPosition(position)
    poly.addVertex(point)

See hou.Face.addVertex for a slightly more complicated example.

Create a new NURBS with the specified number of vertices and return it. You would typically call this method from the code of a Python-defined SOP.

If the geometry contains primitive attributes, the new curve receives the default values for those attributes.

# This code will work from inside a Python SOP, but not from the Python
# shell.
geo = hou.pwd().geometry()
curve = geo.createNURBSCurve(10)
for vertex in curve.vertices():
    vertex.point().setPosition((i, i % 3, 0))

Raises hou.GeometryPermissionError if this geometry is not modifiable.

See also:

• hou.Prim.vertices

• hou.Point.setPosition

Create a new Bezier curve with the specified number of vertices and return it. You would typically call this method from the code of a Python-defined SOP.

The Bezier curve has order 4, and the is_closed parameter determines if it is open or closed (see hou.Face.isClosed for more information). An open Bezier curve must have 3n+1 vertices for some integer n>=1 (so valid values are 4, 7, 10, etc.). A closed Bezier curve must have 3n vertices (e.g. 3, 6, 9, etc.). You cannot use hou.Face.setIsClosed on a Bezier curve, since the number of vertices would need to change.

See hou.Geometry.createNURBSCurve for more information.

Create a NURBS surface in the XY plane centered at the origin with size (1, 1) and return it. You would typically call this method from the code of a Python-defined SOP.

If the geometry contains primitive attributes, the new surface receives the default values for those attributes.

You can move or resize the surface using hou.Prim.transform.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Raises hou.OperationFailed if the number of rows and/or columns is invalid.

# This code will work from inside a Python SOP, but not from the Python
# shell.
geo = hou.pwd().geometry()

# Create a surface with a 10x10 grid of vertices.
surf = geo.createNURBSSurface(10, 10)

# Initially, the center is at (0, 0, 0), size is (1, 1, 1), on the XY
# plane.  Scale to (20, 10) and rotate into the XZ plane.
geo.transformPrims((surf,),
    hou.hmath.buildScale((20, 10, 1)) *
    hou.hmath.buildRotateAboutAxis((1, 0, 0), 90))

See also:

• hou.Geometry.transformPrims

• hou.Matrix4

• hou.hmath

Create a Bezier surface in the XY plane centered at the origin with size (1, 1) and return it. You would typically call this method from the code of a Python-defined SOP.

You can move or resize the surface using hou.Prim.transform.

If the geometry contains primitive attributes, the new surface receives the default values for those attributes.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

import math

# This code will work from inside a Python SOP, but not from the Python
# shell.
geo = hou.pwd().geometry()

# Build a tube-like object about the y axis.
num_rows, num_cols = (10, 9)
surf = geo.createBezierSurface(num_rows, num_cols, is_closed_in_u=True)
for v_index in range(num_rows):
    for u_index in range(num_cols):
        angle = u_index * (2.0 * math.pi) / num_cols
        surf.vertex(u_index, v_index).point().setPosition(
            (math.cos(angle), v_index / float(num_cols-1), math.sin(angle)))

Create a quadrilateral mesh surface in the XY plane centered at the origin with size (1, 1) and return it. You would typically call this method from the code of a Python-defined SOP.

Note that a mesh object is not the same as a set of polygons defining the same shape. A mesh object is a single primitive.

See hou.Geometry.createNURBSSurface for more information.

Given the x, y, and z resolution (or size) of a voxel array, add a new volume primitive to the geometry and return it. The values in the new volume’s voxels are all zero.

Not implemented yet

Delete a sequence of primitives. You would typically call this method from the code of a Python-defined SOP.

To delete a single primitive, pass in a sequence with one primitive.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

# Delete every other primitive:
prims = [p for p in geo.prims() if p.number() % 2 == 0]
geo.deletePrims(prims)

# Delete the first primitive:
geo.deletePrims([geo.iterPrims()[0]])

Delete a sequence of points. You would typically call this method from the code of a Python-defined SOP.

Note that Houdini will delete any vertices that reference the point. For example, suppose you have a box with 6 polygons, each with 4 vertices. Also suppose that each point on the box is shared by 3 vertices on 3 separate polygons. If you delete one of those points, Houdini will remove each of those vertices from their corresponding polygons, leaving 3 polygons with 4 vertices and 3 polygons with 3 vertices.

To delete a single primitive, pass in a sequence with one point.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Return another Geometry object that is not linked to a particular SOP.

When you call hou.SopNode.geometry, the resultant Geometry object retains a reference to that SOP, and is said to be unfrozen. Each time you access points, primitives, attributes, etc. in an unfrozen Geometry object, Houdini uses the SOP’s latest cooked geometry. So, if you change parameters or change the time for an animated SOP, the Geometry object will update to the SOP’s new geometry.

A frozen Geometry object, however, is not associated with a particular SOP. When the SOP recooks, the frozen Geometry object will save its own copy of the point and primitive data, and is unaffected by subsequent changes to the SOP. When a frozen Geometry object is destroyed, any geometry copy it created is destroyed.

Calling this method on an unfrozen Geometry object returns a frozen one. Calling it on a frozen object has no effect, and it returns a frozen object.

Note that accessing a Geometry object’s points, primitives, attributes, etc. may be faster when dealing with frozen objects. So, you may want to work with frozen Geometry in speed-sensitive operations.

If the Geometry is not frozen, return the hou.SopNode object corresponding to this Geometry. Otherwise, return None.

See hou.Geometry.freeze for more information on frozen geometry.

Return a tuple of all the points in the geometry.

See also the hou.Geometry.iterPoints method.

Return a generator that iterates through all the points in the geometry.

Whereas hou.Geometry.points allocates and returns a tuple of all the points in the geometry, this method returns a generator object that will allocate hou.Point objects on demand. This object is very fast at random access into the sequence.

If you're accessing a specific point by index and the geometry contains many points, it is faster to use iterPoints() than points(). If, however, you are iterating over all the points in the geometry, it is generally faster to use points() than iterPoints().

# This is preferred:
geo.iterPoints()[23]

# over this:
geo.points()[23]

# But this is preferred:
for point in geo.points():
    ...process point...

# over this:
for point in geo.iterPoints():
    ...process point...

Return a tuple of points corresponding to a pattern of point numbers.

The pattern format is the same one used by the group fields on SOP nodes that take point selections. Elements in the pattern are separated by spaces, and elements can be point numbers, point number ranges, or group names.

This method can be useful when writing a Python SOP that works on only a selected set of points.

Raises hou.OperationFailed if the pattern is not valid or if it refers to a group that does not exist. Note that an empty pattern is considered to be invalid. Numbers that do not refer to valid points are not errors, and simply do not match points.

# Return a tuple containing points 5 and 7.
geo.globPoints("5 7")

# Return a tuple containing points 5 to 10.
geo.globPoints("5-10")

# Return a tuple containing all the points in the pointgroup called group1.
geo.globPoints("group1")

# Return all the points except those from 0 to 98.
geo.globPoints("!0-98")

# Return points 5, 10 to 20, and those in group1.
geo.globPoints("5 group1 10-20")

The following Python SOP example is behaves similarly to the Point sop.

# This code will work from inside a Python SOP, but not from the Python
# shell.  It assumes the Python sop has the following parm tuples:
#     group: A string containing which points to affect
#     t:     A set of 3 floats that behaves like the point sop's position
#            parameter.  Set these parameters to the expressions ($TX, $TY, $TZ).
geo = hou.pwd().geometry()

# Use the group field to determine which points to affect.  If it's blank,
# operate on all points.
pattern = hou.ch("group")
if pattern == "":
    points = geo.points()
else:
    points = geo.globPoints(pattern)

# Loop through the points, setting the SOP's current point as we go.
# Then evaluate the t parm tuple, so it can use the current point (e.g.
# with hscript's $TX or Python's pwd().curPoint()).
for point in points:
    hou.pwd().setCurPoint(point)
    new_position = hou.pwd().evalParmTuple("t")
    point.setPosition(new_position)

Not implemented yet

Not implemented yet

Given a sequence of three floats containing a position, find the location on the primitive closest to that position and return a tuple containing that primitive, the u value on the primitive, the v value on the primitive, and the distance to the primitive.

Note that the first value in the return tuple can be None if there are no primitives in the geometry.

Not implemented yet

Return a tuple of floats containing one attribute’s values for all the points.

This method only works on int or float attributes. If the attribute contains more than one element, each point will correspond to multiple values in the result. For example, if “Cd” is a float attribute of size 3 and there are 3 points with values (0.1, 0.2, 0.3), (0.5, 0.5, 0.5), and (0.8, 0.7, 0.6) then the result will be (0.1, 0.2, 0.3, 0.5, 0.5, 0.5, 0.8, 0.7, 0.6).

Calling this method is faster than looping over all the points and calling hou.Point.attribValue

If the attribute name is invalid or the attribute is not an int or float (e.g. it’s a string attribute), this method raises hou.OperationFailed.

Note that you cannot pass a hou.Attrib object to this method like you can with many methods dealing with attributes. However, you can use hou.Attrib.name to easily get the name from an Attrib object.

Return a string representation of the floats of one attribute’s value for all the points. This method is faster than hou.Geometry.pointFloatAttribValues, and you can use the array module to convert the string into a Python sequence.

This method provides a faster implementation of the following:

import array
def pointFloatAttribValuesAsString(self, name):
    return array.array("f", self.pointFloatAttribValues(name)).tostring()

You can convert the return value from this method to an array using the following method:

import array
def pointFloatAttribValuesAsArray(geometry, name):
    a = array.array("f")
    a.fromstring(geometry.pointFloatAttribValuesAsString(name))
    return a

See hou.Geometry.pointFloatAttribValues for more information.

For a particular attribute, set the attribute values for all points. You would typically call this method from the code of a Python-defined SOP.

Raises hou.OperationFailed if the attribute name is not valid, the attribute is not an int or float (i.e. it’s a string), or the array of values it not the correct size.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Also see hou.Geometry.pointFloatAttribValues.

For a particular attribute, set the attribute values for all points from a string representation of a sequence of single precision float values. This method is faster than hou.Geometry.setPointFloatAttribValues.

Raises hou.OperationFailed if the length of the string is not `len(self.iterPoints() * 4).

See hou.Geometry.setPointFloatAttribValues and hou.Geometry.pointFloatAttribValuesAsString for more information.

The following example function accepts an array.array("f") and sets the attribute values to its contents:

def setPointFloatAttribValuesFromArray(geometry, arr):
    assert(arr.typecode == "f")
    geometry.setPointFloatAttribValuesFromString(arr.tostring())

Return a tuple of all the primitives in the geometry. The primitives returned will be subclasses of hou.Prim (e.g.polygons, volumes, etc.).

See also:

• hou.Geometry.iterPrims

• hou.Face

• hou.Polygon

• hou.Surface

• hou.Volume

Return a generator that iterates through all the primitives in the geometry.

Whereas hou.Geometry.prims allocates and returns a tuple of all the primitives in the geometry, this method returns a generator object that will yield hou.Prim objects on demand. This object is very fast at random access into the sequence.

If you're accessing a specific primitive by index and the geometry contains many primitives, it is faster to use iterPrims() than prims(). If, however, you are iterating over all the primitives in the geometry, it is generally faster to use prims() than iterPrims().

# This is preferred:
geo.iterPrims()[23]

# over this:
geo.prims()[23]

# But this is preferred:
for prim in geo.prims():
    ...process prim...

# over this:
for prim in geo.iterPrims():
    ...process prim...

See also the hou.Geometry.prims method.

Return a tuple of primitives corresponding to a pattern of primitive numbers.

The pattern format is the same one used by the group fields on SOP nodes that take primitive selections. See hou.Geometry.globPoints for more information.

Return a tuple of floats containing one attribute’s values for all the primitives.

This method only works on int or float attributes. If the attribute contains more than one element, each primitive will correspond to multiple values in the result. For example, if “Cd” is a float attribute of size 3 and there are 3 primitives with values (0.1, 0.2, 0.3), (0.5, 0.5, 0.5), and (0.8, 0.7, 0.6) then the result will be (0.1, 0.2, 0.3, 0.5, 0.5, 0.5, 0.8, 0.7, 0.6).

Calling this method is faster than looping over all the primitives and calling hou.Prim.attribValue

If the attribute name is invalid or the attribute is not an int or float (e.g. it’s a string attribute), this method raises hou.OperationFailed.

Note that you cannot pass a hou.Attrib object to this method like you can with many methods dealing with attributes. However, you can use hou.Attrib.name to easily get the name from an Attrib object.

Return a string representation of the floats of one attribute’s value for all the primitives. This method is faster than hou.Geometry.primFloatAttribValues, and you can use the array module to convert the string into a Python sequence.

This method provides a faster implementation of the following:

import array
def primFloatAttribValuesAsString(self, name):
    return array.array("f", self.primFloatAttribValues(name)).tostring()

You can convert the return value from this method to an array using the following method:

import array
def primFloatAttribValuesAsArray(geometry, name):
    a = array.array("f")
    a.fromstring(geometry.primFloatAttribValuesAsString(name))
    return a

See hou.Geometry.primFloatAttribValues for more information.

For a particular attribute, set the attribute values for all primitives. You would typically call this method from the code of a Python-defined SOP.

Raises hou.OperationFailed if the attribute name is not valid, the attribute is not an int or float (i.e. it’s a string), or the array of values it not the correct size.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Also see hou.Geometry.primFloatAttribValues.

For a particular attribute, set the attribute values for all primitives from a string representation of a sequence of single precision float values. This method is faster than hou.Geometry.setPrimFloatAttribValues.

Raises hou.OperationFailed if the length of the string is not `len(self.iterPrims() * 4).

See hou.Geometry.setPrimFloatAttribValues and hou.Geometry.primFloatAttribValuesAsString for more information.

The following example function accepts an array.array("f") and sets the attribute values to its contents:

def setPrimFloatAttribValuesFromArray(geometry, arr):
    assert(arr.typecode == "f")
    geometry.setPrimFloatAttribValuesFromString(arr.tostring())

Save the contents of the geometry object to a file. The file extension determines what file format to use.

All file formats supported by Houdini (e.g. geo, bgeo, obj, etc.), including extensions listed in GEOio, are supported. If the file extension is not recognized, the bgeo format is used.

Raises hou.OperationFailed if the path to the file is invalid or there were permission or other I/O errors.

Transforms (e.g. rotates, scales, translates, etc.) the geometry by a transformation matrix. You would typically call this method from the code of a Python-defined SOP.

See hou.hmath for functions that build transformation matrices.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Transforms a set of primitives (e.g. rotates, scales, translates, etc.) by a transformation matrix. You would typically call this method from the code of a Python-defined SOP.

import math

# This code will work from inside a Python SOP, but not from the Python
# shell.

def createCircle(geo, num_vertices=10):
    # Create a closed curve with the specified number of vertices.
    curve = geo.createNURBSCurve(num_vertices)
    curve.setIsClosed(True)

    # Arrange the points into a unit circle on the XZ plane,
    # centered about the origin.
    for i, vertex in enumerate(curve.vertices()):
        angle = i * (2.0 * math.pi) / num_vertices
        position = (math.cos(angle), 0, math.sin(angle))
        vertex.point().setPosition(position)
    return curve

# Create a bunch of circles on the XZ plane, tilt them slightly
# about X, translate them away from the origin, and rotate each
# one about the y axis by a different amount.
geo = hou.pwd().geometry()
num_copies = 20
for i in range(num_copies):
    curve = createCircle(geo)
    geo.transformPrims([curve],
        hou.hmath.buildRotateAboutAxis((1, 0, 0), 30) *
        hou.hmath.buildTranslate((2, 0, 0)) *
        hou.hmath.buildRotateAboutAxis((0, 1, 0), i * 360.0 / num_copies))

See hou.hmath functions that build transformation matrices.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Not implemented yet

Not implemented yet