lithop 0.2.0 → 0.3.0

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

@@ -3,11 +3,15 @@
 module Lithop
   # Indexes vertices and triangles for a 3MF mesh resource.
   class ThreeMFMesh
-    attr_reader :vertices, :vertex_indices, :triangle_count
+    NATIVE_BATCH_SIZE = 8_192
+    MAXIMUM_NATIVE_TOPOLOGY_KEY = (2**63) - 1
+    class UnsupportedNativeTopology < StandardError; end
+
+    attr_reader :vertices, :vertex_indices, :triangle_count, :native_mesh
 
     def initialize(triangles:)
       @triangles = triangles
-      index_resources
+      Native.enabled? ? index_native_resources : index_ruby_resources
     end
 
     def each_indexed_triangle
@@ -18,9 +22,74 @@ module Lithop
       end
     end
 
+    def native_indexed? = !native_mesh.nil?
+
+    def vertex_count = native_indexed? ? native_mesh.vertex_count : vertices.length
+
+    def center
+      return native_mesh.center if native_indexed?
+
+      axes = vertices.transpose
+      axes.map { |values| (values.min + values.max) / 2.0 }
+    end
+
     private
 
-    def index_resources
+    def index_native_resources
+      if @triangles.respond_to?(:native_indexed_mesh)
+        @native_mesh = @triangles.native_indexed_mesh
+        raise InputError, "3MF mesh contains no triangles" if native_mesh.vertex_count.zero?
+
+        @triangle_count = native_mesh.triangle_count
+        @vertices = nil
+        @vertex_indices = nil
+        return
+      end
+
+      @native_mesh = Native::MeshBuilder.new
+      coordinates = []
+      topology_keys = []
+      count = 0
+      @triangles.each do |triangle|
+        validate_triangle!(triangle)
+        triangle.each do |vertex|
+          coordinates.concat(coordinates(vertex))
+          topology_keys << native_topology_key(vertex)
+        end
+        count += 1
+        flush_native_batch(coordinates, topology_keys) if (count % NATIVE_BATCH_SIZE).zero?
+      end
+      flush_native_batch(coordinates, topology_keys)
+      raise InputError, "3MF mesh contains no triangles" if native_mesh.vertex_count.zero?
+
+      @triangle_count = native_mesh.triangle_count
+      @vertices = nil
+      @vertex_indices = nil
+    rescue UnsupportedNativeTopology
+      @native_mesh = nil
+      index_ruby_resources
+    end
+
+    def flush_native_batch(coordinates, topology_keys)
+      return if coordinates.empty?
+
+      native_mesh.add_batch(coordinates, topology_keys)
+      coordinates.clear
+      topology_keys.clear
+    end
+
+    def native_topology_key(vertex)
+      return -1 unless vertex.respond_to?(:topology)
+
+      topology = vertex.topology
+      unless topology.is_a?(Integer) && topology.between?(0, MAXIMUM_NATIVE_TOPOLOGY_KEY)
+        raise UnsupportedNativeTopology
+      end
+
+      topology
+    end
+
+    def index_ruby_resources
       @vertices = []
       @vertex_indices = {}
       @triangle_count = 0

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

@@ -78,7 +78,7 @@ module Lithop
           ThreeMFPartWriter.new(archive: @archive, profile: @profile).write(object_id, part, mesh)
         end
         part.triangles.release_cache! if part.triangles.respond_to?(:release_cache!)
