lithop 0.3.0 → 0.4.0

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

@@ -92,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
@@ -102,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,
@@ -119,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

data/lib/lithop/export/planning.rb

@@ -1,13 +1,33 @@
 # frozen_string_literal: true
 
 module Lithop
-  # Splits the reference White carrier and CMY pigments into closed Z-region parts.
+  # Shared mesh counting and conversion helpers for export plans.
+  module MaterialMeshPlanningHelpers
+    private
+
+    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
+
+  # Slices the CMYW model into contiguous plates over strength-adjusted White supports.
   class ZSeparatedMaterialMeshPlan
+    include MaterialMeshPlanningHelpers
+
     Entry = Data.define(:material, :geometry, :name, :region, :build_z_offset)
 
-    def initialize(model:, base_geometry:, top_geometry:, settings:, maximum_triangles:, limit_message:)
+    def initialize(model:, top_geometry:, settings:, maximum_triangles:, limit_message:)
       @model = model
-      @base_geometry = base_geometry
       @top_geometry = top_geometry
       @settings = settings
       @maximum_triangles = maximum_triangles
@@ -36,42 +56,73 @@ module Lithop
 
     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
-        )
+      plate_ranges.each_with_index do |plate_range, index|
+        region = "z_part_#{index + 1}"
+        source_z_min = plate_range.begin
+        build_z_offset = @settings.z_part_base_white_thickness(index) - source_z_min
+        append_base_white_entry(entries, index:, region:)
+        append_color_entries(entries, index:, region:, build_z_offset:)
+        append_top_white_entry(entries, index:, plate_range:, region:, build_z_offset:)
+      end
+      entries
+    end
+
+    def append_base_white_entry(entries, index:, region:)
+      range = 0.0...@settings.z_part_base_white_thickness(index)
+      entries << Entry.new(
+        material: :white, geometry: box_geometry(range),
+        name: "Z plate #{index + 1} Base White", region:, build_z_offset: 0.0
+      )
+    end
+
+    def append_color_entries(entries, index:, region:, build_z_offset:)
+      range = color_ranges.fetch(index)
+      return unless range.begin < range.end
+
+      region_model = ZRegionModel.new(model: @model, z_range: range)
+      entries << Entry.new(
+        material: :white, geometry: color_region_white_geometry(region_model),
+        name: "Z plate #{index + 1} White", region:, build_z_offset:
+      )
+      Palette::PIGMENTS.each do |material|
+        next unless region_model.materials.include?(material)
+
         entries << Entry.new(
-          material: :white,
-          geometry: color_region_white_geometry(region_model),
-          name: "Color region #{index + 1} White",
-          region:,
-          build_z_offset:
+          material:, geometry: ColumnGeometry.new(model: region_model, material:),
+          name: "Z plate #{index + 1} #{material.to_s.capitalize}", 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
+    end
+
+    def append_top_white_entry(entries, index:, plate_range:, region:, build_z_offset:)
+      top_start = @settings.layer_structure.color_region_end
+      range = intersection(plate_range, top_start...@settings.z_separated_source_end)
+      return unless range
+
+      geometry = index == plate_ranges.length - 1 ? @top_geometry : box_geometry(range)
       entries << Entry.new(
-        material: :white, geometry: @top_geometry, name: "Top White",
-        region: "top_white", build_z_offset: -@settings.layer_structure.color_region_end
+        material: :white, geometry:, name: "Z plate #{index + 1} Top White",
+        region:, build_z_offset:
       )
-      entries
     end
 
     def color_ranges
-      @settings.layer_structure.color_region_layer_ranges(@settings.color_region_parts)
+      @settings.resolved_z_color_ranges
+    end
+
+    def plate_ranges = @settings.resolved_z_part_ranges
+
+    def intersection(left, right)
+      start = [left.begin, right.begin].max
+      finish = [left.end, right.end].min
+      start < finish ? start...finish : nil
+    end
+
+    def box_geometry(range)
+      BoxGeometry.new(
+        width: @model.x_boundaries.last, height: @model.y_boundaries.last,
+        z_min: range.begin, z_max: range.end
+      )
     end
 
     def color_region_white_geometry(model)
@@ -82,20 +133,6 @@ module Lithop
         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.

data/lib/lithop/export/print_readme.rb

@@ -38,7 +38,7 @@ module Lithop
         - White thickness uses #{settings.pixel_size} mm XY cells; CMYW recipes use
           #{settings.effective_color_pixel_size} mm color cells.
         - Use 100% rectilinear infill and verify every layer in the slicer before printing.
-        - The effective thickness range is #{settings.effective_minimum_thickness}–#{settings.effective_maximum_thickness} mm.
+        - The effective thickness range is #{output_minimum_thickness(settings)}–#{output_maximum_thickness(settings)} mm.
       MARKDOWN
     end
 
@@ -52,8 +52,23 @@ module Lithop
     def z_part_line(settings)
       return "- Z regions remain combined into the material parts." unless settings.separate_z_parts
 
-      "- Z regions use #{settings.color_region_parts + 1} plates: each CMYW color region includes " \
-        "a Base White carrier, followed by Top White; every plate starts at Z=0."
+      "- The separated model uses #{settings.resolved_z_part_count} contiguous Z plates with Base White " \
+        "supports of #{settings.z_part_base_white_layers_by_plate.join("/")} layers " \
+        "(#{settings.z_part_base_white_thicknesses.join("/")} mm); every plate is at least " \
+        "#{settings.z_part_minimum_build_thickness} mm thick. The assembled thickness range is " \
+        "#{settings.z_separated_output_minimum_thickness}–#{settings.z_separated_output_maximum_thickness} mm."
+    end
+
+    def output_minimum_thickness(settings)
+      return settings.effective_minimum_thickness unless settings.separate_z_parts
+
+      settings.z_separated_output_minimum_thickness
+    end
+
+    def output_maximum_thickness(settings)
+      return settings.effective_maximum_thickness unless settings.separate_z_parts
+
+      settings.z_separated_output_maximum_thickness
     end
 
     def profile_material(profile, material)
@@ -81,7 +96,8 @@ module Lithop
       "- Use a #{settings.nozzle_diameter} mm nozzle, #{settings.first_layer_height} mm base layers,\n  " \
         "#{settings.layer_height} mm color layers, and #{upper_height} mm upper White layers."
     end
-    private_class_method :model_instruction, :z_part_line, :profile_material, :calibration_line, :thickness_method,
+    private_class_method :model_instruction, :z_part_line, :output_minimum_thickness, :profile_material,
+                         :calibration_line, :thickness_method,
                          :base_layer_description, :layer_height_description
   end
 end

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

@@ -136,9 +136,7 @@ module Lithop
     end
 
     def source_object_id(assembly)
-      return 3 if assembly.region == "top_white"
-
-      assembly.region.delete_prefix("color_region_").to_i - 1
+      assembly.region.delete_prefix("z_part_").to_i - 1
     end
 
     def number(value) = format("%.9g", value)
@@ -150,12 +148,13 @@ module Lithop
 
     def layer_ranges_xml
       object_id = @assemblies.length
-      min_z = @settings.top_white_start
-      max_z = @settings.maximum_thickness
+      min_z = @settings.layer_structure.top_white_start
+      max_z = @settings.effective_maximum_thickness
       if @settings.separate_z_parts
-        color_end = @settings.layer_structure.color_region_end
-        min_z = (min_z - color_end).round(9)
-        max_z = (max_z - color_end).round(9)
+        source_z_min = last_plate_source_z_min
+        base_white = @settings.z_part_base_white_thickness(@settings.resolved_z_part_count - 1)
+        min_z = (min_z - source_z_min + base_white).round(9)
+        max_z = (max_z - source_z_min + base_white).round(9)
       end
       <<~XML
         <?xml version="1.0" encoding="utf-8"?>
@@ -170,6 +169,10 @@ module Lithop
       XML
     end
 
+    def last_plate_source_z_min
+      @settings.resolved_z_part_ranges.last.begin
+    end
+
     def project_settings
       {
         "filament_colour" => %w[#0086D6 #EC008C #FCE300 #FFFFFF],

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

@@ -198,9 +198,8 @@ module Lithop
 
     def assembly_name(region)
       return "Lithop CMYW lithophane" unless region
-      return "Top White" if region == "top_white"
 
-      region.sub("color_region_", "Color region ")
+      region.sub("z_part_", "Z plate ")
     end
 
     def write_assembly(assembly, submodel_index = nil)
@@ -264,9 +263,7 @@ module Lithop
     end
 
     def plate_index(assembly)
-      return 3 if assembly.region == "top_white"
-
-      assembly.region.delete_prefix("color_region_").to_i - 1
+      assembly.region.delete_prefix("z_part_").to_i - 1
     end
 
     def model_header

data/lib/lithop/image/pipeline.rb

@@ -5,13 +5,13 @@ module Lithop
   # rubocop:disable-next Metrics/ClassLength
   class ImagePipeline
     REFERENCE_WHITE_MAXIMUM_DENSITY = 0.04
-    REFERENCE_WHITE_MAXIMUM_CHROMA = 0.08
     REFERENCE_DARK_MAXIMUM_VALUE = 0.75
     REFERENCE_NEUTRAL_MAXIMUM_CHROMA = 0.25
     REFERENCE_BROWN_LINE_CMY_COVERAGE = 1.0 / 7
     Result = Data.define(
       :width, :height, :cmys, :cmy_densities, :white_densities, :color_cells, :corrected_preview_png
     )
+    LoadedImage = Data.define(:image, :material_display)
 
     def initialize(settings)
       @settings = settings
@@ -23,13 +23,14 @@ module Lithop
       require "vips"
 
       access = @settings.color_pixel_size ? :random : :sequential
-      image = normalized_image(path, access:)
+      loaded = normalized_image(path, access:)
+      image = loaded.image
       sampled = @placement.call(image, @settings.sampling_grid).cast(:uchar).copy_memory
 
       rgbs = rgb_components(sampled)
-      color_samples = rgbs.map { |rgb| color_sample(rgb) }
+      color_samples = rgbs.map { |rgb| color_sample(rgb, material_display: loaded.material_display) }
       result_color_cells = if @settings.color_pixel_size
-                             color_cells(image)
+                             color_cells(image, material_display: loaded.material_display)
                            else
                              standard_color_cells(color_samples, @settings.columns, @settings.rows)
                            end
@@ -38,7 +39,7 @@ module Lithop
         height: sampled.height,
         cmys: color_samples.map(&:first),
         cmy_densities: color_samples.map(&:last),
-        white_densities: rgbs.map { |rgb| white_density(rgb) },
+        white_densities: rgbs.map { |rgb| white_density(rgb, material_display: loaded.material_display) },
         color_cells: result_color_cells,
         corrected_preview_png: sampled.write_to_buffer(".png")
       )
@@ -52,8 +53,8 @@ module Lithop
       require "vips"
 
       grid = preview_grid(maximum_width:, maximum_height:)
-      image = normalized_image(path, access: :sequential, sampling_grids: [grid])
-      @placement.call(image, grid).cast(:uchar).write_to_buffer(".png")
+      loaded = normalized_image(path, access: :sequential, sampling_grids: [grid])
+      @placement.call(loaded.image, grid).cast(:uchar).write_to_buffer(".png")
     rescue SystemCallError, Vips::Error => e
       raise InputError, "could not read image: #{e.message}"
     end
@@ -61,19 +62,24 @@ module Lithop
     private
 
     def normalized_image(path, access:, sampling_grids: nil)
-      image = load_image(path, access:, sampling_grids:)
+      loaded = load_image(path, access:, sampling_grids:)
+      image = loaded.image
       image = image.autorot
       validate_input!(image)
       image = image.flatten(background: [255, 255, 255]) if image.has_alpha?
-      adjust_image(to_srgb(image))
+      LoadedImage.new(image: adjust_image(to_srgb(image)), material_display: loaded.material_display)
     end
 
     def load_image(path, access:, sampling_grids: nil)
       signature = File.binread(path, 8)
       raster = signature.start_with?("\xFF\xD8\xFF".b) || signature.start_with?("\x89PNG\r\n\x1A\n".b)
-      return Vips::Image.new_from_file(path.to_s, access:) if raster
+      if raster
+        image = Vips::Image.new_from_file(path.to_s, access:)
+        return LoadedImage.new(image:, material_display: false)
+      end
 
-      @svg_loader.call(path, access:, sampling_grids:)
+      result = @svg_loader.call(path, access:, sampling_grids:)
+      LoadedImage.new(image: result.image, material_display: result.material_display)
     end
 
     def preview_grid(maximum_width:, maximum_height:)
@@ -128,12 +134,12 @@ module Lithop
       [@settings.brightness, @settings.contrast, @settings.saturation]
     end
 
-    def color_cells(image)
+    def color_cells(image, material_display:)
       return if @settings.color_pixel_size.nil?
 
       grid = @settings.color_sampling_grid
       sampled = @placement.call(image, grid).cast(:uchar)
-      samples = rgb_components(sampled).map { |rgb| color_sample(rgb) }
+      samples = rgb_components(sampled).map { |rgb| color_sample(rgb, material_display:) }
       coarse_cells = standard_color_cells(samples, grid.columns, grid.rows)
       expand_color_cells(coarse_cells, grid)
     end
@@ -153,7 +159,7 @@ module Lithop
 
         density = samples.sum(&:last).fdiv(samples.length)
         cmy = samples.map(&:first).transpose.map { |components| components.sum.fdiv(components.length) }
-        next [0.0, 0.0, 0.0] if standard_white?(density, cmy)
+        next [0.0, 0.0, 0.0] if standard_white?(density)
 
         cmy
       end
@@ -190,16 +196,28 @@ module Lithop
       end
     end
 
-    def color_sample(rgb)
-      display_sample = FilamentProfile.display_sample(rgb)
-      return [display_sample.cmy, display_sample.density] if display_sample
+    def color_sample(rgb, material_display:)
+      display_sample = FilamentProfile.display_sample(rgb, mixtures: material_display)
+      return [mix_yellow(display_sample.cmy), display_sample.density] if display_sample
 
       maximum = rgb.max
-      cmy = standard_cmy(rgb, maximum)
+      cmy = mix_yellow(standard_cmy(rgb, maximum))
       density = rgb.sum { |component| 1.0 - component }.fdiv(3)
       [cmy, density]
     end
 
+    def mix_yellow(cmy)
+      ratio = @settings.yellow_mix_percent.fdiv(100)
+      return cmy if ratio.zero? || cmy.fetch(2).zero?
+
+      mixed = cmy.dup
+      replacement = mixed.fetch(2) * ratio
+      mixed[2] -= replacement
+      index = @settings.yellow_mix_color == "cyan" ? 0 : 1
+      mixed[index] = [mixed.fetch(index) + replacement, 1.0].min
+      mixed
+    end
+
     def standard_cmy(rgb, maximum)
       chroma = rgb.map { |component| maximum - component }
       return chroma unless maximum <= REFERENCE_DARK_MAXIMUM_VALUE &&
@@ -212,20 +230,16 @@ module Lithop
       cmy.all? { |component| (component - REFERENCE_BROWN_LINE_CMY_COVERAGE).abs < 1e-12 }
     end
 
-    def standard_white?(density, cmy)
-      return false if density > REFERENCE_WHITE_MAXIMUM_DENSITY
-
-      pale_yellow = cmy.fetch(2) == cmy.max && cmy.fetch(2) > REFERENCE_WHITE_MAXIMUM_CHROMA &&
-                    cmy.fetch(0) <= 0.05
-      !pale_yellow
+    def standard_white?(density)
+      @settings.suppress_pale_colors && density <= REFERENCE_WHITE_MAXIMUM_DENSITY
     end
 
     def rec601_density(rgb)
       1.0 - rgb.zip([0.299, 0.587, 0.114]).sum { |component, weight| component * weight }
     end
 
-    def white_density(rgb)
-      FilamentProfile.display_sample(rgb)&.density || rec601_density(rgb)
+    def white_density(rgb, material_display:)
+      FilamentProfile.display_sample(rgb, mixtures: material_display)&.density || rec601_density(rgb)
     end
   end
 end

data/lib/lithop/image/svg_loader.rb

@@ -6,6 +6,8 @@ require "rexml/xpath"
 module Lithop
   # Applies the self-contained, static subset accepted for SVG input.
   class SVGDocumentValidator
+    MATERIAL_DISPLAY_ATTRIBUTE = "data-lithop-color-encoding"
+    MATERIAL_DISPLAY_VALUE = "material-display"
     FORBIDDEN_ELEMENTS = %w[script foreignobject animate animatemotion animatetransform set].freeze
     LENGTH = /\A\+?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:px|mm|in)?\z/i
     NUMBER = /[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/
@@ -15,6 +17,7 @@ module Lithop
       validate_declarations!(data)
       document = parse(data)
       validate_document!(document)
+      document
     rescue REXML::ParseException => e
       raise InputError, "invalid SVG XML: #{e.message.lines.first.to_s.strip}"
     end
@@ -133,6 +136,7 @@ module Lithop
 
   # Rasterizes a validated SVG at the resolution required by the sampling grids.
   class SVGLoader
+    Result = Data.define(:image, :material_display)
     BASE_DPI = 96.0
     MAXIMUM_FILE_BYTES = 15_000_000
 
@@ -143,7 +147,7 @@ module Lithop
 
     def call(path, access:, sampling_grids: nil)
       data = read(path)
-      @validator.call(data)
+      document = @validator.call(data)
       ensure_loader!
 
       probe = render(data, scale: 1.0, access: :sequential)
@@ -153,11 +157,16 @@ module Lithop
 
       image = render(data, scale:, access:)
       validate_rendered_image!(image)
-      image
+      Result.new(image:, material_display: material_display?(document))
     end
 
     private
 
+    def material_display?(document)
+      document.root.attributes[SVGDocumentValidator::MATERIAL_DISPLAY_ATTRIBUTE] ==
+        SVGDocumentValidator::MATERIAL_DISPLAY_VALUE
+    end
+
     def read(path)
       raise InputError, "SVG input exceeds #{MAXIMUM_FILE_BYTES} bytes" if File.size(path) > MAXIMUM_FILE_BYTES
 

data/lib/lithop/layer_structure.rb

@@ -64,15 +64,6 @@ module Lithop
     def color_region_start = base_white_thickness
     def color_region_end = color_end
 
-    def color_region_layer_ranges(part_count)
-      size, remainder = color_layer_count.divmod(part_count)
-      start = base_white_layers
-      Array.new(part_count) do |index|
-        finish = start + size + (index < remainder ? 1 : 0)
-        (start...finish).tap { start = finish }
-      end
-    end
-
     def materials_for(recipe_layers, height)
       top_white_layers = top_white_layer_count(height, pigment_layers: recipe_layers.length)
       [*Array.new(base_white_layers, :white), *recipe_layers, *Array.new(top_white_layers, :white)]

data/lib/lithop/model/filament_profile.rb

@@ -62,12 +62,12 @@ module Lithop
 
     def default = BAMBU_LAB_PLA_CMYK
 
-    def display_sample(rgb)
-      cmy, density = MaterialDisplayMap.call(rgb)
+    def display_sample(rgb, mixtures: true)
+      cmy, density = MaterialDisplayMap.call(rgb, mixtures:)
       DisplaySample.new(cmy:, density:) if cmy
     end
 
-    def display_cmy(rgb) = display_sample(rgb)&.cmy
+    def display_cmy(rgb, mixtures: true) = display_sample(rgb, mixtures:)&.cmy
 
     def validate!(profile)
       channels = profile.materials.map(&:channel)

data/lib/lithop/model/material_display_map.rb

@@ -32,12 +32,13 @@ module Lithop
 
     module_function
 
-    def call(rgb)
+    def call(rgb, mixtures: true)
       channels = rgb.map { |component| (component * 255).round.clamp(0, 255) }
       packed = channels.reduce(0) { |value, component| (value << 8) | component }
       return [[0.0, 0.0, 0.0], 0.0] if packed == 0xFFFFFF
       return [CMY_BLACK, CMY_BLACK_DENSITIES.fetch(packed)] if CMY_BLACK_DENSITIES.key?(packed)
       return [COLOR_CMYS.fetch(packed), 1.0] if COLOR_CMYS.key?(packed)
+      return unless mixtures
 
       match = closest_line(channels)
       return unless match && match.first <= MAXIMUM_ERROR