lithop 0.1.0

data/lib/lithop/export/generation.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Runs the image, mesh, preview, and metadata stages for one regular export.
+  # rubocop:disable-next Metrics/ClassLength
+  class ExportGeneration
+    Result = Data.define(:files, :triangle_count, :three_mf_triangle_count, :material_count, :object_count)
+
+    def initialize(settings:, input_settings_path:, calibration:, progress:, instrumentation:)
+      @settings = settings
+      @input_settings_path = input_settings_path
+      @calibration_context = ExportCalibration.new(settings:, input: calibration)
+      @progress = progress
+      @instrumentation = Instrumentation.new(instrumentation)
+      @metadata = ExportMetadata.new(
+        settings:, input_settings_path:, calibration: @calibration_context
+      )
+    end
+
+    def call(source:, directory:, job_id:)
+      image = @instrumentation.measure(:image_processing) { ImagePipeline.new(@settings).call(source) }
+      white_heights = @instrumentation.measure(:height_selection) do
+        @calibration_context.heights(image.white_densities)
+      end
+      geometry = white_geometry(white_heights)
+      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)
+      write_supporting_files(directory, source, job_id, artifacts)
+      result_for(directory, artifacts)
+    end
+
+    private
+
+    def white_geometry(heights)
+      Geometry.new(
+        heights:,
+        columns: @settings.columns,
+        rows: @settings.rows,
+        x_boundaries: @settings.x_boundaries,
+        y_boundaries: @settings.y_boundaries,
+        optimize_bottom: true
+      )
+    end
+
+    def material_mesh_plan(material_model, white_geometry)
+      ReferenceMaterialMeshPlan.new(
+        model: material_model,
+        white_geometry:,
+        maximum_triangles: @settings.maximum_triangles,
+        limit_message: ->(count) { @settings.triangle_limit_message("physical CMYW mesh", count) }
+      ).call
+    end
+
+    def write_artifacts(directory, geometry, material_model, mesh_plan, 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
+        )
+      end
+      mesh_plan.validate!(three_mf)
+      @instrumentation.measure(:preview_write) do
+        ExportPreviews.write(directory, model: material_model, settings: @settings, white_heights:)
+      end
+      ExportArtifacts.new(
+        stl_name:,
+        three_mf_name:,
+        stl_triangle_count: triangle_count,
+        three_mf:,
+        material_model:
+      )
+    end
+
+    def write_supporting_files(directory, source, job_id, artifacts)
+      @instrumentation.measure(:metadata_write) do
+        @calibration_context.write(directory)
+        @metadata.write(directory:, source:, job_id:, artifacts:)
+        PrintReadme.write(
+          File.join(directory, "PRINT_README.md"),
+          settings: @settings,
+          material_model: artifacts.material_model,
+          calibration_profile: @calibration_context.profile
+        )
+      end
+    end
+
+    def report_estimate(plan)
+      return unless @progress
+
+      @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
+        )
+      )
+    end
+
+    def result_for(directory, artifacts)
+      three_mf = artifacts.three_mf
+      Result.new(
+        files: Dir.children(directory).sort,
+        triangle_count: artifacts.stl_triangle_count,
+        three_mf_triangle_count: three_mf.triangle_count,
+        material_count: three_mf.material_count,
+        object_count: three_mf.object_count
+      )
+    end
+  end
+end

data/lib/lithop/export/job.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Lithop
+  # Coordinates image processing, mesh generation, and artifact export.
+  class Export
+    CalibrationInput = Data.define(:profile, :path)
+    Estimate = Data.define(:stl_triangle_count, :three_mf_triangle_count, :triangle_counts_by_material)
+
+    Result = ExportResult
+
+    # Dependency injection keeps job IDs testable; generation options remain explicit keywords.
+    # rubocop:disable-next Metrics/ParameterLists
+    def initialize(
+      settings:, project_dir:, input_settings_path: nil, calibration: nil, progress: nil,
+      instrumentation: nil, clock: Time, random: SecureRandom
+    )
+      @settings = settings
+      @project_dir = File.expand_path(project_dir)
+      @input_settings_path = input_settings_path
+      @calibration = calibration
+      @progress = progress
+      @clock = clock
+      @random = random
+      @generation = ExportGeneration.new(
+        settings:, input_settings_path:, calibration:, progress:, instrumentation:
+      )
+    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
+      )
+    end
+  end
+end

