aurora-geometry 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 679c3759dd2dedb0e7c23c68c1e7cf57d7e3a062
+  data.tar.gz: 91861bec8416024680f582a465478dbd2ed9dee3
+SHA512:
+  metadata.gz: fc0d69e2b233c88288628217c2cc3bb665590c2f904431397c22d70c1f4636215f9c92d3b83a8572f6fb00aa3fae9837b338103dc4ffd5e03a4ec5f00c50f9d1
+  data.tar.gz: 899e24c83db56901a937b9da0593cbe0a4be071b662593c6b7ec3c2dbdd7280208174be2c1f574ad8158632e74b4681e5c339e89417bb40e60d4778ca589c3fc

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.yardoc
+Gemfile.lock
+pkg/*
+doc

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+    gem 'rake'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012, Brandon Fosdick <bfoz@bfoz.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided 
+that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the
+    following disclaimer.
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+    the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,105 @@
+Geometry for Ruby
+=================
+
+[![Build Status](https://travis-ci.org/bfoz/geometry.png)](https://travis-ci.org/bfoz/geometry)
+
+Classes and methods for the handling of all of the basic geometry that you 
+learned in high school (and then forgot).
+
+The classes in this libary are based on the Vector class provided by the Ruby 
+standard library. Geometric primitives are generally assumed to lie in 2D space,
+but aren't necessarily restricted to it. Please let me know if you find cases 
+that don't work in higher dimensions and I'll do my best to fix them.
+
+License
+-------
+
+Copyright 2012-2014 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+
+Primitives
+----------
+
+- Point
+- Size
+- Line
+- Edge
+- [Arc](http://en.wikipedia.org/wiki/Arc_(geometry)), Circle
+- Rectangle, Square
+- Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon), [RegularPolygon](http://en.wikipedia.org/wiki/Regular_polygon)
+- Transformation
+- [Triangle](http://en.wikipedia.org/wiki/Triangle)
+- [Obround](http://en.wiktionary.org/wiki/obround)
+
+Examples
+--------
+
+### Point
+```ruby
+    point = Geometry::Point[3,4]    # 2D Point at coordinate 3, 4
+
+    # Copy constructors
+    point2 = Geometry::Point[point]
+    point2 = Geometry::Point[Vector[5,6]]
+
+    # Accessors
+    point.x
+    point.y
+    point[2]	# Same as point.z
+
+    # Zero
+    PointZero.new   # A Point full of zeros of unspecified length
+    Point.zero      # Another way to do the same thing
+    Point.zero(3)   # => Point[0,0,0]
+```
+
+### Line
+```ruby
+    # Two-point constructors
+    line = Geometry::Line[[0,0], [10,10]]
+    line = Geometry::Line[Geometry::Point[0,0], Geometry::Point[10,10]]
+    line = Geometry::Line[Vector[0,0], Vector[10,10]]
+
+    # Slope-intercept constructors
+    Geometry::Line[Rational(3,4), 5]	# Slope = 3/4, Intercept = 5
+    Geometry::Line[0.75, 5]
+
+    # Point-slope constructors
+    Geometry::Line(Geometry::Point[0,0], 0.75)
+    Geometry::Line(Vector[0,0], Rational(3,4))
+
+    # Special constructors (2D only)
+    Geometry::Line.horizontal(y=0)
+    Geometry::Line.vertical(x=0)
+```
+
+### Rectangle
+```ruby
+    # A Rectangle made from two corner points
+    Geometry::Rectangle.new [1,2], [2,3]
+    Geometry::Rectangle.new from:[1,2], to:[2,3]
+
+    Geometry::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
+    Geometry::Rectangle.new origin:[1,2], size:[1,1]	# Using an origin point and a size
+
+    # A Rectangle with its origin at [0, 0] and a size of [10, 20]
+    Geometry::Rectangle.new size: [10, 20]
+    Geometry::Rectangle.new size: Size[10, 20]
+    Geometry::Rectangle.new width: 10, height: 20
+```
+
+### Circle
+```ruby
+    # A circle at Point[1,2] with a radius of 3
+    circle = Geometry::Circle.new center:[1,2], radius:3
+```
+
+### Polygon
+```ruby
+    # A polygon that looks a lot like a square
+    polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
+```
+### Regular Polygon
+```ruby
+    # Everyone loves a good hexagon
+    hexagon = Geometry::RegularPolygon.new 6, :diameter => 3
+```

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList['test/**/*.rb']
+    t.verbose = true
+end
+
+task :fixdates do
+    branch = `git branch --no-color -r --merged`.strip
+    `git fix-dates #{branch}..HEAD`
+end
+
+task :fixdates_f do
+    branch = `git branch --no-color -r --merged`.strip
+    `git fix-dates -f #{branch}..HEAD`
+end
+
+task :trim_whitespace do
+  system(%Q[git status --short | awk '{if ($1 != "D" && $1 != "R") print $2}' | grep -e '.*\.rb$' | xargs sed -i '' -e 's/[ \t]*$//g;'])
+end

