bezier 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3aed71560a6e593488935c03515b4051250972f
+  data.tar.gz: 2f72e82dff6eb6e86f05fc077a2bc4d4af6b5cbd
+SHA512:
+  metadata.gz: fdce08938f49c4d32b9cb53cd8bc8952ba1e4c8434d87e6fa34a0a80288c79ec740e07a10f3a1fe9704255fe0c4a0d41db6651605f76f83856db4d2699d06045
+  data.tar.gz: 6ed226250dd075889198c9c17a442e4a68dfbd3cc768000c4a75682c45daa3255d8e80e50d559c8eb756f78779cbcf514009d92a36324db8a015e1451700cc6f

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+Gemfile.lock
+doc
+.yardoc
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Yihang Ho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,16 @@
+# Bézier
+A Ruby library to draw Bézier curves.
+
+# Quick Start
+
+```ruby
+require 'bezier'
+
+p0 = Bezier::Point.new(20, 20)
+p1 = Bezier::Point.new(20, 100)
+p2 = Bezier::Point.new(200, 100)
+p3 = Bezier::Point.new(200, 20)
+
+bezier = Bezier::Bezier.new(p0, p1, p2, p3)
+Bezier::Painter.new(bezier.run).save # Check Bézier.png
+```

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake/testtask'
+require 'yard'
+require 'yard-tomdoc'
+
+task default: [:test]
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/test_*.rb'
+  test.verbose = true
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.options = ['--plugin', 'tomdoc']
+end

data/bezier.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = 'bezier'
+  s.version     = '0.0.1'
+  s.license     = 'MIT'
+  s.summary     = 'Draw a Bézier curve'
+  s.description = 'Library to draw Bézier curves'
+  s.author      = 'Yihang Ho'
+  s.email       = 'me@yihangho.com'
+  s.homepage    = 'https://github.com/yihangho/bezier'
+
+
+  s.files = `git ls-files`.split($/)
+
+  s.add_runtime_dependency('chunky_png', '~> 1.3.1')
+
+  s.add_development_dependency('rake', '~> 10.3.1')
+  s.add_development_dependency('minitest', '~> 5.3.3')
+  s.add_development_dependency('yard', '~> 0.8.7.4')
+  s.add_development_dependency('yard-tomdoc', '~> 0.7.1')
+end

data/lib/bezier.rb

@@ -0,0 +1,4 @@
+require 'bezier/point'
+require 'bezier/math'
+require 'bezier/bezier'
+require 'bezier/painter'

data/lib/bezier/bezier.rb

@@ -0,0 +1,45 @@
+module Bezier
+  class Bezier
+    # Public: Gets/Sets the control points
+    attr_accessor :control_points
+
+    # Public: Construct a new instance of Bezier
+    #
+    # crit_points - The control points of this Bezier curve. They should be
+    #                instances of Point.
+    def initialize(*control_points)
+      self.control_points = control_points
+    end
+
+    # Public: Get the degree of this Bezier curve
+    #
+    # Returns a number
+    def degrees
+      control_points.length - 1
+    end
+
+    # Public: Get a point on the Bezier curve
+    #
+    # t - An integer in the interval [0, 1]
+    #
+    # Returns a Point
+    def point_from_t(t)
+      return nil if t < 0 || t > 1
+      output = Point.new(*Array.new(control_points[0].dimensions) { 0 })
+      for i in 0..degrees
+        coefficient = Math.combination(degrees, i) * ((1 - t) ** (degrees - i)) * (t ** i)
+        output += control_points[i] * coefficient
+      end
+      output
+    end
+
+    # Public: "Plot" the Bezier curve.
+    #
+    # num_points - The number of points to produce. (Default: 1000)
+    #
+    # Returns an Array of Points
+    def run(num_points = 1000)
+      Array.new(num_points) { |i| point_from_t(i * 1.0 / (num_points - 1)) }
+    end
+  end
+end

data/lib/bezier/math.rb

@@ -0,0 +1,29 @@
+module Bezier
+  # Public: Math-related stuff
+  class Math
+    # Public: Calculate the number of combinations
+    #
+    # n - A non-negative Integer, the number of items in a set
+    # r - A non-negative Integer, the number of items to be chosen from the set.
+    #     r should be at most as large as n
+    #
+    # Examples
+    #
+    #   Bezier::Math.combination(10, 8)
+    #   => 45
+    #
+    # Returns an Integer if the combination can be calculated, nil otherwise.
+    def self.combination(n, r)
+      return nil unless n.is_a?(Integer) && r.is_a?(Integer)
+      return nil unless n >= 0 && r >= 0
+      return nil if r > n
+
+      output = 1
+      for i in 1..r
+        output *= (n - i + 1)
+        output /= i
+      end
+      output
+    end
+  end
+end

