lithop 0.1.0 → 0.2.0

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.rb

@@ -44,7 +44,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}"
@@ -66,6 +67,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]

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,14 @@ 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)
 
-    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 +20,32 @@ 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")
+      tile_estimates = @instrumentation.measure(:triangle_planning) do
+        estimate_tiles(tile_layout, material_model, white_heights)
+      end
+      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
+      )
+      report_job_progress(:metadata_write, 95, "Writing job metadata")
       write_supporting_files(directory, source, job_id, artifacts)
       result_for(directory, artifacts)
     end
@@ -58,28 +72,102 @@ module Lithop
       ).call
     end
 
-    def write_artifacts(directory, geometry, material_model, mesh_plan, white_heights)
+    def estimate_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
+        )
+      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
+
+    def write_artifacts(directory, geometry, material_model, tile_layout, white_heights)
       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 = 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)
+        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,
+                                        settings: @settings
+          )
+        end
+        mesh_plan.validate!(three_mf)
+        TileArtifact.new(tile:, name:, three_mf:, material_model: tile_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:)
       end
       ExportArtifacts.new(
         stl_name:,
-        three_mf_name:,
+        tile_artifacts:,
         stl_triangle_count: triangle_count,
-        three_mf:,
-        material_model:
+        material_model:,
+        tile_layout:
       )
     end
 
@@ -91,27 +179,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,

data/lib/lithop/export/job.rb

@@ -15,35 +15,49 @@ module Lithop
     # rubocop:disable-next Metrics/ParameterLists
     def initialize(
       settings:, project_dir:, input_settings_path: nil, calibration: nil, progress: nil,
-      instrumentation: nil, clock: Time, random: SecureRandom
+      job_progress: nil, instrumentation: nil, clock: Time, random: SecureRandom, job_id: nil
     )
       @settings = settings
       @project_dir = File.expand_path(project_dir)
       @input_settings_path = input_settings_path
       @calibration = calibration
       @progress = progress
+      @job_progress = job_progress
       @clock = clock
       @random = random
-      @generation = ExportGeneration.new(
-        settings:, input_settings_path:, calibration:, progress:, instrumentation:
-      )
+      @instrumentation = instrumentation
+      @job_id = job_id
     end
 
     def call(input_path)
       source = File.expand_path(input_path)
