Python —— hou.Node class

目录

Hierarchy

node —— 返回指定路径的节点

nodes —— 返回指定多个路径的节点元组

item —— 返回指定路径的item

items —— 返回指定多个路径的item元组

allItems —— 返回该节点所有子节点的元组

cookPathNodes —— 返回上次cook所属network使用的节点列表

isNetwork —— 判断节点是否是network

children —— 返回子节点的列表

allSubChildren —— 递归返回所有子节点

allNodes —— 递归返回包含的所有节点

glob —— 返回名字匹配的子节点元组

recursiveGlob —— 递归返回名字匹配的子节点元组

Adding and Removing

createNode —— 创建指定类型的子节点

createOrMoveVisualizer —— 创建指定类型的子节点

destroy —— 删除节点

deleteItems —— 删除指定items

copyTo —— 将节点复制到新位置

copyItems —— 复制所有指定items

Selection

isCurrent —— 判断是否是最后一个选择的节点

setCurrent —— 设置或取消该节点为最后一个选择的节点

selectedChildren —— 返回该节点被选择的子节点

selectedItems —— 返回该节点被选择的孩子item

numItems —— 返回该节点孩子items指定类型的数量

Types

type —— 返回节点类型

changeNodeType —— 在同一语境下改变节点类型

changeTypeCategory —— 返回该节点子节点的类型类别

Parameters

expressionLanguage —— 返回默认表达式语言

setExpressionLanguage —— 设置节点默认表达式语言

parm —— 返回指定路径的参数

parms —— 返回节点的参数列表

allParms —— 递归返回节点及其子节点的所有参数序列

parmTuple —— 返回指定路径参数元素

parmTuples —— 返回该节点所有参数列表

parmTnFolder —— 返回该文件夹下的参数列表

parmTuplesTnFolder —— 返回该文件夹下的参数元组列表

globParms —— 返回匹配参数的元组

parmsReferencingThis —— 返回引用此节点的参数列表

setParms —— 设置节点参数值

setParmsPending —— 设置节点参数值

setParmExpressions —— 设置节点参数值

evalParm —— 计算指定参数并返回值

evalParmTuple —— 计算指定参数元组并返回值

spareParms —— 返回用户定义的备用参数列表

removeSpareParms —— 移除所有备用参数

addSpareParmTuple —— 在节点参数末尾添加备用参数元组

removeSpareParmTuple —— 移除指定的备用参数元组

addControlParmFolder —— 在最前面添加控制参数文件夹

addSpareParmFolder —— 添加文件夹

removeSpareParmFolder —— 移除空文件夹

replaceSpareParmTuple —— 替代已有的spare参数元组

parmTemplateGroup —— 返回对应当前参数布局的参数模板组

setParmTemplateGroup —— 更改该节点的备用参数

localVariables —— 返回能被$引用的局部变量列表

localAttributes —— 返回能被@引用的局部变量列表

parmAliases —— 返回参数别名的字典

clearParmAliases —— 清除所有来自参数的别名

saveParmClip —— 存储关联参数的动画

loadParmClip —— 加载关联参数的动画

parmClipData —— 返回参数的clip数据

setParmClipData —— 从给定的clip数据加载参数动画

Inputs and outputs

input —— 返回连接到此节点指定输入端口的节点

inputs —— 返回连接到此节点输入的节点元组

inputFollowingOutputs —— 返回连接到此节点指定输入端口的节点

outputs —— 返回连接到此节点输出的节点元组

setInput —— 从另一个节点的输出连接到该节点的输入

setNamedInput —— 从另一个节点的输出连接到该节点的输入

setFirstInput —— 从另一个节点的输出连接到该节点的第一个输入

setNextInput —— 从另一个节点的输出连接到该节点的第一个未输入

Layout

moveToGoodPosition —— 将节点移动到其输入或输出附近合适位置

layoutChildren —— 自动布局节点的所有或部分子节点

isHidden —— 判断节点是否隐藏

hide —— 隐藏或显示节点

Methods from hou.NetworkMovableItem

name —— 返回节点名字

setName —— 设置节点名字

digitsInName —— 返回节点名字中最后一组数字

path —— 返回节点完整路径

relativePathTo —— 返回从该节点到指定节点的路径

parent —— 返回该节点的父节点

parentNetworkBox —— 返回包含该节点的Network box

isSelected —— 判断item是否被选择

isPicked —— 判断item是否被选择

setSelected —— 选择或取消选择指定item

setPicked —— 选择或取消选择指定item

color —— 返回item颜色

setColor —— 设置item颜色

sessionId —— 返回唯一标识的整数值

position —— 返回item的位置

