go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/open-sky-dump/main.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"
	"time"

	"go.charczuk.com/sdk/cliutil"
	"go.charczuk.com/sdk/db"
	"go.charczuk.com/sdk/db/migration"
	"go.charczuk.com/sdk/logutil"
	"go.charczuk.com/sdk/quad"
	"go.charczuk.com/sdk/uuid"
)

func loadFile(path string) (*File, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	var file File
	if err = json.NewDecoder(f).Decode(&file); err != nil {
		return nil, err
	}
	return &file, nil
}

func main() {
	dbConfig := db.Config{
		Port:     "26257",
		Database: "spatial_test",
	}
	_ = dbConfig.Resolve(context.Background())

	conn, err := db.New(db.OptConfig(dbConfig))
	if err != nil {
		cliutil.Fatal(err)
	}

	l := logutil.New()
	logutil.Infof(l, "using connection string: %q", dbConfig.CreateLoggingDSN())

	if err = conn.Open(); err != nil {
		cliutil.Fatal(err)
	}

	if err = ensureSchema(context.Background(), conn); err != nil {
		cliutil.Fatal(err)
	}

	filePath := "_testdata/2023-08-07-states_all.json"
	file, err := loadFile(filePath)
	if err != nil {
		cliutil.Fatal(err)
	}

	// insert all the vectors from the file
	for _, vec := range file.States {
		if err = createStateVector(context.Background(), conn, vec); err != nil {
			cliutil.Fatal(err)
		}
	}
}

func createStateVector(ctx context.Context, conn *db.Connection, vec StateVector) error {
	_, err := conn.Exec(`INSERT INTO point_of_interest (
		timestamp_utc
		, latitude 
		, longitude
		, geom
		, callsign
		, icao24
		, origin_country
		, baro_altitude
		, on_ground
		, velocity
	) VALUES($1, $2, $3, ST_SetSRID(ST_Makepoint($3,$2), 4326), $4, $5, $6, $7, $8, $9)`, time.Now().UTC(), vec.Latitude, vec.Longitude, vec.Callsign, vec.ICAO24, vec.OriginCountry, vec.BaroAltitude, vec.OnGround, vec.Velocity)
	if err != nil {
		return fmt.Errorf("error inserting vector: %w", err)
	}
	return nil
}

func ensureSchema(ctx context.Context, conn *db.Connection) error {
	tableExists, err := migration.PredicateTableExists(ctx, conn, nil, "point_of_interest")
	if err != nil {
		return err
	}
	if !tableExists {
		_, err := conn.ExecContext(ctx, `
CREATE TABLE point_of_interest (
	id uuid not null default gen_random_uuid()
	, timestamp_utc timestamp default current_timestamp
	, latitude float not null
	, longitude float not null
	, geom GEOMETRY not null
	, callsign text
	, icao24 text
	, origin_country text
	, baro_altitude float
	, on_ground boolean
	, velocity float
	, CONSTRAINT "primary" PRIMARY KEY (id)
	, INVERTED INDEX geom_idx (geom)
	, FAMILY "primary" (id, geom)
)`)
		if err != nil {
			return err
		}
	}
	return nil
}

type PointOfInterest struct {
	ID           uuid.UUID `db:"id,pk"`
	TimestampUTC time.Time `db:"timestamp_utc"`
	Latitude     float64   `db:"latitude"`
	Longitude    float64   `db:"longitude"`

	Callsign      string  `db:"callsign"`
	ICAO24        string  `db:"icao24"`
	OriginCountry string  `db:"origin_country"`
	BaroAltitude  float64 `db:"baro_altitude"`
	OnGround      bool    `db:"on_ground"`
	Velocity      float64 `db:"velocity"`
}

func (poi PointOfInterest) TableName() string {
	return "point_of_interest"
}