data/aurora-geometry.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "aurora-geometry"
+  s.version     = '0.0.2'
+  s.authors     = ["Brandon Fosdick", "Meseker Yohannes"]
+  s.email       = ["meseker.yohannes@gmail.com"]
+  s.homepage    = "http://github.com/meseker/geometry"
+  s.summary     = %q{Geometric primitives and algoritms}
+  s.description = %q{Geometric primitives and algorithms for Ruby}
+
+  s.rubyforge_project = "aurora-geometry"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/geometry.rb

@@ -0,0 +1,22 @@
+require_relative 'geometry/arc'
+require_relative 'geometry/circle'
+require_relative 'geometry/line'
+require_relative 'geometry/obround'
+require_relative 'geometry/path'
+require_relative 'geometry/point'
+require_relative 'geometry/point_zero'
+require_relative 'geometry/polygon'
+require_relative 'geometry/polyline'
+require_relative 'geometry/rectangle'
+require_relative 'geometry/regular_polygon'
+require_relative 'geometry/rotation'
+require_relative 'geometry/size'
+require_relative 'geometry/size_zero'
+require_relative 'geometry/square'
+require_relative 'geometry/transformation'
+require_relative 'geometry/triangle'
+require_relative 'geometry/vector'
+require_relative 'geometry/text'
+
+module Geometry
+end

data/lib/geometry/arc.rb