data/lib/lithop/export/metadata.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Lithop
+  # Builds and writes the resolved settings and export manifest.
+  class ExportMetadata
+    def initialize(settings:, input_settings_path:, calibration:)
+      @settings = settings
+      @input_settings_path = input_settings_path
+      @calibration = calibration
+      @color_metadata = ExportColorMetadata.new(settings:, calibration:)
+    end
+
+    def write(directory:, source:, job_id:, artifacts:)
+      resolved_settings = @settings.to_h.merge(
+        schema_version: 1,
+        generator_version: Lithop::VERSION,
+        input_path: source,
+        input_settings_path: @input_settings_path,
+        calibration_profile_id: @calibration.profile&.profile_id,
+        calibration_profile_path: @calibration.path
+      )
+      manifest = manifest_for(source, job_id, artifacts)
+      write_json(File.join(directory, "settings.json"), resolved_settings)
+      write_json(File.join(directory, "manifest.json"), manifest)
+    end
+
+    private
+
+    def manifest_for(source, job_id, artifacts)
+      materials = material_names(used_materials(artifacts))
+      {
+        schema_version: 1,
+        job_id:,
+        units: "mm",
+        viewing_direction: "+Z",
+        image_top: "+Y",
+        dimensions_mm: {
+          width: @settings.width,
+          height: @settings.height,
+          depth: @settings.effective_maximum_thickness
+        },
+        print_settings: {
+          nozzle_diameter_mm: @settings.nozzle_diameter,
+          first_layer_height_mm: @settings.first_layer_height,
+          layer_height_mm: @settings.layer_height
+        },
+        input_sha256: Digest::SHA256.file(source).hexdigest,
+        filament_profile: FilamentProfile.default.to_h,
+        parts: [
+          { file: artifacts.stl_name, material: "White", role: "monochrome_reference" },
+          { file: artifacts.three_mf_name, materials:, role: "cmyw_lithophane" }
+        ],
+        color_model: @color_metadata.call(artifacts),
+        files: artifact_files(artifacts),
+        triangle_count: artifacts.stl_triangle_count,
+        three_mf_triangle_count: artifacts.three_mf.triangle_count
+      }
+    end
+
+    def artifact_files(artifacts)
+      files = [
+        artifacts.stl_name, artifacts.three_mf_name, "settings.json", "manifest.json",
+        "preview.png", "transmission.png", "thickness.png",
+        *Palette::MATERIALS.map { |material| "#{material}-mask.png" }, "PRINT_README.md"
+      ]
+      files << "calibration-profile.json" if @calibration.profile
+      files
+    end
+
+    def used_materials(artifacts)
+      Palette::MATERIALS.select { |material| artifacts.material_model.materials.include?(material) }
+    end
+
+    def material_names(materials)
+      materials.map { |material| material.to_s.capitalize }
+    end
+
+    def write_json(path, value)
+      File.write(path, "#{JSON.pretty_generate(value)}\n")
+    end
+  end
+end

data/lib/lithop/export/planning.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Builds the reference-style overlapping White height field and contiguous CMY columns.
+  class ReferenceMaterialMeshPlan
+    def initialize(model:, white_geometry:, maximum_triangles:, limit_message:)
+      @model = model
+      @white_geometry = white_geometry
+      @maximum_triangles = maximum_triangles
+      @limit_message = limit_message
+    end
+
+    def call
+      geometries = [[:white, @white_geometry]]
+      Palette::PIGMENTS.each do |material|
+        geometries << [material, ColumnGeometry.new(model: @model, material:)] if @model.materials.include?(material)
+      end
+      counts = geometries.to_h do |material, geometry|
+        count = geometry.respond_to?(:triangle_count) ? geometry.triangle_count : geometry.each_triangle.count
+        [material, count]
+      end
+      triangle_count = counts.values.sum
+      raise ConfigurationError, @limit_message.call(triangle_count) if triangle_count > @maximum_triangles
+
+      MaterialMeshPlan::Result.new(
+        parts: geometries.map do |material, geometry|
+          triangles = geometry.is_a?(ColumnGeometry) ? geometry : geometry.each_triangle
+          ThreeMF::Part.new(material:, triangles:)
+        end,
+        triangle_count:,
+        triangle_counts_by_material: counts.freeze
+      )
+    end
+  end
+
+  # Builds material parts and exact triangle counts before writing a 3MF package.
+  class MaterialMeshPlan
+    Result = Data.define(:parts, :triangle_count, :triangle_counts_by_material) do
+      def validate!(three_mf_result)
+        return true if triangle_count == three_mf_result.triangle_count
+
+        raise Error, "planned and written 3MF triangle counts differ"
+      end
+    end
+
+    def initialize(model:, maximum_triangles:, label:, limit_message: nil)
+      @model = model
+      @maximum_triangles = maximum_triangles
+      @label = label
+      @limit_message = limit_message
+    end
+
+    def call
+      geometries = @model.materials.map do |material|
+        geometry = VoxelGeometry.new(model: @model, material:)
+        [material, geometry, geometry.triangle_count]
+      end
+      triangle_count = geometries.sum { |_material, _geometry, count| count }
+      raise ConfigurationError, limit_message(triangle_count) if triangle_count > @maximum_triangles
+
+      Result.new(
+        parts: geometries.map do |material, geometry, _count|
+          ThreeMF::Part.new(material:, triangles: geometry.each_triangle)
+        end,
+        triangle_count:,
+        triangle_counts_by_material: geometries.to_h do |material, _geometry, count|
+          [material, count]
+        end.freeze
+      )
+    end
+
+    def limit_message(triangle_count)
+      return @limit_message.call(triangle_count) if @limit_message
+
+      "#{@label} has #{triangle_count} triangles; maximum is #{@maximum_triangles}"
+    end
+  end
+end