data/lib/bezier/painter.rb

@@ -0,0 +1,65 @@
+require 'chunky_png'
+
+module Bezier
+  # Public: Paint an Array of Points into a PNG file
+  class Painter
+    # Public: The Array of Points to be drawn.
+    attr_accessor :points
+
+    # Public: The path to the output file.
+    attr_accessor :path
+
+    # Public: The padding to be added to the edges of the image.
+    attr_accessor :padding
+
+    # Public: Contruct a new instance of Bezier::Painter.
+    #
+    # Examples
+    #
+    #   painter = Bezier::Painter.new do |p|
+    #     p.points  = [...]
+    #     p.path    = "Bézier.png"
+    #     p.padding = 20
+    #   end
+    def initialize
+      self.points  = []
+      self.path    = "Bézier.png"
+      self.padding = 10
+      yield(self) if block_given?
+    end
+
+    # Public: Save the PNG
+    #
+    # Returns nothing
+    def save
+      image = ChunkyPNG::Image.new(parameters[:width], parameters[:height], ChunkyPNG::Color::WHITE)
+      points.each do |pt|
+        x = pt.x - parameters[:x_offset]
+        y = pt.y - parameters[:y_offset]
+        image[x.round, y.round] = ChunkyPNG::Color::BLACK
+      end
+      p image.class
+      image.save(path)
+    end
+
+    # Internal: Get the parameters associated with this PNG.
+    #
+    # Returns a Hash
+    def get_parameters
+      output = {}
+
+      output[:x_min] = self.points.min_by { |p| p.x }.x
+      output[:x_max] = self.points.max_by { |p| p.x }.x
+      output[:y_min] = self.points.min_by { |p| p.y  }.y
+      output[:y_max] = self.points.max_by { |p| p.y  }.y
+
+      output[:width]  = (output[:x_max] - output[:x_min] + 2 * self.padding).ceil
+      output[:height] = (output[:y_max] - output[:y_min] + 2 * self.padding).ceil
+
+      output[:x_offset] = output[:x_min] - self.padding
+      output[:y_offset] = output[:y_min] - self.padding
+
+      output
+    end
+  end
+end

data/lib/bezier/point.rb

@@ -0,0 +1,124 @@
+module Bezier
+  # Public: Stuff related to N-dimensional Points
+  class Point
+    # Public: Gets/Sets coordinates
+    attr_accessor :coordinates
+
+    # Public: Construct an instance of Point.
+    #
+    # *coordinates - N numbers describing an N-dimensional Point.
+    #
+    # Examples
+    #
+    #   Bezier::Point.new(1, 2, 3)
+    def initialize(*coordinates)
+      self.coordinates = coordinates
+    end
+
+    # Public: Get the dimension.
+    #
+    # Returns a number
+    def dimensions
+      coordinates.length
+    end
+
+    # Public: Get the first element of the coordinates
+    #
+    # Returns a number
+    def x
+      coordinates.first
+    end
+
+    # Public: Get the last element of the coordinates
+    #
+    # Returns a number
+    def y
+      coordinates.last
+    end
+
+    # Public: Vector addition.
+    #
+    # another - Another instance of Point having the same dimension as the
+    #           current Point
+    #
+    # Examples
+    #
+    #   Bezier::Point.new(1, 2, 3) + Bezier::Point.new(4, 5, 6)
+    #   => (5, 7, 9)
+    #
+    #   Bezier::Point.new(1, 2) + Bezier::Point.new(1, 2, 3)
+    #   => nil
+    #
+    # Returns a new Point if addition can be carried out, nil otherwise
+    def +(another)
+      if another.respond_to?(:coordinates) && another.dimensions == dimensions
+        new_coordinates = []
+        coordinates.each_index do |i|
+          new_coordinates << coordinates[i] + another.coordinates[i]
+        end
+        self.class.new(*new_coordinates)
+      else
+        nil
+      end
+    end
+
+    # Public: Equality test
+    #
+    # another - Another instance of Point to be tested for equality
+    #
+    # Examples
+    #
+    #   Bezier::Point.new(1, 2) == Bezier::Point.new(1, 2)
+    #   => true
+    #
+    #   Bezier::Point.new(1, 2) == Bezier::Point.new(1, 2, 3)
+    #   => false
+    #
+    # Returns a Boolean
+    def ==(another)
+      another.respond_to?(:coordinates) && coordinates == another.coordinates
+    end
+
+    # Public: Scalar multiplication
+    #
+    # scalar - A number (instance of Numeric)
+    #
+    # Examples
+    #
+    #   Bezier::Point.new(1, 2) * 2
+    #   => (2, 4)
+    #
+    #   Bezier::Point.new(1, 2) * -1.2
+    #   => (-1.2, -2.4)
+    #
+    # Returns a Point if multiplication can be carried out, nil otherwise
+    def *(scalar)
+      if scalar.is_a? Numeric
+        new_coordinates = coordinates.map { |x| scalar * x }
+        self.class.new(*new_coordinates)
+      else
+        nil
+      end
+    end
+
+    # Public: Calculate the distance between two points
+    #
+    # another - A Point
+    #
+    # Examples
+    #
+    #   Bezier::Point.new(3, 4).distance Bezier::Point.new(0, 0)
+    #   => 5
+    #
+    # Returns a number if the distance is calculable, nil otherwise
+    def distance(another)
+      return nil unless another.respond_to?(:coordinates) && another.dimensions == dimensions
+
+      square_diff = 0
+      coordinates.each_index do |i|
+        square_diff += (coordinates[i] - another.coordinates[i]) ** 2
+      end
+      ::Math.sqrt(square_diff)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require 'bezier'

