beziercurve 0.8 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7550491650757d1ef4313a11191cb788974cae7
-  data.tar.gz: 66f165775867bf78cec4db74658de8b7a9bce86c
+  metadata.gz: a6acfd138758503d0649eb27ad80333f8c772cf2
+  data.tar.gz: 8c97586296b5fa7c2c11c5bf67979c81dfc6ece2
 SHA512:
-  metadata.gz: a03fad9c836c26f020f3f5b5e859f9f5268b411cc5583d7022e7cf89f975cfedd16611f3cf20736451fa3d23f2ccb1a308ccf1367cdf3d4d3a50631545bc1464
-  data.tar.gz: a84249c4189caac7f6f80d93dceebab5e29e1a0068e3d6e6ddd370e7e3d491361085703ea70fcafb059ffdd1c8120b3b7aa1520bb33fdd7afc2e75b3323181c4
+  metadata.gz: 22d46c3b5d4b41421dda3f3170833a0685dbbd6ce30de4d8a7bd1cdea9d5d54073d9ea2a163b5f2b9e82d3ba83946346aac44e4602f012187149666de2d6371f
+  data.tar.gz: 5dcae4d88aab32ca8c8d12e64bde76f59eb9fc60942e4bebf31ab3e95b9c39c6393da2781bba4f334f0b3e04ee473b1607a33a7ef192afb11756a157f561f502

data/README.md