data/lib/lithop/export/previews.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Writes the nominal color, transmission, thickness, and material-mask previews.
+  module ExportPreviews
+    module_function
+
+    def write(directory, model:, settings:, white_heights: nil)
+      heights = white_heights && cell_heights(white_heights, settings.columns, settings.rows)
+      options = {
+        model:,
+        minimum: settings.effective_minimum_thickness,
+        maximum: settings.effective_maximum_thickness,
+        heights:
+      }
+      Preview.write_material(File.join(directory, "preview.png"), **options, transmission_gamma: 0.5)
+      Preview.write_transmission(File.join(directory, "transmission.png"), **options)
+      Preview.write_thickness(File.join(directory, "thickness.png"), **options)
+      Palette::MATERIALS.each do |material|
+        Preview.write_mask(File.join(directory, "#{material}-mask.png"), model:, material:)
+      end
+    end
+
+    def cell_heights(vertex_heights, columns, rows)
+      stride = columns + 1
+      Array.new(columns * rows) do |index|
+        row, column = index.divmod(columns)
+        top_left = (row * stride) + column
+        corners = [top_left, top_left + 1, top_left + stride, top_left + stride + 1]
+        corners.sum { |corner| vertex_heights.fetch(corner) }.fdiv(4)
+      end
+    end
+    private_class_method :cell_heights
+  end
+end

data/lib/lithop/export/print_readme.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Writes print and material instructions for an exported project.
+  module PrintReadme
+    module_function
+
+    def write(path, settings:, material_model:, calibration_profile: nil, profile: FilamentProfile.default)
+      materials = Palette::MATERIALS.select { |material| material_model.materials.include?(material) }
+      names = materials.map { |material| profile_material(profile, material).name }
+      assignments = materials.map do |material|
+        "#{profile.materials.index(profile_material(profile, material)) + 1} #{material.to_s.capitalize}"
+      end
+
+      File.write(path, <<~MARKDOWN)
+        # Lithop print guide
+
+        This is #{calibration_profile ? "a measured-profile calibrated" : "an uncalibrated"} CMYW lithophane
+        generated in millimetres.
+
+        - Open `lithop.3mf` for the physical color model; it contains: #{names.join(", ")}.
+        #{calibration_line(calibration_profile)}
+        - Bambu Studio assignments encoded for this job: #{assignments.join(", ")}.
+        - The model uses #{settings.color_layer_count} CMY/W color layers #{base_layer_description(settings)}.
+        - The backlight-to-view color-layer order is #{settings.pigment_order.map(&:capitalize).join(" -> ")} -> White.
+        - White thickness above the color region follows #{thickness_method(settings, calibration_profile)}.
+        - `preview.png` shows nominal recipe colors with relative thickness shading; it is not a colorimetric prediction.
+        - `transmission.png`, `thickness.png`, and the four material masks use the same cells as `lithop.3mf`.
+        - `cmyk_white.stl` is a separate monochrome reference model, not the color model.
+        - Product: #{profile.product_url}
+        - Guide: #{profile.reference_url}
+        - Import models without scaling, place the flat back at Z=0, and view the print from +Z.
+        #{layer_height_description(settings)}
+        - 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.
+      MARKDOWN
+    end
+
+    def profile_material(profile, material)
+      profile.materials.find { |candidate| candidate.channel == material }
+    end
+
+    def calibration_line(calibration_profile)
+      return "- No measured calibration profile was used." unless calibration_profile
+
+      "- Measured calibration profile: #{calibration_profile.profile_id}."
+    end
+
+    def thickness_method(_settings, calibration_profile)
+      return "the closest measured White luminance stage" if calibration_profile
+
+      "continuous normalized material-display density or Rec. 601 luminance"
+    end
+
+    def base_layer_description(settings)
+      "above #{settings.base_white_layers} White base layers"
+    end
+
+    def layer_height_description(settings)
+      upper_height = settings.layer_structure.top_layer_height
+      "- 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 :profile_material, :calibration_line, :thickness_method,
+                         :base_layer_description, :layer_height_description
+  end
+end

