Class which will build node graph connectivity information from a MaterialX document. More...

Public Member Functions
	constructor (doc)
	Constructor.

	setIncludeGraphs (graphs)
	Set graphs to include.

	getDictionary ()
	Get the graph dictionary.

	getConnections ()
	Get graph connections.

	updateGraphDictionaryPath (key, item, nodetype, type, value, graphDictionary)
	Update the graph dictionary with a new item.

	updateGraphDictionaryItem (item, graphDictionary)
	Update the graph dictionary with a new item.

	printGraphDictionary (graphDictionary)
	Print the graph dictionary.

	getParentGraph (elem)
	Get the parent graph of an element.

	getDefaultOutput (node)
	Get the default output of a node.

	appendPath (p1, p2)
	Append two paths together.

	buildPortConnection (doc, portPath, connections, portIsNode)
	Store a port connection.

	buildConnections (doc, graphElement, connections)
	Build the connections between graph elements.

	buildGraphDictionary (doc)
	Build the graph dictionary.

	execute ()
	Build the graph information.

	getJSON (inputFileName)
	Get the JSON representation of the graph information.

	exportToJSON (filename, inputFileName)
	Export the graph information to a JSON file.

	importFromJSON (filename)
	Import the graph information from a JSON file.

Detailed Description

Class which will build node graph connectivity information from a MaterialX document.

Definition at line 6 of file JsMaterialXGraph.js.

Member Function Documentation

◆ appendPath()

MxGraphBuilder::appendPath	(		p1,
			p2 )

Append two paths together.

Parameters

p1	Path 1
p2	Path 2

Returns: Appended path

Definition at line 167 of file JsMaterialXGraph.js.

                       {
        return p2 ? p1 + '/' + p2 : p1;
    }

◆ buildConnections()

MxGraphBuilder::buildConnections	(	doc,
		graphElement,
		connections )

Build the connections between graph elements.

Parameters

doc	Document
graphElement	Graph element
connections	Set of connections

Returns: {void}

Definition at line 305 of file JsMaterialXGraph.js.

                                                     {
        let root = doc.getDocument();
 
        for (let elem of graphElement.getChildren()) {
            if (!elem.hasSourceUri()) {
                if (elem instanceof mx.Input) {
                    this.buildPortConnection(root, elem.getNamePath(), connections, true);
                } else if (elem instanceof mx.Output) {
                    this.buildPortConnection(root, elem.getNamePath(), connections, true);
                } else if (elem instanceof mx.Node) {
                    let nodeInputs = elem.getInputs();
                    for (let nodeInput of nodeInputs) {
                        this.buildPortConnection(root, nodeInput.getNamePath(), connections, false);
                    }
                } else if (elem instanceof mx.NodeGraph) {
                    let nodedef = elem.getNodeDef();
                    if (nodedef) {
                        connections.push([elem.getNamePath(), '', nodedef.getName(), '', 'nodedef']);
                    }
                    let visited = new Set();
                    let path = elem.getNamePath();
                    if (!visited.has(path)) {
                        visited.add(path);
                        this.buildConnections(root, elem, connections);
                    }
                }
            }
        }
    }

◆ buildGraphDictionary()

MxGraphBuilder::buildGraphDictionary ( doc )

Build the graph dictionary.

Parameters

doc Document

Returns: Graph dictionary

Definition at line 340 of file JsMaterialXGraph.js.

                              {
        let graphDictionary = {};
        let root = doc.getDocument();
        let skipped = [];
 
        for (let elem of doc.getChildren()) {
            if (elem.hasSourceUri()) {
                skipped.push(elem.getNamePath());
            } else {
                if ((elem instanceof mx.Input) || (elem instanceof mx.Output) || (elem instanceof mx.Node)) {
                    //console.log('Scan element:', elem.getNamePath(), elem.getCategory(), mx.NodeGraph);
                    this.updateGraphDictionaryItem(elem, graphDictionary);
                } else if (elem instanceof mx.NodeGraph) {
                    //console.log('Scan graph:', elem.getNamePath(), elem.getCategory(), mx.NodeGraph);
                    if (elem.getAttribute('nodedef')) {
                        let nodeDef = elem.getAttribute('nodedef');
                        nodeDef = root.getDescendant(nodeDef);
                        if (nodeDef) {
                            for (let nodeDefInput of nodeDef.getInputs()) {
                                if (elem.getChild("def_" + nodeDefInput.getName())) {
                                    continue;
                                }
                                let newInput = elem.addInput("def_" + nodeDefInput.getName(), nodeDefInput.getType());
                                newInput.copyContentFrom(nodeDefInput);
                            }
                        }
                    }
 
                    for (let node of elem.getInputs()) {
                        this.updateGraphDictionaryItem(node, graphDictionary);
                    }
                    for (let node of elem.getOutputs()) {
                        this.updateGraphDictionaryItem(node, graphDictionary);
                    }
                    for (let node of elem.getNodes()) {
                        this.updateGraphDictionaryItem(node, graphDictionary);
                    }
                    for (let node of elem.getTokens()) {
                        this.updateGraphDictionaryItem(node, graphDictionary);
                    }
                } else if ((elem instanceof mx.NodeDef) || (elem instanceof mx.Token)) {
                    this.updateGraphDictionaryItem(elem, graphDictionary);
                }
            }
        }
 
        return graphDictionary;
    }

