lithop 0.1.0 → 0.3.0

data/ext/lithop_native/src/xml.rs

@@ -0,0 +1,134 @@
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+use std::fmt::Write;
+
+const NUMBER_FORMAT: &[u8] = b"%.9g\0";
+
+fn append_number(output: &mut String, value: f64) -> Result<(), &'static str> {
+    if !value.is_finite() {
+        return Err("3MF coordinates must be finite");
+    }
+
+    let mut buffer = [0_u8; 64];
+    let length = unsafe {
+        libc::snprintf(
+            buffer.as_mut_ptr().cast(),
+            buffer.len(),
+            NUMBER_FORMAT.as_ptr().cast(),
+            value,
+        )
+    };
+    if length < 0 || length as usize >= buffer.len() {
+        return Err("could not format a 3MF coordinate");
+    }
+    let formatted = std::str::from_utf8(&buffer[..length as usize])
+        .map_err(|_| "could not format a 3MF coordinate")?;
+    output.push_str(formatted);
+    Ok(())
+}
+
+fn build_vertex_xml(vertices: &[f64], origin: &[f64]) -> Result<String, &'static str> {
+    if vertices.len() % COMPONENTS != 0 {
+        return Err("3MF vertices must contain XYZ triples");
+    }
+    if origin.len() != COMPONENTS || origin.iter().any(|value| !value.is_finite()) {
+        return Err("3MF origin must contain three finite values");
+    }
+
+    let mut output = String::with_capacity((vertices.len() / COMPONENTS) * 72);
+    for vertex in vertices.chunks_exact(COMPONENTS) {
+        output.push_str("          <vertex x=\"");
+        append_number(&mut output, vertex[0] - origin[0])?;
+        output.push_str("\" y=\"");
+        append_number(&mut output, vertex[1] - origin[1])?;
+        output.push_str("\" z=\"");
+        append_number(&mut output, vertex[2] - origin[2])?;
+        output.push_str("\"/>\n");
+    }
+    Ok(output)
+}
+
+pub(crate) fn build_vertex_records(
+    vertices: &[[f64; COMPONENTS]],
+    origin: &[f64],
+) -> Result<String, &'static str> {
+    if origin.len() != COMPONENTS || origin.iter().any(|value| !value.is_finite()) {
+        return Err("3MF origin must contain three finite values");
+    }
+    let mut output = String::with_capacity(vertices.len() * 72);
+    for vertex in vertices {
+        output.push_str("          <vertex x=\"");
+        append_number(&mut output, vertex[0] - origin[0])?;
+        output.push_str("\" y=\"");
+        append_number(&mut output, vertex[1] - origin[1])?;
+        output.push_str("\" z=\"");
+        append_number(&mut output, vertex[2] - origin[2])?;
+        output.push_str("\"/>\n");
+    }
+    Ok(output)
+}
+
+pub(crate) fn vertex_xml(
+    ruby: &Ruby,
+    vertices: Vec<f64>,
+    origin: Vec<f64>,
+) -> Result<String, Error> {
+    build_vertex_xml(&vertices, &origin)
+        .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+}
+
+fn build_triangle_xml(indices: &[usize]) -> Result<String, &'static str> {
+    if indices.len() % COMPONENTS != 0 {
+        return Err("3MF triangle indices must contain triples");
+    }
+
+    let mut output = String::with_capacity((indices.len() / COMPONENTS) * 56);
+    for triangle in indices.chunks_exact(COMPONENTS) {
+        writeln!(
+            output,
+            "          <triangle v1=\"{}\" v2=\"{}\" v3=\"{}\"/>",
+            triangle[0], triangle[1], triangle[2]
+        )
+        .map_err(|_| "could not format 3MF triangle indices")?;
+    }
+    Ok(output)
+}
+
+pub(crate) fn build_triangle_records(
+    triangles: &[[u32; COMPONENTS]],
+) -> Result<String, &'static str> {
+    let mut output = String::with_capacity(triangles.len() * 56);
+    for triangle in triangles {
+        writeln!(
+            output,
+            "          <triangle v1=\"{}\" v2=\"{}\" v3=\"{}\"/>",
+            triangle[0], triangle[1], triangle[2]
+        )
+        .map_err(|_| "could not format 3MF triangle indices")?;
+    }
+    Ok(output)
+}
+
+pub(crate) fn triangle_xml(ruby: &Ruby, indices: Vec<usize>) -> Result<String, Error> {
+    build_triangle_xml(&indices).map_err(|message| Error::new(ruby.exception_arg_error(), message))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{build_triangle_xml, build_vertex_xml};
+
+    #[test]
+    fn formats_vertex_xml_with_ruby_compatible_precision() {
+        let xml = build_vertex_xml(&[1.2345678912, 2.0, 3.0], &[1.0, 0.0, 0.5]).unwrap();
+        assert_eq!(
+            xml,
+            "          <vertex x=\"0.234567891\" y=\"2\" z=\"2.5\"/>\n"
+        );
+    }
+
+    #[test]
+    fn formats_triangle_xml() {
+        let xml = build_triangle_xml(&[12, 3, 45]).unwrap();
+        assert_eq!(xml, "          <triangle v1=\"12\" v2=\"3\" v3=\"45\"/>\n");
+    }
+}

