context.go

// Copyright 2016, 2017 Florian Pigorsch. All rights reserved.
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

// Package sm (~ static maps) renders static map images from OSM tiles with markers, paths, and filled areas.
package sm

import (
	"fmt"
	"image"
	"image/color"
	"image/draw"
	"log"
	"math"
	"runtime/debug"

	"github.com/fogleman/gg"
	"github.com/golang/geo/s2"
)

// Context holds all information about the map image that is to be rendered
type Context struct {
	width  int
	height int

	zoom int // if > 0, force a requested zoom level

	hasCenter bool
	center    s2.LatLng

	hasBoundingBox bool
	boundingBox    s2.Rect

	background color.Color

	markers []*Marker
	paths   []*Path
	areas   []*Area

	userAgent    string
	tileProvider *TileProvider
}

// NewContext creates a new instance of Context
func NewContext() *Context {
	return &Context{
		width:          512,
		height:         512,
		zoom:           0, // 0 is auto zoom
		hasCenter:      false,
		hasBoundingBox: false,
		background:     nil,
		userAgent:      "",
		tileProvider:   NewTileProviderOpenStreetMaps(),
	}
}

// SetTileProvider sets the TileProvider to be used
func (m *Context) SetTileProvider(t *TileProvider) {
	m.tileProvider = t
}

// SetUserAgent sets the HTTP user agent string used when downloading map tiles
func (m *Context) SetUserAgent(a string) {
	m.userAgent = a
}

// SetSize sets the size of the generated image
func (m *Context) SetSize(width, height int) {
	m.width = width
	m.height = height
}

// SetZoom sets the zoom level
func (m *Context) SetZoom(zoom int) {
	m.zoom = zoom
}

// SetCenter sets the center coordinates
func (m *Context) SetCenter(center s2.LatLng) {
	m.center = center
	m.hasCenter = true
}

// SetBoundingBox sets the bounding box
func (m *Context) SetBoundingBox(bbox s2.Rect) {
	m.boundingBox = bbox
	m.hasBoundingBox = true
}

// SetBackground sets the background color (used as a fallback for areas without map tiles)
func (m *Context) SetBackground(col color.Color) {
	m.background = col
}

// AddMarker adds a marker to the Context
func (m *Context) AddMarker(marker *Marker) {
	m.markers = append(m.markers, marker)
}

// ClearMarkers removes all markers from the Context
func (m *Context) ClearMarkers() {
	m.markers = nil
}

// AddPath adds a path to the Context
func (m *Context) AddPath(path *Path) {
	m.paths = append(m.paths, path)
}

// ClearPaths removes all paths from the Context
func (m *Context) ClearPaths() {
	m.paths = nil
}

// AddArea adds an area to the Context
func (m *Context) AddArea(area *Area) {
	m.areas = append(m.areas, area)
}

// ClearAreas removes all areas from the Context
func (m *Context) ClearAreas() {
	m.areas = nil
}

// bounds returns the boundign box, including any requeted
// bounding box, markers, paths, areas, and center
func (m *Context) bounds() s2.Rect {
	r := s2.EmptyRect()
	if m.hasBoundingBox {
		r = m.boundingBox
	}
	if m.hasCenter {
		r = r.AddPoint(m.center)
	}
	for _, marker := range m.markers {
		r = r.Union(marker.bounds())
	}
	for _, path := range m.paths {
		r = r.Union(path.bounds())
	}
	for _, area := range m.areas {
		r = r.Union(area.bounds())
	}
	return r
}

func (m *Context) determineExtraMarginPixels() float64 {
	p := 0.0
	for _, marker := range m.markers {
		if pp := marker.extraMarginPixels(); pp > p {
			p = pp
		}
	}
	for _, path := range m.paths {
		if pp := path.extraMarginPixels(); pp > p {
			p = pp
		}
	}
	for _, area := range m.areas {
		if pp := area.extraMarginPixels(); pp > p {
			p = pp
		}
	}
	return p
}

