lithop 0.2.0 → 0.4.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

@@ -28,9 +28,9 @@ module Lithop
         )
         execution.call do |job|
           destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
-            generate(directory, job_id, job)
+            generate(directory, job_id, job).tap { job.checkpoint! }
           end
-          job.progress(phase: :publishing, percent: 99, message: "Calibration artifacts published")
+          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

data/lib/lithop/calibration/target.rb

@@ -7,12 +7,12 @@ module Lithop
       private
 
       def validate_structure!
-        unless @settings.color_layer_count == 7 &&
-               @settings.pigment_order == Palette::PIGMENTS
-          raise ConfigurationError,
-                "calibration target requires seven layers in cyan,magenta,yellow pigment order"
-        end
+        return validate_white_levels! if @settings.color_layer_count == 7
+
+        raise ConfigurationError, "calibration target requires seven color layers"
+      end
 
+      def validate_white_levels!
         levels = @settings.layer_structure.normal_layer_count(@settings.effective_maximum_thickness) -
                  @settings.layer_structure.normal_layer_count(@settings.effective_minimum_thickness) + 1
         return if levels >= Target::WHITE_STAGE_COUNT

data/lib/lithop/cli/image_adjustment_options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Adds sRGB, pale-color, and Yellow transmission adjustments.
+  module CLIImageAdjustmentOptions
+    module_function
+
+    def add(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
+      parser.on("--suppress-pale-colors", "Convert very pale colors to White") do
+        options[:suppress_pale_colors] = true
+      end
+      parser.on("--no-suppress-pale-colors", "Keep very pale colors as CMY candidates (default)") do
+        options[:suppress_pale_colors] = false
+      end
+      parser.on("--yellow-mix-color COLOR", "Pigment mixed into Yellow: cyan/magenta (default: cyan)") do |value|
+        options[:yellow_mix_color] = value.downcase
+      end
+      parser.on(
+        "--yellow-mix-percent PERCENT", Float,
+        "Yellow coverage replaced by mix pigment: 0..100 (default: 0)"
+      ) { |value| options[:yellow_mix_percent] = value }
+    end
+  end
+end

data/lib/lithop/cli/image_options.rb

@@ -10,7 +10,7 @@ module Lithop
       add_tiles(parser, options)
       add_margins(parser, options)
       add_placement(parser, options)
-      add_adjustments(parser, options)
+      CLIImageAdjustmentOptions.add(parser, options)
       add_thickness(parser, options)
       add_sampling(parser, options)
     end
@@ -39,10 +39,10 @@ module Lithop
       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
+      parser.on("--separate-z-parts", "Slice the complete model into contiguous Z 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|
+      parser.on("--color-region-parts COUNT", Integer, "Z plate count (1-3); thinnest plate is 0.34 mm") do |value|
         options[:color_region_parts] = value
       end
     end
@@ -72,24 +72,11 @@ 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|
+      parser.on("--min-thickness MM", Float, "Requested minimum model thickness (default: 0.74)") do |value|
         options[:minimum_thickness] = value
       end
-      parser.on("--max-thickness MM", Float, "Requested maximum model thickness (default: 2.14689422)") do |value|
+      parser.on("--max-thickness MM", Float, "Requested maximum model thickness (default: 1.94)") do |value|
         options[:maximum_thickness] = value
       end
     end

data/lib/lithop/cli/options.rb

@@ -36,10 +36,10 @@ module Lithop
     def calibration(options, out)
       OptionParser.new do |parser|
         parser.banner = "Usage: lithop calibrate [options]"
-        parser.on("--min-thickness MM", Float, "Requested minimum thickness (default: 1.0)") do |value|
+        parser.on("--min-thickness MM", Float, "Requested minimum thickness (default: 0.74)") do |value|
           options[:minimum_thickness] = value
         end
-        parser.on("--max-thickness MM", Float, "Requested maximum thickness (default: 2.14689422)") do |value|
+        parser.on("--max-thickness MM", Float, "Requested maximum thickness (default: 1.94)") do |value|
           options[:maximum_thickness] = value
         end
         add_print_settings(parser, options)
@@ -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
@@ -61,10 +74,10 @@ module Lithop
       parser.on("--color-model MODEL", "Color model (default: cmy)") do |value|
         options[:color_model] = value.downcase
       end
-      parser.on("--color-layer-count COUNT", Integer, "CMY/W color layers: 4/5/7 (default: 7)") do |value|
+      parser.on("--color-layer-count COUNT", Integer, "CMY/W color layers: 4/5/7/8 (default: 7; Z split: 8)") do |value|
         options[:color_layer_count] = value
       end
-      parser.on("--pigment-order LIST", "Pigment order, e.g. cyan,magenta,yellow") do |value|
+      parser.on("--pigment-order LIST", "Pigment order, e.g. yellow,magenta,cyan (default: YMC)") do |value|
         options[:pigment_order] = value
       end
     end

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)
@@ -58,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 " \
@@ -105,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

@@ -68,20 +68,31 @@ module Lithop
 
     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|
+      color_regions = @settings.resolved_z_color_ranges.each_with_index.filter_map do |range, index|
+        next unless range.begin < range.end
+
         {
-          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)
+          id: "z_part_#{index + 1}",
+          z_min: range.begin,
+          z_max: range.end
         }
       end
       metadata = {
         enabled: @settings.separate_z_parts,
-        base_white: { id: "base_white", z_min: 0.0, z_max: structure.base_white_thickness },
+        requested_parts: @settings.color_region_parts,
+        resolved_parts: @settings.resolved_z_part_count,
+        minimum_source_plate_thickness: Settings::MINIMUM_Z_PART_THICKNESS,
+        minimum_plate_thickness: @settings.z_part_minimum_build_thickness,
+        adjusted_minimum_total_thickness: @settings.z_separated_output_minimum_thickness,
+        base_white: {
+          id: "base_white", included: true,
+          layers_per_plate: base_white_layers_per_plate,
+          thickness_per_plate: base_white_thickness_per_plate,
+          repeated_per_plate: true
+        },
+        source_base_white: {
+          id: "source_base_white", included: false, z_min: 0.0, z_max: structure.base_white_thickness
+        },
         color_regions:,
         top_white: {
           id: "top_white", z_min: structure.color_region_end,
@@ -92,30 +103,42 @@ module Lithop
       metadata
     end
 
+    def base_white_layers_per_plate
+      return Settings::Z_PART_BASE_WHITE_LAYERS unless @settings.separate_z_parts
+
+      @settings.z_part_base_white_layers_by_plate
+    end
+
+    def base_white_thickness_per_plate
+      return @settings.z_part_base_white_thickness unless @settings.separate_z_parts
+
+      @settings.z_part_base_white_thicknesses
+    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)
+      top_white = metadata.fetch(:top_white)
+      ranges = @settings.resolved_z_part_ranges
+      ranges.each_with_index.map do |range, index|
+        z_min = range.begin
+        z_max = index == ranges.length - 1 ? top_white.fetch(:z_max) : range.end
         {
           plate_id: index + 1,
-          name: plate_name(region.fetch(:id)),
+          name: "Z plate #{index + 1}",
           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)
+          build_z_max: (z_max - z_min + @settings.z_part_base_white_thickness(index)).round(9),
+          minimum_build_thickness: minimum_plate_build_thickness(range, index),
+          base_white_layers: @settings.z_part_base_white_layers(index),
+          base_white_thickness: @settings.z_part_base_white_thickness(index)
         }
       end
     end
 
