hou.Parm class

Returns the parameter’s channel alias name. Returns an empty string if no such name exists.

Not implemented yet

Returns a script of Python statements that can be executed to set the parameter’s values, flags and other properties. To run the script, use either Python’s exec or execfile functions.

Here is an example of saving the output to a file and then loading it back into Houdini:

# Get a reference to the target parameter.
p = hou.parm("/obj/geo1/tx")

# Execute asCode and write the output script to file.
script = p.asCode()
f = open("set_parm_properties.py", "w")
f.write(script)
f.close()

# Execute the script.  This will set the values, flag values
# and other properties on /obj/geo1's tx parameter.  It will
# also store a reference to the tx parameter into a variable
# named 'hou_parm'.
execfile("set_parm_properties.py")

Here is an example of saving the output into a function and then calling it in Houdini:

# Get a reference to the target parameter.
node = hou.parm("/obj/geo1/tx")

# Execute asCode and write the function definition to file.
func = p.asCode(function_name="setParmProperties")
f = open("parmlib.py", "w")
f.write(func)
f.close()

# Call the function definition to set the properties on another
# parameter.
import parmlib
hou_parm = parmlib.setParmProperties(node.parm("ty"))

Returns the component index of this parameter.

For example, the translation parameter along the x-axis, “tx”, would return a component index of 0, while the translation parameter along the y-axis, “ty” would return a component index of 1.

Returns a tuple of strings corresponding to the names of the folders containing this parameter.

For example, if this parameter is in the Shading folder and the Shading folder is inside the Render folder, this method will return (“Render”, “Shading”).

Returns an empty tuple if this parameter is not inside a folder.

Note that calling this method on many parameters may be slow. For a faster alternative, see hou.Node.parmsInFolder.

See also the containingFolderSetParmTuples method, and hou.Node.parmTuplesInFolder.

Return a tuple of ParmTuples corresponding to the folders containing this parameter.

For example, if this parameter is in the Shading folder and the Shading folder is inside the Render folder, this method will return a tuple containing the Render parm tuple and the Shading parm tuple. Any parm tuples returned will be folder sets.

If this parameter is not inside a folder, an empty tuple is returned.

See also the containingFolders() method, and hou.Node.parmsInFolder and hou.Node.parmTuplesInFolder.

Return a tuple of indices corresponding to the folders containing this parameter. Each index refers to a folder in the corresponding folder set parameter.

This method can be implemented as follows:

def containingFolderIndices(self):
    return tuple(
        list(folder_set_parm_tuple.parmTemplate().folderNames()).index(
            folder_name)
        for folder_set_parm_tuple, folder_name in zip(
            parm.containingFolderSetParmTuples(), parm.containingFolders()))

This example makes a parameter visible in the parameter pane by opening all the folders containing it.

def makeParmVisible(parm):
    for folder_set_parm_tuple, folder_index in zip(
            parm.containingFolderSetParmTuples(),
            parm.containingFolderIndices()):
        folder_set_parm_tuple[0].set(folder_index)

Not implemented yet

Removes all keyframes from this parameter.

This has no effect if there are no keyframes to delete. The value of the parameter after all keyframes are removed will be the one it evaluated to at the current frame.

This function will raise a hou.ObjectWasDeleted exception if it is invoked on a parameter that does not exist in Houdini.

This function will raise a hou.PermissionError exception if writing to the specified parameter is impossible.

See also hou.ParmTuple.deleteAllKeyframes.

Returns this parameter’s label.

Not implemented yet

Evaluates this parameter at the current frame and returns the result. See also the evalAtFrame() method.

Evaluates this parameter at the current frame and returns the result as a float.

Raises hou.TypeError if the value cannot be converted to a float.

Evaluates this parameter at a certain frame and returns the result as a float.

Raises hou.TypeError if the value cannot be converted to a float.

Evalutes this parameter at the current frame and returns the result as an integer.

Raises hou.TypeError if the value cannot be converted to an integer.

Evaluates this parameter at a certain frame and returns the result as an integer.

Raises hou.TypeError if the value cannot be converted to an integer.

Evalutes this parameter at the current frame and returns the result as a string.

Raises hou.TypeError if the value cannot be converted to a string.

Evaluates this parameter at a certain frame and returns the result as a string.

Raises hou.TypeError if the value cannot be converted to a string.

Evalutes this parameter at a certain frame and returns the result as an integer, float or string.

Evalutes this parameter at the current frame and returns the result as a ramp.

Raises hou.TypeError if the parameter is not a ramp.

Evalutes this parameter at a certain frame and returns the result as a ramp.

Raises hou.TypeError if the parameter is not a ramp.

Not implemented yet

TODO: Do we need executeCallbacks now that we have pressButton?

Emulates clicking a button parameter to trigger its callback script. Raises hou.OperationFailed if the callback script could not be run.

Returns this parameter’s expression.

For example, a parameter might contain the Python expression “frame() * 2”. In this case hou.Parm.eval at frame 2 would return the value 4, while calling expression() would return the string “frame() * 2”.

If the parameter does not contain an expression, this method will raise hou.OperationFailed. Also, if the parameter contains more than one keyframe then it could contain multiple different expressions, so it also raises hou.OperationFailed in that case.

This method is roughly equivalent to…

parm.keyframes()[0].expression()

