alternative

Author: monkstone

processing_app/library/vecmath/vec2d/basic_circumcircle_sketch.rb

@@ -0,0 +1,90 @@
+# Loosely based on a sketch by Bárbara Almeida
+# https://www.openprocessing.org/sketch/179567
+# Here is a sketch that clearly demonstrates some of the most egregious parts of
+# vanilla processing:-
+# PVector is over complicated and overloads 2D and 3D functionality, cf Vec2D
+# JRubyArt and propane which behaves as a 2D vector (cross product is a float)
+# and can easily be used in chain calculations.
+
+##################################################
+# Usage click on screen with mouse to generate a point, repeat as required
+# to create a triangle, and the circumcircle will be drawn unless the points are
+# collinear. Additional clicks erase the first point and add a new point. To
+# demonstrate the stupid processing coordinate convention press 'c' or 'C', you
+# will see the graph is inverted and origin y is top left, also demonstrates
+# the collinearity test press space-bar to clear
+##################################################
+
+load_library :simple_circle # but does not use math_point
+
+attr_reader :pnt, :points, :circle, :renderer
+
+def settings
+  size 800, 800, P2D
+  # pixel_density(2) # for HiDpi screens
+  # smooth # see https://processing.org/reference/smooth_.html
+end
+
+def setup
+  sketch_title 'Simplified Circumcircle Sketch'
+  @pnt = Vec2D.new
+  @points = SimplePoints.new
+  ellipse_mode RADIUS
+  @renderer = AppRender.new(self)
+end
+
+def draw
+  graph_paper
+  stroke_weight 4
+  stroke 200, 0, 0
+  point(pnt.x, pnt.y)
+  points.map { |pt| point(pt.x, pt.y) }
+  return unless points.full?
+  return render_triangle if points.collinear? # Renders a straight line
+  circle = Circumcircle.new(points)
+  circle.calculate
+  center = circle.center
+  point(center.x, center.y)
+  no_fill
+  stroke_weight 2
+  render_triangle
+  stroke 0, 0, 255, 100
+  ellipse(center.x, center.y, circle.radius, circle.radius)
+end
+
+def mouse_pressed
+  points << Vec2D.new(mouse_x, mouse_y)
+end
+
+def render_triangle
+  stroke 255, 255, 0, 100
+  begin_shape
+  points.each do |point|
+    point.to_vertex(renderer)
+  end
+  end_shape(CLOSE)
+end
+
+def key_pressed
+  case key
+  when ' '
+    points.clear
+  when 'c', 'C'
+    (0..400).step(200) do |i|
+      points << Vec2D.new(i, i)
+    end
+    puts 'collinear points' if points.collinear?
+  end
+end
+
+def graph_paper
+  background(180)
+  cell_size = 20 # size of the grid
+  (0..width).step(cell_size) do |i|
+    stroke(75, 135, 155)
+    line(i, 0, i, height)
+  end
+  (0..height).step(cell_size) do |i|
+    line(0, i, width, i)
+  end
+end

processing_app/library/vecmath/vec2d/circumcircle.md

@@ -0,0 +1,11 @@
+### Dealing with processing coordinate system ###
+
+If you want to create Math Sketches in processing, you need to deal with peculiar coordinate systems, where the Y-axis is inverted in theory you should be able to do.
+
+```ruby
+scale(1, -1)
+translate(0, -height)
+```
+But that will mess up any text (plus you probably need to `push_matrix` and `pop_matrix`) so it is probably simpler to create a parallel coordinate system for the math, and translate that back to the screen (using the processing `map` function or in `propane` and `JRubyArt` use `map1d`).
+
+We have done this in `circumcircle_sketch.rb` or just accept the processing coordinate system as we have with `basic_cirmcumcircle_sketch.rb` (it is much simpler).

processing_app/library/vecmath/vec2d/library/simple_circle/lib/circumcircle.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+PBisector = Struct.new(:vector, :angle) # perpendicular bisector
+Vect = Struct.new(:x, :y, :z) # for calculation of center
+# Circumcircle from 3 points
+class Circumcircle
+  include Math
+  attr_reader :center, :radius, :points
+  def initialize(points)
+    @points = points
+  end
+
+  def calculate
+    ab = bisector(points[0], points[1]) # find 2 midpoints
+    bc = bisector(points[1], points[2])
+    @center = circumcenter(ab, bc)
+    @radius = center.dist(points[2]) # points[2] = c
+  end
+
+  def bisector(a, b)
+    midpoint = (a + b) / 2.0 # middle of ab (or bc)
+    theta = atan2(b.y - a.y, b.x - a.x) # slope of ab (or bc)
+    PBisector.new(midpoint, theta - PI / 2)
+  end
+
+  def circumcenter(pb1, pb2)
+    # equation of the first bisector (ax - y =  -b)
+    a0 = tan pb1.angle
+    v0 = pb1.vector
+    a1 = tan pb2.angle
+    v1 = pb2.vector
+    eq0 = Vect.new(a0, -1, -1 * (v0.y - v0.x * a0))
+    eq1 = Vect.new(a1, -1, -1 * (v1.y - v1.x * a1))
+    # calculate x and y coordinates of the circumcenter
+    ox = (eq1.y * eq0.z - eq0.y * eq1.z) /
+         (eq0.x * eq1.y - eq1.x * eq0.y)
+    oy = (eq0.x * eq1.z - eq1.x * eq0.z) /
+         (eq0.x * eq1.y - eq1.x * eq0.y)
+    Vec2D.new(ox, oy)
+  end
+end

processing_app/library/vecmath/vec2d/library/simple_circle/lib/simple_points.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'forwardable'
+MAX_POINT = 3
+# A collection of a maximum of 3 points in the processing world
+# includes a collinearity test using Vec2D
+class SimplePoints
+  extend Forwardable
+  def_delegators(:@points, :each, :map, :size, :shift, :clear, :[])
+  include Enumerable
+
+  attr_reader :points
+
+  def initialize
+    @points = []
+  end
+
+  def <<(pt)
+    points << pt
+    shift if size > MAX_POINT
+  end
+
+  def collinear?
+    full? ? (points[0] - points[1]).cross(points[1] - points[2]).zero? : false
+  end
+
+  def full?
+    points.length == MAX_POINT
+  end
+end

processing_app/library/vecmath/vec2d/library/simple_circle/simple_circle.rb

@@ -0,0 +1,2 @@
+require_relative 'lib/circumcircle'
+require_relative 'lib/simple_points'