◆ buildPortConnection()

MxGraphBuilder::buildPortConnection	(	doc,
		portPath,
		connections,
		portIsNode )

Store a port connection.

Parameters

doc	Document
portPath	Path of the port
connections	Set of connections
portIsNode	Port is a node

Returns: {void}

Definition at line 179 of file JsMaterialXGraph.js.

                                                                {
        let root = doc.getDocument();
        let port = root.getDescendant(portPath);
        if (!port) {
            console.log('Element not found:', portPath);
            return;
        }
    
        if (!(port instanceof mx.Input) && !(port instanceof mx.Output)) {
            console.log('Element is not an input or output');
            return;
        }
    
        let parent = port.getParent();
        let parentPath = parent.getNamePath();
        let parentGraph = this.getParentGraph(port);
    
        if ((port instanceof mx.Input) && (parent instanceof mx.NodeGraph)) {
            parentGraph = parentGraph.getParent();
        }
    
        if (!parentGraph) {
            console.log('Cannot find parent graph of port', port);
            //return;
        }
        let parentGraphPath = parentGraph.getNamePath();
    
        let outputName = port.getOutputString();
    
        let destNode = portIsNode ? portPath : parentPath;
        let destPort = portIsNode ? '' : port.getName();
    
        let nodename = port.getAttribute('nodename');
        if (nodename) {
            let result;
            if (!parentGraphPath) {
                result = [this.appendPath(nodename, ''), outputName, destNode, destPort, 'nodename'];
            } else {
                result = [this.appendPath(parentGraphPath, nodename), outputName, destNode, destPort, 'nodename'];
            }
            connections.push(result);
            return;
        }
    
        let nodegraph = port.getNodeGraphString();
        if (nodegraph) {
            if (!outputName) {
                outputName = this.getDefaultOutput(parentGraph.getChild(nodegraph));
            }
            let result;
            if (!parentGraphPath) {
                result = [this.appendPath(nodegraph, outputName), '', destNode, destPort, 'nodename'];
            } else {
                result = [this.appendPath(parentGraphPath, nodegraph), outputName, destNode, destPort, 'nodegraph'];
            }
            connections.push(result);
            return;
        }
    
        let interfaceName = port.getInterfaceName();
        if (interfaceName) {
            let result;
            if (!parentGraphPath) {
                if (!outputName) {
                    outputName = this.getDefaultOutput(parentGraph.getChild(interfaceName));
                }
                result = [this.appendPath(interfaceName, outputName), '', destNode, destPort, 'nodename'];
            } else {
                let outputName = '';
                let itemValue = '';
                if (destNode === parentGraphPath + '/' + interfaceName) {
                    let dictItem = this.graphDictionary[parentGraphPath];
                    if (dictItem) {
                        let found = false;
                        for (let item of dictItem) {
                            if (item[0] === parentGraphPath + '/' + interfaceName) {
                                found = true;
                                break;
                            }
                        }
                        if (found) {
                            console.log('Warning: Rename duplicate interface:', parentGraphPath + '/' + interfaceName + ':in');
                            interfaceName = interfaceName + ':in';
                        }
                    }
                }
    
                let found = false;
                let dictItem = this.graphDictionary[parentGraphPath];
                if (dictItem) {
                    for (let item of dictItem) {
                        if (item[0] === parentGraphPath + '/' + interfaceName) {
                            found = true;
                            break;
                        }
                    }
                }
    
                if (!found) {
                    this.updateGraphDictionaryPath(parentGraphPath, parentGraphPath + '/' + interfaceName, 'input', port.getType(), itemValue, this.graphDictionary);
                }
                result = [this.appendPath(parentGraphPath, interfaceName), outputName, destNode, destPort, 'interfacename'];
            }
            connections.push(result);
            return;
        }
    
        if (outputName) {
            let result;
            if (!parentGraphPath) {
                result = [this.appendPath(outputName, ''), '', parentPath, port.getName(), 'nodename'];
            } else {
                result = [this.appendPath(parentGraphPath, outputName), '', parentPath, port.getName(), 'output'];
            }
            connections.push(result);
            return;
        }
    }    

