このオブジェクトで表現されたネットワークアイテムのタイプを示した列挙値を返します。 この値は、isinstanceビルトインPython関数でそれに一致したクラスを使用することと等価です(例えば、hou.networkItemType.Connectionはhou.NodeConnectionと等価です)。

このノードの名前を返します。hou.NetworkMovableItem.pathも参照してください。

このノードの名前を設定します。その新しい名前に英数字、.、-、_以外の文字が含まれている場合、hou.OperationFailedを引き起こします。 ノードの名前を変更できなかった場合(例えば、他のノードで同じ名前が既に使用されていたり、そのノードがルートノードまたはトップレベルマネージャ(例えば、/obj)だったり、そのノードがロックアセット内にある場合)は、hou.OperationFailedを引き起こします。 unique_nameパラメータをTrueに設定すると、指定した名前が既存ノードの名前と被らないように変更させることができます。

ノードの名前の最後の桁の値を返します。 桁がなければ0を返します。

例えば、geo102ノードは102、light12to34ノードは34を返します。

ネットワーク内のこのノードのフルパス(つまり、/から始まります)を返します。

他のノードオブジェクトを基準として、このノードの相対パスを返します。

>>> box1 = hou.node("/obj/box_object1/box1")
>>> sphere1 = hou.node("/obj/sphere_object1/sphere1")
>>> box1.relativePathTo(sphere1)
'../../sphere_object1/sphere1'
>>> hou.node("/obj").relativePathTo(box1)
'box_object1/box1'
>>> box1.relativePathTo(box1)
'.'

このアイテムを含んだノードを返します。

そのアイテムがルートノード(つまり、/)であれば、このメソッドはNoneを返すことに注意してください。

>>> hou.node("/obj/box_object1").parent()
<hou.Node at /obj>
>>> print hou.node("/").parent()
None

このアイテムを含んだ親のネットワークボックスを返します。それがネットワークボックスに含まれていなければNoneを返します。

このアイテムが選択されているかどうかを返します。

hou.selectedNodes()も参照してください。

hou.NetworkMovableItem.isSelectedをコールする事と等価です。

このアイテムを選択または選択解除します。オプションで、このネットワーク内で選択されているアイテム以外すべてを選択解除することができます。 show_asset_if_selectedがTrueで、このアイテムがNodeの場合、このペインは、代わりに選択したアイテムのトップレベルのアセットを表示します。

すべてのオプションのパラメータのデフォルト値でhou.NetworkMovableItem.setSelectedをコールする事と等価です。

ネットワークエディタ内のこのアイテムのタイルのカラーを返します。

指定したhou.Colorで、ネットワークエディタ内のこのアイテムのタイルのカラーを設定します。

指定したHoudiniセッション内でこのアイテムを固有に識別するための整数値を返します。 このIDは、単一Houdiniプロセス内でのみ固有であることが保証されます。 このIDは、アイテムの保存、復元、参照をするのが簡単になるので便利です。 また、このIDは特定のアイテムサブクラスに対しても固有です。 そのため、NetworkBoxと同じセッションIDを持つNodeが存在することがあります。

セッションIDからノードを取得するにはhou.nodeBySessionId()を、セッションIDからネットワークボックスを取得するにはhou.networkBoxBySessionId()を、 もっと汎用的にセッションIDとアイテムサブクラスを示した列挙値を組み合わせてそのタイプのアイテムを取得するにはhou.itemBySessionId()を参照してください。

ネットワークエディタグラフ内のこのアイテムのタイルの位置をVector2として返します。 move()とsetPosition()も参照してください。

ネットワークエディタグラフ内のこのアイテムのタイルの位置を設定します。 アイテムの位置を動かせなかった場合は、hou.InvalidInputを引き起こします。

ネットワークエディタグラフ内のこのアイテムのタイルを、指定したhou.Vector2の分だけ動かします。

アイテムを絶対位置で動かすには、setPosition()を使用します。

アイテムの現行グラフ位置を取得するには、position()を使用します。

指定した位置にアイテムを動かせなかった場合は、hou.InvalidInputを引き起こします。

hou.NetworkMovableItem.moveをコールする事と等価です。

ネットワークエディタグラフ内のこのアイテムのタイルのサイズをVector2として返します。

指定したパスのノードを返します。ノードが見つからなければNoneを返します。 相対パス(つまり、/で始まらないパス)を指定した場合、このノードを基準に検索が実行されます。

例えば、変数n内のノードの親ノードを取得するには、n.node("..")を使用します。 geo5という名前の子ノードを取得するには、n.node("geo5")を使用します。 light3という名前の兄弟ノードを取得するには、n.node("../light3")を使用します。

戻り値は、Nodeのサブクラスのインスタンスであることに注意してください。 例えば、見つかったノードがオブジェクトノードであれば、戻り値は、hou.ObjNodeインスタンスになります。

パスが絶対パス(つまり、/で始まるパス)なら、このメソッドは、hou.node(node_path)のショートカットです。 相対パスなら、hou.node(self.path() + "/" + node_path)のショートカットです。 hou.node()も参照してください。

これは、node()と同様ですが、複数のパスを受け取り、複数のNodeオブジェクトを返します。これは以下と等価です:

nodes = [self.node(path) for path in paths]

指定したパスのネットワークアイテムを返します。そのアイテムが存在しなかった場合はNoneを返します。 相対パス(つまり、/で始まらないパス)を指定すると、このノードを基準に検索が実行されます。

そのパスが絶対パス(つまり、/で始まる)の場合、このメソッドは、hou.item(node_path)のショートカットです。 それ以外の場合、hou.item(self.path() + "/" + item_path)のショートカットです。 hou.item()も参照してください。

戻り値がNetworkMovableItemのサブクラスのインスタンスである場合があることに注意してください。 例えば、見つかったアイテムがオブジェクトノードであれば、その戻り値はhou.ObjNodeインスタンスです。 そのアイテムがネットワークボックスであれば、その戻り値はhou.NetworkBoxインスタンスです。

これは、item()と同様ですが、複数のパスを受け取り、複数のNetworkMovableItemオブジェクトを返します。これは以下と等価です:

items = [self.item(path) for path in paths]

このノードがネットワークの場合、つまり、子ノードを含むことができるノードの場合はTrueを返します。 それ以外の場合はFalseを返します。 これは、hou.Node.createNodeなどのいくつかの他のメソッドをコールすると、そのメソッドはhou.OperationFailedを引き起こすことを意味します。

If this node is not an HDA and not inside an HDA, this method returns True.

If this node is an HDA node, returns True if the node is unlocked, False if it is locked (this is equivalent to not node.matchesCurrentDefinition()).

If this node is inside a locked HDA node, this method returns True if this node is or is inside an editable subnet within the locked HDA. Otherwise it returns False.

This method reflects the ability of certain types of modifications to be made to the children of this node. These modifications, such as wiring nodes together, or setting flags are edits to the child nodes which also affect the behavior of the parent or surrounding nodes. For example, to determine if a node can have its display flag turned on, you would test node.parent().isEditable(). For modifications to a node that are purely internal to the node itself, such as modifying a parameter value, you should test if node.isEditableInsideLockedHDA().

このノードの子であるノードのリストを返します。 ファイルシステムと同じように、ノードの子はフォルダ/ディレクトリのような構成になっています。

子ノードの数を調べるには、len(node.children())を使用します。

その結果の子の順番は、Houdiniでのユーザ定義の順番と同じです。 この順番を確認するには、Network Viewペインをリストモードに切り替え、そのリスト順を user defined に設定します。 ノードの順番を変更するには、そのリスト内でノードをドラッグアンドドロップします。

def pc(node):
    '''特定のノードの子の名前をプリントします。
       この関数は、Pythonシェルでインタラクティヴに動作させる時に役に立ちます。'''
    for child in node.children():
        print child.name()

