add hexa16 route.

	r.HandleFunc("/labs/squares/random", squares.Random)

	r.HandleFunc("/labs/isogrids/hexa", isogrids.Hexa)

	r.HandleFunc("/labs/isogrids/hexa/:key", isogrids.Hexa)

	r.HandleFunc("/labs/isogrids/hexa16/:key", isogrids.Hexa16)

	r.HandleFunc("/labs/isogrids/skeleton", isogrids.Skeleton)

	r.HandleFunc("/labs/isogrids/diagonals", isogrids.Diagonals)

	r.HandleFunc("/labs/isogrids/halfdiagonals", isogrids.HalfDiagonals)

package isogrids

import (

	"crypto/md5"

	"fmt"

	"io"

	"net/http"

	"github.com/taironas/route"

	"github.com/taironas/tinygraphs/draw/isogrids"

	"github.com/taironas/tinygraphs/extract"

	"github.com/taironas/tinygraphs/write"

)

// Hexa is the handler for /isogrids/hexa16/:key

// builds an hexagon with alternate colors.

func Hexa16(w http.ResponseWriter, r *http.Request) {

	var err error

	size := extract.Size(r)

	var key string

	if key, _ = route.Context.Get(r, "key"); err != nil {

		key = ""

	}

	h := md5.New()

	io.WriteString(h, key)

	key = fmt.Sprintf("%x", h.Sum(nil)[:])

	lines := extract.Hexalines(r)

	colors := extract.Colors(r)

	write.ImageSVG(w)

	isogrids.Hexa16(w, key, colors, size, lines)

}

package isogrids

import (

	"image/color"

	"net/http"

	"github.com/ajstarks/svgo"

	"github.com/taironas/tinygraphs/draw"

)

// Hexa builds an image with lines x lines grids of half diagonals in the form of an hexagon

func Hexa16(w http.ResponseWriter, key string, colors []color.RGBA, size, lines int) {

	canvas := svg.New(w)

	canvas.Start(size, size)

	fringeSize := size / lines

	distance := distanceTo3rdPoint(fringeSize)

	lines = size / fringeSize

	offset := ((fringeSize - distance) * lines) / 2

	for xL := 0; xL < lines/2; xL++ {

		for yL := 0; yL < lines; yL++ {

			fill1 := fillTransparent()

			fill2 := fillTransparent()

			if isFill1InHexagon(xL, yL, lines) {

				fill1 = draw.FillFromRGBA(draw.PickColor(key, colors, (xL+3*yL+lines)%15))

			}

			if isFill2InHexagon(xL, yL, lines) {

				fill2 = draw.FillFromRGBA(draw.PickColor(key, colors, (xL+3*yL+1+lines)%15))

			}

			if !isFill1InHexagon(xL, yL, lines) && !isFill2InHexagon(xL, yL, lines) {

				continue

			}

			var x1, x2, y1, y2, y3 int

			if (xL % 2) == 0 {

				x1, y1, x2, y2, _, y3 = right1stTriangle(xL, yL, fringeSize, distance)

			} else {

				x1, y1, x2, y2, _, y3 = left1stTriangle(xL, yL, fringeSize, distance)

			}

			xs := []int{x2 + offset, x1 + offset, x2 + offset}

			ys := []int{y1, y2, y3}

			canvas.Polygon(xs, ys, fill1)

			xsMirror := mirrorCoordinates(xs, lines, distance, offset*2)

			canvas.Polygon(xsMirror, ys, fill1)

			var x11, x12, y11, y12, y13 int

			if (xL % 2) == 0 {

				x11, y11, x12, y12, _, y13 = left2ndTriangle(xL, yL, fringeSize, distance)

				// in order to have a perfect hexagon,

				// we make sure that the previous triangle and this one touch each other in this point.

				y12 = y3

			} else {

				x11, y11, x12, y12, _, y13 = right2ndTriangle(xL, yL, fringeSize, distance)

				// in order to have a perfect hexagon,

				// we make sure that the previous triangle and this one touch each other in this point.

				y12 = y1 + fringeSize

			}

			xs1 := []int{x12 + offset, x11 + offset, x12 + offset}

			ys1 := []int{y11, y12, y13}

			canvas.Polygon(xs1, ys1, fill2)

			xs1 = mirrorCoordinates(xs1, lines, distance, offset*2)

			canvas.Polygon(xs1, ys1, fill2)

		}

	}

	canvas.End()

}