See also the setExpression(), expressionLanguage(), keyframes(), and eval() methods.

Returns the parameter’s expression’s language.

If the parameter does not contain an expression, this method will raise hou.OperationFailed. Also, if the parameter contains more than one keyframe then it could contain multiple different expressions, so it also raises hou.OperationFailed in that case.

To change the expression language, use hou.Parm.setExpression and explicitly specify the language: parm.setExpression(parm.expression(), language).

This method is roughly equivalent to…

parm.keyframes()[0].expressionLanguage()

See also the expression(), setExpression(), keyframes(), and setExpressionLanguage() methods.

Returns the referenced parameter. If no paramter is referenced, returns this parameter.

Returns whether this parameter’s autoscope property is on.

Returns whether this parameter is locked (uneditable).

Not implemented yet

Not implemented yet

Returns whether this parameter is a “spare” (user-defined) parameter.

Returns whether this parameter is time dependent, that is, its value changes depending on the point on the timeline at which it’s evaluated. For example the parameter has an expression containing the $F (current frame number) variable.

Return whether this parameter is an instance of a multi parm. For example, the pt0x, pt1x, pt2x, etc. parameters in an add SOP are instances of a multiparm.

Not implemented yet

Not implemented yet

Returns the keyframes on this parameter.

Not implemented yet

Not implemented yet

Locks (lock(True)) or unlocks (lock(False)) this parameter (this is, makes the value uneditable).

Raises hou.PermissionError if this parameter is part of a locked digital asset.

Returns a list of all possible menu items (for a menu parameter). Raises hou.OperationFailed if this parameter is not a menu.

Not implemented yet

Returns this parameter’s name.

Returns the node on which this parameter exists.

Returns the CHOP track overriding this parameter, if any.

Returns the template for this parameter.

Returns the full path to this parameter.

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Not implemented yet

Changes the value back to the default that ships with Houdini, and restores that default.

See also the revertToDefaults() method, and hou.ParmTuple.revertToAndRestorePermanentDefaults

Change the value back to the default(s). See also the revertToAndRestoreFactoryDefaults() method.

Sets the parameter value at the current frame.

Raises hou.TypeError if the type of value does not match the type of this parameter. Raises hou.PermissionError if this parameter is not writable.

Gives the parameter another name by which it can be referenced in channels. You can pass in an empty string to remove an existing alias name.

Not implemented yet

Changes the autoscope property of the parameter. If this property is on, this parameter is automatically scoped when the object is selected.

Sets this parameter’s expression.

Unlike hou.Parm.set, this method does not follow channel references. That is, if this parameter is referencing another parameter and you call setExpression(), it change the channel reference expression into the specified expression.

If the parameter does not already contain any keyframes, this method is roughly equivalent to setting a keyframe at frame 1, where the keyframe’s expression and language are the ones specified.

This method can be approximately implemented as follows:

def setExpression(self, expression, language=None, replace_expression=None)
    if self.template().type() == hou.parmTemplateType.String:
        k = hou.StringKeyframe()
    else:
        k = hou.Keyframe()

    k.setExpression(expression, language)

    if len(self.keyframes()):
        if replace_expression:
            k.setTime(self.effectiveKeyframeAtFrame(hou.frame()).time())
        else:
            k.setTime(hou.time())
    else
        k.setTime(0.0)

    self.setKeyframe(k)

See also the expression, expressionLanguage, and setKeyframe methods, and hou.Node.expressionLanguage.

Sets a keyframe on this parameter.

Raises hou.TypeError if keyframe is not of type hou.BaseKeyframe. Raises hou.PermissionError if this parameter is not writable.

Not implemented yet

Sets the parameter value at the current frame and marks it as pending if the parameter is keyed.

Raises hou.TypeError if the type of value does not match this parameter’s type. Raises hou.PermissionError if this parameter is not writable.

Creates a Channel CHOP representing this parameter. The Channel CHOP is created with the given name as a child of the given parent node. The parent_node is typically created via hou.Node.findOrCreateMotionEffectsNetwork.

See also hou.Node.findOrCreateMotionEffectsNetwork.

Not implemented yet

Not implemented yet

Returns the hou.ParmTuple associated with this parameter.

For example, calling this method on the Parm object for the translation parameter “tx”, would return a ParmTuple that contains Parm objects for the three translation parameters “tx”, “ty” and “tz”. If no tuple is associated with the parameter, then the parameter itself is returned in a tuple of size 1.

Not implemented yet

Returns the contents of the parameter before dollar sign and backtick expansion.

Examples of unexpanded strings would be “image$F.pic”, “$HIP/split.otl”, or “chs('../font1/text')”. If you were to call eval() on them, Houdini would perform variable expansion and backtick expression evaluation, so you would get back something like “image1.pic” instead of “image$F.pic”.

Because only string parameters will attempt to do dollar sign and string expansion, this method will raise hou.OperationFailed if called from a non-string parameter.

Suppose a string parameter contains keyframes. In this situation, Houdini will not attempt to do string expansion on the parameter’s value, so calling this method will raise hou.OperationFailed. Instead of calling this method, you can call expression() to access the first Keyframe’s expression. If there are multiple keyframes, you can call keyframes() to get a list of hou.StringKeyframe objects and call expression() on those objects to retrieve the expression.