Пример #1
0
// Opens a closed way (i.e. a way where the last node has the
// same id as the first one) at the node with the given id. A
// new node is inserted where the way is open. This new node
// will be the end of the current way -> the first node will
// not necessarily stay the first node
func (w *Way) OpenAt(id int64) (nn *node.Node, err error) {
	if !w.Closed() {
		return nil, errors.New("Cannot open non-closed way")
	}
	var i int
	var nd *node.Node
	last := len(w.Nodes_) - 1
	for i, nd = range w.Nodes_ {
		if nd.Id_ != id {
			continue
		}

		w.modified = true
		nn = node.New(nd.Position_)
		nn.Tags_ = nd.Tags_

		if i == 0 {
			w.Nodes_[last] = nn
			return nn, nil
		}

		nb, nl := w.Nodes_[:i], w.Nodes_[i:]
		nl = append(nl, nb...)
		w.Nodes_ = append(nl, nn)

		return nn, nil
	}

	return nil, errors.New(fmt.Sprintf("Node #%d not a member of way #%d", id, w.Id()))
}
Пример #2
0
// Splits a way and returns all resulting ways. For a closed way at least two
// node ids must be given. A resulting way must contain at least two nodes.
func (w *Way) Split(ids ...int64) (ws []*Way, err error) {
	var orig []*node.Node
	for _, n := range w.Nodes_ {
		orig = append(orig, n)
	}

	if w.Closed() {
		if len(ids) < 2 {
			err = errors.New("Not enough arguments to split a closed way")
			return
		}
		var id0 int64
		id0, ids = ids[0], ids[1:]
		_, err = w.OpenAt(id0)
		if err != nil {
			w.Nodes_ = orig
			return
		}
	}

	min_len := 2*len(ids) + 1
	if min_len > len(w.Nodes_) {
		w.Nodes_ = orig
		err = errors.New("Way has too few nodes to split")
		return
	}

	ws = []*Way{w}
	cur_w := w
	for _, id := range ids {
		// the node with the id "id" will be the last node of the current
		// way, a new node with the same position is inserted at the
		// beginning of the new way
		var nid int64
		nid, err = cur_w.NextNodeId(id)
		if err != nil {
			w.Nodes_ = orig
			ws = EmptyWays()
			err = errors.New(fmt.Sprintf("Node #%d not a member of way #%d", nid, w.Id()))
			return
		}
		for i, n := range cur_w.Nodes_ {
			if n.Id_ == nid {
				if i == 0 || i == len(cur_w.Nodes_)-1 {
					w.Nodes_ = orig
					ws = EmptyWays()
					err = errors.New("Cannot split way at first or last node")
					return
				}
				if i == 1 {
					w.Nodes_ = orig
					ws = EmptyWays()
					err = errors.New("Cannot split into a way with one node")
					return
				}

				nn := node.New(n.Position_)
				nn.Tags_ = n.Tags_
				nl := []*node.Node{nn}
				for _, nd := range cur_w.Nodes_[i:] {
					nl = append(nl, nd)
				}
				cur_w.Nodes_ = cur_w.Nodes_[0:i]
				var new_w *Way
				new_w, err = New(nl)
				if err != nil {
					w.Nodes_ = orig
					ws = EmptyWays()
					return
				}
				new_w.Tags_ = cur_w.Tags_
				ws = append(ws, new_w)
				cur_w = new_w
			}
		}
	}
	w.modified = true
	return ws, nil
}