@@ -4,32 +4,47 @@ require 'curves/hermite' module CelticKnot class Builder - attr_reader :graph, :knot + attr_reader :graph, :knot, :state def initialize(graph) @graph = graph @knot = Knot.new - @node_i = @edge_j = @thread_i = @connection_j = 0 - @edge = @thread = @direction = @midpoint = nil - @step = 0 + set_state(:crossings) end def next_step - @step += 1 - if @node_i < graph.nodes.length + case @state + when :crossings if @thread continue_thread else start_thread end - elsif @thread_i < knot.threads.length - @thread = knot.threads[@thread_i] + when :curves define_thread + when :overlap + compute_overlaps + when :done + return nil + else + raise "invalid state #{state.inspect}" end end private + def set_state(state) + @state = state + @node_i = @edge_j = @thread_i = 0 + @edge = @thread = @connection = @direction = @midpoint = nil + @stack = [] + end + + def transition_to(state) + set_state(state) + return next_step + end + def next_edge @edge_j += 1 @@ -41,7 +56,9 @@ module CelticKnot def start_thread loop do - @node = graph.nodes[@node_i] or return nil + return transition_to(:curves) if @node_i >= graph.nodes.length + + @node = graph.nodes[@node_i] @edge = @node.edges[@edge_j] if @edge.nil? @@ -55,6 +72,7 @@ module CelticKnot else puts "thread ------>" @thread = knot.new_thread + @step = 0 # direction is either "clockwise" or "counter-clockwise", # and refers to the direction the cable would travel if it were to @@ -75,6 +93,8 @@ puts "thread ------>" end def continue_thread + @step += 1 + far = @edge.other(@node) parallel = far - @node vector = @edge.vector(parallel, @direction) @@ -87,6 +107,7 @@ puts "thread ------>" far_edge = far.nearest_edge_to(@edge, @direction) difference = @edge.difference(far_edge, @direction) + difference = 1.0 if difference == 0.0 puts "%d: %s %s" % [@step, @node, @edge] puts " far edge: %s" % far_edge @@ -95,7 +116,7 @@ puts " vector: %s" % vector puts " midpoint: %s" % @midpoint puts " direction: %s" % @direction puts " difference: %f" % difference - @thread.add_connection(@midpoint, vector, 4.5 * difference) + @thread.add_connection(@midpoint, vector, 4.5 * difference, @edge.normal?) @edge.mark(@node, @direction) @@ -117,20 +138,59 @@ puts " difference: %f" % difference end def next_connection - @connection_j += 1 + @connection = @connection[:next] - if @connection_j >= @thread.connections.length - @connection_j = 0 + if @connection == thread.head @thread_i += 1 + @connection = thread && thread.head end end + def thread + knot.threads[@thread_i] + end + def define_thread - near = @thread.connections[@connection_j] - far = @thread.connections[(@connection_j + 1) % @thread.connections.length] + return transition_to(:overlap) if thread.nil? + + @connection ||= thread.head + + near = @connection + far = @connection[:next] + near[:curve] = Curves::Hermite.new([near[:at], near[:vector] * near[:magnitude], far[:at], far[:vector] * near[:magnitude]]) + next_connection + return knot end + + def compute_overlaps + worker = Proc.new do |start, offset| + c = start + loop do + if c[:intersection] + if c[:offset] + offset = c[:offset] + else + c[:offset] = offset + end + + offset = -offset + + crosses = knot.overlaps[c[:at]] + other = crosses[0][:thread] == thread ? crosses[1] : crosses[0] + worker[other, offset] unless other[:offset] + end + + c = c[:next] + break if c == start + end + end + + knot.threads.each { |thread| worker[thread.head, 1] } + + return transition_to(:done) + end end end lib/celtic_knot/builder.rb @@ -3,13 +3,15 @@ require 'celtic_knot/thread' module CelticKnot class Knot attr_reader :threads + attr_reader :overlaps def initialize @threads = [] + @overlaps = Hash.new { |h,k| h[k] = [] } end def new_thread - thread = Thread.new + thread = Thread.new(self) @threads << thread return thread end lib/celtic_knot/knot.rb @@ -1,20 +1,50 @@ module CelticKnot class Thread - attr_reader :connections + attr_reader :knot + attr_reader :head + attr_reader :tail - def initialize - @connections = [] + def initialize(knot) + @knot = knot + @head = @tail = nil end - def add_connection(point, vector, magnitude) - connections << { :at => point, :vector => vector, :vnorm => vector.normalize, :magnitude => magnitude } + def each_connection + c = head + loop do + yield c + c = c[:next] + break if c == head + end + self + end + + def add_connection(point, vector, magnitude, intersection) + connection = { :at => point, + :vector => vector, + :vnorm => vector.normalize, + :magnitude => magnitude, + :thread => self, + :intersection => intersection } + + knot.overlaps[point] << connection + + @head ||= connection + @tail ||= connection + + @tail[:next] = connection + @head[:prev] = connection + + connection[:prev] = @tail + connection[:next] = @head + + @tail = connection + self end def closes?(point, vector) - connections.first && - connections.first[:at] == point && - connections.first[:vnorm] == vector.normalize + head && head[:at] == point && head[:vnorm] == vector.normalize end end end lib/celtic_knot/thread.rb 95db7ecc70ce48b0688610361d4598e2ae1311ba Jamis Buck jamis@37signals.com http://github.com/jamis/celtic_knot/commit/afa29ac19a6e6792895c627ff49c6ea75a6bb9cb afa29ac19a6e6792895c627ff49c6ea75a6bb9cb 2009-06-07T21:11:49-07:00 2009-06-07T21:11:49-07:00 get over/under calculations working right 9059322051500d6cb708b049cefa1dec6b7950d1 Jamis Buck jamis@37signals.com