setPosition —— 设置item的位置

move —— 移动item位置

shiftPosition —— 移动item位置

size —— 返回item大小

Examples

---

Houdini内所有节点（Object、SOP、COP等）的基类，该类的实例对应houdini内的节点；

        每个节点都有一个唯一的路径（定义其在节点树内的位置）；节点路径层次结构类似于文件系统中的文件和文件夹的层次结构；一些节点可能包含其他节点（类似文件夹），其他节点可能不包含；如object实例和SOP subnetwork实例可能包含SOP节点，但box SOP实例不包含；

注，不要混淆节点和节点类型，节点是节点类型的实例；如box1是box SOP，有自己唯一的名字和自己参数值的副本，是box SOP的实例；节点类型定义所有实例共有的参数及算法，表示节点类型的类是hou.NodeType；

        不可使用hou.Node.__init__创建hou.Node的实例，使用hou.node()查找Node对象（对应已存在的houdini节点）；在其他节点内创建新的houdini节点实例，使用hou.Node.createNode()；删除houdini节点，使用hou.Node.destroy()；

        Node对象内部存储对应houdni节点的引用，它们的生命周期lifetime不同；如python节点对象被删除，因为其引用数将为零，houdini节点将不受影响；另外，如在python变量内有一个Node对象，houidni节点被删除，则python变量仍然存在，python不会崩溃；如后来在调用python Node对象的方法，将返回hou.ObjectWasDeleted异常；

        不要和函数hou.node混淆；

Hierarchy

node —— 返回指定路径的节点

node(node_path) → hou.Node or None

• 如相对路径，是相对于该节点的；
• 返回的可能是Node的子类；
• 如是绝对路径，此方法是 hou.node(node_path) 的缩写；否则是 hou.node(self.path() + "/" + node_path) 的缩写；

obj = hou.node('/obj') 
obj.node('.') // obj
obj.node('..') // /
obj.node('geo/merge') // merge
//返回的是Node的子类
obj = hou.node('/obj') // <class 'hou.Node'>
geo = hou.node('/obj/geo') // <class 'hou.ObjNode'>
merge = hou.node('/obj/geo/merge') // <class 'hou.SopNode'>

nodes —— 返回指定多个路径的节点元组

nodes(node_path_tuple) → tuple of hou.Node or None

• 如相对路径，是相对于该节点的；
• 等价于 nodes = [self.node(path) for path in paths] ；

obj = hou.node('/obj/geo') 
paths = ['/obj', '/obj/geo', '/obj/geo/merge'] 
obj.nodes(paths) // 等价于 [obj.node(path) for path in paths]
//(<hou.Node at /obj>, <hou.ObjNode of type geo at /obj/geo>, <hou.SopNode of type merge at /obj/geo/merge>)

item —— 返回指定路径的item

item(item_path) → hou.NetworkMovableItem or None

• 如相对路径，是相对于该节点的；
• 返回的可能是NetworkMovableItem的子类；
• 如是绝对路径，此方法是 hou.item(node_path) 的缩写；否则是 hou.item(self.path() + "/" + item_path) 的缩写；

items —— 返回指定多个路径的item元组

items(item_path_tuple) → tuple of hou.NetworkMovableItem or None

• 如相对路径，是相对于该节点的；
• 等价于 items = [self.item(path) for path in paths] ；

allItems —— 返回该节点所有子节点的元组

allItems() → tuple of hou.NetworkMovableItem

cookPathNodes —— 返回上次cook所属network使用的节点列表

cookPathNodes() → tuple of hou.Node

• 包括subnet内的节点；

for node in hou.node('/obj/geo1/null1').cookPathNodes():print(node)

isNetwork —— 判断节点是否是network

isNetwork() → bool

• 即判断节点是否包含子节点；
• 如不是，则像createNode方法会报错hou.OperationFailed；

children —— 返回子节点的列表

children() → tuple of hou.Node

• 获取子节点的个数使用 len(node.children()) ；
• 返回子节点的顺序与用户定义的顺序相同（list mode）

geo = hou.node('/obj/geo/')
for node in geo.children():print(node.name())

allSubChildren —— 递归返回所有子节点

allSubChildren(top_down=True, recurse_in_locked_nodes=True, sync_delayed_definition=False) → tuple of hou.Node

allNodes —— 递归返回包含的所有节点

allNodes() → generator of hou.Node

• 递归返回该节点及其所有子节点；
• 与allSubChidren节点不同，返回的是generator，创建或删除节点不安全；

glob —— 返回名字匹配的子节点元组

glob(pattern, ignore_case=False) → tuple of hou.Node

