bfoz / geometry

Geometric primitives for Ruby

Geometry for Ruby

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-2024 Brandon Fosdick [email protected] and released under the BSD license.

Primitives

• Point
• Size
• Line
• Edge
• Annulus
• Arc, Circle
• Bézier Curves
• Rectangle, Square
• Path, Polyline, Polygon, RegularPolygon
• Transformation
• Triangle
• Obround

Examples

Point

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

# 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

# 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

# A circle at Point[1,2] with a radius of 3
circle = Geometry::Circle.new center:[1,2], radius:3

Polygon

# A polygon that looks a lot like a square
polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]

Regular Polygon

# Everyone loves a good hexagon
hexagon = Geometry::RegularPolygon.new 6, :diameter => 3

Zeros and Ones

# For when you know you need a zero, but you don't know how big it should be
zero = Point.zero       # Returns a Point of indeterminate length that always compares equal to zero

# Oh, you wanted ones instead? No problem.
ones = Point.one        # => Point[1,1,1...1]

# Looking for something more exotic that a mere 1?
iso = Point.iso(5)      # => Point[5,5,5...5]

geometry's Issues

Allow center==nil in equality checking

A Circle or RegularPolygon with a nil center should be equal to another class of the same type with the same radius or diameter (and number of sides, for RegularPolygon)

Add Rectangle#outset

Like Polygon#outset, but for Rectangle

Fill out the Polygon class cluster

Methods

• inside?
  • checks if a passed point is inside, or on the boundary
  • checks if a passed edge is entirely inside, or on the boundary
  • checks if a passed polygon is entirely inside, or matches the boundary entirely
• outside? - opposite of inside?
• intersect?
  • true if passed line intersects the polygon
  • true if any part of the passed polygon is inside?
• equal? polygon - true if passed polygon has same vertices, and number of vertices
• on_boundary?
  • true if passed point is a vertex or on an edge
  • true if passed line is an edge or entirely on an edge
  • true if passed polygon is equal?
• vertex? point - true if passed point is a vertex of the polygon
• edge? line - true if passed line is an edge of the vertex
• edge? point - true if passed point in on any edge
• concave?
• convex?
• decompose - cuts a concave polygon into 1 or more convex polygons
• hull - creates a convex hull
• square - smallest enclosing Square
• rectangle - smallest enclosing Rectangle

Cluster

• RegularPolygon

Finish the Square class cluster

The current version is a skeleton that was rushed in support of the engineering gem.

Support Ruby 2 keyword arguments

Rectangle, Square, Obround, etc should take left, right, top, bottom, bottom_left, top_right, width, height, etc...

Add a PolyLine class

A sequence of Edges that may, or may not, be closed. It's like a Polygon in that it only contains straight lines, but also like a Path in that it isn't necessarily closed.

Add a Path class

Like a Polygon, but not necessarily closed and not limited to straight lines

Rectangle should require named arguments

Add a Size class

Like Point, but with a different name

Add a Rectangle class

Add a Polygon class

Accessors

• vertices
• edges

Add the Grahm Scan method of finding a polygon's convex hull

http://en.wikipedia.org/wiki/Graham_scan
http://branch14.org/snippets/convex_hull_in_ruby.html

Add an Intersection class

Add a Triangle class

Add min, max, and minmax methods to Rectangle

min returns a Point that's on the Rectangle and closest to the origin
max returns a Point that's on the Rectangle and farthest from the origin
minmax returns the Array of Points [min, max]

Add a Union class

Add a Square class

Subclass of Rectangle?

Fill out the Line class cluster

Needs accessors, etc

• parallel? line - true if the passed line is parallel
• intersect? line - true if the passed line intersects
• angle - the angle between the two lines
• direction - a vector pointing along the line
• equal? line - true if collinear
• distance
  • point - distance to the point
  • line - closest distance between the lines
  • circle - distance to the circle's center minus its radius

Add an Arc class

A portion of a circle

Add an Obround class

Two semicircles connected by parallel lines

http://en.wiktionary.org/wiki/obround

Add Chan's algorithm

http://en.wikipedia.org/wiki/Chan%27s_algorithm

RegularPolygon

A Polygon that's constrained to be a regular polygon. Has accessors for radius and center.

Add a Circle class

Implement Polygon set operations

http://gvu.gatech.edu/people/official/jarek/graphics/papers/04PolygonBooleansMargalit.pdf

Union is already implemented. Do the others at some point.

Add RegularPolygon#circle

circle should return a Circle that encloses the RegularPolygon

incircle should return a Circle that incribes the RegularPolygon

Composition

Adding two elements should return a Path that's the union of the elements, or an exception if they don't intersect.

Add a Octonion class

Line testing

Fix test framework for Line class

• Rename file
• Rename test case (not a Point test)
• Add test cases for individual cluster classes

Implement Polygon union

http://gvu.gatech.edu/people/official/jarek/graphics/papers/04PolygonBooleansMargalit.pdf

Add PointZero and SizeZero classes

Special subclasses that are always zero, always compare as zero and are compatible with Points and Sizes of any length.

Add an Edge class

Like a TwoPointLine, but not implicitly of infinite length

Remove support for using square brackets to create a Rectangle

Rectangle[...] seems wrong now that I look at it again. Switch to the more standard Rectangle.new syntax.

Add an Ellipse class

Polygon should inherit from Polyline

Add an inset method to Rectangle

Generates a new Rectangle that's inset by the specified amount. Overloads for single inset all around, horizontal/vertical insets, and top/left/bottom/right insets. Negative numbers produce an "outset".

Add a centroid property to Polygon

Add Kite and Dart

http://en.wikipedia.org/wiki/Kite_(geometry)

Look into using DelegateClass for PolygonBuilder and PathBuilder

http://www.ruby-doc.org/stdlib-1.9.3/libdoc/delegate/rdoc/Object.html

Creating a Rectangle with only a size argument should set the origin property to PointZero

Add a Quaternion class

Array == Point should work

Need to add Point#coerce

Edge#intersection

http://stackoverflow.com/a/1968345/44747

Module convenience methods

• pentagon - returns a regular pentagon
• hexagon - returns a regular hexagon
• regular_polygon - constructs a regular polygon with a specified number of edges

Add a Rotation class

Represents the concept of a rotation regardless of the underlying implementation. Has methods for getting the equivalent rotation matrix and the equivalent quaternion.

Rectangle#== should do implicit type conversion

Rectangle.new [-1,-1],[1,1] should == Rectangle.new Size[2,2]

Currently #== is aliased to #eql?

Add Zork methods for Polyline building

Implement north, south, east, and west methods in addition to the existing up, down, left and right methods

Add Edge#normal

Returns a Vector that's perpendicular to the Edge

Polygon Offsetting

http://fcacciola.50webs.com/Offseting%20Methods.htm

http://stackoverflow.com/questions/1109536/an-algorithm-for-inflating-deflating-offsetting-buffering-polygons

Straight Skeleton: http://en.wikipedia.org/wiki/Straight_skeleton
http://www.dma.fi.upm.es/mabellanas/tfcs/skeleton/html/documentacion/Straight%20Skeletons%20Implementation.pdf

Construct Points from Ranges

Returns an array of Points

eg. Point[0..1,1] would return [Point[0,1], Point[1,1]]

Add the spaceship operator to Point

Applies spaceship to each corresponding element and returns a new Point with the results

Monkeypatch it into Vector as well?