data/test/test_bezier.rb

@@ -0,0 +1,52 @@
+require 'helper'
+
+describe Bezier::Bezier do
+  before do
+    coordinates     = [[20, 20], [20, 100], [200, 100], [200, 20]]
+    @control_points = Array.new(4) { |i| Bezier::Point.new *coordinates[i] }
+    @bezier         = Bezier::Bezier.new *@control_points
+  end
+
+  describe "#control_points" do
+    it "should be an Array" do
+      assert_instance_of Array, @bezier.control_points
+    end
+
+    it "should give the correct control points" do
+      assert_equal @bezier.control_points, @control_points
+    end
+  end
+
+  describe "#degrees" do
+    it "should give the correct degrees" do
+      assert_equal @bezier.degrees, @control_points.length - 1
+    end
+  end
+
+  describe "#point_from_t" do
+    it "should return P0 when t = 0" do
+      assert_equal @bezier.point_from_t(0), @control_points.first
+    end
+
+    it "should return PN when t = 1" do
+      assert_equal @bezier.point_from_t(1), @control_points.last
+    end
+
+    it "should return nil when t is not in [0, 1]" do
+      assert_nil @bezier.point_from_t(-1)
+      assert_nil @bezier.point_from_t(100)
+    end
+
+    it "should return the correct point elsewhere" do
+      assert_equal @bezier.point_from_t(0.5), Bezier::Point.new(110, 80)
+    end
+  end
+
+  describe "#run" do
+    it "should return an Array of correct length" do
+      assert_instance_of Array, @bezier.run(2)
+      assert_equal @bezier.run(2).length, 2
+      assert_equal @bezier.run(50).length, 50
+    end
+  end
+end

data/test/test_math.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+describe Bezier::Math do
+  describe "#combination" do
+    it "should return nil either of the inputs is not a non-negative integer" do
+      assert_nil Bezier::Math.combination(-1, 10)
+      assert_nil Bezier::Math.combination(10, -1)
+      assert_nil Bezier::Math.combination(1.5, 2)
+      assert_nil Bezier::Math.combination(2, 1.5)
+    end
+
+    it "should be nil if r > n" do
+      assert_nil Bezier::Math.combination(0, 1)
+      assert_nil Bezier::Math.combination(10, 11)
+    end
+
+    it "should return the correct value" do
+      assert_equal Bezier::Math.combination(5, 2), 10
+      assert_equal Bezier::Math.combination(10, 8), 45
+      assert_equal Bezier::Math.combination(5, 5), 1
+      assert_equal Bezier::Math.combination(0, 0), 1
+    end
+  end
+end

