[Tagging] SEGMENT

A.Pirard.Papou A.Pirard.Papou at gmail.com
Fri Nov 30 16:36:32 GMT 2012


Hi,

The more I tag, the more I read these lists, the more I think: If we 
could use SEGMENT...
I'll just sketch the idea. It has several implications to be discussed. 
So, I refrained from making an incorrect or incomplete proposition, but 
an /in construction/ one would be fine.
The best idea is to keep the idea in mind and imagine it in various 
situations as they arise.

We don't like splitting ways, finding unnecessarily splits, fearing to 
unsplit wrongly.
We don't like to have to make hard-to-the-novice relations just because 
we split.
A very typical example is this:
      |
      ------
      |
------
      |
I was mapping hiking routes relations and I was utterly disgusted to 
split in every places.
Here, the vertical very main road was split over 50 m just because of 
two misaligned paths.

So, why not avoid splitting in the first place?

*segment* <reference>
is a tag meaning that the tags of the pseudo way it defines must be 
merged over the /*segment*/'s span with the tags of the home way 
<reference> that /*segment*/ overlaps.
It shares the nodes of its home way of which it modifies the tags 
between its 2 end nodes.
Example: if a street (---) is one-way on only some span, we can add a 
segment (+++), a way over that span, (---------++++++++-----------) 
containing

|segment=<reference>
oneway=yes|

||possibly (1) for a bridge

|||segment=<reference>
bridge=yes
name=?
|

||in the "typical example" above:

|||segment=<reference>
|

because the segment is kinda brandless plaster changing absolutely 
nothing to the road but being included in the relation.

A segment must not contain tags that belongs to the home way, just what 
to change in it.
There may be restrictions to what can be in a segment (no paramount keys?).

Basically, what a segment may mean for the renderer (pardon me) is to 
internally split the home way at the segment's ends, to apply the 
segment tags to the so-created way, and to forget about the segment.
The segment however retains its existence when it comes to include it in 
a relation. In that case, the segment may be considered as an alias of 
the "so-created way".
Depending on what they do, programs that process the data should process 
segments (as they presently should process relation recursion).
Segments however are real parts of the database, transmitted as such to 
an editor for which the importance is essential.

A key aspect of a segment is that it highlights clearly its reason for 
being (plus, note=* can't be used but segment_note can ;-)). Presently 
knowing why a way is split requires "diff"ing it with an eagle eye.

Issues:

I'm unsure or what <reference> must be (I once thought of using layer#; 
bad idea)

recursivity: can a segment <reference> another segment?
That can be useful for example in case of a 30 km/h overriding a 50 km/h 
speed limit.

priority: what if two segments alter the main way contradictorily?
priority is another way to solve the speed limit example, but it needs 
an eagle eye.

negation: has every tag a way to zap it to default value?
Or should we invent a no:tag=* ?

size: does a segment need to repeat every nodes of the home way or do 
the 2 ends suffice?
Could it span over several ways (<reference> issue)?
Note=that a street which is usually thought of as what has a same name= 
can easily become a what-it-looks-like object, e.g. long avenue or whole 
circular road, by /*segment*/ing name=.
Hence, segment could be used as a sort of  mini easy relation.

progressiveness: could /*segment */be deployed in steps,

you name it: ???

That's what keeps roving in my mind and that I would like to replace by 
peace :-)

Cheers,

André.


(1) if we consider the bridge as an attribute of the road (bridg*ed*).
If we consider it as an object, it should overlay the non-interrupted 
road at level -1.
A bridge is a piece of concrete supporting an non-interrupted tarmac foil.
The renderer (pardon me) can draw a full solid bridge hidden by the road 
instead of, if at level 2, side rails with transparent central part.

PS: This said, I independently wonder why roads are interrupted at a bridge.
As I've just said, a bridge is just an additional object under a road at 
level -1.
Similarly, a tunnel is above the way at level +1, and what's above it 
should better be semi-transparent over some width across the way.
I have mapped without any problem many km of uninterrupted streams at 
best level -2, and passing under culverts and bridges that are at level -1.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.openstreetmap.org/pipermail/tagging/attachments/20121130/23abc81a/attachment.html>


More information about the Tagging mailing list