[OSM-talk] Introducing SwiftAddress, an highly efficient way of collecting housenumbers

[ipswichmapper at tutanota.com]

There are many, may reasons why SwiftAddress is an app worth developing even when Vespucci exists.

Firstly, to add addresses in Vespucci, you have to long press on the location, press the address button then press okay. That is three presses. In SwiftAddress, you simply have to long press to add a housenumber (assuming you have set the increment correctly). This automatically saves 2 presses.

Now this doesn't sound like a lot, however, when you are trying to map 1000s of addresses by foot, every single bit of efficiency matters. If you want as many addresses in OSM as possible, you should be looking to create tools that are as efficient as physically possible.

Vespucci has a very complicated UI (it doesn't even let you add housenumbers on install, you have to disable "simply mode"). This means a lot of things:

- Valuable screen space is wasted on unnecessary buttons. This means the app is less effiicient at mapping housenumbers. Remember, if you are surveying housenumbers by foot, it is such a tedious task that 90% of the survey is just collecting the housenumbers. The occasional shop/amenity can easily be marked with a photo note.
- The barrier to entry for understanding and using this app is unecessary high due to how complicated it is.  You do not need an app this complicated to map housenumbers. If you want many people to survey, you should not require them to use something complicated like Vespucci.
- Performance is slow. For prediction to work, you have to download data. This slows down the app when you try and scroll. Performace isn't that great. Compared to this, SwiftAddress only needs to show a slippy map (so it won't be slow).
- Map is cluttered. There are tons of elements you do not need to see, cluttering the map and making is harder to map and see the housenumbers you have mapped. Compared to this, SwiftAddress shows only a slippy map and the housenumber markers you have added very clearly, whereas on Vespucci it is just another node with a number in it (lot less contrast).

So, if you want as many housenumbers to be mapped in OSM as possible, you if you want OSM data to be more accurate, you should ideally not have to use an app that isn't as efficient as possible and has a cluttered UI and high barrier for entry.

This app is not fragmenting the mobile editor marketplace at all. This app is written as a replacement for Keypad Mapper 3 when I found that Keypad-Mapper 3 is woefully inadequate. The moment SwiftAddress becomes useable, there will be no reason to use Keypad Mapper 3 (since this does the exact same thing but much better). Therefore, the number of mobile editor apps stays the same.

This app is not fragmenting the developer resources either. This app is the first proper application I have written. Before this, the most programming I did was CLI applications and tkinter in Python. Therefore, if I tried to jump head first into contributing to Vespucci, I would have absolutely no clue on what to do. In fact, I still probably will struggle to understand Vespucci, because it's code if far more complicated than SwiftAddress's. 

Compared to this, trying to develop an app from scratch was much easier, and it taught me basic android development. For example, the first thing I did, add a few keypad buttons, and make them add a number to the textbox, was very simple. From there, I gradually started adding more and more complex features. As my skills gradually increased I could add more and more features.