• 默认区分大小写；

obj = hou.node('/obj')
for node in obj.glob('geo*'):print(node.name())

recursiveGlob —— 递归返回名字匹配的子节点元组

recursiveGlob(pattern, filter=hou.nodeTypeFilter.NoFilter, include_subnets=True) → tuple of hou.Node

---

Adding and Removing

createNode —— 创建指定类型的子节点

createNode(node_type_name, node_name=None, run_init_scripts=True, load_contents=True, 
exact_type_name=False, force_valid_node_name=False) 
→ hou.Node

createOrMoveVisualizer —— 创建指定类型的子节点

createOrMoveVisualizer(output_index)

• 仅适用于SOP、VOP节点，其他类型节点不做任何事；

destroy —— 删除节点

destroy(disable_safety_checks=False)

deleteItems —— 删除指定items

deleteItems(items, disable_safety_checks=False)

• 比循环调用destroy高效；
• 可安全的处理不被允许删除的对象；
• items应为该节点的孩子；

copyTo —— 将节点复制到新位置

copyTo(destination_node) → hou.Node

• 新节点是在给定节点内部；

copyItems —— 复制所有指定items

copyItems(items, channel_reference_originals = False, relative_references = True, connect_outputs_to_multi_inputs = True) 
→ tuple of hou.NetworkMovableItem

• items不必是该network的孩子，但items必须被包含在相同的父亲；

geo = hou.node('/obj/geo')
items = geo.allItems()
copyitems = hou.node('/obj/geo1').copyItems(items)

---

Selection

isCurrent —— 判断是否是最后一个选择的节点

isCurrent() → bool

setCurrent —— 设置或取消该节点为最后一个选择的节点

setCurrent(on, clear_all_selected=False)

• 如取消最后一个节点的选择，则倒数第二个选择将是最后一个选择；

selectedChildren —— 返回该节点被选择的子节点

selectedChildren(include_hidden=False, include_hidden_support_nodes=False) → tuple of hou.Node

• include_hidden_support_nodes，如在VOP中选择的节点有隐藏节点；

selectedItems —— 返回该节点被选择的孩子item

selectedItems(include_hidden=False, include_hidden_support_nodes=False) → tuple of hou.NetworkMovableItem

for n in hou.node("/obj").selectedItems():print n.position()

numItems —— 返回该节点孩子items指定类型的数量

numItems(item_type=None, selected_only=False, include_hidden=False) → int

---

Types

type —— 返回节点类型

type() → hou.NodeType

changeNodeType —— 在同一语境下改变节点类型

changeNodeType(new_node_type, keep_name=True, keep_parms=True, keep_network_contents=True, force_change_on_node_type_match=False) 
→ hou.Node

node = hou.node('/obj/geo1')
new_node = node.changeNodeType('cam')

changeTypeCategory —— 返回该节点子节点的类型类别

childTypeCategory() → hou.NodeTypeCategory

node = hou.node('/obj') // Object
node = hou.node('/obj/geo') // Sop

---

Parameters

expressionLanguage —— 返回默认表达式语言

expressionLanguage() → hou.exprLanguage enum value

• 更改表达式语言不会改变已有的表达式；
• 设置表达式语言 hou.Parm.setExpression() ；

setExpressionLanguage —— 设置节点默认表达式语言

setExpressionLanguage(language)

parm —— 返回指定路径的参数

parm(parm_path) → hou.Parm or None

parm = hou.node("/obj/geo1/box1").parm('tx')

parms —— 返回节点的参数列表

parms() → tuple of hou.Parm

parms = hou.node("/obj/geo1/box1").parm()

allParms —— 递归返回节点及其子节点的所有参数序列

allParms() → generator of hou.Parm

root_node = hou.node("/obj")
for parm in root_node.allParms():print(parm.path())

parmTuple —— 返回指定路径参数元素

parmTuple(parm_path) → hou.ParmTuple or None

• 类似parm()；

parms = hou.node("/obj/geo1/box1").parmTuple('t')
for parm in parms:print(parm.name())

parmTuples —— 返回该节点所有参数列表

parmTuples() → tuple of hou.ParmTuple

• 类似parms()；

parmTnFolder —— 返回该文件夹下的参数列表

parmsInFolder(folder_names) → tuple of hou.Parm

• folder_names，使用的是label名，如使用("Render", "Shading")表示在Render文件夹下的Shading文件夹；
  • 如为空，将返回所有参数，与parms()一样；

node.parmsInFolder(("Render", ))
node.parmsInFolder(("Render", "Shading"))
node.parmsInFolder(("Render", "Shading"，"myfolder"))