data/test/test_painter.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+describe Bezier::Painter do
+  before do
+    coordinates = [[20, 20], [20, 100], [200, 100], [200, 20]]
+    @points     = Array.new(4) { |i| Bezier::Point.new *coordinates[i] }
+    @painter    = Bezier::Painter.new { |p| p.points = @points }
+  end
+
+  describe "#get_parameters" do
+    it "should be a Hash" do
+      assert_instance_of Hash, @painter.get_parameters
+    end
+
+    it "should contain correct width and height" do
+      assert_equal @painter.get_parameters[:width], 200
+      assert_equal @painter.get_parameters[:height], 100
+    end
+
+    it "should contain correct min, max values" do
+      assert_equal @painter.get_parameters[:x_min], 20
+      assert_equal @painter.get_parameters[:x_max], 200
+      assert_equal @painter.get_parameters[:y_min], 20
+      assert_equal @painter.get_parameters[:y_max], 100
+    end
+
+    it "should contain correct offsets" do
+      assert_equal @painter.get_parameters[:x_offset], 10
+      assert_equal @painter.get_parameters[:y_offset], 10
+    end
+  end
+end

data/test/test_point.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+describe Bezier::Point do
+  before do
+    @point = Bezier::Point.new(1, 2)
+  end
+
+  describe "its coordinates" do
+    it "should be an Array" do
+      assert_kind_of Array, @point.coordinates, "Coordinates should be an Array"
+    end
+
+    it "should match what is given" do
+      assert_equal @point.coordinates, [1, 2]
+    end
+  end
+
+  describe "#dimensions" do
+    it "should return the dimension" do
+      assert_equal @point.dimensions, 2
+    end
+  end
+
+  describe "#distance" do
+    it "should return nil if the other party is not a Point" do
+      assert_nil @point.distance(1)
+    end
+
+    it "should return nil if the other party is not of the same dimension" do
+      assert_nil @point.distance(Bezier::Point.new(0))
+    end
+
+    it "should calculate the correct distance" do
+      assert_equal @point.distance(Bezier::Point.new(4, 6)), 5
+      assert_equal @point.distance(Bezier::Point.new(1, 1)), 1
+    end
+  end
+
+  describe "equality" do
+    it "should return true if the coordinates are exactly equal" do
+      assert_equal @point, Bezier::Point.new(1, 2)
+    end
+
+    it "should return false if the other party does not respond to :coordinates" do
+      refute_equal @point, 1
+    end
+
+    it "should return false if the other party does not have the same coordinates" do
+      refute_equal @point, Bezier::Point.new(2, 1)
+    end
+
+    it "should return false if the other party does not have the same dimenstion" do
+      refute_equal @point, Bezier::Point.new(1, 2, 3)
+    end
+  end
+
+  describe "addition" do
+    it "should return nil if the other party does not respond to :coordinates" do
+      assert_nil (@point + 1)
+    end
+
+    it "should return nil if the other party is not of the same dimension" do
+      assert_nil (@point + Bezier::Point.new(1))
+      assert_nil (@point + Bezier::Point.new(1, 2, 3))
+    end
+
+    it "should perform correct addition" do
+      assert_equal (@point + Bezier::Point.new(1, 2)), Bezier::Point.new(2, 4)
+    end
+  end
+
+  describe "scalar multiplication" do
+    it "should return nil if parameter given is not a number" do
+      assert_nil (@point * "Hello")
+    end
+
+    it "should perform correct multiplicaiton" do
+      assert_equal (@point * 2), Bezier::Point.new(2, 4)
+      assert_equal (@point * -1.2), Bezier::Point.new(-1.2, -2.4)
+    end
+  end
+
+  describe "#x and #y" do
+    it "should return the correct values" do
+      assert_equal @point.x, 1
+      assert_equal @point.y, 2
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: bezier
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yihang Ho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.3
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+- !ruby/object:Gem::Dependency
+  name: yard-tomdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: Library to draw Bézier curves
+email: me@yihangho.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bezier.gemspec
+- lib/bezier.rb
+- lib/bezier/bezier.rb
+- lib/bezier/math.rb
+- lib/bezier/painter.rb
+- lib/bezier/point.rb
+- test/helper.rb
+- test/test_bezier.rb
+- test/test_math.rb
+- test/test_painter.rb
+- test/test_point.rb
+homepage: https://github.com/yihangho/bezier
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Draw a Bézier curve
+test_files: []
+has_rdoc: