This implements very basic linear referencing functions on Lines and Paths, e.g.

    p := NewPath()
    p.Push(NewPoint(0, 0))
    p.Push(NewPoint(6, 8))
    p.Push(NewPoint(12, 0))
    p.Project(NewPoint(3, 4)) // 5
    p.ProjectNormalized(NewPoint(3, 4)) // 0.25

Happy to hear any feedback.

Thanks for this library!

By following the example, it returned "\x010100000000000000000024c00000000000003e40" to go.geo causing "go.geo: incorrect geometry" error

Any idea what's wrong? thanks!

heya, is it currently possible to compute the mid point along a path (a point on the line string which is exactly 50% along the line)?

I had a look at the APIs and I guess I could use path.Distance() to get the total distance, then I think I would need to walk the points to find the line segment which lies in the center, from there it's a task of interpolating along that segment to find the correct position.

is this all possible with the existing methods or would it require me to open a PR to add additional methods?

Rather than having to use ToGeoJSON(), is there a reason not to just have a built in custom MarshalJSON() that defaults to GeoJSON? That would allow embedded geo fields to marshal properly to GeoJSON out of the box.

I'm trying to select postgis multipoint to geo.PointSet - and scan fails. Checking code - seems like format actually returned by postgis is different from what's expected by geo.PointSet.

BTW for geo.Point WKB scan works fine.

Here is sample code demonstrating issue (manually setup postgresql + postgis server required for test):

package main

import (
	"database/sql"
	"testing"

	_ "github.com/lib/pq"
	geo "github.com/paulmach/go.geo"
	"github.com/stretchr/testify/require"
)

func TestMultipointScan(t *testing.T) {
	/*
		select version() union select postgis_full_version();
		                                                                               version
		----------------------------------------------------------------------------------------------------------------------------------------------------------------------
		 POSTGIS="2.3.2 r15302" GEOS="3.4.2-CAPI-1.8.2 r3921" PROJ="Rel. 4.8.0, 6 March 2012" GDAL="GDAL 1.10.1, released 2013/08/26" LIBXML="2.9.1" LIBJSON="0.11.99" RASTER
		 PostgreSQL 9.6.2 on x86_64-pc-linux-gnu, compiled by gcc (Debian 4.9.2-10) 4.9.2, 64-bit
	*/
	db, err := sql.Open("postgres", "user=x password=x dbname=x sslmode=disable")
	require.NoError(t, err)

	const query = `
		SELECT ST_AsBinary(ST_Collect(ST_GeomFromText('POINT(1 2)'), ST_GeomFromText('POINT(1 2)')))
	`
	var ps geo.PointSet
	err = db.QueryRow(query).Scan(&ps)

	require.NoError(t, err)

	/*
		go test -run TestMultipointScan -v
		=== RUN   TestMultipointScan
		--- FAIL: TestMultipointScan (0.04s)
			Error Trace:	sample_test.go:23
			Error:		Received unexpected error:
					sql: Scan error on column index 0: go.geo: invalid WKB data
	*/
}

For example I used this and scanned it to a geo.PointSet

SET @g = 'POLYGON((50.866753 5.686455, 50.859819 5.708942, 50.851475 5.722675, 50.841611 5.720615, 50.834023 5.708427, 50.840744 5.689373, 50.858735 5.673923, 50.866753 5.686455))';
SELECT ST_AsBinary(PolyFromText(@g));

var p *geo.PointSet
row.Scan(&p)

//  p == EMPTY

It's very likely that I'm way off on this. What am I doing wrong?

hey @paulmach I've been playing with an alternate irregular polygon centroid algorithm which I borrowed from https://github.com/manuelbieh/Geolib/blob/master/src/geolib.js#L404

in theory it should provide a better 'center of gravity' calc than than the existing PointSet.Centroid() algo as it converts the coords to a spherical coordinate space before averaging the values.

what are your thoughts? is this something you'd be interested in merging at some point?

see: http://geojson.io/#id=gist:anonymous/ecd1ce4af92368aa4aea&map=3/-72.39/167.70

package main

import "fmt"
import "math"
import "github.com/paulmach/go.geo"

func main() {
  // berlin := geo.NewPoint(13.408056,52.518611)
  // moscow := geo.NewPoint(37.617778,55.751667)
  // points := geo.PointSet{}
  // points.Push(berlin).Push(moscow)

  // rough new zealand polygon
  // ref: http://geojson.io/#id=gist:anonymous/adc4993b4b85f55ea9ae
  // points := geo.PointSet{}
  // points.Push(geo.NewPoint(172.1298828125,-33.97980872872456))
  // points.Push(geo.NewPoint(172.1298828125,-37.30027528134431))
  // points.Push(geo.NewPoint(165.8974609375,-38.54816542304658))
  // points.Push(geo.NewPoint(168.1728515625,-46.10370875598026))
  // points.Push(geo.NewPoint(179.7802734375,-47.8721439688873))
  // // points.Push(geo.NewPoint(-188.1298828125,-33.97980872872456))

  // antarctica bbox
  points := geo.PointSet{}
  points.Push(geo.NewPoint(148.7109375,-84.83422451455142))
  points.Push(geo.NewPoint(148.7109375,-76.51681887717322))
  points.Push(geo.NewPoint(186.6796875,-76.51681887717322))
  points.Push(geo.NewPoint(186.6796875,-84.83422451455142))

  fmt.Println(points)
  fmt.Println(points.Centroid())
  fmt.Println(getCentroid(points))
}