func doSDK() {
	filePaths := []string{
		"_testdata/2023-08-07-states_all.json",
	}

	qt := quad.New[StateVector](
		quad.OptCenter(quad.Point{
			X: 0,
			Y: 0,
		}),
		quad.OptHalfDimensions(quad.Dimension{
			Width:  180, // -180 to 180
			Height: 90,  // -90 to 90
		}),
	)
	var points, pointsOK uint64
	var ok bool
	for _, filePath := range filePaths {
		file, err := loadFile(filePath)
		if err != nil {
			cliutil.Fatal(err)
		}
		for _, sv := range file.States {
			points++
			ok = qt.Insert(quad.Point{
				X: sv.Longitude,
				Y: sv.Latitude,
			}, sv)
			if ok {
				pointsOK++
			}
		}
	}

	fmt.Printf("points ok=%d total=%d\n", pointsOK, points)

	// visualize the quadtree
	svgWidth := 2000
	svgHeight := 857
	var falseEasting float64 = 180.0
	var falseNorthing float64 = -10

	mapHeight := float64(svgHeight)
	mapHeight2 := mapHeight / 2.0
	mapWidth := float64(svgWidth)
	pixelsPerDegree := mapWidth / 360.0

	// latitude == y, or north to south
	var mapLatitude = func(lat float64) (output int) {
		latRad := DegreesToRadians(lat + falseNorthing)
		mercN := math.Log(math.Tan(_pi4 + (latRad / 2.0)))
		return int(mapHeight2 - (mapWidth * (mercN / (_2pi))))
	}

	// longitude == x, or east to west
	var mapLongitude = func(long float64) (output int) {
		longFalse := long + falseEasting
		output = int(longFalse * pixelsPerDegree)
		return
	}

	vr, _ := newVectorRenderer(svgWidth, svgHeight)
	vr.SetSVGAttributes(`baseprofile="tiny" fill="#ececec" viewbox="0 0 2000 857"`)
	vr.Start()
	globe, _ := os.ReadFile("_testdata/globe.svg")
	vr.b.Write(globe)

	vr.SetStrokeWidth(1.0)
	vr.SetStrokeColor(ColorFromHex("000"))

	qt.VisitDepth(func(n *quad.Tree[StateVector]) {
		// draw the bounding box for the qt
		tl, br := n.Bounds()
		vr.MoveTo(mapLongitude(tl.X), mapLatitude(tl.Y))
		vr.LineTo(mapLongitude(br.X), mapLatitude(tl.Y))
		vr.LineTo(mapLongitude(br.X), mapLatitude(br.Y))
		vr.LineTo(mapLongitude(tl.X), mapLatitude(br.Y))
		vr.LineTo(mapLongitude(tl.X), mapLatitude(tl.Y))
		vr.Stroke()
		for _, pv := range n.Values() {
			vr.Circle(5.0, mapLongitude(pv.Point.X), mapLatitude(pv.Point.Y))
		}
	})
	output, err := os.Create("output.svg")
	cliutil.Fatal(err)
	defer output.Close()
	if err = vr.Save(output); err != nil {
		cliutil.Fatal(err)
	}
}

type File struct {
	Time   int64         `json:"time"`
	States []StateVector `json:"states"`
}

type StateVector struct {
	ICAO24         string         `json:"icao24"`
	Callsign       string         `json:"callsign"`
	OriginCountry  string         `json:"origin_country"`
	TimePosition   int            `json:"time_position"`
	LastContact    int            `json:"last_contact"`
	Longitude      float64        `json:"longitude"`
	Latitude       float64        `json:"latitude"`
	BaroAltitude   float64        `json:"baro_altitude"`
	OnGround       bool           `json:"on_ground"`
	Velocity       float64        `json:"velocity"`
	TrueTack       float64        `json:"true_tack"`
	VerticalRate   float64        `json:"vertical_rate"`
	Sensors        []int          `json:"sensors"`
	GeoAltitude    float64        `json:"geo_altitude,omitempty"`
	Squak          string         `json:"squak,omitempty"`
	SPI            bool           `json:"spi"`
	PositionSource PositionSource `json:"position_source"`
	Category       Category       `json:"category"`
}

func (sv *StateVector) UnmarshalJSON(data []byte) error {
	var values []any
	if err := json.Unmarshal(data, &values); err != nil {
		return err
	}
	sv.ICAO24, _ = values[0].(string)
	sv.Callsign, _ = values[1].(string)
	sv.OriginCountry, _ = values[2].(string)
	sv.TimePosition, _ = values[3].(int)
	sv.LastContact, _ = values[4].(int)
	sv.Longitude, _ = values[5].(float64)
	sv.Latitude, _ = values[6].(float64)
	sv.BaroAltitude, _ = values[7].(float64)
	sv.OnGround, _ = values[8].(bool)
	sv.Velocity, _ = values[9].(float64)
	sv.TrueTack, _ = values[10].(float64)
	sv.VerticalRate, _ = values[11].(float64)
	// sv.Sensors, _ = values[12].([]int)
	sv.GeoAltitude, _ = values[13].(float64)
	sv.Squak, _ = values[14].(string)
	sv.SPI, _ = values[15].(bool)

	if len(values) < 17 {
		return nil
	}
	rawPositionSource, _ := values[16].(int)
	sv.PositionSource = PositionSource(rawPositionSource)

	if len(values) < 18 {
		return nil
	}
	rawCategory, _ := values[17].(int)
	sv.Category = Category(rawCategory)
	return nil
}

type PositionSource int

const (
	PositionSourceADSB    = 0
	PositionSourceASTERIX = 1
	PositionSourceMLAT    = 2
	PositionSourceFLARM   = 3
)

type Category int

const (
	CategoryUnknown          = 0
	CategoryNoADSB           = 1
	CategoryLight            = 2
	CategorySmall            = 3
	CategoryLarge            = 3
	CategoryHighVortexLarge  = 4
	CategoryHeavy            = 5
	CategoryHighPerformance  = 6
	CategoryRotorcraft       = 7
	CategoryGlider           = 8
	CategoryLighterThanAir   = 9
	CategoryParachutist      = 10
	CategoryUltralight       = 11
	CategoryReserved         = 13
	CategoryUnmanned         = 14
	CategorySpace            = 15
	CategorySurfaceEmergency = 16
	CategorySurfaceService   = 17
	CategoryPointObstacle    = 18
	CategoryClusterObstacle  = 19
	CategoryLineObstacle     = 20
)

// newVectorRenderer returns a new vector renderer.
func newVectorRenderer(width, height int) (*vectorRenderer, error) {
	buffer := bytes.NewBuffer([]byte{})
	return &vectorRenderer{
		b:   buffer,
		w:   width,
		h:   height,
		c:   newCanvas(buffer),
		s:   &Style{},
		p:   []string{},
		dpi: 96,
	}, nil
}

// vectorRenderer renders chart commands to a bitmap.
type vectorRenderer struct {
	dpi  float64
	w, h int
	b    *bytes.Buffer
	c    *canvas
	s    *Style
	p    []string
}

func (vr *vectorRenderer) Start() {
	vr.c.Start(vr.w, vr.h)
}

func (vr *vectorRenderer) SetSVGAttributes(attributes string) {
	vr.c.svgAttributes = attributes
}

func (vr *vectorRenderer) ResetStyle() {
	vr.s = &Style{Font: vr.s.Font}
}

// GetDPI returns the dpi.
func (vr *vectorRenderer) GetDPI() float64 {
	return vr.dpi
}

// SetDPI implements the interface method.
func (vr *vectorRenderer) SetDPI(dpi float64) {
	vr.dpi = dpi
	vr.c.dpi = dpi
}

// SetClassName implements the interface method.
func (vr *vectorRenderer) SetClassName(classname string) {
	vr.s.ClassName = classname
}

// SetStrokeColor implements the interface method.
func (vr *vectorRenderer) SetStrokeColor(c Color) {
	vr.s.StrokeColor = c
}

// SetFillColor implements the interface method.
func (vr *vectorRenderer) SetFillColor(c Color) {
	vr.s.FillColor = c
}

// SetLineWidth implements the interface method.
func (vr *vectorRenderer) SetStrokeWidth(width float64) {
	vr.s.StrokeWidth = width
}