def ls():
    '''現行ノード下のノードの名前をプリントします。'''
    pc(hou.pwd())

以下のエクスプレッションは特定のノードタイプの子のリストを評価します:

[c for c in node.children() if c.type() == node_type]

このノードのすべての子を含んだタプルを返します。 childrenとは違い、このメソッドはhou.NetworkBox, hou.SubnetIndirectInput, hou.StickyNote, hou.NetworkDotのオブジェクトも返します。

このノードのサブチルドレンすべてを再帰的に返します。 例えば、hou.node("/").allSubChildren()は、HIPファイル内のノードすべてを返します。

返されるのはタプルであって、ジェネレータではないことに注意してください。 つまり、戻り値を通じてループしている間にノードを削除したり作成しても安全であることを意味します。

以下の関数は、指定したノード内の特定のタイプの子すべてを削除します:

def removeSubChildrenOfType(node, node_type):
    '''特定のタイプの子すべてを再帰的に削除します。'''
    for child in node.allSubChildren():
        if child.type() == node_type:
            child.destroy()

このコードは、例えば、/obj下にあるVisibility SOPすべてを削除します:

>>> removeSubChildrenOfType(hou.node("/obj"), hou.sopNodeTypeCategory().nodeTypes()['visibility'])

Recursively return all sub items (nodes, network boxes, sticky notes, etc.) in this node. For example, hou.node("/").allSubItems() will return all the node network items in the hip file.

Refer to hou.Node.allSubChildren for more information on the method parameters.

このノード内に含まれたすべてのノード(このノードを含む)のシーケンスを再帰的に返します。 このメソッドは、以下の点でhou.Node.allSubChildrenと異なります:

• 戻りのシーケンスには、このノードが含まれます。

• 上から下または下から上の走査順を保証していません。

• このメソッドはジェネレータであり、タプルを返さないので、その戻り値によってループさせてノードを作成または削除するのは危険です。

以下は、/obj下のすべてのノードのパスを出力した例です:

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

パターンに合致した子ノード名のタプルを返します。

パターンには、スペース区切りで複数のピースを含めることができます。 パターンピース内のアスタリスク(*)は、どの文字にも合致します。 デフォルトでは、Houdiniは、各パターンピースで既に合致したノードを追加します。 しかし、そのパターンピースがキャレット(^)で始まっていれば、Houdiniは、その結果からそのピースの合致を排除します。

デフォルトのパターンマッチは、大文字小文字を区別します。 大文字小文字を区別せずにパターンマッチングを行なうには、ignore_caseをTrueに設定します。 この設定は、ノード名のマッチングの時にだけ大文字小文字の区別をしない事に注意してください。 グループ、ネットワークボックス、バンドル名のマッチングでは、大文字小文字の区別がされます。

このメソッドは、空っぽのパターンを指定した場合に空っぽのタプルを返します。

>>> obj = hou.node("/obj")
>>> obj.createNode("geo", "geo1")
<hou.ObjNode of type geo at /obj/geo1>
>>> obj.createNode("geo", "geo2")
<hou.ObjNode of type geo at /obj/geo2>
>>> obj.createNode("geo", "grid")
<hou.ObjNode of type geo at /obj/grid>
>>> obj.createNode("geo", "garbage")
<hou.ObjNode of type geo at /obj/garbage>
>>> obj.createNode("geo", "box")
<hou.ObjNode of type geo at /obj/box>

>>> def names(nodes):
... return [node.name() for node in nodes]

>>> names(obj.glob("g*"))
['geo1', 'geo2', 'grid', 'garbage']
>>> names(obj.glob("ge* ga*"))
['geo1', 'geo2', 'garbage']
>>> names(obj.glob("g* ^ga*"))
['geo1', 'geo2', 'grid']

hou.Node.recursiveGlobも参照してください。

hou.Node.globと同様に、パターンに合致した名前の子ノードのタプルを返します。 違うのは、その合致した子ノードからさらに再帰的にその子ノードすべてが追加されます。 さらに、その結果はノードタイプでフィルタリングすることができます。

Houdiniは、パターンに対して子ノードをマッチングしてから、その合致した子ノードのサブ子ノードを再帰的に追加し、 そしてフィルターを適用します。

パターンとフィルターの挙動は、Houdiniのノードバンドルの挙動と非常に似ています。 詳細は、hou.NodeBundleを参照してください。

パターンが無効な場合は、hou.OperationFailedを引き起こします。

node_type_nameタイプのノードをこのノードの子として新しく作成します。

指定したノード名が無効、且つ、force_valid_node_nameがFalseの場合は、hou.OperationFailedを引き起こします。 このノードに子を含めることができなかった場合は、hou.OperationFailedを引き起こします。 このノードがロックされたアセット内にあった場合は、hou.PermissionErrorを引き起こします。

>>> obj = hou.node("/obj")

# Houdiniにノードタイプ名に基づいた名前を選択させます。
>>> obj.createNode("geo")
<hou.ObjNode of type geo at /obj/geo1>

# Houdiniに固有の名前を選択させます。
>>> obj.createNode("geo")
<hou.ObjNode of type geo at /obj/geo2>

# ノードに特定の名前を指定します。
>>> obj.createNode("geo", "foo")
<hou.ObjNode of type geo at /obj/foo>

# Houdiniに私達が提案した名前から固有の名前を作成させます。
# また、ジオメトリオブジェクトに初期スクリプトを実行させなければ、中身が空っぽになります。
>>> obj.createNode("geo", "geo1", run_init_scripts=False)
<hou.ObjNode of type geo at /obj/geo3>
>>> obj.node("geo1").children()
(<hou.SopNode of type file at /obj/geo1/file1>,)
>>> obj.node("geo3").children()
()

このノードを削除します。

Nodeインスタンスを削除した後に、それに対してメソッドをコールすると、Houdiniはhou.ObjectWasDeletedを引き起こします。

ロックされたアセット内のノードを削除しようとした場合は、hou.OperationFailedを引き起こします。

disable_safety_checksをTrueにすると安全性チェックが無効になるので、ノードをクック中にこのメソッドがコールされるとHoudiniがクラッシュしてしまう場合があります。

指定したアイテムすべてのコピーをこのネットワーク内に作成します。これらのアイテムは、このネットワークの子である必要はありませんが、すべてのアイテムが同じ親ネットワーク内に含まれている必要があります。

channel_reference_originalsがTrueの場合、新しいノードすべてのパラメータが元のノードのチャンネル参照に設定されます。 コピーしたノードがサブネットワークであれば、トップレベルのノードのみが元のサブネットワークのチャンネル参照を構築します。 そのサブネットワーク内の子ノードは、元の子ノードの単純コピーになります。 relative_referencesパラメータは、チャンネル参照がソースノードの相対パスまたは絶対パスのどちらを使用するのかを制御します。

connect_outputs_to_multi_inputsがTrueで、コピーされるアイテムの出力が複数の入力ノードに接続されている場合(例えば、Merge)、そのコピーされた新しいアイテムの出力にもその複数の入力ノードが接続されます。 通常では、コピーされるノードには、そのコピーされるセットの外側のノードへの出力はありません。

新しいネットワークアイテムすべてのtupleを返します。

このノードに子を含めることができなかった場合はhou.OperationFailedを引き起こします。 このノードがロックされたアセット内にあった場合はhou.PermissionErrorを引き起こします。

指定したhou.NetworkMovableItemオブジェクトのタプル内のすべてのアイテムを削除します。 これは、それらのアイテムをループさせて個々にdestroy()をコールするよりも非常に効率的です。 また、これは他のオブジェクトも削除しないと削除することができないオブジェクトが存在する場合でも安全に処理します。