@@ -0,0 +1,94 @@
+require_relative 'point'
+
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+{http://en.wikipedia.org/wiki/Arc_(geometry) Arcs} are Circles that don't quite go all the way around
+
+== Usage
+An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis and goes to the Y-axis (counter-clockwise)
+    arc = Geometry::Arc.new center:[1,1], radius:2, start:0, end:90
+=end
+
+    class Arc
+	include ClusterFactory
+
+	attr_reader :center
+	attr_reader :radius
+	attr_reader :start_angle, :end_angle
+
+	# @overload new(center, start, end)
+	#  Create a new {Arc} given center, start and end {Point}s
+	# @option options [Point] :center (PointZero)   The {Point} at the center
+	# @option options [Point] :start    The {Arc} starts at the start {Point}
+	# @option options [Point] :end	    The {Point} where it all ends
+	# @return [Arc]
+	# @overload new(center, radius, start, end)
+	#  Create a new {Arc} given a center {Point}, a radius and start and end angles
+	# @option options [Point]   :center (PointZero)	The {Point} at the center of it all
+	# @option options [Numeric] :radius	Radius
+	# @option options [Numeric] :start	Starting angle
+	# @option options [Numeric] :end	Ending angle
+	# @return [ThreePointArc]
+	def self.new(options={})
+	    center = options.delete(:center) || PointZero.new
+
+	    if options.has_key?(:radius)
+		original_new(center, options[:radius], options[:start], options[:end])
+	    else
+		ThreePointArc.new(center, options[:start], options[:end])
+	    end
+	end
+
+	# Construct a new {Arc}
+	# @overload initialize(center, radius, start_angle, end_angle)
+	# @param [Point]    center	The {Point} at the center of it all
+	# @param [Numeric]  radius	Radius
+	# @param [Numeric]  start_angle	Starting angle
+	# @param [Numeric]  end_angle	Ending angle
+	def initialize(center, radius, start_angle, end_angle)
+	    @center = Point[center]
+	    @radius = radius
+	    @start_angle = start_angle
+	    @end_angle = end_angle
+	end
+
+	# @return [Point]   The starting point of the {Arc}
+	def first
+	    @center + @radius * Vector[Math.cos(@start_angle), Math.sin(@start_angle)]
+	end
+
+	# @return [Point]   The end point of the {Arc}
+	def last
+	    @center + @radius * Vector[Math.cos(@end_angle), Math.sin(@end_angle)]
+	end
+    end
+
+    class ThreePointArc < Arc
+	attr_reader :center
+	attr_reader :start, :end
+
+	# Contruct a new {Arc} given center, start and end {Point}s
+	#  Always assumes that the {Arc} is counter-clockwise. Reverse the order
+	#  of the start and end points to get an {Arc} that goes around the other way.
+	# @overload initialize(center_point, start_point, end_point)
+	# @param [Point]    center_point    The {Point} at the center
+	# @param [Point]    start_point	    The {Arc} starts at the start {Point}
+	# @param [Point]    end_point	    The {Point} where it all ends
+	def initialize(center_point, start_point, end_point)
+	    @center, @start, @end = [center_point, start_point, end_point].map {|p| Point[p]}
+	    raise ArgumentError unless [@center, @start, @end].all? {|p| p.is_a?(Point)}
+	end
+
+	# The starting point of the {Arc}
+	# @return [Point]
+	alias :first :start
+
+	# The end point of the {Arc}
+	# @return [Point]
+	alias :last :end
+    end
+end

data/lib/geometry/circle.rb

@@ -0,0 +1,122 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+Circles come in all shapes and sizes, but they're usually round.
+
+== Usage
+    circle = Geometry::Circle.new [1,2], 3
+    circle = Geometry::Circle.new center:[1,2], radius:3
+    circle = Geometry::Circle.new center:[1,2], diameter:6
+    circle = Geometry::Circle.new diameter:6
+=end
+
+    class Circle
+	include ClusterFactory
+
+	# @return [Point]   The {Circle}'s center point
+	attr_reader :center
+
+	# @return [Number]  The {Circle}'s radius
+	attr_reader :radius
+
+	# @overload new(center, radius)
+	#   Construct a {Circle} using a centerpoint and radius
+	#   @param [Point]	center  The center point of the {Circle}
+	#   @param [Number]	radius	The radius of the {Circle}
+	# @overload new(center, radius)
+	#   Construct a circle using named center and radius parameters
+	#   @option options [Point]	:center (PointZero)
+	#   @option options [Number]	:radius
+	# @overload new(center, diameter)
+	#   Construct a circle using named center and diameter parameters
+	#   @option options [Point]	:center (PointZero)
+	#   @option options [Number]	:diameter
+	def self.new(*args, &block)
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+	    center, radius = args[0..1]
+
+	    center ||= (options[:center] || PointZero.new)
+	    radius ||= options[:radius]
+
+	    if radius
+		self.allocate.tap {|circle| circle.send :initialize, center, radius, &block }
+	    elsif options.has_key?(:diameter)
+		CenterDiameterCircle.new center, options[:diameter], &block
+	    else
+		raise ArgumentError, "Circle.new requires a radius or a diameter"
+	    end
+	end
+
+	# Construct a new {Circle} from a centerpoint and radius
+	# @param    [Point]	center  The center point of the {Circle}
+	# @param    [Number]	radius  The radius of the {Circle}
+	# @return   [Circle]	A new {Circle} object
+	def initialize(center, radius)
+	    @center = Point[center]
+	    @radius = radius
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.radius == other.radius)
+	end
+	alias :== :eql?
+
+# @!group Accessors
+	# @return [Rectangle]	The smallest axis-aligned {Rectangle} that bounds the receiver
+	def bounds
+	    return Rectangle.new(self.min, self.max)
+	end
+
+	# @!attribute [r] diameter
+	#   @return [Numeric] The diameter of the {Circle}
+	def diameter
+	    @radius*2
+	end
+
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @center+radius
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @center-radius
+	end
+
+	# @return [Array<Point>]    The lower left and upper right corners of the bounding {Rectangle}
+	def minmax
+	    [self.min, self.max]
+	end
+# @!endgroup
+    end
+
+    class CenterDiameterCircle < Circle
+	# @return [Number]  The {Circle}'s diameter
+	attr_reader :diameter
+
+	# Construct a new {Circle} from a centerpoint and a diameter
+	# @param    [Point]	center  The center point of the {Circle}
+	# @param    [Number]	diameter  The radius of the {Circle}
+	# @return   [Circle]	A new {Circle} object
+	def initialize(center, diameter)
+	    @center = Point[center]
+	    @diameter = diameter
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.diameter == other.diameter)
+	end
+	alias :== :eql?
+
+# @!group Accessors
+	# @return [Number] The {Circle}'s radius
+	def radius
+	    @diameter/2
+	end
+# @!endgroup
+    end
+end