// StrokeDashArray sets the stroke dash array.
func (vr *vectorRenderer) SetStrokeDashArray(dashArray []float64) {
	vr.s.StrokeDashArray = dashArray
}

// MoveTo implements the interface method.
func (vr *vectorRenderer) MoveTo(x, y int) {
	vr.p = append(vr.p, fmt.Sprintf("M %d %d", x, y))
}

// LineTo implements the interface method.
func (vr *vectorRenderer) LineTo(x, y int) {
	vr.p = append(vr.p, fmt.Sprintf("L %d %d", x, y))
}

// QuadCurveTo draws a quad curve.
func (vr *vectorRenderer) QuadCurveTo(cx, cy, x, y int) {
	vr.p = append(vr.p, fmt.Sprintf("Q%d,%d %d,%d", cx, cy, x, y))
}

func (vr *vectorRenderer) ArcTo(cx, cy int, rx, ry, startAngle, delta float64) {
	startAngle = RadianAdd(startAngle, _pi2)
	endAngle := RadianAdd(startAngle, delta)

	startx := cx + int(rx*math.Sin(startAngle))
	starty := cy - int(ry*math.Cos(startAngle))

	if len(vr.p) > 0 {
		vr.p = append(vr.p, fmt.Sprintf("L %d %d", startx, starty))
	} else {
		vr.p = append(vr.p, fmt.Sprintf("M %d %d", startx, starty))
	}

	endx := cx + int(rx*math.Sin(endAngle))
	endy := cy - int(ry*math.Cos(endAngle))

	dd := RadiansToDegrees(delta)

	largeArcFlag := 0
	if delta > _pi {
		largeArcFlag = 1
	}

	vr.p = append(vr.p, fmt.Sprintf("A %d %d %0.2f %d 1 %d %d", int(rx), int(ry), dd, largeArcFlag, endx, endy))
}

// Close closes a shape.
func (vr *vectorRenderer) Close() {
	vr.p = append(vr.p, "Z")
}

// Stroke draws the path with no fill.
func (vr *vectorRenderer) Stroke() {
	vr.drawPath(vr.s.GetStrokeOptions())
}

// Fill draws the path with no stroke.
func (vr *vectorRenderer) Fill() {
	vr.drawPath(vr.s.GetFillOptions())
}

// FillStroke draws the path with both fill and stroke.
func (vr *vectorRenderer) FillStroke() {
	vr.drawPath(vr.s.GetFillAndStrokeOptions())
}

// drawPath draws a path.
func (vr *vectorRenderer) drawPath(s Style) {
	vr.c.Path(strings.Join(vr.p, "\n"), vr.s.GetFillAndStrokeOptions())
	vr.p = []string{} // clear the path
}

// Circle implements the interface method.
func (vr *vectorRenderer) Circle(radius float64, x, y int) {
	vr.c.Circle(x, y, int(radius), vr.s.GetFillAndStrokeOptions())
}

// SetFont implements the interface method.
func (vr *vectorRenderer) SetFont(f string) {
	vr.s.Font = f
}

// SetFontColor implements the interface method.
func (vr *vectorRenderer) SetFontColor(c Color) {
	vr.s.FontColor = c
}

// SetFontSize implements the interface method.
func (vr *vectorRenderer) SetFontSize(size float64) {
	vr.s.FontSize = size
}

// Text draws a text blob.
func (vr *vectorRenderer) Text(body string, x, y int) {
	vr.c.Text(x, y, body, vr.s.GetTextOptions())
}

// SetTextRotation sets the text rotation.
func (vr *vectorRenderer) SetTextRotation(radians float64) {
	vr.c.textTheta = &radians
}

// ClearTextRotation clears the text rotation.
func (vr *vectorRenderer) ClearTextRotation() {
	vr.c.textTheta = nil
}

// Save saves the renderer's contents to a writer.
func (vr *vectorRenderer) Save(w io.Writer) error {
	vr.c.End()
	_, err := w.Write(vr.b.Bytes())
	return err
}