指定した1つ以上のアイテムがこのノードの子でなかった場合は、hou.OperationFailedを引き起こします。 このノードがロックされていたり、ロックされたデジタルアセット内にあった場合は、hou.PermissionErrorを引き起こします。

disable_safety_checksをTrueにすると安全性チェックが無効になるので、ノードをクック中にこのメソッドがコールされるとHoudiniがクラッシュしてしまう場合があります。

hou.Node.createDigitalAssetが成功できれば、Trueを返します。

ノードが、ネットワーク内で最後に選択したノードであるかどうかを示すブールを返します。

各ネットワーク(つまり、子を含んだノード)自体には、選択したノードのリストが記録されており、最後に選択したノードが特別な意味を持っています。 例えば、ピン留めしていないパラメータペインで表示されるノードがそれです。

Houdiniですべてのネットワーク内の選択したノードすべてのタプルを取得するには、hou.selectedNodes()も参照してください。 このリストの最後のノードもHoudiniでは特別な意味をもち、グローバルの現行ノードに相当します。

このノードを最後に選択したノードとして設定または未設定にします。

各ネットワーク(つまり、子を含んだノード)自体には、選択したノードのリストが記録されており、最後に選択したノードが特別な意味を持っています。 例えば、ピン留めしていないパラメータペインで表示されるノードがそれです。

onがTrueの場合、このノードが最後に選択したノードになります。 Falseで、このノードが最後に選択したノードだった場合、そのノードが非選択になり、最後から2番目に選択したノードが最後に選択したノードになります。

clear_all_selectedがtrueの場合、Houdiniは、その処理を実行する前に、このネットワーク内のすべてのノードを非選択にします。

hou.Node.setSelectedとhou.selectedNodes()も参照してください。

選択されたこのノードの子を含んだタプルを返します。 最後に選択したノードが特別な意味を持ち、そのノードはhou.Node.isCurrentを使って取得することもできることを覚えておいてください。

以下のサンプルは、/obj内の選択したオブジェクトすべての名前をプリントします:

for n in hou.node("/obj").selectedChildren():
    print n.name()

選択した子ノードの合計を調べるには、len(node.selectedChildren())を使用します。

選択されているこのノードの子を含んだタプルを返します。 selectedChildrenとは違い、このメソッドは、選択されたhou.NetworkBox, hou.SubnetIndirectInput, hou.StickyNote, hou.NetworkDotのオブジェクトも返します。

以下のサンプルは、/obj内の選択したアイテムすべての位置をプリントします:

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

選択されていて且つitem_typeで指定したタイプのノードの子の数を返します。

このノードに対してhou.NodeTypeオブジェクトを返します。

例えば、すべてのカメラノードインスタンスは、同じノードタイプを共有します。

このノードの子に相当するhou.NodeTypeCategoryを返します。 例えば、このノードがジオメトリオブジェクトの場合、その子はSOPです。 オブジェクトサブネットの場合、その子はオブジェクトです。

このノードの入力に接続されたノードのタプルを返します。 入力がhou.SubnetIndirectInputに接続されている場合、それに該当する親サブネットの入力に接続されたノードが返されます。 言い換えれば、間接入力の存在を隠すということです。つまり、その結果のノードは、すべてが呼び出し側のノードの兄弟であるとは限りません。

特定の入力が接続されていない(または、それが間接入力に接続されていても、それに該当するサブネットの親入力が接続されていない)場合は、タプルのその箇所にNone値が配置されます。

このノードの指定された入力に接続されているノードを返します。 入力がhou.SubnetIndirectInputに接続されている場合、それに該当する親サブネットの入力に接続されたノードが返されます。 言い換えれば、間接入力の存在を隠すということです。つまり、その結果のノードは、すべてが呼び出し側のノードの兄弟であるとは限りません。

その入力が接続されていない(または、それが間接入力に接続されていても、それに該当するサブネットの親入力が接続されていない)場合は、None値が返されます。

このノードの指定された入力に接続されているノードを返します。 入力がhou.SubnetIndirectInputに接続されている場合、それに該当する親サブネットの入力に接続されたノードが返されます。 言い換えれば、間接入力の存在を隠すということです。つまり、その結果のノードは、すべてが呼び出し側のノードの兄弟であるとは限りません。

さらに、その入力がSOPsの非プライマリ出力に接続されている場合、返されるノードは、サブネットそのものではなく、SOPネットワーク内のノードになります。 このメソッドを使用することで、このノードの入力に呼応する1番目の出力を持ったノードを取得したい時に、コードが複数出力を考慮しなくて済みます。

その入力が接続されていない(または、それが間接入力に接続されていても、それに該当するサブネットの親入力が接続されていない)場合は、None値が返されます。

このノードの出力に接続されたノードのタプルを返します。

このメソッドは、[connection.outputNode() for connection in self.outputConnections()]のショートカットです。

このノードのトップに繋がっている接続のhou.NodeConnectionオブジェクトのタプルを返します。 このタプルの長さは、このノードに入ってくる接続の数と同じになります。 このノードに何も繋がっていなかった場合は、空っぽのタプルが返されます。

接続されたノード自体のリストを取得するには、hou.Node.inputsを使用します。 (接続の有無に関係なく)接続可能なコネクタのリストすべてを取得するには、hou.Node.inputConnectorsを使用します。

>>> cookie = hou.node("/obj").createNode("geo").createNode("cookie")
>>> cookie.setInput(1, cookie.parent().createNode("box"))
>>> cookie.inputConnections()
(<hou.NodeConnection from grid1 output 0 to cookie input 1>,)
>>> cookie.inputConnectors()
((), (<hou.NodeConnection from grid1 output 0 to cookie input 1>,))

hou.Node.inputConnectorsも参照してください。

このノードの下から繋がっている接続のNodeConnectionオブジェクトのタプルを返します。 このノードの出力に何も繋がっていなかった場合は、空っぽのタプルが返されます。

接続されたノード自体のリストを取得するには、hou.Node.outputsを使用します。

このメソッドは、reduce(lambda a, b: a+b, self.outputConnectors(), ())のショートカットです。 ほとんどのノードは出力コネクタを1つしか持たないので、このメソッドは通常では、self.outputConnectors()[0]と等価です。

>>> box = hou.node("/obj").createNode("geo").createNode("box")
>>> box.parent().createNode("xform").setFirstInput(box)
>>> box.parent().createNode("subdivide").setFirstInput(box)
>>> box.outputConnections()
(<hou.NodeConnection from box1 output 0 to xform1 output 0>, <hou.NodeConnection from box1 output 0 to subdivide1 input 0>)

hou.node.outputConnectorsも参照してください。

hou.NodeConnectionオブジェクトのタプルのタプルを返します。 その結果のタプルの長さは、このノードに接続可能な入力の最大数と同じです。 なにかそのコネクタに接続されていれば、各サブタプルは必ず1個のノード接続を含みます。 何も接続されていなければ、それは空っぽのタプルです。

hou.NodeConnectionとhou.Node.inputConnectionsも参照してください。

hou.NodeConnectionオブジェクトのタプルのタプルを返します。 その結果のタプルの長さは、このノードの出力コネクタの数と同じです。 各サブタプルは、そのコネクタから出ているコネクションすべてを含み、そのコネクタに何も接続されていなければ、それは空っぽのタプルです。

>>> split = hou.node("/obj").createNode("dopnet").createNode("split")
>>> split.parent().createNode("rbdsolver").setFirstInput(split)
>>> split.parent().createNode("gravity").setFirstInput(split, 1)
>>> split.parent().createNode("merge").setFirstInput(split, 1)
>>> split.outputConnectors()
((<hou.NodeConnection from split1 output 0 to rbdsolver1 input 0>,), (<hou.NodeConnection from split1 output 1 to gravity2 input 0>, <hou.NodeConnection from split1 output 1 to merge1 input 0>), (), ())