-        vertex_count += mesh.vertices.length
+        vertex_count += mesh.vertex_count
         triangle_counts[part.material] = triangle_counts.fetch(part.material, 0) + mesh.triangle_count
       end
       Result.new(
@@ -96,7 +96,7 @@ module Lithop
       result
     end
 
-    # rubocop:disable-next Metrics/AbcSize
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
     def write_external_parts(object_ids, assemblies)
       parts_by_object_id = object_ids.zip(@parts).to_h
       vertex_count = 0
@@ -106,22 +106,26 @@ module Lithop
         measure_xml do
           @archive.write(submodel_header)
           write_materials
-          assembly.object_ids.each do |object_id|
-            part = parts_by_object_id.fetch(object_id)
-            mesh = @instrumentation.measure(:three_mf_indexing) do
-              ThreeMFMesh.new(triangles: part.triangles)
-            end
-            center = mesh_center(mesh)
-            assembly.component_origins[object_id] = component_origin(
-              center, assembly.component_origins.fetch(object_id)
-            )
+        end
+        assembly.object_ids.each do |object_id|
+          part = parts_by_object_id.fetch(object_id)
+          mesh = @instrumentation.measure(:three_mf_indexing) do
+            ThreeMFMesh.new(triangles: part.triangles)
+          end
+          center = mesh_center(mesh)
+          assembly.component_origins[object_id] = component_origin(
+            center, assembly.component_origins.fetch(object_id)
+          )
+          measure_xml do
             ThreeMFPartWriter.new(
               archive: @archive, profile: @profile, production: true, origin: center
             ).write(object_id, part, mesh)
-            part.triangles.release_cache! if part.triangles.respond_to?(:release_cache!)
-            vertex_count += mesh.vertices.length
-            triangle_counts[part.material] = triangle_counts.fetch(part.material, 0) + mesh.triangle_count
           end
+          part.triangles.release_cache! if part.triangles.respond_to?(:release_cache!)
+          vertex_count += mesh.vertex_count
+          triangle_counts[part.material] = triangle_counts.fetch(part.material, 0) + mesh.triangle_count
+        end
+        measure_xml do
           @archive.write("  </resources>\n  <build/>\n</model>\n")
         end
       end
@@ -252,8 +256,7 @@ module Lithop
     end
 
     def mesh_center(mesh)
-      axes = mesh.vertices.transpose
-      axes.map { |values| (values.min + values.max) / 2.0 }
+      mesh.center
     end
 
     def component_origin(center, base_origin)

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

@@ -3,6 +3,8 @@
 module Lithop
   # Serializes one indexed material mesh into a 3MF model document.
   class ThreeMFPartWriter
+    XML_BATCH_SIZE = 8_192
+
     def initialize(archive:, profile:, production: false, origin: nil)
       @archive = archive
       @profile = profile
@@ -31,6 +33,9 @@ module Lithop
     private
 
     def write_vertices(mesh)
+      return write_indexed_native_vertices(mesh) if mesh.native_indexed?
+      return write_native_vertices(mesh) if Native.enabled?
+
       mesh.vertices.each do |x, y, z|
         @archive.write(
           "          <vertex x=\"#{number(x - @origin[0])}\" y=\"#{number(y - @origin[1])}\" " \
@@ -40,6 +45,9 @@ module Lithop
     end
 
     def write_triangles(mesh)
+      return write_indexed_native_triangles(mesh) if mesh.native_indexed?
+      return write_native_triangles(mesh) if Native.enabled?
+
       count = 0
       mesh.each_indexed_triangle do |vertices|
         @archive.write(
@@ -52,6 +60,35 @@ module Lithop
       raise InputError, "3MF triangle enumerables must be repeatable"
     end
 
+    def write_native_vertices(mesh)
+      mesh.vertices.each_slice(XML_BATCH_SIZE) do |vertices|
+        @archive.write(Native.vertex_xml(vertices.flatten, @origin))
+      end
+    end
+
+    def write_indexed_native_vertices(mesh)
+      0.step(mesh.vertex_count - 1, XML_BATCH_SIZE) do |offset|
+        @archive.write(mesh.native_mesh.vertex_xml(offset, XML_BATCH_SIZE, @origin))
+      end
+    end
+
+    def write_native_triangles(mesh)
+      count = 0
+      mesh.each_indexed_triangle.each_slice(XML_BATCH_SIZE) do |triangles|
+        @archive.write(Native.triangle_xml(triangles.flatten))
+        count += triangles.length
+      end
+      return if count == mesh.triangle_count
+
+      raise InputError, "3MF triangle enumerables must be repeatable"
+    end
+
+    def write_indexed_native_triangles(mesh)
+      0.step(mesh.triangle_count - 1, XML_BATCH_SIZE) do |offset|
+        @archive.write(mesh.native_mesh.triangle_xml(offset, XML_BATCH_SIZE))
+      end
+    end
+
     def number(value) = format("%.9g", value)
   end
 end

data/lib/lithop/formats/three_mf.rb

@@ -18,7 +18,7 @@ module Lithop
     MODEL_RELATIONSHIP = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"
     MODEL_CONTENT_TYPE = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml"
     ZIP_MUTEX = Mutex.new
-    # Triangles are indexed and then serialized, so their enumerable must be replayable.
+    # The Rust indexer consumes triangles once; the Ruby comparison path requires replayable input.
     Part = Data.define(:material, :triangles, :name, :region, :build_z_offset) do
       def initialize(material:, triangles:, name: nil, region: nil, build_z_offset: 0.0)
         super

data/lib/lithop/image/pipeline.rb

@@ -9,7 +9,9 @@ module Lithop
     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)
+    Result = Data.define(
+      :width, :height, :cmys, :cmy_densities, :white_densities, :color_cells, :corrected_preview_png
+    )
 
     def initialize(settings)
       @settings = settings
@@ -21,13 +23,8 @@ module Lithop
       require "vips"
 
       access = @settings.color_pixel_size ? :random : :sequential
-      image = load_image(path, access:)
-      image = image.autorot
-      validate_input!(image)
-      image = image.flatten(background: [255, 255, 255]) if image.has_alpha?
-      image = to_srgb(image)
-      image = adjust_image(image)
-      sampled = @placement.call(image, @settings.sampling_grid).cast(:uchar)
+      image = normalized_image(path, access:)
+      sampled = @placement.call(image, @settings.sampling_grid).cast(:uchar).copy_memory
 
       rgbs = rgb_components(sampled)
       color_samples = rgbs.map { |rgb| color_sample(rgb) }
@@ -42,20 +39,62 @@ module Lithop
         cmys: color_samples.map(&:first),
         cmy_densities: color_samples.map(&:last),
         white_densities: rgbs.map { |rgb| white_density(rgb) },
-        color_cells: result_color_cells
+        color_cells: result_color_cells,
+        corrected_preview_png: sampled.write_to_buffer(".png")
       )
     rescue SystemCallError, Vips::Error => e
       raise InputError, "could not read image: #{e.message}"
     end
 
+    # Returns the same normalized and placed image used by conversion, bounded
+    # to a browser-friendly sampling grid and without running CMYW or mesh work.
+    def preview_png(path, maximum_width: 960, maximum_height: 720)
+      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")
+    rescue SystemCallError, Vips::Error => e
+      raise InputError, "could not read image: #{e.message}"
+    end
+
     private
 
-    def load_image(path, access:)
+    def normalized_image(path, access:, sampling_grids: nil)
+      image = load_image(path, access:, sampling_grids:)
+      image = image.autorot
+      validate_input!(image)
+      image = image.flatten(background: [255, 255, 255]) if image.has_alpha?
+      adjust_image(to_srgb(image))
+    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
 
-      @svg_loader.call(path, access:)
+      @svg_loader.call(path, access:, sampling_grids:)
+    end
+
+    def preview_grid(maximum_width:, maximum_height:)
+      maximum_width = Integer(maximum_width)
+      maximum_height = Integer(maximum_height)
+      raise InputError, "preview dimensions must be at least 2 pixels" if maximum_width < 2 || maximum_height < 2
+
+      pixel_size = [
+        @settings.width.fdiv(maximum_width - 1),
+        @settings.height.fdiv(maximum_height - 1),
+        0.01
+      ].max
+      SamplingGrid.new(
+        width: @settings.width, height: @settings.height, pixel_size:,
+        margins: {
+          top: @settings.margin_top, right: @settings.margin_right,
+          bottom: @settings.margin_bottom, left: @settings.margin_left
+        }
+      )
+    rescue ArgumentError, TypeError
+      raise InputError, "preview dimensions must be integers"
     end
 
     def validate_input!(image)

data/lib/lithop/image/svg_loader.rb

@@ -141,14 +141,14 @@ module Lithop
       @validator = SVGDocumentValidator.new
     end
 
-    def call(path, access:)
+    def call(path, access:, sampling_grids: nil)
       data = read(path)
       @validator.call(data)
       ensure_loader!
 
       probe = render(data, scale: 1.0, access: :sequential)
       validate_rendered_image!(probe, pixels: false)
-      scale = render_scale(probe)
+      scale = render_scale(probe, sampling_grids || default_sampling_grids)
       validate_planned_pixels!(probe, scale)
 
       image = render(data, scale:, access:)
@@ -180,8 +180,8 @@ module Lithop
       raise InputError, "could not render SVG: #{e.message}"
     end
 
-    def render_scale(image)
-      scales = sampling_grids.map do |grid|
+    def render_scale(image, grids)
+      scales = grids.map do |grid|
         width, height = grid.content_sample_size
         ratios = [width.fdiv(image.width), height.fdiv(image.height)]
         @settings.image_fit == "contain" ? ratios.min * @settings.crop_scale : ratios.max / @settings.crop_scale
@@ -189,7 +189,7 @@ module Lithop
       [*scales, 1.0 / image.width, 1.0 / image.height].max
     end
 
-    def sampling_grids
+    def default_sampling_grids
       grids = [@settings.sampling_grid]
       grids << @settings.color_sampling_grid if @settings.color_pixel_size
       grids

data/lib/lithop/job_execution.rb

@@ -27,8 +27,10 @@ module Lithop
       @jobs_dir = File.join(@build_dir, ".jobs")
       @status_path = File.join(@jobs_dir, "#{job_id}.json")
       @cancel_path = File.join(@jobs_dir, "#{job_id}.cancel")
+      @transition_lock_path = File.join(@jobs_dir, "#{job_id}.transition.lock")
       @lock_path = File.join(@build_dir, ".lithop.lock")
       @lock = nil
+      @transition_lock = nil
       @record = base_record
     end
 
@@ -40,7 +42,7 @@ module Lithop
       raise_if_cancelled!
       transition("running", phase: "starting", percent: 0, message: "Conversion started", started_at: timestamp)
       result = yield self
-      raise_if_cancelled!
+      raise_if_cancelled! unless @publication_committed
       complete(result)
       result
     rescue JobCancelled, Interrupt => e
@@ -53,6 +55,7 @@ module Lithop
       raise
     ensure
       release_lock
+      release_transition_lock
       remove_cancel_request if prepared?
     end
 
@@ -62,21 +65,95 @@ module Lithop
       raise_if_cancelled!
     end
 
+    def checkpoint!
+      @transition_mutex = self.class.send(:transition_mutex, @transition_lock_path)
+      @transition_mutex.lock
+      @transition_mutex_locked = true
+      @transition_lock = File.open(@transition_lock_path, File::RDWR | File::CREAT, 0o600)
+      @transition_lock.flock(File::LOCK_EX)
+      raise_if_cancelled!
+    rescue StandardError
+      release_transition_lock
+      raise
+    end
+
+    # Once JobDirectory has atomically published the output, late cancellation
+    # must not turn a complete artifact set into a cancelled job.
+    def publication_committed!(message: "Artifacts published")
+      @publication_committed = true
+      transition("running", phase: "publishing", percent: 99, message:)
+    end
+
     def self.request_cancel(project_dir:, job_id:, clock: Time)
       validate_job_id!(job_id)
       jobs_dir = File.join(File.expand_path(project_dir), "build", ".jobs")
       FileUtils.mkdir_p(jobs_dir)
       status_path = File.join(jobs_dir, "#{job_id}.json")
       path = File.join(jobs_dir, "#{job_id}.cancel")
+      lock_path = File.join(jobs_dir, "#{job_id}.transition.lock")
       requested_at = clock.now.utc.iso8601(6)
-      atomic_write(path, JSON.generate(job_id:, requested_at:))
-      mark_cancelling(status_path, requested_at)
-      path
+      requested = false
+      transition_mutex(lock_path).synchronize do
+        File.open(lock_path, File::RDWR | File::CREAT, 0o600) do |lock|
+          lock.flock(File::LOCK_EX)
+          unless final_status?(status_path)
+            atomic_write(path, JSON.generate(job_id:, requested_at:))
+            mark_cancelling(status_path, requested_at)
+            requested = true
+          end
+        end
+      end
+      path if requested
+    end
+
+    def self.finalize_process_exit(project_dir:, job_id:, clock: Time)
+      validate_job_id!(job_id)
+      build_dir = File.join(File.expand_path(project_dir), "build")
+      jobs_dir = File.join(build_dir, ".jobs")
+      status_path = File.join(jobs_dir, "#{job_id}.json")
+      cancel_path = File.join(jobs_dir, "#{job_id}.cancel")
+      record = if File.file?(status_path)
+                 JSON.parse(File.read(status_path))
+               else
+                 process_exit_record(job_id:, cancelled: File.file?(cancel_path), clock:)
+               end
+      return record unless ACTIVE_STATES.include?(record["state"])
+
+      now = clock.now.utc.iso8601(6)
+      output_path = File.join(build_dir, job_id)
+      finalize_exit_record(record, output_path:, cancelled: File.file?(cancel_path), now:)
+      atomic_write(status_path, JSON.pretty_generate(record) << "\n")
+      record
+    rescue JSON::ParserError, SystemCallError
+      nil
+    ensure
+      FileUtils.rm_f(cancel_path) if defined?(cancel_path)
     end
 
     class << self
       private
 
+      def finalize_exit_record(record, output_path:, cancelled:, now:)
+        if File.directory?(output_path) && !File.symlink?(output_path)
+          record.merge!(
+            "state" => "completed", "phase" => "completed", "percent" => 100.0,
+            "message" => "Conversion completed", "updated_at" => now, "finished_at" => now,
+            "output_path" => output_path, "files" => artifact_files(output_path), "error" => nil
+          )
+        elsif record["state"] == "cancelling" || cancelled
+          record.merge!(
+            "state" => "cancelled", "phase" => "cancelled", "message" => "Conversion cancelled",
+            "updated_at" => now, "finished_at" => now
+          )
+        else
+          record.merge!(
+            "state" => "failed", "phase" => "failed", "message" => "Conversion process exited",
+            "updated_at" => now, "finished_at" => now,
+            "error" => { "class" => "Lithop::Error", "message" => "conversion process exited before completion" }
+          )
+        end
+      end
+
       def validate_job_id!(job_id)
         return if job_id.is_a?(String) && job_id.match?(/\A[0-9A-Za-z][0-9A-Za-z._-]*\z/)
 
@@ -107,6 +184,39 @@ module Lithop
       rescue JSON::ParserError, SystemCallError
         nil
       end
+
+      def final_status?(path)
+        File.file?(path) && FINAL_STATES.include?(JSON.parse(File.read(path))["state"])
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
+
+      def transition_mutex(path)
+        @transition_mutex_guard ||= Mutex.new
+        @transition_mutex_guard.synchronize do
+          @transition_mutexes ||= {}
+          @transition_mutexes[path] ||= Mutex.new
+        end
+      end
+
+      def artifact_files(output_path)
+        Dir.glob("**/*", base: output_path).select do |name|
+          path = File.join(output_path, name)
+          File.file?(path) && !File.symlink?(path)
+        end.sort
+      end
+
+      def process_exit_record(job_id:, cancelled:, clock:)
+        now = clock.now.utc.iso8601(6)
+        {
+          "schema_version" => SCHEMA_VERSION, "job_id" => job_id,
+          "state" => cancelled ? "cancelling" : "running",
+          "phase" => cancelled ? "cancelling" : "starting", "percent" => 0,
+          "message" => cancelled ? "Cancellation requested" : "Conversion process started",
+          "created_at" => now, "updated_at" => now, "started_at" => nil,
+          "finished_at" => nil, "output_path" => nil, "files" => nil, "error" => nil
+        }
+      end
     end
 
     private
@@ -139,6 +249,24 @@ module Lithop
       @lock = nil
     end
 
+    def release_transition_lock
+      if @transition_lock
+        @transition_lock.flock(File::LOCK_UN)
+        @transition_lock.close
+        @transition_lock = nil
+      end
+      if @transition_mutex_locked
+        @transition_mutex.unlock
+        @transition_mutex_locked = false
+      end
+    rescue IOError, SystemCallError
+      @transition_lock = nil
+      if @transition_mutex_locked
+        @transition_mutex.unlock
+        @transition_mutex_locked = false
+      end
+    end
+
     def recover_temporary_directories
       JobDirectory.recover(project_dir: @project_dir).each do |recovered|
         mark_recovered_job(recovered)

data/lib/lithop/mesh/column_geometry.rb

@@ -35,6 +35,14 @@ module Lithop
 
     def release_cache! = @topology.release_cache!
 
+    def native_indexed_mesh
+      Native.column_mesh(
+        @model.columns, @model.rows, @model.x_boundaries, @model.y_boundaries, @model.z_boundaries,
+        @intervals.flat_map { |value| value || [-1, -1] },
+        @topology.group_ids, @topology.group_count
+      )
+    end
+
     def triangle_count
       @model.rows.times.sum do |row|
         @model.columns.times.sum do |column|

data/lib/lithop/mesh/column_topology.rb

@@ -174,6 +174,8 @@ module Lithop
       roots.freeze
     end.freeze
 
+    attr_reader :group_ids, :group_count
+
     def initialize(model:, intervals:)
       @model = model
       @intervals = intervals

data/lib/lithop/model/material_model.rb

@@ -17,6 +17,7 @@ module Lithop
         pigment_order: settings.pigment_order
       )
       @settings = settings