func newCanvas(w io.Writer) *canvas {
	return &canvas{
		w:   w,
		dpi: DefaultDPI,
	}
}

const DefaultDPI = 96.0

type canvas struct {
	w             io.Writer
	dpi           float64
	textTheta     *float64
	width         int
	height        int
	css           string
	nonce         string
	svgAttributes string
}

func (c *canvas) Start(width, height int) {
	c.width = width
	c.height = height
	var attributes string
	if c.svgAttributes != "" {
		attributes = " " + c.svgAttributes
	}
	c.w.Write([]byte(fmt.Sprintf(`<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="%d" height="%d"%s>\n`, c.width, c.height, attributes)))
	if c.css != "" {
		c.w.Write([]byte(`<style type="text/css"`))
		if c.nonce != "" {
			// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
			c.w.Write([]byte(fmt.Sprintf(` nonce="%s"`, c.nonce)))
		}
		// To avoid compatibility issues between XML and CSS (f.e. with child selectors) we should encapsulate the CSS with CDATA.
		c.w.Write([]byte(fmt.Sprintf(`><![CDATA[%s]]></style>`, c.css)))
	}
}

func (c *canvas) Path(d string, style Style) {
	var strokeDashArrayProperty string
	if len(style.StrokeDashArray) > 0 {
		strokeDashArrayProperty = c.getStrokeDashArray(style)
	}
	c.w.Write([]byte(fmt.Sprintf(`<path %s d="%s" %s/>`, strokeDashArrayProperty, d, c.styleAsSVG(style))))
}

func (c *canvas) Text(x, y int, body string, style Style) {
	if c.textTheta == nil {
		c.w.Write([]byte(fmt.Sprintf(`<text x="%d" y="%d" %s>%s</text>`, x, y, c.styleAsSVG(style), body)))
	} else {
		transform := fmt.Sprintf(` transform="rotate(%0.2f,%d,%d)"`, RadiansToDegrees(*c.textTheta), x, y)
		c.w.Write([]byte(fmt.Sprintf(`<text x="%d" y="%d" %s%s>%s</text>`, x, y, c.styleAsSVG(style), transform, body)))
	}
}

func (c *canvas) Circle(x, y, r int, style Style) {
	c.w.Write([]byte(fmt.Sprintf(`<circle cx="%d" cy="%d" r="%d" %s/>`, x, y, r, c.styleAsSVG(style))))
}

func (c *canvas) End() {
	c.w.Write([]byte("</svg>"))
}

// getStrokeDashArray returns the stroke-dasharray property of a style.
func (c *canvas) getStrokeDashArray(s Style) string {
	if len(s.StrokeDashArray) > 0 {
		var values []string
		for _, v := range s.StrokeDashArray {
			values = append(values, fmt.Sprintf("%0.1f", v))
		}
		return "stroke-dasharray=\"" + strings.Join(values, ", ") + "\""
	}
	return ""
}

// GetFontFace returns the font face for the style.
func (c *canvas) getFontFace(s Style) string {
	family := "sans-serif"
	if s.Font != "" {
		family = s.Font
	}
	return fmt.Sprintf("font-family:%s", family)
}

// styleAsSVG returns the style as a svg style or class string.
func (c *canvas) styleAsSVG(s Style) string {
	sw := s.StrokeWidth
	sc := s.StrokeColor
	fc := s.FillColor
	fs := s.FontSize
	fnc := s.FontColor

	if s.ClassName != "" {
		var classes []string
		classes = append(classes, s.ClassName)
		if !sc.IsZero() {
			classes = append(classes, "stroke")
		}
		if !fc.IsZero() {
			classes = append(classes, "fill")
		}
		if fs != 0 || s.Font != "" {
			classes = append(classes, "text")
		}

		return fmt.Sprintf("class=\"%s\"", strings.Join(classes, " "))
	}

	var pieces []string

	if sw != 0 {
		pieces = append(pieces, "stroke-width:"+fmt.Sprintf("%d", int(sw)))
	} else {
		pieces = append(pieces, "stroke-width:0")
	}

	if !sc.IsZero() {
		pieces = append(pieces, "stroke:"+sc.String())
	} else {
		pieces = append(pieces, "stroke:none")
	}

	if !fnc.IsZero() {
		pieces = append(pieces, "fill:"+fnc.String())
	} else if !fc.IsZero() {
		pieces = append(pieces, "fill:"+fc.String())
	} else {
		pieces = append(pieces, "fill:none")
	}

	if fs != 0 {
		pieces = append(pieces, "font-size:"+fmt.Sprintf("%.1fpx", PointsToPixels(c.dpi, fs)))
	}
	if s.Font != "" {
		pieces = append(pieces, c.getFontFace(s))
	}
	return fmt.Sprintf("style=\"%s\"", strings.Join(pieces, ";"))
}

