lithop 0.1.0 → 0.2.0

data/lib/lithop/export/print_readme.rb

@@ -5,7 +5,10 @@ module Lithop
   module PrintReadme
     module_function
 
-    def write(path, settings:, material_model:, calibration_profile: nil, profile: FilamentProfile.default)
+    def write(
+      path, settings:, material_model:, tile_artifacts:, calibration_profile: nil,
+      profile: FilamentProfile.default
+    )
       materials = Palette::MATERIALS.select { |material| material_model.materials.include?(material) }
       names = materials.map { |material| profile_material(profile, material).name }
       assignments = materials.map do |material|
@@ -18,14 +21,15 @@ module Lithop
         This is #{calibration_profile ? "a measured-profile calibrated" : "an uncalibrated"} CMYW lithophane
         generated in millimetres.
 
-        - Open `lithop.3mf` for the physical color model; it contains: #{names.join(", ")}.
+        - #{model_instruction(tile_artifacts, names)}
         #{calibration_line(calibration_profile)}
         - Bambu Studio assignments encoded for this job: #{assignments.join(", ")}.
         - The model uses #{settings.color_layer_count} CMY/W color layers #{base_layer_description(settings)}.
         - The backlight-to-view color-layer order is #{settings.pigment_order.map(&:capitalize).join(" -> ")} -> White.
         - White thickness above the color region follows #{thickness_method(settings, calibration_profile)}.
+        #{z_part_line(settings)}
         - `preview.png` shows nominal recipe colors with relative thickness shading; it is not a colorimetric prediction.
-        - `transmission.png`, `thickness.png`, and the four material masks use the same cells as `lithop.3mf`.
+        - `transmission.png`, `thickness.png`, and the four material masks use the same cells as the 3MF output.
         - `cmyk_white.stl` is a separate monochrome reference model, not the color model.
         - Product: #{profile.product_url}
         - Guide: #{profile.reference_url}
@@ -38,6 +42,20 @@ module Lithop
       MARKDOWN
     end
 
+    def model_instruction(tile_artifacts, names)
+      return "Open `lithop.3mf` for the physical color model; it contains: #{names.join(", ")}." if tile_artifacts.one?
+
+      "Open the #{tile_artifacts.length} 3MF files under `tiles/` and assemble them using " \
+        "`tile-layout.svg` and `manifest.json`; together they contain: #{names.join(", ")}."
+    end
+
+    def z_part_line(settings)
+      return "- Z regions remain combined into the material parts." unless settings.separate_z_parts
+
+      "- Z regions use #{settings.color_region_parts + 1} plates: each CMYW color region includes " \
+        "a Base White carrier, followed by Top White; every plate starts at Z=0."
+    end
+
     def profile_material(profile, material)
       profile.materials.find { |candidate| candidate.channel == material }
     end
@@ -63,7 +81,7 @@ module Lithop
       "- Use a #{settings.nozzle_diameter} mm nozzle, #{settings.first_layer_height} mm base layers,\n  " \
         "#{settings.layer_height} mm color layers, and #{upper_height} mm upper White layers."
     end
-    private_class_method :profile_material, :calibration_line, :thickness_method,
+    private_class_method :model_instruction, :z_part_line, :profile_material, :calibration_line, :thickness_method,
                          :base_layer_description, :layer_height_description
   end
 end

data/lib/lithop/export/result.rb

@@ -1,13 +1,35 @@
 # frozen_string_literal: true
 
 module Lithop
