barefootstache @barefootstache@qoto.org

#DailyBloggingChallenge (242/250)

The positional keyword `reverse|rev|-` is used to explain if either the mirrored or shapes are flipped. The direction of the flip is first on the vertical axis and then horizontal.

For the symmetric shapes `T, V, Y` it is obvious that adding `reverse` will flip it horizontal.

Further similarities with existing notations:

```
[ = rev]
```
```
] = rev[
```
```
L = right floor
```
```
revL = left floor
```
```
rev left floor = left ceil
```
```
rev right ceil = right floor
```

#DailyBloggingChallenge (241/250)

Sometimes the combo of positional with mirrored keywords is not enough, thus the shapes were introduced. These give the possibility to give a more concrete layout of the situation.

The situation can be an intersection of ways like seen with `T` or `Y`. Or it can highlight non-typical flow of the way seen with `L, V, ], [`.

This non-typical highlight does not conclude that there is no intersection of the way.

#DailyBloggingChallenge (240/250)

Now adding positional keywords to the mix, one defines the one-sided version of the mirrored keyword.

This means that

```
ceil = left ceil + right ceil
```

and respectively with `floor`.

Or more concretely `⌊ = left floor` and `⌋ = right floor`.

#DailyBloggingChallenge (239/250)

The mirror keywords are occasions when the same object exists on both sides of the reference object. In our case, the object is a _ditch_ and the reference object is a _path_.

- `both`, a generic notion that the object exists on both sides
- `ceil`, $⌈x⌉$, the object is on both sides and has a $⌉x⌈$ shape
- `floor`, $⌋x⌊$, the object is on both sides and has a $⌊x⌋$ shape

Typical examples where `ceil|floor` occur is when a highway yields (perpendicularly) into another highway or an intersection of two highways.

#DailyBloggingChallenge (238/250)

It was already introduced the cardinal directions for general positioning, though often these don't suffice when dealing with ditch positioning.

Thus three mirrored keywords are introduced: `both, ceil, floor` and three positional keywords: `left, right, reverse|rev|-` plus a wide range of shapes: `L,V, T, Y, [, ]`.

#DailyBloggingChallenge (237/250)

To simplify such crossings the following keywords are added for note taking:

- `culvert|c`
- `bridge <material>`, the material is added if it differs from the highway
- `ford`

For example, if a new path exist with a culvert than the note says `other pc` or `other p c`. Or on an existing highway one would just add `other c`.

#DailyBloggingChallenge (236/250)

There are (in general) three possible ditch crossings:

- `tunnel=culvert, layer=-1` for the ditch
- `bridge=yes, layer=1` for the highway
- `ford=yes` for the intersection between ditch and highway.

#DailyBloggingChallenge (235/250)

One of my #OpenStreetMap #MicroMapping areas is `waterway=ditch` mapping. In this realm one mainly needs to know the possible crossings, the water flow direction, and on which side of the highway it exists.

The flow direction is the trickiest of the three, since with the tag `intermittent=yes` one cannot depict directly the flow direction. The tag is used when the ditch is either dry or has little water across the year. This tag is optional, though since it exists, expect the outcome to meet such instances in the wild.

#DailyBloggingChallenge (234/250)

Thus eventually instead of using the generic note for a random topic, it was agreed upon that it denotes a path.

Though lately removed the ambiguous definition and hard defined the word `path|p`. This removes any potential guess work in the future.

A simple example of a perpendicular path is `other p` where as a more complex one could look like `other p sw` which equates to _a path that is going south west away from current highway_.

#DailyBloggingChallenge (233/250)

One thing that I have done in the past is have a topic per hike. This means I have a generic note that just says `other `. This is then connect to a quick action.

So if the topic e.g. are bird perches, then each of them will just be denoted with "other ".

This is all good for maybe up to a couple of days, though if notes first get resolved weeks in the future, then that detail is lost, thus the effort is gone.

#DailyBloggingChallenge (232/250)

While on the topic of barriers, these typically have a start and end. One could attempt to use the starting letter of _start_ and one would realize that `s` has already been declared for _south_. Likewise doing for _end_, one gets `e` which is used for _east_.