hou.NodeConnectionとhou.Node.outputConnectionsも参照してください。

サブネットのhou.SubnetIndirectInputオブジェクトを返します。

このノードがサブネットワークでない場合は、hou.InvalidNodeTypeを引き起こします。

サブネットワークの子出力ノードを返します。

SOPsなどの特定のネットワークには、通常のディスプレイノードまたはレンダーノードをオーバーライドして複数の出力を可能にするための特別なOutputノードがあります。 何かしらのOutputノードが存在すれば、これは、それらのノードのリストを返します。 何もOutputノードが存在しなければ、クックのターゲットがディスプレイノードなのか出力ドライバなのかに応じて、ディスプレイノードまたはレンダーノードのどちらかが返されます。 サブネットに何も子がなければ、空っぽのリストが返されます。

このノードの入力ノードすべてのタプルを返します。include_ref_inputsがFalseの場合、参照入力を辿りません。 follow_subnetsがTrueの場合、サブネットワークノードを単一ノードとして扱わず、そのディスプレイノードから始まる子ノードも辿ります。 only_used_inputsがTrueの場合、最後のクックに関係したノードのみを辿ります。

inputs()メソッドも参照してください。

指定した名前のノード入力のインデックスを取得します。

入力名を使用するノードカテゴリに関しては、指定した名前の入力のインデックスを返します。 VOPノードに関しては、その名前が、それに該当する入力を持ったノードパラメータ名にもなります。

指定した名前のノード出力のインデックスを取得します。

入力名を使用するノードカテゴリに関しては、指定した名前の出力のインデックスを返します。

item_to_become_inputがNoneでない場合、他のノードの出力コネクタをこのノードの入力コネクタに接続します。 それ以外の場合、入力コネクタに接続されたすべてのノードの接続を解除します。

output_indexが無効の場合は、hou.InvalidInputを引き起こします。 item_to_become_inputがこのノードと同じネットワーク内にない場合は、hou.OperationFailedを引き起こします。 ノードがロックされたアセット内にある場合は、hou.PermissionErrorを引き起こします。

input_nameで指定されたこのノード上の入力を、output_nameまたはoutput_indexで指定したitem_to_become_input上の出力に接続します。

self.setInput(0, item_to_become_input)のショートカット。 詳細は、hou.Node.setInputを参照してください。

他のノードからの出力コネクタを、このノードの1番目の非接続入力コネクタまたは複数入力コネクタに接続します。 ノードにOrdered InputsとUnordered Inputs(複数入力コネクタ)がある場合、unordered_onlyパラメータを使用することで強制的に入力を、Ordered Inputではなく、Unordered Inputs(複数入力コネクタ)に接続することができます。

このメソッドは、ほぼ以下と等価です:

for input_index, connectors in enumerate(self.inputConnectors()):
    if len(connectors) == 0:
        self.setInput(input_index, item_to_become_input, output_index)
    raise hou.InvalidInput("All inputs are connected")

すべての入力が接続されていれば、hou.InvalidInputを引き起こします。 詳細は、hou.Node.setInputを参照してください。

入力ワイヤーを挿入します。つまり、input_indexの後の入力コネクタ毎に、その入力コネクタの内容を次のコネクタにシフトさせて、 hou.Node.setInputをコールします。パラメータの意味については、hou.Node.setInputを参照してください。

いくつかのノードでは、特有の意味を持つ専用の入力をいくつか持っており、その後に任意の数の追加入力を持っています。 この追加入力では隙間は許可されていません(これらの入力のことをUnordered Inputsと呼びます)。 これは、Multiple Solver DOPなどのDOPノードがそうです。 この関数は、そのUnordered Inputsの前の専用(またはOrdered)の入力の数を返します。 このノードのhou.Node.typeオブジェクトに対してhou.NodeType.hasUnorderedInputs関数がTrueを返す場合は、この関数はゼロ以外の値を返すだけです。

新しくノードを作成し、そのノードをこのノードの入力の1つに接続します。その新しいノードを返します。

createOutputNodeメソッドも参照してください。

新しくノードを作成し、その1番目の入力のこのノードの(1番目の)出力に接続します。その新しいノードを返します。

パラメータの詳細は、createNodeメソッドを参照してください。

createInputNodeメソッドも参照してください。

このノードに対して入力名すべてのタプルを返します。不可視の入力コネクタの名前も含まれます。

このノードの入力ラベルすべてのタプルを返します。非表示の入力コネクタのラベルも含まれます。

このノードに対して出力名すべてのタプルを返します。

このノードの出力ラベルすべてのタプルを返します。

指定した入力インデックスに関連のある文字列キー/値のペアの辞書を返します。 これらの文字列の目的は、あるノードタイプを他のノードタイプに変換することです。

このメソッドは、そのノードタイプがこの機能を利用していなければ例外を引き起こします。 そのノードタイプが、編集可能な入力データに対応しているかどうか判断するには、hasEditableInputDataを使用します。

指定した入力インデックスとキーに関連のある文字列を返します。 この文字列の目的は、あるノードタイプを他のノードタイプに可変させることです。

このメソッドは、そのノードタイプがこの機能を使用していない場合に例外を引き起こします。 hasEditableInputDataを使用することで、ノードタイプが編集可能入力データに対応しているかどうかを判断することができます。

指定した入力インデックスとキーに関連のある文字列を設定します。 この文字列の目的は、あるノードタイプを他のノードタイプに可変させることです。

このメソッドは、そのノードタイプがこの機能を使用していない場合に例外を引き起こします。 hasEditableInputDataを使用することで、ノードタイプが編集可能入力データに対応しているかどうかを判断することができます。

ノードがサブネットワークならTrue、そうでないならFalseを返します。

このノードの子ノードのシーケンスを指定すると、それらの子ノードをサブネットワークに折りたたみます。 つまり、このノードのネットワーク内にサブネットが作成され、このネットワークの指定した子をそのサブネット内に移動させます。

child_nodes内のノードがこのネットワークの子でない場合やchild_nodesが空っぽのシーケンスの場合は、hou.OperationFailedを引き起こします。

このサンプルの関数は、単一ノードを受け取り、それをサブネットに置換し、そのノードをサブネットに移動させます..

def collapseSingleNodeIntoSubnet(node, subnet_name=None):
    node.parent().collapseIntoSubnet((node,), subnet_name=None)

このサブネットノードの子を移動させて、このノードの兄弟にし、このノードを削除します。このメソッドは、collapseIntoSubnet()と逆のメソッドです。 抽出されたすべてのアイテムを含んだタプルを返します。

このノードがサブネットワークでない場合は、hou.InvalidNodeTypeを引き起こします。

ノードのコメント文字列を返します。

このノードに関連したコメントを設定します。 appendComment()も参照してください。

指定したテキストを、このノードに関連したコメントに追加します。

ネットワークエディタ内でノードが説明的名前を表示するかどうかを示すブールを返します。

ネットワークディター内でこのノードが説明的名前を表示するかどうか設定します。

このノードから、異なるタイプの最初の親を返します。 単純なネットワークでは、これはparent()と同じですが、その親が同じノードタイプの場合(例えば、どちらもSOPだった場合)、異なるタイプが見つかるまで処理が繰り返されます。 これは、コンテナノードを検索するのに役立ち、例えば、入れ子状になったSOPネットワークについて気にすることなく、SOPが格納されているObjectを検索することができます。 とはいえ、SOPの親が必ずしもObjectであるとは限らないことに注意してください!

ノードをその入力や出力の近くで上手く間隔を空けて動かし、そのノードの新しい位置を返します。

このノードのすべてまたは一部の子ノードをネットワークエディタ内で自動的に配置します。