+      @material_arrays = {}
       validate_samples!(cmys, heights, cell_cmys)
       @cells = build_cells(cmys, heights, cell_cmys).freeze
       maximum_layers = cells.map { |cell| cell.materials.length }.max
@@ -31,7 +32,9 @@ module Lithop
     end
 
     def materials
-      @materials ||= cells.flat_map(&:materials).uniq.freeze
+      @materials ||= cells.each_with_object({}) do |cell, result|
+        cell.materials.each { |material| result[material] = true }
+      end.keys.freeze
     end
 
     def recipe_counts
@@ -63,12 +66,21 @@ module Lithop
     end
 
     def build_cells(cmys, heights, cell_cmys)
-      Array.new(rows * columns) do |index|
+      cell_heights = Array.new(rows * columns)
+      cell_colors = Array.new(rows * columns) do |index|
         row, column = index.divmod(columns)
         cmy = cell_cmys ? cell_cmys.fetch(index) : average(corners(cmys, row, column))
-        height = @settings.quantize_thickness(average(corners(heights, row, column)))
-        recipe = @palette.nearest(cmy)
-        Cell.new(height:, recipe:, materials: materials_for(recipe, height).freeze)
+        cell_heights[index] = @settings.quantize_thickness(average(corners(heights, row, column)))
+        cmy
+      end
+      recipes = if @palette.respond_to?(:nearest_many)
+                  @palette.nearest_many(cell_colors)
+                else
+                  cell_colors.map { |cmy| @palette.nearest(cmy) }
+                end
+      cell_heights.zip(recipes).map do |height, recipe|
+        materials = @material_arrays[[recipe, height]] ||= materials_for(recipe, height).freeze
+        Cell.new(height:, recipe:, materials:)
       end
     end
 