// determineZoom returns the desired zoom level based on requested
// image pizel width and tile pixel size
func (m *Context) determineZoom() int {
	b := m.bounds()
	if b.IsEmpty() || b.IsPoint() {
		return 15
	}

	tileSize := m.tileProvider.TileSize
	margin := 4.0 + m.determineExtraMarginPixels()
	w := (float64(m.width) - 2.0*margin) / float64(tileSize)
	h := (float64(m.height) - 2.0*margin) / float64(tileSize)
	minX := (b.Lo().Lng.Degrees() + 180.0) / 360.0
	maxX := (b.Hi().Lng.Degrees() + 180.0) / 360.0
	minY := (1.0 - math.Log(math.Tan(b.Lo().Lat.Radians())+(1.0/math.Cos(b.Lo().Lat.Radians())))/math.Pi) / 2.0
	maxY := (1.0 - math.Log(math.Tan(b.Hi().Lat.Radians())+(1.0/math.Cos(b.Hi().Lat.Radians())))/math.Pi) / 2.0

	dx := maxX - minX
	for dx < 0 {
		dx = dx + 1
	}
	for dx > 1 {
		dx = dx - 1
	}
	dy := math.Abs(maxY - minY)

	zoom := 2
	for zoom < 30 {
		tiles := float64(uint(1) << uint(zoom))
		if dx*tiles > w || dy*tiles > h {
			return zoom - 1
		}
		zoom = zoom + 1
	}

	return 15
}

// getCenter returns the center of the area
func (m *Context) getCenter() s2.LatLng {
	if m.hasCenter {
		return m.center
	}
	return m.bounds().Center()
}

type transformer struct {
	zoom               int
	numTiles           float64 // number of tiles per dimension at this zoom level
	tileSize           int     // tile size in pixels from this provider
	pWidth, pHeight    int     // pixel size of returned set of tiles
	pCenterX, pCenterY int     // pixel location of requested center in set of tiles
	tCountX, tCountY   int     // download area in tile units
	tCenterX, tCenterY float64 // tile index to requested center
	tOriginX, tOriginY int     // bottom left tile to download
	pMinX, pMaxX       int
}

func (m *Context) newTransformer(zoom int) *transformer {
	tileSize := m.tileProvider.TileSize
	t := &transformer{
		zoom:     zoom,
		numTiles: math.Exp2(float64(zoom)),
		tileSize: tileSize,
	}

	numTiles := int(t.numTiles)

	// get bounds for bounding box or markers, paths, etc...
	bbox := m.bounds()
	if bbox.IsEmpty() {
		log.Print("Map tile fetch failed, requested area has no bounding box, contect, or center")
		return t
	}

	// fractional tile index to center of requested area
	t.tCenterX, t.tCenterY = t.ll2t(bbox.Center())

	// minimum tiles to return to meet pixel request
	ww := float64(m.width) / float64(tileSize)
	hh := float64(m.height) / float64(tileSize)

	lo := bbox.Lo()
	hi := bbox.Hi()
	// origin tile to fulfill request
	// tiles come from top left
	tlX, tlY := t.ll2t(s2.LatLng{
		Lat: hi.Lat,
		Lng: lo.Lng,
	})
	// tiles in each axis to fulfill request
	// tiles fromtop left to bottom right
	brX, brY := t.ll2t(s2.LatLng{
		Lat: lo.Lat,
		Lng: hi.Lng,
	})

	if bbox.Lng.IsFull() {
		t.tOriginX = 0
		t.tCountX = numTiles
	} else {
		t.tOriginX = int(math.Floor(tlX))
		// impose minimum pixel limit
		if float64(t.tOriginX)+0.5*ww > t.tCenterX {
			t.tOriginX = int(math.Floor(t.tCenterX - 0.5*ww))
		}
		t.tCountX = int(math.Ceil(brX)) - t.tOriginX + 1
		// impose minimum pixel limit
		if t.tCountX < int(ww) {
			t.tCountX = int(math.Ceil(ww))
		}
		if t.tCountX > numTiles {
			t.tCountX = numTiles
		}
	}

	if hi.Lat > 0.9*math.Pi && lo.Lat < -0.9*math.Pi {
		t.tOriginY = 0
		t.tCountY = numTiles
	} else {
		t.tOriginY = int(math.Floor(tlY))
		if float64(t.tOriginY)+0.5*hh > t.tCenterY {
			t.tOriginY = int(math.Floor(t.tCenterY - 0.5*hh))
		}
		t.tCountY = int(math.Ceil(brY)) - t.tOriginY + 1
		if t.tCountY < int(hh) {
			t.tCountY = int(math.Ceil(hh))
		}
		if t.tCountY > numTiles {
			t.tCountY = numTiles
		}
	}

	// final pixel dimensions of area returned
	t.pWidth = t.tCountX * tileSize
	t.pHeight = t.tCountY * tileSize

	// Pixel location in returned image for center of reqested area
	t.pCenterX = int((t.tCenterX - float64(t.tOriginX)) * float64(tileSize))
	t.pCenterY = int((t.tCenterY - float64(t.tOriginY)) * float64(tileSize))

	t.pMinX = t.pCenterX - m.width/2
	t.pMaxX = t.pMinX + m.width

	return t
}

