Convex Polygon class

Introduced properties

fun is_ccw: Bool

geometry :: ConvexPolygon :: is_ccw

Check if the order of the points in the polygon is counter-clockwise

Redefined properties

redef type SELF: ConvexPolygon

geometry $ ConvexPolygon :: SELF

Type of this instance, automatically specialized in every class
redef fun add_vertex(p: Point[Float]): Bool

geometry $ ConvexPolygon :: add_vertex

Add a vertex to the polygon
redef fun intersects(other: APolygon): Bool

geometry $ ConvexPolygon :: intersects

Does this polygon intersects other ?

All properties

fun !=(other: nullable Object): Bool

core :: Object :: !=

Have self and other different values?
fun ==(other: nullable Object): Bool

core :: Object :: ==

Have self and other the same value?
type CLASS: Class[SELF]

core :: Object :: CLASS

The type of the class of self.
type SELF: Object

core :: Object :: SELF

Type of this instance, automatically specialized in every class
fun add_vertex(p: Point[Float]): Bool

geometry :: APolygon :: add_vertex

Add a vertex to self
protected fun class_factory(name: String): CLASS

core :: Object :: class_factory

Implementation used by get_class to create the specific class.
fun class_name: String

core :: Object :: class_name

The class name of the object.
abstract fun contain(p: Point[Float]): Bool

geometry :: APolygon :: contain

Is p contained in self ?
fun delete_vertex(p: Point[Float])

geometry :: APolygon :: delete_vertex

Remove p from the vertices, keeping at least 3 vertices
fun get_class: CLASS

core :: Object :: get_class

The meta-object representing the dynamic type of self.
fun hash: Int

core :: Object :: hash

The hash code of the object.
init init

core :: Object :: init

fun inspect: String

core :: Object :: inspect

Developer readable representation of self.
protected fun inspect_head: String

core :: Object :: inspect_head

Return "CLASSNAME:#OBJECTID".
abstract fun intersects(other: APolygon): Bool

geometry :: APolygon :: intersects

Does self intersects with other
fun is_ccw: Bool

geometry :: ConvexPolygon :: is_ccw

Check if the order of the points in the polygon is counter-clockwise
fun is_convex: Bool

geometry :: APolygon :: is_convex

Is self convex ?
intern fun is_same_instance(other: nullable Object): Bool

core :: Object :: is_same_instance

Return true if self and other are the same instance (i.e. same identity).
fun is_same_serialized(other: nullable Object): Bool

core :: Object :: is_same_serialized

Is self the same as other in a serialization context?
intern fun is_same_type(other: Object): Bool

core :: Object :: is_same_type

Return true if self and other have the same dynamic type.
intern fun object_id: Int

core :: Object :: object_id

An internal hash code for the object based on its identity.
fun output

core :: Object :: output

Display self on stdout (debug only).
intern fun output_class_name

core :: Object :: output_class_name

Display class name on stdout (debug only).
fun points: Array[Point[Float]]

geometry :: APolygon :: points

Vertices of this polygon
protected fun points=(points: Array[Point[Float]])

geometry :: APolygon :: points=

Vertices of this polygon
fun serialization_hash: Int

core :: Object :: serialization_hash

Hash value use for serialization
fun sort_ccw

geometry :: APolygon :: sort_ccw

Sort the vertices in counter clockwise order
fun sort_cw

geometry :: APolygon :: sort_cw

Sort the vertices in clockwise order
intern fun sys: Sys

core :: Object :: sys

Return the global sys object, the only instance of the Sys class.
abstract fun to_jvalue(env: JniEnv): JValue

core :: Object :: to_jvalue

fun to_s: String

core :: Object :: to_s

User readable representation of self.
package_diagram geometry::ConvexPolygon ConvexPolygon geometry::APolygon APolygon geometry::ConvexPolygon->geometry::APolygon core::Object Object geometry::APolygon->core::Object ...core::Object ... ...core::Object->core::Object

Ancestors

interface Object

core :: Object

The root of the class hierarchy.

Parents

abstract class APolygon

geometry :: APolygon

Abstraction of a Polygon

Class definitions

geometry $ ConvexPolygon
# Convex Polygon class
class ConvexPolygon
	super APolygon

	# Does this polygon intersects `other` ?
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_ccw
	# p1 = new Point[Float](2.5, 2.5)
	# p2 = new Point[Float](7.5, 2.5)
	# p3 = new Point[Float](2.5, 7.5)
	# p4 = new Point[Float](7.5, 7.5)
	# arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly2 = new ConvexPolygon(arr)
	# poly2.sort_ccw
	# assert poly.intersects(poly2)
	# ~~~
	redef fun intersects(other) do
		assert is_convex

		var axes1 = axes
		var axes2 = other.axes
		for axis in axes1 do
			var project1 = project(axis)
			var project2 = other.project(axis)
			if not project1.overlap(project2) then return false
		end
		for axis in axes2 do
			var project1 = project(axis)
			var project2 = other.project(axis)
			if not project1.overlap(project2) then return false
		end
		return true
	end

	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var p5 = new Point[Float](2.5, 2.5)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_ccw
	# assert poly.contain(p5)
	# ~~~
	redef fun contain(p) do
		var prev = points[points.length - 1]
		var curr = p
		var next = points[0]
		var is_ccw = turn_left(prev, curr, next)
		for i in [1..points.length[ do
			prev = next
			next = points[i]
			if turn_left(prev, curr, next) != is_ccw then return false
		end
		return true
	end

	# Check if the order of the points in the polygon is counter-clockwise
	# The vertices in the polygon need to be sorted
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_ccw
	# assert poly.is_ccw
	# ~~~
	fun is_ccw: Bool do
		var min = points[0].y
		var min_index = 0
		for i in [1..points.length - 1[ do
			if points[i].y < min then
				min = points[i].y
				min_index = i
			end
		end
		var prev = points[(min_index - 1 + points.length) % points.length]
		var next = points[(min_index + 1) % points.length]
		return not turn_left(prev, points[min_index], next)
	end



	# Add a vertex to the polygon
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# var p5 = new Point[Float](2.5, 7.5)
	# assert poly.add_vertex(p5)
	# ~~~
	redef fun add_vertex(p) do
		assert points.length >= 3
		var temp_list = points.clone
		temp_list.add(p)
		var temp_polygon = new ConvexPolygon(temp_list)
		temp_polygon.sort_ccw
		if temp_polygon.is_convex then
			points = temp_polygon.points
			return true
		else
			return false
		end
	end
end
lib/geometry/polygon.nit:162,1--281,3