const (
	_pi   = math.Pi
	_2pi  = 2.0 * math.Pi
	_3pi4 = (3.0 * math.Pi) / 4.0
	_4pi3 = (4.0 * math.Pi) / 3.0
	_3pi2 = (3.0 * math.Pi) / 2.0
	_5pi4 = (5.0 * math.Pi) / 4.0
	_7pi4 = (7.0 * math.Pi) / 4.0
	_pi2  = math.Pi / 2.0
	_pi4  = math.Pi / 4.0
	_d2r  = (math.Pi / 180.0)
	_r2d  = (180.0 / math.Pi)
)

// RadiansToDegrees translates a radian value to a degree value.
func RadiansToDegrees(value float64) float64 {
	return math.Mod(value, _2pi) * _r2d
}

// RadianAdd adds a delta to a base in radians.
func RadianAdd(base, delta float64) float64 {
	value := base + delta
	if value > _2pi {
		return math.Mod(value, _2pi)
	} else if value < 0 {
		return math.Mod(_2pi+value, _2pi)
	}
	return value
}

func DegreesToRadians(degrees float64) float64 {
	return degrees * math.Pi / 180.0
}

// PointsToPixels returns the pixels for a given number of points at a DPI.
func PointsToPixels(dpi, points float64) (pixels float64) {
	pixels = (points * dpi) / 72.0
	return
}

// PixelsToPoints returns the points for a given number of pixels at a DPI.
func PixelsToPoints(dpi, pixels float64) (points float64) {
	points = (pixels * 72.0) / dpi
	return
}

// Style is a simple style set.
type Style struct {
	Hidden  bool
	Padding Box

	ClassName string

	StrokeWidth     float64
	StrokeColor     Color
	StrokeDashArray []float64

	DotColor Color
	DotWidth float64

	FillColor Color

	FontSize  float64
	FontColor Color
	Font      string

	TextLineSpacing     int
	TextRotationDegrees float64 //0 is unset or normal
}

// GetStrokeOptions returns the stroke components.
func (s Style) GetStrokeOptions() Style {
	return Style{
		ClassName:       s.ClassName,
		StrokeDashArray: s.StrokeDashArray,
		StrokeColor:     s.StrokeColor,
		StrokeWidth:     s.StrokeWidth,
	}
}

// GetFillOptions returns the fill components.
func (s Style) GetFillOptions() Style {
	return Style{
		ClassName: s.ClassName,
		FillColor: s.FillColor,
	}
}

// GetDotOptions returns the dot components.
func (s Style) GetDotOptions() Style {
	return Style{
		ClassName:       s.ClassName,
		StrokeDashArray: nil,
		FillColor:       s.DotColor,
		StrokeColor:     s.DotColor,
		StrokeWidth:     1.0,
	}
}

// GetFillAndStrokeOptions returns the fill and stroke components.
func (s Style) GetFillAndStrokeOptions() Style {
	return Style{
		ClassName:       s.ClassName,
		StrokeDashArray: s.StrokeDashArray,
		FillColor:       s.FillColor,
		StrokeColor:     s.StrokeColor,
		StrokeWidth:     s.StrokeWidth,
	}
}

