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
}
ww.NodesToSrid(w.Nodes)
w.Id = ww.wayId(w.Id)
inserted := false
if matches := ww.lineMatcher.MatchWay(w); len(matches) > 0 {
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 matches := ww.polygonMatcher.MatchWay(w); len(matches) > 0 {
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 (d *Deleter) deleteWay(id int64, deleteRefs bool) error {
d.deletedWays[id] = struct{}{}
elem, err := d.osmCache.Ways.GetWay(id)
if err != nil {
if err == cache.NotFound {
return nil
}
return err
}
if elem.Tags == nil {
return nil
}
deleted := false
if matches := d.tmPolygons.MatchWay(elem); len(matches) > 0 {
if err := d.delDb.Delete(d.WayId(elem.Id), matches); err != nil {
return err
}
deleted = true
}
if matches := d.tmLineStrings.MatchWay(elem); len(matches) > 0 {
if err := d.delDb.Delete(d.WayId(elem.Id), matches); err != nil {
return err
}
deleted = true
}
if deleted && deleteRefs {
for _, n := range elem.Refs {
if err := d.diffCache.Coords.DeleteRef(n, id); err != nil {
return err
}
}
}
if deleted && d.expireor != nil {
err := d.osmCache.Coords.FillWay(elem)
if err != nil {
return err
}
expire.ExpireNodes(d.expireor, elem.Nodes)
}
return nil
}
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
}
rw.NodesToSrid(m.Way.Nodes)
}
// BuildRelation updates r.Members but we need all of them
// for the diffCache
allMembers := r.Members
//if relation type is route then proccess relation ways
if r.Tags["type"] == "route" {
if matches := rw.lineMatcher.MatchRelation(r); len(matches) > 0 {
for _, member := range allMembers {
if member.Way == nil {
continue
}
//switch way tags to relation tags and insert way
originalTags := member.Way.Tags
member.Way.Tags = r.Tags
err := rw.buildAndInsertWay(geos, member.Way, matches, false)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue NextRel
}
//return back original way Tags
member.Way.Tags = originalTags
}
}
}
// prepare relation first (build rings and compute actual
// relation tags)
prepedRel, err := geomp.PrepareRelation(r, rw.srid, rw.maxGap)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue NextRel
}
// check for matches before building the geometry
matches := rw.polygonMatcher.MatchRelation(r)
if len(matches) == 0 {
continue NextRel
}
// build the multipolygon
geom, err := prepedRel.Build()
if err != nil {
if geom.Geom != nil {
geos.Destroy(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(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 = rw.relId(r.Id)
geom = geomp.Geometry{Geom: g, Wkb: geos.AsEwkbHex(g)}
err := rw.inserter.InsertPolygon(rel.OSMElem, geom, matches)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
}
} else {
rel := element.Relation(*r)
rel.Id = rw.relId(r.Id)
err := rw.inserter.InsertPolygon(rel.OSMElem, geom, matches)
if err != nil {
if errl, ok := err.(ErrorLevel); !ok || errl.Level() > 0 {
log.Warn(err)
}
continue
}
}
for _, m := range mapping.SelectRelationPolygons(rw.polygonMatcher, r) {
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(geom.Geom)
}
rw.wg.Done()
}
func (d *Deleter) deleteRelation(id int64, deleteRefs bool, deleteMembers bool) error {
d.deletedRelations[id] = struct{}{}
elem, err := d.osmCache.Relations.GetRelation(id)
if err != nil {
if err == cache.NotFound {
return nil
}
return err
}
if elem.Tags == nil {
return nil
}
// delete from all tables to handle relations with tags from members
// and relation_members
e := element.OSMElem(elem.OSMElem)
e.Id = d.RelId(e.Id)
if err := d.delDb.DeleteElem(e); err != nil {
return err
}
if deleteRefs {
for _, m := range elem.Members {
if m.Type == element.WAY {
if err := d.diffCache.Ways.DeleteRef(m.Id, id); err != nil {
return err
}
}
}
}
if deleteMembers {
// delete members from db and force reinsert of members
// use case: relation is deleted and member now stands for its own
for _, member := range elem.Members {
if member.Type == element.WAY {
d.deletedMembers[member.Id] = struct{}{}
if _, ok := d.deletedWays[member.Id]; ok {
continue
}
for _, r := range d.diffCache.Ways.Get(member.Id) {
if err := d.deleteRelation(r, false, false); err != nil {
return err
}
}
if err := d.deleteWay(member.Id, false); err != nil {
return err
}
}
}
}
if err := d.osmCache.InsertedWays.DeleteMembers(elem.Members); err != nil {
return err
}
if d.expireor != nil {
for _, m := range elem.Members {
if m.Way == nil {
continue
}
err := d.osmCache.Coords.FillWay(m.Way)
if err != nil {
continue
}
proj.NodesToMerc(m.Way.Nodes)
expire.ExpireNodes(d.expireor, m.Way.Nodes)
}
}
return nil
}
func (rw *RelationWriter) loop() {
geos := geosp.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
}
for i, 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
}
rw.NodesToSrid(m.Way.Nodes)
r.Members[i].Elem = &m.Way.OSMElem
}
// handleRelation updates r.Members but we need all of them
// for the diffCache
allMembers := r.Members
inserted := false
if handleRelationMembers(rw, r, geos) {
inserted = true
}
if handleRelation(rw, r, geos) {
inserted = true
}
if handleMultiPolygon(rw, r, geos) {
inserted = true
}
if inserted && rw.diffCache != nil {
rw.diffCache.Ways.AddFromMembers(r.Id, allMembers)
rw.diffCache.CoordsRel.AddFromMembers(r.Id, allMembers)
for _, member := range allMembers {
if member.Way != nil {
rw.diffCache.Coords.AddFromWay(member.Way)
}
}
}
if inserted && rw.expireor != nil {
for _, m := range allMembers {
if m.Way != nil {
expire.ExpireNodes(rw.expireor, m.Way.Nodes)
}
}
}
}
rw.wg.Done()
}