data/lib/lithop/calibration/export.rb

@@ -10,34 +10,47 @@ module Lithop
     class Export
       Result = Data.define(:job_id, :path, :files, :triangle_count, :patch_count)
 
-      def initialize(settings:, project_dir:, clock: Time, random: SecureRandom)
+      def initialize(
+        settings:, project_dir:, job_progress: nil, clock: Time, random: SecureRandom, job_id: nil
+      )
         @settings = settings
         @project_dir = File.expand_path(project_dir)
         @clock = clock
         @random = random
+        @job_progress = job_progress
+        @job_id = job_id
       end
 
       def call
-        job_id = "#{@clock.now.utc.strftime("%Y%m%dT%H%M%SZ")}-#{@random.hex(4)}-calibration"
-        destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
-          generate(directory, job_id)
+        job_id = @job_id || "#{@clock.now.utc.strftime("%Y%m%dT%H%M%SZ")}-#{@random.hex(4)}-calibration"
+        execution = JobExecution.new(
+          project_dir: @project_dir, job_id:, progress: @job_progress, clock: @clock
+        )
+        execution.call do |job|
+          destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
+            generate(directory, job_id, job).tap { job.checkpoint! }
+          end
+          job.publication_committed!(message: "Calibration artifacts published")
+          Result.new(job_id:, path: destination, files: generated.fetch(:files),
+                     triangle_count: generated.fetch(:triangle_count), patch_count: generated.fetch(:patch_count))
         end
-        Result.new(job_id:, path: destination, files: generated.fetch(:files),
-                   triangle_count: generated.fetch(:triangle_count), patch_count: generated.fetch(:patch_count))
       end
 
       private
 
-      def generate(directory, job_id)
+      def generate(directory, job_id, job)
+        job.progress(phase: :calibration_planning, percent: 10, message: "Planning calibration target")
         target = Target.new(settings: @settings)
+        job.progress(phase: :three_mf_write, percent: 35, message: "Writing calibration 3MF")
         result = write_three_mf(File.join(directory, "calibration.3mf"), target)
+        job.progress(phase: :supporting_files, percent: 80, message: "Writing calibration files")
         TargetSVG.write(File.join(directory, "calibration.svg"), target)
         profile = Profile.template(profile_id: job_id, settings: @settings, target:)
         profile.write(File.join(directory, "calibration-profile.json"))
         write_manifest(directory, job_id, target, result)
         write_readme(directory, target)
         {
-          files: Dir.children(directory).sort,
+          files: Dir.children(directory).reject { |name| name == JobDirectory::OWNER_FILE }.sort,
           triangle_count: result.triangle_count,
           patch_count: target.patches.length
         }

data/lib/lithop/cli/calibration.rb

@@ -17,7 +17,9 @@ module Lithop
       raise OptionParser::InvalidArgument, arguments.join(" ") unless arguments.empty?
 
       project_dir, settings, = load_settings(options, keys: CALIBRATION_SETTING_KEYS)
