notebooks/mtlx_json_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample MaterialX Notebook (JSON test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Setup for Colab Usage\n",
    "\n",
    "This can be uncommented and run if you are using Google Colab. It will install the necessary dependencies and install the MaterialX package.\n",
    "\n",
    "This is **not necessary** if opening using Github Codespaces "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment if running using Colab\n",
    "#!pip install MaterialX\n",
    "#!rm -rf MaterialX_Learn_Sample_Codespace\n",
    "#!git clone https://github.com/kwokcb/MaterialX_Learn_Sample_Codespace\n",
    "#import os\n",
    "#os.chdir('MaterialX_Learn_Sample_Codespace/notebooks')\n",
    "#!ls -R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Materialx version:  1.38.9\n",
      "Json version:  2.0.9\n"
     ]
    }
   ],
   "source": [
    "import MaterialX as mx\n",
    "import mtlxutils.mxfile as mxf\n",
    "import json\n",
    "\n",
    "from IPython.display import display_markdown\n",
    "\n",
    "# Print xmltodict version\n",
    "print('Materialx version: ', mx.__version__)\n",
    "print('Json version: ', json.__version__)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getShaderNodes(graphElement):\n",
    "    '''\n",
    "    Find all surface shaders in a GraphElement.\n",
    "    '''\n",
    "    shaderNodes = set()\n",
    "    for material in graphElement.getMaterialNodes():\n",
    "        for shader in mx.getShaderNodes(material):\n",
    "            shaderNodes.add(shader.getNamePath())\n",
    "    for shader in graphElement.getNodes():\n",
    "        if shader.getType() == 'surfaceshader':\n",
    "            shaderNodes.add(shader.getNamePath())\n",
    "    return shaderNodes\n",
    "\n",
    "\n",
    "def getRenderableGraphs(graphElement):\n",
    "    '''\n",
    "    Find all renderable graphs in a GraphElement.\n",
    "    '''\n",
    "    ngnamepaths = set()\n",
    "    graphs = []\n",
    "    shaderNodes = getShaderNodes(graphElement)\n",
    "    for shaderPath in shaderNodes:\n",
    "        shader = doc.getDescendant(shaderPath)\n",
    "        for input in shader.getInputs():\n",
    "            ngString = input.getNodeGraphString()\n",
    "            if ngString and ngString not in ngnamepaths:\n",
    "                graphs.append(graphElement.getNodeGraph(ngString))\n",
    "                ngnamepaths.add(ngString)\n",
    "    return graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def copyGraphInterfaces(dest, ng):\n",
    "    '''\n",
    "    Copy the interface of a nodegraph to a new nodegraph under a specified parent `dest`.\n",
    "    '''\n",
    "    copyMethod = 'add_remove'\n",
    "    ng1 = dest.addNodeGraph(ng.getName())\n",
    "    if copyMethod == 'add_remove':\n",
    "        ng1.copyContentFrom(ng)\n",
    "        for child in ng1.getChildren():\n",
    "            if child.isA(mx.Input) or child.isA(mx.Output):\n",
    "                for attr in ['nodegraph', 'nodename', 'defaultinput']:\n",
    "                    child.removeAttribute(attr)\n",
    "                continue\n",
    "            ng1.removeChild(child.getName())\n",
    "    else:\n",
    "        for attrName in ng.getAttributeNames():\n",
    "            attr = ng.getAttribute(attrName)\n",
    "            newattr = ng1.addAttribute(attr.getName(), attr.getType(), attr.getValue())\n",
    "            newattr.copyContentFrom(attr)\n",
    "        for port in ng.getInputs():\n",
    "            newport = ng1.addInput(port.getName(), port.getType())\n",
    "            newport.copyContentFrom(port)\n",
    "        for port in ng.getOutputs():\n",
    "            newport = ng1.addOutput(port.getName(), port.getType())\n",
    "            newport.copyContentFrom(port)\n",
    "            for attr in ['nodegraph', 'nodename', 'defaultinput']:\n",
    "                newport.removeAttribute(attr)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use a colon to separate the category and name of an element in the JSON hierarchy\n",
    "JSON_CATEGORY_NAME_SEPARATOR = ':'\n",
    "# The root of the JSON hierarchy\n",
    "MATERIALX_DOCUMENT_ROOT = 'materialx'\n",
    "\n",
    "# Convert MaterialX element to JSON\n",
    "def elementToJSON(elem, jsonParent):\n",
    "    '''\n",
    "    Convert an MaterialX XML element to JSON.\n",
    "    Will recursively traverse the parent/child Element hierarchy.\n",
    "    '''\n",
    "    if (elem.getSourceUri() != \"\"):\n",
    "        return\n",
    "    \n",
    "    # Create a new JSON element for the MaterialX element\n",
    "    jsonElem = {}\n",
    "\n",
    "    # Add attributes\n",
    "    for attrName in elem.getAttributeNames():\n",
    "        jsonElem[attrName] = elem.getAttribute(attrName)\n",
    "\n",
    "    # Add children\n",
    "    for child in elem.getChildren():\n",
    "        jsonElem = elementToJSON(child, jsonElem)\n",
    "    \n",
    "    # Add element to parent\n",
    "    jsonParent[elem.getCategory() + JSON_CATEGORY_NAME_SEPARATOR + elem.getName()] = jsonElem\n",
    "    return jsonParent\n",
    "\n",
    "# Convert MaterialX document to JSON\n",
    "def documentToJSON(doc):\n",
    "    '''Convert an MaterialX XML document to JSON'''\n",
    "    root = {}\n",
    "    root[\"materialx\"] = {}\n",
    "\n",
    "    for attrName in doc.getAttributeNames():\n",
    "        root[attrName] =  doc.getAttribute(attrName)\n",
    "\n",
    "    for elem in doc.getChildren():\n",
    "        elementToJSON(elem, root[MATERIALX_DOCUMENT_ROOT])\n",
    "\n",
    "    result = json.dumps(root, indent=2)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<details><summary>Extracted MaterialX Nodegraphs in XML</summary>\n",
       "\n",
       "```xml\n",
       "<?xml version=\"1.0\"?>\n",
       "<materialx version=\"1.38\">\n",
       "  <nodegraph name=\"NG_marble1\">\n",
       "    <input name=\"base_color_1\" type=\"color3\" value=\"0.8, 0.8, 0.8\" uiname=\"Color 1\" uifolder=\"Marble Color\" />\n",
       "    <input name=\"base_color_2\" type=\"color3\" value=\"0.1, 0.1, 0.3\" uiname=\"Color 2\" uifolder=\"Marble Color\" />\n",
       "    <input name=\"noise_scale_1\" type=\"float\" value=\"6.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Scale 1\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_scale_2\" type=\"float\" value=\"4.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Scale 2\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_power\" type=\"float\" value=\"3.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Power\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_octaves\" type=\"integer\" value=\"3\" uisoftmin=\"1\" uisoftmax=\"8\" uiname=\"Octaves\" uifolder=\"Marble Noise\" />\n",
       "    <output name=\"out\" type=\"color3\" />\n",
       "  </nodegraph>\n",
       "</materialx>\n",
       "\n",
       "```\n",
       "</details>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load in sample MaterialX file\n",
    "#doc = mx.createDocument()\n",
    "doc, libFiles, status = mxf.MtlxFile.createWorkingDocument()\n",
    "mx.readFromXmlFile(doc, './data/sample_marble.mtlx')\n",
    "\n",
    "# Create destination document and copy nodegraph interfaces over\n",
    "xmldoc = mx.createDocument()\n",
    "graphs = getRenderableGraphs(doc)\n",
    "for ng in graphs:\n",
    "    copyGraphInterfaces(xmldoc, ng)\n",
    "\n",
    "# Get interfaces as an XML string\n",
    "xml_string = mxf.MtlxFile.writeDocumentToString(xmldoc)\n",
    "\n",
    "text = '<details><summary>Extracted MaterialX Nodegraphs in XML</summary>\\n\\n' + '```xml\\n' + xml_string + '\\n```\\n' + '</details>\\n' \n",
    "display_markdown(text, raw=True)\n",
    "\n",
    "filename = './data/sample_marble_graph.mtlx'\n",
    "mx.writeToXmlFile(xmldoc, filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<details><summary>Entire document to JSON</summary>\n",
       "\n",
       "```json\n",
       "{\n",
       "  \"materialx\": {\n",
       "    \"nodegraph:NG_marble1\": {\n",
       "      \"input:base_color_1\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"value\": \"0.8, 0.8, 0.8\",\n",
       "        \"uiname\": \"Color 1\",\n",
       "        \"uifolder\": \"Marble Color\"\n",
       "      },\n",
       "      \"input:base_color_2\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"value\": \"0.1, 0.1, 0.3\",\n",
       "        \"uiname\": \"Color 2\",\n",
       "        \"uifolder\": \"Marble Color\"\n",
       "      },\n",
       "      \"input:noise_scale_1\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"6.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Scale 1\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_scale_2\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"4.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Scale 2\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_power\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"3.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Power\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_octaves\": {\n",
       "        \"type\": \"integer\",\n",
       "        \"value\": \"3\",\n",
       "        \"uisoftmin\": \"1\",\n",
       "        \"uisoftmax\": \"8\",\n",
       "        \"uiname\": \"Octaves\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"position:obj_pos\": {\n",
       "        \"type\": \"vector3\"\n",
       "      },\n",
       "      \"dotproduct:add_xyz\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"vector3\",\n",
       "          \"nodename\": \"obj_pos\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"vector3\",\n",
       "          \"value\": \"1, 1, 1\"\n",
       "        }\n",
       "      },\n",
       "      \"multiply:scale_xyz\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"add_xyz\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"interfacename\": \"noise_scale_1\"\n",
       "        }\n",
       "      },\n",
       "      \"multiply:scale_pos\": {\n",
       "        \"type\": \"vector3\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"vector3\",\n",
       "          \"nodename\": \"obj_pos\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"interfacename\": \"noise_scale_2\"\n",
       "        }\n",
       "      },\n",
       "      \"fractal3d:noise\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:octaves\": {\n",
       "          \"type\": \"integer\",\n",
       "          \"interfacename\": \"noise_octaves\"\n",
       "        },\n",
       "        \"input:position\": {\n",
       "          \"type\": \"vector3\",\n",
       "          \"nodename\": \"scale_pos\"\n",
       "        }\n",
       "      },\n",
       "      \"multiply:scale_noise\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"noise\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"value\": \"3.0\"\n",
       "        }\n",
       "      },\n",
       "      \"add:sum\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"scale_xyz\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"scale_noise\"\n",
       "        }\n",
       "      },\n",
       "      \"sin:sin\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"sum\"\n",
       "        }\n",
       "      },\n",
       "      \"multiply:scale\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"sin\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"value\": \"0.5\"\n",
       "        }\n",
       "      },\n",
       "      \"add:bias\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"scale\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"value\": \"0.5\"\n",
       "        }\n",
       "      },\n",
       "      \"power:power\": {\n",
       "        \"type\": \"float\",\n",
       "        \"input:in1\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"bias\"\n",
       "        },\n",
       "        \"input:in2\": {\n",
       "          \"type\": \"float\",\n",
       "          \"interfacename\": \"noise_power\"\n",
       "        }\n",
       "      },\n",
       "      \"mix:color_mix\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"input:bg\": {\n",
       "          \"type\": \"color3\",\n",
       "          \"interfacename\": \"base_color_1\"\n",
       "        },\n",
       "        \"input:fg\": {\n",
       "          \"type\": \"color3\",\n",
       "          \"interfacename\": \"base_color_2\"\n",
       "        },\n",
       "        \"input:mix\": {\n",
       "          \"type\": \"float\",\n",
       "          \"nodename\": \"power\"\n",
       "        }\n",
       "      },\n",
       "      \"output:out\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"nodename\": \"color_mix\"\n",
       "      }\n",
       "    },\n",
       "    \"standard_surface:SR_marble1\": {\n",
       "      \"type\": \"surfaceshader\",\n",
       "      \"xpos\": \"13.768116\",\n",
       "      \"ypos\": \"-0.672414\",\n",
       "      \"input:base\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"1\"\n",
       "      },\n",
       "      \"input:base_color\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"nodegraph\": \"NG_marble1\",\n",
       "        \"output\": \"out\"\n",
       "      },\n",
       "      \"input:specular_roughness\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"0.1\"\n",
       "      },\n",
       "      \"input:subsurface\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"0.4\"\n",
       "      },\n",
       "      \"input:subsurface_color\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"nodegraph\": \"NG_marble1\",\n",
       "        \"output\": \"out\"\n",
       "      }\n",
       "    },\n",
       "    \"surfacematerial:Marble_3D\": {\n",
       "      \"type\": \"material\",\n",
       "      \"xpos\": \"17.391304\",\n",
       "      \"ypos\": \"0.000000\",\n",
       "      \"input:surfaceshader\": {\n",
       "        \"type\": \"surfaceshader\",\n",
       "        \"nodename\": \"SR_marble1\"\n",
       "      }\n",
       "    }\n",
       "  },\n",
       "  \"version\": \"1.38\",\n",
       "  \"colorspace\": \"lin_rec709\"\n",
       "}\n",
       "```\n",
       "</details>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<details><summary>Node Graph Interface to JSON</summary>\n",
       "\n",
       "```json\n",
       "{\n",
       "  \"materialx\": {\n",
       "    \"nodegraph:NG_marble1\": {\n",
       "      \"input:base_color_1\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"value\": \"0.8, 0.8, 0.8\",\n",
       "        \"uiname\": \"Color 1\",\n",
       "        \"uifolder\": \"Marble Color\"\n",
       "      },\n",
       "      \"input:base_color_2\": {\n",
       "        \"type\": \"color3\",\n",
       "        \"value\": \"0.1, 0.1, 0.3\",\n",
       "        \"uiname\": \"Color 2\",\n",
       "        \"uifolder\": \"Marble Color\"\n",
       "      },\n",
       "      \"input:noise_scale_1\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"6.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Scale 1\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_scale_2\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"4.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Scale 2\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_power\": {\n",
       "        \"type\": \"float\",\n",
       "        \"value\": \"3.0\",\n",
       "        \"uisoftmin\": \"1.0\",\n",
       "        \"uisoftmax\": \"10.0\",\n",
       "        \"uiname\": \"Power\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"input:noise_octaves\": {\n",
       "        \"type\": \"integer\",\n",
       "        \"value\": \"3\",\n",
       "        \"uisoftmin\": \"1\",\n",
       "        \"uisoftmax\": \"8\",\n",
       "        \"uiname\": \"Octaves\",\n",
       "        \"uifolder\": \"Marble Noise\"\n",
       "      },\n",
       "      \"output:out\": {\n",
       "        \"type\": \"color3\"\n",
       "      }\n",
       "    }\n",
       "  },\n",
       "  \"version\": \"1.38\"\n",
       "}\n",
       "```\n",
       "</details>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert entire document\n",
    "doc_result = documentToJSON(doc)\n",
    "\n",
    "text = '<details><summary>Entire document to JSON</summary>\\n\\n' + '```json\\n' + doc_result  + '\\n```\\n' + '</details>\\n' \n",
    "display_markdown(text, raw=True)\n",
    "\n",
    "# Convert just the graph\n",
    "graph_result = documentToJSON(xmldoc)\n",
    "\n",
    "text = '<details><summary>Node Graph Interface to JSON</summary>\\n\\n' + '```json\\n' + graph_result  + '\\n```\\n' + '</details>\\n' \n",
    "display_markdown(text, raw=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save graph_result to file\n",
    "filename = './data/sample_marble_graph.json'\n",
    "file = open(filename, 'w')\n",
    "file.write(graph_result)\n",
    "file.close()\n",
    "\n",
    "# Save doc_result to file\n",
    "filename = './data/sample_marble.json'\n",
    "file = open(filename, 'w')\n",
    "file.write(doc_result)\n",
    "file.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Deserialization from JSON\n",
    "\n",
    "For conversion from JSON we introduce two functions:\n",
    "\n",
    "1. `documentFromJSON()` : Converts a JSON string to a MaterialX document.\n",
    "2. `elementFromJSON()` : Converts a JSON string to a MaterialX element, and continues to recursively convert any children.\n",
    "\n",
    "Note that to perform deserialization we need to split the `category` and `name` out for non-attribute elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separator between category and name in JSON element\n",
    "JSON_CATEGORY_NAME_SEPARATOR = \":\"\n",
    "\n",
    "# Convert JSON element to MaterialX\n",
    "def elementFromJSON(node, elem):\n",
    "    '''\n",
    "    Convert an JSON element to MaterialX\n",
    "    '''\n",
    "    for key in node:\n",
    "        value = node[key]\n",
    "\n",
    "        # Set attributes            \n",
    "        if isinstance(value, str):\n",
    "            elem.setAttribute(key, str(value))\n",
    "\n",
    "        # Traverse chilren\n",
    "        else:\n",
    "            # Traverse down from root\n",
    "            if key == MATERIALX_DOCUMENT_ROOT:\n",
    "                elementFromJSON(value, elem)\n",
    "                continue\n",
    "\n",
    "            # Split key name by \":\" to get category and name\n",
    "            category, name = key.split(JSON_CATEGORY_NAME_SEPARATOR, 1)\n",
    "            if category and not elem.getChild(name):\n",
    "                child = elem.addChildOfCategory(category, name)\n",
    "                elementFromJSON(value, child)\n",
    "\n",
    "# Convert JSON to MaterialX document\n",
    "def documentFromJSON(jsonDoc, doc):\n",
    "    '''\n",
    "    Convert a JSON document to MaterialX\n",
    "    '''\n",
    "    elementFromJSON(jsonDoc, doc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<details><summary>JSON Deserialization of Document</summary>\n",
       "\n",
       "```xml\n",
       "<?xml version=\"1.0\"?>\n",
       "<materialx version=\"1.38\" colorspace=\"lin_rec709\">\n",
       "  <nodegraph name=\"NG_marble1\">\n",
       "    <input name=\"base_color_1\" type=\"color3\" value=\"0.8, 0.8, 0.8\" uiname=\"Color 1\" uifolder=\"Marble Color\" />\n",
       "    <input name=\"base_color_2\" type=\"color3\" value=\"0.1, 0.1, 0.3\" uiname=\"Color 2\" uifolder=\"Marble Color\" />\n",
       "    <input name=\"noise_scale_1\" type=\"float\" value=\"6.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Scale 1\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_scale_2\" type=\"float\" value=\"4.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Scale 2\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_power\" type=\"float\" value=\"3.0\" uisoftmin=\"1.0\" uisoftmax=\"10.0\" uiname=\"Power\" uifolder=\"Marble Noise\" />\n",
       "    <input name=\"noise_octaves\" type=\"integer\" value=\"3\" uisoftmin=\"1\" uisoftmax=\"8\" uiname=\"Octaves\" uifolder=\"Marble Noise\" />\n",
       "    <position name=\"obj_pos\" type=\"vector3\" />\n",
       "    <dotproduct name=\"add_xyz\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"vector3\" nodename=\"obj_pos\" />\n",
       "      <input name=\"in2\" type=\"vector3\" value=\"1, 1, 1\" />\n",
       "    </dotproduct>\n",
       "    <multiply name=\"scale_xyz\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"add_xyz\" />\n",
       "      <input name=\"in2\" type=\"float\" interfacename=\"noise_scale_1\" />\n",
       "    </multiply>\n",
       "    <multiply name=\"scale_pos\" type=\"vector3\">\n",
       "      <input name=\"in1\" type=\"vector3\" nodename=\"obj_pos\" />\n",
       "      <input name=\"in2\" type=\"float\" interfacename=\"noise_scale_2\" />\n",
       "    </multiply>\n",
       "    <fractal3d name=\"noise\" type=\"float\">\n",
       "      <input name=\"octaves\" type=\"integer\" interfacename=\"noise_octaves\" />\n",
       "      <input name=\"position\" type=\"vector3\" nodename=\"scale_pos\" />\n",
       "    </fractal3d>\n",
       "    <multiply name=\"scale_noise\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"noise\" />\n",
       "      <input name=\"in2\" type=\"float\" value=\"3.0\" />\n",
       "    </multiply>\n",
       "    <add name=\"sum\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"scale_xyz\" />\n",
       "      <input name=\"in2\" type=\"float\" nodename=\"scale_noise\" />\n",
       "    </add>\n",
       "    <sin name=\"sin\" type=\"float\">\n",
       "      <input name=\"in\" type=\"float\" nodename=\"sum\" />\n",
       "    </sin>\n",
       "    <multiply name=\"scale\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"sin\" />\n",
       "      <input name=\"in2\" type=\"float\" value=\"0.5\" />\n",
       "    </multiply>\n",
       "    <add name=\"bias\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"scale\" />\n",
       "      <input name=\"in2\" type=\"float\" value=\"0.5\" />\n",
       "    </add>\n",
       "    <power name=\"power\" type=\"float\">\n",
       "      <input name=\"in1\" type=\"float\" nodename=\"bias\" />\n",
       "      <input name=\"in2\" type=\"float\" interfacename=\"noise_power\" />\n",
       "    </power>\n",
       "    <mix name=\"color_mix\" type=\"color3\">\n",
       "      <input name=\"bg\" type=\"color3\" interfacename=\"base_color_1\" />\n",
       "      <input name=\"fg\" type=\"color3\" interfacename=\"base_color_2\" />\n",
       "      <input name=\"mix\" type=\"float\" nodename=\"power\" />\n",
       "    </mix>\n",
       "    <output name=\"out\" type=\"color3\" nodename=\"color_mix\" />\n",
       "  </nodegraph>\n",
       "  <standard_surface name=\"SR_marble1\" type=\"surfaceshader\" xpos=\"13.768116\" ypos=\"-0.672414\">\n",
       "    <input name=\"base\" type=\"float\" value=\"1\" />\n",
       "    <input name=\"base_color\" type=\"color3\" nodegraph=\"NG_marble1\" output=\"out\" />\n",
       "    <input name=\"specular_roughness\" type=\"float\" value=\"0.1\" />\n",
       "    <input name=\"subsurface\" type=\"float\" value=\"0.4\" />\n",
       "    <input name=\"subsurface_color\" type=\"color3\" nodegraph=\"NG_marble1\" output=\"out\" />\n",
       "  </standard_surface>\n",
       "  <surfacematerial name=\"Marble_3D\" type=\"material\" xpos=\"17.391304\" ypos=\"0.000000\">\n",
       "    <input name=\"surfaceshader\" type=\"surfaceshader\" nodename=\"SR_marble1\" />\n",
       "  </surfacematerial>\n",
       "</materialx>\n",
       "\n",
       "```\n",
       "</details>\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert entire document back from JSON\n",
    "newDoc = mx.createDocument() \n",
    "jsonObject = json.loads(doc_result)\n",
    "documentFromJSON(jsonObject, newDoc)\n",
    "\n",
    "# Validate and upgrade element version\n",
    "valid, errors = newDoc.validate()\n",
    "if not valid:\n",
    "    print('Validation errors:')\n",
    "    for err in errors:\n",
    "        print('  {}'.format(err))\n",
    "newDoc.upgradeVersion()\n",
    "\n",
    "newDocString = mx.writeToXmlString(newDoc)    \n",
    "text = '<details><summary>JSON Deserialization of Document</summary>\\n\\n' + '```xml\\n' + newDocString  + '\\n```\\n' + '</details>\\n' \n",
    "display_markdown(text, raw=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}