parmTuplesTnFolder —— 返回该文件夹下的参数元组列表

parmTuplesInFolder(folder_names) → tuple of hou.ParmTuple

node.parmTuplesInFolder(("Render", ))
node.parmTuplesInFolder(("Render", "Shading"))

globParms —— 返回匹配参数的元组

globParms(pattern, ignore_case=False, search_label=False, single_pattern=False) → tuple of hou.Parm

• pattern，可包含多个（用空格隔开），* 表示匹配任何字符，^表示排除；
• ignore_case，默认区分大小写；不区分大小写仅适用节点和参数名字，group、network box 、bundle名字不适用；

parms = hou.node("/obj/geo1").globParms('t? r? s?')
for parm in parms:print(parm.name())

parmsReferencingThis —— 返回引用此节点的参数列表

parmsReferencingThis() → tuple of hou.Parm

setParms —— 设置节点参数值

setParms(parm_dict)

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParms({"tx": 1, "sy": 3})

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParms({"t": (1, 2, 3), "s": (3, 3, 3)})

setParmsPending —— 设置节点参数值

setParmsPending(parm_dict)

setParmExpressions —— 设置节点参数值

setParmExpressions(parm_dict, language=None, replace_expressions=True)

hou.node("/obj/geo1/box1").setParmExpressions({'tx': 'sin($F)'})

evalParm —— 计算指定参数并返回值

evalParm(parm_path) → int , float , or str

evalParmTuple —— 计算指定参数元组并返回值

evalParmTuple(parm_path) → tuple of int , float , or str

spareParms —— 返回用户定义的备用参数列表

spareParms() → tuple of hou.Parm

removeSpareParms —— 移除所有备用参数

removeSpareParms()

addSpareParmTuple —— 在节点参数末尾添加备用参数元组

addSpareParmTuple(parm_template, in_folder=(), create_missing_folders=False) → hou.ParmTuple

removeSpareParmTuple —— 移除指定的备用参数元组

removeSpareParmTuple(parm_tuple)

• 此方法已丢弃，使用 setParmTemplateGroup ；

addControlParmFolder —— 在最前面添加控制参数文件夹

addControlParmFolder(folder_name=None, parm_name=None)

• 如节点没有文件夹，则会额外添加 "Parameters" 文件夹

addSpareParmFolder —— 添加文件夹

addSpareParmFolder(folder_name, in_folder=(), parm_name=None, create_missing_folders=False)

removeSpareParmFolder —— 移除空文件夹

removeSpareParmFolder(folder)

replaceSpareParmTuple —— 替代已有的spare参数元组

replaceSpareParmTuple(parm_tuple_name, parm_template)

• 此方法已丢弃，使用 setParmTemplateGroup ；

parmTemplateGroup —— 返回对应当前参数布局的参数模板组

parmTemplateGroup() → hou.ParmTemplateGroup

setParmTemplateGroup —— 更改该节点的备用参数

setParmTemplateGroup(parm_template_group, rename_conflicting_parms=False)

• 此方法优先于其他参数相关方法；

>>> node = hou.node("/obj").createNode("geo")
>>> group = node.parmTemplateGroup()
>>> folder = hou.FolderParmTemplate("folder", "My Parms")
>>> folder.addParmTemplate(hou.FloatParmTemplate("myparm", "My Parm", 1))
>>> group.append(folder)
>>> node.setParmTemplateGroup(group)

localVariables —— 返回能被$引用的局部变量列表

localVariables()

localAttributes —— 返回能被@引用的局部变量列表

localAttributes()

parmAliases —— 返回参数别名的字典

parmAliases(recurse=False) → dict of hou.Parm to str

clearParmAliases —— 清除所有来自参数的别名

clearParmAliases()

saveParmClip —— 存储关联参数的动画

saveParmClip(file_name, start=None, end=None, sample_rate=0, scoped_only=False)

• 文件扩展名应为 .clip、.bclip、.bclip.sc ；

loadParmClip —— 加载关联参数的动画

loadParmClip(file_name, sample_rate=0, start=None)

node = hou.node("/obj/geo1/transform1")
node.saveParmClip('parm.clip')
new_node = hou.node("/obj/geo1/transform2")
new_node.loadParmClip('parm.clip')

parmClipData —— 返回参数的clip数据

parmClipData(start=None, end=None, binary=True, use_blosc_compression=True, sample_rate=0, scoped_only=False) 
→ str for Python 2, bytes for Python 3

• 类似 hou.Node.saveParmClip ，只是返回数据（文件内容）；

setParmClipData —— 从给定的clip数据加载参数动画

setParmClipData(data, binary=True, blosc_compressed=True, sample_rate=0, start=1)