As an analogy, developing SwiftAddress has been like playing a video game from the start, doing each level, while trying to improve Vespucci with no previous development is trying to do the final boss battle of the video game with no prior practise (i.e. it wouldn't have been possible).

So all in all if I hadn't written SwiftAddress I would have written nothing at all.

Furthermore, there are many, many things where a dedicated housenumber application is much better at than Vespucci. 

In Russia, housenumbers follow this format: "48А к2 с1" (meaning housenumber "48A", building "2", construction "1"). I could write a layout which makes it very easy to map something like this efficiently (I have already created mockups on paper). On Vespucci, however, it won't be nearly as efficient. It won't really be able to predict that either.

In Czech Republic, there are "conscription numbers". Again, I could write a Czech Republic specific layout (although this isn't that useful because it seems that addresses have been imported there).

In many countries around the world, there isn't such a formal system of housenumber and streetname, but more complicated & confusing address systems, or even addresses referring to nearest junction names instead of nearest street names. Again, I could write layouts that make it efficient to specifically add addresses in those countries.

Furthermore, the app also allows you to quickly map building levels (by swiping up on one of the keys in the keypad, and in future by swiping up/ double tapping on the arrow). Vespucci cannot quickly add building levels. You have manually type out the tags & number, or find the preset. 

Building heights give a more accurate picture when in 3D navigation and other 3D maps. It is data you cannot see on aerial imagery, so you need to survey to get. Yes, you van get this data by taking photos from mapillary.

Soon enough, I will add ability to quickly create an interpolation line between two addresses in SwiftAddress. All you will do is click on a house, tap interpolate, and then connect the line with the other address. Can Vespucci easily create such addr:interpolation? No, you would have to type out the tags and values.

Those are just some of the features I thought of where a dedicted housenumber survey application is easily more efficient then a complicated generalised editor. There are probably more: the point I want to make is it is definately work creating a specialized housenumber app.

And yes, Internationalisation and Localisation is definately an issue. Dispite the fact that there are not that many strings in this app anyway, lets say (worst case scenario), that no one wanted to translate this app. Well in that case, it would still be very useful in the UK, where the government refuses to release housenumber data. Here, an app like SwiftAddress, if used enough, could add millions of addresses to the database. 

Just as reference, in a relatively long survey (1hr+), I can collect about 500 house-numbers or even more. To collect a million addresses, it would only take 2000 surveys of these surveys to get a million housenumbers. So just 400 people doing five of these surveys would do that. 

Even in the "worst worst" case scenario, where this app is useless and Vespucci is better in every single way, at least I learnt some android development. At least I learnt how to structure a project that is longer than just 50 lines of code. I could then use those Android Development skills to improve another OSM editing application.

Thanks,
IpswichMapper
--  

23 Jan 2021, 10:20 by simon at poole.ch:

>
> I don't quite understand why, outside of a specialized keyboard,      you are reinventing the wheel (and fragmenting available      development resources, OK, I suppose that is one of the hallmarks      of OSM development which unluckily get rewarded time and time      again). Vespucci:
>
>
> - allows you to directly enter address for upload, aka enter      once, no 2nd pass needed at home
>
>
> - automatically will download data (so that you don't      accidentally duplicate existing addresses)
>
>
> - can highlight missing tags, for example addresses
>
>
> - has all the background and overlay layers from ELI available 
>
>
> - has address prediction that will automatically detect odd /      even address schemes and increment and is street side aware
>
>
> - allows you to configure which address tags should be set on      addresses (this tends to be a question of national preference)
>
>
> - handles addr:street and addr:place 
>
>
> - seeds address tags values from existing data
>
>
> - and many other things like conflict resolution and so on.
>
>
> All since more than half a decade (actually 7 years).
>
>
> Yes, as said, it is true that it doesn't have a specialized      keyboard, but as you typically only have to type in a small number      of numbers per street, if any at all, the pain isn't really large      enough to offset the complexity caused by i18n support that would      be required. But we even have an issue for that > https://github.com/MarcusWolschon/osmeditor4android/issues/574>  and      if somebody wants to put the effort (see i18n problems) a PR would      be gladly accepted.
>
>
> Simon
>
>
>
>
> Am 22.01.2021 um 12:25 schrieb      ipswichmapper--- via talk:
>
>> Hello openstreetmap community, 
>>
>> I have been writing an android application that should make        it significantly easier to collect housenumbers. 
>>
>> Now, finally, I have released an apk on Github (you'll find        it under the "assets" tab):
>>
>> https://github.com/IpswichMapper/SwiftAddress/releases
>>
>> Make sure you check the releases page because I'll be          releasing updates that improve functionality and fix bugs.
>>
>> I have written about the app in more detail in my diary        entry:
>>
>> https://www.openstreetmap.org/user/IpswichMapper/diary/395413
>>
>> The app starts up as a simple OSMdroid map. The way you place        housenumbers is by moving the crosshair (which is in the middle        of the screen) above the building outline of the housenumber you        are trying to map. You then add the housenumber using the        keypad.
>>
>> The advantage of this is that the housenumbers are already in        the right place when surveying. There is no need to clean up the        messy data (like with Keypad Mapper 3) or draw housenumbers        (like with Streetcomplete). All that needs to be done is to load        the data into JOSM and then upload. (In the future direct upload        might be supported). 
>>
>> Of course, most times building outlines aren't drawn in OSM,        so you can't tell from OSM imagery where the postition of the        building/house is. For this I plan on implementing satellite        background imageries into the app, so that you can use that to        find the position of the house. (I need to know how to implement        that first, however, and what imagery/tms I can use)
>>
>> You can also has a few more features, for example,        auto-incrementing, and the ability to take notes. I have        described the app in more detail in the diary entry. 
>>
>> Thanks,
>> IpswichMapper
>>
>> _______________________________________________talk mailing list>> talk at openstreetmap.org>> https://lists.openstreetmap.org/listinfo/talk
>>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.openstreetmap.org/pipermail/talk/attachments/20210125/1c3f5d44/attachment-0001.htm>