lithop 0.2.0 → 0.3.0

data/ext/lithop_native/src/mesh.rs

@@ -0,0 +1,187 @@
+use crate::xml::{build_triangle_records, build_vertex_records};
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum VertexKey {
+    Coordinates([u64; COMPONENTS]),
+    Topology(i64),
+}
+
+#[derive(Default)]
+pub(crate) struct MeshData {
+    pub(crate) vertices: Vec<[f64; COMPONENTS]>,
+    pub(crate) triangles: Vec<[u32; COMPONENTS]>,
+    coordinate_indices: HashMap<[u64; COMPONENTS], u32>,
+    topology_indices: HashMap<i64, u32>,
+}
+
+#[magnus::wrap(class = "Lithop::Native::MeshBuilder", free_immediately, size)]
+pub(crate) struct MeshBuilder(RefCell<MeshData>);
+
+impl MeshBuilder {
+    pub(crate) fn new() -> Self {
+        Self(RefCell::new(MeshData::default()))
+    }
+
+    pub(crate) fn from_data(data: MeshData) -> Self {
+        Self(RefCell::new(data))
+    }
+
+    pub(crate) fn add_batch(
+        ruby: &Ruby,
+        rb_self: &Self,
+        coordinates: Vec<f64>,
+        topology_keys: Vec<i64>,
+    ) -> Result<usize, Error> {
+        if coordinates.len() % (COMPONENTS * COMPONENTS) != 0 {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh coordinates must contain complete triangles",
+            ));
+        }
+        if topology_keys.len() * COMPONENTS != coordinates.len() {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh topology key count must match its vertices",
+            ));
+        }
+        if coordinates.iter().any(|value| !value.is_finite()) {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF coordinates must be finite",
+            ));
+        }
+
+        let mut data = rb_self.0.borrow_mut();
+        let maximum_vertex_count = data.vertices.len().checked_add(topology_keys.len());
+        if maximum_vertex_count.is_none_or(|count| count > u32::MAX as usize) {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF mesh contains too many vertices",
+            ));
+        }
+        for (triangle_coordinates, triangle_keys) in coordinates
+            .chunks_exact(COMPONENTS * COMPONENTS)
+            .zip(topology_keys.chunks_exact(COMPONENTS))
+        {
+            let mut triangle = [0; COMPONENTS];
+            for vertex_offset in 0..COMPONENTS {
+                let start = vertex_offset * COMPONENTS;
+                let point = [
+                    triangle_coordinates[start],
+                    triangle_coordinates[start + 1],
+                    triangle_coordinates[start + 2],
+                ];
+                let key = vertex_key(point, triangle_keys[vertex_offset]);
+                triangle[vertex_offset] = index_mesh_vertex(&mut data, point, key);
+            }
+            data.triangles.push(triangle);
+        }
+        Ok(data.triangles.len())
+    }
+
+    pub(crate) fn vertex_count(&self) -> usize {
+        self.0.borrow().vertices.len()
+    }
+    pub(crate) fn triangle_count(&self) -> usize {
+        self.0.borrow().triangles.len()
+    }
+
+    pub(crate) fn center(&self) -> Vec<f64> {
+        let data = self.0.borrow();
+        let mut minimum = [f64::INFINITY; COMPONENTS];
+        let mut maximum = [f64::NEG_INFINITY; COMPONENTS];
+        for vertex in &data.vertices {
+            for axis in 0..COMPONENTS {
+                minimum[axis] = minimum[axis].min(vertex[axis]);
+                maximum[axis] = maximum[axis].max(vertex[axis]);
+            }
+        }
+        (0..COMPONENTS)
+            .map(|axis| (minimum[axis] + maximum[axis]) / 2.0)
+            .collect()
+    }
+
+    pub(crate) fn vertex_xml(
+        ruby: &Ruby,
+        rb_self: &Self,
+        offset: usize,
+        count: usize,
+        origin: Vec<f64>,
+    ) -> Result<String, Error> {
+        let data = rb_self.0.borrow();
+        let end = offset.saturating_add(count).min(data.vertices.len());
+        if offset > end {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF vertex offset is out of range",
+            ));
+        }
+        build_vertex_records(&data.vertices[offset..end], &origin)
+            .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+    }
+
+    pub(crate) fn triangle_xml(
+        ruby: &Ruby,
+        rb_self: &Self,
+        offset: usize,
+        count: usize,
+    ) -> Result<String, Error> {
+        let data = rb_self.0.borrow();
+        let end = offset.saturating_add(count).min(data.triangles.len());
+        if offset > end {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "3MF triangle offset is out of range",
+            ));
+        }
+        build_triangle_records(&data.triangles[offset..end])
+            .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+    }
+
+    pub(crate) fn memory_bytes(&self) -> usize {
+        let data = self.0.borrow();
+        data.vertices.capacity() * std::mem::size_of::<[f64; COMPONENTS]>()
+            + data.triangles.capacity() * std::mem::size_of::<[u32; COMPONENTS]>()
+            + data.coordinate_indices.capacity()
+                * (std::mem::size_of::<[u64; COMPONENTS]>() + std::mem::size_of::<u32>())
+            + data.topology_indices.capacity()
+                * (std::mem::size_of::<i64>() + std::mem::size_of::<u32>())
+    }
+}
+
+fn vertex_key(point: [f64; COMPONENTS], topology_key: i64) -> VertexKey {
+    if topology_key >= 0 {
+        VertexKey::Topology(topology_key)
+    } else {
+        VertexKey::Coordinates(point.map(|value| if value == 0.0 { 0 } else { value.to_bits() }))
+    }
+}
+
+pub(crate) fn index_mesh_vertex(
+    data: &mut MeshData,
+    point: [f64; COMPONENTS],
+    key: VertexKey,
+) -> u32 {
+    let existing = match key {
+        VertexKey::Coordinates(coordinates) => data.coordinate_indices.get(&coordinates),
+        VertexKey::Topology(topology) => data.topology_indices.get(&topology),
+    };
+    if let Some(index) = existing {
+        return *index;
+    }
+    let index = data.vertices.len() as u32;
+    data.vertices.push(point);
+    match key {
+        VertexKey::Coordinates(coordinates) => {
+            data.coordinate_indices.insert(coordinates, index);
+        }
+        VertexKey::Topology(topology) => {
+            data.topology_indices.insert(topology, index);
+        }
+    }
+    index
+}

