Exemple #1
0
func New(p *point.Point) *Node {
	return &Node{
		Position_:  p,
		Id_:        newNodeId(),
		Tags_:      tags.New(),
		Timestamp_: time.Now(),
		Version_:   0,
		Changeset_: 0,
		Visible_:   true,
		User_:      user.New(0, ""),
		modified:   true,
		deleted:    false,
	}
}
Exemple #2
0
// implements the osm.Parser interface
func (p *Pbf) Parse() (o *osm.OSM, err error) {
	d := osmpbf.NewDecoder(p.r)

	err = d.Start(runtime.GOMAXPROCS(-1))
	if err != nil {
		return
	}

	o = osm.NewOSM()
	var v interface{}
	for {
		if v, err = d.Decode(); err == io.EOF {
			err = nil
			break
		} else if err != nil {
			return
		} else {
			switch v := v.(type) {
			case *osmpbf.Node:
				var t tags.Tags
				if v.Tags != nil && len(v.Tags) != 0 {
					t = tags.Tags(v.Tags)
				}
				o.Nodes[v.ID] = &node.Node{
					Id_:        v.ID,
					User_:      user.New(int64(v.Info.Uid), v.Info.User),
					Position_:  point.New(v.Lat, v.Lon),
					Timestamp_: v.Info.Timestamp,
					Changeset_: v.Info.Changeset,
					Version_:   int64(v.Info.Version),
					Visible_:   v.Info.Visible,
					Tags_:      &t,
				}
			case *osmpbf.Way:
				var t tags.Tags
				if v.Tags != nil && len(v.Tags) != 0 {
					t = tags.Tags(v.Tags)
				}
				w := &way.Way{
					Id_:        v.ID,
					User_:      user.New(int64(v.Info.Uid), v.Info.User),
					Timestamp_: v.Info.Timestamp,
					Changeset_: v.Info.Changeset,
					Version_:   int64(v.Info.Version),
					Visible_:   v.Info.Visible,
					Tags_:      &t,
				}
				var nd []*node.Node
				for _, id := range v.NodeIDs {
					n := o.Nodes[id]
					if n == nil {
						err = errors.New(fmt.Sprintf("Missing node #%d in way #%d", id, v.ID))
						o = nil
						return
					}
					nd = append(nd, n)
				}
				w.Nodes_ = nd
				o.Ways[v.ID] = w
			case *osmpbf.Relation:
				var t tags.Tags
				if v.Tags != nil && len(v.Tags) != 0 {
					t = tags.Tags(v.Tags)
				}
				r := &relation.Relation{
					Id_:        v.ID,
					User_:      user.New(int64(v.Info.Uid), v.Info.User),
					Timestamp_: v.Info.Timestamp,
					Changeset_: v.Info.Changeset,
					Version_:   int64(v.Info.Version),
					Visible_:   v.Info.Visible,
					Tags_:      &t,
				}
				var members []*relation.Member
				for _, m := range v.Members {
					member := &relation.Member{Role: m.Role, Id_: m.ID}
					switch m.Type {
					case osmpbf.NodeType:
						member.Type_ = item.TypeNode
						member.Ref = o.GetNode(m.ID)
					case osmpbf.WayType:
						member.Type_ = item.TypeWay
						member.Ref = o.GetWay(m.ID)
					case osmpbf.RelationType:
						member.Type_ = item.TypeRelation
						member.Ref = o.GetRelation(m.ID)
					}
					if member.Ref == nil {
						err = errors.New(fmt.Sprintf("Missing member #%d (%s) in way #%d", m.ID, member.Type(), v.ID))
						o = nil
						return
					}
					members = append(members, member)
				}
				r.Members_ = members
				o.Relations[v.ID] = r
			default:
				log.Printf("ERROR: unknown type %T\n", v)
			}
		}
	}
	return
}
Exemple #3
0
func (x *DotOSM) parseItem(line string) (i item.Item, err error) {
	prefix, closed, m := x.parseLine(line)

	var ts time.Time
	if m["timestamp"] != "" {
		ts, err = time.Parse(time.RFC3339, m["timestamp"])
		if err != nil {
			err = errors.New(fmt.Sprintf("Failed to parse timestamp '%s': %s\n", m["timestamp"], err))
			return
		}
	}
	switch prefix {
	case "<node":
		n := &node.Node{
			Id_:        str2int64(m["id"]),
			User_:      user.New(str2int64(m["uid"]), m["user"]),
			Position_:  point.New(str2float64(m["lat"]), str2float64(m["lon"])),
			Timestamp_: ts,
			Version_:   str2int64(m["version"]),
			Changeset_: str2int64(m["changeset"]),
			Visible_:   str2bool(m["visible"]),
		}
		if !closed {
			n.Tags_ = x.parseTags("node")
		}
		// fmt.Printf("NODE=%q\n", n)
		return n, nil

	case "<way":
		if closed {
			err = errors.New(fmt.Sprintf("Way %s has no nodes\n", m["id"]))
			return
		}

		w := &way.Way{
			Id_:        str2int64(m["id"]),
			User_:      user.New(str2int64(m["uid"]), m["user"]),
			Timestamp_: ts,
			Version_:   str2int64(m["version"]),
			Changeset_: str2int64(m["changeset"]),
			Visible_:   str2bool(m["visible"]),
		}
		var t *tags.Tags
		var nd []*node.Node
		t, nd, err = x.parseWay(str2int64(m["id"]))
		if err != nil {
			return
		}
		w.Tags_ = t
		w.Nodes_ = nd

		// fmt.Printf("WAY=%q\n", w)
		return w, nil

	case "<relation":
		if closed {
			err = errors.New(fmt.Sprintf("Relation %s has no members\n", m["id"]))
			return
		}

		rel := &relation.Relation{
			Id_:        str2int64(m["id"]),
			User_:      user.New(str2int64(m["uid"]), m["user"]),
			Timestamp_: ts,
			Version_:   str2int64(m["version"]),
			Changeset_: str2int64(m["changeset"]),
			Visible_:   str2bool(m["visible"]),
		}
		members, tags := x.parseRelation(str2int64(m["id"]))
		rel.Members_ = members
		rel.Tags_ = tags

		// fmt.Printf("RELATION=%q\n", rel)
		return rel, nil

	case "<osm":
		// fmt.Printf("OSM=%q\n", m)
	case "</osm>":
		// fmt.Printf("/OSM\n")
	case "<bounds":
		// fmt.Printf("BOUNDS=%q\n", m)
	default:
		// fmt.Printf("OTHER=%q\n", m)
	}
	return &xmlItem{t: item.TypeUnknown}, nil
}