func (nw *NodeWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(nw.srid)
defer geos.Finish()
for n := range nw.nodes {
nw.progress.AddNodes(1)
if matches := nw.tagMatcher.Match(&n.Tags); len(matches) > 0 {
proj.NodeToMerc(n)
if nw.expireTiles != nil {
nw.expireTiles.ExpireFromNodes([]element.Node{*n})
}
point, err := geom.Point(geos, *n)
if err != nil {
if err, ok := err.(ErrorLevel); ok {
if err.Level() <= 0 {
continue
}
}
log.Println(err)
continue
}
n.Geom, err = geom.AsGeomElement(geos, point)
if err != nil {
log.Println(err)
continue
}
if nw.limiter != nil {
parts, err := nw.limiter.Clip(n.Geom.Geom)
if err != nil {
log.Println(err)
continue
}
if len(parts) >= 1 {
nw.insertMatches(&n.OSMElem, matches)
}
} else {
nw.insertMatches(&n.OSMElem, matches)
}
}
}
nw.wg.Done()
}
func (ww *WayWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(ww.srid)
defer geos.Finish()
for w := range ww.ways {
ww.progress.AddWays(1)
if len(w.Tags) == 0 {
continue
}
insertedAsRelation, err := ww.osmCache.InsertedWays.IsInserted(w.Id)
if err != nil {
log.Warn(err)
continue
}
err = ww.osmCache.Coords.FillWay(w)
if err != nil {
continue
}
proj.NodesToMerc(w.Nodes)
inserted := false
if ok, matches := ww.inserter.ProbeLineString(w.OSMElem); ok {
err := ww.buildAndInsert(geos, w, matches, false)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
inserted = true
}
if w.IsClosed() && !insertedAsRelation {
// only add polygons that were not inserted as a MultiPolygon relation
if ok, matches := ww.inserter.ProbePolygon(w.OSMElem); ok {
err := ww.buildAndInsert(geos, w, matches, true)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
inserted = true
}
}
if inserted && ww.expireor != nil {
expire.ExpireNodes(ww.expireor, w.Nodes)
}
if ww.diffCache != nil {
ww.diffCache.Coords.AddFromWay(w)
}
}
ww.wg.Done()
}
func (nw *NodeWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(nw.srid)
defer geos.Finish()
for n := range nw.nodes {
nw.progress.AddNodes(1)
if ok, matches := nw.inserter.ProbePoint(n.OSMElem); ok {
proj.NodeToMerc(n)
if nw.expireor != nil {
nw.expireor.Expire(n.Long, n.Lat)
}
point, err := geom.Point(geos, *n)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
n.Geom, err = geom.AsGeomElement(geos, point)
if err != nil {
log.Warn(err)
continue
}
if nw.limiter != nil {
parts, err := nw.limiter.Clip(n.Geom.Geom)
if err != nil {
log.Warn(err)
continue
}
if len(parts) >= 1 {
if err := nw.inserter.InsertPoint(n.OSMElem, matches); err != nil {
log.Warn(err)
continue
}
}
} else {
if err := nw.inserter.InsertPoint(n.OSMElem, matches); err != nil {
log.Warn(err)
continue
}
}
}
}
nw.wg.Done()
}
func (ww *WayWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(ww.srid)
defer geos.Finish()
for w := range ww.ways {
ww.progress.AddWays(1)
if len(w.Tags) == 0 {
continue
}
inserted, err := ww.osmCache.InsertedWays.IsInserted(w.Id)
if err != nil {
log.Println(err)
continue
}
if inserted {
continue
}
err = ww.osmCache.Coords.FillWay(w)
if err != nil {
continue
}
proj.NodesToMerc(w.Nodes)
inserted = false
if matches := ww.lineStringTagMatcher.Match(&w.Tags); len(matches) > 0 {
ww.buildAndInsert(geos, w, matches, geom.LineString)
inserted = true
}
if w.IsClosed() {
if matches := ww.polygonTagMatcher.Match(&w.Tags); len(matches) > 0 {
ww.buildAndInsert(geos, w, matches, geom.Polygon)
inserted = true
}
}
if inserted && ww.expireTiles != nil {
ww.expireTiles.ExpireFromNodes(w.Nodes)
}
if ww.diffCache != nil {
ww.diffCache.Coords.AddFromWay(w)
}
}
ww.wg.Done()
}
func (rw *RelationWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(rw.srid)
defer geos.Finish()
NextRel:
for r := range rw.rel {
rw.progress.AddRelations(1)
err := rw.osmCache.Ways.FillMembers(r.Members)
if err != nil {
if err != cache.NotFound {
log.Warn(err)
}
continue NextRel
}
for _, m := range r.Members {
if m.Way == nil {
continue
}
err := rw.osmCache.Coords.FillWay(m.Way)
if err != nil {
if err != cache.NotFound {
log.Warn(err)
}
continue NextRel
}
proj.NodesToMerc(m.Way.Nodes)
}
// BuildRelation updates r.Members but we need all of them
// for the diffCache
allMembers := r.Members
// prepare relation first (build rings and compute actual
// relation tags)
prepedRel, err := geom.PrepareRelation(r, rw.srid)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue NextRel
}
// check for matches befor building the geometry
ok, matches := rw.inserter.ProbePolygon(r.OSMElem)
if !ok {
continue NextRel
}
// build the multipolygon
r, err = prepedRel.Build()
if err != nil {
if r.Geom != nil && r.Geom.Geom != nil {
geos.Destroy(r.Geom.Geom)
}
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue NextRel
}
if rw.limiter != nil {
start := time.Now()
parts, err := rw.limiter.Clip(r.Geom.Geom)
if err != nil {
log.Warn(err)
continue NextRel
}
if duration := time.Now().Sub(start); duration > time.Minute {
log.Warnf("clipping relation %d to -limitto took %s", r.Id, duration)
}
for _, g := range parts {
rel := element.Relation(*r)
rel.Id = -r.Id
rel.Geom = &element.Geometry{Geom: g, Wkb: geos.AsEwkbHex(g)}
err := rw.inserter.InsertPolygon(rel.OSMElem, matches)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
}
} else {
rel := element.Relation(*r)
rel.Id = -r.Id
err := rw.inserter.InsertPolygon(rel.OSMElem, matches)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
}
for _, m := range rw.inserter.SelectRelationPolygons(r.Tags, r.Members) {
err = rw.osmCache.InsertedWays.PutWay(m.Way)
if err != nil {
log.Warn(err)
}
}
if rw.diffCache != nil {
rw.diffCache.Ways.AddFromMembers(r.Id, allMembers)
for _, member := range allMembers {
if member.Way != nil {
rw.diffCache.Coords.AddFromWay(member.Way)
}
}
}
if rw.expireor != nil {
for _, m := range allMembers {
if m.Way != nil {
expire.ExpireNodes(rw.expireor, m.Way.Nodes)
}
}
}
geos.Destroy(r.Geom.Geom)
}
rw.wg.Done()
}
func (rw *RelationWriter) loop() {
geos := geos.NewGeos()
geos.SetHandleSrid(rw.srid)
defer geos.Finish()
NextRel:
for r := range rw.rel {
rw.progress.AddRelations(1)
err := rw.osmCache.Ways.FillMembers(r.Members)
if err != nil {
if err != cache.NotFound {
fmt.Println(err)
}
continue NextRel
}
for _, m := range r.Members {
if m.Way == nil {
continue
}
err := rw.osmCache.Coords.FillWay(m.Way)
if err != nil {
if err != cache.NotFound {
fmt.Println(err)
}
continue NextRel
}
proj.NodesToMerc(m.Way.Nodes)
}
// BuildRelation updates r.Members but we need all of them
// for the diffCache
allMembers := r.Members
// prepare relation first (build rings and compute actual
// relation tags)
prepedRel, err := geom.PrepareRelation(r, rw.srid)
if err != nil {
if err, ok := err.(ErrorLevel); ok {
if err.Level() <= 0 {
continue NextRel
}
}
log.Println(err)
continue NextRel
}
// check for matches befor building the geometry
matches := rw.tagMatcher.Match(&r.Tags)
if len(matches) == 0 {
continue NextRel
}
// build the multipolygon
r, err = prepedRel.Build()
if err != nil {
if r.Geom != nil && r.Geom.Geom != nil {
geos.Destroy(r.Geom.Geom)
}
if err, ok := err.(ErrorLevel); ok {
if err.Level() <= 0 {
continue NextRel
}
}
log.Println(err)
continue NextRel
}
if rw.limiter != nil {
parts, err := rw.limiter.Clip(r.Geom.Geom)
if err != nil {
log.Println(err)
continue NextRel
}
for _, g := range parts {
rel := element.Relation(*r)
rel.Geom = &element.Geometry{g, geos.AsEwkbHex(g)}
rw.insertMatches(&rel.OSMElem, matches)
}
} else {
rw.insertMatches(&r.OSMElem, matches)
}
err = rw.osmCache.InsertedWays.PutMembers(r.Members)
if err != nil {
fmt.Println(err)
}
if rw.diffCache != nil {
rw.diffCache.Ways.AddFromMembers(r.Id, allMembers)
for _, member := range allMembers {
if member.Way != nil {
rw.diffCache.Coords.AddFromWay(member.Way)
}
}
}
if rw.expireTiles != nil {
for _, m := range allMembers {
if m.Way != nil {
rw.expireTiles.ExpireFromNodes(m.Way.Nodes)
}
}
}
geos.Destroy(r.Geom.Geom)
}
rw.wg.Done()
}