ノードがネットワークエディタ内で非表示かどうか返します。 Houdiniは、“exposed”という用語を使用して、非表示でないノードを参照することもできます。

可視ノードを不可視ノードに接続した場合、ネットワークエディタは、その可視ノードから不可視ノードまでのワイヤーを破線で表示します。

hou.Node.hideも参照してください。

ネットワークエディタ内にノードを非表示または表示します。不可視ノードに関する詳細は、hou.Node.isHiddenを参照してください。

このノードの最後のクックからのエラーのテキストを返します。エラーがなければ空っぽのタプルが返されます。

このノードの最後のクックからの警告のテキストを返します。警告がなければ空っぽのタプルが返されます。

このノードの最後のクックからメッセージのテキストを返します。メッセージがなければ空っぽのタプルが返されます。

このノード内のネットワークボックスのリストを返します。

このノード内のすべてのネットワークボックスを巡回するジェネレータを返します。

このノード内の指定した名前のネットワークボックスを返します。または指定した名前のネットワークボックスが存在しなかった場合はNoneが返されます。

このノード内のパターンに合致した名前のネットワークボックスのリストを返します。

このネットワーク内にネットワークボックスを作成します。このノードがネットワークでない場合は、hou.OperationFailedを引き起こします。

nameを指定しなかった場合は、Houdiniは、そのネットワークボックスにデフォルトの名前を付けます。

ネットワークボックス名はネットワークエディタペイン内に表示されません。 その代わり、hou.NetworkBox.setCommentメソッドによって“コメント”を指定することができます。 このコメントは、ネットワークボックスのタイトルバーに表示されます。

ネットワークボックスをコピーし、そのコピーを返します。

new_nameを指定した場合、そのネットワークボックスがnew_nameという名前の新しいネットワークボックスにコピーされます(既にその名前のネットワークボックスが存在すれば別の名前が生成されます)。

channel_reference_originalがTrueの場合、そのコピーで作成されたすべてのオペレータは、元のオペレータを参照するように設定されたアニメーション可能なパラメータを持ちます。

このノードがネットワークでない場合や、ノードの子タイプがネットワークボックスのノードタイプに合致しなかった場合は、hou.OperationFailedを引き起こします。

このノード内のステッキーノートのリストを返します。

このノード内のすべてのステッキーノートを巡回するジェネレータを返します。

このノード内の指定した名前のステッキーノートを返します。指定した名前のステッキーノートが存在しなかった場合は、Noneを返します。

このノード内のパターンに合致した名前のステッキーノートのリストを返します。

このネットワーク内にステッキーノートを作成します。このノードがネットワークでない場合は、hou.OperationFailedを引き起こします。

nameを指定しなかった場合、Houdiniは、そのノートをデフォルトの名前にします。

ステッキーノートをコピーして、そのコピーを返します。

new_nameを指定した場合、そのステッキーノートがnew_nameという名前の新しいステッキーノートにコピーされます(既にその名前のステッキーノートが存在すれば別の名前が生成されます)。

このノードがネットワークでない場合や、ノードの子タイプがステッキーノートのノードタイプに合致しなかった場合は、hou.OperationFailedを引き起こします。

このネットワーク内にネットワークドットを作成します。このノードがネットワークでない場合は、hou.OperationFailedを引き起こします。

このネットワーク内のすべてのドットのタプルを返します。

子アイテムのシーケンス(ノード、ネットワークボックス、ステッキーノートなど)を指定すると、このネットワークまたは他のネットワーク内にそれらをペーストできるように、 それらのアイテムがクリップボードに保存されます。

これらのノードまたはネットワークボックスがこのノードの子でない場合は、hou.OperationFailedを引き起こします。 このノードの内容を読み込む権限がない場合は、hou.PermissionErrorを引き起こします。

hou.Node.copyItemsToClipboardを使って保存されたファイルの内容を、このノードの内容に読み込みます。 positionパラメータを2つのfloat値のタプル(またはhou.Vector2のような同等のもの)として指定すると、ペーストしたアイテムが、その位置を中心に配置されるように移動されます。

このノードがネットワークでない場合やクリップボードからアイテムを読み込む時にエラーが発生した場合は、hou.OperationFailedを引き起こします。 このノードがロックされたデジタルアセットインスタンスであれば、hou.PermissionErrorを引き起こします。

Nodeオブジェクト間に==を実装します。

例えば、hou.root() == hou.node(“/”)はTrueを返します。

同じHoudiniノードに対して複数のPython Nodeオブジェクトが存在できます。 hou.node()の2つの同一コールは、異なるPython Nodeオブジェクトを返し、それぞれ同じHoudiniノードを意味します。 ==(別名__eq__)を使用してそれらのノードを比較すると、Trueを返し、 is(オブジェクト同一性テスト)を使用してそれらのノードを比較するとFalseを返します。

Nodeオブジェクト間に!=を実装します。__eq__()を参照してください。

このノードインスタンス上に名前付き文字列を追加/設定します。

この名前/値のペアがHIPファイルに格納され、それがopscriptとhou.Node.asCodeからの出力に含まれます。

以下のサンプルは、ユーザ定義データを設定、アクセス、削除する方法について説明しています:

>>> n = hou.node("/obj").createNode("geo")
>>> n.setUserData("my data", "my data value")
>>> n.userData("my data")
'my data value'
>>> n.userDataDict()
{'my data': 'my data value'}
>>> n.destroyUserData("my data")
>>> n.userDataDict()
{}
>>> print n.userData("my data")
None

詳細とサンプルは、ノード毎のユーザ定義データを参照してください。

このノードに対するユーザ定義の名前/文字列のペアすべてを含んだ辞書を返します。

詳細は、hou.Node.setUserDataを参照してください。

この名前のユーザ定義データを返します。この名前のデータが存在しなかった場合は、Noneが返されます。

詳細は、hou.Node.setUserDataを参照してください。

このメソッドは以下のように実装されています:

def userData(self, name):
    return self.userDataDict().get(name)

この名前のユーザ定義データを削除します。

詳細は、hou.Node.setUserDataを参照してください。

この名前のユーザデータが存在しない且つmust_existがTrueの場合は、hou.OperationFailedを引き起こします。

すべてのユーザ定義データを削除します。

詳細は、hou.Node.setUserDataを参照してください。

指定したフラグが読み込み可ならTrue、そうでないならFalseを返します。

flagは、hou.nodeFlag値でなければなりません。

指定したフラグが書き込み可ならTrueを、そうでないならFalseを返します。

flagは、hou.nodeFlag値でなければなりません。

指定したフラグの値を返します。

flagは、hou.nodeFlag値でなければなりません。

bool、valueに基づいて、指定したフラグの値を設定します。

flagは、hou.nodeFlag値でなければなりません。

Creates a node for visualizing the data from a particular output of this node. If a visualizer node already exists in the current network, it is moved and connected to the specified output_index. This method is only implemented for SOP and VOP nodes. Other node types do nothing when this method is called.

Copy this node to a new place in the node hierarchy. The new node is placed inside the given destination node. This method returns the new node.

Raises hou.OperationFailed if the destination node cannot contain the new node. Raises hou.PermissionError if the destination node is inside a locked asset.

Return the parameter at the given path, or None if the parameter doesn’t exist.

Return a tuple of parameters matching the pattern.

The pattern may contain multiple pieces, separated by spaces. An asterisk (*) in a pattern piece will match any character. By default, Houdini will add the parameters from each pattern piece to those already matched. However, if the pattern piece begins with a caret (^), Houdini will remove the matches for that piece from the result.

By default the pattern match is case-sensitive. Set ignore_case to True for case-insensitive pattern matching. Note that case insensitivity only applies when matching node and parameter names. It does not apply when matching group, network box or bundle names.

