Return the x, y, and z dimensions of the volume. For example, a resolution of (10, 20, 30) means the volume is 10 voxels in x by 20 voxels in y by 30 voxels in z.

Given a sequence of three floats containing a 3D position, return the value of the volume at that position. If the position is not in the middle of a voxel, Houdini will interpolate using values from surrounding voxels.

See also hou.Volume.voxel() and hou.Volume.posToIndex().

Given a sequence of three floats containing a 3D position, return a vector which points in the direction of the greatest rate of increase of the volume’s value.

See Wikipedia’s gradient page for more information.

Given a sequence of three integers containing a voxel index, return the value of the corresponding voxel.

>>> volume_sop = hou.node("/obj").createNode("geo").createNode("volume")
>>> volume_sop.parm("initialval1").set(0.3)
>>> volume = volume_sop.geometry().prims()[0]
>>> volume.resolution()
(10, 10, 10)
>>> volume.voxel((0, 0, 0))
0.3

Set the value of a voxel. You would typically call this method from the code of a Python-defined SOP.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

Return a tuple of floats containing the values of all voxels. It is faster to call this method to retrieve all the voxels than it is to loop through the voxel array in Python.

You can, for example, use Python’s Numpy library to perform operations on the voxel data and then store the result back into the volume from a Python SOP using hou.Volume.setAllVoxels(). Note that Numpy allows you to reshape the flat tuple of floats to behave like a 3D matrix of floats.

This method can be approximately implemented as follows (though this Python implementation is much slower):

def allVoxels(self):
    result = []
    xres, yres, zres = self.resolution()
    for z in range(zres):
        for y in range(yres):
            for x in range(xres):
                result.append(self.voxel((x, y, z)))
    return tuple(result)

See also hou.Volume.allVoxelsAsString(), hou.Geometry.pointFloatAttribValues(), and hou.Geometry.primFloatAttribValues().

Return a binary string representation of the floats containing all the values of all voxels. This method is faster than hou.Volume.allVoxels(), 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 allVoxelsAsString(self):
    return array.array("f", self.allVoxels()).tostring()

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

import array
def allVoxelsAsArray(volume):
    a = array.array("f")
    a.fromstring(volume.allVoxelsAsString())
    return a

See hou.Volume.allVoxels() for more information.

Set the value of all voxels in this volume. You would typically call this method from the code of a Python-defined SOP.

Raises hou.OperationFailed if the sequence of values is not exactly the same as self.resolution()[0] * self.resolution()[1] * self.resolution()[2].

Raises hou.GeometryPermissionError if this geometry is not modifiable.

See also hou.Volume.allVoxels().

Set the value of all voxels in this volume from a string representation of a sequence of single precision float values. This method is faster than hou.Volume.setAllVoxels().

Note that this method can accept more types that just a string: it can receive any Python object that supports the buffer interface. In particular, arrays from the array and numpy Python modules are supported, so there is no need to first construct strings from those arrays.

Raises hou.OperationFailed if the length of the string is not exactly the same as self.resolution()[0] * self.resolution()[1] * self.resolution()[2] * 4.

See hou.Volume.setAllVoxels() and hou.Volume.allVoxelsAsString() for more information.

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

def setAllVoxelsFromArray(volume, arr):
    assert(arr.typecode == "f")
    volume.setAllVoxelsFromString(arr)

Return a tuple of floats containing the values of all voxels in a particular slice. It is faster to call this method to retrieve a slice than it is to loop through the voxel array in Python.

This method can be approximately implemented as follows (though this Python implementation is much slower):

def voxelSlice(self, plane, index):
    result = []

    start = [0] * 3
    stop = list(self.resolution())

    slice_axis = {"xy": 2, "xz": 1, "yz": 0}[plane]
    start[slice_axis] = index
    stop[slice_axis] = index + 1

    for z in range(start[2], stop[2]):
        for y in range(start[1], stop[1]):
            for x in range(start[0], stop[0]):
                result.append(self.voxel((x, y, z)))
    return tuple(result)

See also hou.Volume.voxelSliceAsString() and hou.Volume.allVoxels().

Return a binary string representation of the floats containing all the values of voxels in a particular slice.

See hou.Volume.voxelSlice() and hou.Volume.allVoxelsAsString() for more information.

Set the value of the voxels in a particular slice of this volume. You would typically call this method from the code of a Python-defined SOP.

Raises hou.OperationFailed if the sequence of values is not equal to the number of voxels in the slice.

Raises hou.GeometryPermissionError if this geometry is not modifiable.

See also hou.Volume.voxelSlice(). See hou.Volume.setVoxelSliceFromString() for an example.

Set the value of the voxels in a particular slice of this volume. You would typically call this method from the code of a Python-defined SOP.

See hou.Volume.setVoxelSlice() for more information.

The following example builds a volume from an compositing network sequence:

def buildVolumeFromCopSequence(
        cop_node, geo, voxel_depth, plane="C", component="r"):
    zres = int(cop_node.sequenceFrameLength())
    volume_bbox = hou.BoundingBox(*(
        0, 0, 0,
        cop_node.xRes(), cop_node.yRes(), zres) * voxel_depth)
    volume = geo.createVolume(
        cop_node.xRes(), cop_node.yRes(), zres, volume_bbox)

    for z in range(zres):
        pixels = cop_node.allPixelsAsString(
            plane, component,
            time=hou.frameToTime(z + cop_node.sequenceStartFrame()))
        volume.setVoxelSliceFromString(pixels, "xy", z)

Given a sequence of three floats containing a 3D position, return a tuple of three ints containing the corresponding index into the voxel array.

Note that the returned index will be invalid if the position is outside the volume. Use hou.Volume.isValidIndex() to determine if the index is valid.

Given a sequence of three ints containing an index into the voxel array, return the corresponding 3D position of the middle of that voxel.

Return whether or not a sequence of three ints containing an index into the voxel array is valid, ie, within the bounds of the array.

This method can approximately be implemented as follows:

def isValidIndex(self, index):
    for i, maximum in zip(index, self.resolution()):
        if i < 0 or i >= maximum:
            return False
    return True

Return whether or not the volume is flagged as a signed distance field. Such volumes have a special border condition where out of bound reads will add the distance to the bounding box to the streaked boundary condition. They are also best to be semantically treated as signed distance fields.

Return whether or not the volume is flagged as a heightfield. Such volumes are two dimensional and have the heightfield visualization set.

Return the average value of all voxels.

Return the minimum value of all voxels.

Return the maximum value of all voxels.

Return a 3×3 matrix containing the scale and rotation transformations for this volume.

Note that the position information for the volume can be obtained by calling volume.vertex(0).point().position().

The following function returns a 4×4 transformation matrix for the volume that includes the translation:

def fullTransform(volume):
    return (hou.Matrix4(volume.transform()) *
        hou.hmath.buildTranslate(volume.vertex(0).point().position()))

Given a 4×4 matrix, set the position, rotation, and scale of this volume.

Note that if you want to just set the translate portion of a volume to a hou.Vector3, you could just call volume.vertex(0).point().setPosition(position).