• 类似 hou.Node.loadParmClip ，只是返回数据（文件内容）；

---

Inputs and outputs

input —— 返回连接到此节点指定输入端口的节点

input(inputidx) → hou.Node

inputs —— 返回连接到此节点输入的节点元组

inputs() → tuple of hou.Node

inputFollowingOutputs —— 返回连接到此节点指定输入端口的节点

inputFollowingOutputs(inputidx) → hou.Node

• 如输入的不是首个输出，会返回输出节点内部的节点；

outputs —— 返回连接到此节点输出的节点元组

outputs() → tuple of hou.Node

• 此方法是 [connection.outputNode() for connection in self.outputConnections()] 的缩写；

setInput —— 从另一个节点的输出连接到该节点的输入

setInput(input_index, item_to_become_input, output_index=0)

• item_to_become_input，如为None将断开连接；

node = hou.node('../subnet1')
current_node = hou.pwd()
current_node.setInput(0, node, 1)

setNamedInput —— 从另一个节点的输出连接到该节点的输入

setNamedInput(input_name, item_to_become_input, output_name_or_index)

• 通过名字指定输出、输入；

node = hou.node('../subnet1')
current_node = hou.pwd()
current_node.setNamedInput('input1', node, 'output2')

setFirstInput —— 从另一个节点的输出连接到该节点的第一个输入

​setFirstInput(item_to_become_input, output_index=0)

• 此方法是 self.setInput(0, item_to_become_input) 的缩写；

setNextInput —— 从另一个节点的输出连接到该节点的第一个未输入

setNextInput(item_to_become_input, output_index=0, unordered_only=False)

Layout

moveToGoodPosition —— 将节点移动到其输入或输出附近合适位置

moveToGoodPosition(relative_to_inputs=True, move_inputs=True, move_outputs=True, move_unconnected=True) → hou.Vector2

layoutChildren —— 自动布局节点的所有或部分子节点

layoutChildren(items=(), horizontal_spacing=-1.0, vertical_spacing=-1.0)

• -1，表示为默认的间隔；

isHidden —— 判断节点是否隐藏

isHidden()

hide —— 隐藏或显示节点

hide(on)

---

Methods from hou.NetworkMovableItem

name —— 返回节点名字

name() → str

setName —— 设置节点名字

setName(name, unique_name=False)

digitsInName —— 返回节点名字中最后一组数字

digitsInName() → int

• 没有数字，返回0；

path —— 返回节点完整路径

path() → str

relativePathTo —— 返回从该节点到指定节点的路径

relativePathTo(base_node) → str

parent —— 返回该节点的父节点

parent() → hou.Node

parentNetworkBox —— 返回包含该节点的Network box

parentNetworkBox() → hou.NetworkBox or None

isSelected —— 判断item是否被选择

isSelected() → bool

• 函数 hou.selectedNodes() 返回所有被选择的节点；

isPicked —— 判断item是否被选择

isPicked() → bool

• 等价于 hou.NetworkMovableItem.isSelected() ；

setSelected —— 选择或取消选择指定item

setSelected(on, clear_all_selected=False, show_asset_if_selected=False)

setPicked —— 选择或取消选择指定item

setPicked(on)

• 等价于 hou.NetworkMovableItem.setSelected() ；

color —— 返回item颜色

color() → hou.Color

setColor —— 设置item颜色

setColor(color)

sessionId —— 返回唯一标识的整数值

sessionId()

position —— 返回item的位置

position() → hou.Vector2

setPosition —— 设置item的位置

setPosition(vector2)

move —— 移动item位置

move(vector2)

shiftPosition —— 移动item位置

shiftPosition(vector2)

• 等价于 hou.NetworkMovableItem.move() ；

size —— 返回item大小

size() → hou.Vector2

---

Examples

//在不同层级创建对象，返回的类型也不同
import os
obj = hou.node('/obj') // /obj
geo = obj.createNode('geo', 'geo') // /obj/geo
merge = geo.createNode('merge') // /obj/geo/mergeprint(obj, type(obj)) // obj <class 'hou.Node'>
print(geo, type(geo)) // geo <class 'hou.ObjNode'>
print(merge, type(merge)) // merge1 <class 'hou.SopNode'>

//创建多个对象并连接
import os
geo = hou.node('/obj').createNode('geo', 'geo')
boxes = []
for i in range(5):box = geo.createNode('box')boxes.append(box)
merge = geo.createNode('merge')
for box in boxes:merge.setNextInput(box)
geo.layoutChildren()
merge.setDisplayFlag(True)
merge.setRenderFlag(True)