By default, only parameters with names matching the pattern are returned. Set search_label to True to also return parameters with labels matching the pattern.

If single_pattern is True, the pattern will be treated as one pattern even if there are spaces in the pattern.

This method returns an empty tuple if you pass in an empty pattern.

Evaluates the specified parameter and returns the result.

Return a list of the parameters on this node.

Return a list of the parameters that reference this node.

Recursively return a sequence of all the parameters on all of the nodes contained in this node including this node.

This method is a generator and does not return a tuple.

Here is an example of printing out the parameter paths for all nodes under /obj:

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

Given a dictionary mapping parm names to values, set each of the corresponding parms on this node to the given value in the dictionary.

The following example sets the tx and sy parameters at once:

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

The names are tried against both parameters and parmameter tuples, so the base name can also be used:

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

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setParmExpressions method.

Given a dictionary mapping parm names to values, sets the pending value of each of the corresponding parms on this node. Supports both parameters and parameter tuples.

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setPending method.

Given a dictionary mapping parm names to expression strings, set each of the corresponding parms on this node to the given expression string in the dictionary.

See hou.Parm.setExpression for a description of the language and replace_expressions parms.

The following example expressions set the tx and sy parameters at once:

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParmExpressions({"tx": 'ch("ty")', "sy": "sin($F)"})

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setParms method.

Return the parm tuple at the given path, or None if it doesn’t exist.

This method is similar to parm(), except it returns a hou.ParmTuple instead of a hou.Parm.

Evaluates the specified parameter tuple and returns the result.

Return a list of all parameter tuples on this node.

This method is similar to parms(), except it returns a list of hou.ParmTuple instead of hou.Parm.

Return a list of parameters in a folder on this node. Returns all parameters in the folder and its subfolders (if any).

Raises hou.OperationFailed if the folder specified by folder_names does not exist.

For example, suppose a node had a Render folder that contained a Shading subfolder. Then this line of code would return the parameters in the Render folder:

# Note the trailing comma after "Render" to tell Python that "Render" is
# contained in a tuple/sequence as opposed to just a single string with
# parentheses around it.
>>> node.parmsInFolder(("Render", ))

And this line of code would return the parameters in the Shading subfolder.

>>> node.parmsInFolder(("Render", "Shading"))

See also hou.Parm.containingFolders and hou.Parm.containingFolderSetParmTuples

Note that this method does not work for multi-parameters, which behave similar to folder parameters. To get a list of parameters in a multi-parameter, call hou.Parm.multiParmInstances.

Return a list of the parameter tuples in a folder on this node. This method is similar to parmsInFolder(), except it returns a list of hou.ParmTuple instead of hou.Parm. See parmsInFolder() above for information about the arguments.

See also hou.Parm.containingFolders and hou.Parm.containingFolderSetParmTuples

Return the node’s default expression language.

When you enter an expression in a parameter that does not already contain an expression, the node’s expression language is used to determine how that expression should be evaluated. You can change a node’s expression language in the parameter dialog in the GUI.

Changing the node’s expression language will not change the language in parameters already containing expressions (i.e. parameters with keyframes).

Note that if a parameter already contains an expression and you change that expression in the GUI, the expression language will not change, regardless of the value of the node’s expression language. To change the language of an existing expression in a parameter from Python, use hou.Parm.setExpression, as in parm.setExpression(parm.expression(), language).

Set the node’s default expression language. See expressionLanguage() for more information.

Return a dictionary of parameter aliases on the node’s parameters. The keys in the dictionary are the parameters that have aliases and the values are the alias names.

Removes all alias names from parameters on the node.

Return a list of the spare (user-defined) parameters on this node.

Removes all spare parameters from this node.

Return the group of parm templates corresponding to the current parameter layout for this node.

You can edit the parameter layout for this node (add or remove spare parameters, reorder or hide built-in parameters, etc.) by getting the current parameter group, modifying it, and calling hou.Node.setParmTemplateGroup with it.

The following example creates a geometry object, adds a My Parms folder to it, and adds a My Parm float parameter to it in that folder. The parameters are added only to the geometry object created; other geometry objects are unaffected.

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

See hou.ParmTemplateGroup and the setParmTemplateGroup method for more information and examples.

Change the spare parameters for this node.

Note that each node type has a set of parameters which must exist and must be of certain types. If your parm template group does not contain the required parameters for the node type the will be added at the bottom and will be made invisible. Similarly, if your parm template group attempts to modify the type, range, label, or other property of a required parameter, all changes to that parameter other than visibility settings will be ignored.

This method is preferred over the other parameter-related methods in this class (addSpareParmTuple, removeSpareParmTuple, replaceSpareParmTuple, addSpareParmFolder, removeSpareParmFolder) because it lets you more easily make manipulate parameters.

See hou.HDADefinition.setParmTemplateGroup to change the parameter interface of a digital asset.

Add a spare parameter tuple to the end of the parameters on the node. If in_folder is not an empty sequence, this method adds the parameters to the end of the parameters in a particular folder.

Note that this method can add a single folder by passing a hou.FolderParmTemplate for parm_template.

See also the removeSpareParmTuple() and addSpareParmFolder() methods.

This method is deprecated in favor of setParmTemplateGroup.

Removes the specified spare parameter tuple.

See also addSpareParmTuple().

This method is deprecated in favor of setParmTemplateGroup.

Adds a control parameter folder as the front-most folder at the top-level. This is used to increase visibility of customized control parameters. If a folder of the same name already exists, no new folder will be created. If folder_name is None, it will be set as 'Controls'. If parm_name is None, it will be set as 'folder'.

If there are no current folders present, the existing parameters will be grouped together and stored into a new folder named 'Parameters' and placed after the new control parameter folder.

Adds a folder to the spare parameters.

Note that all the folders in a set correspond to one parameter. If this is the first folder to go in the set, parm_name will be used as the parameter name. Otherwise, parm_name will be ignored and the parameter name of the first folder in the set is used.

If this is the first folder in the set and parm_name is None, it will default to 'sparefolder0'. If parm_name is already in use, a unique name will be automatically generated.

If create_missing_folders is True, this method will create the folders in in_folder that don’t exist. So, this method can be used to add spare folders and a spare parameter at the same time.

Note that you can add folders by passing a hou.FolderParmTemplate to the addSpareParmTuple method, so this method is deprecated. Note also that addSpareParmTuple is deprecated in favor of setParmTemplateGroup.

See also the removeSpareParmFolder and addSpareParmTuple methods.

This method is deprecated in favor of setParmTemplateGroup.

Removes an empty folder from the spare parameters.

folder is a sequence of folder names. So, to remove the Output folder, use ("Output",) instead of "Output".

See also addSpareParmFolder(), hou.ParmTemplateGroup.remove, and hou.ParmTemplateGroup.findFolder.

Replace an existing spare parameter tuple with a new one. The old parameter tuple is removed and the new one is added in its place.

The new parameter tuple may or may not have the same name as the old one. By providing a parameter tuple with the same name, you can modify an existing spare parameter tuple.

Note that you cannot replace non-spare parameter tuples. However, you can change the visibility of non-spare parameters using hou.ParmTuple.hide.

To change a parameter for all instances of digital asset, use hou.HDADefinition.replaceParmTuple.

This method is deprecated in favor of setParmTemplateGroup.

Return a list of local variables that can be referenced in parameter expressions on this node using the $ prefix.

Return a list of local variables that can be referenced in parameter expressions on this node using the @ prefix. This includes local variables defined in this node as attributes and any context options that were available to this node the last time it was cooked.

Load animation for the parameters in this node from the clip file specified by file_name. See hou.Node.saveParmClip for the list of supported clip file formats.

Any tracks in the clip file that do not match the name of the parameters of this node will be ignored.

If sample_rate is set to a non-zero, non-negative value, the specified value will be used when loading the animation. For example, if the current frame rate is 24 (hou.fps()) and sample_rate is set to 12, the animation will be loaded with a keyframe at every second frame since sample_rate is half of the current frame rate.

start specifies the frame the loaded animation should start from. By default the animation starts at the frame specified in the clip file.

This function will raise a hou.OperationFailed exception if there is an error reading animation data from the file.

Load animation for the parameters in this node from the given clip data. This method is similar to hou.Node.loadParmClip, except that it loads animation from the given clip data instead of a clip file.

The clip data must be a bytes object in Python 3 and a str object in Python 2. See HOM binary data for more information.

sample_rate and start behave the same as in hou.Node.loadParmClip.

binary and blosc_compressed specify the type of input data.

If binary is True, the given data is binary clip data otherwise it is plain text (ASCII) clip data.

If blosc_compressed is True, the given data is blosc compressed binary data. This cannot be used for plain text (ASCII) clip data.

Raises a hou.OperationFailed exception if the given data is invalid.

Raises a hou.InvalidInput exception if binary = False and blosc_compressed = True.

Return a tuple of nodes that are referenced by this node, either through parameter expressions, referring to the node by name, or using expressions which rely on the data generated by another node. These reflect all the other ways (besides connecting to an input) in which one node may affect another.

Note that the result can differ depending last cook of the nodes. It’s recommended that you first call cook() on the node first.

Return a tuple of nodes that are reference this node, either through parameter expressions, referring to the node by name, or using expressions which rely on the data generated by this node. These reflect all the other ways (besides connecting to an input) in which one node may affect another.

Note that the result can differ depending last cook of the nodes.

Returns a sequence of tuples representing references to external files (such as textures, geometry files, and asset libraries) from this node. Applies to all sub children of this node if recurse is set to true.

See also hou.fileReferences()

Create a digital asset from this node. You would typically call this method on subnet nodes.

Create a compiled digital asset from this node. You would typically call this method on VOP network nodes, such as Material Shader Builder SHOP, Surface Shader Builder SHOP, or VEX Surface SHOP Type VOPNET. The digital asset does not have contents section, which means it does not have VOP network inside, but instead relies on the saved VEX code sections to provide the shader code.

After the creation of a compiled HDA, if its VEX code section is ever changed manually, the corresponding vex object code section can be recompiled using hou.HDADefinition.compileCodeSection.

Changes the node to a new type (within the same context). new_node_type is the internal string name of the type you want to change to.

Keep_name, keep_parms, and keep_network_contents indicate that the node should keep the same name, parameter values, and contents, respectively, after its type has changed. force_change_on_node_type_match indicates whether to perform the change even when is already of the specified type.

Unlocks a digital asset so its contents can be edited.

To use this function, you must have permission to modify the HDA.

If this node is an unlocked digital asset, change its contents to match what is stored in the definition and lock it. The parameter values are unchanged.

If this node is locked or is not a digital asset, this method has no effect.

See also hou.Node.matchesCurrentDefinition and hou.Node.isLocked.

Return whether the contents of the node are locked to its type definition.

If this node is a digital assets whose contents are currently in a delay-sync condition, the contents will be synced. If it is already synced or not a syncable asset, no effect occurs.

If this node is a digital assets whose contents are currently in a delay-sync condition, returns true. Otherwise returns false, which will include nodes that are not syncable.

If this node is an instance of a digital asset, return whether or not it is locked. Otherwise, return False.

To differentiate between unlocked digital assets and nodes that are not instances of digital assets, check if the node’s type has a definition:

def isUnlockedAsset(node):
    return not node.isLockedHDA() and node.type().definition() is not None

See hou.HDADefinition.updateFromNode for an example of how to save and lock all unlocked digital asset instances.

Return whether this node is inside a locked digital asset. If this node is not inside a locked HDA, the node may deviate from the HDA definition.

Return False if the node is contained inside a locked HDA node and, is not marked as editable within that locked HDA, and True otherwise. In particular this function will return True for a node that is not inside a locked HDA (or not inside an HDA at all).

Returns True if the node contains materials.

This method is a shortcut for self.type().hdaModule() to reduce the length of expressions in Python parameters and button callbacks. See hou.NodeType.hdaModule for more information.

See also the hm method and hou.phm().

This method is a shortcut for self.hdaModule().

See also hou.phm().

This method creates an instance of hou.HDAViewerStateModule associated to the underlying Node.

See also hou.NodeType.hdaViewerStateModule.

This method creates an instance of hou.HDAViewerHandleModule associated to the underlying Node.

See also hou.NodeType.hdaViewerHandleModule.

Synchronize the node from the specified version to the current version of its HDA definition. See also hou.HDADefinition.version.

Return an integer to indicate which output of the node should be used for display purposes.

Sets which output should be used for display purposes on this node.

Return the date and time when the node was created.

Return the date and time when the node was last modified.

This returns the name of the viewport tool that was used to be created. This name is not set by default and is usually the empty string.

This sets the name of the tool that created this node. If you call this with a name that differs from the node type name, you should also call setBuiltExplicitly(False).

Return whether this node was built explicitly (defaults to True). Most nodes are built explicitly, but some are implicitly created by Houdini. For example, if you select geometry from multiple SOPs and then perform an operation, Houdini will put down an implicit merge SOP before performing that operation. When reselecting geometry in SOPs, Houdini will automatically delete any SOPs that were created implicitly.

Set whether this node was built explicitly (default value is True). If set to False, this node will not show up in various menus and in the Network View pane’s list mode. This flag is typically used for intermediate utility nodes that one is unlikely to want to change its parameters.

Return whether the node is time dependent. A time dependent node is re-evaluated every time the frame changes.

Asks or forces the node to re-cook.

Asks if the node needs to re-cook.

Returns the number of times this node has cooked in the current session.

Update the UI states, such as hidden and disabled, for each parameter in the node.

UI states can be expressed as conditionals (i.e. Disable When) which require evaluation. Typically in graphical Houdini the Parameter Pane performs the evaluation when the node is selected in order to determine how the node parameters should look in the pane. However in non-graphical Houdini or if the Parameter Pane has not yet loaded the node, then the evaluation does not occur and the UI states remain at their defaults causing methods such as hou.Parm.isDisabled and hou.Parm.isHidden to return incorrect values. In these cases, it is recommended that hou.Node.updateParmStates is called.

Returns a tree structure containing information about the node and its most recently cooked data. The contents of the tree vary widely depending on the node type, and the nature of its cooked data. This tree of data is used to generate the node information window contents.

Return a list of the nodes, including nodes in subnets, that were used in the last cook for the network this node belongs to.

Return True if the node can generate compiled cook code and False otherwise.

If check_parent is true, the parents in the ancestor hierarchy are tested if any of them can generate code.

If the node cannot generate cook code explicitly, it might still be able to provide such code implicitly, if it can be wrapped in auto-shader. E.g., a building-block VOPs such as Anti-Aliased Noise don’t generate a complete cook code; they provide code fragment that contributes to the full cook function. But sometimes they can be automatically wrapped in such a function, which which will act as cook code. If check_auto_shader is true, the node will be tested if it provides implicit cook code.

Return the node itself or a network node that contains this node and can generate compiled cook code. For example, the generator node for a VOP node could be the SHOP node or SOP node that contains it for example.

Return None if this node cannot generate code and is not contained in a code generating node either either.

Return the language of the generated cook code (i.e. VEX, RSL).

Raises hou.OperationFailed if this node cannot generate compiled code.

Return True if this node can generate compiled cook code for multiple contexts (i.e. surface context, displacement context, etc.) and False otherwise.