// ll2t returns fractional tile index for a lat/lng points
func (t *transformer) ll2t(ll s2.LatLng) (float64, float64) {
	x := t.numTiles * (ll.Lng.Degrees() + 180.0) / 360.0
	if ll.Lat > math.Pi*0.5 {
		return x, 0
	}
	if ll.Lat < -math.Pi*0.5 {
		return x, t.numTiles - 1
	}
	y := t.numTiles * (1 - math.Log(math.Tan(ll.Lat.Radians())+(1.0/math.Cos(ll.Lat.Radians())))/math.Pi) / 2.0
	return x, y
}

func (t *transformer) ll2p(ll s2.LatLng) (float64, float64) {
	x, y := t.ll2t(ll)
	x = float64(t.pCenterX) + (x-t.tCenterX)*float64(t.tileSize)
	y = float64(t.pCenterY) + (y-t.tCenterY)*float64(t.tileSize)

	offset := t.numTiles * float64(t.tileSize)
	if x < float64(t.pMinX) {
		for x < float64(t.pMinX) {
			x = x + offset
		}
	} else if x >= float64(t.pMaxX) {
		for x >= float64(t.pMaxX) {
			x = x - offset
		}
	}
	return x, y
}

// Rect returns an s2.Rect bounding box around the set of tiles described by transformer
func (t *transformer) Rect() (bbox s2.Rect) {
	// transform from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Go
	invNumTiles := 1.0 / t.numTiles
	// Get latitude bounds
	n := math.Pi - 2.0*math.Pi*float64(t.tOriginY)*invNumTiles
	bbox.Lat.Hi = math.Atan(0.5 * (math.Exp(n) - math.Exp(-n)))
	n = math.Pi - 2.0*math.Pi*float64(t.tOriginY+t.tCountY)*invNumTiles
	bbox.Lat.Lo = math.Atan(0.5 * (math.Exp(n) - math.Exp(-n)))
	// Get longtitude bounds, much easier
	bbox.Lng.Lo = float64(t.tOriginX)*invNumTiles*2.0*math.Pi - math.Pi
	bbox.Lng.Hi = float64(t.tOriginX+t.tCountX)*invNumTiles*2.0*math.Pi - math.Pi
	return bbox
}

// TileRect returns the s2.Rect for a given tile
func (t *transformer) TileRect(x, y int) (bbox s2.Rect) {
	// transform from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Go
	invNumTiles := 1.0 / t.numTiles
	// Get latitude bounds
	n := math.Pi - 2.0*math.Pi*float64(y)*invNumTiles
	bbox.Lat.Hi = math.Atan(0.5 * (math.Exp(n) - math.Exp(-n)))
	n = math.Pi - 2.0*math.Pi*float64(y+1)*invNumTiles
	bbox.Lat.Lo = math.Atan(0.5 * (math.Exp(n) - math.Exp(-n)))
	// Get longtitude bounds, much easier
	bbox.Lng.Lo = float64(x)*invNumTiles*2.0*math.Pi - math.Pi
	bbox.Lng.Hi = float64(x+1)*invNumTiles*2.0*math.Pi - math.Pi
	return bbox

}