data/ext/lithop_native/src/palette.rs

@@ -0,0 +1,67 @@
+use crate::COMPONENTS;
+use magnus::{Error, Ruby};
+
+fn select_palette_indices(cmys: &[f64], coverages: &[f64]) -> Result<Vec<usize>, &'static str> {
+    if cmys.len() % COMPONENTS != 0 {
+        return Err("CMY values must contain triples");
+    }
+    if coverages.is_empty() || coverages.len() % COMPONENTS != 0 {
+        return Err("recipe coverage must contain triples");
+    }
+    if cmys
+        .iter()
+        .any(|value| !value.is_finite() || !(0.0..=1.0).contains(value))
+    {
+        return Err("CMY values must be finite values between zero and one");
+    }
+
+    let recipes: Vec<&[f64]> = coverages.chunks_exact(COMPONENTS).collect();
+    let mut indices = Vec::with_capacity(cmys.len() / COMPONENTS);
+    for target in cmys.chunks_exact(COMPONENTS) {
+        let mut best_index = 0;
+        let mut best_distance = f64::INFINITY;
+        for (index, coverage) in recipes.iter().enumerate() {
+            let cyan = coverage[0] - target[0];
+            let magenta = coverage[1] - target[1];
+            let yellow = coverage[2] - target[2];
+            let distance = (cyan * cyan) + (magenta * magenta) + (yellow * yellow);
+            if distance < best_distance {
+                best_index = index;
+                best_distance = distance;
+            }
+        }
+        indices.push(best_index);
+    }
+    Ok(indices)
+}
+
+pub(crate) fn palette_indices(
+    ruby: &Ruby,
+    cmys: Vec<f64>,
+    coverages: Vec<f64>,
+) -> Result<Vec<usize>, Error> {
+    select_palette_indices(&cmys, &coverages)
+        .map_err(|message| Error::new(ruby.exception_arg_error(), message))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::select_palette_indices;
+
+    #[test]
+    fn selects_the_first_recipe_at_equal_distance() {
+        let indices =
+            select_palette_indices(&[0.5, 0.0, 0.0], &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]).unwrap();
+        assert_eq!(indices, vec![0]);
+    }
+
+    #[test]
+    fn selects_multiple_samples_in_one_call() {
+        let indices = select_palette_indices(
+            &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+            &[0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+        )
+        .unwrap();
+        assert_eq!(indices, vec![0, 1]);
+    }
+}

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/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)
@@ -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/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
 
@@ -135,32 +140,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 +177,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
 

data/lib/lithop/export/previews.rb

@@ -5,7 +5,7 @@ module Lithop
   module ExportPreviews
     module_function
 
-    def write(directory, model:, settings:, white_heights: nil)
+    def write(directory, model:, settings:, white_heights: nil, corrected_input: nil)
       heights = white_heights && cell_heights(white_heights, settings.columns, settings.rows)
       options = {
         model:,
@@ -19,8 +19,32 @@ module Lithop
       Palette::MATERIALS.each do |material|
         Preview.write_mask(File.join(directory, "#{material}-mask.png"), model:, material:)
       end
+      File.binwrite(File.join(directory, "corrected-input.png"), corrected_input) if corrected_input
     end
 
+    def write_tiles(directory, tile_artifacts:, settings:, white_heights:)
+      return if tile_artifacts.one?
+
+      heights = cell_heights(white_heights, settings.columns, settings.rows)
+      tile_artifacts.each do |artifact|
+        tile = artifact.tile
+        tile_heights = (tile.row_start...tile.row_end).flat_map do |row|
+          offset = (row * settings.columns) + tile.column_start
+          heights.slice(offset, artifact.material_model.columns)
+        end
+        Preview.write_material(
+          File.join(directory, tile_preview_name(artifact)),
+          model: artifact.material_model,
+          minimum: settings.effective_minimum_thickness,
+          maximum: settings.effective_maximum_thickness,
+          heights: tile_heights,
+          transmission_gamma: 0.5
+        )
+      end
+    end
+
+    def tile_preview_name(artifact) = artifact.name.sub(/\.3mf\z/, "-preview.png")
+
     def cell_heights(vertex_heights, columns, rows)
       stride = columns + 1
       Array.new(columns * rows) do |index|