-      result = Calibration::Export.new(settings:, project_dir:).call
+      result = Calibration::Export.new(
+        settings:, project_dir:, job_progress: method(:report_job_progress)
+      ).call
       @out.puts "Generated #{result.patch_count} calibration patches and #{result.triangle_count} 3MF triangles"
       @out.puts "in #{result.path}"
       result.files.each { |file| @out.puts "  #{file}" }

data/lib/lithop/cli/image_options.rb

@@ -7,8 +7,10 @@ module Lithop
 
     def add(parser, options)
       add_dimensions(parser, options)
+      add_tiles(parser, options)
       add_margins(parser, options)
       add_placement(parser, options)
+      add_adjustments(parser, options)
       add_thickness(parser, options)
       add_sampling(parser, options)
     end
@@ -17,11 +19,35 @@ module Lithop
       parser.on("--layout-profile NAME", "Layout profile: standard") do |value|
         options[:layout_profile] = value
       end
-      parser.on("--width MM", Float, "Model width (default: 130)") { |value| options[:width] = value }
-      parser.on("--height MM", Float, "Model height (default: 100)") { |value| options[:height] = value }
+      parser.on("--width MM", Float, "Model width (default: #{Settings::DEFAULTS.fetch(:width)})") do |value|
+        options[:width] = value
+      end
+      parser.on("--height MM", Float, "Model height (default: #{Settings::DEFAULTS.fetch(:height)})") do |value|
+        options[:height] = value
+      end
     end
     private_class_method :add_dimensions
 
+    def add_tiles(parser, options)
+      parser.on("--tile-count COUNT", Integer, "Number of 3MF tiles (default: 1)") do |value|
+        options[:tile_count] = value
+      end
+      parser.on("--tile-layout MODE", "Tile layout: auto/columns/rows/grid (default: auto)") do |value|
+        options[:tile_layout] = value.downcase
+      end
+      parser.on("--tile-rows COUNT", Integer, "Tile rows for grid layout") { |value| options[:tile_rows] = value }
+      parser.on("--tile-columns COUNT", Integer, "Tile columns for grid layout") do |value|
+        options[:tile_columns] = value
+      end
+      parser.on("--separate-z-parts", "Put base White, color regions, and top White on separate plates") do
+        options[:separate_z_parts] = true
+      end
+      parser.on("--color-region-parts COUNT", Integer, "Number of CMYW color-region Z parts (default: 3)") do |value|
+        options[:color_region_parts] = value
+      end
+    end
+    private_class_method :add_tiles
+
     def add_margins(parser, options)
       parser.on("--margin-top MM", Float, "Top margin (default: 0)") { |value| options[:margin_top] = value }
       parser.on("--margin-right MM", Float, "Right margin (default: 0)") { |value| options[:margin_right] = value }
@@ -46,6 +72,19 @@ module Lithop
     end
     private_class_method :add_placement
 
+    def add_adjustments(parser, options)
+      parser.on("--brightness PERCENT", Float, "Brightness: -100..100 (default: 0)") do |value|
+        options[:brightness] = value
+      end
+      parser.on("--contrast PERCENT", Float, "Contrast: -100..100 (default: 0)") do |value|
+        options[:contrast] = value
+      end
+      parser.on("--saturation PERCENT", Float, "Saturation: -100..100 (default: 0)") do |value|
+        options[:saturation] = value
+      end
+    end
+    private_class_method :add_adjustments
+
     def add_thickness(parser, options)
       parser.on("--min-thickness MM", Float, "Requested minimum model thickness (default: 1.0)") do |value|
         options[:minimum_thickness] = value

data/lib/lithop/cli/options.rb

@@ -48,6 +48,19 @@ module Lithop
       end
     end
 
+    def ui(options, out)
+      OptionParser.new do |parser|
+        parser.banner = "Usage: lithop ui [--project-dir DIR] [--port PORT]"
+        parser.on("--project-dir DIR", "Project directory containing config/ and build/") do |value|
+          options[:project_dir] = value
+        end
+        parser.on("--port PORT", Integer, "Local UI port (default: 4567)") do |value|
+          options[:port] = value
+        end
+        add_information(parser, out)
+      end
+    end
+
     def add_print_settings(parser, options)
       parser.on("--first-layer-height MM", Float, "First layer height (default: 0.1)") do |value|
         options[:first_layer_height] = value

data/lib/lithop/cli.rb

@@ -2,9 +2,11 @@
 
 require "optparse"
 require "fileutils"
+require "json"
 
 module Lithop
   # Command-line interface for generating and cleaning lithophane projects.
+  # rubocop:disable-next Metrics/ClassLength
   class CLI
     include CLICalibration
 
@@ -18,9 +20,12 @@ module Lithop
       @cwd = File.expand_path(cwd)
     end
 
+    # rubocop:disable-next Metrics/AbcSize
     def run(argv)
       return clean(argv.drop(1)) if argv.first == "clean"
       return calibrate(argv.drop(1)) if argv.first == "calibrate"
+      return web_ui(argv.drop(1)) if argv.first == "ui"
+      return diagnostics(argv.drop(1)) if argv.first == "doctor"
 
       options = {}
       parser = CLIOptions.generation(options, @out)
@@ -44,7 +49,8 @@ module Lithop
         project_dir:,
         input_settings_path: settings_path,
         calibration:,
-        progress: method(:report_estimate)
+        progress: method(:report_estimate),
+        job_progress: method(:report_job_progress)
       ).call(input)
       @out.puts "Generated #{result.triangle_count} STL and #{result.three_mf_triangle_count} CMYW 3MF triangles"
       @out.puts "in #{result.path}"
@@ -57,6 +63,13 @@ module Lithop
 
     private
 
+    def diagnostics(arguments)
+      raise InputError, "doctor does not accept arguments" unless arguments.empty?
+
+      @out.puts JSON.pretty_generate(Native.diagnostics)
+      0
+    end
+
     def report_estimate(estimate)
       @out.puts(
         "Estimated #{estimate.stl_triangle_count} STL and " \
@@ -66,6 +79,12 @@ module Lithop
       @out.puts "  CMYW by material: #{counts}"
     end
 
+    def report_job_progress(progress)
+      return unless progress.state == "running" && progress.percent.positive?
+
+      @out.puts "Progress #{progress.percent.round}%: #{progress.message}"
+    end
+
     def load_settings(options, keys: nil)
       resolved = CLISettings.new(cwd: @cwd).call(options, keys:)
       [resolved.project_dir, resolved.settings, resolved.input_settings_path]
@@ -98,5 +117,21 @@ module Lithop
     end
 
     def report_missing_build(build_dir) = 0.tap { @out.puts "No build directory: #{build_dir}" }
+
+    def web_ui(argv)
+      options = {}
+      parser = CLIOptions.ui(options, @out)
+      arguments = parser.parse(argv)
+      raise OptionParser::InvalidArgument, arguments.join(" ") unless arguments.empty?
+
+      project_dir = File.expand_path(options.fetch(:project_dir, @cwd), @cwd)
+      port = options.fetch(:port, 4567)
+      raise OptionParser::InvalidArgument, "port must be from 1 to 65535" unless port.between?(1, 65_535)
+
+      require_relative "web/server"
+      @out.puts "Lithop Local UI: http://127.0.0.1:#{port}"
+      Web::Server.run(project_dir:, port:)
+      0
+    end
   end
 end

data/lib/lithop/export/color_metadata.rb

@@ -2,6 +2,7 @@
 
 module Lithop
   # Builds the color-model portion of an export manifest.
+  # rubocop:disable-next Metrics/ClassLength
   class ExportColorMetadata
     def initialize(settings:, calibration:)
       @settings = settings
@@ -12,6 +13,7 @@ module Lithop
     def call(artifacts)
       {
         file: artifacts.three_mf_name,
+        files: artifacts.three_mf_names,
         format: "3MF",
         property: "3MF color group and Bambu Studio part extruder assignments",
         calibration: @calibration.metadata,
@@ -23,6 +25,7 @@ module Lithop
         layout_profile: @settings.layout_profile,
         base_white_layers: @settings.base_white_layers,
         minimum_top_white_layers: @settings.minimum_top_white_layers,
+        z_part_separation: z_part_separation,
         thickness_mm: thickness_structure,
         physical_material_layers_encoded: true,
         bambu_studio_material_assignments_encoded: true,
@@ -63,6 +66,58 @@ module Lithop
       }
     end
 
+    def z_part_separation
+      structure = @settings.layer_structure
+      boundaries = structure.z_boundaries(@settings.base_white_layers + @settings.color_layer_count)
+      color_regions = structure.color_region_layer_ranges(@settings.color_region_parts)
+                               .each_with_index.map do |range, index|
+        {
+          id: "color_region_#{index + 1}",
+          layer_start: range.begin - @settings.base_white_layers + 1,
+          layer_end: range.end - @settings.base_white_layers,
+          z_min: boundaries.fetch(range.begin),
+          z_max: boundaries.fetch(range.end)
+        }
+      end
+      metadata = {
+        enabled: @settings.separate_z_parts,
+        base_white: { id: "base_white", z_min: 0.0, z_max: structure.base_white_thickness },
+        color_regions:,
+        top_white: {
+          id: "top_white", z_min: structure.color_region_end,
+          z_max: @settings.effective_maximum_thickness
+        }
+      }
+      metadata[:plates] = z_plates(metadata) if @settings.separate_z_parts
+      metadata
+    end
+
+    def z_plates(metadata)
+      base_white = metadata.fetch(:base_white)
+      regions = metadata.fetch(:color_regions).map do |region|
+        region.merge(z_min: base_white.fetch(:z_min), build_z_max: region.fetch(:z_max))
+      end
+      regions << metadata.fetch(:top_white)
+      regions.each_with_index.map do |region, index|
+        z_min = region.fetch(:z_min)
+        z_max = region.fetch(:z_max)
+        {
+          plate_id: index + 1,
+          name: plate_name(region.fetch(:id)),
+          source_z_min: z_min,
+          source_z_max: z_max,
+          build_z_min: 0.0,
+          build_z_max: (region[:build_z_max] || (z_max - z_min)).round(9)
+        }
+      end
+    end
+
+    def plate_name(id)
+      return "Top White" if id == "top_white"
+
+      id.sub("color_region_", "Color region ")
+    end
+
     def used_materials(artifacts)
       Palette::MATERIALS.select { |material| artifacts.material_model.materials.include?(material) }
     end

data/lib/lithop/export/generation.rb

@@ -5,12 +5,15 @@ module Lithop
   # rubocop:disable-next Metrics/ClassLength
   class ExportGeneration
     Result = Data.define(:files, :triangle_count, :three_mf_triangle_count, :material_count, :object_count)
+    TileEstimate = Data.define(:triangle_count, :triangle_counts_by_material)
+    PlannedTile = Data.define(:tile, :material_model, :mesh_plan, :estimate)
 
-    def initialize(settings:, input_settings_path:, calibration:, progress:, instrumentation:)
+    def initialize(settings:, input_settings_path:, calibration:, progress:, job_progress:, instrumentation:)
       @settings = settings
       @input_settings_path = input_settings_path
       @calibration_context = ExportCalibration.new(settings:, input: calibration)
       @progress = progress
+      @job_progress = job_progress
       @instrumentation = Instrumentation.new(instrumentation)
       @metadata = ExportMetadata.new(
         settings:, input_settings_path:, calibration: @calibration_context
@@ -18,20 +21,33 @@ module Lithop
     end
 
     def call(source:, directory:, job_id:)
+      report_job_progress(:image_processing, 5, "Processing input image")
       image = @instrumentation.measure(:image_processing) { ImagePipeline.new(@settings).call(source) }
+      report_job_progress(:height_selection, 20, "Selecting White heights")
       white_heights = @instrumentation.measure(:height_selection) do
         @calibration_context.heights(image.white_densities)
       end
       geometry = white_geometry(white_heights)
+      report_job_progress(:material_model, 30, "Building CMYW material model")
       material_model = @instrumentation.measure(:material_model) do
         MaterialModel.new(
           cmys: image.cmys, cell_cmys: image.color_cells,
           heights: white_heights, settings: @settings, palette: @calibration_context.palette
         )
       end
-      mesh_plan = @instrumentation.measure(:triangle_planning) { material_mesh_plan(material_model, geometry) }
-      report_estimate(mesh_plan)
-      artifacts = write_artifacts(directory, geometry, material_model, mesh_plan, white_heights)
+      tile_layout = TileLayout.new(@settings)
+      report_job_progress(:triangle_planning, 40, "Planning mesh triangles")
+      planned_tiles = @instrumentation.measure(:triangle_planning) do
+        plan_tiles(tile_layout, material_model, white_heights)
+      end
+      tile_estimates = planned_tiles.map(&:estimate)
+      validate_total_triangle_count!(tile_estimates)
+      report_estimate(tile_estimates)
+      report_job_progress(:artifact_write, 50, "Writing model artifacts")
+      artifacts = write_artifacts(
+        directory, geometry, material_model, tile_layout, planned_tiles, white_heights, image.corrected_preview_png
+      )
+      report_job_progress(:metadata_write, 95, "Writing job metadata")
       write_supporting_files(directory, source, job_id, artifacts)
       result_for(directory, artifacts)
     end
@@ -58,31 +74,116 @@ module Lithop
       ).call
     end
 
-    def write_artifacts(directory, geometry, material_model, mesh_plan, white_heights)
+    def plan_tiles(tile_layout, material_model, white_heights)
+      tile_layout.tiles.map do |tile|
+        tile_model, mesh_plan = @instrumentation.measure(:tile_plan_estimate) do
+          build_tile_plan(tile, material_model, white_heights)
+        end
+        estimate = TileEstimate.new(
+          triangle_count: mesh_plan.triangle_count,
+          triangle_counts_by_material: mesh_plan.triangle_counts_by_material
+        )
+        PlannedTile.new(tile:, material_model: tile_model, mesh_plan:, estimate:)
+      end
+    end
+
+    def build_tile_plan(tile, material_model, white_heights)
+      tile_model = TileMaterialModel.new(model: material_model, tile:)
+      plan = if @settings.separate_z_parts
+               top_geometry = tile_white_geometry(
+                 tile, tile_model, white_heights,
+                 base_height: @settings.layer_structure.color_region_end
+               )
+               z_separated_material_mesh_plan(tile_model, top_geometry)
+             else
+               geometry = tile_white_geometry(tile, tile_model, white_heights)
+               material_mesh_plan(tile_model, geometry)
+             end
+      [tile_model, plan]
+    end
+
+    def tile_white_geometry(tile, model, heights, base_height: 0.0)
+      stride = @settings.columns + 1
+      sliced_heights = (tile.row_start..tile.row_end).flat_map do |row|
+        heights.slice((row * stride) + tile.column_start, model.columns + 1)
+      end
+      Geometry.new(
+        heights: sliced_heights,
+        columns: model.columns,
+        rows: model.rows,
+        x_boundaries: model.x_boundaries,
+        y_boundaries: model.y_boundaries,
+        optimize_bottom: true,
+        base_height:
+      )
+    end
+
+    def z_separated_material_mesh_plan(model, top_geometry)
+      base_height = @settings.layer_structure.base_white_thickness
+      base_geometry = BoxGeometry.new(
+        width: model.x_boundaries.last,
+        height: model.y_boundaries.last,
+        z_min: 0.0,
+        z_max: base_height
+      )
+      ZSeparatedMaterialMeshPlan.new(
+        model:, base_geometry:, top_geometry:, settings: @settings,
+        maximum_triangles: @settings.maximum_triangles,
+        limit_message: ->(count) { @settings.triangle_limit_message("physical Z-separated CMYW mesh", count) }
+      ).call
+    end
+
+    def validate_total_triangle_count!(tile_estimates)
+      count = tile_estimates.sum(&:triangle_count)
+      return if count <= @settings.maximum_triangles
+
+      raise ConfigurationError, @settings.triangle_limit_message("physical CMYW tiled mesh", count)
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists
+    def write_artifacts(directory, geometry, material_model, tile_layout, planned_tiles, white_heights, corrected_input)
       stl_name = "cmyk_white.stl"
       triangle_count = @instrumentation.measure(:stl_write) do
         STL.write(File.join(directory, stl_name), geometry.each_triangle)
       end
-      three_mf_name = "lithop.3mf"
-      three_mf = @instrumentation.measure(:three_mf_write) do
-        ThreeMF.write(
-          File.join(directory, three_mf_name), parts: mesh_plan.parts, instrumentation: @instrumentation,
-                                               settings: @settings
-        )
+      FileUtils.mkdir_p(File.join(directory, "tiles")) if tile_layout.tiles.length > 1
+      tile_artifacts = planned_tiles.each_with_index.map do |planned, index|
+        tile = planned.tile
+        percent = 60 + ((index * 20.0) / planned_tiles.length)
+        report_job_progress(:three_mf_write, percent, "Writing 3MF tile #{index + 1}/#{planned_tiles.length}")
+        name = tile_layout.tiles.one? ? "lithop.3mf" : "tiles/#{tile.id}.3mf"
+        three_mf = @instrumentation.measure(:three_mf_write) do
+          ThreeMF.write(
+            File.join(directory, name), parts: planned.mesh_plan.parts, instrumentation: @instrumentation,
+                                        settings: @settings
+          )
+        end
+        planned.mesh_plan.validate!(three_mf)
+        TileArtifact.new(tile:, name:, three_mf:, material_model: planned.material_model)
+      end
+      if tile_layout.tiles.length > 1
+        TileLayoutSVG.write(File.join(directory, "tile-layout.svg"), settings: @settings, layout: tile_layout)
       end
-      mesh_plan.validate!(three_mf)
+      report_job_progress(:preview_write, 85, "Writing previews")
       @instrumentation.measure(:preview_write) do
-        ExportPreviews.write(directory, model: material_model, settings: @settings, white_heights:)
+        write_previews(directory, material_model, tile_artifacts, white_heights, corrected_input)
       end
       ExportArtifacts.new(
         stl_name:,
-        three_mf_name:,
+        tile_artifacts:,
         stl_triangle_count: triangle_count,
-        three_mf:,
-        material_model:
+        material_model:,
+        tile_layout:
       )
     end
 
+    def write_previews(directory, material_model, tile_artifacts, white_heights, corrected_input)
+      ExportPreviews.write(
+        directory, model: material_model, settings: @settings, white_heights:, corrected_input:
+      )
+      ExportPreviews.write_tiles(directory, tile_artifacts:, settings: @settings, white_heights:)
+    end
+
     def write_supporting_files(directory, source, job_id, artifacts)
       @instrumentation.measure(:metadata_write) do
         @calibration_context.write(directory)
@@ -91,27 +192,36 @@ module Lithop
           File.join(directory, "PRINT_README.md"),
           settings: @settings,
           material_model: artifacts.material_model,
-          calibration_profile: @calibration_context.profile
+          calibration_profile: @calibration_context.profile,
+          tile_artifacts: artifacts.tile_artifacts
         )
       end
     end
 
-    def report_estimate(plan)
+    def report_estimate(tile_estimates)
       return unless @progress
 
+      counts = tile_estimates.each_with_object(Hash.new(0)) do |estimate, totals|
+        estimate.triangle_counts_by_material.each { |material, count| totals[material] += count }
+      end
+
       @progress.call(
         Export::Estimate.new(
           stl_triangle_count: @settings.estimated_triangles,
-          three_mf_triangle_count: plan.triangle_count,
-          triangle_counts_by_material: plan.triangle_counts_by_material
+          three_mf_triangle_count: tile_estimates.sum(&:triangle_count),
+          triangle_counts_by_material: counts.freeze
         )
       )
     end
 
+    def report_job_progress(phase, percent, message)
+      @job_progress&.call(phase:, percent:, message:)
+    end
+
     def result_for(directory, artifacts)
       three_mf = artifacts.three_mf
       Result.new(
-        files: Dir.children(directory).sort,
+        files: Dir.glob("**/*", base: directory).select { |name| File.file?(File.join(directory, name)) }.sort,
         triangle_count: artifacts.stl_triangle_count,
         three_mf_triangle_count: three_mf.triangle_count,
         material_count: three_mf.material_count,