// Render actually renders the map image including all map objects (markers, paths, areas)
func (m *Context) Render() (image.Image, error) {

	zoom := m.zoom
	if zoom <= 0 {
		zoom = m.determineZoom()
	}

	tileSize := m.tileProvider.TileSize
	trans := m.newTransformer(zoom)
	img := image.NewRGBA(image.Rect(0, 0, trans.pWidth, trans.pHeight))
	gc := gg.NewContextForRGBA(img)
	if m.background != nil {
		draw.Draw(img, img.Bounds(), &image.Uniform{m.background}, image.ZP, draw.Src)
	}

	// fetch and draw tiles to img
	t := NewTileFetcher(m.tileProvider)
	if m.userAgent != "" {
		t.SetUserAgent(m.userAgent)
	}

	tiles := (1 << uint(zoom))
	for xx := 0; xx < trans.tCountX; xx++ {
		x := trans.tOriginX + xx
		if x < 0 {
			x = x + tiles
		} else if x >= tiles {
			x = x - tiles
		}
		for yy := 0; yy < trans.tCountY; yy++ {
			y := trans.tOriginY + yy
			if y < 0 || y >= tiles {
				log.Printf("Skipping out of bounds tile %d/%d", x, y)
			} else {
				if tileImg, err := t.Fetch(zoom, x, y); err == nil {
					gc.DrawImage(tileImg, xx*tileSize, yy*tileSize)
				} else {
					log.Printf("Error downloading tile file: %s", err)
				}
			}
		}
	}

	// draw map objects
	for _, area := range m.areas {
		area.draw(gc, trans)
	}
	for _, path := range m.paths {
		path.draw(gc, trans)
	}
	for _, marker := range m.markers {
		marker.draw(gc, trans)
	}

	// crop image
	croppedImg := image.NewRGBA(image.Rect(0, 0, int(m.width), int(m.height)))
	draw.Draw(croppedImg, image.Rect(0, 0, int(m.width), int(m.height)),
		img, image.Point{trans.pCenterX - int(m.width)/2, trans.pCenterY - int(m.height)/2},
		draw.Src)

	// draw attribution
	if m.tileProvider.Attribution == "" {
		return croppedImg, nil
	}
	_, textHeight := gc.MeasureString(m.tileProvider.Attribution)
	boxHeight := textHeight + 4.0
	gc = gg.NewContextForRGBA(croppedImg)
	gc.SetRGBA(0.0, 0.0, 0.0, 0.5)
	gc.DrawRectangle(0.0, float64(m.height)-boxHeight, float64(m.width), boxHeight)
	gc.Fill()
	gc.SetRGBA(1.0, 1.0, 1.0, 0.75)
	gc.DrawString(m.tileProvider.Attribution, 4.0, float64(m.height)-4.0)

	return croppedImg, nil
}

// Tile represents an image tile with an associated lat/lng boundign rectangle
type Tile struct {
	image.Image       // Image is data in this tile
	s2.Rect           // Rect provides the Lat/Lng bounding box for this tile
	Err         error // Err reports any error attempting to retrieve this tile
}

