// Isogrids builds an image with 10x10 grids of half diagonals
func Isogrids(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
// triangle grid here:
for xL := -1; xL < lines/2; xL++ {
for yL := -1; yL <= lines; yL++ {
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}
fill1 := draw.FillFromRGBA(draw.PickColor(key, colors, (xL+3*yL+lines)%15))
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)
// 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}
fill2 := draw.FillFromRGBA(draw.PickColor(key, colors, (xL+3*yL+1+lines)%15))
canvas.Polygon(xs1, ys1, fill2)
xs1 = mirrorCoordinates(xs1, lines, distance, offset*2)
canvas.Polygon(xs1, ys1, fill2)
}
}
canvas.End()
}
// SVG builds an svg image with 6 by 6 quadrants of alternate colors.
func SVG(w http.ResponseWriter, key string, colors []color.RGBA, size int) {
canvas := svg.New(w)
canvas.Start(size, size)
squares := 6
quadrantSize := size / squares
middle := math.Ceil(float64(squares) / float64(2))
colorMap := make(map[int]color.RGBA)
for yQ := 0; yQ < squares; yQ++ {
y := yQ * quadrantSize
colorMap = make(map[int]color.RGBA)
for xQ := 0; xQ < squares; xQ++ {
x := xQ * quadrantSize
if _, ok := colorMap[xQ]; !ok {
if float64(xQ) < middle {
colorMap[xQ] = draw.PickColor(key, colors, xQ+3*yQ)
} else if xQ < squares {
colorMap[xQ] = colorMap[squares-xQ-1]
} else {
colorMap[xQ] = colorMap[0]
}
}
canvas.Rect(x, y, quadrantSize, quadrantSize, draw.FillFromRGBA(colorMap[xQ]))
}
}
canvas.End()
}
// Image builds an image.RGBA type with 6 by 6 quadrants of alternate colors.
func Image(m *image.RGBA, key string, colors []color.RGBA) {
size := m.Bounds().Size()
squares := 6
quad := size.X / squares
middle := math.Ceil(float64(squares) / float64(2))
colorMap := make(map[int]color.RGBA)
var currentYQuadrand = 0
for y := 0; y < size.Y; y++ {
yQuadrant := y / quad
if yQuadrant != currentYQuadrand {
// when y quadrant changes, clear map
colorMap = make(map[int]color.RGBA)
currentYQuadrand = yQuadrant
}
for x := 0; x < size.X; x++ {
xQuadrant := x / quad
if _, ok := colorMap[xQuadrant]; !ok {
if float64(xQuadrant) < middle {
colorMap[xQuadrant] = draw.PickColor(key, colors, xQuadrant+3*yQuadrant)
} else if xQuadrant < squares {
colorMap[xQuadrant] = colorMap[squares-xQuadrant-1]
} else {
colorMap[xQuadrant] = colorMap[0]
}
}
m.Set(x, y, colorMap[xQuadrant])
}
}
}
// triangleColors returns an array of strings, one for each sub triangle.
// Each string corresponds to an svg color.
// Colors are selected from the array of colors passed as parameter and the key.
func triangleColors(id int, key string, colors []color.RGBA, lines int) (tColors []string) {
for _, t := range triangles[id] {
x := t.x
y := t.y
tColors = append(tColors, draw.FillFromRGBA(draw.PickColor(key, colors, (x+3*y+lines)%15)))
}
return
}
func selectColor(colorMap map[int]color.RGBA, key string, colors []color.RGBA, middle float64, xQ, yQ, squares int) (c color.RGBA) {
if float64(xQ) < middle {
c = draw.PickColor(key, colors[1:], xQ+2*yQ)
} else if xQ < squares {
c = colorMap[squares-xQ-1]
} else {
c = colorMap[0]
}
return
}