◆ constructor()

MxGraphBuilder::constructor ( doc )

Constructor.

Parameters

{doc	MaterialX document

Definition at line 12 of file JsMaterialXGraph.js.

                     {
        this.doc = doc;
        this.graphDictionary = {};
        this.connections = [];
        this.includeGraphs = '';
    }

◆ execute()

MxGraphBuilder::execute ( )

Build the graph information.

Returns: {void}

Definition at line 393 of file JsMaterialXGraph.js.

              {
        this.connections = [];
        this.graphDictionary = {};
 
        let graphElement = this.doc;
        if (this.includeGraphs) {
            let graph = this.includeGraphs;
            graphElement = this.doc.getDescendant(graph);
            if (graphElement) {
                graphElement.setSourceUri('');
                console.log('Scan graph:', graphElement.getNamePath());
            } else {
                console.log('Graph not found:', graph);
            }
        }
 
        this.graphDictionary = this.buildGraphDictionary(graphElement);
        this.buildConnections(this.doc, graphElement, this.connections);
    }

◆ exportToJSON()

MxGraphBuilder::exportToJSON	(		filename,
			inputFileName )

Export the graph information to a JSON file.

Parameters

filename	Output file name
inputFileName	Input file name

Returns: {void}

Definition at line 434 of file JsMaterialXGraph.js.

                                          {
        let data = {
            doc: 'Graph connections for: ' + inputFileName,
            //copyright: 'Copyright 2024, NanMu Consulting. kwokcb@gmail.com',
            graph: this.graphDictionary,
            connections: this.connections
        };
 
        //let fs = require('fs');
        //fs.writeFileSync(filename, JSON.stringify(data, null, 2));
 
        let dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(data, null, 2));
        let downloadAnchorNode = document.createElement('a');
        downloadAnchorNode.setAttribute("href", dataStr);
        downloadAnchorNode.setAttribute("download", filename);
        document.body.appendChild(downloadAnchorNode); // required for firefox
        downloadAnchorNode.click();
        downloadAnchorNode.remove();
    }

◆ getConnections()

MxGraphBuilder::getConnections ( )

Get graph connections.

Returns: Graph connections

Definition at line 40 of file JsMaterialXGraph.js.

                     {
        return this.connections;
    }

◆ getDefaultOutput()

MxGraphBuilder::getDefaultOutput ( node )

Get the default output of a node.

Parameters

node	Node to check

Returns: Default output

Definition at line 143 of file JsMaterialXGraph.js.

                           {
        if (!node) return '';
 
        let defaultOutput = null;
        if (node instanceof mx.Node) {
            let nodedef = node.getNodeDef();
            if (nodedef) {
                defaultOutput = nodedef.getActiveOutputs()[0];
            } else {
                console.log('Cannot find nodedef for node:', node.getNamePath());
            }
        } else if (node instanceof mx.NodeGraph) {
            defaultOutput = node.getOutputs()[0];
        }
 
        return defaultOutput ? defaultOutput.getName() : '';
    }

◆ getDictionary()

MxGraphBuilder::getDictionary ( )

Get the graph dictionary.

Returns: Graph dictionary

Definition at line 32 of file JsMaterialXGraph.js.

                    {
        return this.graphDictionary;
    }

◆ getJSON()

MxGraphBuilder::getJSON ( inputFileName )

Get the JSON representation of the graph information.

Parameters

inputFileName Input file name

Returns: JSON string

Definition at line 418 of file JsMaterialXGraph.js.

                           {
        let data = {
            doc: 'Graph connections for: ' + inputFileName,
            //copyright: 'Copyright 2024, NanMu Consulting. kwokcb@gmail.com',
            graph: this.graphDictionary,
            connections: this.connections
        };
        return JSON.stringify(data, null, 4);
    }

◆ getParentGraph()

MxGraphBuilder::getParentGraph ( elem )

Get the parent graph of an element.

Parameters

elem	Element to check

Returns: Parent graph

Definition at line 131 of file JsMaterialXGraph.js.

                         {
        while (elem && !(elem instanceof mx.GraphElement)) {
            elem = elem.getParent();
        }
        return elem;
    }

◆ importFromJSON()

MxGraphBuilder::importFromJSON ( filename )

Import the graph information from a JSON file.

Parameters

filename Input file name

Returns: {void}

Definition at line 459 of file JsMaterialXGraph.js.

                             {
        let fs = require('fs');
        let data = JSON.parse(fs.readFileSync(filename, 'utf8'));
        this.graphDictionary = data.graph;
        this.connections = data.connections;
    }

◆ printGraphDictionary()

MxGraphBuilder::printGraphDictionary ( graphDictionary )

Print the graph dictionary.

Parameters

graphDictionary Graph dictionary

Returns: {void}

Definition at line 97 of file JsMaterialXGraph.js.

                                          {
        for (let graphPath in graphDictionary) {
            if (graphPath === '') {
                console.log('Root Document:');
            } else {
                console.log(graphPath + ':');
            }
 
            let filter = 'input';
            for (let item of graphDictionary[graphPath]) {
                if (item[1] !== filter) continue;
                console.log('- ', item);
            }
 
            filter = 'output';
            for (let item of graphDictionary[graphPath]) {
                if (item[1] !== filter) continue;
                console.log('- ', item);
            }
 
            filter = ['output', 'input'];
            for (let item of graphDictionary[graphPath]) {
                if (!filter.includes(item[1])) {
                    console.log('- ', item);
                }
            }
        }
    }

◆ setIncludeGraphs()

MxGraphBuilder::setIncludeGraphs ( graphs )

Set graphs to include.

Parameters

graphs Graphs to include

Returns: {void}

Definition at line 24 of file JsMaterialXGraph.js.

                             {
        this.includeGraphs = graphs;
    }

◆ updateGraphDictionaryItem()

MxGraphBuilder::updateGraphDictionaryItem	(		item,
			graphDictionary )

Update the graph dictionary with a new item.

Parameters

item	Item to add
graphDictionary	Graph dictionary

Returns: {void}

Definition at line 68 of file JsMaterialXGraph.js.

                                                     {
        if (!item) return;
 
        let parentElem = item.getParent();
        if (!parentElem || !(parentElem instanceof mx.GraphElement)) return;
 
        let key = parentElem.getNamePath();
        let value = item.getNamePath();
        let itemType = item.getType();
        let itemCategory = item.getCategory();
        let itemValue = '';
 
        if (item instanceof mx.Node) {
            let inputs = item.getInputs();
            if (inputs.length === 1) {
                itemValue = inputs[0].getValueString();
            }
        } else if (item instanceof mx.Input) {
            itemValue = item.getValueString();
        }
 
        this.updateGraphDictionaryPath(key, value, itemCategory, itemType, itemValue, graphDictionary);
    }

◆ updateGraphDictionaryPath()

MxGraphBuilder::updateGraphDictionaryPath	(	key,
		item,
		nodetype,
		type,
		value,
		graphDictionary )

Update the graph dictionary with a new item.

Parameters

key	Key for the dictionary
item	Item to add
nodetype	Node type
type	Type of the node
value	Value of the node
graphDictionary	Graph dictionary

Returns: {void}

Definition at line 54 of file JsMaterialXGraph.js.

                                                                                 {
        if (key in graphDictionary) {
            graphDictionary[key].push([item, nodetype, type, value]);
        } else {
            graphDictionary[key] = [[item, nodetype, type, value]];
        }
    }

The documentation for this class was generated from the following file:

JsMaterialXGraph.js

Public Member Functions

Detailed Description

Member Function Documentation

◆ appendPath()

◆ buildConnections()

◆ buildGraphDictionary()

◆ buildPortConnection()

◆ constructor()

◆ execute()

◆ exportToJSON()

◆ getConnections()

◆ getDefaultOutput()

◆ getDictionary()

◆ getJSON()

◆ getParentGraph()

◆ importFromJSON()

◆ printGraphDictionary()

◆ setIncludeGraphs()

◆ updateGraphDictionaryItem()

◆ updateGraphDictionaryPath()