// GetTextOptions returns just the text components of the style.
func (s Style) GetTextOptions() Style {
	return Style{
		ClassName:           s.ClassName,
		FontColor:           s.FontColor,
		FontSize:            s.FontSize,
		Font:                s.Font,
		TextLineSpacing:     s.TextLineSpacing,
		TextRotationDegrees: s.TextRotationDegrees,
	}
}

var (
	// ColorTransparent is a fully transparent color.
	ColorTransparent = Color{}

	// ColorWhite is white.
	ColorWhite = Color{R: 255, G: 255, B: 255, A: 255}

	// ColorBlack is black.
	ColorBlack = Color{R: 0, G: 0, B: 0, A: 255}

	// ColorRed is red.
	ColorRed = Color{R: 255, G: 0, B: 0, A: 255}

	// ColorGreen is green.
	ColorGreen = Color{R: 0, G: 255, B: 0, A: 255}

	// ColorBlue is blue.
	ColorBlue = Color{R: 0, G: 0, B: 255, A: 255}
)

func parseHex(hex string) uint8 {
	v, _ := strconv.ParseInt(hex, 16, 16)
	return uint8(v)
}

// ColorFromHex returns a color from a css hex code.
func ColorFromHex(hex string) Color {
	var c Color
	if len(hex) == 3 {
		c.R = parseHex(string(hex[0])) * 0x11
		c.G = parseHex(string(hex[1])) * 0x11
		c.B = parseHex(string(hex[2])) * 0x11
	} else {
		c.R = parseHex(string(hex[0:2]))
		c.G = parseHex(string(hex[2:4]))
		c.B = parseHex(string(hex[4:6]))
	}
	c.A = 255
	return c
}

// ColorFromAlphaMixedRGBA returns the system alpha mixed rgba values.
func ColorFromAlphaMixedRGBA(r, g, b, a uint32) Color {
	fa := float64(a) / 255.0
	var c Color
	c.R = uint8(float64(r) / fa)
	c.G = uint8(float64(g) / fa)
	c.B = uint8(float64(b) / fa)
	c.A = uint8(a | (a >> 8))
	return c
}

// ColorChannelFromFloat returns a normalized byte from a given float value.
func ColorChannelFromFloat(v float64) uint8 {
	return uint8(v * 255)
}

// Color is our internal color type because color.Color is bullshit.
type Color struct {
	R, G, B, A uint8
}

// RGBA returns the color as a pre-alpha mixed color set.
func (c Color) RGBA() (r, g, b, a uint32) {
	fa := float64(c.A) / 255.0
	r = uint32(float64(uint32(c.R)) * fa)
	r |= r << 8
	g = uint32(float64(uint32(c.G)) * fa)
	g |= g << 8
	b = uint32(float64(uint32(c.B)) * fa)
	b |= b << 8
	a = uint32(c.A)
	a |= a << 8
	return
}

// IsZero returns if the color has been set or not.
func (c Color) IsZero() bool {
	return c.R == 0 && c.G == 0 && c.B == 0 && c.A == 0
}

// IsTransparent returns if the colors alpha channel is zero.
func (c Color) IsTransparent() bool {
	return c.A == 0
}

// WithAlpha returns a copy of the color with a given alpha.
func (c Color) WithAlpha(a uint8) Color {
	return Color{
		R: c.R,
		G: c.G,
		B: c.B,
		A: a,
	}
}

// Equals returns true if the color equals another.
func (c Color) Equals(other Color) bool {
	return c.R == other.R &&
		c.G == other.G &&
		c.B == other.B &&
		c.A == other.A
}

// AverageWith averages two colors.
func (c Color) AverageWith(other Color) Color {
	return Color{
		R: (c.R + other.R) >> 1,
		G: (c.G + other.G) >> 1,
		B: (c.B + other.B) >> 1,
		A: c.A,
	}
}

// String returns a css string representation of the color.
func (c Color) String() string {
	fa := float64(c.A) / float64(255)
	return fmt.Sprintf("rgba(%v,%v,%v,%.1f)", c.R, c.G, c.B, fa)
}

// Box represents the main 4 dimensions of a box.
type Box struct {
	Top    int
	Left   int
	Right  int
	Bottom int
	IsSet  bool
}