Raises hou.OperationFailed if this node cannot generate compiled code.

Saves compiled VEX code to a disk file (for nodes that support this). See hou.Node.saveCookCodeToFile for a description of the arguments.

Saves VEX/RSL source code to a disk file (on nodes that support this).

node("/shop/vopmaterial1").saveCookCodeToFile("myfile.vfl", context_name="surface")

Add a node group to the node and return the new group.

If a group of the given name already exists then this function simply returns the existing group without adding a new one. If the name of the group is None or an empty string, then a unique default name is automatically chosen.

This function can only be called on nodes that are networks. If it is called on a node that is not a network, then it raises hou.OperationFailed.

To remove a node group, use hou.NodeGroup.destroy.

Return a node group contained by the node with the given name, or None if the group does not exist.

Return the list of node groups in this node.

Runs the initialization script associated with this node’s type.

Return the script that will run when this node is deleted.

Sets the script that will run when this node is deleted.

Return a node path representing the location for storing clips. This location may or may not exist. To find or create such a network, use hou.Node.findOrCreateMotionEffectsNetwork.

Return a CHOP network node suitable for storing Motion Effects. By default, if the node doesn’t exist, it will be created.

See also hou.Parm.storeAsClip and hou.Node.motionEffectsNetworkPath.

Return a copy stamping floating point or string value. This node must be a downstream stamping operator, such as a Copy SOP, Cache SOP, LSystem SOP, or Copy CHOP.

You might put the following expression in a Python parameter:

node("../copy1").stampValue("sides", 5)

Given a sequence of child items (nodes, network boxes, sticky notes, etc), save a file containing those items. You can load this file using hou.Node.loadItemsFromFile.

Raises hou.OperationFailed if any of the nodes or network boxes are node children of this node, or if the file could not be written to. Raises hou.PermissionError if you do not have permission to read the contents of this node.

Combines separate lists of nods and network boxes into a single sequence, and calls hou.Node.saveItemsToFile. This method is provided for backward compatibility. New code should call saveItemsToFile directly.

Load the contents of a file (saved with hou.Node.saveItemsToFile) into the contents of this node.

Raises hou.OperationFailed if the file does not exist or it is not the correct type of file. Raises hou.PermissionError if this node is a locked instance of a digital asset. Raises hou.LoadWarning if the load succeeds but with warnings and ignore_load_warnings is False.

Calls hou.Node.loadItemsFromFile. Provided for backward compatibility. New code should call loadItemsFromFile directly.

Prints the Python code necessary to recreate a node.

Registers a Python callback that Houdini will call whenever a particular action, or event, occurs on this particular node instance.

Callbacks only persist for the current session. For example, they are not saved to the .hip file. If you want persistent callbacks in every session, you can add them in code in 456.py (runs when the user opens a .hip file). See where to add Python scripting for more information.

def event_callback(event_type, **kwargs):
    ...

Raises hou.OperationFailed if the event_types list argument is empty.

The following example shows to set up a function that’s called whenever a certain node’s name changes:

def name_changed(node, event_type, **kwargs):
    print("The geometry object is now named", node.name())

hou.node("/obj/geo1").addEventCallback((hou.nodeEventType.NameChanged, ), name_changed)

See also hou.Node.removeEventCallback and hou.Node.removeAllEventCallbacks.

Given a callback that was previously added on this node and a sequence of hou.nodeEventType enumerated values, remove those event types from the set of event types for the callback. If the remaining set of event types is empty, the callback will be removed entirely from this node.

Raises hou.OperationFailed if the callback had not been previously added.

See hou.Node.addEventCallback for more information.

Registers a Python callback that Houdini will call whenever a parameter in parm_names changes on this particular node instance. This is can be faster than filtering the parameter names in a callback installed with hou.Node.addEventCallback if you only care about some parameters or if the node has many parameters.

See hou.Node.addEventCallback for more information.

Remove all event callbacks for all event types from this node.

See hou.Node.addEventCallback for more information.

Return a tuple of all the Python callbacks that have been registered with this node with calls to hou.Node.addEventCallback.

Add/set a named value on this node instance. Unlike setUserData, values set using this method are not saved with the hip file.

name: A unique name (key) for the user-defined data. By using different names, you can attach multiple pieces of user-defined data to a node. value: The value to store. Unlike setUserData, this value may be any Python object.

This name/value pair is not stored with the hip file. It is useful for nodes implemented in Python that want to save temporary values between cooks, to avoid recomputing them on subsequent cooks.

The following example illustrates how to set, access, and delete cached user-defined data:

>>> n = hou.node("/obj").createNode("geo")
>>> n.setCachedUserData("my data", [1, 2, {"a": "b", "c": "d"}])
>>> n.cachedUserData("my data")
[1, 2, {'a': 'b', 'c': 'd'}]
>>> n.cachedUserDataDict()
{'my data': [1, 2, {'a': 'b', 'c': 'd'}]}
>>> n.destroyCachedUserData("my data")
>>> n.cachedUserDataDict()
{}
>>> print n.cachedUserData("my data")
None

See per-node user-defined data for more information and examples.

Return a dictionary containing all the user-defined name/string pairs for this node.

See hou.Node.setCachedUserData for more information.

Return the user-defined cached data with this name, or None if no data with this name exists.

See hou.Node.setCachedUserData for more information.

This method can be implemented as follows:

def cachedUserData(self, name):
    return self.cachedUserDataDict().get(name)

Note that None is a valid value for a key, so the most reliable way to check if a key is valid is to check if it is in the result of cachedUserDataDict:

>>> n = hou.node("/obj").createNode("geo")
>>> n.cachedUserDataDict()
{}
>>> print n.cachedUserData("foo")
None
>>> "foo" in n.cachedUserDataDict()
False
>>> n.setCachedUserData("foo", None)
>>> n.cachedUserDataDict()
{'foo': None}
>>> print n.cachedUserData("foo")
None
>>> "foo" in n.cachedUserDataDict()
True

Remove the user-defined cached data with this name.

See hou.Node.setCachedUserData for more information.

Raises hou.OperationFailed if no user data with this name exists and must_exist is True.

Remove all user-defined cached data.

See hou.Node.setCachedUserData for more information.

Return the names of all data blocks stored on this node that are of the data type specified by the blocktype parameter.

Data blocks are similar to user data in that they can contain any extra data that may be useful to attach to a specific node. They differ from user data in that data blocks are designed to more efficiently handle large blocks of data. Data blocks can also contain binary data, and have a data type associated with each block.

Return the data type of the block specified by the key parameter.

Raises hou.ValueError if the provided key is not associated with any data block on this node.

Returns the data block as a binary string stored under the given key. This method will only work if the specified data block is has a type that can be represented by a python object. Otherwise None is returned.

The returned binary string is a bytes object in Python 3 and a str object in Python 2. See HOM binary data for more information.

Raises hou.ValueError if the provided key is not associated with any data block on this node.

Stores the provided data block on the node under the provided key name, marking it with the provided data type.

Passing an empty string as the block value will remove any data block with the specified key. Data blocks can also be removed with the removeDataBlock() method.

The blocktype string argument requires a C++/HDK plugin to interpret data blocks and turn them into C++ objects. If you're using Python to get and set data blocks, leave the blocktype empty.

Removes any existing data block on the node with the specified key. If there is no data block with this key, this method does nothing.

Return the simulation defined by this DOP network node. This raises an exception if this is not a dop network.

Given a hou.DopObject, return a tuple of DOP nodes that processed that object. This raises an exception if this is not a dopnetwork.

If a work item is selected, selects the next visible work item

If a work item is selected, selects the previous work item

Deselects the active work item if this node is inside or contains the TOP network with the currently selected work item.

If a TOP node can’t display all work items, sets which work item subset (page) will be displayed