func getCentroid(ps geo.PointSet) *geo.Point {

  X := 0.0
  Y := 0.0
  Z := 0.0

  var toRad = math.Pi / 180
  var fromRad = 180 / math.Pi

  for _, point := range ps {

    var lon = point[0] * toRad
    var lat = point[1] * toRad

    X += math.Cos(lat) * math.Cos(lon)
    Y += math.Cos(lat) * math.Sin(lon)
    Z += math.Sin(lat)
  }

  numPoints := float64(len(ps))
  X = X / numPoints
  Y = Y / numPoints
  Z = Z / numPoints

  var lon = math.Atan2(Y, X)
  var hyp = math.Sqrt(X * X + Y * Y)
  var lat = math.Atan2(Z, hyp)

  var centroid = geo.NewPoint(lon * fromRad, lat * fromRad)

  return centroid;
}

Hi, not an issue so much, as something I'm struggling with adapting.

I need the ability to have a number associated with a geo point, in order to reference back to what it relates to. I've customised the point type to have length of 3 instead of 2, with the 3rd float been the ID, so the idea was, when I ran a nearest command against the quad tree of points, I'd be able to find it's owner.

The creating of the point works, and the existing tests pass. But soon as the point is added to the quad tree, it appears to lose it's 3rd value, returning X and Y as expected, but the 3rd number is always 0.

Is there something I'm missing in the quad tree section, that is removing this 3rd column. Any help or advice on the best way to approach this would be much appreciated!

This PR implements a quadtree for use with objects that implement the geo.Pointer interface:

type Pointer interface {
    Point() *Point
}

It supports Find which locates the nearest pointer to given point and InBound which finds all the points in the bounds. I think performance is really good:

BenchmarkInsert-4                2000000           749 ns/op          72 B/op          1 allocs/op
BenchmarkInsert1000-4            2000000           668 ns/op          72 B/op          1 allocs/op
BenchmarkFromPointer1000-4         10000        197301 ns/op      100003 B/op          8 allocs/op
BenchmarkRandomFind1000-4        2000000           907 ns/op         112 B/op          5 allocs/op
BenchmarkRandomInBound1000-4      300000          4928 ns/op        1828 B/op         10 allocs/op
BenchmarkRandomInBound1000Buf-4   500000          3245 ns/op          80 B/op          4 allocs/op

This is based on a tree with 1000 random points. So it'll be different in practice, but I think it's pretty good.

Still left to do:

• [x] Think about TODO that deals with how to handle close/duplicate points.
• [x] ~~Remove point~~ leave for v2
• [x] Write a README with some examples

If you have a chance. @mlerner please review.

I'd like to be able to scan data from the multipolygon column from the PostGIS database into Go app.

I was hoping I could simply define a struct where one of the fields is of type MultiPolygon:

import(geo "github.com/paulmach/go.geo")
...
type Area struct {
	ID        uuid.UUID        `gorm:"column:id" json:"id"`
	Shape     *geo.MultiPolygon `gorm:"column:shape" json:"shape"`

However, of course such a type is not yet defined.

Is there a way to actually read the MultiPolygon data from PostGIS?

Also it seems that we have to run the ST_AsBinary function when fetching data from the database. Failing to do so results in the sql: Scan error on column index 3: go.geo: invalid WKB data error.

Couldn't we always apply the ST_AsBinary function? eg. when defining the struct? I'd say that the typical scenario is that the data is actually saved as WKB binary and the ST_AsBinary function simply changes:

shape | 01060...E614340

to

st_asbinary | \x01060...e614340

Currently I'm doing something like:

quadkey := geo.NewPoint(v.Lon, v.Lat).QuadkeyString(quadKeyLevel)

With v.Lon and v.Lat not necessarily being on a tile boundary. I'm not sure, based on the results, whether QuadKeyString will represent a tile, or if it'll be different based on different points with a tile at the same level.

I have this javascript code which normalizes geographic coordinates to within the ranges of lat +-90 and lon +-180 (it unwinds multiple rotations around the globe).

This function is quite nice as it avoids floating point precision errors which can occur when using other methods.

Would you be interested in me porting the code to go.geo? If so what would you call the method? it's specific to geographic coordinates.

Maybe this could close https://github.com/paulmach/go.geo/pull/41 as it appears to be doing something similar?

Could be named something like point.NormalizeGeographicCoordinates()