[mkgmap-dev] [PATCH] POI Address Support v6 R942

28 Feb 2009

Hi,

here is the updated POI address patch for the current trunk R942:

- Poi address information is now added by default
-- Option -no-poi-address added to switch the feature off
- Check if zip tag contains a list of zips added
- By default heuristic is disabled. Exception are:
-- Name of nearest city is added to street POIs (if street POIs are enabled)
-- If POI contains a city name tag. Country region info is taken from 
city with same name in the neighborhood
- You can use the --location-autofill=X option to enable heuristic if 
you like

Thanks
Berni.



Index: src/uk/me/parabola/imgfmt/app/trergn/TREHeader.java
===================================================================

--- src/uk/me/parabola/imgfmt/app/trergn/TREHeader.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/trergn/TREHeader.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -236,6 +236,10 @@
 	public void setMapId(int id) {
 		mapId = id;
 	}
+	
+	public void setPoiDisplayFlags(byte poiDisplayFlags) {
+		this.poiDisplayFlags = poiDisplayFlags;
+	}	
 
 	public int getMapInfoSize() {
 		return mapInfoSize;
Index: src/uk/me/parabola/imgfmt/app/trergn/TREFile.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/trergn/TREFile.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/trergn/TREFile.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -315,6 +315,10 @@
 		header.setBounds(area);
 	}
 