For this conundrum one can look at the Greek alphabet and use the first and last letter. They are alpha and omega making it `a` and `o`.

Example of a railing south of the path. The start of railing: `railing s a` and respectively for the end: `railing s o`.

#DailyBloggingChallenge (231/250)

Another typical example are railings or fences along a path. Since one barely ever knows which direction the way is going, thus a safer approach is to use the cardinal directions to denote a one-sided barrier.

Caveats are more obvious cases like steps, where usually `incline=up` aligns with the way's direction. In this case `left|l` and respectively `right|r` are used.

#DailyBloggingChallenge (230/250)

The first shorthand note are the cardinal directions denoted as `n`, `e`, `s`, and `w`.

These can be combined together to create more concrete directions like `ne`, `se`, `sw`, or `nw`. Or even more specific `nne`, `een`, `ees`, `sse`, `ssw`, `wws`, `wwn`, `nnw`.

An use-case is to denote more specifically where an object should be positioned relative to a way or an area. So if e.g. a path does not exist yet which branches off the current path and it is not perpendicular to the current path, then these directions can help to map the initial path head.

Hint: make sure to add the `fixme` key at the path's tail to check if the path continues. The most simplest value is `continue?`.

#OpenStreetMap

#DailyBloggingChallenge (229/250)

In the past, I already wrote a blog on how to create _quick actions_ in #OsmAnd: https://bf5.eu/post/osm/how-to-quick-map-with-osmand/ and for the next couple of entries regarding shorthand note system (that I use), the notes are created in such a way that a quick action cannot replace it.

That being said, kind of wish OsmAnd had quick action presets, so that one can quickly ease the sorting of the quick actions when in various situations. Like in urban terrain fire hydrants and street cabinets are more frequent, where as in comparison in rural terrain the frequency of hunting stands and feeding places are higher.

#DailyBloggingChallenge (228/250)

In the past, I uploaded the notes to the server and have (an outdated) note interpreter for my shorthand notes: https://www.openstreetmap.org/user/barefootstache

Though these days, I only push notes if they are obvious and/or I am using a specific app that does not permit offline notes. Like being a bit too fast with floors or type of building in #StreetComplete, though the new buildings overlay should take care of this issue in the past.

#DailyBloggingChallenge (227/250)

Onto the in person mappers comes the goal factor. This means is the goal just _to map_ or is the goal _to get to a specific destination_.

If it's the latter then one needs to manage between achieving the goal while mapping on the fly. For such cases there are many apps that can achieve the _updater_ aspect without losing too much time mapping. To name a few #StreetComplete or #EveryDoor.

In the _manager_ aspect the mentioned apps can help or #SCEE or #OsmAnd or #Vespucci.

Though many times one doesn't have enough time to navigate through the apps to accomplish the desired outcome. Thus jotting a note down or taking a photo can quickly save the details and later when more allotted time exists they can be updated.

#OpenStreetMap

#DailyBloggingChallenge (226/250)

One is usually a combination of the three kinds of mappers: creators, updaters, and managers.

Typically, one starts as an updater. Then once one is comfortable of knowing which objects exist, one adds creator to the mix. And finally once even more confident of the correct data format, one adds manager.

#DailyBloggingChallenge (225/250)

When doing #OpenStreetMap in person, there are typically three kinds of mappers: creators, updaters, and managers.

A _creator_ is a mapper who creates new objects. Predominantly by adding amenities like POIs or more specifically: benches, waste bins, fire hydrants, street cabinets, etc.

An _updater_ is a mapper who updates existing objects by adding missing data to complete the object. Most of #StreetComplete quests fall into this category.

A _manager_ is a mapper who edits existing objects. This means that at least one key-value pair is incorrect. A typical example is that the opening hours are outdated. Other cases are updating highway or other line based objects like waterways, or updating land covers.

#DailyBloggingChallenge (224/250)

Got to try out the new building overlay feature on #StreetComplete. It quickens the choosing of the building values and eases the option of updating them as well.

IMO, the icons of the buildings feel a bit small and could use the white space better.