standard_draw_tk 0.1.0

data/README.md

@@ -0,0 +1,74 @@
+# Standard Draw TK
+
+I was going through the [Algorithms 4th edition](https://algs4.cs.princeton.edu/home/) and wanted to write the algorithms in ruby instead of the default java. The book uses the [Princeton Standard Libraries](https://introcs.cs.princeton.edu/java/stdlib/) to help clarify the code. I've added a simple [jruby wrapper gem](https://rubygems.org/gems/princeton_standard_libraries) that lets you call the original java code in Jruby.
+
+I really would like to call this code in standard ruby. So I'm attempting to keep the original interface while recreating the logic using the [ruby TK gem](https://github.com/ruby/tk).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'standard_draw_tk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install standard_draw_tk
+Ruby doesn't contain TK by default anymore. And installing the TK gem requires a bit of manual installation depending on the system. I followed this [blog post](https://saveriomiroddi.github.io/Installing-ruby-tk-bindings-gem-on-ubuntu/) to get it working on linux.
+
+## Usage
+
+The drawing of geometric shapes has been implemented though there are probably some small tweaks that need to be added, e.g. the line ends of arcs.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Things to implement:
+
+### Drawing geometric shapes
+* [x] line
+* [x] point
+* [x] pixel
+* [x] rectangle
+* [x] filled_rectangle
+* [x] polygon
+* [x] filled_polygon
+* [x] circle
+* [x] filled_circle
+* [x] ellipse
+* [x] filled_ellipse
+* [x] arc
+* [x] square
+* [x] filled_square
+
+### Drawing images
+
+### Drawing text
+* [ ] get/set font
+* [ ] text centered at x,y
+* [ ] text centered at x,y with degree rotation
+* [ ] text left aligned x,y
+* [ ] text right aligned x,y
+
+### Saving drawing to a file
+* [ ] save to jpg
+
+### Mouse interactions
+
+### Keyboard interactions
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gregors/standard_draw_tk.
+
+## License
+
+The gem is available as open source under the terms of the [GNU General Public License, version 3 (GPLv3)](http://www.gnu.org/copyleft/gpl.html).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "standard_draw_tk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/arcs.rb

@@ -0,0 +1,6 @@
+require 'standard_draw_tk'
+
+StdDraw.pen_color = 'red'
+StdDraw.pen_radius = 0.02
+StdDraw.arc(0.8, 0.2, 0.1, 200, 45)
+StdDraw.pause

data/examples/circles.rb

@@ -0,0 +1,8 @@
+require 'standard_draw_tk'
+
+StdDraw.filled_circle(0.5, 0.5, 0.10)
+
+1.upto(50) do |i|
+  StdDraw.circle(0.5, 0.5, 1.0/i)
+end
+StdDraw.pause

data/examples/ellipse.rb

@@ -0,0 +1,5 @@
+require 'standard_draw_tk'
+
+StdDraw.ellipse(0.5, 0.5, 0.20, 0.10)
+StdDraw.filled_ellipse(0.20, 0.20, 0.05, 0.20)
+StdDraw.pause

data/examples/example1.rb

@@ -0,0 +1,13 @@
+require 'standard_draw_tk'
+
+n = 100
+StdDraw.set_xscale(0,n)
+StdDraw.set_yscale(0,n*n)
+StdDraw.pen_radius = 0.01
+
+0.upto(n) do |i|
+  StdDraw.point(i, i)
+  StdDraw.point(i, i*i)
+  StdDraw.point(i, i*Math.log(i))
+end
+StdDraw.pause

data/examples/example2.rb

@@ -0,0 +1,17 @@
+require 'standard_draw_tk'
+
+n = 50
+a = []
+
+0.upto(n) do |i|
+  a[i] = rand
+end
+
+0.upto(n) do |i|
+  x = 1.0 * i / n
+  y = a[i] / 2.0
+  rw = 0.5 / n
+  rh = a[i] / 2.0
+  StdDraw.filled_rectangle(x, y, rw, rh)
+end
+StdDraw.pause

data/examples/example3.rb

@@ -0,0 +1,19 @@
+require 'standard_draw_tk'
+
+n = 50
+a = []
+
+0.upto(50) do |i|
+  a[i] = rand
+end
+
+a.sort!
+
+0.upto(50) do |i|
+  x = 1.0 * i / n
+  y = a[i] / 2.0
+  rw = 0.5 / n
+  rh = a[i] / 2.0
+  StdDraw.filled_rectangle(x, y, rw, rh)
+end
+StdDraw.pause

data/examples/points.rb

@@ -0,0 +1,8 @@
+require 'standard_draw_tk'
+
+StdDraw.pen_radius = 0.05
+StdDraw.pen_color = 'blue'
+StdDraw.point(0.5, 0.5)
+StdDraw.pen_color = 'red'
+StdDraw.point(0.8, 0.8)
+StdDraw.pause

data/examples/polygon.rb

@@ -0,0 +1,10 @@
+require 'standard_draw_tk'
+
+x = [ 0.1, 0.2, 0.3, 0.2 ]
+y = [ 0.2, 0.3, 0.2, 0.1 ]
+StdDraw.filled_polygon(x, y)
+
+x = [ 0.3, 0.4, 0.5, 0.4 ]
+y = [ 0.4, 0.5, 0.4, 0.3 ]
+StdDraw.polygon(x, y)
+StdDraw.pause

data/examples/rectangle.rb

@@ -0,0 +1,5 @@
+require 'standard_draw_tk'
+
+StdDraw.filled_rectangle(0.5, 0.5, 0.05, 0.08)
+StdDraw.rectangle(0.10, 0.5, 0.08, 0.05)
+StdDraw.pause

data/examples/square.rb

@@ -0,0 +1,5 @@
+require 'standard_draw_tk'
+
+StdDraw.filled_square(0.5, 0.5, 0.05)
+StdDraw.square(0.10, 0.5, 0.05)
+StdDraw.pause

data/examples/triangle.rb

@@ -0,0 +1,8 @@
+require 'standard_draw_tk'
+
+t = Math.sqrt(3.0) / 2.0
+StdDraw.line(0.0, 0.0, 1.0, 0.0)
+StdDraw.line(1.0, 0.0, 0.5, t)
+StdDraw.line(0.5, t, 0.0, 0.0)
+StdDraw.point(0.5, t/3.0)
+StdDraw.pause

data/lib/coordinates.rb

@@ -0,0 +1,61 @@
+class StandardDrawTk::Coordinates
+  BORDER = 0.00
+  DEFAULT_MIN = 0.0
+  DEFAULT_MAX = 1.0
+  DEFAULT_SIZE = 512
+
+  attr_reader :width, :height
+
+  def initialize
+    @height = @width = DEFAULT_SIZE
+    @xmin = @ymin = DEFAULT_MIN
+    @xmax = @ymax = DEFAULT_MAX
+  end
+
+  def init
+    set_xscale(DEFAULT_XMIN, DEFAULT_XMAX)
+    set_yscale(DEFAULT_YMIN, DEFAULT_YMAX)
+  end
+
+  def scale_x(x)
+    @width  * (x - @xmin) / (@xmax - @xmin)
+  end
+
+  def scale_y(y)
+    @height * (@ymax - y) / (@ymax - @ymin)
+  end
+
+  def factor_x(w)
+    w * @width  / (@xmax - @xmin).abs
+  end
+
+  def factor_y(h)
+    h * @height / (@ymax - @ymin).abs
+  end
+
+  def user_x(x)
+    @xmin + x * (@xmax - @xmin) / @width
+  end
+
+  def user_y(y)
+    @ymax - y * (@ymax - @ymin) / @height
+  end
+
+  def box(x, y, r)
+    [x - r, y - r, x + r, y + r]
+  end
+
+  def set_xscale(min, max)
+    size = max - min
+    throw 'the min and max are the same' if size == 0.0
+    @xmin = min - BORDER * size
+    @xmax = max + BORDER * size
+  end
+
+  def set_yscale(min, max)
+    size = max - min
+    throw 'the min and max are the same' if size == 0.0
+    @ymin = min - BORDER * size
+    @ymax = max + BORDER * size
+  end
+end

data/lib/standard_draw_tk.rb

@@ -0,0 +1,196 @@
+require 'standard_draw_tk/version'
+require 'tk'
+require_relative './coordinates'
+
+class StdDraw
+  @@pen_radius = DEFAULT_PEN_RADIUS = 0.002
+
+  @@coords = StandardDrawTk::Coordinates.new
+
+  @@color = 'black'
+  @@bg_color = 'white'
+
+  @@root = TkRoot.new
+  @@root.title = 'Standard Draw'
+  @@canvas = TkCanvas.new(@@root) do
+    height @@coords.height
+    width @@coords.width
+    bg @@bg_color
+  end
+  @@canvas.pack
+  @@thread = Thread.new do
+    Tk.mainloop
+  end
+
+  def self.coords
+    @@coords
+  end
+
+  def self.set_xscale(min,max)
+    coords.set_xscale(min,max)
+  end
+
+  def self.set_yscale(min,max)
+    coords.set_yscale(min,max)
+  end
+
+  def self.pen_radius=(radius)
+    throw 'pen radius must be nonnegative' if radius <= 0
+    @@pen_radius = radius
+  end
+
+  def self.pen_color=(color)
+    @@color = color
+  end
+
+  def self.color
+    @@color
+  end
+
+  def self.line(x0, y0, x1, y1)
+    x0 = coords.scale_x(x0)
+    y0 = coords.scale_y(y0)
+    x1 = coords.scale_x(x1)
+    y1 = coords.scale_y(y1)
+    TkcLine.new(@@canvas, x0, y0, x1, y1, fill: color)
+  end
+
+  def self.arc(x, y, radius, angle1, angle2)
+    throw 'arc radius must be nonnegative' if radius < 0
+    while angle2 < angle1
+      angle2 += 360
+    end
+    xs = coords.scale_x(x)
+    ys = coords.scale_y(y)
+    ws = coords.factor_x(2*radius)
+    hs = coords.factor_y(2*radius)
+    if ws <= 1 && hs <= 1
+      pixel(x, y)
+    else
+      x1 = xs - ws/2
+      y1 = ys - hs/2
+      x2 = x1 + ws
+      y2 = y1 + hs
+      scaled_pen_radius = @@pen_radius * StandardDrawTk::Coordinates::DEFAULT_SIZE
+      TkcArc.new(@@canvas, x1, y1, x2, y2, style: :arc, start: angle1, extent: angle2 - angle1, fill: color, width: scaled_pen_radius, outline: color)
+    end
+  end
+
+  def self.circle(x, y, radius)
+    draw_circle(x, y, radius, outline: color)
+  end
+
+  def self.ellipse(x, y, w, h)
+    draw_ellipse(x, y, w, h, outline: color)
+  end
+
+  def self.filled_ellipse(x, y, w, h)
+    draw_ellipse(x, y, w, h, fill: color)
+  end
+
+  def self.filled_circle(x, y, radius)
+    draw_circle(x, y, radius, fill: color)
+  end
+
+  def self.rectangle(x, y, half_width, half_height)
+    draw_rectangle(x, y, half_width, half_height, outline: color)
+  end
+
+  def self.filled_rectangle(x, y, half_width, half_height)
+    draw_rectangle(x, y, half_width, half_height, fill: color)
+  end
+
+  def self.square(x, y, half_length)
+    draw_rectangle(x, y, half_length, half_length, outline: color)
+  end
+
+  def self.filled_square(x, y, half_length)
+    draw_rectangle(x, y, half_length, half_length, fill: color)
+  end
+
+  def self.point(x, y)
+    draw_circle(x, y, @@pen_radius, outline: color, fill: color)
+  end
+
+  def self.pixel(x, y)
+    puts 'pixel'
+    x1 = coords.scale_x(x).round
+    y1 = coords.scale_y(y).round
+    TkcRectangle.new(@@canvas, [x1, y1, x1 + 1, y1 + 1], outline: color, fill: color)
+  end
+
+  def self.pause
+    @@thread.join
+  end
+
+  def self.polygon(x, y)
+    draw_polygon(x, y, outline: color)
+  end
+
+  def self.filled_polygon(x, y)
+    draw_polygon(x, y, fill: color)
+  end
+
+  private
+
+  def self.draw_polygon(x, y, fill: '', outline: nil)
+    throw 'x-coordinate array is null' if x.nil?
+    throw 'y-coordinate array is null' if y.nil?
+    throw 'arrays must be of the same length' if x.size != y.size
+    return if x.empty?
+    x = x.map{|i| coords.scale_x(i)}
+    y = y.map{|i| coords.scale_y(i)}
+    points = x.zip(y).flatten
+    scaled_pen_radius = @@pen_radius * StandardDrawTk::Coordinates::DEFAULT_SIZE
+    TkcPolygon.new(@@canvas, *points, width: scaled_pen_radius, fill: fill, outline: outline)
+  end
+
+  def self.draw_ellipse(x, y, w, h, outline: nil, fill: nil)
+    throw 'semi_major_axis must be nonnegative' if w < 0
+    throw 'semi_minor_axis must be nonnegative' if h < 0
+
+    xs = coords.scale_x(x)
+    ys = coords.scale_y(y)
+    ws = coords.factor_x(2*w)
+    hs = coords.factor_y(2*h)
+    if ws <= 1 && hs <= 1
+      pixel(x, y)
+    else
+      x1 = xs - ws/2
+      y1 = ys - hs/2
+      b = [x1, y1, x1 + ws, y1 + hs]
+      TkcOval.new(@@canvas, b, outline: outline, fill: fill)
+    end
+  end
+
+  def self.draw_circle(x, y, radius, outline: nil, fill: nil)
+    throw 'radius must be nonnegative' if radius < 0
+    xs = coords.scale_x(x)
+    ys = coords.scale_y(y)
+    scaled_pen_radius = radius * StandardDrawTk::Coordinates::DEFAULT_SIZE
+    if scaled_pen_radius <= 1
+      pixel(x, y)
+    else
+      b = coords.box(xs, ys, scaled_pen_radius/2)
+      TkcOval.new(@@canvas, b, outline: outline, fill: fill)
+    end
+  end
+
+  def self.draw_rectangle(x, y, half_width, half_height, outline: nil, fill: nil)
+    throw 'half width must be nonnegative' if half_width < 0
+    throw 'half height must be nonnegative' if half_height < 0
+
+    ws = coords.factor_x(2*half_width)
+    hs = coords.factor_y(2*half_height)
+
+    if (ws <= 1 && hs <= 1)
+      pixel(x, y)
+    else
+      xs = coords.scale_x(x)
+      ys = coords.scale_y(y)
+      x = xs - ws/2
+      y = ys - hs/2
+      TkcRectangle.new(@@canvas, x, y, x + (ws-1), y + (hs-1), outline: outline, fill: fill)
+    end
+  end
+end