data/lib/lithop/export/result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lithop
+  ExportArtifacts = Data.define(
+    :stl_name,
+    :three_mf_name,
+    :stl_triangle_count,
+    :three_mf,
+    :material_model
+  )
+
+  ExportResult = Data.define(
+    :job_id,
+    :path,
+    :files,
+    :triangle_count,
+    :three_mf_triangle_count,
+    :material_count,
+    :object_count
+  )
+end

data/lib/lithop/formats/stl.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Reads and writes binary stereolithography (STL) triangle meshes.
+  module STL
+    module_function
+
+    def write(path, triangles)
+      count = 0
+      File.open(path, "wb") do |file|
+        file.write("Lithop binary STL".ljust(80, "\0"))
+        file.write([0].pack("V"))
+        triangles.each do |triangle|
+          normal = normal_for(triangle)
+          file.write((normal + triangle.flatten + [0]).pack("e12v"))
+          count += 1
+        end
+        file.seek(80)
+        file.write([count].pack("V"))
+      end
+      count
+    end
+
+    def each_triangle(path)
+      return enum_for(__method__, path) unless block_given?
+
+      File.open(path, "rb") do |file|
+        raise InputError, "STL header is truncated" unless file.read(80)&.bytesize == 80
+
+        count_data = file.read(4)
+        raise InputError, "STL triangle count is missing" unless count_data&.bytesize == 4
+
+        count_data.unpack1("V").times do
+          record = file.read(50)
+          raise InputError, "STL triangle data is truncated" unless record&.bytesize == 50
+
+          values = record.unpack("e12v")
+          yield values[3, 9].each_slice(3).to_a
+        end
+        raise InputError, "STL contains trailing data" unless file.eof?
+      end
+    end
+
+    def normal_for(triangle)
+      a, b, c = triangle
+      ab = b.zip(a).map { |left, right| left - right }
+      ac = c.zip(a).map { |left, right| left - right }
+      cross = [
+        (ab[1] * ac[2]) - (ab[2] * ac[1]),
+        (ab[2] * ac[0]) - (ab[0] * ac[2]),
+        (ab[0] * ac[1]) - (ab[1] * ac[0])
+      ]
+      magnitude = Math.sqrt(cross.sum { |component| component**2 })
+      raise InputError, "cannot write a zero-area triangle" if magnitude.zero?
+
+      cross.map { |component| component / magnitude }
+    end
+    private_class_method :normal_for
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lithop
+  # Writes Bambu Studio material-assignment metadata into a 3MF package.
+  class ThreeMFBambuMetadata
+    PATH = "Metadata/model_settings.config"
+    FIRST_MODEL_OBJECT_INDEX = 1
+
+    def initialize(archive:, assembly_id:, object_ids:, parts:, profile:, settings: nil)
+      @archive = archive
+      @assembly_id = assembly_id
+      @object_ids = object_ids
+      @parts = parts
+      @profile = profile
+      @settings = settings
+    end
+
+    def write
+      @archive.put_next_entry(PATH)
+      @archive.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<config>\n")
+      @archive.write("  <object id=\"#{@assembly_id}\">\n")
+      @archive.write("    <metadata key=\"name\" value=\"Lithop CMYW lithophane\"/>\n")
+      if bambu_project?
+        @archive.write("    <metadata key=\"extruder\" value=\"1\"/>\n")
+        @archive.write("    <metadata key=\"layer_height\" value=\"#{@settings.layer_height}\"/>\n")
+        @archive.write("    <metadata key=\"sparse_infill_density\" value=\"100%\"/>\n")
+        @archive.write("    <metadata key=\"sparse_infill_pattern\" value=\"zig-zag\"/>\n")
+      end
+      @object_ids.zip(@parts).each do |object_id, part|
+        write_part(object_id, part.material)
+      end
+      @archive.write("  </object>\n")
+      write_plate if bambu_project?
+      @archive.write("</config>\n")
+      write_project_entries if bambu_project?
+    end
+
+    private
+
+    def write_part(object_id, material)
+      profile_material = @profile.materials.find { |candidate| candidate.channel == material }
+      extruder = @profile.materials.index(profile_material) + 1
+      @archive.write("    <part id=\"#{object_id}\" subtype=\"normal_part\">\n")
+      @archive.write("      <metadata key=\"name\" value=\"#{profile_material.name}\"/>\n")
+      @archive.write("      <metadata key=\"extruder\" value=\"#{extruder}\"/>\n")
+      @archive.write("    </part>\n")
+    end
+
+    def bambu_project? = @settings&.bambu_project
+
+    def write_plate
+      @archive.write(<<~XML)
+        <plate>
+          <metadata key="plater_id" value="1"/>
+          <metadata key="plater_name" value="lithophane"/>
+          <metadata key="locked" value="false"/>
+          <model_instance>
+            <metadata key="object_id" value="#{@assembly_id}"/>
+            <metadata key="instance_id" value="0"/>
+          </model_instance>
+        </plate>
+      XML
+    end
+
+    def write_project_entries
+      write_entry("Metadata/layer_config_ranges.xml", layer_ranges_xml)
+      write_entry("Metadata/project_settings.config", "#{JSON.pretty_generate(project_settings)}\n")
+    end
+
+    def layer_ranges_xml
+      <<~XML
+        <?xml version="1.0" encoding="utf-8"?>
+        <objects>
+          <object id="#{FIRST_MODEL_OBJECT_INDEX}">
+            <range min_z="#{@settings.top_white_start}" max_z="#{@settings.maximum_thickness}">
+              <option opt_key="extruder">4</option>
+              <option opt_key="layer_height">#{@settings.top_layer_height}</option>
+            </range>
+          </object>
+        </objects>
+      XML
+    end
+
+    def project_settings
+      {
+        "filament_colour" => %w[#0086D6 #EC008C #FCE300 #FFFFFF],
+        "filament_type" => Array.new(4, "PLA"),
+        "initial_layer_line_width" => "0.25",
+        "initial_layer_print_height" => @settings.first_layer_height.to_s,
+        "layer_height" => @settings.layer_height.to_s,
+        "line_width" => "0.22",
+        "max_layer_height" => ["0.14"],
+        "min_layer_height" => [@settings.top_layer_height.to_s],
+        "nozzle_diameter" => [@settings.nozzle_diameter.to_s]
+      }
+    end
+
+    def write_entry(path, contents)
+      @archive.put_next_entry(path)
+      @archive.write(contents)
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lithop
+  # Indexes vertices and triangles for a 3MF mesh resource.
+  class ThreeMFMesh
+    attr_reader :vertices, :vertex_indices, :triangle_count
+
+    def initialize(triangles:)
+      @triangles = triangles
+      index_resources
+    end
+
+    def each_indexed_triangle
+      return enum_for(__method__) unless block_given?
+
+      @triangles.each do |triangle|
+        yield triangle.map { |vertex| vertex_indices.fetch(vertex) }
+      end
+    end
+
+    private
+
+    def index_resources
+      @vertices = []
+      @vertex_indices = {}
+      @triangle_count = 0
+
+      @triangles.each do |triangle|
+        validate_triangle!(triangle)
+        triangle.each { |vertex| index_vertex(vertex) }
+        @triangle_count += 1
+      end
+      raise InputError, "3MF mesh contains no triangles" if vertices.empty?
+    end
+
+    def index_vertex(vertex)
+      return if vertex_indices.key?(vertex)
+
+      vertex_indices[vertex] = vertices.length
+      vertices << coordinates(vertex).freeze
+    end
+
+    def validate_triangle!(triangle)
+      valid = triangle.is_a?(Array) && triangle.length == 3 && triangle.all? do |vertex|
+        point = coordinates(vertex)
+        point.length == 3 && point.all? { |value| value.is_a?(Numeric) && value.finite? }
+      end
+      raise InputError, "3MF triangle must contain three finite XYZ vertices" unless valid
+    end
+
+    def coordinates(vertex)
+      vertex.respond_to?(:coordinates) ? vertex.coordinates : vertex
+    end
+  end
+end