geoserver Is a Go Package For Manipulating a GeoServer Instance via the GeoServer REST API

[![Go Report Card](https://goreportcard.com/badge/github.com/hishamkaram/geoserver)](https://goreportcard.com/report/github.com/hishamkaram/geoserver)
[![GitHub license](https://img.shields.io/github/license/hishamkaram/geoserver.svg)](https://github.com/hishamkaram/geoserver/blob/master/LICENSE)
[![GitHub issues](https://img.shields.io/github/issues/hishamkaram/geoserver.svg)](https://github.com/hishamkaram/geoserver/issues)
[![Coverage Status](https://coveralls.io/repos/github/hishamkaram/geoserver/badge.svg?branch=master&service=github)](https://coveralls.io/github/hishamkaram/geoserver?branch=master&service=github)
[![Build Status](https://travis-ci.org/hishamkaram/geoserver.svg?branch=master)](https://travis-ci.org/hishamkaram/geoserver)
[![Documentation](https://godoc.org/github.com/hishamkaram/geoserver?status.svg)](https://godoc.org/github.com/hishamkaram/geoserver?)
[![GitHub forks](https://img.shields.io/github/forks/hishamkaram/geoserver.svg)](https://github.com/hishamkaram/geoserver/network)
[![GitHub stars](https://img.shields.io/github/stars/hishamkaram/geoserver.svg)](https://github.com/hishamkaram/geoserver/stargazers)
[![Twitter](https://img.shields.io/twitter/url/https/github.com/hishamkaram/geoserver/edit/master/README.md.svg?style=social)](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fhishamkaram%2Fgeoserver%2Fedit%2Fmaster%2FREADME.md)






 <img src="https://i.imgur.com/bVuV5v6.png" width="200"/>


 <img src="https://i.imgur.com/31CL1xg.png" width="200"/>


# Geoserver
geoserver Is a Go Package For Manipulating a GeoServer Instance via the GeoServer REST API. 

---
## How to install:
- `go get -v gopkg.in/hishamkaram/geoserver.v1`
 - now you can import the package from `gopkg.in/hishamkaram/geoserver.v1`, example:
 ```
 import (
 ...
 "gopkg.in/hishamkaram/geoserver.v1"
 ...
 )
 ```
---

## usage:
 - Create new Catalog (which contains all available operations):
 - `gsCatalog := geoserver.GetCatalog("http://localhost:8080/geoserver13/", "admin", "geoserver")`
 - Use catalog Methods to Perform a Geoserver REST Operation:
 - Create New workspace:
 ```
 created, err := gsCatalog.CreateWorkspace("golang")
 if err != nil {
 fmt.Printf("\nError:%s\n", err)
 }
 fmt.Println(strconv.FormatBool(created))
 ```
 output if created:
 ```
 INFO[31-03-2018 16:26:35] url:http://localhost:8080/geoserver13/rest/workspaces	response Status=201 
 true
 ```
 output if error:
 ```
 INFO[31-03-2018 16:26:37] url:http://localhost:8080/geoserver13/rest/workspaces	response Status=401 
 WARN[31-03-2018 16:26:37] <!doctype html><html lang="en"><head><title>HTTP Status 401 – Unauthorized</title><style type="text/css">h1 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:22px;} h2 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:16px;} h3 {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;font-size:14px;} body {font-family:Tahoma,Arial,sans-serif;color:black;background-color:white;} b {font-family:Tahoma,Arial,sans-serif;color:white;background-color:#525D76;} p {font-family:Tahoma,Arial,sans-serif;background:white;color:black;font-size:12px;} a {color:black;} a.name {color:black;} .line {height:1px;background-color:#525D76;border:none;}</style></head><body><h1>HTTP Status 401 – Unauthorized</h1><hr class="line" />Type Status ReportMessage Workspace &#39;golang&#39; already existsDescription The request has not been applied because it lacks valid authentication credentials for the target resource.<hr class="line" /><h3>Apache Tomcat/9.0.6</h3></body></html> 

 Error:Unauthorized
 false
 ```
 - Get Layers through GetLayers take workspace as paramter if empty workspace will be ignored and geoserver will return all public layers
 ```
 layers, err := gsCatalog.GetLayers("")
 if err != nil {
 fmt.Printf("\nError:%s\n", err)
 }
 for _, lyr := range layers {
 fmt.Printf("\nName:%s href:%s\n", lyr.Name, lyr.Href)
 }
 ```
 output:
 ```
 INFO[31-03-2018 19:04:44] url:http://localhost:8080/geoserver13/rest/layers	response Status=200 

 Name:tiger:giant_polygon href:http://localhost:8080/geoserver13/rest/layers/tiger%3Agiant_polygon.json

 Name:tiger:poi href:http://localhost:8080/geoserver13/rest/layers/tiger%3Apoi.json

 Name:tiger:poly_landmarks href:http://localhost:8080/geoserver13/rest/layers/tiger%3Apoly_landmarks.json

 Name:tiger:tiger_roads href:http://localhost:8080/geoserver13/rest/layers/tiger%3Atiger_roads.json

 Name:nurc:Arc_Sample href:http://localhost:8080/geoserver13/rest/layers/nurc%3AArc_Sample.json

 Name:nurc:Img_Sample href:http://localhost:8080/geoserver13/rest/layers/nurc%3AImg_Sample.json

 Name:nurc:Pk50095 href:http://localhost:8080/geoserver13/rest/layers/nurc%3APk50095.json

 Name:nurc:mosaic href:http://localhost:8080/geoserver13/rest/layers/nurc%3Amosaic.json
 ......
 ```
 - Get Specific Layer from Geoserver:
 ```
 layer, err := gsCatalog.GetLayer("nurc", "Arc_Sample")
 if err != nil {
 fmt.Printf("\nError:%s\n", err)
 } else {
 fmt.Printf("%+v\n", layer)
 }
 ```
 output:
 ```
 INFO[31-03-2018 20:12:07] url:http://localhost:8080/geoserver13/rest/workspaces/nurc/layers/Arc_Sample	response Status=200 
 {Name:Arc_Sample Path:/ Type:RASTER DefaultStyle:{Class: Name:rain Href:http://localhost:8080/geoserver13/rest/styles/rain.json} Styles:{Class:linked-hash-set Style:[{Class: Name:raster Href:http://localhost:8080/geoserver13/rest/styles/raster.json}]} Resource:{Class:coverage Name:nurc:Arc_Sample Href:http://localhost:8080/geoserver13/rest/workspaces/nurc/coveragestores/arcGridSample/coverages/Arc_Sample.json} Queryable:false Opaque:false Attribution:{Title: Href: LogoURL: LogoType: LogoWidth:0 LogoHeight:0}}
 ```
 - You can find more examples by check testing files
 - You can find all supported operations on [Godocs](https://godoc.org/github.com/hishamkaram/geoserver)
 ---

### TESTING
| | Go Version | Geoserver Version | Tested |
|---|------------|-------------------|--------------------|
| 1 | 1.13.x | 2.13.x | :heavy_check_mark: |
| 2 | 1.13.x | 2.14.x | :heavy_check_mark: |
| 3 | 1.14.x | 2.13.x | :heavy_check_mark: |
| 4 | 1.14.x | 2.14.x | :heavy_check_mark: |
| 5 | 1.15.x | 2.13.x | :heavy_check_mark: |
| 6 | 1.15.x | 2.14.x | :heavy_check_mark: |

___
### [Documentation](https://godoc.org/github.com/hishamkaram/geoserver)

geoserver

Go bindings for H3, a hierarchical hexagonal geospatial indexing system

<img src="https://uber.github.io/img/h3Logo-color.svg" alt="H3 Logo" width="200" align="right" />

[![Build](https://github.com/uber/h3-go/actions/workflows/build.yml/badge.svg)](https://github.com/uber/h3-go/actions/workflows/build.yml)
[![Coverage Status](https://coveralls.io/repos/github/uber/h3-go/badge.svg?branch=master)](https://coveralls.io/github/uber/h3-go?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/uber/h3-go/v4)](https://goreportcard.com/report/github.com/uber/h3-go)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![Go Reference](https://pkg.go.dev/badge/github.com/uber/h3-go/v4.svg)](https://pkg.go.dev/github.com/uber/h3-go/v4)
[![H3 Version](https://img.shields.io/badge/h3-v4.4.0-blue.svg)](https://github.com/uber/h3/releases/tag/v4.4.0)

# H3-Go

This library provides Golang bindings for the
[H3 Core Library](https://github.com/uber/h3). For API reference, see the
[H3 Documentation](https://h3geo.org/).

**This is v4 of this library, supporting H3 v4.**

Check out [v3](https://github.com/uber/h3-go/tree/v3.7.1) or checkout the git tag for the version you need.

**Migrating from v3?**

Check out [v3 to v4 migration guide](https://h3geo.org/docs/library/migrating-3.x).
There have been no breaking changes to the format of H3 indexes. Indexes
generated by older versions can be parsed in v4, and vice-versa.

# Usage

## Prerequisites

H3-Go requires [CGO](https://golang.org/cmd/cgo/) (`CGO_ENABLED=1`) in order to
be built. Go should do the right thing when including this library:

> The cgo tool is enabled by default for native builds on systems where it is
> expected to work. It is disabled by default when cross-compiling as well as
> when the CC environment variable is unset and the default C compiler (typically
> gcc or clang) cannot be found on the system PATH. You can override the default
> by setting the CGO_ENABLED environment variable when running the go tool: set
> it to 1 to enable the use of cgo, and to 0 to disable it. The go tool will set
> the build constraint "cgo" if cgo is enabled. The special import "C" implies
> the "cgo" build constraint, as though the file also said "//go:build cgo".
> Therefore, if cgo is disabled, files that import "C" will not be built by the
> go tool. (For more about build constraints see https://pkg.go.dev/go/build#hdr-Build_Constraints).

If you see errors/warnings like _"build constraints exclude all Go files..."_,
then the `cgo` build constraint is likely disabled; try setting `CGO_ENABLED=1`
environment variable in your `go build` step.

## Installation

```bash
go get github.com/uber/h3-go/v4
```

## Quickstart

```go
import "github.com/uber/h3-go/v4"

func ExampleLatLngToCell() {
 latLng := h3.NewLatLng(37.775938728915946, -122.41795063018799)
 resolution := 9 // between 0 (biggest cell) and 15 (smallest cell)

 cell := h3.LatLngToCell(latLng, resolution)

 fmt.Printf("%s", cell)
 // Output:
 // 8928308280fffff
}

```

# C API

## Notes

* `LatLng` returns `Lat` and `Lng` as degrees, instead of radians.
* H3 C API function prefixes of `get` have been dropped in support of Golang's
 `Getter` [naming style](https://go.dev/doc/effective_go#Getters).
* Convenience methods have been added to various types where that type was the
 main or only argument.

## Bindings

| C API | Go API |
|------------------------------|-----------------------------------------------------------|
| `latLngToCell` | `LatLngToCell`, `LatLng#Cell` |
| `cellToLatLng` | `CellToLatLng`, `Cell#LatLng` |
| `cellToBoundary` | `CellToBoundary`, `Cell#Boundary` |
| `gridDisk` | `GridDisk`, `Cell#GridDisk` |
| `gridDisksUnsafe` | `GridDisksUnsafe` |
| `gridDiskDistances` | `GridDiskDistances`, `Cell#GridDiskDistances` |
| `gridDiskDistancesSafe` | `GridDiskDistancesSafe`, `Cell#GridDiskDistancesSafe` |
| `gridDiskDistancesUnsafe` | `GridDiskDistancesUnsafe`, `Cell#GridDiskDistancesUnsafe` |
| `gridRing` | `GridRing`, `Cell#GridRing` |
| `gridRingUnsafe` | `GridRingUnsafe`, `Cell#GridRingUnsafe` |
| `polygonToCells` | `PolygonToCells`, `GeoPolygon#Cells` |
| `cellsToMultiPolygon` | `CellsToMultiPolygon` |
| `degsToRads` | `DegsToRads` |
| `radsToDegs` | `RadsToDegs` |
| `greatCircleDistance` | `GreatCircleDistance* (3/3)` |
| `getHexagonAreaAvg` | `HexagonAreaAvg* (3/3)` |
| `cellArea` | `CellArea* (3/3)` |
| `getHexagonEdgeLengthAvg` | `HexagonEdgeLengthAvg* (2/2)` |
| `exactEdgeLength` | `EdgeLength* (3/3)` |
| `getNumCells` | `NumCells` |
| `getRes0Cells` | `Res0Cells` |
| `getPentagons` | `Pentagons` |
| `getResolution` | `Resolution` |
| `getBaseCellNumber` | `BaseCellNumber`, `Cell#BaseCellNumber` |
| `stringToH3` | `IndexFromString`, `Cell#UnmarshalText` |
| `h3ToString` | `IndexToString`, `Cell#String`, `Cell#MarshalText` |
| `isValidCell` | `Cell#IsValid` |
| `cellToParent` | `Cell#Parent`, `Cell#ImmediateParent` |
| `cellToChildren` | `Cell#Children` `Cell#ImmediateChildren` |
| `cellToCenterChild` | `Cell#CenterChild` |
| `compactCells` | `CompactCells` |
| `uncompactCells` | `UncompactCells` |
| `isResClassIII` | `Cell#IsResClassIII` |
| `isPentagon` | `Cell#IsPentagon` |
| `getIcosahedronFaces` | `Cell#IcosahedronFaces` |
| `areNeighborCells` | `Cell#IsNeighbor` |
| `cellsToDirectedEdge` | `Cell#DirectedEdge` |
| `isValidDirectedEdge` | `DirectedEdge#IsValid` |
| `getDirectedEdgeOrigin` | `DirectedEdge#Origin` |
| `getDirectedEdgeDestination` | `DirectedEdge#Destination` |
| `directedEdgeToCells` | `DirectedEdge#Cells` |
| `originToDirectedEdges` | `Cell#DirectedEdges` |
| `directedEdgeToBoundary` | `DirectedEdge#Boundary` |
| `cellToVertex` | `CellToVertex` |
| `cellToVertexes` | `CellToVertexes` |
| `vertexToLatLng` | `VertexToLatLng` |
| `isValidVertex` | `IsValidVertex` |
| `gridDistance` | `GridDistance`, `Cell#GridDistance` |
| `gridPathCells` | `GridPath`, `Cell#GridPath` |
| `cellToLocalIj` | `CellToLocalIJ` |
| `localIjToCell` | `LocalIJToCell` |

## CGO

The H3 C source code and header files are copied into this project to optimize
for portability. `h3-go` can be imported into any Go project for any platform
that CGO supports.

# Contributing

Pull requests and Github issues are welcome. Please read our [contributing
guide](./CONTRIBUTING.md) for more information.

## Legal and Licensing

H3-Go is licensed under the [Apache 2.0 License](./LICENSE).

A simple Go-based server for map tiles stored in mbtiles format

mbtileserver

Library for reading, writing and working with OpenStreetMap data and APIs

# osm [![CI](https://github.com/paulmach/osm/workflows/CI/badge.svg)](https://github.com/paulmach/osm/actions?query=workflow%3ACI+event%3Apush) [![Go Report Card](https://goreportcard.com/badge/github.com/paulmach/osm)](https://goreportcard.com/report/github.com/paulmach/osm) [![Go Reference](https://pkg.go.dev/badge/github.com/paulmach/osm.svg)](https://pkg.go.dev/github.com/paulmach/osm)

This package is a general purpose library for reading, writing and working
with [OpenStreetMap](https://osm.org) data in Go (golang). It has the ability to:

-   read/write [OSM XML](https://wiki.openstreetmap.org/wiki/OSM_XML)
-   read/write [OSM JSON](https://wiki.openstreetmap.org/wiki/OSM_JSON),
    a format returned by the Overpass API.
-   efficiently parse [OSM PBF](https://wiki.openstreetmap.org/wiki/PBF_Format) data files available at
    [planet.osm.org](https://planet.osm.org/)

Made available by the package are the following types:

-   Node
-   Way
-   Relation
-   Changeset
-   Note
-   User

And the following “container” types:

-   OSM - container returned via API
-   Change - used by the replication API
-   Diff - corresponds to [Overpass Augmented Diffs](https://wiki.openstreetmap.org/wiki/Overpass_API/Augmented_Diffs)

## List of sub-package utilities

-   [`annotate`](annotate) - adds lon/lat, version, changeset and orientation data to way and relation members
-   [`osmapi`](osmapi) - supports all the v0.6 read/data endpoints
-   [`osmgeojson`](osmgeojson) - OSM to GeoJSON conversion compatible with [osmtogeojson](https://github.com/tyrasd/osmtogeojson)
-   [`osmpbf`](osmpbf) - stream processing of `*.osm.pbf` files
-   [`osmxml`](osmxml) - stream processing of `*.osm` xml files
-   [`replication`](replication) - fetch replication state and change files

## Concepts

This package refers to the core OSM data types as **Objects**. The Node, Way,
Relation, Changeset, Note and User types implement the `osm.Object` interface
and can be referenced using the `osm.ObjectID` type. As a result it is possible
to have a slice of `[]osm.Object` that contains nodes, changesets and users.

Individual versions of the core OSM Map Data types are referred to as **Elements**
and the set of versions for a give Node, Way or Relation is referred to as a
**Feature**. For example, an `osm.ElementID` could refer to "Node with id 10 and
version 3" and the `osm.FeatureID` would refer to "all versions of node with id 10."
Put another way, features represent a road and how it's changed over time and an
element is a specific version of that feature.

A number of helper methods are provided for dealing with features and elements.
The idea is to make it easy to work with a Way and its member nodes, for example.

## Scanning large data files

For small data it is possible to use the `encoding/xml` package in the
Go standard library to marshal/unmarshal the data. This is typically done using the
`osm.OSM` or `osm.Change` "container" structs.

For large data the package defines the `Scanner` interface implemented in both the [osmxml](osmxml)
and [osmpbf](osmpbf) sub-packages.

```go
type osm.Scanner interface {
	Scan() bool
	Object() osm.Object
	Err() error
	Close() error
}
```

This interface is designed to mimic the [bufio.Scanner](https://golang.org/pkg/bufio/#Scanner)
interface found in the Go standard library.

Example usage:

```go
f, err := os.Open("./delaware-latest.osm.pbf")
if err != nil {
	panic(err)
}
defer f.Close()

scanner := osmpbf.New(context.Background(), f, 3)
defer scanner.Close()

for scanner.Scan() {
	o := scanner.Object()
	// do something
}

scanErr := scanner.Err()
if scanErr != nil {
	panic(scanErr)
}
```

**Note:** Scanners are **not** safe for parallel use. One should feed the
objects into a channel and have workers read from that.

## Working with JSON

This library supports reading and writing [OSM JSON](https://wiki.openstreetmap.org/wiki/OSM_JSON).
This format is returned by the Overpass API and can be optionally returned by the
[OSM API](https://wiki.openstreetmap.org/wiki/API_v0.6#JSON_Format).

If performance is important, this library supports third party "encoding/json" replacements
such as [github.com/json-iterator/go](https://github.com/json-iterator/go).

They can be enabled with something like this:

```go
import (
  jsoniter "github.com/json-iterator/go"
  "github.com/paulmach/osm"
)

var c = jsoniter.Config{
  EscapeHTML:              true,
  SortMapKeys:             false,
  MarshalFloatWith6Digits: true,
}.Froze()

osm.CustomJSONMarshaler = c
osm.CustomJSONUnmarshaler = c
```

The above change can have dramatic performance implications, see the benchmarks below
on a large OSM Change object.

```
benchmark                            old ns/op     new ns/op     delta
BenchmarkChange_MarshalJSON-12       604496        461349        -23.68%
BenchmarkChange_UnmarshalJSON-12     1633834       1051630       -35.63%

benchmark                            old allocs    new allocs    delta
BenchmarkChange_MarshalJSON-12       1277          1081          -15.35%
BenchmarkChange_UnmarshalJSON-12     5133          8580          +67.15%

benchmark                            old bytes     new bytes     delta
BenchmarkChange_MarshalJSON-12       180583        162727        -9.89%
BenchmarkChange_UnmarshalJSON-12     287707        317723        +10.43%
```

## CGO and zlib

OSM PBF data comes in blocks, each block is zlib compressed. Decompressing this
data takes about 33% of the total read time. [DataDog/czlib](https://github.com/DataDog/czlib) is
used to speed this process.
See [osmpbf/README.md](osmpbf#using-cgoczlib-for-decompression) for more details.

As a result, a C compiler is necessary to install this module. On macOS this may require
installing pkg-config using something like `brew install pkg-config`

CGO can be disabled at build time using the `CGO_ENABLED` ENV variable.
For example, `CGO_ENABLED=0 go build`. The code will fallback to the stdlib implementation of zlib.


# pbf
OpenStreetMap PBF golang encoder/decoder

[![Build Status](https://github.com/maguro/pbf/actions/workflows/ci.yml/badge.svg)](https://github.com/maguro/pbf/actions/workflows/ci.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/maguro/pbf)](https://goreportcard.com/report/github.com/maguro/pbf) 
[![Documentation](https://godoc.org/github.com/maguro/pbf?status.svg)](http://godoc.org/github.com/maguro/pbf)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=maguro_pbf&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=maguro_pbf)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

A golang based OpenStreetMap PBF encoder/decoder with a handy command line utility, `pbf`.

## Development

This repository includes a Codex-friendly workflow:

    $ make fmt
    $ make test
    $ make test-race
    $ make test-integration
    $ make lint
    $ make verify

Project-specific agent guidance is documented in `AGENTS.md`.
The Makefile uses a project-local `.cache/` directory for Go and lint caches to
keep local and sandboxed runs reproducible; `.cache/` is intentionally ignored
by git.

## Go Version Support

- Supported window: the Go release from approximately one year ago through latest stable.
- As of February 26, 2026, CI-verified versions are `1.24.x`, `1.25.x`, and `1.26.x`.
- `go.mod` currently declares `go 1.23`; this is a compatibility floor, while active support is the CI-verified window above.
- Bug reports should include `go version` output so compatibility issues can be reproduced quickly.

## pbf Command Line Utility

The `pbf` CLI can be installed using the `go install` command:

    $ go install m4o.io/pbf/v2/cmd/pbf

### pbf info

The `pbf` CLI can be used to obtain summary and extended information about an
OpenStreetMap PBF file:

    $ pbf info -i testdata/greater-london.osm.pbf
    BoundingBox: [(51.69344, -0.511482) (51.28554, 0.335437)]
    RequiredFeatures: OsmSchema-V0.6, DenseNodes
    OptionalFeatures: 
    WritingProgram: Osmium (http://wiki.openstreetmap.org/wiki/Osmium)
    Source: 
    OsmosisReplicationTimestamp: 2014-03-24T21:55:02Z
    OsmosisReplicationSequenceNumber: 0
    OsmosisReplicationBaseURL: 

JSON output can be obtained by adding the `-j` option:

    $ pbf info -j -i testdata/greater-london.osm.pbf | jq
    {
      "BoundingBox": {
        "Left": -0.511482,
        "Right": 0.33543700000000004,
        "Top": 51.69344,
        "Bottom": 51.285540000000005
      },
      "RequiredFeatures": [
        "OsmSchema-V0.6",
        "DenseNodes"
      ],
      "OptionalFeatures": null,
      "WritingProgram": "Osmium (http://wiki.openstreetmap.org/wiki/Osmium)",
      "Source": "",
      "OsmosisReplicationTimestamp": "2014-03-24T14:55:02-07:00",
      "OsmosisReplicationSequenceNumber": 0,
      "OsmosisReplicationBaseURL": ""
    }

Here, [jq](https://stedolan.github.io/jq/) is used to pretty print the compact
JSON.

Extended information about the OpenStreetMap PBF file can be obtained
by using the `-e` option.  This causes the entire file to be scanned, which can
take a very long time; a progress bar is displayed on `stderr`.

    $ pbf info -e -i testdata/greater-london.osm.pbf
    BoundingBox: [(51.69344, -0.511482) (51.28554, 0.335437)]
    RequiredFeatures: OsmSchema-V0.6, DenseNodes
    OptionalFeatures: 
    WritingProgram: Osmium (http://wiki.openstreetmap.org/wiki/Osmium)
    Source: 
    OsmosisReplicationTimestamp: 2014-03-24T21:55:02Z
    OsmosisReplicationSequenceNumber: 0
    OsmosisReplicationBaseURL: 
    NodeCount: 2,729,006
    WayCount: 459,055
    RelationCount: 12,833

Finally, `pbf` can read an OpenStreetMap PBF file from `stdin`:

    $ cat testdata/greater-london.osm.pbf | pbf info -e

In this case, a progress bar is not displayed since there is no way to know,
a priori, what the size of the PBF file is.


# S2 geometry library in Go

[![Go Reference](https://pkg.go.dev/badge/github.com/golang/geo.svg)](https://pkg.go.dev/github.com/golang/geo) [![Go Build and Test](https://github.com/golang/geo/actions/workflows/go.yml/badge.svg)](https://github.com/golang/geo/actions/workflows/go.yml) [![CodeQL](https://github.com/golang/geo/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/golang/geo/actions/workflows/github-code-scanning/codeql) [![golangci-lint](https://github.com/golang/geo/actions/workflows/golangci-lint.yml/badge.svg)](https://github.com/golang/geo/actions/workflows/golangci-lint.yml) [![OpenSSF Scorecard](https://img.shields.io/ossf-scorecard/github.com/golang/geo?label=OpenSSF%20Scorecard&style=flat)](https://scorecard.dev/viewer/?uri=github.com/golang/geo)

S2 is a library for spherical geometry that aims to have the same robustness,
flexibility, and performance as the best planar geometry libraries.

This is a library for manipulating geometric shapes. Unlike many geometry
libraries, S2 is primarily designed to work with *spherical geometry*, i.e.,
shapes drawn on a sphere rather than on a planar 2D map. (In fact, the name S2
is derived from the mathematical notation for the unit sphere *S²*.) This makes
it especially suitable for working with geographic data.

More details about S2 in general are available on the S2 Geometry Website
[s2geometry.io](https://s2geometry.io/).

## Scope

The library provides the following:

*   Representations of angles, intervals, latitude-longitude points, unit
    vectors, and so on, and various operations on these types.

*   Geometric shapes over the unit sphere, such as spherical caps ("discs"),
    latitude-longitude rectangles, polylines, and polygons. These are
    collectively known as "regions".

*   A hierarchical decomposition of the sphere into regions called "cells". The
    hierarchy starts with the six faces of a projected cube and recursively
    subdivides them in a quadtree-like fashion.

*   Robust constructive operations (e.g., union) and boolean predicates (e.g.,
    containment) for arbitrary collections of points, polylines, and polygons.

*   Fast in-memory indexing of collections of points, polylines, and polygons.

*   Algorithms for measuring distances and finding nearby objects.

*   Robust algorithms for snapping and simplifying geometry (with accuracy and
    topology guarantees).

*   A collection of efficient yet exact mathematical predicates for testing
    relationships among geometric objects.

*   Support for spatial indexing, including the ability to approximate regions
    as collections of discrete "S2 cells". This feature makes it easy to build
    large distributed spatial indexes.

*   Translate angles and steradians into distances and areas using earth's radius
    through the [`earth`](https://pkg.go.dev/github.com/golang/geo/earth) package.

On the other hand, the following are outside the scope of S2:

*   Planar geometry.

*   Conversions to/from common GIS formats.

### Robustness

What do we mean by "robust"?

In the S2 library, the core operations are designed to be 100% robust. This
means that each operation makes strict mathematical guarantees about its output,
and is implemented in such a way that it meets those guarantees for all possible
valid inputs. For example, if you compute the intersection of two polygons, not
only is the output guaranteed to be topologically correct (up to the creation of
degeneracies), but it is also guaranteed that the boundary of the output stays
within a user-specified tolerance of true, mathematically exact result.

Robustness is very important when building higher-level algorithms, since
unexpected results from low-level operations can be very difficult to handle. S2
achieves this goal using a combination of techniques from computational
geometry, including *conservative error bounds*, *exact geometric predicates*,
and *snap rounding*.

The implementation attempts to be precise both in terms of mathematical
definitions (e.g. whether regions include their boundaries, and how degeneracies
are handled) and numerical accuracy (e.g. minimizing cancellation error).

Note that the intent of this library is to represent geometry as a mathematical
abstraction. For example, although the unit sphere is obviously a useful
approximation for the Earth's surface, functions that are specifically related
to geography are not part of the core library (e.g. easting/northing
conversions, ellipsoid approximations, geodetic vs. geocentric coordinates,
etc).

For an analogous library in C++, see https://github.com/google/s2geometry, in
Java, see https://github.com/google/s2-geometry-library-java, and Python, see
https://github.com/google/s2geometry/tree/master/src/python

# Status of the Go Library

This library is principally a port of the
[C++ S2 library](https://github.com/google/s2geometry), adapting to Go idioms
where it makes sense. We detail the progress of this port below relative to that
C++ library.

Legend:

*   ✅ - Feature Complete
*   🟡 - Mostly Complete
*   ❌ - Not available

## [ℝ¹](https://pkg.go.dev/github.com/golang/geo/r1) - One-dimensional Cartesian coordinates

C++ Type   | Go
:--------- | ---
R1Interval | ✅

## [ℝ²](https://pkg.go.dev/github.com/golang/geo/r2) - Two-dimensional Cartesian coordinates

C++ Type | Go
:------- | ---
R2Point  | ✅
R2Rect   | ✅

## [ℝ³](https://pkg.go.dev/github.com/golang/geo/r3) - Three-dimensional Cartesian coordinates

C++ Type      | Go
:------------ | ---
R3Vector      | ✅
R3ExactVector | ✅
Matrix3x3     | ✅

## [S¹](https://pkg.go.dev/github.com/golang/geo/s1) - Circular Geometry

C++ Type     | Go
:----------- | ---
S1Angle      | ✅
S1ChordAngle | ✅
S1Interval   | ✅

## [S²](https://pkg.go.dev/github.com/golang/geo/s2) - Spherical Geometry

### Basic Types

C++ Type             | Go
:------------------- | ---
S2Cap                | ✅
S2Cell               | ✅
S2CellId             | ✅
S2CellIdVector       | ❌
S2CellIndex          | 🟡
S2CellUnion          | ✅
S2Coords             | ✅
S2DensityTree        | ❌
S2DistanceTarget     | ✅
S2EdgeVector         | ✅
S2LatLng             | ✅
S2LatLngRect         | ✅
S2LaxLoop            | 🟡
S2LaxPolygon         | 🟡
S2LaxPolyline        | 🟡
S2Loop               | ✅
S2PaddedCell         | ✅
S2Point              | ✅
S2PointIndex         | ❌
S2PointSpan          | ❌
S2PointRegion        | ❌
S2PointVector        | ✅
S2Polygon            | 🟡
S2Polyline           | ✅
S2R2Rect             | ❌
S2Region             | ✅
S2RegionCoverer      | ✅
S2RegionIntersection | ❌
S2RegionUnion        | ✅
S2Shape              | ✅
S2ShapeIndex         | ✅
S2ShapeIndexRegion   | ❌
EncodedLaxPolygon    | ❌
EncodedLaxPolyline   | ❌
EncodedShapeIndex    | ❌
EncodedStringVector  | ❌
EncodedUintVector    | ❌
IdSetLexicon         | ❌
ValueSetLexicon      | ❌
SequenceLexicon      | ❌
LaxClosedPolyline    | ❌
VertexIDLaxLoop      | ❌

### Query Types

C++ Type             | Go
:------------------- | ---
S2ChainInterpolation | ❌
S2ClosestCell        | ❌
S2FurthestCell       | ❌
S2ClosestEdge        | ✅
S2FurthestEdge       | ✅
S2ClosestPoint       | ❌
S2FurthestPoint      | ❌
S2ContainsPoint      | ✅
S2ContainsVertex     | ✅
S2ConvexHull         | ✅
S2CrossingEdge       | ✅
S2HausdorffDistance  | ❌
S2ShapeNesting       | ❌
S2ValidationQuery    | ❌

### Supporting Types

C++ Type                         | Go
:------------------------------- | ---
S2BooleanOperation               | ❌
S2BufferOperation                | ❌
S2Builder                        | ❌
S2BuilderGraph                   | ❌
S2BuilderLayer                   | ❌
S2BuilderUtil_\*                 | ❌
S2CellIterator                   | ❌
S2CellIteratorJoin               | ❌
S2CellRangeIterator              | ❌
S2Coder                          | ❌
S2Earth                          | ✅
S2EdgeClipping                   | ✅
S2EdgeCrosser                    | ✅
S2EdgeCrossings                  | ✅
S2EdgeDistances                  | ✅
S2EdgeTessellator                | ✅
S2Fractal                        | ❌
S2LoopMeasures                   | ❌
S2Measures                       | ✅
S2MemoryTracker                  | ❌
S2Metrics                        | ❌
S2PointUtil                      | 🟡
S2PointCompression               | 🟡
S2PolygonBuilder                 | ❌
S2PolylineAlignment              | ❌
S2PolylineMeasures               | ✅
S2PolylineSimplifier             | ❌
S2Predicates                     | ✅
S2Projections                    | ❌
S2Random                         | ❌
S2RectBounder                    | ❌
S2RegionSharder                  | ❌
S2RegionTermIndexer              | ❌
S2ShapeIndexBufferedRegion       | ❌
S2ShapeIndexMeasures             | ❌
S2ShapeIndexUtil\*               | 🟡
S2ShapeMeasures                  | ❌
S2ShapeUtil\*                    | 🟡
S2Stats                          | ❌
S2Testing                        | ✅
S2TextFormat                     | ✅
S2WedgeRelations                 | ✅
S2WindingOperation               | ❌


### Encode/Decode

Encoding and decoding of S2 types is fully implemented and interoperable with
C++ and Java.


## Disclaimer

This is not an official Google product.


S2 geometry

simplesfeatures is a 2D geometry library that provides Go types that model geometries, as well as algorithms that operate on them

# Simple Features

[![Build Status](https://github.com/peterstace/simplefeatures/workflows/build/badge.svg)](https://github.com/peterstace/simplefeatures/actions)
[![Go Report
Card](https://goreportcard.com/badge/github.com/peterstace/simplefeatures)](https://goreportcard.com/report/github.com/peterstace/simplefeatures)
[![Coverage
Status](https://coveralls.io/repos/github/peterstace/simplefeatures/badge.svg?branch=master)](https://coveralls.io/github/peterstace/simplefeatures?branch=master)

Simple Features is a 2D geometry library that provides Go types that model
geometries, as well as algorithms that operate on them.

It's a pure Go Implementation of the OpenGIS Consortium's Simple
Feature Access Specification (which can be found
[here](http://www.opengeospatial.org/standards/sfa)). This is the same
specification that [GEOS](https://trac.osgeo.org/geos),
[JTS](https://locationtech.github.io/jts/), and [PostGIS](https://postgis.net/)
implement, so the Simple Features API will be familiar to developers who have
used those libraries before.

**Table of Contents:**
- [Native Go Packages](#native-go-packages)
  - [Geom](#geom)
  - [Carto](#carto)
  - [R-Tree](#r-tree)
- [C-Wrapper Packages](#c-wrapper-packages)
  - [GEOS](#geos)
  - [PROJ](#proj)

## Native Go Packages

The Simple Features library contains several packages that are implemented
purely in Go, and do not require CGO to use. These are `geom`, `carto`, and
`rtree`.

### Geom

[Package
`geom`](https://pkg.go.dev/github.com/peterstace/simplefeatures/geom?tab=doc)
provides types (`Point`, `MultiPoint`, `LineString`, `MultiLineString`,
`Polygon`, `MultiPolygon`, `GeometryCollection`) representing each geometry, as
well as algorithms that operate with/on them.

The following operations are supported:

- **Serialisation:** WKT, WKB, GeoJSON, TWKB.
- **Overlay operations:** union, intersection, difference, symmetric difference, unary union.
- **Relate operations:** DE-9IM matrix, equals, intersects, disjoint, contains, covered by, covers, overlaps, touches, within, crosses.
- **Measurements:** area, length, distance.
- **Analysis:** centroid, convex hull, envelope, point on surface, boundary, minimum area bounding rectangle, minimum width bounding rectangle.
- **Transformations:** simplify, densify, snap to grid, reverse, force clockwise, force counter-clockwise, affine transformation.
- **Buffer:** buffer with configurable end cap styles, join styles, and single-sided mode.
- **Prepared geometries:** preprocess a geometry for efficient repeated spatial predicate evaluation.
- **Comparison:** exact equals.
- **Linear Interpolation:** interpolate point, interpolate evenly spaced points.
- **Properties:** is simple, is empty, dimension, is clockwise, is counter-clockwise, validate.
- **Envelope operations:** intersects, contains, covers, distance, expand to include, center, width, height, area, bounding diagonal.

The overlay, relate, buffer, and prepared geometry operations are powered by a Go port of
[JTS](https://locationtech.github.io/jts/). This means that it's using robust
and battle tested algorithms that are common to JTS and its derivatives (such as
GEOS).

### Carto

[Package
`carto`](https://pkg.go.dev/github.com/peterstace/simplefeatures/carto?tab=doc)
provides cartographic map projections and related functionality. It can be used
as a lite replacement for PROJ for simple cartographic projections.

The following projections are supported:

- **Conic:** Lambert conformal conic, Albers equal area conic, equidistant
  conic.
- **Cylindrical:** equirectangular, web mercator, Lambert cylindrical equal
  area.
- **Azimuthal:** orthographic, azimuthal equidistant.
- **Pseudocylindrical:** sinusoidal.
- **UTM:** All 60 UTM projections.

### R-Tree

[Package
`rtree`](https://pkg.go.dev/github.com/peterstace/simplefeatures/rtree?tab=doc)
provides an in-memory R-Tree data structure, which can be used for fast and
efficient spatial searches.

## C-Wrapper Packages

The Simple Features library also contains several packages that depend on C
libraries (via CGO). They are segregated into separate Go packages so users who
don't need that functionality aren't required to install the relevant C
dependencies.

### GEOS

[Package
`geos`](https://pkg.go.dev/github.com/peterstace/simplefeatures/geos?tab=doc)
is a thin CGO wrapper around the [GEOS](https://www.osgeo.org/projects/geos/)
library. It provides access to GEOS functionality that has not yet been
implemented in the `geom` package natively in Go.

To install the GEOS C library:

```sh
# Debian/Ubuntu
apt-get install libgeos-dev

# Alpine
apk add geos-dev

# macOS
brew install geos
```

### PROJ

[Package
`proj`](https://pkg.go.dev/github.com/peterstace/simplefeatures/proj?tab=doc)
is a thin CGO wrapper around the [PROJ](https://proj.org/) library. It provides
an exhaustive set of cartographic projections and coordinate transformations.

To install the PROJ C library:

```sh
# Debian/Ubuntu
apt-get install libproj-dev

# Alpine
apk add proj-dev

# macOS
brew install proj
```


simplefeatures

Geolocation DB with spatial index and realtime geofencing

<picture>
 <source media="(prefers-color-scheme: dark)" srcset="/.github/images/logo-dark.svg">
 <source media="(prefers-color-scheme: light)" srcset="/.github/images/logo-light.svg">
 <img alt="Tile38" src="/.github/images/logo-light.svg" width="284">
</picture>


<a href="https://tile38.com/slack/"><img src="https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=fff" alt="Slack"></a>
<a href="https://discord.gg/esq8ESgzms"><img src="https://img.shields.io/badge/Discord-%235865F2.svg?&logo=discord&logoColor=white" alt="Discord"></a>





Tile38 is an open source (MIT licensed), in-memory geolocation data store, spatial index, and realtime geofencing server.
It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON. 


This README is quick start document. You can find detailed documentation at <a href="https://tile38.com">https://tile38.com</a>. 
<a href="#searching"><img src="/.github/images/search-nearby.png" alt="Nearby" border="0" width="120" height="120"></a>
<a href="#searching"><img src="/.github/images/search-within.png" alt="Within" border="0" width="120" height="120"></a>
<a href="#searching"><img src="/.github/images/search-intersects.png" alt="Intersects" border="0" width="120" height="120"></a>
<a href="https://tile38.com/topics/geofencing"><img src="/.github/images/geofence.gif" alt="Geofencing" border="0" width="120" height="120"></a>
<a href="https://tile38.com/topics/roaming-geofences"><img src="/.github/images/roaming.gif" alt="Roaming Geofences" border="0" width="120" height="120"></a>


## Features

- Spatial index with [search](#searching) methods such as Nearby, Within, and Intersects.
- Realtime [geofencing](#geofencing) through [webhooks](https://tile38.com/commands/sethook) or [pub/sub channels](#pubsub-channels).
- Object types of [lat/lon](#latlon-point), [bbox](#bounding-box), [Geohash](#geohash), [GeoJSON](#geojson), [QuadKey](#quadkey), and [XYZ tile](#xyz-tile).
- Support for lots of [Clients Libraries](#tile38-client-libraries) written in many different languages.
- Variety of protocols, including [http](#http) (curl), [websockets](#websockets), [telnet](#telnet), and the [Redis RESP](https://redis.io/topics/protocol).
- Server responses are [RESP](https://redis.io/topics/protocol) or [JSON](https://www.json.org).
- Full [command line interface](#cli).
- Leader / follower [replication](#replication).
- In-memory database that persists on disk.

## Components
- tile38-server: The server
- tile38-cli: Command line interface tool
- tile38-benchmark: Server benchmark tool

## Getting Started

### Getting Tile38

Perhaps the easiest way to get the latest Tile38 is to use one of the pre-built release binaries which are available for OSX, Linux, FreeBSD, and Windows. Instructions for using these binaries are on the GitHub [releases page](https://github.com/tidwall/tile38/releases).

### Docker 

To run the latest stable version of Tile38:

```
docker pull tile38/tile38
docker run -p 9851:9851 tile38/tile38
```

Visit the [Tile38 hub page](https://hub.docker.com/r/tile38/tile38/) for more information.

### Homebrew (macOS)

Install Tile38 using [Homebrew](https://brew.sh/)

```sh
brew install tile38
tile38-server
```

### Building Tile38 

Tile38 can be compiled and used on Linux, OSX, Windows, FreeBSD, and probably others since the codebase is 100% Go. We support both 32 bit and 64 bit systems. [Go](https://golang.org/dl/) must be installed on the build machine.

To build everything simply:
```
$ make
```

To test:
```
$ make test
```

### Running 
For command line options invoke:
```
$ ./tile38-server -h
```

To run a single server:

```
$ ./tile38-server

# The tile38 shell connects to localhost:9851
$ ./tile38-cli
> help
```

#### Prometheus Metrics
Tile38 can natively export Prometheus metrics by setting the `--metrics-addr` command line flag (disabled by default). This example exposes the HTTP metrics server on port 4321:
```
# start server and enable Prometheus metrics, listen on local interface only
./tile38-server --metrics-addr=127.0.0.1:4321

# access metrics
curl http://127.0.0.1:4321/metrics
```
If you need to access the `/metrics` endpoint from a different host you'll have to set the flag accordingly, e.g. set it to `0.0.0.0:<<port>>` to listen on all interfaces.

Use the [redis_exporter](https://github.com/oliver006/redis_exporter) for more advanced use cases like extracting key values or running a lua script.


## <a name="cli"></a>Playing with Tile38

Basic operations:
```
$ ./tile38-cli

# add a couple of points named 'truck1' and 'truck2' to a collection named 'fleet'.
> set fleet truck1 point 33.5123 -112.2693 # on the Loop 101 in Phoenix
> set fleet truck2 point 33.4626 -112.1695 # on the I-10 in Phoenix

# search the 'fleet' collection.
> scan fleet # returns both trucks in 'fleet'
> nearby fleet point 33.462 -112.268 6000 # search 6 kilometers around a point. returns one truck.

# key value operations
> get fleet truck1 # returns 'truck1'
> del fleet truck2 # deletes 'truck2'
> drop fleet # removes all 
```

Tile38 has a ton of [great commands](https://tile38.com/commands).

## Fields
Fields are extra data that belongs to an object. A field is always a double precision floating point. There is no limit to the number of fields that an object can have. 

To set a field when setting an object:
```
> set fleet truck1 field speed 90 point 33.5123 -112.2693 
> set fleet truck1 field speed 90 field age 21 point 33.5123 -112.2693
```

To set a field when an object already exists:
```
> fset fleet truck1 speed 90
```

To get a field when an object already exists:
```
> fget fleet truck1 speed
```

## Searching

Tile38 has support to search for objects and points that are within or intersects other objects. All object types can be searched including Polygons, MultiPolygons, GeometryCollections, etc.

<img src="/.github/images/search-within.png" width="200" height="200" border="0" alt="Search Within" align="left">

#### Within 
WITHIN searches a collection for objects that are fully contained inside a specified bounding area.
 

<img src="/.github/images/search-intersects.png" width="200" height="200" border="0" alt="Search Intersects" align="left">

#### Intersects
INTERSECTS searches a collection for objects that intersect a specified bounding area.
 

<img src="/.github/images/search-nearby.png" width="200" height="200" border="0" alt="Search Nearby" align="left">

#### Nearby
NEARBY searches a collection for objects that intersect a specified radius.
 

### Search options
**WHERE** - This option allows for filtering out results based on [field](#fields) values. For example ```nearby fleet where speed 70 +inf point 33.462 -112.268 6000``` will return only the objects in the 'fleet' collection that are within the 6 km radius **and** have a field named `speed` that is greater than `70`. Multiple WHEREs are concatenated as **and** clauses. ```WHERE speed 70 +inf WHERE age -inf 24``` would be interpreted as *speed is over 70 and age is less than 24.* The default value for a field is always `0`. Thus if you do a WHERE on the field `speed` and an object does not have that field set, the server will pretend that the object does and that the value is Zero. WHERE expressions support the `=~` operator for regex matching. It uses Go's re2 regular expression engine to match string values in fields or GeoJSON properties within objects. For example, `WHERE properties.name =~ 'truck.*'` filters objects where the 'name' property matches the pattern, and `WHERE field_name =~ 'value.*'` works similarly for fields.

**MATCH** - MATCH is similar to WHERE except that it works on the object id instead of fields. ```nearby fleet match truck* point 33.462 -112.268 6000``` will return only the objects in the 'fleet' collection that are within the 6 km radius **and** have an object id that starts with `truck`. There can be multiple MATCH options in a single search. The MATCH value is a simple [glob pattern](https://en.wikipedia.org/wiki/Glob_(programming)).

**CURSOR** - CURSOR is used to iterate though many objects from the search results. An iteration begins when the CURSOR is set to Zero or not included with the request, and completes when the cursor returned by the server is Zero.

**NOFIELDS** - NOFIELDS tells the server that you do not want field values returned with the search results.

**LIMIT** - LIMIT can be used to limit the number of objects returned for a single search request.


## Geofencing

<img src="/.github/images/geofence.gif" width="200" height="200" border="0" alt="Geofence animation" align="left">
A <a href="https://en.wikipedia.org/wiki/Geo-fence">geofence</a> is a virtual boundary that can detect when an object enters or exits the area. This boundary can be a radius, bounding box, or a polygon. Tile38 can turn any standard search into a geofence monitor by adding the FENCE keyword to the search. 

*Tile38 also allows for [Webhooks](https://tile38.com/commands/sethook) to be assigned to Geofences.*

 

A simple example:
```
> nearby fleet fence point 33.462 -112.268 6000
```
This command opens a geofence that monitors the 'fleet' collection. The server will respond with:
```
{"ok":true,"live":true}
```
And the connection will be kept open. If any object enters or exits the 6 km radius around `33.462,-112.268` the server will respond in realtime with a message such as:

```
{"command":"set","detect":"enter","id":"truck02","object":{"type":"Point","coordinates":[-112.2695,33.4626]}}
```

The server will notify the client if the `command` is `del | set | drop`. 

- `del` notifies the client that an object has been deleted from the collection that is being fenced.
- `drop` notifies the client that the entire collection is dropped.
- `set` notifies the client that an object has been added or updated, and when it's position is detected by the fence.

The `detect` may be one of the following values.

- `inside` is when an object is inside the specified area.
- `outside` is when an object is outside the specified area.
- `enter` is when an object that **was not** previously in the fence has entered the area.
- `exit` is when an object that **was** previously in the fence has exited the area.
- `cross` is when an object that **was not** previously in the fence has entered **and** exited the area.

These can be used when establishing a geofence, to pre-filter responses. For instance, to limit responses to `enter` and `exit` detections:

```
> nearby fleet fence detect enter,exit point 33.462 -112.268 6000
```

### Pub/sub channels

Tile38 supports delivering geofence notifications over pub/sub channels. 

To create a static geofence that sends notifications when a bus is within 200 meters of a point and sends to the `busstop` channel:

```
> setchan busstop nearby buses fence point 33.5123 -112.2693 200
```

Subscribe on the `busstop` channel:

```
> subscribe busstop
```

## Object types

All object types except for XYZ Tiles and QuadKeys can be stored in a collection. XYZ Tiles and QuadKeys are reserved for the SEARCH keyword only.

#### Lat/lon point
The most basic object type is a point that is composed of a latitude and a longitude. There is an optional `z` member that may be used for auxiliary data such as elevation or a timestamp.
```
set fleet truck1 point 33.5123 -112.2693 # plain lat/lon
set fleet truck1 point 33.5123 -112.2693 225 # lat/lon with z member
```

#### Bounding box
A bounding box consists of two points. The first being the southwestern most point and the second is the northeastern most point.
```
set fleet truck1 bounds 30 -110 40 -100
```
#### Geohash
A [geohash](https://en.wikipedia.org/wiki/Geohash) is a string representation of a point. With the length of the string indicating the precision of the point. 
```
set fleet truck1 hash 9tbnthxzr # this would be equivalent to 'point 33.5123 -112.2693'
```

#### GeoJSON
[GeoJSON](https://tools.ietf.org/html/rfc7946) is an industry standard format for representing a variety of object types including a point, multipoint, linestring, multilinestring, polygon, multipolygon, geometrycollection, feature, and featurecollection.

* All ignored members will not persist.

**Important to note that all coordinates are in Longitude, Latitude order.**

```
set city tempe object {"type":"Polygon","coordinates":[[[0,0],[10,10],[10,0],[0,0]]]}
```

#### XYZ Tile
An XYZ tile is rectangle bounding area on earth that is represented by an X, Y coordinate and a Z (zoom) level.
Check out [maptiler.org](http://www.maptiler.org/google-maps-coordinates-tile-bounds-projection/) for an interactive example.

#### QuadKey
A QuadKey used the same coordinate system as an XYZ tile except that the string representation is a string characters composed of 0, 1, 2, or 3. For a detailed explanation checkout [The Bing Maps Tile System](https://msdn.microsoft.com/en-us/library/bb259689.aspx).

## Network protocols

It's recommended to use a [client library](#tile38-client-libraries) or the [Tile38 CLI](#running), but there are times when only HTTP is available or when you need to test from a remote terminal. In those cases we provide an HTTP and telnet options.

#### HTTP
One of the simplest ways to call a tile38 command is to use HTTP. From the command line you can use [curl](https://curl.haxx.se/). For example:

```
# call with request in the body
curl --data "set fleet truck3 point 33.4762 -112.10923" localhost:9851

# call with request in the url path
curl localhost:9851/set+fleet+truck3+point+33.4762+-112.10923
```

#### Websockets
Websockets can be used when you need to Geofence and keep the connection alive. It works just like the HTTP example above, with the exception that the connection stays alive and the data is sent from the server as text websocket messages.

#### Telnet
There is the option to use a plain telnet connection. The default output through telnet is [RESP](https://redis.io/topics/protocol).

```
telnet localhost 9851
set fleet truck3 point 33.4762 -112.10923
+OK

```

The server will respond in [JSON](https://json.org) or [RESP](https://redis.io/topics/protocol) depending on which protocol is used when initiating the first command.

- HTTP and Websockets use JSON. 
- Telnet and RESP clients use RESP.

## Tile38 Client Libraries

The following clients are built specifically for Tile38. 
Clients that support most Tile38 features are marked with a ⭐️.

- ⭐️ Go: [xjem/t38c](https://github.com/xjem/t38c)
- ⭐️ Node.js: [node-tile38](https://github.com/phulst/node-tile38) ([example code](https://github.com/tidwall/tile38/wiki/Node.js-example-(node-tile38)))
- ⭐️ Python: [pyle38](https://github.com/iwpnd/pyle38)
- ⭐️ TypeScript: [tile38-ts](https://github.com/iwpnd/tile38-ts)
- Go: [cjkreklow/t38c](https://github.com/cjkreklow/t38c)
- Python: [pytile38](https://github.com/mitghi/pytile38)
- Rust: [nazar](https://github.com/younisshah/nazar)
- Swift: [Talon](https://github.com/mikekinney/Talon)
- Java: [tile38-client-java](https://github.com/jamshidrostami/tile38-client-java)
- Java: [tile38-client](https://github.com/HkMoyun/tile38-client)

## Redis Client Libraries

Tile38 uses the [Redis RESP](https://redis.io/topics/protocol) protocol natively. 
Therefore most clients that support basic Redis commands will also support Tile38.

- C: [hiredis](https://github.com/redis/hiredis)
- C#: [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis)
- C++: [redox](https://github.com/hmartiro/redox)
- Clojure: [carmine](https://github.com/ptaoussanis/carmine)
- Common Lisp: [CL-Redis](https://github.com/vseloved/cl-redis)
- Erlang: [Eredis](https://github.com/wooga/eredis)
- Go: [go-redis](https://github.com/go-redis/redis) ([example code](https://github.com/tidwall/tile38/wiki/Go-example-(go-redis)))
- Go: [redigo](https://github.com/gomodule/redigo) ([example code](https://github.com/tidwall/tile38/wiki/Go-example-(redigo)))
- Haskell: [hedis](https://github.com/informatikr/hedis)
- Java: [lettuce](https://github.com/mp911de/lettuce) ([example code](https://github.com/tidwall/tile38/wiki/Java-example-(lettuce)))
- Node.js: [node_redis](https://github.com/NodeRedis/node_redis) ([example code](https://github.com/tidwall/tile38/wiki/Node.js-example-(node-redis)))
- Perl: [perl-redis](https://github.com/PerlRedis/perl-redis)
- PHP: [tinyredisclient](https://github.com/ptrofimov/tinyredisclient) ([example code](https://github.com/tidwall/tile38/wiki/PHP-example-(tinyredisclient)))
- PHP: [phpredis](https://github.com/phpredis/phpredis)
- Python: [redis-py](https://github.com/andymccurdy/redis-py) ([example code](https://github.com/tidwall/tile38/wiki/Python-example))
- Ruby: [redic](https://github.com/amakawa/redic) ([example code](https://github.com/tidwall/tile38/wiki/Ruby-example-(redic)))
- Ruby: [redis-rb](https://github.com/redis/redis-rb) ([example code](https://github.com/tidwall/tile38/wiki/Ruby-example-(redis-rb)))
- Rust: [redis-rs](https://github.com/mitsuhiko/redis-rs)
- Scala: [scala-redis](https://github.com/debasishg/scala-redis)
- Swift: [Redbird](https://github.com/czechboy0/Redbird)

## Contact

Josh Baker [@tidwall](https://twitter.com/tidwall)

## License

Tile38 source code is available under the MIT [License](/LICENSE).

Tile38

Detects image borders and converts to GeoJSON for GIS operations

# Borders

[![Go Reference](https://pkg.go.dev/badge/github.com/kpfaulkner/borders.svg)](https://pkg.go.dev/github.com/kpfaulkner/borders)
[![Go Report Card](https://goreportcard.com/badge/github.com/kpfaulkner/borders)](https://goreportcard.com/report/github.com/kpfaulkner/borders)
[![Go Coverage](https://github.com/kpfaulkner/borders/wiki/coverage.svg)](https://raw.githack.com/wiki/kpfaulkner/borders/coverage.html)
[![Go](https://github.com/kpfaulkner/borders/actions/workflows/ci.yaml/badge.svg)](https://github.com/kpfaulkner/borders/actions/workflows/ci.yaml)

This is an implementation of the Suzuki + Abe "Topological Structural Analysis of Digitized Binary Images by Border Following"
( http://pdf.xuebalib.com:1262/xuebalib.com.17233.pdf )

This implementation is based off the original paper as well as being inspired by other papers/implementations/ideas from across the web.

## Description

Borders generates a tree of contours/borders which are generated from a monochrome bitmap. The bitmap needs to be either black/0 for background and white/1 for content to be scanned for borders.
The result is a tree of borders due to borders can contain inner borders (holes), which can in turn contain other borders etc.


## Usage

Easiest approach is to have a black and white png file and execute:

To generate contours from one file and save to another:
```
img,_ := border.LoadImage("test.png")

// contour is root node
contour := border.FindContours(img)   

// this will save contours in contour.png
border.SaveContourSliceImage("contour.png", contour, img.Width, img.Height, false, 0) 
```

To generate a geometry of the contours from an image file:
```
	img, _ := border.LoadImage("someimage.png", 1, 1)
	cont, _ := border.FindContours(img)
	
	// create a slippy map converter so we can generate a multipolygon that has the latitude/longitude
	// geojson.
	// This means that we need to know the slippy X/Y coords of the top left corner of the map
	slippyX := 1891519.0
	slippyY := 1285047.0
	slippyConverter := converters.NewSlippyToLatLongConverter(slippyX, slippyY, scale)

	// tolerance of 0 means get ConvertContourToPolygon to calculate it
	poly, _ := converters.ConvertContourToPolygon(cont, scale, true, 0, 0, true, slippyConverter)
	
	j, _ := poly.MarshalJSON()
	fmt.Printf("geojson: %s\n", string(j))
```

The resulting geojson can be put into any GIS system or viewer (eg geojson.io)


## Test coverage

go test ./... -coverprofile=coverage

then

go tool cover -html=coverage


## OpenCV Sanity Check

The directory opencv-sanity-check has a small test of test images and the contours generated by OpenCV. The code for
this is at github.com/kpfaulkner/opencvtest

This is purely to compare results of Borders vs OpenCV.







borders

A library provides spatial data and geometric algorithms

# Geoos
Our organization `spatial-go` is officially established! The first open source project `Geoos`(Using `Golang`) provides spatial data and geometric algorithms.
All comments and suggestions are welcome!

## Guides

http://www.spatial-go.com

## Contents
  - [Guides](#guides)
  - [Contents](#contents)
  - [Structure](#structure)
  - [Documentation](#documentation)
  - [Maintainer](#maintainer)
  - [Contributing](#contributing)
  - [License](#license)



## Structure
1.algorithm
Package algorithm defines Specifies Computational Geometric and algorithm err.
2.clusters
Package clusters is a spatial clustering algorithm.
3.coordtransform
Package coordtransform is for transform coord.
4.example
Example This is an example .
5.geoencoding
Package geoencoding is a library for encoding and decoding into Go structs using the geometries.
6.grid
Package grid is used to generate grid data.
7.index
Package index define spatial index interface.
8.planar
Package planar provides support for the implementation of spatial operations and geometric algorithms.
9.space
Package space A representation of a linear vector geometry.
10.utils
Package utils A functions of utils.

## Documentation
How to use `Geoos`:
Example: Calculating `area` via `Geoos`
```
package main

import (
	"bytes"
	"fmt"

	"github.com/spatial-go/geoos/geoencoding"
	"github.com/spatial-go/geoos/planar"
)

func main() {
	// First, choose the default algorithm.
	strategy := planar.NormalStrategy()
	// Secondly, manufacturing test data and convert it to geometry
	const polygon = `POLYGON((-1 -1, 1 -1, 1 1, -1 1, -1 -1))`
	// geometry, _ := wkt.UnmarshalString(polygon)

	buf0 := new(bytes.Buffer)
	buf0.Write([]byte(polygon))
	geometry, _ := geoencoding.Read(buf0, geoencoding.WKT)

	// Last， call the Area () method and get result.
	area, e := strategy.Area(geometry)
	if e != nil {
		fmt.Printf(e.Error())
	}
	fmt.Printf("%f", area)
	// get result 4.0
}
```
Example: geoencoding
[example_encoding.go](https://github.com/spatial-go/geoos/example/example_encoding.go)

## Maintainer

[@spatial-go](https://github.com/spatial-go)。

## Contributing

We will also uphold the concept of "openness, co-creation, and win-win" to contribute in the field of space computing.

Welcome to join us ！[please report an issue](https://github.com/spatial-go/geoos/issues/new)

Email Address： [geoos@changjing.ai](mailto:geoos@changjing.ai)

## License
`Geoos` is licensed under the:
[LGPL-2.1 ](LICENSE)

geoos

Conversion utilities between H3 indexes and GeoJSON

# go-geojson2h3

[![Coverage Status](https://coveralls.io/repos/github/mmadfox/go-geojson2h3/badge.svg?branch=main&n=1)](https://coveralls.io/github/mmadfox/go-geojson2h3?branch=main&n=1)
[![Documentation](https://godoc.org/github.com/mmadfox/go-geojson2h3?status.svg)](https://pkg.go.dev/github.com/mmadfox/go-geojson2h3)
[![Go Report Card](https://goreportcard.com/badge/github.com/mmadfox/go-geojson2h3)](https://goreportcard.com/report/github.com/mmadfox/go-geojson2h3)

The `geojson2h3` library includes a set of utilities for conversion between GeoJSON Objects: 
* Point, MultiPoint,
* LineString, MultiLineString
* Polygon,MultiPolygon
* GeometryCollection
* Feature,FeatureCollection
* Circle

and [H3 hexagon indexes](https://h3geo.org), 
using:
    [H3-GO](https://github.com/uber/h3-go) and
    [GeoJSON](https://github.com/tidwall/geojson)

## Installation
```shell
$ go get github.com/mmadfox/go-geojson2h3
```

## API
```go
// ToH3 converts a GeoJSON objects to a list of hexagons with specified resolution.
ToH3(resolution int, o geojson.Object) (indexes []h3.H3Index, err error)

// ToFeatureCollection converts a set of hexagons to a GeoJSON `FeatureCollection`
// with the set outline(s). The feature's geometry type will be `Polygon`.
ToFeatureCollection(indexes []h3.H3Index) (*geojson.FeatureCollection, error)
```

## Examples

* [Point, MultiPoint](examples/point.go)
* [LineString, MultiLineString](examples/line.go)
* [Polygon,MultiPolygon](examples/polygon.go)
* [GeometryCollection](examples/collection.go)
* [Feature,FeatureCollection](examples/feature.go)
* [Circle](examples/circle.go)
* [Rect](examples/rect.go)

```go
package main

import (
	"fmt"

	"github.com/mmadfox/go-geojson2h3"
	"github.com/tidwall/geojson"
	"github.com/uber/h3-go/v3"
)

func main() {
	resolution := 9
	object, err := geojson.Parse(`{"type":"FeatureCollection","features":[{"type":"Feature","properties":{"shape":"Polygon","name":"Unnamed Layer","category":"default"},"geometry":{"type":"Polygon","coordinates":[[[-73.901303,40.756892],[-73.893924,40.743755],[-73.871476,40.756278],[-73.863378,40.764175],[-73.871444,40.768467],[-73.879852,40.760014],[-73.885515,40.764045],[-73.891522,40.761054],[-73.901303,40.756892]]]},"id":"a6ca1b7e-9ddf-4425-ad07-8a895f7d6ccf"}]}`, nil)
	if err != nil {
		panic(err)
	}

	indexes, err := geojson2h3.ToH3(resolution, object)
	if err != nil {
		panic(err)
	}
	for _, index := range indexes {
		fmt.Printf("h3index: %s\n", h3.ToString(index))
	}

	featureCollection, err := geojson2h3.ToFeatureCollection(indexes)
	if err != nil {
		panic(err)
	}
	fmt.Println("Polyfill:")
	fmt.Println(featureCollection.JSON())
}
```

## Contributing
Pull requests and [Github issues](https://github.com/mmadfox/go-geojson2h3/issues) are welcome. Please include tests for new work, and keep the library test coverage at 90-100%. 


H3 GeoJSON

Convert geojson to s2 cells & demonstrating some S2 geometry features on map

[![Build Status](https://travis-ci.com/pantrif/s2-geojson.svg?branch=develop)](https://travis-ci.com/pantrif/s2-geojson)
[![GoDoc](https://godoc.org/github.com/pantrif/s2-geojson?status.png)](http://godoc.org/github.com/pantrif/s2-geojson)
[![Go Report Card](https://goreportcard.com/badge/github.com/pantrif/s2-geojson)](https://goreportcard.com/report/github.com/pantrif/s2-geojson)
[![codecov](https://codecov.io/gh/pantrif/s2-geojson/branch/develop/graph/badge.svg)](https://codecov.io/gh/pantrif/s2-geojson)


## Preview
<img width="1645" alt="preview" src="https://user-images.githubusercontent.com/9129280/77917392-31dca180-72a3-11ea-9e93-27c331731196.png">


## Summary

Draw a polygon on the map or paste a geoJSON and explore how the s2.RegionCoverer covers it with S2 cells depending on the min and max levels.
Drop a marker and inspect the corresponding S2 cell.

- Display s2 cells on leaflet map using the region coverer. 
- Convert geojson features to cell unions depending on the min and max levels (supported only Polygons and Points).
- Draw points and polygons.
- Check point & circle intersection with the geoJSON features.


## Quick start
```
 go run cmd/s2-geojson/main.go
```

## Docker 
```
docker run -p 8080:8080 --rm lmaroulis/s2-geojson
```



## License

This project is licensed under the MIT License - see [the LICENSE file](LICENSE) for details.

S2 geojson

Library for Coordinate Conversion and Transformation (ETRS89, OSGB36, NAD83, RGF93, Web Mercator, UTM)

[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white)](https://pkg.go.dev/github.com/wroge/wgs84@v2.0.0-alpha.13)

## WGS84 - Coordinate Transformations

```
go get github.com/wroge/wgs84/v2@v2.0.0-alpha.13
```  


I am currently in the process of rewriting the package. Some things will change and some new features will be added. One of these features is the support of NTv2 grid transformations and other projections, such as Krovak. If you would like to help or have any comments, please report them in the issues.

### Web Mercator

```go
package main

import (
	"fmt"

	"github.com/wroge/wgs84/v2"
)

func main() {
	transform := wgs84.Transform(wgs84.EPSG(4326), wgs84.EPSG(3857)).Round(3)

	east, north, _ := transform(10, 50, 0)

	fmt.Println(east, north)
	// 1.113194908e+06 6.446275841e+06

	// echo 10 50 | cs2cs +init=epsg:4326 +to +init=epsg:3857 -d 3
	// 1113194.908     6446275.841
}
```

### OSGB

```go
package main

import (
	"fmt"

	"github.com/wroge/wgs84/v2"
)

func main() {
	transform := wgs84.Transform(wgs84.EPSG(4326), wgs84.EPSG(27700)).Round(3)

	east, north, h := transform(-2.25, 52.25, 0)

	fmt.Println(east, north, h)
	// 383029.296 261341.615 0

	// echo -2.25 52.25 | cs2cs +init=epsg:4326 +to +init=epsg:27700 -d 3
	// 383029.296 261341.615 0.000
}
```


WGS84

Publish Your GIS Data(Vector Data) to PostGIS and Geoserver

[![Go Report Card](https://goreportcard.com/badge/github.com/hishamkaram/gismanager)](https://goreportcard.com/report/github.com/hishamkaram/gismanager)
[![GitHub license](https://img.shields.io/github/license/hishamkaram/gismanager.svg)](https://github.com/hishamkaram/gismanager/blob/master/LICENSE)
[![GitHub issues](https://img.shields.io/github/issues/hishamkaram/gismanager.svg)](https://github.com/hishamkaram/gismanager/issues)
[![Coverage Status](https://coveralls.io/repos/github/hishamkaram/gismanager/badge.svg?branch=master&service=github)](https://coveralls.io/github/hishamkaram/gismanager?branch=master&service=github)
[![Build Status](https://travis-ci.org/hishamkaram/gismanager.svg?branch=master)](https://travis-ci.org/hishamkaram/gismanager)
[![Documentation](https://godoc.org/github.com/hishamkaram/gismanager?status.svg)](https://godoc.org/github.com/hishamkaram/gismanager?)
[![GitHub forks](https://img.shields.io/github/forks/hishamkaram/gismanager.svg)](https://github.com/hishamkaram/gismanager/network)
[![GitHub stars](https://img.shields.io/github/stars/hishamkaram/gismanager.svg)](https://github.com/hishamkaram/gismanager/stargazers)
[![Twitter](https://img.shields.io/twitter/url/https/github.com/hishamkaram/gismanager/edit/master/README.md.svg?style=social)](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fhishamkaram%2Fgeoserver%2Fedit%2Fmaster%2FREADME.md)



 <img src="http://geoserver.org/img/OSGeo_project.png" width="200"/>


 <img src="https://i.imgur.com/31CL1xg.png" width="200"/>


# GISManager
Publish Your GIS Data(Vector Data) to PostGIS and Geoserver

- How to install:
 - `go get -v github.com/hishamkaram/gismanager`
- Usage:
 - `testdata` folder content:
 ```
 ./testdata/
 ├── neighborhood_names_gis.geojson
 ├── nested
 │   └── nyc_wi-fi_hotspot_locations.geojson
 ├── sample.gpkg
 ```
 - create `ManagerConfig` instance:
 ```
 manager:= gismanager.ManagerConfig{
 Geoserver: gismanager.GeoserverConfig{WorkspaceName: "golang", Username: "admin", Password: "geoserver", ServerURL: "http://localhost:8080/geoserver"},
 Datastore: gismanager.DatastoreConfig{Host: "localhost", Port: 5432, DBName: "gis", DBUser: "golang", DBPass: "golang", Name: "gismanager_data"},
 Source: gismanager.SourceConfig{Path: "./testdata"},
 logger: gismanager.GetLogger(),
 }
 ```
 - get Supported GIS Files:
 ```
 files, _ := gismanager.GetGISFiles(manager.Source.Path)
 for _, file := range files {
 fmt.Println(file)
 }
 ```
 - output:
 ```
 <full_path>/testdata/neighborhood_names_gis.geojson
 <full_path>/testdata/nested/nyc_wi-fi_hotspot_locations.geojson
 <full_path>/testdata/sample.gpkg
 ```
 - read files and get layers Schema:
 ```
 for _, file := range files {
 source, ok := manager.OpenSource(file, 0)
 if ok {
 for index := 0; index < source.LayerCount(); index++ {
 layer := source.LayerByIndex(index)
 gLayer := gismanager.GdalLayer{
 Layer: &layer,
 }
 fmt.Println(layer.Name())
 for _, f := range gLayer.GetLayerSchema() {
 fmt.Printf("\n%+v\n", *f)
 }
 }
 }
 }
 ```
 - output sample:
 ```
 neighborhood_names_gis

 {Name:geom Type:POINT}

 {Name:stacked Type:String}

 {Name:name Type:String}

 {Name:annoline1 Type:String}

 {Name:annoline3 Type:String}

 {Name:objectid Type:String}

 {Name:annoangle Type:String}

 {Name:annoline2 Type:String}

 {Name:borough Type:String}
 ...
 ```
 - add your gis data to your database:
 ```
 for _, file := range files {
 source, ok := manager.OpenSource(file, 0)
 targetSource, targetOK := manager.OpenSource(manager.Datastore.BuildConnectionString(), 1)
 if ok && targetOK {
 for index := 0; index < source.LayerCount(); index++ {
 layer := source.LayerByIndex(index)
 gLayer := gismanager.GdalLayer{
 Layer: &layer,
 }
 newLayer, postgisErr := gLayer.LayerToPostgis(targetSource, manager, true)
 if postgisErr != nil {
 panic(postgisErr)
 }
 logger.Infof("Layer: %s added to you database", newLayer.Name())
 }
 }
 }
 ```
 - output:
 ```
 INFO[14-10-2018 17:28:37] Layer: neighborhood_names_gis added to you database 
 INFO[14-10-2018 17:28:38] Layer: nyc_wi_fi_hotspot_locations added to you database 
 INFO[14-10-2018 17:28:38] Layer: hwy_patrol added to you database
 ```
 - update the previous code to publish your postgis layers to geoserver
 ```
 for _, file := range files {
 source, ok := manager.OpenSource(file, 0)
 targetSource, targetOK := manager.OpenSource(manager.Datastore.BuildConnectionString(), 1)
 if ok && targetOK {
 for index := 0; index < source.LayerCount(); index++ {
 layer := source.LayerByIndex(index)
 gLayer := gismanager.GdalLayer{
 Layer: &layer,
 }
 if newLayer, postgisErr := gLayer.LayerToPostgis(targetSource, manager, true); newLayer.Layer != nil || postgisErr != nil {
 ok, pubErr := manager.PublishGeoserverLayer(newLayer)
 if pubErr != nil {
 logger.Error(pubErr)
 }
 if !ok {
 logger.Error("Failed to Publish")
 } else {
 logger.Info("published")
 }
 }

 }
 }
 }
 ```
 - output:
 ```
 INFO[14-10-2018 17:37:07] url:http://localhost:8080/geoserver/rest/workspaces/golang Status=404 
 ERRO[14-10-2018 17:37:07] No such workspace: 'golang' found 
 INFO[14-10-2018 17:37:07] url:http://localhost:8080/geoserver/rest/workspaces Status=201 
 INFO[14-10-2018 17:37:07] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis?quietOnNotFound=true Status=404 
 INFO[14-10-2018 17:37:07] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores Status=201 
 ERRO[14-10-2018 17:37:07] {"featureType":{"name":"neighborhood_names_gis","nativeName":"neighborhood_names_gis"}} 
 INFO[14-10-2018 17:37:07] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis/featuretypes Status=201 
 INFO[14-10-2018 17:37:07] published 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang Status=200 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis?quietOnNotFound=true Status=200 
 ERRO[14-10-2018 17:37:08] {"featureType":{"name":"nyc_wi_fi_hotspot_locations","nativeName":"nyc_wi_fi_hotspot_locations"}} 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis/featuretypes Status=201 
 INFO[14-10-2018 17:37:08] published 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang Status=200 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis?quietOnNotFound=true Status=200 
 ERRO[14-10-2018 17:37:08] {"featureType":{"name":"hwy_patrol","nativeName":"hwy_patrol"}} 
 INFO[14-10-2018 17:37:08] url:http://localhost:8080/geoserver/rest/workspaces/golang/datastores/gis/featuretypes Status=201 
 INFO[14-10-2018 17:37:08] published 
 ```
 - done check you geoserver or via geoserver rest api url http://localhost:8080/geoserver/rest/layers.json : 
 ```
 {
 "layers": {
 "layer": [..., {
 "name": "golang:hwy_patrol",
 "href": "http:\/\/localhost:8080\/geoserver\/rest\/layers\/golang%3Ahwy_patrol.json"
 }, {
 "name": "golang:neighborhood_names_gis",
 "href": "http:\/\/localhost:8080\/geoserver\/rest\/layers\/golang%3Aneighborhood_names_gis.json"
 }, {
 "name": "golang:nyc_wi_fi_hotspot_locations",
 "href": "http:\/\/localhost:8080\/geoserver\/rest\/layers\/golang%3Anyc_wi_fi_hotspot_locations.json"
 }]
 }
 }
 ```
 ---
 
# Todo:
 - [ ] backup postgis as geopackage

gismanager

# Golang bindings for GDAL
[![Go Reference](https://pkg.go.dev/badge/github.com/airbusgeo/godal.svg)](https://pkg.go.dev/github.com/airbusgeo/godal)
[![License](https://img.shields.io/github/license/airbusgeo/godal.svg)](https://github.com/airbusgeo/godal/blob/main/LICENSE)
[![Build Status](https://github.com/airbusgeo/godal/workflows/build/badge.svg?branch=main&event=push)](https://github.com/airbusgeo/godal/actions?query=workflow%3Agodal+event%3Apush+branch%3Amain)
[![Coverage Status](https://coveralls.io/repos/github/airbusgeo/godal/badge.svg?branch=main)](https://coveralls.io/github/airbusgeo/godal?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/airbusgeo/godal)](https://goreportcard.com/report/github.com/airbusgeo/godal)



### Goals

Godal aims at providing an idiomatic go wrapper around the <img src="https://gdal.org/_static/gdalicon.png" width="25" height="25">
[GDAL](https://gdal.org) library:

* Function calls return a result and an error. The result will be valid if
 no error was returned. The error message will contain the root cause of why
 the error happened.
* Calls between go and native libraries incur some overhead. As such godal does
 not strictly expose GDAL's API, but groups often-used calls in a single cgo function
 to reduce this overhead. For example, C code like
```c++
 hDS = GDALOpen(filename, GA_Readonly)
 if (hDS == NULL) exit(1);
 int sx = GDALGetRasterXSize(hDS);
 int sy = GDALGetRasterYSize(hDS);
 int nBands = GDALGetRasterCount(hDS);
 printf("dataset size: %dx%dx%d\n",sx,sy,nBands);
 for (int i=1; i<=nBands; i++) {
 hBand = GDALGetRasterBand(hDS,i);
 int ovrCount = GDALGetOverviewCount(hBand)
 for(int o=0; o<=ovrCount; o++) {
 GDALRasterBandH oBand = GDALGetOverview(hBand,o);
 int osx = GDALGetRasterBandXSize(oBand);
 int osy = GDALGetRasterBandYSize(oBand);
 printf("overview %d size: %dx%d\n",o,osx,osy);
 }
 }
```
will be written as
```go
 hDS,err := godal.Open(filename)
 if err!=nil {
 panic(err)
 }
 structure := hDS.Structure()
 fmt.Printf("dataset size: %dx%dx%d\n", structure.SizeX,structure.SizeY,structure.NBands)
 for _,band := range hDS.Bands() {
 for o,ovr := range band.Overviews() {
 bstruct := ovr.Structure()
 fmt.Printf("overview %d size: %dx%d\n",o,bstruct.SizeX,bstruct.SizeY)
 }
 }
```
* Unfrequently used or non-default parameters are passed as options:
```go
 ds,err := godal.Open(filename) //read-only
 ds,err := godal.Open(filename, Update()) //read-write
```
* Godal exposes a VSI handler that can easily allow you to expose an
 [io.ReaderAt](https://golang.org/pkg/io/#ReaderAt) as a filename that can be
 opened by GDAL. A handler for opening `gs://` google cloud storage URIs is
 provided through https://github.com/airbusgeo/osio

### Documentation

[![GoReference](https://pkg.go.dev/badge/github.com/airbusgeo/godal.svg)](https://pkg.go.dev/github.com/airbusgeo/godal)
contains the API reference and example code to get you started. The
`*_test.go` files can also be used as reference.


### Status

Godal is not feature complete. The raster side is nearing completion and
should remain stable. The vector and spatial-referencing sides are far from
complete, meaning that the API might evolve in backwards incompatible ways
until essential functionality is covered.

### Contributing

Contributions are welcome. Please read the [contribution guidelines](CONTRIBUTING.md)
before submitting fixes or enhancements.

### Installation

Godal requires a GDAL version greater than 3.0. Make sure the GDAL headers
are installed on the system used for compiling go+godal code. If using a GDAL
installation in a non standard location, you can set your `PKG_CONFIG_PATH`
environment variable, e.g. `export PKG_CONFIG_PATH=/opt/include/pkgconfig`.

### Licensing
Godal is licensed under the Apache License, Version 2.0. See
[LICENSE](https://github.com/airbusgeo/godal/blob/main/LICENSE) for the full
license text.

godal

Distribution of Uber H3geo cells by virtual nodes

# H3-geo distributed cells 

[![Documentation](https://godoc.org/github.com/mmadfox/go-h3geo-dist?status.svg)](https://pkg.go.dev/github.com/mmadfox/go-h3geo-dist)
[![Coverage Status](https://coveralls.io/repos/github/mmadfox/go-h3geo-dist/badge.svg?branch=main)](https://coveralls.io/github/mmadfox/go-h3geo-dist?branch=main&1)
[![Go Report Card](https://goreportcard.com/badge/github.com/mmadfox/go-h3geo-dist)](https://goreportcard.com/report/github.com/mmadfox/go-h3geo-dist)

Distribution of [Uber H3geo](https://h3geo.org/) cells by nodes 

Prerequisites
-------
[H3-Go requires CGO ](https://github.com/uber/h3-go#prerequisites)

Install
-------
With a correctly configured Go env:

```
go get github.com/mmadfox/go-h3geo-dist
```

Examples
--------
```go
package main

import (
	"fmt"

	h3geodist "github.com/mmadfox/go-h3geo-dist"
	"github.com/uber/h3-go/v3"
)

func main() {
	level := h3geodist.Level1
	h3dist, err := h3geodist.New(level)
	if err != nil {
		panic(err)
	}

	_ = h3dist.Add("127.0.0.1")
	_ = h3dist.Add("127.0.0.2")
	_ = h3dist.Add("127.0.0.3")

	// iterate over all cells level one
	h3geodist.Iter(level, func(index uint, cell h3.H3Index) {
		// find a node by h3geo cell
		dcell, ok := h3dist.Lookup(cell)
		fmt.Printf("h3dist.Lookup: cell=%v, host=%s, found=%v\n", cell, dcell.Host, ok)
	})

	h3dist.LookupMany([]h3.H3Index{
		h3.FromString("821fa7fffffffff"),
		h3.FromString("821f9ffffffffff"),
		h3.FromString("81973ffffffffff"),
		h3.FromString("81f07ffffffffff"),
	}, func(c h3geodist.Cell) bool {
		fmt.Printf("h3dist.LookupMany: cell=%v, host=%s\n", c.H3ID, c.Host)
		return true
	})

	h3dist.Remove("127.0.0.1")
	h3dist.Remove("127.0.0.2")
	h3dist.Remove("127.0.0.3")
}
```

The Best Go Libraries For Geographic (16)