-    def plate_name(id)
-      return "Top White" if id == "top_white"
-
-      id.sub("color_region_", "Color region ")
+    def minimum_plate_build_thickness(range, index)
+      source_end = [range.end, @settings.effective_minimum_thickness].min
+      source_thickness = [source_end - range.begin, 0.0].max
+      (source_thickness + @settings.z_part_base_white_thickness(index)).round(9)
     end
 
     def used_materials(artifacts)

data/lib/lithop/export/generation.rb

@@ -6,6 +6,7 @@ module Lithop
   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:, job_progress:, instrumentation:)
       @settings = settings
@@ -36,14 +37,15 @@ module Lithop
       end
       tile_layout = TileLayout.new(@settings)
       report_job_progress(:triangle_planning, 40, "Planning mesh triangles")
-      tile_estimates = @instrumentation.measure(:triangle_planning) do
-        estimate_tiles(tile_layout, material_model, white_heights)
+      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, white_heights
+        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)
@@ -72,13 +74,16 @@ module Lithop
       ).call
     end
 
-    def estimate_tiles(tile_layout, material_model, white_heights)
+    def plan_tiles(tile_layout, material_model, white_heights)
       tile_layout.tiles.map do |tile|
-        _tile_model, plan = build_tile_plan(tile, material_model, white_heights)
-        TileEstimate.new(
-          triangle_count: plan.triangle_count,
-          triangle_counts_by_material: plan.triangle_counts_by_material
+        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
 
@@ -87,7 +92,11 @@ module Lithop
       plan = if @settings.separate_z_parts
                top_geometry = tile_white_geometry(
                  tile, tile_model, white_heights,
-                 base_height: @settings.layer_structure.color_region_end
+                 base_height: [
+                   @settings.layer_structure.color_region_end,
+                   @settings.resolved_z_part_ranges.last.begin
+                 ].max,
+                 minimum_height: @settings.effective_minimum_thickness
                )
                z_separated_material_mesh_plan(tile_model, top_geometry)
              else
@@ -97,11 +106,12 @@ module Lithop
       [tile_model, plan]
     end
 
-    def tile_white_geometry(tile, model, heights, base_height: 0.0)
+    def tile_white_geometry(tile, model, heights, base_height: 0.0, minimum_height: nil)
       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
+      sliced_heights.map! { |height| [height, minimum_height].max } if minimum_height
       Geometry.new(
         heights: sliced_heights,
         columns: model.columns,
@@ -114,15 +124,8 @@ module Lithop
     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,
+        model:, top_geometry:, settings: @settings,
         maximum_triangles: @settings.maximum_triangles,
         limit_message: ->(count) { @settings.triangle_limit_message("physical Z-separated CMYW mesh", count) }
       ).call
@@ -135,32 +138,33 @@ module Lithop
       raise ConfigurationError, @settings.triangle_limit_message("physical CMYW tiled mesh", count)
     end
 
-    def write_artifacts(directory, geometry, material_model, tile_layout, white_heights)
+    # 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
       FileUtils.mkdir_p(File.join(directory, "tiles")) if tile_layout.tiles.length > 1
-      tile_artifacts = tile_layout.tiles.each_with_index.map do |tile, index|
-        percent = 60 + ((index * 20.0) / tile_layout.tiles.length)
-        report_job_progress(:three_mf_write, percent, "Writing 3MF tile #{index + 1}/#{tile_layout.tiles.length}")
-        tile_model, mesh_plan = build_tile_plan(tile, material_model, white_heights)
+      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: mesh_plan.parts, instrumentation: @instrumentation,
+            File.join(directory, name), parts: planned.mesh_plan.parts, instrumentation: @instrumentation,
                                         settings: @settings
           )
         end
