193 lines
8.2 KiB
Ruby
193 lines
8.2 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "test_helper"
|
|
|
|
class StandTest < Minitest::Test
|
|
def setup
|
|
@config = MoonModel::Config.new("stand" => { "enabled" => true })
|
|
end
|
|
|
|
def test_orbital_stand_is_printable_and_scales_for_common_moons
|
|
[30.0, 120.0, 203.2].each do |diameter|
|
|
result = MoonModel::Stand.build(@config, diameter)
|
|
stats = result.statistics
|
|
|
|
assert result.mesh.valid?
|
|
assert_manifold result.mesh
|
|
assert_equal "orbital_triskelion_stand", result.mesh.name
|
|
assert_equal "orbital_triskelion", stats["style"]
|
|
assert_in_delta 0.0, result.mesh.bounds[2][0], 1e-9
|
|
assert_connected_oriented_positive result.mesh
|
|
assert_operator stats["measured_noncontact_clearance_mm"], :>=, stats["noncontact_arm_clearance_mm"]
|
|
assert_operator stats["overhang_area_above_45_deg_mm2"], :>, 0
|
|
assert_operator stats["contact_radius_mm"], :<, diameter / 2.0
|
|
assert_operator stats["contact_height_mm"], :>, stats["moon_bottom_clearance_mm"]
|
|
assert_in_delta 10.0, stats["guaranteed_hub_clearance_mm"], 1e-9
|
|
assert_in_delta stats["hub_height_mm"] + 10.0, stats["guaranteed_moon_bottom_height_mm"], 1e-9
|
|
refute stats["bed_capped"]
|
|
end
|
|
end
|
|
|
|
|
|
def test_eight_inch_exaggerated_moon_clears_hub_in_any_rotation
|
|
config = MoonModel::Config.new(
|
|
"size" => { "input" => "diameter", "value" => 8.0, "unit" => "in", "meaning" => "datum" },
|
|
"vertical_exaggeration" => 5.0,
|
|
"stand" => { "enabled" => true },
|
|
"resolution" => { "longitude_segments" => 96 }
|
|
)
|
|
sizing = MoonModel::Sizing.calculate(config, MoonModel::DataSet.new)
|
|
result = MoonModel::Stand.build(config, "envelope_mm" => sizing.final_envelope_mm,
|
|
"minimum_radius_mm" => sizing.minimum_radius_mm,
|
|
"maximum_radius_mm" => sizing.maximum_radius_mm)
|
|
stats = result.statistics
|
|
|
|
assert_equal "terrain_envelope_v3", stats["safety_model"]
|
|
assert_in_delta 10.0, stats["guaranteed_hub_clearance_mm"], 1e-9
|
|
assert_operator stats["guaranteed_moon_bottom_height_mm"], :>=, stats["hub_height_mm"] + 10.0
|
|
assert_operator stats["contact_height_mm"], :>, 30.0
|
|
assert_operator stats["measured_noncontact_clearance_mm"], :>=, stats["noncontact_arm_clearance_mm"]
|
|
end
|
|
|
|
def test_custom_clearance_changes_guaranteed_gap
|
|
config = MoonModel::Config.new("stand" => { "enabled" => true, "base_clearance_mm" => 4.0 })
|
|
result = MoonModel::Stand.build(config, 120.0)
|
|
|
|
assert_in_delta 4.0, result.statistics["guaranteed_hub_clearance_mm"], 1e-9
|
|
end
|
|
|
|
def test_large_moon_stand_is_capped_to_usable_bed
|
|
result = MoonModel::Stand.build(@config, 463.0)
|
|
usable = @config.build_volume.first(2).map { |value| value - 2.0 * @config["edge_clearance_mm"] }
|
|
|
|
assert result.statistics["bed_capped"]
|
|
assert_operator result.statistics["dimensions_mm"][0], :<=, usable[0]
|
|
assert_operator result.statistics["dimensions_mm"][1], :<=, usable[1]
|
|
assert_operator result.statistics["dimensions_mm"][2], :<=, @config.build_volume[2]
|
|
end
|
|
|
|
def test_legacy_stand_configuration_gets_new_style
|
|
config = MoonModel::Config.new("stand" => { "enabled" => true, "material" => nil })
|
|
|
|
assert_equal "orbital_triskelion", config["stand"]["style"]
|
|
assert_equal 10.0, config["stand"]["base_clearance_mm"]
|
|
end
|
|
|
|
def test_current_eight_inch_moon_has_three_concave_paired_pads
|
|
result = MoonModel::Stand.build(@config, "envelope_mm" => 203.659589,
|
|
"minimum_radius_mm" => 100.595822,
|
|
"maximum_radius_mm" => 102.766127)
|
|
stats = result.statistics
|
|
assert_equal 6, stats["branch_count"]
|
|
assert_equal 3, stats["pad_count"]
|
|
assert_nil result.mesh.material
|
|
assert_connected_oriented_positive result.mesh
|
|
radius = stats["contact_radius_mm"]
|
|
sphere = stats["minimum_terrain_radius_mm"]
|
|
center_z = stats["moon_center_height_mm"]
|
|
3.times do |index|
|
|
angle = Math::PI / 3 + index * 2 * Math::PI / 3
|
|
dish = result.mesh.vertices.filter_map do |x,y,z|
|
|
radial = x*Math.cos(angle) + y*Math.sin(angle) - radius
|
|
tangent = -x*Math.sin(angle) + y*Math.cos(angle)
|
|
next unless radial.abs < 1e-6 && tangent.abs < 3.0
|
|
expected = center_z - Math.sqrt(sphere*sphere - x*x - y*y)
|
|
[tangent,z] if (z - expected).abs < 1e-6
|
|
end
|
|
center = dish.min_by { |t,_| t.abs }
|
|
assert_in_delta stats["contact_height_mm"], center[1], 1e-6
|
|
[-1,1].each do |side|
|
|
contact = dish.select { |t,_| t*side > 0.5 }.max_by { |t,_| t.abs }
|
|
refute_nil contact, "dish needs curved surface samples on both sides"
|
|
assert_operator contact[1], :>, center[1], "pad must form a bowl, not a planar fan"
|
|
end
|
|
end
|
|
assert_operator stats["measured_noncontact_clearance_mm"], :>=, 1.0
|
|
end
|
|
|
|
def test_curve_sampling_and_round_profile_resolve_below_thirty_microns
|
|
mesh = MoonModel::Mesh.new(name: "curve_test")
|
|
surface = MoonModel::StandSurface.new(mesh, MoonModel::Stand::CROSS_SECTION_POINTS, 48)
|
|
section = ->(_x,_y,q,z) { z + 3*q }
|
|
a = { center: [0.0,0.0,4.0], section: section }
|
|
b = { center: [100.0,80.0,40.0], section: section }
|
|
from = surface.port(a, 0, 0, 10)
|
|
to = surface.port(b, Math::PI/2, 0, 10)
|
|
rings = surface.rail(from, to, 10, MoonModel::Stand::PATH_STATIONS, section)
|
|
centers = rings.map { |ring| 3.times.map { |axis| ring.sum { |id| mesh.vertices[id][axis] } / ring.length } }
|
|
handle = Math.hypot(100,80)*0.42
|
|
errors = centers.each_cons(2).with_index.map do |(first,last),i|
|
|
t = (i+0.5)/(centers.length-1)
|
|
xy = surface.bezier(a[:center], [handle,0], [100,80+handle], b[:center], t)
|
|
exact = xy + [4+36*surface.smooth(t)]
|
|
Math.sqrt(3.times.sum { |axis| (exact[axis] - (first[axis]+last[axis])/2)**2 })
|
|
end
|
|
assert_operator errors.max, :<, 0.03
|
|
assert_operator 5*(1-Math.cos(Math::PI / MoonModel::Stand::CROSS_SECTION_POINTS)), :<, 0.03
|
|
assert_operator centers[1][2]-centers[0][2], :<, 0.001
|
|
assert_operator centers[-1][2]-centers[-2][2], :<, 0.001
|
|
end
|
|
|
|
def test_rejects_geometry_that_cannot_fit
|
|
tiny_bed = MoonModel::Config.new("printer" => { "build_volume_mm" => [20,20,100] })
|
|
assert_raises(ArgumentError) { MoonModel::Stand.build(tiny_bed, 203.2) }
|
|
assert_raises(ArgumentError) do
|
|
MoonModel::Stand.build(@config, "envelope_mm" => 100, "minimum_radius_mm" => 50, "maximum_radius_mm" => 49)
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def assert_connected_oriented_positive(mesh)
|
|
neighbors = Array.new(mesh.vertices.length) { [] }
|
|
directed_edges = Hash.new(0)
|
|
area_on_table = 0.0
|
|
volume = 0.0
|
|
minimum_area = Float::INFINITY
|
|
mesh.triangles.each do |tri|
|
|
a, b, c = tri.map { |id| mesh.vertices[id] }
|
|
u = b.zip(a).map { |x,y| x-y }
|
|
v = c.zip(a).map { |x,y| x-y }
|
|
normal = [u[1]*v[2]-u[2]*v[1], u[2]*v[0]-u[0]*v[2], u[0]*v[1]-u[1]*v[0]]
|
|
area = Math.sqrt(normal.sum { |n| n*n }) / 2
|
|
minimum_area = [area, minimum_area].min
|
|
area_on_table += area if [a,b,c].all? { |p| p[2].abs < 1e-9 }
|
|
volume += a.zip(normal).sum { |x,y| x*y } / 6
|
|
3.times do |i|
|
|
x, y = tri[i], tri[(i+1)%3]
|
|
neighbors[x] << y
|
|
neighbors[y] << x
|
|
directed_edges[[x,y]] += 1
|
|
end
|
|
end
|
|
seen = { 0 => true }
|
|
queue = [0]
|
|
cursor = 0
|
|
while cursor < queue.length
|
|
neighbors[queue[cursor]].each do |id|
|
|
next if seen[id]
|
|
seen[id] = true
|
|
queue << id
|
|
end
|
|
cursor += 1
|
|
end
|
|
assert_equal mesh.vertices.length, seen.length, "pads, branches, and hub must share one surface"
|
|
assert directed_edges.all? { |(a,b), count| count == 1 && directed_edges[[b,a]] == 1 }
|
|
assert_operator volume, :>, 0
|
|
assert_operator minimum_area, :>, 1e-10
|
|
assert_operator area_on_table, :>, 0
|
|
end
|
|
|
|
def assert_manifold(mesh)
|
|
edge_uses = Hash.new(0)
|
|
mesh.triangles.each do |triangle|
|
|
triangle.each_index do |index|
|
|
edge = [triangle[index], triangle[(index + 1) % triangle.length]].sort
|
|
edge_uses[edge] += 1
|
|
end
|
|
end
|
|
|
|
assert edge_uses.values.all? { |count| count == 2 }, "every mesh edge must belong to exactly two faces"
|
|
end
|
|
end
|