@@ -0,0 +1,36 @@
+**Bézier Ruby Gem**
+==
+
+A Ruby gem for creating and analyzing Bézier curves. Allows you to create a Bézier curve by its control points, get specific point on that curve or iterate the curve points by an Enumerator. Inspired by [A Primer on Bézier Curves](http://pomax.github.io/bezierinfo/).
+
+History
+-------
+
+0.7 - implemented the De Casteljau algorithm
+
+0.8 - defined minimum Ruby version (2.0.0)
+
+
+Installation
+------------
+
+    > gem install beziercurve
+
+Sample
+------------------
+
+    > require 'beziercurve'
+    > bez = Bezier::Curve.new(Bezier::ControlPoint.new(40, 250), Bezier::ControlPoint.new(50, 150), Bezier::ControlPoint.new(90, 220))
+    > puts bez.point_on_curve(0.2).x;
+    45.2
+    > puts bez.point_on_curve(0.2).y;
+    216.8
+
+    or a nicer way:
+
+    > bez = Bezier::Curve.new([40, 250], [50, 150], [90, 220])
+    > puts bez.point_on_curve(0.2).x;
+    45.2
+    > puts bez.point_on_curve(0.2).y;
+    216.8
+

data/lib/beziercurve.rb

@@ -1,30 +1,49 @@
 # Curve == series of ControlPoints
-module Bezier
 
+module Bezier
 	class ControlPoint
 		attr_accessor :x, :y
+
+    # @param x [Numeric]
+    # @param y [Numeric]
+    #
+    # Creates a new control point for the Bézier curve
 		def initialize(x,y)
 			@x = x
 			@y = y
 		end
+
 		def - (b)
-			self.class.new(self.x - b.x, self.y - b.y)
-		end
-		def + (b)
-			self.class.new(self.x + b.x, self.y + b.y)
+    	self.class.new(self.x - b.x, self.y - b.y)
+    end
+    def + (b)
+    	self.class.new(self.x + b.x, self.y + b.y)
+    end
+
+		# @param point [ControlPoint]
+		#
+    # @return [ControlPoint] A ControlPoint in a new position
+    # Moves a controlpoint with relative distance
+    def movepoint (point)
+			self.class.new(self.x + point.x, self.y + point.y)
 		end
+
 		def inspect
 			return @x, @y
 		end
-		# @return [CurvePoint] Returns a ControlPoint, converted to CurvePoint (only naming differences).
+
+		# @return [CurvePoint] Returns a ControlPoint, converted to CurvePoint (this is only a naming difference).
 		def to_curvepoint
 			CurvePoint.new(self.x, self.y)
 		end
-		def to_a
+
+    # @return [Array]
+    # Returns the control point as an array => [x, y]. The Array is fit to be as argument for ControlPoint.new
+    def to_a
 			[self.x, self.y]
 		end
 	end
-	
+
 	class CurvePoint < ControlPoint
 		# @return [ControlPoint] point coordinates on the Bézier curve.
 		def to_controlpoint
@@ -33,105 +52,163 @@ module Bezier
 	end
 
 	class Curve
-		# returns hull control points
+    # defaults
+    DeCasteljau = :decasteljau
+    Bernstein = :bernstein
+
+    # this should have been instance variable in the first place, correcting '@@...'
+    @calculation_method = Bernstein
+
+		@@fact_memoize = Hash.new
+		@@binomial_memoize = Hash.new
+		@@pascaltriangle_memoize = Hash.new
+
+		# Ye' olde factorial function
+		#
+		# @param n [Fixnum]
+		# @example
+		#   > fact(5)
+		def self.fact(n)
+			@@fact_memoize[n] ||= (1..n).reduce(:*)
+    end
+
+		# @param n [Fixnum]
+		# @param k [Fixnum]
+		# standard 'n choose k'
+		def self.binomial(n,k)
+			return 1 if n-k <= 0
+			return 1 if k <= 0
+			@@binomial_memoize[[n,k]] ||= fact(n) / ( fact(k) * fact( n - k ) )
+    end
+
+		# Returns the specified line from the Pascal triangle as an Array
+		# @return [Array] A line from the Pascal triangle
+		# @example
+		#   > pascaltriangle(6)
+		def self.pascaltriangle(nth_line) # Classic Pascal triangle
+			@@pascaltriangle_memoize[nth_line] ||= (0..nth_line).map { |e| binomial(nth_line, e) }
+    end
+
+		# Returns the Bezier curve control points
+		#
+		# @return [Array<ControlPoints>]
+
 		attr_accessor :controlpoints
 
-		# @param controlpoints [Array<ControlPoints, Array(Fixnum, Fixnum)>] list of ControlPoints defining the hull for the Bézier curve. A point can be of class ControlPoint or an Array containig 2 Fixnums, which will be converted to ControlPoint.
-		# @return [Curve] a Bézier curve object
+		# @param controlpoints [Array<ControlPoints>, Array<(Fixnum, Fixnum)>] list of ControlPoints defining the hull for the Bézier curve. A point can be of class ControlPoint or an Array containig 2 Numerics, which will be converted to ControlPoint.
+		# @return [Curve] Creates a new Bézier curve object. The minimum number of control points is currently 3.
 		# @example
 		#    initialize(p1, p2, p3)
 		#    initialize(p1, [20, 30], p3)
 		def initialize(*controlpoints)
+
 			# need at least 3 control points
 			# this constraint has to be lifted, to allow adding Curves together like a 1 point curve to a 3 point curve
 			if controlpoints.size < 3
-				raise ArgumentError, 'Cannot create Bézier curve with less than 3 control points'
+				raise ArgumentError, 'Cannot create curve with less than 3 control points'
 			end
 
-			@controlpoints = controlpoints.map { |e|
-				if e.class == Array
-					ControlPoint.new(*e[0..1]) # make sure ControlPoint.new gets no more than 2 arguments. 'e' should contain at least 2 elements here
-				elsif e.class == ControlPoint
-					e
+			@controlpoints = controlpoints.map { |point|
+				if point.class == Array
+					ControlPoint.new(*point[0..1]) # ControlPoint.new gets no more than 2 arguments, excess values are ignored
+				elsif point.class == ControlPoint
+					point
 				else
 					raise 'Control points should be type of ControlPoint or Array'
 				end
 			  }
 		end
 
-		# @param point [ControlPoint] addition
+		# Adds a new control point to the Bezier curve as endpoint.
+		#
+		# @param [ControlPoint, Array] point
 		def add(point)
-			if point.class == ControlPoint
-				@controlpoints << point
-			else
-				raise TypeError, 'Point should be type of ControlPoint'
-			end
-		end
-
-		# @param t [CurvePoint] 
-		def point_on_curve(t)
-
-			def point_on_hull(point1, point2, t) # making this method local
-				if (point1.class != ControlPoint) or (point2.class != ControlPoint)
-					raise TypeError, 'Both points should be type of ControlPoint'
-				end
-				new_x = (point1.x - point2.x) * t
-				new_y = (point1.y - point2.y) * t
-				return ControlPoint.new(new_x, new_y)
-			end
-
-			# imperatively ugly, but works, refactor later. point_on_curve and point_on_hull should be one method
-			ary = @controlpoints
-			return ary if ary.length <= 1 # zero or one element as argument, return unmodified
-
-			while ary.length > 1
-				temp = []
-				0.upto(ary.length-2) do |index|
-					memoize1 = point_on_hull(ary[index], ary[index+1], t)
-					temp << ary[index+0] - memoize1
-				end
-				ary = temp
-			end
-			return temp[0].to_curvepoint
+      @controlpoints << case point
+                        when ControlPoint
+                          point
+                        when Array
+                          ControlPoint.new(*point[0..1])
+                        else
+                          raise(TypeError, 'Point should be type of ControlPoint')
+                        end
+
+			# if point.class == ControlPoint
+			# 	@controlpoints << point
+   #    elsif point.class == Array
+   #      @controlpoints << ControlPoint.new(*point[0..1])
+			# else
+			# 	raise TypeError, 'Point should be type of ControlPoint'
+			# end
 		end
 
-		def pascaltriangle(nth_line)
-			# @param n [Fixnum] Ye' olde factorial function
-			# @todo this is slow, should be rewritten
-			# @return [Array] an array of the specified line from the Pascal triangle
-			# @example
-			#   > fact(5)
-			#   > 
-			def fact(n)
-				(1..n).reduce(:*)
-			end
+		# @param [CurvePoint] t
+		def point_on_curve(t) # calculates the 'x,y' coordinates of a point on the curve, at the ratio 't' (0 <= t <= 1)
+      case
+        when @@calculation_method == DeCasteljau
+          poc_with_decasteljau(t)
+        when @@calculation_method == Bernstein
+          poc_with_bernstein(t)
+        else
+          poc_with_bernstein(t) # default
+      end
+    end
+    alias_method :poc, :point_on_curve
+
+		def poc_with_bernstein(t)
+			n = @controlpoints.size-1
+      sum = [0,0]
+      for k in 0..n
+      	sum[0] += @controlpoints[k].x * self.class.binomial(n,k) * (1-t)**(n-k) * t**k
+      	sum[1] += @controlpoints[k].y * self.class.binomial(n,k) * (1-t)**(n-k) * t**k
+      end
+      return ControlPoint.new(*sum)
+      #poc_with_decasteljau(t)
+    end
+
+    def point_on_hull(point1, point2, t) # just realized this was nested (geez), Jörg.W.Mittag would have cried. So it is moved out from poc_with_decasteljau()
+      if (point1.class != ControlPoint) or (point2.class != ControlPoint)
+        raise TypeError, 'Both points should be type of ControlPoint'
+      end
+      new_x = (1-t) * point1.x + t * point2.x
+      new_y = (1-t) * point1.y + t * point2.y
+      return ControlPoint.new(new_x, new_y)
+    end
+
+    def poc_with_decasteljau(t)
+      # imperatively ugly, but works, refactor later. point_on_curve and point_on_hull should be one method
+      ary = @controlpoints
+      return ary if ary.length <= 1 # zero or one element as argument, return unmodified
+
+      while ary.length > 1
+        temp = []
+        0.upto(ary.length-2) do |index|
+          memoize1 = point_on_hull(ary[index], ary[index+1], t)
+          temp << ary[index+0] - memoize1
+        end
+        ary = temp
+      end
+      temp[0].to_curvepoint
+    end
 
-			# @param n [Fixnum]
-			# @param k [Fixnum]
-			def binomial(n,k)
-				return 1 if n-k <= 0
-				return 1 if k <= 0
-				fact(n) / ( fact(k) * fact( n - k ) )
+		def point_on_curve_binom(t)
+			coeffs = self.class.pascaltriangle(self.order)
+			coeffs.reduce do |memo, obj|
+				memo += t**obj * (1-t)** (n - obj)
 			end
-			(0..nth_line).map { |e| binomial(nth_line, e) }
 		end
 
-		def point_on_curve_binom(t)
-
-			# locally scoped, we don't need it outside of point_on_curve_binom
 
-			coeffs = pascaltriangle(self.order)
-			coeffs.reduce { |memo, obj| 
-				memo += t**obj * (1-t)** (n - obj) 
-			}
+		def gnuplot_hull # was recently 'display_points'. just a helper, for quickly put ControlPoints to STDOUT in a gnuplottable format
+			@controlpoints.map{|point| [point.x, point.y] }
 		end
 
-		def display_points # just a helper, for quickly put ControlPoints to STDOUT in a gnuplottable format
-			@controlpoints.map{|point| puts "#{point.x} #{point.y}"}
+		def gnuplot_points(precision)
 		end
 
+		# returns a new Enumerator that iterates over the Bezier curve from [start_t] to 1 by [delta_t] steps.
 		def enumerated(start_t, delta_t)
 	  		Enumerator.new do |yielder|
+	  			#TODO only do the conversion if start_t is not Float, Fractional or Bigfloat
 	  			point_position = start_t.to_f
 	    		number = point_on_curve(point_position)
 	    		loop do
@@ -143,9 +220,15 @@ module Bezier
 	  		end
 		end
 
+		# returns the order of the Bezier curve, aka the number of control points.
 		def order
 			@controlpoints.size
 		end
 	end
-
 end
+
+# Bernstein calculation is finished, that is the default
+# DeCasteljau still has bugs 
+# renamed display_points to gnuplot_hull (this displays Hull coordinates)
+# created gnuplot_points (this displays Curve points, uses the enumerated method to iterate over the curve)
+# TODO: make sure the original CurvePoint argument type won't get converted. If someone created a new Bezier instance with Bigfloat as CurvePoints, it should stay Bigfloat during the entire calculation

data/test/test_beziercurve.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'beziercurve'
+
+class TestBezierCurve < Test::Unit::TestCase
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beziercurve
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: 0.8.4
 platform: ruby
 authors:
 - Földes László
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
+date: 2016-04-10 00:00:00.000000000 Z
 dependencies: []
 description: Creates a Bézier curve by its control points. Implemented with de Casteljau
   method.
@@ -17,8 +17,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/beziercurve.rb
-homepage: http://devrandom.postr.hu
+- test/test_beziercurve.rb
+homepage: https://github.com/karatedog/beziercurve
 licenses:
 - MIT
 metadata: {}
@@ -38,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Create and analyze Bézier curves