-        mesh_plan.validate!(three_mf)
-        TileArtifact.new(tile:, name:, three_mf:, material_model: tile_model)
+        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
       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:,
@@ -171,6 +175,13 @@ module Lithop
       )
     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)

data/lib/lithop/export/job.rb

@@ -45,9 +45,9 @@ module Lithop
           instrumentation: @instrumentation
         )
         destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
-          generation.call(source:, directory:, job_id:)
+          generation.call(source:, directory:, job_id:).tap { job.checkpoint! }
         end
-        job.progress(phase: :publishing, percent: 99, message: "Artifacts published")
+        job.publication_committed!
         Result.new(
           job_id:,
           path: destination,

data/lib/lithop/export/metadata.rb

@@ -76,10 +76,13 @@ module Lithop
     def artifact_files(artifacts)
       files = [
         artifacts.stl_name, *artifacts.three_mf_names, "settings.json", "manifest.json",
-        "preview.png", "transmission.png", "thickness.png",
+        "corrected-input.png", "preview.png", "transmission.png", "thickness.png",
         *Palette::MATERIALS.map { |material| "#{material}-mask.png" }, "PRINT_README.md"
       ]
-      files << "tile-layout.svg" if artifacts.tile_artifacts.length > 1
+      if artifacts.tile_artifacts.length > 1
+        files.concat(artifacts.tile_artifacts.map { |artifact| ExportPreviews.tile_preview_name(artifact) })
+        files << "tile-layout.svg"
+      end
       files << "calibration-profile.json" if @calibration.profile
       files
     end
@@ -100,7 +103,7 @@ module Lithop
       artifacts.tile_artifacts.map do |artifact|
         tile = artifact.tile
         used = Palette::MATERIALS.select { |material| artifact.material_model.materials.include?(material) }
-        {
+        metadata = {
           id: tile.id,
           file: artifact.name,
           row: tile.row,
@@ -112,6 +115,8 @@ module Lithop
           unused_materials: material_names(Palette::MATERIALS - used),
           triangle_count: artifact.three_mf.triangle_count
         }
+        metadata[:preview_file] = ExportPreviews.tile_preview_name(artifact) unless artifacts.tile_artifacts.one?
+        metadata
       end
     end