XML to Python Dict Converter

[AnsonSavage]

Hey!

It seems like in some cases (e.g., the caustics optimization tutorial), the scene needs to be defined in Python because you can't define an XML scene and then dynamically inject new items/objects (if there is a way to do this, I would love to know!)

So, given that I had generated a scene in Blender, I was looking for a way to convert the XML file to Python dict construction code. I couldn't find anything online about how to do that automatically, so I had o3-mini come up with this class (after several tries). It works for my XML file, although I'm sure with more advanced stuff, it might struggle. I thought I'd post it here in case anyone else would like to use it or if anyone else knows of a better solution.

Thanks!
Anson

import xml.etree.ElementTree as ET
import os

class XMLSceneConverter:
    """
    A converter that transforms a Mitsuba XML scene file into equivalent Python code.
    
    Usage:
        converter = XMLSceneConverter("scenes/geometry.xml")
        converter.convert()      # builds internal defaults and scene_dict
        code_str = converter.to_code()
        print(code_str)
    """

    class Code:
        """
        Helper class to wrap code snippets that should be output verbatim.
        """
        def __init__(self, code):
            self.code = code
        def __repr__(self):
            return self.code

    def __init__(self, xml_file):
        self.xml_file = xml_file
        self.defaults = {}
        self.scene_dict = {}

    def sanitize_id(self, id_str):
        """Sanitize an id by removing any periods and subsequent characters."""
        return id_str.split('.')[0]

    def parse_value(self, elem, defaults):
        """
        Convert a leaf XML element to its Python value.
        For 'rgb', return a dict with type info.
        For 'matrix', return a Code instance that calls mi.ScalarTransform4f(np.array(...)).
        Also substitutes default values when the value starts with '$'.
        """
        tag = elem.tag
        val = elem.attrib.get("value")
        
        # Substitute default values.
        if val.startswith("$"):
            key = val[1:]
            if key in defaults:
                val = defaults[key]
            else:
                return val  # fallback

        if tag == "integer":
            return int(val)
        elif tag == "float":
            return float(val)
        elif tag == "boolean":
            return val.lower() == "true"
        elif tag == "string":
            return val
        elif tag == "rgb":
            # Return a dictionary with type info.
            return {"type": "rgb", "value": list(map(float, val.split()))}
        elif tag == "matrix":
            numbers = list(map(float, val.split()))
            matrix_list = [numbers[i:i+4] for i in range(0, 16, 4)]
            return XMLSceneConverter.Code(f"mi.ScalarTransform4f(np.array({matrix_list}, dtype=np.float32))")
        else:
            return val

    def parse_transform(self, elem, defaults):
        """
        Process a <transform> element.
        If a <matrix> child is present, use it directly.
        Otherwise, compose rotate and translate elements.
        """
        # If there's a matrix child, use that.
        for child in elem:
            if child.tag == "matrix":
                return self.parse_value(child, defaults)
        
        # Otherwise, compose rotations and translation.
        rotations = {"x": None, "y": None, "z": None}
        translate_val = None
        for child in elem:
            if child.tag == "rotate":
                if "x" in child.attrib:
                    rotations["x"] = float(child.attrib["angle"])
                elif "y" in child.attrib:
                    rotations["y"] = float(child.attrib["angle"])
                elif "z" in child.attrib:
                    rotations["z"] = float(child.attrib["angle"])
            elif child.tag == "translate":
                numbers = [float(x) for x in child.attrib["value"].split()]
                translate_val = ", ".join(map(str, numbers))
        parts = []
        if translate_val is not None:
            parts.append(f"mi.ScalarTransform4f.translate([{translate_val}])")
        if rotations["z"] is not None:
            parts.append(f"mi.ScalarTransform4f.rotate([0, 0, 1], {rotations['z']})")
        if rotations["y"] is not None:
            parts.append(f"mi.ScalarTransform4f.rotate([0, 1, 0], {rotations['y']})")
        if rotations["x"] is not None:
            parts.append(f"mi.ScalarTransform4f.rotate([1, 0, 0], {rotations['x']})")
        transform_code = " @ ".join(parts)
        return XMLSceneConverter.Code(transform_code)

    def element_to_dict(self, elem, defaults, base_dir):
        """
        Recursively convert an XML element (and its children) to a dictionary.
        Propagates defaults for variable substitutions and adjusts relative filenames.
        """
        result = {}
        # Process attributes (skip 'id' and 'name')
        for key, value in elem.attrib.items():
            if key in ["id", "name"]:
                continue
            # Adjust relative paths for filenames.
            if key == "filename" and not os.path.isabs(value):
                value = os.path.join(base_dir, value)
            result[key] = value

        # Process children.
        for child in elem:
            if child.tag == "transform":
                name = child.attrib.get("name", "to_world")
                result[name] = self.parse_transform(child, defaults)
            elif child.tag in ["integer", "float", "boolean", "string", "rgb", "matrix"]:
                name = child.attrib.get("name", child.tag)
                val = self.parse_value(child, defaults)
                # Adjust relative path for filename if this child is a filename string.
                if name == "filename" and isinstance(val, str) and not os.path.isabs(val):
                    val = os.path.join(base_dir, val)
                result[name] = val
            elif child.tag == "ref":
                name = child.attrib.get("name", "ref")
                result[name] = {"type": "ref", "id": self.sanitize_id(child.attrib["id"])}
            else:
                name = child.attrib.get("name", child.tag)
                result[name] = self.element_to_dict(child, defaults, base_dir)
        return result

    def convert_scene_xml_to_dict(self, xml_file):
        """
        Parse the XML file and build:
          - defaults: from <default> tags.
          - scene_dict: for all other scene elements (keys sanitized).
        Then add the top-level scene type.
        Adjust relative paths based on the XML file's directory.
        """
        base_dir = os.path.dirname(os.path.abspath(xml_file))
        tree = ET.parse(xml_file)
        root = tree.getroot()
        scene_dict = {}
        defaults = {}
        for child in root:
            if child.tag == "default":
                defaults[child.attrib["name"]] = child.attrib["value"]
            else:
                orig_id = child.attrib.get("id", child.tag)
                key = self.sanitize_id(orig_id)
                scene_dict[key] = self.element_to_dict(child, defaults, base_dir)
        # Add the overall scene type.
        scene_dict["type"] = "scene"
        return defaults, scene_dict

    def serialize_obj(self, obj, indent=0):
        """
        Recursively serialize an object (dict, list, Code, or basic type) into a string.
        Code instances are inserted verbatim (without quotes).
        """
        sp = "    " * indent
        if isinstance(obj, XMLSceneConverter.Code):
            return obj.code
        elif isinstance(obj, dict):
            items = []
            for key, value in obj.items():
                serialized_value = self.serialize_obj(value, indent + 1)
                items.append(f"{'    '*(indent+1)}{repr(key)}: {serialized_value}")
            if items:
                return "{\n" + ",\n".join(items) + "\n" + sp + "}"
            else:
                return "{}"
        elif isinstance(obj, list):
            items = [("    "*(indent+1) + self.serialize_obj(item, indent + 1)) for item in obj]
            if items:
                return "[\n" + ",\n".join(items) + "\n" + sp + "]"
            else:
                return "[]"
        else:
            return repr(obj)

    def dict_to_code(self, defaults, scene_dict):
        """
        Convert the defaults and scene_dict into a Python code string.
        Uses the custom serializer to embed Code objects verbatim.
        """
        lines = []
        lines.append("import numpy as np")
        lines.append("import mitsuba as mi")
        lines.append("")
        lines.append("defaults = " + self.serialize_obj(defaults))
        lines.append("")
        lines.append("scene_dict = " + self.serialize_obj(scene_dict))
        lines.append("")
        lines.append("scene = mi.load_dict(scene_dict)")
        return "\n".join(lines)

    def convert(self):
        """
        Perform the conversion from XML to the internal scene_dict.
        """
        self.defaults, self.scene_dict = self.convert_scene_xml_to_dict(self.xml_file)
        return self.defaults, self.scene_dict

    def to_code(self):
        """
        Generate the Python code string from the converted scene.
        """
        if not self.scene_dict:
            self.convert()
        return self.dict_to_code(self.defaults, self.scene_dict)

Example usage:

from xml_scene_converter import XMLSceneConverter

# Provide the path to your XML file.
xml_file = 'scenes/geometry.xml'
converter = XMLSceneConverter(xml_file)
converter.convert()  # Build the internal dictionary
code_str = converter.to_code()
print(code_str)