data/lib/lithop/model/palette.rb

@@ -49,13 +49,20 @@ module Lithop
       @layer_count = layer_count
       @pigment_order = pigment_order.dup.freeze
       @recipes = build_recipes.freeze
+      @native_coverages = recipes.flat_map(&:coverage_cmy).freeze
     end
 
     def nearest(cmy)
       validate_cmy!(cmy)
-      recipes.min_by do |recipe|
-        recipe.coverage_cmy.zip(cmy).sum { |coverage, target| (coverage - target)**2 }
-      end
+      nearest_validated(cmy)
+    end
+
+    def nearest_many(cmys)
+      cmys.each { |cmy| validate_cmy!(cmy) }
+      return cmys.map { |cmy| nearest_validated(cmy) } unless Native.enabled?
+
+      indices = Native.palette_indices(cmys.flatten, @native_coverages)
+      indices.map { |index| recipes.fetch(index) }
     end
 
     def display_color(recipe)
@@ -97,5 +104,16 @@ module Lithop
 
       raise InputError, "CMY must contain three values between 0 and 1"
     end
+
+    def squared_distance(coverage, target)
+      cyan = coverage[0] - target[0]
+      magenta = coverage[1] - target[1]
+      yellow = coverage[2] - target[2]
+      (cyan * cyan) + (magenta * magenta) + (yellow * yellow)
+    end
+
+    def nearest_validated(cmy)
+      recipes.min_by { |recipe| squared_distance(recipe.coverage_cmy, cmy) }
+    end
   end
 end