+	public void setPoiDisplayFlags(byte b) {
+		header.setPoiDisplayFlags(b);
+	}	
+
 	public String[] getCopyrights() {
 		if (!isReadable())
 			throw new IllegalStateException("not open for reading");
Index: src/uk/me/parabola/imgfmt/app/lbl/POIRecord.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/lbl/POIRecord.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/lbl/POIRecord.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -16,6 +16,7 @@
  */
 package uk.me.parabola.imgfmt.app.lbl;
 
+import java.util.Vector;
 import uk.me.parabola.imgfmt.app.ImgFileWriter;
 import uk.me.parabola.imgfmt.app.Label;
 
@@ -23,6 +24,94 @@
  * @author Steve Ratcliffe
  */
 public class POIRecord {
+
+  class SimpleStreetPhoneNumber // Helper Class to encode Street Phone Numbers
+	{
+		/**
+			Street and Phone numbers can be stored in two different ways in the poi record
+			Simple Number that only contain digits are coded in base 11 coding. 
+			This helper	class tries to code the given number. If the number contains other
+			chars like in 4a the coding fails and the caller has to use a Label instead
+		*/
+	
+		private byte encodedNumber[] = null;
+		private int  encodedSize = 0;
+		
+		public boolean set(String number)
+		{
+			int i = 0;
+			int j = 0;
+			int val = 0;
+
+			// remove sourounding whitespaces to increase chance for simple encoding
+
+			number = number.trim();  
+
+			encodedNumber  = new byte[(number.length()/2)+2];
+				
+			while(i < number.length())
+			{
+				int c1 = 0;
+				int c2 = 0;
+
+				c1 = decodeChar(number.charAt(i));
+				i++;
+ 
+				if(i < number.length())
+				{
+					c2 = decodeChar(number.charAt(i));
+					i++;
+				}
+				else
+					c2 = 10;
+	
+				if(c1 < 0 || c1 > 10 || c2 < 0 || c2 > 10) // Only 0-9 and - allowed
+				{
+					return false;
+				}
+
+				val = c1 * 11 + c2;  							// Encode as base 11
+ 
+				if(i < 3 || i >= number.length())  // first byte needs special marking with 0x80
+					val = val | 0x80;							 // If this is not set would be treated as label pointer
+
+				encodedNumber[j++] = (byte)val;	
+			}
+			
+			if((val & 0x80) == 0 || i < 3)  // terminate string with 0x80 if not done 
+			{
+				val = 0xF8;
+				encodedNumber[j++] = (byte)val;
+			}
+			
+			encodedSize  = j;
+			
+			return true;
+		}
+		
+		public void write(ImgFileWriter writer)
+		{
+			for(int i = 0; i < encodedSize; i++)
+				writer.put(encodedNumber[i]);
+		}
+		
+		public boolean isUsed()
+		{
+			return (encodedSize > 0);
+		}
+		
+		public int getSize()	
+		{
+			return encodedSize;
+		}
+		
+		private int decodeChar(char ch)
+		{		
+			return (ch - '0');
+		}
+		
+	}
+
 	public static final byte HAS_STREET_NUM = 0x01;
 	public static final byte HAS_STREET     = 0x02;
 	public static final byte HAS_CITY       = 0x04;
@@ -43,13 +132,16 @@
 	private int offset = -1;
 	private Label poiName;
 
-	private int streetNumber;
+	private SimpleStreetPhoneNumber simpleStreetNumber = new SimpleStreetPhoneNumber();
+	private SimpleStreetPhoneNumber simplePhoneNumber = new SimpleStreetPhoneNumber();
+
 	private Label streetName;
 	private Label streetNumberName; // Used for numbers such as 221b
+	private Label complexPhoneNumber; // Used for numbers such as 221b
+	
+	private City city = null;
+	private char zipIndex  = 0;
 
-	private char cityIndex ;
-	private char zipIndex  ;
-
 	private String phoneNumber;
 
 	public void setLabel(Label label) {
@@ -60,14 +152,35 @@
 		this.streetName = label;
 	}
 	
+	public boolean setSimpleStreetNumber(String streetNumber) 
+	{
+		return simpleStreetNumber.set(streetNumber);
+	}
+	
+	public void setComplexStreetNumber(Label label) 
+	{
+		streetNumberName = label;
+	}
+	
+	public boolean setSimplePhoneNumber(String phone) 
+	{
+		return simplePhoneNumber.set(phone);
+	}
+	
+	public void setComplexPhoneNumber(Label label) 
+	{
+		complexPhoneNumber = label;
+	}
+	
+	
 	public void setZipIndex(int zipIndex)
 	{
 		this.zipIndex =  (char) zipIndex;
 	}
 	
-	public void setCityIndex(int cityIndex)
+	public void setCity(City city)
 	{
-		this.cityIndex  = (char) cityIndex;
+		this.city = city;
 	}
 
 	void write(ImgFileWriter writer, byte POIGlobalFlags, int realofs,
@@ -82,11 +195,21 @@
 		if (POIGlobalFlags != getPOIFlags())
 			writer.put(getWrittenPOIFlags(POIGlobalFlags));
 
+		if (streetNumberName != null)
+		{
+			int labOff = streetNumberName.getOffset();
+			writer.put((byte)((labOff & 0x7F0000) >> 16));
+			writer.putChar((char)(labOff & 0xFFFF));
+		}
+	   else if (simpleStreetNumber.isUsed())
+		   simpleStreetNumber.write(writer);
+
 		if (streetName != null)
 			writer.put3(streetName.getOffset());
 			
-		if (cityIndex > 0)
+		if (city != null)
 		{
+			char cityIndex = (char) city.getIndex();
 			if(numCities > 255)
  			  writer.putChar(cityIndex);
 			else
@@ -100,44 +223,60 @@
 			else
 			 writer.put((byte)zipIndex);
 		}
+		
+		if (complexPhoneNumber != null)
+		{
+			int labOff = complexPhoneNumber.getOffset();
+			writer.put((byte)((labOff & 0x7F0000) >> 16));
+			writer.putChar((char)(labOff & 0xFFFF));
+		}
+	   	else if (simplePhoneNumber.isUsed())
+		   simplePhoneNumber.write(writer);		
 	}
 
 	byte getPOIFlags() {
 		byte b = 0;
 		if (streetName != null)
 			b |= HAS_STREET;
-		if (cityIndex > 0)
+		if (simpleStreetNumber.isUsed() || streetNumberName != null)
+		   b |= HAS_STREET_NUM;
+		if (city != null)
 		        b |= HAS_CITY;
 		if (zipIndex > 0)
-		        b |= HAS_ZIP;			
+		        b |= HAS_ZIP;	
+		if (simplePhoneNumber.isUsed() || complexPhoneNumber != null)
+		   b |= HAS_PHONE;				  		
 		return b;
 	}
 	
 	byte getWrittenPOIFlags(byte POIGlobalFlags) 
 	{
-	    int mask;
-	    int flag = 0;
-	    int j = 0;
+			int mask;
+			int flag = 0;
+			int j = 0;
 	
-	    int usedFields = getPOIFlags();
+			int usedFields = getPOIFlags();
 	
-	    /* the local POI flag is really tricky
-	       if a bit is not set in the global mask
-	       we have to skip this bit in the local mask.
-	       In other words the meaning of the local bits
-	       change influenced by the global bits */
+			/* the local POI flag is really tricky if a bit is not set in the global mask
+					we have to skip this bit in the local mask. In other words the meaning of the local bits
+					change influenced by the global bits */
+	
+			for(byte i = 0; i < 6; i++)
+			{
+				mask =  1 << i;
 
-		for (byte i = 0; i < 6; i++) {
-			mask = 1 << i;
-
-			if ((mask & POIGlobalFlags) == mask) {
-				if ((mask & usedFields) == mask)
-					flag |= (1 << j);
-				j++;
+				if((mask & POIGlobalFlags) == mask)
+				{
+					if((mask & usedFields) == mask)
+						flag = flag | (1 << j);
+					j++;
+				}
+		
 			}
 
-		}
-	    return (byte) flag;
+			flag = flag | 0x80; // gpsmapedit asserts for this bit set
+	    
+			return (byte) flag;
 	}
 
 	/**
@@ -150,9 +289,17 @@
 		int size = 3;
 		if (POIGlobalFlags != getPOIFlags())
 			size += 1;
+		if (simpleStreetNumber.isUsed())		
+			size += simpleStreetNumber.getSize();
+		if (streetNumberName != null)
+			size += 3;
+		if (simplePhoneNumber.isUsed())		
+			size += simplePhoneNumber.getSize();			
+		if (complexPhoneNumber != null)
+			size += 3;			
 		if (streetName != null)
-			size += 3;
-		if (cityIndex > 0) 
+			size += 3;	
+		if (city != null) 
 		{
 			/*
 			  depending on how many cities are in the LBL block we have
@@ -160,9 +307,9 @@
 			*/
 		
 			if(numCities > 255)
-	  		  size += 2;
+				size += 2;
 			else
-			  size += 1;
+				size += 1;
 		}
 		if (zipIndex > 0)
 		{
Index: src/uk/me/parabola/imgfmt/app/lbl/PlacesFile.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/lbl/PlacesFile.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/lbl/PlacesFile.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -20,6 +20,8 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
 
 import uk.me.parabola.imgfmt.app.ImgFileWriter;
 import uk.me.parabola.imgfmt.app.Label;
@@ -33,7 +35,8 @@
 public class PlacesFile {
 	private final Map<String, Country> countries = new LinkedHashMap<String, Country>();
 	private final Map<String, Region> regions = new LinkedHashMap<String, Region>();
-	private final List<City> cities = new ArrayList<City>();
+	private final Map<String, City> cities = new LinkedHashMap<String, City>();
+	private final SortedMap<String, City> cityList = new TreeMap<String, City>();
 	private final Map<String, Zip> postalCodes = new LinkedHashMap<String, Zip>();
 	private final List<POIRecord> pois = new ArrayList<POIRecord>();
 
@@ -62,8 +65,12 @@
 			r.write(writer);
 		placeHeader.endRegions(writer.position());
 
-		for (City c : cities)
+		for (String s : cityList.keySet())
+		{
+			City c = cityList.get(s);
 			c.write(writer);
+		}
+
 		placeHeader.endCity(writer.position());
 
 		int poistart = writer.position();
@@ -79,56 +86,122 @@
 	}
 
 	Country createCountry(String name, String abbr) {
-		Country c = new Country(countries.size()+1);
-
+	
 		String s = abbr != null ? name + (char)0x1d + abbr : name;
+			
+		Country c = countries.get(s);
+	
+		if(c == null)
+		{
+		   c = new Country(countries.size()+1);
 
-		Label l = lblFile.newLabel(s);
-		c.setLabel(l);
-
-		countries.put(name, c);
+		   Label l = lblFile.newLabel(s);
+		   c.setLabel(l);
+   		 countries.put(s, c);
+		}
 		return c;
 	}
 
 	Region createRegion(Country country, String name, String abbr) {
-		Region r = new Region(country, regions.size()+1);
-
+	
 		String s = abbr != null ? name + (char)0x1d + abbr : name;
 
-		Label l = lblFile.newLabel(s);
-		r.setLabel(l);
-
-		regions.put(name, r);
+		String uniqueRegionName = s.toUpperCase().concat(Long.toString(country.getIndex()));	
+	
+		Region r = regions.get(uniqueRegionName);
+		
+		if(r == null)
+		{
+		  r = new Region(country, regions.size()+1);
+		  Label l = lblFile.newLabel(s);
+		  r.setLabel(l);
+		  regions.put(uniqueRegionName, r);
+		}
 		return r;
 	}
 
-	City createCity(Country country, String name) {
-		City c = new City(country, cities.size()+1);
+	City createCity(Country country, String name, boolean unique) {
+		
+		String uniqueCityName = name.toUpperCase().concat("_C").concat(Long.toString(country.getIndex()));
+		
+		City c = null;
 
-		Label l = lblFile.newLabel(name);
-		c.setLabel(l);	// label may be ignored if pointref is set
+		if(!unique)
+			c = cities.get(uniqueCityName);
+		
+		if(c == null)
+		{
+			c = new City(country);
 
-		cities.add(c);
+			Label l = lblFile.newLabel(name);
+			c.setLabel(l);
+
+			/*
+				 Adding 0 in between is important to get right sort order !!!
+				 We have to make sure that "Kirchdorf" gets sorted before "Kirchdorf am Inn"
+				 If this order is not correct nuvi would not find right city
+			*/
+
+		  cityList.put(name + " 0" + c, c);
+			cities.put(uniqueCityName, c);
+		}
+
 		return c;
-	}
+  }
 
-	City createCity(Region region, String name) {
-		City c = new City(region, cities.size()+1);
+	City createCity(Region region, String name, boolean unique) {
+		
+		String uniqueCityName = name.toUpperCase().concat("_R").concat(Long.toString(region.getIndex()));
+		
+		City c = null;
 
-		Label l = lblFile.newLabel(name);
-		c.setLabel(l);	// label may be ignored if pointref is set
+		if(!unique)
+			c = cities.get(uniqueCityName);
+		
+		if(c == null)
+		{
+		   c = new City(region);
 
-		cities.add(c);
+			Label l = lblFile.newLabel(name);
+			c.setLabel(l);
+
+			/*
+				 Adding 0 in between is important to get right sort order !!!
+				 We have to make sure that "Kirchdorf" gets sorted before "Kirchdorf am Inn"
+				 If this order is not correct nuvi would not find right city
+			*/
+
+			cityList.put(name + " 0" + c, c); 
+			cities.put(uniqueCityName, c);
+		}
+
 		return c;
 	}
 
+	private void sortCities()
+	{
+		int index = 1;
+
+		for (String s : cityList.keySet())
+		{
+			City c = cityList.get(s);
+			c.setIndex(index++);
+		}
+	}
+
 	Zip createZip(String code) {
-		Zip z = new Zip(postalCodes.size()+1);
+	
+		Zip z = postalCodes.get(code);
+		
+		if(z == null)
+		{
+	  	   z = new Zip(postalCodes.size()+1);
 
-		Label l = lblFile.newLabel(code);
-		z.setLabel(l);
+		   Label l = lblFile.newLabel(code);
+		   z.setLabel(l);
 
-		postalCodes.put(code, z);
+		   postalCodes.put(code, z);
+ 	        }
 		return z;
 	}
 
@@ -146,6 +219,9 @@
 	}
 
 	void allPOIsDone() {
+
+		sortCities();
+
 		poisClosed = true;
 
 		byte poiFlags = 0;
Index: src/uk/me/parabola/imgfmt/app/lbl/City.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/lbl/City.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/lbl/City.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -30,7 +30,7 @@
 	private static final int POINT_REF = 0x8000;
 	private static final int REGION_IS_COUNTRY = 0x4000;
 
-	private final int index;
+	private int index = -1;
 
 	private final Region region;
 	private final Country country;
@@ -49,13 +49,13 @@
 	// null if the location is being specified.
 	private Label label;
 
-	public City(Region region, int index) {
+	public City(Region region) {
 		this.region = region;
 		this.country = null;
 		this.index = index;
 	}
 
-	public City(Country country, int index) {
+	public City(Country country) {
 		this.country = country;
 		this.region = null;
 		this.index = index;
@@ -83,9 +83,15 @@
 	}
 
 	public int getIndex() {
+		if (index == -1)
+			throw new IllegalStateException("Offset not known yet.");
 		return index;
 	}
 
+	public void setIndex(int index) {
+		this.index = index;
+	}
+
 	public void setLabel(Label label) {
 		pointRef = false;
 		this.label = label;
Index: src/uk/me/parabola/imgfmt/app/lbl/LBLFile.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/lbl/LBLFile.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/lbl/LBLFile.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -147,14 +147,18 @@
 	    return places.createRegion(country, region, abbr);
 	}
 	
-	public City createCity(Region region, String city) {
-		return places.createCity(region, city);
+	public City createCity(Region region, String city, boolean unique) {
+		return places.createCity(region, city, unique);
 	}
 
-	public City createCity(Country country, String city) {
-		return places.createCity(country, city);
+	public City createCity(Country country, String city, boolean unique) {
+		return places.createCity(country, city, unique);
 	}
 
+	public Zip createZip(String code) {
+		return places.createZip(code);
+	}
+
 	public void allPOIsDone() {
 		places.allPOIsDone();
 	}
Index: src/uk/me/parabola/imgfmt/app/map/Map.java
===================================================================
--- src/uk/me/parabola/imgfmt/app/map/Map.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/imgfmt/app/map/Map.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -225,6 +225,14 @@
 		treFile.addPolygonOverview(ov);
 	}
 
+	/**
+	 * Set the point of interest flags.
+	 * @param flags The POI flags.
+	 */
+	public void setPoiDisplayFlags(int flags) {
+		treFile.setPoiDisplayFlags((byte) flags);
+	}
+
 	public void addMapObject(MapObject item) {
 		rgnFile.addMapObject(item);
 	}
Index: src/uk/me/parabola/mkgmap/build/MapPointMultiMap.java
===================================================================
--- src/uk/me/parabola/mkgmap/build/MapPointMultiMap.java	(.../upstream/mkgmap)	(revision 0)
+++ src/uk/me/parabola/mkgmap/build/MapPointMultiMap.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2009 Bernhard Heibler
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ * 	This is multimap to store city information for the Address Locator
+ *
+ *
+ * Author: Bernhard Heibler
+ * Create date: 02-Jan-2009
+ */
+
+package uk.me.parabola.mkgmap.build;
+
+
+import java.util.Vector;
+import java.util.HashMap;
+import java.util.Collection;
+import uk.me.parabola.mkgmap.general.MapPoint;
+
+class MapPointMultiMap{
+
+	private final java.util.Map<String,Vector<MapPoint>> map  = new HashMap<String,Vector<MapPoint>>();
+
+	public MapPoint put(String name, MapPoint p)
+	{
+		Vector<MapPoint> list;
+		
+		list = map.get(name);
+		
+		if(list == null){
+
+		   list = new Vector<MapPoint>();
+		   list.add(p);		
+		   map.put(name, list);
+		}
+		else
+		   list.add(p);
+		
+		return p;
+	}
+
+	public MapPoint get(String name)
+	{
+		Vector<MapPoint> list;
+		
+		list = map.get(name);
+		
+		if(list != null)		
+				return list.elementAt(0);
+		else
+		  return null;
+	}
+	   
+	public Collection<MapPoint> getList(String name)
+	{
+		return map.get(name);
+	}
+}
\ No newline at end of file
Index: src/uk/me/parabola/mkgmap/build/Locator.java
===================================================================
--- src/uk/me/parabola/mkgmap/build/Locator.java	(.../upstream/mkgmap)	(revision 0)
+++ src/uk/me/parabola/mkgmap/build/Locator.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -0,0 +1,474 @@
+/*
+ * Copyright (C) 2009 Bernhard Heibler
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  The Locator tries to fill missing country, region, postal coude information
+ *
+ *	The algorithm works like this:
+ *
+ *	1. Step: Go through all cities an check if they have useful country region info
+ *	The best case is if the tags is_in:country and is_in:county are present thats easy.
+ *	Some cities have is_in information that can be used. We check for three different 
+ *	formats:
+ *
+ *	County, State, Country, Continent
+ *	County, State, Country
+ *	Continent, Country, State, County, ...
+ *
+ *	In "openGeoDb countries" this info is pretty reliable since it was imported from a 
+ *	external db into osm. Other countries have very sparse is_in info.
+ *
+ *	All this cities that have such info will end up in "city" list. All which lack 
+ *	such information in "location" list.
+ *
+ * 	2. Step: Go through the "location" list and check if the is_in info has some relations 
+ *	to the cities we have info about.
+ *
+ *	Especially hamlets often have no full is_in information. They only have one entry in 
+ *	is_in that points to the city they belong to. I will check if I can find the name 
+ *	of this city in the "City" list. If there are more with the same name I use the 
+ *	closest one. If we can't find the exact name I use fuzzy name search. Thats a
+ *	workaround for german umlaute since sometimes there are used in the tags and 
+ *	sometimes there are written as ue ae oe. 
+ *
+ *	3. Step: Do the same like in step 2 once again. This is used to support at least
+ *	one level of recursion in is_in relations.
+ *
+ *  If there is still no info found I use brute force and use the information from the
+ *	next city. Has to be used for countries with poor is_in tagging.
+ *
+ * Author: Bernhard Heibler
+ * Create date: 02-Jan-2009
+ */
+
+package uk.me.parabola.mkgmap.build;
+
+import java.util.Collection;
+import uk.me.parabola.mkgmap.general.MapPoint;
+import java.util.Vector;
+
+public class Locator {
+
+	private final MapPointFastFindMap cityMap  					= new MapPointFastFindMap();
+	private final MapPointMultiMap  	fuzzyCityMap			= new MapPointMultiMap();
+	private final java.util.Vector<MapPoint> placesMap  =  new Vector<MapPoint>();
+
+	private LocatorConfig locConfig = new LocatorConfig();
+
+	static double totalTime = 0;
+	static long totalFinds = 0;
+	private int autoFillLevel = 0;
+
+	public void addLocation(MapPoint p) 
+	{
+		resolveIsInInfo(p); // Preprocess the is_in field
+		
+		if(autoFillLevel < 1 &&  p.getCity() == null)
+		{			
+			// Without autofill city name is the name of the tag
+			p.setCity(p.getName());
+		}
+		
+		if(p.getCity() != null)
+		{
+			cityMap.put(p.getCity(), p);
+			
+			fuzzyCityMap.put(fuzzyDecode(p.getCity()),p);
+
+			if(p.getName() != null && p.getCity().equals(p.getName()) == false) // Name variants ? 
+				fuzzyCityMap.put(fuzzyDecode(p.getName()),p);
+		}
+		else
+		{
+			// All other places which do not seam to be a real city has to resolved later
+			placesMap.add(p);		
+		}
+			
+	}
+
+			
+
+	public void setAutoFillLevel(int level)
+	{
+		autoFillLevel = level;
+	}
+
+	public void setDefaultCountry(String country, String abbr)
+	{
+		locConfig.setDefaultCountry(country, abbr);
+	}
+
+	public String fixCountryString(String country)
+  {
+		return locConfig.fixCountryString(country);
+	}
+
+	private String isCountry(String country)
+  {
+		return locConfig.isCountry(country);
+	}
+
+	public String getCountryCode(String country)
+  {
+		return locConfig.getCountryCode(country);
+  }
+
+	public int getPOIDispFlag(String country)
+  {
+		return locConfig.getPoiDispFlag(country);
+  }
+
+	private boolean isOpenGeoDBCountry(String country)
+	{
+		// Countries that have open geo db data in osm
+		// Right now this are only germany, austria and swizerland
+		return locConfig.isOpenGeoDBCountry(country);
+	}
+
+	private boolean isContinent(String continent)
+  {
+		return locConfig.isContinent(continent);
+	}
+
+
+	/**
+	 * resolveIsInInfo tries to get country and region info out of the is_in field 
+	 * @param p 	Point to process
+	 */
+	private void resolveIsInInfo(MapPoint p)
+	{
+		if(p.getCountry() != null)
+			p.setCountry(fixCountryString(p.getCountry()));
+
+		if(p.getCountry() != null && p.getRegion() != null && p.getCity() == null)
+		{		
+			p.setCity(p.getName());
+			return;
+		}
+
+		if(p.getIsIn() != null)
+		{	
+			String cityList[] = p.getIsIn().split(",");			
+			
+			//System.out.println(p.getIsIn());
+
+			// is_in content is not well defined so we try our best to get some info out of it
+			// Format 1 popular in Germany: "County,State,Country,Continent"
+
+			if(cityList.length > 1 &&
+				isContinent(cityList[cityList.length-1]))	// Is last a continent ?
+			{
+				// The one before contient should be the country
+	  		p.setCountry(fixCountryString(cityList[cityList.length-2].trim()));				
+
+				// aks the config which info to use for region info				
+				int offset = locConfig.getRegionOffset(p.getCountry()) + 1;
+
+				if(cityList.length > offset)
+					p.setRegion(cityList[cityList.length-(offset+1)].trim());
+
+			}
+
+			// Format 2 other way round: "Continent,Country,State,County"	
+
+			if(cityList.length > 1 && isContinent(cityList[0]))	// Is first a continent ?
+			{
+				// The one before contient should be the country
+	  		p.setCountry(fixCountryString(cityList[1].trim()));				
+				
+				int offset = locConfig.getRegionOffset(p.getCountry()) + 1;
+
+				if(cityList.length > offset)
+					p.setRegion(cityList[offset].trim());
+			}	
+
+			// Format like this "County,State,Country"
+
+			if(p.getCountry() == null && cityList.length > 0)
+			{
+				// I don't like to check for a list of countries but I don't want other stuff in country field
+
+				String countryStr = isCountry(cityList[cityList.length-1]);
+
+				if(countryStr != null)
+				{	
+					p.setCountry(countryStr);
+
+					int offset = locConfig.getRegionOffset(countryStr) + 1;
+
+					if(cityList.length > offset)
+		     		p.setRegion(cityList[cityList.length-(offset+1)].trim());	
+				}
+			}
+		}
+
+		if(p.getCountry() != null && p.getRegion() != null && p.getCity() == null)
+		{	
+			// In OpenGeoDB Countries I don't want to mess up the info which city is a real independent
+			// Community in all other countries I just have to do it
+
+			if(isOpenGeoDBCountry(p.getCountry()) == false)	
+				p.setCity(p.getName());
+		}
+	}
+	
+	public MapPoint findNextPoint(MapPoint p)
+	{
+		long   startTime = System.nanoTime();
+	
+		MapPoint nextPoint = null;
+	
+		nextPoint = cityMap.findNextPoint(p);
+		
+		totalFinds++;
+		totalTime = totalTime + ((System.nanoTime() - startTime)/1e9);
+		return nextPoint;
+	}
+	
+	public  MapPoint findByCityName(MapPoint p)
+	{
+		MapPoint near   = null;
+		Double minDist  = Double.MAX_VALUE;
+		Collection <MapPoint> nextCityList = null;			
+		
+		if(p.getCity() == null)
+			return null;
+		
+		nextCityList = cityMap.getList(p.getCity());
+				
+		if(nextCityList != null)
+		{
+			for (MapPoint nextCity: nextCityList)		
+			{
+				Double dist = p.getLocation().distance(nextCity.getLocation());
+
+				if(dist < minDist)
+				{
+					minDist = dist;
+					near = nextCity;
+				}
+			}
+	 	}
+		
+		nextCityList = fuzzyCityMap.getList(fuzzyDecode(p.getCity()));
+		
+		if(nextCityList != null)
+		{
+			for (MapPoint nextCity: nextCityList)		
+			{
+				Double dist = p.getLocation().distance(nextCity.getLocation());
+
+				if(dist < minDist)
+				{
+					minDist = dist;
+					near = nextCity;
+				}
+			}
+	 	}
+		
+		if(near != null && minDist < 30000) // Wrong hit more the 30 km away ?
+			return near;
+		else
+			return null;
+	}
+	
+	private MapPoint findCity(MapPoint place, boolean fuzzy)
+	{
+		MapPoint near   = null;
+		Double minDist  = Double.MAX_VALUE;
+		Collection <MapPoint> nextCityList = null;	
+
+		String isIn = place.getIsIn();
+			
+		if(isIn != null)
+		{
+			String cityList[] = isIn.split(",");
+ 
+			// Go through the isIn string and check if we find a city with this name
+			// Lets hope we find the next bigger city 
+
+			for(int i = 0; i < cityList.length; i++)
+		  {
+		  	String biggerCityName=cityList[i].trim();
+				
+
+				if(fuzzy == false)
+					nextCityList = cityMap.getList(biggerCityName);
+				else
+				  nextCityList = fuzzyCityMap.getList(fuzzyDecode(biggerCityName));
+
+				if(nextCityList != null)
+				{
+					for (MapPoint nextCity: nextCityList)		
+					{
+						Double dist = place.getLocation().distance(nextCity.getLocation());
+
+						if(dist < minDist)
+						{
+							minDist = dist;
+							near = nextCity;
+				  	}
+					}
+			 	}
+			}
+
+			if (autoFillLevel > 3)  // Some debug output to find suspicios relations
+			{
+			   
+				if(near != null && minDist > 30000)
+			  {
+			  		System.out.println("Locator: " + place.getName() + " is far away from " +
+								near.getName() + 	" " + (minDist/1000.0) + " km is_in" +	place.getIsIn());
+						if(nextCityList != null)
+				   		System.out.println("Number of cities with this name: " + nextCityList.size());					
+			  }
+			   
+ 				//if(near != null && fuzzy)
+			  //{
+				// System.out.println("Locator: " + place.getName() + " may belong to " +
+				//			 near.getName() + " is_in" + place.getIsIn());
+				//}
+			}
+		}
+
+		return near;
+	}
+
+	public void resolve() {
+
+		if(autoFillLevel < 0)
+			return;			// Nothing to do if autofill is fulli disabled
+
+		if(autoFillLevel > 2)
+		{
+			System.out.println("\nLocator City   Map contains " + cityMap.size() + " entries");
+			System.out.println("Locator Places Map contains " + placesMap.size() + " entries");
+		}
+		
+		int runCount = 0;
+		int maxRuns = 2;
+		int unresCount;
+		
+		do
+		{
+			unresCount=0;
+
+			for (int i = 0; i < placesMap.size(); i++)
+			{
+				MapPoint place = placesMap.get(i);
+
+				if(place != null)
+				{
+
+					// first lets try exact name
+
+					MapPoint near = findCity(place, false);
+
+					
+					// if this didn't worked try to workaround german umlaute 
+
+		  		if(near == null)
+			  		near = findCity(place, true);
+				
+			  	if(autoFillLevel > 3 && near == null && (runCount + 1) == maxRuns)
+			  	{
+						if(place.getIsIn() != null)
+						System.out.println("Locator: CAN't locate " + place.getName() + " is_in " +	place.getIsIn()
+								+ " " + place.getLocation().toOSMURL());
+			  	}
+
+	
+					if(near != null)
+					{
+						place.setCity(near.getCity());
+						place.setZip(near.getZip());
+		     	}
+					else if (autoFillLevel > 1 && (runCount + 1) == maxRuns)
+					{
+							// In the last resolve run just take info from the next known city
+							near = cityMap.findNextPoint(place);
+					}
+
+
+					if(near != null) 
+					{
+						if(place.getRegion() == null)
+							place.setRegion(near.getRegion());
+
+						if(place.getCountry() == null)
+							place.setCountry(near.getCountry());	
+
+					}
+
+					if(near == null)
+						unresCount++;
+
+				}
+			}
+
+			for (int i = 0; i < placesMap.size(); i++)
+			{
+				MapPoint place = placesMap.get(i);
+
+				if (place != null)
+				{
+					if( place.getCity() != null)
+					{
+		 	  		cityMap.put(place.getName(),place);
+						fuzzyCityMap.put(fuzzyDecode(place.getName()),place);
+						placesMap.set(i, null);
+					}
+					else if(autoFillLevel < 2 && (runCount + 1) == maxRuns)
+					{
+						place.setCity(place.getName());
+						cityMap.put(place.getName(),place);
+					}
+				}				
+			}
+			
+			runCount++;
+
+			if(autoFillLevel > 2)
+				System.out.println("Locator City   Map contains " + cityMap.size() + 
+				" entries after resolver run " + runCount + " Still unresolved " + unresCount);
+			
+		} 
+		while(unresCount > 0 && runCount < maxRuns);
+		
+	}
+	
+	public void printStat()
+	{	
+	   System.out.println("Locator Find called: " + totalFinds + " time");
+	   System.out.println("Locator Find time:   " + totalTime + " s");
+	   
+	   cityMap.printStat();
+	}	
+	
+	private String fuzzyDecode(String stringToDecode)
+  {
+
+		if(stringToDecode == null)
+			return stringToDecode;
+
+		String decodeString = stringToDecode.toUpperCase().trim();
+
+		// German umlaut resolution
+		decodeString = decodeString.replaceAll("Ä","AE").replaceAll("Ü","UE").replaceAll("Ö","OE");
+		
+		//if(decodeString.equals(stringToDecode) == false)
+		//	System.out.println(stringToDecode + " -> " + decodeString);
+
+		return (decodeString);
+	}
+		
+}
+
Index: src/uk/me/parabola/mkgmap/build/MapBuilder.java
===================================================================
--- src/uk/me/parabola/mkgmap/build/MapBuilder.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/build/MapBuilder.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -21,12 +21,12 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
-import java.util.SortedMap;
-import java.util.TreeMap;
 
 import uk.me.parabola.imgfmt.app.Coord;
 import uk.me.parabola.imgfmt.app.lbl.City;
 import uk.me.parabola.imgfmt.app.lbl.Country;
+import uk.me.parabola.imgfmt.app.lbl.Zip;
+import uk.me.parabola.imgfmt.app.Label;
 import uk.me.parabola.imgfmt.app.lbl.LBLFile;
 import uk.me.parabola.imgfmt.app.lbl.POIRecord;
 import uk.me.parabola.imgfmt.app.lbl.Region;
@@ -83,26 +83,55 @@
 	private static final int CLEAR_TOP_BITS = (32 - 15);
 
 	private final java.util.Map<MapPoint,POIRecord> poimap = new HashMap<MapPoint,POIRecord>();
-	private final SortedMap<String, Object> sortedCities = new TreeMap<String, Object>();
+	private final java.util.Map<MapPoint,City> cityMap = new HashMap<MapPoint,City>();
+
 	private boolean doRoads;
 
+	private Locator locator = new Locator();
 	private Country country;
 	private Region  region;
 
-	private String countryName = "UNITED KINGDOM";
-	private String countryAbbr = "GBR";
+	private String countryName = "COUNTRY";
+	private String countryAbbr = "ABC";
 	private String regionName;
 	private String regionAbbr;
+	private int		locationAutofillLevel = 0;
+	private boolean	poiAddresses = true;
+	private int		poiDisplayFlags = 0;
 
 	public MapBuilder() {
 		regionName = null;
 	}
 
 	public void config(EnhancedProperties props) {
+
+		String autoFillPar;
+
 		countryName = props.getProperty("country-name", countryName);
 		countryAbbr = props.getProperty("country-abbr", countryAbbr);
 		regionName = props.getProperty("region-name", null);
 		regionAbbr = props.getProperty("region-abbr", null);
+		
+		if(props.getProperty("no-poi-address", null) != null)
+			poiAddresses = false;
+
+		autoFillPar = props.getProperty("location-autofill", null);
+
+		if(autoFillPar != null)
+		{
+			try
+			{
+				locationAutofillLevel = Integer.parseInt(autoFillPar);
+			}
+			catch (Exception e)
+			{
+				locationAutofillLevel = 1;
+			}
+		}
+
+		locator.setAutoFillLevel(locationAutofillLevel);
+
+
 	}
 
 	/**
@@ -123,6 +152,7 @@
 		if(regionName != null)
 			region = lblFile.createRegion(country, regionName, regionAbbr);
 
+		processCities(map, src);
 		processPOIs(map, src);
 		//preProcessRoads(map, src);
 		processOverviews(map, src);
@@ -157,52 +187,211 @@
 	}
 
 	/**
-	 * First stage of handling POIs
+	 * Processing of Cities
 	 *
-	 * POIs need to be handled first, because we need the offsets
-	 * in the LBL file.
+	 * Fills the city list in lbl block that is required for find by name
+	 * It also builds up information that is required to get address info
+	 * for the POIs
 	 *
 	 * @param map The map.
 	 * @param src The map data.
 	 */
-	private void processPOIs(Map map, MapDataSource src) {
+	private void processCities(Map map, MapDataSource src) {
 		LBLFile lbl = map.getLblFile();
 
-		// gpsmapedit doesn't sort the city names so to be
-		// friendly we generate the city objects in alphabetic
-		// order - to do that we first build a map from city
-		// name to the associated MapPoint - we don't want to
-		// be fooled by duplicate names so suffix the name
-		// with the object to make it unique
+		locator.setDefaultCountry(countryName, countryAbbr);
+		
+		// collect the names of the cities
 		for (MapPoint p : src.getPoints()) {
 			if(p.isCity() && p.getName() != null)
-				sortedCities.put(p.getName() + "@" + p, p);
+				locator.addLocation(p); // Put the city info the map for missing info 
 		}
 
-		// now loop through the sorted keys and retrieve
-		// the MapPoint associated with the key - now we
-		// can create the City object and remember it for later
-		for (String s : sortedCities.keySet()) {
-		    MapPoint p = (MapPoint)sortedCities.get(s);
-		    City c;
-		    if(region != null)
-		    	c = lbl.createCity(region, p.getName());
-		    else
-		    	c = lbl.createCity(country, p.getName());
-		    sortedCities.put(s, c);
+		if(locationAutofillLevel > 0)
+			locator.resolve(); // Try to fill missing information that include search of next city
+
+		for (MapPoint p : src.getPoints()) 
+		{
+			if(p.isCity() && p.getName() != null)
+			{
+				Country thisCountry;
+				Region 	thisRegion;
+				City 		thisCity;
+
+				String CountryStr = p.getCountry();
+				String RegionStr  = p.getRegion();
+
+				if(CountryStr != null)
+					thisCountry = lbl.createCountry(CountryStr, locator.getCountryCode(CountryStr));
+				else
+					thisCountry = country;
+					
+				if(RegionStr != null)
+				{
+					thisRegion = lbl.createRegion(thisCountry,RegionStr, null);
+				}
+				else
+					thisRegion = region;
+
+				if(thisRegion != null)
+					thisCity = lbl.createCity(thisRegion, p.getName(), true);
+				else
+					thisCity = lbl.createCity(thisCountry, p.getName(), true);
+
+				cityMap.put(p, thisCity);
+			}
 		}
-		// if point has a nearest city, create a POIRecord to
-		// reference it
+	}
+
+	private void processPOIs(Map map, MapDataSource src) {
+
+		LBLFile lbl = map.getLblFile();
+		long poiAddrCountr = 0;
+		boolean checkedForPoiDispFlag = false;
+		boolean doAutofill;
+
 		for (MapPoint p : src.getPoints()) {
-			MapPoint nearestCityPoint = p.getNearestCityPoint();
-			if(nearestCityPoint != null && p.getName() != null) {
-				POIRecord r = lbl.createPOI(p.getName());
-				City nearestCity = (City)sortedCities.get(nearestCityPoint.getName() + "@" + nearestCityPoint);
-				r.setCityIndex(nearestCity.getIndex());
+
+			if(p.isCity() == false &&
+				 (p.isRoadNamePOI() || poiAddresses))
+			{		
+				if(locationAutofillLevel > 0 || p.isRoadNamePOI())
+					doAutofill = true;
+				else
+					doAutofill = false;
+				
+				
+				String CountryStr = p.getCountry();
+				String RegionStr  = p.getRegion();		
+				String ZipStr     = p.getZip();
+				String CityStr    = p.getCity();
+				boolean guessed   = false;
+
+				if(CityStr != null || ZipStr != null ||RegionStr != null || CountryStr != null)
+					poiAddrCountr++;
+
+				if(CountryStr != null)
+					CountryStr = locator.fixCountryString(CountryStr);	
+
+				if(CountryStr == null || RegionStr == null || (ZipStr == null && CityStr == null))
+				{
+						MapPoint nextCity = locator.findByCityName(p);
+						
+						if(doAutofill && nextCity == null)
+							nextCity = locator.findNextPoint(p);
+
+						if(nextCity != null)
+						{
+							guessed = true;
+
+							if (CountryStr == null)	CountryStr = nextCity.getCountry();
+							if (RegionStr == null)  RegionStr  = nextCity.getRegion();
+
+							if(doAutofill)
+							{
+								if(ZipStr == null)
+								{
+									String CityZipStr = nextCity.getZip();
+									
+									// Ignore list of Zips seperated by ;
+									
+									if(CityZipStr != null && CityZipStr.indexOf(',') < 0)
+										ZipStr = CityZipStr; 
+								}
+								
+								if(CityStr == null) CityStr = nextCity.getCity();								
+							}
+						
+						}
+				}
+				
+	
+				if(CountryStr != null && checkedForPoiDispFlag == false)
+				{
+					// Different countries require different address notation
+
+					poiDisplayFlags = locator.getPOIDispFlag(CountryStr);
+					checkedForPoiDispFlag = true;
+				}
+
+
+				if(p.isRoadNamePOI() && CityStr != null)					
+				{
+						// If it is road POI add city name and street name into address info
+						p.setStreet(p.getName());
+						p.setName(p.getName() + "/" + CityStr);
+				}
+
+				POIRecord r = lbl.createPOI(p.getName());	
+
+				if(CityStr != null)
+				{
+					Country thisCountry;
+					Region 	thisRegion;
+					City 		city;
+
+					if(CountryStr != null)
+						thisCountry = lbl.createCountry(CountryStr, locator.getCountryCode(CountryStr));
+					else
+						thisCountry = country;
+					
+					if(RegionStr != null)
+						thisRegion = lbl.createRegion(thisCountry,RegionStr, null);
+					else
+						thisRegion = region;
+
+					if(thisRegion != null)
+						city = lbl.createCity(thisRegion, CityStr, false);
+					else
+						city = lbl.createCity(thisCountry, CityStr, false);
+
+	  			r.setCity(city);
+
+				}
+
+				if (ZipStr != null)
+				{
+					Zip zip = lbl.createZip(ZipStr);
+					r.setZipIndex(zip.getIndex());
+				}
+
+				if(p.getStreet() != null)
+				{
+					Label streetName = lbl.newLabel(p.getStreet());
+					r.setStreetName(streetName);			  
+				}
+				else if (guessed == true && locationAutofillLevel > 0)
+				{
+					Label streetName = lbl.newLabel("FIX MY ADDRESS");
+					r.setStreetName(streetName);		
+				}
+
+				if(p.getHouseNumber() != null)
+				{
+					if(r.setSimpleStreetNumber(p.getHouseNumber()) == false)
+					{
+						Label streetNumber = lbl.newLabel(p.getHouseNumber());
+						r.setComplexStreetNumber(streetNumber);
+					}
+				}
+
+				if(p.getPhone() != null)
+				{
+					if(r.setSimplePhoneNumber(p.getPhone()) == false)
+					{
+						Label phoneNumber = lbl.newLabel(p.getPhone());
+						r.setComplexPhoneNumber(phoneNumber);
+					}
+				}	
+		  	
 				poimap.put(p, r);
 			}
 		}
+
+		//System.out.println(poiAddrCountr + " POIs have address info");
+
 		lbl.allPOIsDone();
+
 	}
 
 	/**
@@ -369,6 +558,9 @@
 		// The bounds of the map.
 		map.setBounds(src.getBounds());
 
+		if(poiDisplayFlags != 0)							// POI requested alterate address notation
+			map.setPoiDisplayFlags(poiDisplayFlags);
+
 		// You can add anything here.
 		// But there has to be something, otherwise the map does not show up.
 		//
@@ -461,7 +653,8 @@
 					// retrieve the City created earlier for
 					// this point and store the point info
 					// in it
-					City c = (City)sortedCities.get(name + "@" + point);
+					City c = (City)cityMap.get(point);
+
 					if(pointIndex > 255) {
 						System.err.println("Can't set city point index for " + name + " (too many indexed points in division)\n");
 					} else {
Index: src/uk/me/parabola/mkgmap/build/MapPointFastFindMap.java
===================================================================
--- src/uk/me/parabola/mkgmap/build/MapPointFastFindMap.java	(.../upstream/mkgmap)	(revision 0)
+++ src/uk/me/parabola/mkgmap/build/MapPointFastFindMap.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2009 Bernhard Heibler
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ * 	This is multimap to store city information for the Address Locator
+ *  tt provides also a fast tile based nearest point search function
+ *
+ *
+ * Author: Bernhard Heibler
+ * Create date: 02-Jan-2009
+ */
+
+package uk.me.parabola.mkgmap.build;
+
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Vector;
+import uk.me.parabola.mkgmap.general.MapPoint;
+
+class MapPointFastFindMap{
+
+	private final java.util.Map<String,Vector<MapPoint>> map  = new HashMap<String,Vector<MapPoint>>();
+	private final java.util.Map<Long,Vector<MapPoint>> posMap = new HashMap<Long,Vector<MapPoint>>();	   
+	private final java.util.Vector<MapPoint> points  =  new Vector<MapPoint>();
+
+	public static final  long POS_HASH_DIV = 8000;  	// the smaller -> more tiles 
+	public static final  long POS_HASH_MUL = 10000;		// multiplicator for latitude to create hash
+
+	public MapPoint put(String name, MapPoint p)
+	{
+		Vector<MapPoint> list;
+		
+		list = map.get(name);
+		
+		if(list == null){
+
+		   list = new Vector<MapPoint>();
+		   list.add(p);		
+		   map.put(name, list);
+		}
+		else
+		   list.add(p);
+		
+	  points.add(p);
+		
+		long posHash  =  getPosHashVal(p.getLocation().getLatitude(), p.getLocation().getLongitude());
+		
+		//System.out.println("PosHash " + posHash);
+	
+		list = posMap.get(posHash);
+		
+		if(list == null)
+		{
+			list = new Vector<MapPoint>();
+			list.add(p);		
+			posMap.put(posHash, list);
+		}
+		else
+			list.add(p);
+		
+		return p;
+	}
+
+	public MapPoint get(String name)
+	{
+		Vector<MapPoint> list;
+		
+		list = map.get(name);
+		
+		if(list != null)		
+				return list.elementAt(0);
+		else
+		  return null;
+	}
+	   
+	public Collection<MapPoint> getList(String name)
+	{
+		return map.get(name);
+	}
+	   
+	public long size()
+	{
+		return points.size();
+	}
+	   
+	public Collection<MapPoint> values()
+	{
+		return points;
+	}
+
+	public MapPoint get(int index)
+	{
+		return points.get(index);
+	}
+
+	public MapPoint set(int index, MapPoint p)
+	{
+		return points.set(index, p);
+	}
+	   
+	public boolean remove(MapPoint p)
+	{
+		return points.remove(p);
+	}
+
+	public MapPoint findNextPoint(MapPoint p)
+	{
+		/* tile based search 
+			
+		to prevent expensive linear search over all points we put the points
+		into tiles. We just search the tiles the point is in linear and the 
+		sourounding tiles. If we don't find a point we have to search further
+		arround the central tile
+
+		*/
+			
+		Vector<MapPoint> list;
+		double minDist = Double.MAX_VALUE;
+		MapPoint nextPoint = null;
+		
+		if(points.size() < 1)  // No point in list
+		   return nextPoint;
+		
+		long centLatitIdx = p.getLocation().getLatitude()  / POS_HASH_DIV ;
+		long centLongiIdx = p.getLocation().getLongitude() / POS_HASH_DIV ;
+		long delta = 1;
+		
+		long latitIdx;
+		long longiIdx;
+		long posHash;
+		
+		do
+		{
+			// in the first step we only check our tile and the tiles sourinding us
+			
+			for(latitIdx = centLatitIdx - delta; latitIdx <= centLatitIdx + delta; latitIdx++)
+		    for(longiIdx = centLongiIdx - delta; longiIdx <= centLongiIdx + delta; longiIdx++)
+		    {
+		    	if(delta < 2 
+						|| latitIdx == centLatitIdx - delta 
+						|| latitIdx == centLatitIdx + delta
+						|| longiIdx == centLongiIdx - delta
+						|| longiIdx == centLongiIdx + delta)
+					{
+		    
+						posHash = latitIdx * POS_HASH_MUL + longiIdx; 
+		
+						list = posMap.get(posHash);		
+				
+						if(list != null)
+						{
+			    
+							for (MapPoint actPoint: list)
+							{
+								double distance =  actPoint.getLocation().distance(p.getLocation());
+
+								if(distance < minDist)
+								{
+									nextPoint = actPoint;
+									minDist = distance;
+								}
+			    		}
+			  		}
+					}
+				}
+			delta ++; // We have to look in tiles farer away
+		}
+		while(nextPoint == null);
+	 
+		return nextPoint;
+	}
+	
+	private long getPosHashVal(long lat, long lon)
+	{
+		long latitIdx  =  lat /  POS_HASH_DIV ;
+		long longiIdx  =  lon /  POS_HASH_DIV ; 
+		
+		//System.out.println("LatIdx " + latitIdx + " LonIdx " + longiIdx);
+	
+		return latitIdx * POS_HASH_MUL + longiIdx;
+	}
+	   
+	public void printStat()
+	{
+	   	System.out.println("Locator PosHashmap contains " + posMap.size() + " tiles");
+	}
+}
\ No newline at end of file
Index: src/uk/me/parabola/mkgmap/build/LocatorConfig.java
===================================================================
--- src/uk/me/parabola/mkgmap/build/LocatorConfig.java	(.../upstream/mkgmap)	(revision 0)
+++ src/uk/me/parabola/mkgmap/build/LocatorConfig.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2009 Bernhard Heibler
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  The Locator tries to fill missing country, region, postal coude information
+ *
+ *  To do so we analyse the is_in information and if this doesn't helps us we
+ *  try to get info from the next known city
+ * 
+ * Author: Bernhard Heibler
+ * Create date: 02-Jan-2009
+ */
+package uk.me.parabola.mkgmap.build;
+
+import org.w3c.dom.*;
+import javax.xml.parsers.*;
+import java.io.*;
+
+import java.util.HashMap;
+
+public class LocatorConfig {
+
+	private final java.util.Map<String,String>  variantMap = new HashMap<String,String>();
+	private final java.util.Map<String,String>  abrMap = new HashMap<String,String>();
+	private final java.util.Map<String,Boolean> geoDbMap = new HashMap<String,Boolean>();
+	private final java.util.Map<String,Integer>  regOffsetMap = new HashMap<String,Integer>();
+	private final java.util.Map<String,Integer>  poiDispFlagMap = new HashMap<String,Integer>();
+	private final java.util.Map<String,Boolean> continentMap = new HashMap<String,Boolean>();
+
+
+	public LocatorConfig()
+	{
+    loadConfig("/LocatorConfig.xml");
+	}
+
+ 	private void loadConfig(String fileName)
+ 	{
+		try 
+		{
+			DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+
+			InputStream inStream;
+
+			try
+      {
+			  inStream = new FileInputStream("resources/" + fileName);
+			}
+			catch (Exception ex)
+			{
+				inStream = null;
+			}
+
+			if(inStream == null)	// If not loaded from disk use from jar file
+				inStream = this.getClass().getResourceAsStream(fileName);
+
+			Document document = builder.parse(inStream);
+  		
+			Node rootNode = document.getDocumentElement();
+			
+			if(rootNode.getNodeName().equals("locator"))
+			{
+				  Node cNode = rootNode.getFirstChild();
+
+					while(cNode != null)
+					{
+						if(cNode.getNodeName().equals("continent"))
+						{
+							NamedNodeMap attr = cNode.getAttributes();
+							Node nameTag = null;
+	
+							if(attr != null)
+							{
+								nameTag = attr.getNamedItem("name");
+								if(nameTag != null)
+									addContinent(nameTag.getNodeValue());
+							}
+
+						}
+
+						if(cNode.getNodeName().equals("country"))
+						{
+							NamedNodeMap attr = cNode.getAttributes();
+							Node nameTag = null;
+
+							if(attr != null)
+							{
+								nameTag = attr.getNamedItem("name");
+								
+								Node abrTag = attr.getNamedItem("abr");
+
+								if(abrTag != null && nameTag != null)
+									addAbr(nameTag.getNodeValue(),abrTag.getNodeValue());
+								
+								if(abrTag == null && nameTag != null)					
+									addAbr(nameTag.getNodeValue(),"");
+
+								Node geoTag = attr.getNamedItem("geodb");
+
+								if(nameTag != null && geoTag != null)
+								{
+									if(geoTag.getNodeValue().equals("1"))
+										addOpenGeoDb(nameTag.getNodeValue());
+								}
+
+								Node regionOffsetTag = attr.getNamedItem("regionOffset");
+
+								if(regionOffsetTag != null && nameTag != null)
+								{
+									addRegionOffset(nameTag.getNodeValue(),Integer.parseInt(regionOffsetTag.getNodeValue()));
+								}
+
+								Node poiDispTag = attr.getNamedItem("poiDispFlag");
+
+								if(poiDispTag != null && nameTag != null)
+								{
+									addPoiDispTag(nameTag.getNodeValue(),Integer.decode(poiDispTag.getNodeValue()));
+								}
+							}
+
+							Node cEntryNode = cNode.getFirstChild();
+							while(cEntryNode != null)
+							{
+								if(cEntryNode.getNodeName().equals("variant"))
+								{
+									Node nodeText = cEntryNode.getFirstChild();
+
+									if(nodeText != null && nameTag != null)
+										addVariant(nameTag.getNodeValue(), nodeText.getNodeValue());
+										
+								}
+								cEntryNode = cEntryNode.getNextSibling();
+							}
+						}
+
+						cNode = cNode.getNextSibling();
+					}
+			}
+			else
+			{
+				System.out.println(fileName + "contains invalid root tag " + rootNode.getNodeName());
+			}
+   	}
+		catch (Exception ex)
+		{
+			ex.printStackTrace();
+			//System.out.println("Something is wrong here");
+		}
+  	return;
+ }
+
+	private void addVariant(String country, String variant)
+  {
+		String cStr = country.toUpperCase().trim();
+		String vStr = variant.toUpperCase().trim();
+
+		//System.out.println(vStr + " -> " + cStr);
+
+		variantMap.put(vStr,cStr);
+  }
+
+	private void addAbr(String country, String abr)
+  {
+		String cStr = country.toUpperCase().trim();
+		String aStr = abr.toUpperCase().trim();
+
+		//System.out.println(cStr + " -> " + aStr);
+
+		abrMap.put(cStr,aStr);
+  }
+
+	private void addRegionOffset(String country, Integer offset)
+  {
+		String cStr = country.toUpperCase().trim();
+
+		//System.out.println(cStr + " -> " + offset);
+
+		regOffsetMap.put(cStr,offset);
+  }
+
+	private void addPoiDispTag(String country, Integer flag)
+  {
+		String cStr = country.toUpperCase().trim();
+
+		//System.out.println(cStr + " -> " + flag);
+
+		poiDispFlagMap.put(cStr,flag);
+  }
+
+	private void addOpenGeoDb(String country)
+  {
+		String cStr = country.toUpperCase().trim();
+		
+		//System.out.println(cStr + " openGeoDb");
+		
+		geoDbMap.put(cStr,true);
+		
+  }
+
+	private void addContinent(String continent)
+  {
+		String cStr = continent.toUpperCase().trim();
+		
+		//System.out.println(cStr + " continent");
+		
+		continentMap.put(cStr,true);
+		
+  }
+
+
+	public void setDefaultCountry(String country, String abbr)
+	{
+		addAbr(country, abbr);
+	}
+
+  public String fixCountryString(String country)
+  {
+		String cStr = country.toUpperCase().trim();
+		
+		String fixedString = variantMap.get(cStr);
+
+		if(fixedString != null)
+			return fixedString;
+		else
+			return(cStr);
+	}
+
+	public String isCountry(String country)
+  {
+		String cStr = fixCountryString(country);
+
+		if(getCountryCode(cStr) != null)
+			return cStr;
+		else
+			return null;
+	
+	}
+
+	public String getCountryCode(String country)
+  {
+		String cStr = country.toUpperCase().trim();
+		return abrMap.get(cStr);
+  }
+
+	public int getRegionOffset(String country)
+  {
+		String cStr = country.toUpperCase().trim();
+		
+		Integer regOffset = regOffsetMap.get(cStr);
+
+		if(regOffset != null)
+			return regOffset;
+		else
+			return 1; // Default is 1 the next string after before country
+  }
+
+	public int getPoiDispFlag(String country)
+  {
+		String cStr = country.toUpperCase().trim();
+		
+		Integer flag = poiDispFlagMap.get(cStr);
+
+		if(flag != null)
+			return flag;
+		else
+			return 0; // Default is 1 the next string after before country
+  }
+
+	public boolean isOpenGeoDBCountry(String country)
+	{
+		// Countries that have open geo db data in osm
+		// Right now this are only germany, austria and swizerland
+
+		String cStr = country.toUpperCase().trim();
+
+		if(geoDbMap.get(cStr) != null)
+			return true;
+		
+		return false;
+	}
+
+	public boolean isContinent(String continent)
+  {
+		String s = continent.toUpperCase().trim();
+
+		if(continentMap.get(s) != null)
+			return(true);
+
+		return false;
+	}
+
+
+
+		
+}
+
Index: src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java
===================================================================
--- src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -271,6 +271,50 @@
 		ms.setType(gt.getType());
 		ms.setMinResolution(gt.getMinResolution());
 		ms.setMaxResolution(gt.getMaxResolution());
+		
+		// Now try to get some address info for POIs
+		
+		String city         = element.getTag("addr:city");
+		String zip          = element.getTag("addr:postcode");
+		String street 	    = element.getTag("addr:street");
+		String houseNumber  = element.getTag("addr:housenumber");		
+		String phone	 	    = element.getTag("phone");		
+		String isIn	        = element.getTag("is_in");
+		String country      = element.getTag("is_in:country");
+		String region       = element.getTag("is_in:county");
+		
+		if(country != null)
+			country = element.getTag("addr:country");
+
+		if(zip == null)
+		  zip = element.getTag("openGeoDB:postal_codes");
+		
+		if(city == null)
+		  city = element.getTag("openGeoDB:sort_name");
+		
+		if(city != null)
+		  ms.setCity(city);
+		  
+		if(zip != null)
+		  ms.setZip(zip);
+		  
+		if(street != null)
+		  ms.setStreet(street);		  
+
+		if(houseNumber != null)
+		  ms.setHouseNumber(houseNumber);
+		  
+		if(isIn != null)
+		  ms.setIsIn(isIn);		  
+			
+		if(phone != null)
+		  ms.setPhone(phone);	
+
+		if(country != null)
+		  ms.setCountry(country);	
+
+		if(region != null)
+		  ms.setRegion(region);			
 	}
 
 	void addRoad(Way way, GType gt) {
Index: src/uk/me/parabola/mkgmap/reader/polish/PolishMapDataSource.java
===================================================================
--- src/uk/me/parabola/mkgmap/reader/polish/PolishMapDataSource.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/reader/polish/PolishMapDataSource.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -362,6 +362,23 @@
 			} catch (NumberFormatException e) {
 				endLevel = 0;
 			}
+		} else if (name.equals("ZipCode")) {
+		  elem.setZip(recode(value));
+		} else if (name.equals("CityName")) {
+		  elem.setCity(recode(value));		  
+		} else if (name.equals("StreetDesc")) {
+		  elem.setStreet(recode(value));
+		} else if (name.equals("HouseNumber")) {
+		  elem.setHouseNumber(recode(value));
+		} else if (name.equals("is_in")) {
+		  elem.setIsIn(recode(value));		  
+		} else if (name.equals("Phone")) {
+		  elem.setPhone(recode(value));			
+		} else if (name.equals("CountryName")) {
+		  elem.setCountry(recode(value));
+		} else if (name.equals("RegionName")) {
+			//System.out.println("RegionName " + value);
+		  elem.setRegion(recode(value));				
 		} else {
 			return false;
 		}
Index: src/uk/me/parabola/mkgmap/main/MapMaker.java
===================================================================
--- src/uk/me/parabola/mkgmap/main/MapMaker.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/main/MapMaker.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -277,26 +277,10 @@
 		}
 
 		String name = road.getName();
-		MapPoint nearestCity = null;
-		if(cities != null) {
-			double shortestDistance = 10000000;
-			for(MapPoint mp : cities) {
-				double distance = coord.distance(mp.getLocation());
-				if(distance < shortestDistance) {
-					shortestDistance = distance;
-					nearestCity = mp;
-				}
-			}
-		}
-
 		MapPoint rnp = new MapPoint();
 
-		if(nearestCity != null && nearestCity.getName() != null) {
-			//rnp.setNearestCityPoint(nearestCity);
-			name += "/" + nearestCity.getName();
-		}
-
 		rnp.setName(name);
+		rnp.setRoadNamePOI(true);
 		rnp.setType(type);
 		rnp.setLocation(coord);
 		return rnp;
Index: src/uk/me/parabola/mkgmap/general/MapElement.java
===================================================================
--- src/uk/me/parabola/mkgmap/general/MapElement.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/general/MapElement.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -15,6 +15,9 @@
  */
 package uk.me.parabola.mkgmap.general;
 
+import java.util.Map;
+import java.util.HashMap;
+
 import uk.me.parabola.imgfmt.app.Coord;
 
 /**
@@ -29,6 +32,13 @@
 
 	private int minResolution = 24;
 	private int maxResolution = 24;
+	
+	private String zipCode;
+	private String city;
+	private String region;
+	private String country;	
+	
+	private final Map<String, String> attributes = new HashMap<String, String>();
 
 	protected MapElement() {
 	}
@@ -53,9 +63,84 @@
 	}
 
 	public void setName(String name) {
-		this.name = name;
+	  if(name != null)
+		this.name = name.toUpperCase();
 	}
 
+	public String getCity() {
+		return city;
+	}
+
+	public void setCity(String city) {
+	  if(city != null)
+		this.city = city.toUpperCase();
+	}
+	
+	public String getZip() {
+		return zipCode;
+	}
+
+	public void setZip(String zip) {
+		this.zipCode = zip;
+	}
+
+	public String getCountry() {
+		return country;
+	}
+
+	public void setCountry(String country) {
+	  if(country != null)
+		this.country = country.toUpperCase();
+	}
+	
+	public String getRegion() {
+		return region;
+	}
+
+	public void setRegion(String region) {
+	  if(region != null)
+  		this.region = region.toUpperCase();
+	}	
+	
+	public String getStreet() {
+		return attributes.get("street");
+	}
+
+	public void setStreet(String street) {
+		attributes.put("street", street);	
+	}
+
+	public String getPhone() {
+		return attributes.get("phone");
+	}
+
+	public void setPhone(String phone) {
+	
+	  if(phone.startsWith("00"))
+		{
+		  phone = phone.replaceFirst("00","+");
+		}
+		attributes.put("phone", phone);	
+	}
+
+	public String getHouseNumber() {
+		return attributes.get("houseNumber");
+	}
+
+	public void setHouseNumber(String houseNumber) {
+		attributes.put("houseNumber", houseNumber);		
+	}
+	
+	public String getIsIn() {
+		return attributes.get("isIn");
+	}
+
+	public void setIsIn(String isIn) {
+	  if(isIn != null)
+		attributes.put("isIn", isIn.toUpperCase());
+	}	
+
+
 	/**
 	 * This is the type code that goes in the .img file so that the GPS device
 	 * knows what to display.
Index: src/uk/me/parabola/mkgmap/general/MapPoint.java
===================================================================
--- src/uk/me/parabola/mkgmap/general/MapPoint.java	(.../upstream/mkgmap)	(revision 271)
+++ src/uk/me/parabola/mkgmap/general/MapPoint.java	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -27,6 +27,7 @@
 public class MapPoint extends MapElement {
 	private Coord location;
 	private MapPoint nearestCityPoint;
+	private boolean isRoadNamePoi = false;
 
 	public MapPoint() {
 	}
@@ -63,11 +64,11 @@
 		return type >= 0x0100 && type <= 0x1100;
 	}
 
-	public void setNearestCityPoint(MapPoint nearestCityPoint) {
-		this.nearestCityPoint = nearestCityPoint;
+	public void setRoadNamePOI(boolean isRoadNamePoi) {
+		this.isRoadNamePoi = isRoadNamePoi;
 	}
 
-	public MapPoint getNearestCityPoint() {
-		return nearestCityPoint;
+	public boolean isRoadNamePOI() {
+		return this.isRoadNamePoi;
 	}
 }
Index: build.xml
===================================================================
--- build.xml	(.../upstream/mkgmap)	(revision 271)
+++ build.xml	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -78,8 +78,9 @@
   <target name="build" depends="compile" >
 		<copy todir="${build.classes}">
 			<fileset dir="${resources}">
-				<include name="*.csv"/>
+				<include name="*.csv"/>				
 				<include name="*.properties"/>
+				<include name="*.xml"/>				
 				<include name="**/*.trans"/>
 				<include name="styles/**"/>
 				<include name="help/**"/>
@@ -151,6 +152,7 @@
 				manifest="${resources}/MANIFEST.MF">
 			<include name="**/*.class"/>
 			<include name="*.csv"/>
+			<include name="*.xml"/>			
 			<include name="*.properties"/>
 			<include name="**/*.trans"/>
 			<include name="styles/**"/>
Index: resources/LocatorConfig.xml
===================================================================
--- resources/LocatorConfig.xml	(.../upstream/mkgmap)	(revision 0)
+++ resources/LocatorConfig.xml	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<locator>
+	<country name="Deutschland" abr="DEU" geodb="1" regionOffset="3" poiDispFlag="0xc">
+		<variant>Bundesrepublik Deutschland</variant>
+		<variant>Germany</variant>
+		<variant>DE</variant>		
+	</country>
+	<country name="Österreich" abr="AUT" geodb="1" poiDispFlag="0xc">
+		<variant>Austria</variant>
+		<variant>AT</variant>		
+	</country>
+	<country name="Schweiz" abr="CHE" geodb="1" poiDispFlag="0xc">
+		<variant>Switzerland</variant>
+		<variant>CH</variant>		
+	</country>	
+	<country name="United Kingdom" abr="GBR">
+		<variant>UK</variant>
+		<variant>GB</variant>		
+	</country>
+	<country name="Italia" abr="ITA" regionOffset="2">
+		<variant>Italy</variant>
+		<variant>IT</variant>		
+	</country>	
+	<country name="France" abr="FRA">
+	</country>	
+	<continent name="Europe">
+	</continent>
+	<continent name="Africa">
+	</continent>
+	<continent name="Asia">
+	</continent>		
+	<continent name="North America">
+	</continent>		
+	<continent name="South America">
+	</continent>			
+	<continent name="Oceania">
+	</continent>		
+</locator>
Index: resources/help/en/options
===================================================================
--- resources/help/en/options	(.../upstream/mkgmap)	(revision 271)
+++ resources/help/en/options	(.../work_poiaddr/mkgmap)	(revision 271)
@@ -134,6 +134,24 @@
 	same area, you can see through this map and see the lower map too.
 	Useful for contour line maps among other things.
 
+--no-poi-address
+	Disable address / phone information to POIs. Address info is read according to
+	the "Karlsruhe" tagging schema. Automatic filling of missing information could
+	be enabled using the "location-autofill" option.
+
+--location-autofill=''number''
+	Controls how country region info is gathered for cities / streets and pois
+
+	0	(Default) The country region info is gathered by analysis of the cities is_in tags.
+		If no country region info is present the default passed default country	region is used.
+		 
+	1	Additional analysis of partial is_in info to get relations between hamlets and cities
+	
+	2	Brute force search for nearest city with info if all methods before failed. Warning
+		cities my end up in the wrong country/region.
+		
+	3	Enables debug output about suspicious relations that might cause wrong country region info
+
 --version 
 	Output program version.

    