+  TileArtifact = Data.define(:tile, :name, :three_mf, :material_model)
+
   ExportArtifacts = Data.define(
     :stl_name,
-    :three_mf_name,
+    :tile_artifacts,
     :stl_triangle_count,
-    :three_mf,
-    :material_model
-  )
+    :material_model,
+    :tile_layout
+  ) do
+    def three_mf_names = tile_artifacts.map(&:name)
+
+    def three_mf_name
+      three_mf_names.fetch(0) if three_mf_names.one?
+    end
+
+    def three_mf
+      results = tile_artifacts.map(&:three_mf)
+      counts = results.each_with_object(Hash.new(0)) do |result, totals|
+        result.triangle_counts_by_material.each { |material, count| totals[material] += count }
+      end
+      ThreeMF::Result.new(
+        vertex_count: results.sum(&:vertex_count),
+        triangle_count: results.sum(&:triangle_count),
+        material_count: counts.length,
+        object_count: results.sum(&:object_count),
+        triangle_counts_by_material: counts.freeze
+      )
+    end
+  end
 
   ExportResult = Data.define(
     :job_id,

data/lib/lithop/formats/three_mf/bambu_metadata.rb

@@ -4,14 +4,14 @@ require "json"
 
 module Lithop
   # Writes Bambu Studio material-assignment metadata into a 3MF package.
+  # rubocop:disable-next Metrics/ClassLength
   class ThreeMFBambuMetadata
     PATH = "Metadata/model_settings.config"
-    FIRST_MODEL_OBJECT_INDEX = 1
 
-    def initialize(archive:, assembly_id:, object_ids:, parts:, profile:, settings: nil)
+    def initialize(archive:, object_ids:, assemblies:, parts:, profile:, settings: nil)
       @archive = archive
-      @assembly_id = assembly_id
       @object_ids = object_ids
+      @assemblies = assemblies
       @parts = parts
       @profile = profile
       @settings = settings
@@ -20,61 +20,148 @@ module Lithop
     def write
       @archive.put_next_entry(PATH)
       @archive.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<config>\n")
-      @archive.write("  <object id=\"#{@assembly_id}\">\n")
-      @archive.write("    <metadata key=\"name\" value=\"Lithop CMYW lithophane\"/>\n")
+      @assemblies.each { |assembly| write_object(assembly) }
       if bambu_project?
-        @archive.write("    <metadata key=\"extruder\" value=\"1\"/>\n")
+        write_plates
+        write_assemble if separate_z_plates?
+      end
+      @archive.write("</config>\n")
+      write_project_entries if bambu_project?
+    end
+
+    private
+
+    def write_object(assembly)
+      @archive.write("  <object id=\"#{assembly.id}\">\n")
+      @archive.write("    <metadata key=\"name\" value=\"#{assembly.name}\"/>\n")
+      if bambu_project?
+        @archive.write("    <metadata key=\"extruder\" value=\"#{root_extruder(assembly)}\"/>\n")
         @archive.write("    <metadata key=\"layer_height\" value=\"#{@settings.layer_height}\"/>\n")
         @archive.write("    <metadata key=\"sparse_infill_density\" value=\"100%\"/>\n")
         @archive.write("    <metadata key=\"sparse_infill_pattern\" value=\"zig-zag\"/>\n")
       end
-      @object_ids.zip(@parts).each do |object_id, part|
-        write_part(object_id, part.material)
+      part_map = @object_ids.zip(@parts).to_h
+      assembly.object_ids.each_with_index do |object_id, volume_id|
+        part = part_map.fetch(object_id)
+        write_part(object_id, part, assembly, volume_id)
       end
       @archive.write("  </object>\n")
-      write_plate if bambu_project?
-      @archive.write("</config>\n")
-      write_project_entries if bambu_project?
     end
 
-    private
+    def root_extruder(assembly)
+      return 1 if @assemblies.one?
+
+      part_map = @object_ids.zip(@parts).to_h
+      material = part_map.fetch(assembly.object_ids.first).material
+      @profile.materials.index { |candidate| candidate.channel == material } + 1
+    end
 
-    def write_part(object_id, material)
+    def write_part(object_id, part, assembly, volume_id)
+      material = part.material
       profile_material = @profile.materials.find { |candidate| candidate.channel == material }
       extruder = @profile.materials.index(profile_material) + 1
-      @archive.write("    <part id=\"#{object_id}\" subtype=\"normal_part\">\n")
-      @archive.write("      <metadata key=\"name\" value=\"#{profile_material.name}\"/>\n")
+      uuid = separate_z_plates? ? %( uuid="#{part_uuid(object_id)}") : ""
+      @archive.write("    <part id=\"#{object_id}\" subtype=\"normal_part\"#{uuid}>\n")
+      @archive.write("      <metadata key=\"name\" value=\"#{part.name || profile_material.name}\"/>\n")
+      if separate_z_plates?
+        origin = assembly.component_origins.fetch(object_id)
+        @archive.write("      <metadata key=\"matrix\" value=\"#{matrix(origin)}\"/>\n")
+        @archive.write("      <metadata key=\"source_file\" value=\"lithop.3mf\"/>\n")
+        @archive.write("      <metadata key=\"source_object_id\" value=\"#{source_object_id(assembly)}\"/>\n")
+        @archive.write("      <metadata key=\"source_volume_id\" value=\"#{volume_id}\"/>\n")
+        @archive.write("      <metadata key=\"source_offset_x\" value=\"#{number(origin[0])}\"/>\n")
+        @archive.write("      <metadata key=\"source_offset_y\" value=\"#{number(origin[1])}\"/>\n")
+        source_z = number(origin[2] - part.build_z_offset)
+        @archive.write("      <metadata key=\"source_offset_z\" value=\"#{source_z}\"/>\n")
+      end
       @archive.write("      <metadata key=\"extruder\" value=\"#{extruder}\"/>\n")
       @archive.write("    </part>\n")
     end
 
     def bambu_project? = @settings&.bambu_project
 
-    def write_plate
-      @archive.write(<<~XML)
+    def part_uuid(object_id)
+      format("%08x-7f79-4c88-9311-43ae0fc671e7", object_id)
+    end
+
+    def write_plates
+      @assemblies.each_with_index { |assembly, index| write_plate(assembly, index + 1) }
+    end
+
+    def write_plate(assembly, plate_id)
+      name = @assemblies.one? ? "lithophane" : assembly.name
+      @archive.write(<<~XML.chomp)
         <plate>
-          <metadata key="plater_id" value="1"/>
-          <metadata key="plater_name" value="lithophane"/>
+          <metadata key="plater_id" value="#{plate_id}"/>
+          <metadata key="plater_name" value="#{name}"/>
           <metadata key="locked" value="false"/>
           <model_instance>
-            <metadata key="object_id" value="#{@assembly_id}"/>
+            <metadata key="object_id" value="#{assembly.id}"/>
             <metadata key="instance_id" value="0"/>
-          </model_instance>
-        </plate>
       XML
+      @archive.write("\n    <metadata key=\"identify_id\" value=\"#{identify_id(plate_id)}\"/>") if separate_z_plates?
+      @archive.write("\n  </model_instance>\n</plate>\n")
+    end
+
+    def write_assemble
+      @archive.write("<assemble>\n")
+      @assemblies.each do |assembly|
+        @archive.write(
+          "  <assemble_item object_id=\"#{assembly.id}\" instance_id=\"0\" " \
+          "transform=\"1 0 0 0 1 0 0 0 1 0 0 0\" offset=\"0 0 0\"/>\n"
+        )
+        assembly.object_ids.each_with_index do |object_id, volume_id|
+          transform = volume_transform(assembly.component_origins.fetch(object_id))
+          @archive.write(
+            "  <assemble_item object_id=\"#{assembly.id}\" volume_id=\"#{volume_id}\" " \
+            "transform=\"#{transform}\"/>\n"
+          )
+        end
+      end
+      @archive.write("</assemble>\n")
+    end
+
+    def separate_z_plates? = @settings&.separate_z_parts && @assemblies.length > 1
+
+    def identify_id(plate_id)
+      [218, 253, 276, 287].fetch(plate_id - 1, 287 + (plate_id * 32))
+    end
+
+    def volume_transform(origin)
+      "1 0 0 0 1 0 0 0 1 #{origin.map { |value| number(value) }.join(" ")}"
+    end
+
+    def matrix(origin)
+      "1 0 0 #{number(origin[0])} 0 1 0 #{number(origin[1])} 0 0 1 #{number(origin[2])} 0 0 0 1"
+    end
+
+    def source_object_id(assembly)
+      return 3 if assembly.region == "top_white"
+
+      assembly.region.delete_prefix("color_region_").to_i - 1
     end
 
+    def number(value) = format("%.9g", value)
+
     def write_project_entries
       write_entry("Metadata/layer_config_ranges.xml", layer_ranges_xml)
       write_entry("Metadata/project_settings.config", "#{JSON.pretty_generate(project_settings)}\n")
     end
 
     def layer_ranges_xml
+      object_id = @assemblies.length
+      min_z = @settings.top_white_start
+      max_z = @settings.maximum_thickness
+      if @settings.separate_z_parts
+        color_end = @settings.layer_structure.color_region_end
+        min_z = (min_z - color_end).round(9)
+        max_z = (max_z - color_end).round(9)
+      end
       <<~XML
         <?xml version="1.0" encoding="utf-8"?>
         <objects>
-          <object id="#{FIRST_MODEL_OBJECT_INDEX}">
-            <range min_z="#{@settings.top_white_start}" max_z="#{@settings.maximum_thickness}">
+          <object id="#{object_id}">
+            <range min_z="#{min_z}" max_z="#{max_z}">
               <option opt_key="extruder">4</option>
               <option opt_key="layer_height">#{@settings.top_layer_height}</option>
             </range>

data/lib/lithop/formats/three_mf/model_writer.rb

@@ -2,12 +2,18 @@
 
 module Lithop
   # Serializes model resources and build items into a 3MF model document.
+  # rubocop:disable-next Metrics/ClassLength
   class ThreeMFModelWriter
     CUSTOM_NAMESPACE = "https://github.com/ogom/lithop/3mf/v1"
+    BAMBU_STUDIO_NAMESPACE = "http://schemas.bambulab.com/package/2021"
+    BAMBU_STUDIO_APPLICATION = "BambuStudio-02.08.03.66"
+    PRODUCTION_NAMESPACE = "http://schemas.microsoft.com/3dmanufacturing/production/2015/06"
+    MODEL_PATH = "3D/3dmodel.model"
     BASE_MATERIALS_ID = 1
     COLOR_GROUP_ID = 2
     FIRST_OBJECT_ID = 3
     Result = Data.define(:vertex_count, :triangle_count, :triangle_counts_by_material)
+    Assembly = Data.define(:id, :name, :region, :object_ids, :component_origins)
 
     def initialize(archive, parts, profile, instrumentation: Instrumentation.new, settings: nil)
       @archive = archive
@@ -18,23 +24,20 @@ module Lithop
     end
 
     def write
+      object_ids = part_object_ids
+      assemblies = build_assemblies(object_ids)
+      return write_bambu_multi_plate(object_ids, assemblies) if bambu_multi_plate_project?
+
       measure_xml do
+        @archive.put_next_entry(MODEL_PATH)
         @archive.write(model_header)
         write_materials
       end
-      object_ids, result = write_parts
-      assembly_id = object_ids.max + 1
+      result = write_parts(object_ids)
       measure_xml do
-        write_assembly(assembly_id, object_ids)
-        @archive.write("  </resources>\n  <build>\n    <item objectid=\"#{assembly_id}\"/>\n  </build>\n</model>\n")
-        ThreeMFBambuMetadata.new(
-          archive: @archive,
-          assembly_id:,
-          object_ids:,
-          parts: @parts,
-          profile: @profile,
-          settings: @settings
-        ).write
+        assemblies.each { |assembly| write_assembly(assembly) }
+        write_build(assemblies)
+        write_bambu_metadata(object_ids, assemblies)
       end
       result
     end
@@ -49,42 +52,227 @@ module Lithop
       @archive.write("    </m:colorgroup>\n")
     end
 
-    def write_parts
+    def part_object_ids
+      return @parts.each_index.map { |index| index + FIRST_OBJECT_ID }.freeze unless bambu_multi_plate_project?
+
+      next_id = 1
+      @parts.group_by(&:region).values.flat_map do |parts|
+        ids = Array.new(parts.length) do
+          value = next_id
+          next_id += 1
+          value
+        end
+        next_id += 1
+        ids
+      end.freeze
+    end
+
+    def write_parts(object_ids)
       vertex_count = 0
       triangle_counts = {}
-      object_ids = @parts.each_with_index.map do |part, index|
-        object_id = index + FIRST_OBJECT_ID
+      object_ids.zip(@parts).each do |object_id, part|
         mesh = @instrumentation.measure(:three_mf_indexing) do
           ThreeMFMesh.new(triangles: part.triangles)
         end
         measure_xml do
-          ThreeMFPartWriter.new(archive: @archive, profile: @profile).write(object_id, part.material, mesh)
+          ThreeMFPartWriter.new(archive: @archive, profile: @profile).write(object_id, part, mesh)
         end
         part.triangles.release_cache! if part.triangles.respond_to?(:release_cache!)
         vertex_count += mesh.vertices.length
-        triangle_counts[part.material] = mesh.triangle_count
-        object_id
+        triangle_counts[part.material] = triangle_counts.fetch(part.material, 0) + mesh.triangle_count
       end
-      result = Result.new(
+      Result.new(
         vertex_count:,
         triangle_count: triangle_counts.values.sum,
         triangle_counts_by_material: triangle_counts.freeze
       )
-      [object_ids, result]
+    end
+
+    def write_bambu_multi_plate(object_ids, assemblies)
+      result = write_external_parts(object_ids, assemblies)
+      write_root_model(assemblies)
+      write_model_relationships(assemblies)
+      write_bambu_metadata(object_ids, assemblies)
+      result
+    end
+
+    # rubocop:disable-next Metrics/AbcSize
+    def write_external_parts(object_ids, assemblies)
+      parts_by_object_id = object_ids.zip(@parts).to_h
+      vertex_count = 0
+      triangle_counts = {}
+      assemblies.each_with_index do |assembly, index|
+        @archive.put_next_entry("3D/Objects/object_#{index + 1}.model")
+        measure_xml do
+          @archive.write(submodel_header)
+          write_materials
+          assembly.object_ids.each do |object_id|
+            part = parts_by_object_id.fetch(object_id)
+            mesh = @instrumentation.measure(:three_mf_indexing) do
+              ThreeMFMesh.new(triangles: part.triangles)
+            end
+            center = mesh_center(mesh)
+            assembly.component_origins[object_id] = component_origin(
+              center, assembly.component_origins.fetch(object_id)
+            )
+            ThreeMFPartWriter.new(
+              archive: @archive, profile: @profile, production: true, origin: center
+            ).write(object_id, part, mesh)
+            part.triangles.release_cache! if part.triangles.respond_to?(:release_cache!)
+            vertex_count += mesh.vertices.length
+            triangle_counts[part.material] = triangle_counts.fetch(part.material, 0) + mesh.triangle_count
+          end
+          @archive.write("  </resources>\n  <build/>\n</model>\n")
+        end
+      end
+      Result.new(
+        vertex_count:,
+        triangle_count: triangle_counts.values.sum,
+        triangle_counts_by_material: triangle_counts.freeze
+      )
+    end
+
+    def write_root_model(assemblies)
+      @archive.put_next_entry(MODEL_PATH)
+      measure_xml do
+        @archive.write(bambu_multi_plate_model_header)
+        assemblies.each_with_index { |assembly, index| write_assembly(assembly, index + 1) }
+        write_build(assemblies)
+      end
+    end
+
+    def write_model_relationships(assemblies)
+      @archive.put_next_entry("3D/_rels/3dmodel.model.rels")
+      @archive.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+      @archive.write("<Relationships xmlns=\"#{ThreeMF::RELATIONSHIP_NAMESPACE}\">\n")
+      assemblies.each_with_index do |_assembly, index|
+        @archive.write(
+          " <Relationship Target=\"/3D/Objects/object_#{index + 1}.model\" Id=\"rel-#{index + 1}\" " \
+          "Type=\"#{ThreeMF::MODEL_RELATIONSHIP}\"/>\n"
+        )
+      end
+      @archive.write("</Relationships>\n")
+    end
+
+    def write_bambu_metadata(object_ids, assemblies)
+      ThreeMFBambuMetadata.new(
+        archive: @archive,
+        object_ids:,
+        assemblies:,
+        parts: @parts,
+        profile: @profile,
+        settings: @settings
+      ).write
     end
 
     def measure_xml(&)
       @instrumentation.measure(:three_mf_xml_zip, &)
     end
 
-    def write_assembly(assembly_id, object_ids)
-      @archive.write("    <object id=\"#{assembly_id}\" type=\"model\" name=\"Lithop CMYW lithophane\">\n")
+    def build_assemblies(object_ids)
+      groups = if separate_z_plates?
+                 object_ids.zip(@parts).group_by { |_object_id, part| part.region }
+               else
+                 { nil => object_ids.zip(@parts) }
+               end
+      groups.map do |region, entries|
+        Assembly.new(
+          id: entries.map(&:first).max + 1,
+          name: assembly_name(region),
+          region:,
+          object_ids: entries.map(&:first).freeze,
+          component_origins: entries.to_h { |object_id, part| [object_id, [0.0, 0.0, part.build_z_offset]] }
+        )
+      end.freeze
+    end
+
+    def separate_z_plates?
+      @settings&.separate_z_parts && @parts.all?(&:region)
+    end
+
+    def bambu_multi_plate_project? = @settings&.bambu_project && separate_z_plates?
+
+    def assembly_name(region)
+      return "Lithop CMYW lithophane" unless region
+      return "Top White" if region == "top_white"
+
+      region.sub("color_region_", "Color region ")
+    end
+
+    def write_assembly(assembly, submodel_index = nil)
+      uuid = submodel_index ? production_uuid(assembly.id) : ""
+      @archive.write("    <object id=\"#{assembly.id}\"#{uuid} type=\"model\" name=\"#{assembly.name}\">\n")
       @archive.write("      <components>\n")
-      object_ids.each { |object_id| @archive.write("        <component objectid=\"#{object_id}\"/>\n") }
+      assembly.object_ids.each_with_index do |object_id, index|
+        transform = component_transform(assembly.component_origins.fetch(object_id))
+        path = submodel_index ? %( p:path="/3D/Objects/object_#{submodel_index}.model") : ""
+        uuid = submodel_index ? production_uuid((assembly.id * 1000) + index + 1) : ""
+        @archive.write("        <component#{path} objectid=\"#{object_id}\"#{uuid}#{transform}/>\n")
+      end
       @archive.write("      </components>\n    </object>\n")
     end
 
+    def component_transform(origin)
+      return "" if origin.all?(&:zero?)
+
+      %( transform="1 0 0 0 1 0 0 0 1 #{origin.map { |value| format_number(value) }.join(" ")}")
+    end
+
+    def format_number(number) = format("%.9g", number)
+
+    def write_build(assemblies)
+      @archive.write("  </resources>\n  <build>\n")
+      assemblies.each do |assembly|
+        attributes = if bambu_multi_plate_project?
+                       %(#{build_uuid(assembly.id)} transform="#{build_transform(assembly)}" printable="1")
+                     else
+                       ""
+                     end
+        @archive.write("    <item objectid=\"#{assembly.id}\"#{attributes}/>\n")
+      end
+      @archive.write("  </build>\n</model>\n")
+    end
+
+    def production_uuid(identifier)
+      %( p:UUID="#{format("%08x", identifier)}-61cb-4c03-9d28-80fed5dfa1dc")
+    end
+
+    def build_uuid(identifier)
+      %( p:UUID="#{format("%08x", identifier)}-b1ec-4553-aec9-835e5b724bb4")
+    end
+
+    def build_transform(assembly)
+      x, y = [
+        [48.0, 30.0],
+        [300.160253, 37.8003226],
+        [52.2484968, -205.366274],
+        [288.0, -210.0]
+      ].fetch(plate_index(assembly))
+      "1 0 0 0 1 0 0 0 1 #{format_number(x)} #{format_number(y)} 0"
+    end
+
+    def mesh_center(mesh)
+      axes = mesh.vertices.transpose
+      axes.map { |values| (values.min + values.max) / 2.0 }
+    end
+
+    def component_origin(center, base_origin)
+      [center[0], center[1], center[2] + base_origin[2]]
+    end
+
+    def plate_index(assembly)
+      return 3 if assembly.region == "top_white"
+
+      assembly.region.delete_prefix("color_region_").to_i - 1
+    end
+
     def model_header
+      return bambu_multi_plate_model_header if bambu_multi_plate_project?
+
+      inline_model_header
+    end
+
+    def inline_model_header
       <<~XML
         <?xml version="1.0" encoding="UTF-8"?>
         <model unit="millimeter" xml:lang="en-US" requiredextensions="m"
@@ -101,6 +289,40 @@ module Lithop
       XML
     end
 
+    def bambu_multi_plate_model_header
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <model unit="millimeter" xml:lang="en-US" requiredextensions="p"
+          xmlns="#{ThreeMF::CORE_NAMESPACE}"
+          xmlns:BambuStudio="#{BAMBU_STUDIO_NAMESPACE}"
+          xmlns:p="#{PRODUCTION_NAMESPACE}"
+          xmlns:lithop="#{CUSTOM_NAMESPACE}">
+          <metadata name="Title">Lithop CMYW lithophane</metadata>
+          <metadata name="Application">#{BAMBU_STUDIO_APPLICATION}</metadata>
+          <metadata name="BambuStudio:3mfVersion">1</metadata>
+          <metadata name="lithop:Application" preserve="1">Lithop #{Lithop::VERSION}</metadata>
+          <metadata name="Description">Physical CMY subtractive layers with variable White luminance thickness.</metadata>
+          <metadata name="lithop:FilamentBundle" preserve="1">#{@profile.name}</metadata>
+          <metadata name="lithop:FilamentProduct" preserve="1">#{@profile.product_url}</metadata>
+          <metadata name="lithop:PrintingGuide" preserve="1">#{@profile.reference_url}</metadata>
+          <resources>
+      XML
+    end
+
+    def submodel_header
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <model unit="millimeter" xml:lang="en-US" requiredextensions="m p"
+          xmlns="#{ThreeMF::CORE_NAMESPACE}"
+          xmlns:m="#{ThreeMF::MATERIAL_NAMESPACE}"
+          xmlns:BambuStudio="#{BAMBU_STUDIO_NAMESPACE}"
+          xmlns:p="#{PRODUCTION_NAMESPACE}"
+          xmlns:lithop="#{CUSTOM_NAMESPACE}">
+          <metadata name="BambuStudio:3mfVersion">1</metadata>
+          <resources>
+      XML
+    end
+
     def material_xml(material)
       name = "#{@profile.manufacturer} #{material.name} (#{material.color_code})"
       <<~XML

data/lib/lithop/formats/three_mf/part_writer.rb

@@ -3,18 +3,23 @@
 module Lithop
   # Serializes one indexed material mesh into a 3MF model document.
   class ThreeMFPartWriter
-    def initialize(archive:, profile:)
+    def initialize(archive:, profile:, production: false, origin: nil)
       @archive = archive
       @profile = profile
+      @production = production
+      @origin = origin || [0.0, 0.0, 0.0]
     end
 
-    def write(object_id, material, mesh)
+    def write(object_id, part, mesh)
+      material = part.material
       material_index = @profile.materials.index { |candidate| candidate.channel == material }
-      name = @profile.materials.fetch(material_index).name
+      name = part.name || @profile.materials.fetch(material_index).name
+      region = part.region ? " lithop:region=\"#{part.region}\"" : ""
+      uuid = @production ? %( p:UUID="00000000-0000-4000-8000-#{format("%012d", object_id)}") : ""
       @archive.write(
-        "    <object id=\"#{object_id}\" type=\"model\" name=\"#{name}\" " \
+        "    <object id=\"#{object_id}\"#{uuid} type=\"model\" name=\"#{name}\" " \
         "pid=\"#{ThreeMFModelWriter::COLOR_GROUP_ID}\" pindex=\"#{material_index}\" " \
-        "lithop:channel=\"#{material}\">\n"
+        "lithop:channel=\"#{material}\"#{region}>\n"
       )
       @archive.write("      <mesh>\n        <vertices>\n")
       write_vertices(mesh)
@@ -27,7 +32,10 @@ module Lithop
 
     def write_vertices(mesh)
       mesh.vertices.each do |x, y, z|
-        @archive.write("          <vertex x=\"#{number(x)}\" y=\"#{number(y)}\" z=\"#{number(z)}\"/>\n")
+        @archive.write(
+          "          <vertex x=\"#{number(x - @origin[0])}\" y=\"#{number(y - @origin[1])}\" " \
+          "z=\"#{number(z - @origin[2])}\"/>\n"
+        )
       end
     end