// GetTiles requests a set of tiles, which will be sent over the returned channel.
// The channel will closed when all tiles have been returned.
func (m *Context) GetTiles(cancel <-chan struct{}) (tiles <-chan Tile, zoom int) {

	zoom = m.zoom
	if zoom <= 0 {
		zoom = m.determineZoom()
	}

	trans := m.newTransformer(zoom)

	// fetch and draw tiles to img
	t := NewTileFetcher(m.tileProvider)
	if m.userAgent != "" {
		t.SetUserAgent(m.userAgent)
	}

	// make channel to handle all returned tiles,
	// ensures below go routine will not stall if consumer
	// gives up before reading
	ch := make(chan Tile, trans.tCountX*trans.tCountY+1)

	go func(ch chan<- Tile) {
		defer func() {
			if r := recover(); r != nil {
				ch <- Tile{
					Err: fmt.Errorf("%v\n%s", r, string(debug.Stack())),
				}
			}
			close(ch)
		}()

		numTiles := int(trans.numTiles)
		for xx := 0; xx < trans.tCountX; xx++ {
			x := trans.tOriginX + xx
			x = x % numTiles
			if x < 0 {
				x += numTiles
			}
			for yy := 0; yy < trans.tCountY; yy++ {
				y := trans.tOriginY + yy
				y = y % numTiles
				if y < 0 {
					y += numTiles
				}
				tile := Tile{
					Rect: trans.TileRect(x, y),
				}
				tile.Image, tile.Err = t.Fetch(zoom, x, y)

				// check cancel seprately from send select below
				// ensure we don't keep trying to retrieve and send
				// if cancel is requested since order in below select is
				// random
				select {
				case _ = <-cancel:
					// abort this retrieval
					return
				default:
				}

				select {
				case ch <- tile:
					// ch is large enough for all tiles, so should never
					// block, but listen for cancel concurrently anyway to be safe
				case _ = <-cancel:
					// abort this retrieval
					return
				}
			}
		}
	}(ch) // go routine to fetch and send tiles over channel
	return ch, zoom
}

// RenderWithBounds actually renders the map image including all map objects (markers, paths, areas)
// returned image covers requested area as well as any tiles necessary to cover that area, which may
// be larger than the request
//
// Specific bounding box of as-returned image is provided to support image registratino with other data
func (m *Context) RenderWithBounds() (image.Image, s2.Rect, error) {
	zoom := m.zoom
	if zoom <= 0 {
		zoom = m.determineZoom()
	}

	tileSize := m.tileProvider.TileSize
	trans := m.newTransformer(zoom)
	img := image.NewRGBA(image.Rect(0, 0, trans.pWidth, trans.pHeight))
	gc := gg.NewContextForRGBA(img)
	if m.background != nil {
		draw.Draw(img, img.Bounds(), &image.Uniform{m.background}, image.ZP, draw.Src)
	}

	// fetch and draw tiles to img
	t := NewTileFetcher(m.tileProvider)
	if m.userAgent != "" {
		t.SetUserAgent(m.userAgent)
	}

	tiles := (1 << uint(zoom))
	for xx := 0; xx < trans.tCountX; xx++ {
		x := trans.tOriginX + xx
		if x < 0 {
			x = x + tiles
		} else if x >= tiles {
			x = x - tiles
		}
		for yy := 0; yy < trans.tCountY; yy++ {
			y := trans.tOriginY + yy
			if y < 0 || y >= tiles {
				log.Printf("Skipping out of bounds tile %d/%d", x, y)
			} else {
				if tileImg, err := t.Fetch(zoom, x, y); err == nil {
					gc.DrawImage(tileImg, xx*tileSize, yy*tileSize)
				} else {
					log.Printf("Error downloading tile file: %s", err)
				}
			}
		}
	}

	// draw map objects
	for _, area := range m.areas {
		area.draw(gc, trans)
	}
	for _, path := range m.paths {
		path.draw(gc, trans)
	}
	for _, marker := range m.markers {
		marker.draw(gc, trans)
	}

	// draw attribution
	if m.tileProvider.Attribution == "" {
		return img, trans.Rect(), nil
	}
	_, textHeight := gc.MeasureString(m.tileProvider.Attribution)
	boxHeight := textHeight + 4.0
	gc.SetRGBA(0.0, 0.0, 0.0, 0.5)
	gc.DrawRectangle(0.0, float64(trans.pHeight)-boxHeight, float64(trans.pWidth), boxHeight)
	gc.Fill()
	gc.SetRGBA(1.0, 1.0, 1.0, 0.75)
	gc.DrawString(m.tileProvider.Attribution, 4.0, float64(m.height)-4.0)

	return img, trans.Rect(), nil
}