-      job_id = "#{@clock.now.utc.strftime("%Y%m%dT%H%M%SZ")}-#{@random.hex(4)}"
-      destination, result = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
-        @generation.call(source:, directory:, job_id:)
-      end
-      Result.new(
-        job_id:,
-        path: destination,
-        files: result.files,
-        triangle_count: result.triangle_count,
-        three_mf_triangle_count: result.three_mf_triangle_count,
-        material_count: result.material_count,
-        object_count: result.object_count
+      job_id = @job_id || "#{@clock.now.utc.strftime("%Y%m%dT%H%M%SZ")}-#{@random.hex(4)}"
+      execution = JobExecution.new(
+        project_dir: @project_dir, job_id:, progress: @job_progress, clock: @clock
       )
+      execution.call do |job|
+        generation = ExportGeneration.new(
+          settings: @settings,
+          input_settings_path: @input_settings_path,
+          calibration: @calibration,
+          progress: @progress,
+          job_progress: job.method(:progress),
+          instrumentation: @instrumentation
+        )
+        destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
+          generation.call(source:, directory:, job_id:)
+        end
+        job.progress(phase: :publishing, percent: 99, message: "Artifacts published")
+        Result.new(
+          job_id:,
+          path: destination,
+          files: generated.files,
+          triangle_count: generated.triangle_count,
+          three_mf_triangle_count: generated.three_mf_triangle_count,
+          material_count: generated.material_count,
+          object_count: generated.object_count
+        )
+      end
     end
   end
 end

data/lib/lithop/export/metadata.rb

@@ -5,6 +5,7 @@ require "json"
 
 module Lithop
   # Builds and writes the resolved settings and export manifest.
+  # rubocop:disable-next Metrics/ClassLength
   class ExportMetadata
     def initialize(settings:, input_settings_path:, calibration:)
       @settings = settings
@@ -29,8 +30,8 @@ module Lithop
 
     private
 
+    # rubocop:disable-next Metrics/MethodLength
     def manifest_for(source, job_id, artifacts)
-      materials = material_names(used_materials(artifacts))
       {
         schema_version: 1,
         job_id:,
@@ -49,9 +50,21 @@ module Lithop
         },
         input_sha256: Digest::SHA256.file(source).hexdigest,
         filament_profile: FilamentProfile.default.to_h,
+        tile_layout: tile_layout_metadata(artifacts),
+        tiles: tile_metadata(artifacts),
         parts: [
           { file: artifacts.stl_name, material: "White", role: "monochrome_reference" },
-          { file: artifacts.three_mf_name, materials:, role: "cmyw_lithophane" }
+          *artifacts.tile_artifacts.map do |artifact|
+            tile_materials = Palette::MATERIALS.select do |material|
+              artifact.material_model.materials.include?(material)
+            end
+            {
+              file: artifact.name,
+              tile_id: artifact.tile.id,
+              materials: material_names(tile_materials),
+              role: artifacts.tile_artifacts.one? ? "cmyw_lithophane" : "cmyw_lithophane_tile"
+            }
+          end
         ],
         color_model: @color_metadata.call(artifacts),
         files: artifact_files(artifacts),
@@ -62,14 +75,46 @@ module Lithop
 
     def artifact_files(artifacts)
       files = [
-        artifacts.stl_name, artifacts.three_mf_name, "settings.json", "manifest.json",
+        artifacts.stl_name, *artifacts.three_mf_names, "settings.json", "manifest.json",
         "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
       files << "calibration-profile.json" if @calibration.profile
       files
     end
 
+    def tile_layout_metadata(artifacts)
+      {
+        requested: @settings.tile_layout,
+        tile_count: @settings.tile_count,
+        rows: artifacts.tile_layout.rows,
+        columns: artifacts.tile_layout.columns,
+        order: "left_to_right_then_top_to_bottom",
+        local_origin: "xy_min",
+        assembled_image_top: "+Y"
+      }
+    end
+
+    def tile_metadata(artifacts)
+      artifacts.tile_artifacts.map do |artifact|
+        tile = artifact.tile
+        used = Palette::MATERIALS.select { |material| artifact.material_model.materials.include?(material) }
+        {
+          id: tile.id,
+          file: artifact.name,
+          row: tile.row,
+          column: tile.column,
+          offset_mm: tile.offset,
+          bounds_mm: tile.bounds,
+          dimensions_mm: { width: tile.width, height: tile.height, depth: @settings.effective_maximum_thickness },
+          materials: material_names(used),
+          unused_materials: material_names(Palette::MATERIALS - used),
+          triangle_count: artifact.three_mf.triangle_count
+        }
+      end
+    end
+
     def used_materials(artifacts)
       Palette::MATERIALS.select { |material| artifacts.material_model.materials.include?(material) }
     end

data/lib/lithop/export/planning.rb

@@ -1,6 +1,103 @@
 # frozen_string_literal: true
 
 module Lithop
+  # Splits the reference White carrier and CMY pigments into closed Z-region parts.
+  class ZSeparatedMaterialMeshPlan
+    Entry = Data.define(:material, :geometry, :name, :region, :build_z_offset)
+
+    def initialize(model:, base_geometry:, top_geometry:, settings:, maximum_triangles:, limit_message:)
+      @model = model
+      @base_geometry = base_geometry
+      @top_geometry = top_geometry
+      @settings = settings
+      @maximum_triangles = maximum_triangles
+      @limit_message = limit_message
+    end
+
+    def call
+      entries = build_entries
+      entry_counts = entries.map { |entry| triangle_count(entry.geometry) }
+      total = entry_counts.sum
+      raise ConfigurationError, @limit_message.call(total) if total > @maximum_triangles
+
+      MaterialMeshPlan::Result.new(
+        parts: entries.map do |entry|
+          ThreeMF::Part.new(
+            material: entry.material, triangles: triangle_source(entry.geometry),
+            name: entry.name, region: entry.region, build_z_offset: entry.build_z_offset
+          )
+        end,
+        triangle_count: total,
+        triangle_counts_by_material: counts_by_material(entries, entry_counts)
+      )
+    end
+
+    private
+
+    def build_entries
+      entries = []
+      color_ranges.each_with_index do |range, index|
+        region_model = LayerRegionModel.new(model: @model, layer_range: range)
+        region = "color_region_#{index + 1}"
+        build_z_offset = @settings.layer_structure.base_white_thickness - region_model.z_boundaries.first
+        entries << Entry.new(
+          material: :white, geometry: @base_geometry, name: "Color region #{index + 1} Base White",
+          region:, build_z_offset: 0.0
+        )
+        entries << Entry.new(
+          material: :white,
+          geometry: color_region_white_geometry(region_model),
+          name: "Color region #{index + 1} White",
+          region:,
+          build_z_offset:
+        )
+        Palette::PIGMENTS.each do |material|
+          next unless region_model.materials.include?(material)
+
+          entries << Entry.new(
+            material:,
+            geometry: ColumnGeometry.new(model: region_model, material:),
+            name: "Color region #{index + 1} #{material.to_s.capitalize}",
+            region:,
+            build_z_offset:
+          )
+        end
+      end
+      entries << Entry.new(
+        material: :white, geometry: @top_geometry, name: "Top White",
+        region: "top_white", build_z_offset: -@settings.layer_structure.color_region_end
+      )
+      entries
+    end
+
+    def color_ranges
+      @settings.layer_structure.color_region_layer_ranges(@settings.color_region_parts)
+    end
+
+    def color_region_white_geometry(model)
+      BoxGeometry.new(
+        width: model.x_boundaries.last,
+        height: model.y_boundaries.last,
+        z_min: model.z_boundaries.first,
+        z_max: model.z_boundaries.last
+      )
+    end
+
+    def triangle_count(geometry)
+      geometry.respond_to?(:triangle_count) ? geometry.triangle_count : geometry.each_triangle.count
+    end
+
+    def triangle_source(geometry)
+      geometry.is_a?(ColumnGeometry) ? geometry : geometry.each_triangle
+    end
+
+    def counts_by_material(entries, entry_counts)
+      entries.zip(entry_counts).each_with_object(Hash.new(0)) do |(entry, count), totals|
+        totals[entry.material] += count
+      end.freeze
+    end
+  end
+
   # Builds the reference-style overlapping White height field and contiguous CMY columns.
   class ReferenceMaterialMeshPlan
     def initialize(model:, white_geometry:, maximum_triangles:, limit_message:)