Polygons and paths

ngon(x, y, radius, sides=5, orientation=0, action=:nothing;
    vertices=false, reversepath=false)

Find the vertices of a regular n-sided polygon centered at x, y with circumradius radius.

ngon() draws the shapes: if you just want the raw points, use keyword argument vertices=true, which returns the array of points instead. Compare:

ngon(0, 0, 4, 4, 0, vertices=true) # returns the polygon's points:

    4-element Array{Luxor.Point,1}:
    Luxor.Point(2.4492935982947064e-16,4.0)
    Luxor.Point(-4.0,4.898587196589413e-16)
    Luxor.Point(-7.347880794884119e-16,-4.0)
    Luxor.Point(4.0,-9.797174393178826e-16)

whereas

ngon(0, 0, 4, 4, 0, :close) # draws a polygon

ngon(centerpos, radius, sides=5, orientation=0, action=:nothing;
    vertices=false,
    reversepath=false)

Draw a regular polygon centered at point centerpos:

ngonside(centerpoint::Point, sidelength::Real, sides::Int=5, orientation=0,
    action=:nothing; kwargs...)

Draw a regular polygon centered at centerpoint with sides sides of length sidelength.

star(xcenter, ycenter, radius, npoints=5, ratio=0.5, orientation=0, action=:nothing;
    vertices = false,
    reversepath=false)

Make a star. ratio specifies the height of the smaller radius of the star relative to the larger.

Use vertices=true to return the vertices of a star instead of drawing it.

star(center, radius, npoints=5, ratio=0.5, orientation=0, action=:nothing;
    vertices = false, reversepath=false)

Draw a star centered at a position:

Draw a polygon.

poly(pointlist::Array, action = :nothing;
    close=false,
    reversepath=false)

A polygon is an Array of Points. By default poly() doesn't close or fill the polygon, to allow for clipping.

prettypoly(points::Array{Point, 1}, action=:nothing, vertexfunction = () -> circle(O, 2, :stroke);
    close=false,
    reversepath=false,
    vertexlabels = (n, l) -> ()
    )

Draw the polygon defined by points, possibly closing and reversing it, using the current parameters, and then evaluate the vertexfunction function at every vertex of the polygon.

The default vertexfunction draws a 2 pt radius circle.

To mark each vertex of a polygon with a randomly colored filled circle:

p = star(O, 70, 7, 0.6, 0, vertices=true)
prettypoly(p, :fill, () ->
    begin
        randomhue()
        circle(O, 10, :fill)
    end,
    close=true)

The optional keyword argument vertexlabels lets you supply a function with two arguments that can access the current vertex number and the total number of vertices at each vertex. For example, you can label the vertices of a triangle "1 of 3", "2 of 3", and "3 of 3" using:

prettypoly(triangle, :stroke,
    vertexlabels = (n, l) -> (text(string(n, " of ", l))))

Simplify a polygon:

simplify(pointlist::Array, detail=0.1)

detail is the smallest permitted distance between two points in pixels.

isinside(p, pol; allowonedge=false)

Is a point p inside a polygon pol? Returns true or false.

This is an implementation of the Hormann-Agathos (2001) Point in Polygon algorithm.

Set allowonedge to false to suppress point-on-edge errors.

randompoint(lowpt, highpt)

Return a random point somewhere inside the rectangle defined by the two points.

randompoint(lowx, lowy, highx, highy)

Return a random point somewhere inside a rectangle defined by the four values.

randompointarray(lowpt, highpt, n)

Return an array of n random points somewhere inside the rectangle defined by two points.

randompointarray(lowx, lowy, highx, highy, n)

Return an array of n random points somewhere inside the rectangle defined by the four coordinates.

polysplit(p, p1, p2)

Split a polygon into two where it intersects with a line. It returns two polygons:

(poly1, poly2)

This doesn't always work, of course. For example, a polygon the shape of the letter "E" might end up being divided into more than two parts.

Sort a polygon by finding the nearest point to the starting point, then the nearest point to that, and so on.

polysortbydistance(p, starting::Point)

You can end up with convex (self-intersecting) polygons, unfortunately.

Sort the points of a polygon into order. Points are sorted according to the angle they make with a specified point.

polysortbyangle(pointlist::Array, refpoint=minimum(pointlist))

The refpoint can be chosen, but the minimum point is usually OK too:

polysortbyangle(parray, polycentroid(parray))

Find the centroid of simple polygon.

polycentroid(pointlist)

Returns a point. This only works for simple (non-intersecting) polygons.

You could test the point using isinside().

polysmooth(points, radius, action=:action; debug=false)

Make a closed path from the points and round the corners by making them arcs with the given radius. Execute the action when finished.

The arcs are sometimes different sizes: if the given radius is bigger than the length of the shortest side, the arc can't be drawn at its full radius and is therefore drawn as large as possible (as large as the shortest side allows).

The debug option also draws the construction circles at each corner.

offsetpoly(path::Array{Point, 1}, d)

Return a polygon that is offset from a polygon by d units.

The incoming set of points path is treated as a polygon, and another set of points is created, which form a polygon lying d units away from the source poly.

Polygon offsetting is a topic on which people have written PhD theses and published academic papers, so this short brain-dead routine will give good results for simple polygons up to a point (!). There are a number of issues to be aware of:

• very short lines tend to make the algorithm 'flip' and produce larger lines

• small polygons that are counterclockwise and larger offsets may make the new polygon appear the wrong side of the original

• very sharp vertices will produce even sharper offsets, as the calculated intersection point veers off to infinity

• duplicated adjacent points might cause the routine to scratch its head and wonder how to draw a line parallel to them

polyfit(plist::Array, npoints=30)

Build a polygon that constructs a B-spine approximation to it. The resulting list of points makes a smooth path that runs between the first and last points.

pathtopoly()

Convert the current path to an array of polygons.

Returns an array of polygons.

getpath()

Get the current path and return a CairoPath object, which is an array of element_type and points objects. With the results you can step through and examine each entry:

o = getpath()
for e in o
      if e.element_type == Cairo.CAIRO_PATH_MOVE_TO
          (x, y) = e.points
          move(x, y)
      elseif e.element_type == Cairo.CAIRO_PATH_LINE_TO
          (x, y) = e.points
          # straight lines
          line(x, y)
          strokepath()
          circle(x, y, 1, :stroke)
      elseif e.element_type == Cairo.CAIRO_PATH_CURVE_TO
          (x1, y1, x2, y2, x3, y3) = e.points
          # Bezier control lines
          circle(x1, y1, 1, :stroke)
          circle(x2, y2, 1, :stroke)
          circle(x3, y3, 1, :stroke)
          move(x, y)
          curve(x1, y1, x2, y2, x3, y3)
          strokepath()
          (x, y) = (x3, y3) # update current point
      elseif e.element_type == Cairo.CAIRO_PATH_CLOSE_PATH
          closepath()
      else
          error("unknown CairoPathEntry " * repr(e.element_type))
          error("unknown CairoPathEntry " * repr(e.points))
      end
  end

getpathflat()

Get the current path, like getpath() but flattened so that there are no Bèzier curves.

Returns a CairoPath which is an array of element_type and points objects.

makebezierpath(pgon::Array; smoothing=1)

Return a Bézier path that follows an array of points. The Bézier path is an array of tuples; each tuple contains the four points that make up a section of the path.

drawbezierpath(bezierpath, action=:none;
    close=true)

Draw a Bézier path, and apply the action, such as :none, :stroke, :fill, etc. By default the path is closed.

polyperimeter(p::Array{Point, 1}; closed=true)

Find the total length of the sides of polygon p.

polyportion(p::Array{Point, 1}, portion=0.5; closed=true, pdist=[])

Return a portion of a polygon, starting at a value between 0.0 (the beginning) and 1.0 (the end). 0.5 returns the first half of the polygon, 0.25 the first quarter, 0.75 the first three quarters, and so on.

If you already have a list of the distances between each point in the polygon (the "polydistances"), you can pass them in pdist, otherwise they'll be calculated afresh, using polydistances(p, closed=closed).

Use the complementary polyremainder() function to return the other part.

polydistances(p::Array{Point, 1}; closed=true)

Return an array of the cumulative lengths of a polygon.

nearestindex(polydistancearray, value)

Return a tuple of the index of the largest value in polydistancearray less than value, and the difference value. Array is assumed to be sorted.

(Designed for use with polydistances()).

polyarea(p::Array)

Find the area of a simple polygon. It works only for polygons that don't self-intersect.