Python —— hou.Node class

不可使用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/merge

print(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)