Commit c030eea9b51dba4cb40a6a11f1e7612458941388 - mkgmap

New upstream version 0.0.0+svn4454 Bas Couwenberg 4 years ago

15 changed file(s) with 355 addition(s) and 131 deletion(s). Raw diff Collapse all Expand all

+20

-0

build.xml less more

37	37
38	38	<property name="src" value="src"/>
39	39	<property name="test" value="test"/>
	40	<property name="tools" value="tools"/>
40	41
41	42	<property name="doc" value="doc"/>
42	43	<property name="javadoc" value="${doc}/api"/>

369	370	<attribute name="Implementation-Version" value="${project.version}" />
370	371	</manifest>
371	372	<include name="*/.class"/>
	373	<exclude name="/buildoptions/"/>
372	374	<include name="*.csv"/>
373	375	<include name="known-hgt.bin"/>
374	376	<include name="*.xml"/>

421	423	</javadoc>
422	424	</target>
423	425
	426	<!-- Compile the tools -->
	427	<target name="compile-tools" depends="prepare" description="tool compilation">
	428
	429	<javac srcdir="${tools}" destdir="${build.classes}" encoding="utf-8" debug="true" includeantruntime="false">
	430	<include name="*/.java" />
	431	<classpath refid="main"/>
	432	</javac>
	433	</target>
	434
	435	<!-- Generate help file options from doc file options.txt -->
	436	<target name="gen-options-file" depends="compile-tools">
	437	<exec executable="java" dir="${build.classes}" failonerror="true" failifexecutionfails="true" input="doc/options.txt">
	438	<arg value="buildoptions.OptionsBuilder" />
	439	<arg value="../../resources/help/en/options" />
	440	</exec>
	441	</target>
	442
	443
424	444	<target name="macker" depends="build, resolve-macker">
425	445	<taskdef name="macker"
426	446	classname="net.innig.macker.ant.MackerAntTask"

-1

doc/index.txt less more

43	43	This documents the language that is accepted by the TYP compiler that
44	44	is included within mkgmap.
45	45
46		[/doc/options '''Logging''']
	46	[/doc/logging '''Logging''']
47	47	Instructions on how to control messages that are logged and to where
48	48	they are written.
49	49

-1

doc/logging.txt less more

42	42	log file, with warning and error messages being also sent to stdout.
43	43
44	44	Further information can be found at
45		https://docs.oracle.com/javase/8/docs/technotes/guides/logging/overview.html
	45	[https://docs.oracle.com/javase/8/docs/technotes/guides/logging/overview.html https://docs.oracle.com/javase/8/docs/technotes/guides/logging/overview.html]
46	46

-1

doc/options.txt less more

	0	=== Command line ===
	1
0	2	The command line is of the format:
1	3
2	4	: java.exe [java-options] -jar mkgmap.jar [mkgmap-options]

28	30	disable specific logging messages. This is useful if you want to see
29	31	certain types of message that are not logged by default or choose where
30	32	the messages should be written.
	33
31	34	=== Mkgmap options ===
32	35
33	36	The order of the options is significant in that options only apply

48	51
49	52	=== File options ===
50	53
51		filename
	54	;filename
52	55	;--input-file=filename
53	56	: Read input data from the given file. This option (or just a
54	57	filename) may be specified more than once. Make sure you set all

-1

resources/help/en/options less more

	0	=== Command line ===
	1
0	2	The command line is of the format:
1	3
2	4	java.exe [java-options] -jar mkgmap.jar [mkgmap-options]

25	27	Specifies a logging configuration file that allows you to enable and
26	28	disable specific logging messages. This is useful if you want to see
27	29	certain types of message that are not logged by default or choose where the
28		messages should be written. === Mkgmap options ===
	30	messages should be written.
	31
	32	=== Mkgmap options ===
29	33
30	34	The order of the options is significant in that options only apply to
31	35	subsequent input files. If you are using splitter, you probably will need to

-2

resources/mkgmap-version.properties less more

0		svn.version: 4434
1		build.timestamp: 2020-01-31T07:23:47+0000
	0	svn.version: 4454
	1	build.timestamp: 2020-02-20T09:16:25+0000

-1

src/uk/me/parabola/imgfmt/app/trergn/LinePreparer.java less more

50	50	private final boolean ignoreNumberOnlyNodes;
51	51
52	52	LinePreparer(Polyline line) {
53		extraBit = line.isRoad() && line.getSubdiv().getZoom().getLevel() == 0 && line.hasInternalNodes();
	53	extraBit = line.isRoad() && line.getSubdiv().getZoom().getLevel() == 0
	54	&& (line.hasInternalNodes() \|\| !line.isLastSegment());
54	55	ignoreNumberOnlyNodes = !line.hasHouseNumbers();
55	56	extTypeLine = line.hasExtendedType();
56	57

-2

src/uk/me/parabola/mkgmap/combiners/FileInfo.java less more

143	143	* @throws FileNotFoundException If the file doesn't actually exist.
144	144	*/
145	145	public static FileInfo getFileInfo(String inputName) throws FileNotFoundException {
146
147	146	int end = inputName.length();
148		String ext = inputName.substring(end - 3).toUpperCase(Locale.ENGLISH);
	147	File f = new File(inputName);
	148	if (f.isDirectory() \|\| end < 3)
	149	return new FileInfo(inputName, UNKNOWN_KIND);
	150
	151	String ext = end < 3 ? "" : inputName.substring(end - 3).toUpperCase(Locale.ENGLISH);
149	152	FileInfo info;
150	153
151	154	if (Objects.equals(ext, "IMG")) {

-0

src/uk/me/parabola/mkgmap/main/MapMaker.java less more

49	49	}
50	50
51	51	public String makeMap(CommandArgs args, String filename) {
	52	if (new File(filename).isDirectory()) {
	53	System.err.println("Need a single file, not a directory: " + filename);
	54	return filename;
	55	}
52	56	try {
53	57	LoadableMapDataSource src = loadFromFile(args, filename);
54	58	sort = args.getSort();

-1

src/uk/me/parabola/mkgmap/osmstyle/ConvertedWay.java less more

35	35	private final int index;
36	36	private final Way way; // with tags after Style processing
37	37	private final GType gt;
	38	private final boolean isRoad;
38	39
39	40	private byte roadClass; // 0-4
40	41	private byte roadSpeed; // 0-7
41	42	private byte mkgmapAccess; // bit mask, see ACCESS_TAGS
42	43	private final byte routeFlags; // bit mask, see ROUTING_TAGS
43		private boolean isRoad;
44	44	private boolean reversed; // points were reversed
45	45	private boolean overlay; // this is a non-routable overlay line that for a road
46	46

72	72	// copy all other attributes
73	73	this.index = other.index;
74	74	this.gt = other.gt;
	75	this.isRoad = other.isRoad;
75	76	this.roadClass = other.roadClass;
76	77	this.roadSpeed = other.roadSpeed;
77	78	this.mkgmapAccess = other.mkgmapAccess;
78	79	this.routeFlags = other.routeFlags;
	80	this.overlay = other.overlay;
79	81	}
80	82
81	83	public int getIndex(){

+16

-11

src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java less more

27	27	import java.util.LinkedHashSet;
28	28	import java.util.List;
29	29	import java.util.Map;
	30	import java.util.Map.Entry;
30	31	import java.util.Set;
31		import java.util.Map.Entry;
32	32	import java.util.logging.Level;
33	33
34	34	import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;

117	117	private IdentityHashMap<Coord, CoordNode> nodeIdMap = new IdentityHashMap<>();
118	118
119	119	public static final String WAY_POI_NODE_IDS = "mkgmap:way-poi-node-ids";
120		private final HashMap<Integer, Map<String,MapPoint>> pointMap;
	120	private final HashMap<Integer, Map<String, MapPoint>> pointMap;
121	121
122	122	/** boundary ways with admin_level=2 */
123	123	private final Set<Way> borders = new LinkedHashSet<>();

127	127
128	128	private List<ConvertedWay> roads = new ArrayList<>();
129	129	private List<ConvertedWay> lines = new ArrayList<>();
130		private HashMap<Long, ConvertedWay> modifiedRoads = new HashMap<>();
131		private HashSet<Long> deletedRoads = new HashSet<>();
	130	private List<MapPoint> renderedCoordPOI = new ArrayList<>();
132	131
133	132	private int nextRoadId = 1;
134	133

587	586	return;
588	587	}
589	588
	589	if (node.getLocation() instanceof CoordPOI) {
	590	renderedCoordPOI.add(mp);
	591	}
590	592	collector.addPoint(mp);
591	593	}
592	594

882	884	borders.clear();
883	885
884	886	setHighwayCounts();
	887	HashMap<Long, ConvertedWay> modifiedRoads = new HashMap<>();
885	888	findUnconnectedRoads();
886		rotateClosedWaysToFirstNode();
	889	rotateClosedWaysToFirstNode(modifiedRoads);
887	890	filterCoordPOI();
	891
	892	HashSet<Long> deletedRoads = new HashSet<>();
888	893	WrongAngleFixer wrongAngleFixer = new WrongAngleFixer(bbox);
889		wrongAngleFixer.optimizeWays(roads, lines, modifiedRoads, deletedRoads, restrictions);
890
	894	wrongAngleFixer.optimizeWays(roads, lines, modifiedRoads, deletedRoads, restrictions, renderedCoordPOI);
	895
891	896	// make sure that copies of modified roads have equal points
892	897	for (ConvertedWay line : lines){
893	898	if (!line.isValid())

914	919	log.warn("Way that is used in valid restriction relation was removed, id:",wayId);
915	920	}
916	921	}
917		deletedRoads = null;
918		modifiedRoads = null;
	922	deletedRoads.clear();
	923	modifiedRoads.clear();
919	924	mergeRoads();
920	925
921	926	resetHighwayCounts();

997	1002	* Try to make sure that closed ways start with a point that is
998	1003	* also part of another road. This reduces the number of nodes
999	1004	* a little bit.
	1005	* @param modifiedRoads Will contain roads modified by this routine
1000	1006	*
1001	1007	*/
1002		private void rotateClosedWaysToFirstNode() {
	1008	private void rotateClosedWaysToFirstNode(HashMap<Long, ConvertedWay> modifiedRoads ) {
1003	1009	for (ConvertedWay cw: roads){
1004	1010	if (!cw.isValid())
1005	1011	continue;

1943	1949
1944	1950	return trailingWay;
1945	1951	}
1946
1947	1952
1948	1953	/**
1949	1954	* Increment the highway counter for each coord of each road.

+115

-110

src/uk/me/parabola/mkgmap/osmstyle/WrongAngleFixer.java less more

28	28	import uk.me.parabola.imgfmt.app.Coord;
29	29	import uk.me.parabola.log.Logger;
30	30	import uk.me.parabola.mkgmap.filters.DouglasPeuckerFilter;
	31	import uk.me.parabola.mkgmap.general.MapPoint;
31	32	import uk.me.parabola.mkgmap.reader.osm.CoordPOI;
32	33	import uk.me.parabola.mkgmap.reader.osm.FakeIdGenerator;
33	34	import uk.me.parabola.mkgmap.reader.osm.Node;

59	60
60	61	private final Area bbox;
61	62	private static final String DEBUG_PATH = null;
62		static final int MODE_ROADS = 0;
63		static final int MODE_LINES = 1;
64		private int mode = MODE_ROADS;
65	63	private int pass;
66	64	private boolean extraPass;
67
	65
	66	private ArrayList<ConvertedWay> convertedWays;
	67
	68	/**
	69	* Construct new WrongAngleFixer
	70	* @param bbox the bounding box, ignored if null, else might be used for debugging
	71	* @param allCoordPOI all {@code MapPoint} instances which refer to {@code CoordP} instances. There location might be changed
	72	* in this class.
	73	*/
68	74	public WrongAngleFixer(Area bbox) {
69	75	this.bbox = bbox;
70	76	if (DEBUG_PATH != null && bbox != null && (long) bbox.getWidth() * bbox.getHeight() < 100000) {

86	92	* @param lines list of non-routable ways
87	93	* @param modifiedRoads Will be enlarged by all roads modified in this method
88	94	* @param deletedRoads Will be enlarged by all roads in roads that were set to null by this method
89		* @param restrictions Map with restriction relations
	95	* @param restrictions Map with restriction relations
	96	* @param renderedPOI all MapPoint instances for {@code CoordPOI} instances
90	97	*/
91	98	public void optimizeWays(List<ConvertedWay> roads, List<ConvertedWay> lines, Map<Long, ConvertedWay> modifiedRoads,
92		Set<Long> deletedRoads, List<RestrictionRelation> restrictions) {
	99	Set<Long> deletedRoads, List<RestrictionRelation> restrictions, List<MapPoint> renderedPOI) {
93	100	printBadAngles("bad_angles_start", roads);
94	101	writeOSM("roads_orig", roads);
95	102	writeOSM("lines_orig", lines);
96		Long2ObjectOpenHashMap<Coord> coordMap = new Long2ObjectOpenHashMap<>();
97		replaceDuplicateBoundaryNodes(roads, coordMap);
98		replaceDuplicateBoundaryNodes(lines, coordMap);
99		coordMap.clear();
100		removeWrongAngles(roads, lines, modifiedRoads, deletedRoads, restrictions);
	103
	104	convertedWays = new ArrayList<>();
	105	convertedWays.addAll(roads);
	106	convertedWays.addAll(lines);
	107	convertedWays.removeIf(ConvertedWay::isOverlay);
	108	convertedWays.sort((o1,o2) -> Long.compare(o1.getWay().getId(), o2.getWay().getId()));
	109	replaceDuplicateBoundaryNodes(convertedWays);
	110	Map<Coord, Coord> replacements = removeWrongAngles(modifiedRoads, deletedRoads);
101	111	writeOSM("roads_post_rem_wrong_angles", roads);
102		removeObsoletePoints(roads, modifiedRoads);
	112	removeObsoletePoints(modifiedRoads);
103	113	writeOSM("roads_post_rem_obsolete_points", roads);
104	114	printBadAngles("bad_angles_finish", roads);
105		this.mode = MODE_LINES;
106		writeOSM("lines_after_roads", lines);
107		removeWrongAngles(null, lines, modifiedRoads, null, restrictions);
108	115	writeOSM("lines_post_rem_wrong_angles", lines);
109		removeObsoletePoints(lines, modifiedRoads);
110		writeOSM("lines_final", lines);
	116	convertedWays = null;
	117
	118	for (RestrictionRelation rr : restrictions) {
	119	for (Coord p : rr.getViaCoords()) {
	120	Coord replacement = getReplacement(p, null, replacements);
	121	if (p != replacement) {
	122	rr.replaceViaCoord(p, replacement);
	123	}
	124	}
	125	}
	126
	127	// update positions of the POIs which were already created.
	128	for (MapPoint mp : renderedPOI) {
	129	Coord replacement = getReplacement(mp.getLocation(), null, replacements);
	130	if (mp.getLocation() != replacement) {
	131	mp.setLocation(replacement);
	132	}
	133	}
111	134	}
112	135
113	136	/**

115	138	* @param convertedWays
116	139	* @param coordMap
117	140	*/
118		private static void replaceDuplicateBoundaryNodes(List<ConvertedWay> convertedWays,
119		Long2ObjectOpenHashMap<Coord> coordMap) {
	141	private static void replaceDuplicateBoundaryNodes(List<ConvertedWay> convertedWays) {
	142	Long2ObjectOpenHashMap<Coord> coordMap = new Long2ObjectOpenHashMap<>();
120	143	for (ConvertedWay cw : convertedWays) {
121		if (!cw.isValid() \|\| cw.isOverlay())
	144	if (!cw.isValid())
122	145	continue;
123	146	Way way = cw.getWay();
124	147	List<Coord> points = way.getPoints();

194	217	/**
195	218	* Find wrong angles caused by rounding to map units. Try to fix them by
196	219	* moving, removing or merging points.
197		* @param roads list with routable ways or null, if lines should be optimized
198		* @param lines list with non-routable ways
199	220	* @param modifiedRoads map of modified routable ways (modified by this routine)
200	221	* @param deletedRoads set of ids of deleted routable ways (modified by this routine)
201		* @param restrictions Map with restriction relations. The restriction relations may be modified by this routine
	222	* @return
202	223	*/
203		private void removeWrongAngles(List<ConvertedWay> roads, List<ConvertedWay> lines,
204		Map<Long, ConvertedWay> modifiedRoads, Set<Long> deletedRoads, List<RestrictionRelation> restrictions) {
	224	private Map<Coord, Coord> removeWrongAngles(Map<Long, ConvertedWay> modifiedRoads, Set<Long> deletedRoads) {
205	225	// replacements maps those nodes that have been replaced to
206	226	// the node that replaces them
207	227	Map<Coord, Coord> replacements = new IdentityHashMap<>();

211	231	HashSet<Way> waysWithBearingErrors = new HashSet<>();
212	232	HashSet<Long> waysThatMapToOnePoint = new HashSet<>();
213	233
214		List<ConvertedWay> convertedWays = (roads != null) ? roads: lines;
215
216	234	// filter with Douglas Peucker algo
217		prepWithDouglasPeucker(convertedWays, modifiedRoads);
	235	prepWithDouglasPeucker(modifiedRoads);
218	236
219	237	Way lastWay = null;
220	238	boolean anotherPassRequired = true;

224	242	break;
225	243	anotherPassRequired = false;
226	244	log.info("Removing wrong angles - PASS", pass);
227		writeOSM(((mode == MODE_LINES) ? "lines" : "roads") + "_pass_" + pass, convertedWays);
	245	writeOSM("pass_" + pass, convertedWays);
228	246
229	247	// Step 1: detect points which are parts of line segments with wrong bearings
230	248	lastWay = null;
231	249	for (ConvertedWay cw : convertedWays) {
232		if (!cw.isValid() \|\| cw.isOverlay())
	250	if (!cw.isValid())
233	251	continue;
234	252	Way way = cw.getWay();
235	253	if (way.equals(lastWay))

250	268	if (pass == 1)
251	269	p.setRemove(false);
252	270	p = getReplacement(p, way, replacements);
253		if (i == 0 \|\| i == points.size() - 1) {
	271	if (!cw.isRoad() && (i == 0 \|\| i == points.size() - 1)) {
254	272	p.setEndOfWay(true);
255	273	}
256	274

278	296
279	297	lastWay = null;
280	298	for (ConvertedWay cw : convertedWays) {
281		if (!cw.isValid() \|\| cw.isOverlay() \|\| cw.getWay().equals(lastWay))
	299	if (!cw.isValid() \|\| cw.getWay().equals(lastWay))
282	300	continue;
283	301	Way way = cw.getWay();
284	302	if (pass != 1 && !waysWithBearingErrors.contains(way))

298	316	if (p == prev) {
299	317	points.remove(i);
300	318	--i;
301		if (mode == MODE_ROADS)
	319	if (cw.isRoad()) {
302	320	modifiedRoads.put(way.getId(), cw);
	321	}
303	322	continue;
304	323	}
305	324	if (p.isPartOfBadAngle() \|\| prev.isPartOfBadAngle()) {

307	326	// save both points with their neighbour
308	327	Coord p1 = prev;
309	328	Coord p2 = p;
310		CenterOfAngle coa1 = getOrCreateCenter(p, way, centerMap, centers, overlaps);
311		CenterOfAngle coa2 = getOrCreateCenter(prev, way, centerMap, centers, overlaps);
	329	CenterOfAngle coa1 = getOrCreateCenter(p, cw, centerMap, centers, overlaps);
	330	CenterOfAngle coa2 = getOrCreateCenter(prev, cw, centerMap, centers, overlaps);
312	331	coa1.addNeighbour(coa2);
313	332	coa2.addNeighbour(coa1);
314	333	if (points.size() == 2) {
315	334	// way has only two points, don't merge them
316	335	coa1.addBadMergeCandidate(coa2);
317	336	}
318		if (mode == MODE_ROADS && p1.getHighwayCount() >= 2 && p2.getHighwayCount() >= 2
	337	if (cw.isRoad() && p1.getHighwayCount() >= 2 && p2.getHighwayCount() >= 2
319	338	&& cw.isRoundabout()) {
320	339	// avoid to merge exits of roundabouts
321	340	coa1.addBadMergeCandidate(coa2);

332	351	// Step 3: Update list of ways with bearing errors or points next to them
333	352	lastWay = null;
334	353	for (ConvertedWay cw : convertedWays) {
335		if (!cw.isValid() \|\| cw.isOverlay() \|\| cw.getWay().equals(lastWay))
	354	if (!cw.isValid() \|\| cw.getWay().equals(lastWay))
336	355	continue;
337	356	Way way = cw.getWay();
338	357	lastWay = way;

380	399	boolean lastWayModified = false;
381	400	ConvertedWay lastConvertedWay = null;
382	401	for (ConvertedWay cw : convertedWays) {
383		if (!cw.isValid() \|\| cw.isOverlay() \|\| !waysWithBearingErrors.contains(cw.getWay()))
	402	if (!cw.isValid() \|\| !waysWithBearingErrors.contains(cw.getWay()))
384	403	continue;
385	404	Way way = cw.getWay();
386	405	List<Coord> points = way.getPoints();

441	460	anotherPassRequired = true;
442	461	}
443	462	}
444		if (lastWayModified && mode == MODE_ROADS) {
	463	if (lastWayModified && cw.isRoad()) {
445	464	modifiedRoads.put(way.getId(), cw);
446	465	}
447	466	}

469	488	boolean lastWayModified = false;
470	489	ConvertedWay lastConvertedWay = null;
471	490	for (ConvertedWay cw : convertedWays) {
472		if (cw.isOverlay())
473		continue;
474	491	Way way = cw.getWay();
475	492
476	493	List<Coord> points = way.getPoints();
477	494	if (points.size() < 2) {
478	495	if (log.isInfoEnabled())
479	496	log.info(" Way " + way.getTag("name") + " (" + way.toBrowseURL() + ") has less than 2 points - deleting it");
480		if (mode == MODE_LINES && !waysThatMapToOnePoint.contains(way.getId())) {
	497	if (!cw.isRoad() && !waysThatMapToOnePoint.contains(way.getId())) {
481	498	log.warn("non-routable way ", way.getId(), "was removed");
482	499	}
483	500
484		if (mode == MODE_ROADS)
	501	if (cw.isRoad())
485	502	deletedRoads.add(way.getId());
486	503	++numWaysDeleted;
487	504	continue;

510	527	prev = p;
511	528	}
512	529	}
513		if (mode == MODE_ROADS) {
514		// treat special case: non-routable ways may be connected to moved
515		// points in roads
516		for (ConvertedWay cw : lines) {
517		if (!cw.isValid() \|\| cw.isOverlay())
518		continue;
519		Way way = cw.getWay();
520		List<Coord> points = way.getPoints();
521		int n = points.size();
522		boolean hasReplacedPoints = false;
523		for (int i = 0; i < n; i++) {
524		Coord p = points.get(i);
525		if (p.isReplaced()) {
526		hasReplacedPoints = true;
527		points.set(i, getReplacement(p, null, replacements));
528		}
529		}
530		if (hasReplacedPoints && DEBUG_PATH != null) {
531		GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, way.getId() + "_mod_non_routable"), points);
532		}
533		}
534
535		for (RestrictionRelation rr : restrictions) {
536		for (Coord p : rr.getViaCoords()) {
537		Coord replacement = getReplacement(p, null, replacements);
538		if (p != replacement) {
539		rr.replaceViaCoord(p, replacement);
540		}
541		}
542		}
543		}
544
	530	// treat special case: non-routable ways may be connected to moved
	531	// points in roads
	532	for (ConvertedWay cw : convertedWays) {
	533	if (!cw.isValid() \|\| cw.isRoad())
	534	continue;
	535	Way way = cw.getWay();
	536	List<Coord> points = way.getPoints();
	537	int n = points.size();
	538	boolean hasReplacedPoints = false;
	539	for (int i = 0; i < n; i++) {
	540	Coord p = points.get(i);
	541	if (p.isReplaced()) {
	542	hasReplacedPoints = true;
	543	points.set(i, getReplacement(p, null, replacements));
	544	}
	545	}
	546	if (hasReplacedPoints && DEBUG_PATH != null) {
	547	GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, way.getId() + "_mod_non_routable"), points);
	548	}
	549	}
	550
545	551	if (DEBUG_PATH != null) {
546	552	GpxCreator.createGpx(
547		Utils.joinPath(DEBUG_PATH, (mode == MODE_ROADS ? "roads_" : "lines_") + "solved_badAngles"),
	553	Utils.joinPath(DEBUG_PATH, "solved_badAngles"),
548	554	bbox.toCoords(), new ArrayList<>(changedPlaces));
549	555	}
550	556	if (anotherPassRequired) {

553	559	log.info("Removing wrong angles - finished in", pass, "passes (", numNodesMerged, "nodes merged,",
554	560	numWaysDeleted, "ways deleted)");
555	561	}
556		}
557
558		private CenterOfAngle getOrCreateCenter(Coord p, Way way, IdentityHashMap<Coord, CenterOfAngle> centerMap,
	562	return replacements;
	563	}
	564
	565	private CenterOfAngle getOrCreateCenter(Coord p, ConvertedWay cw, IdentityHashMap<Coord, CenterOfAngle> centerMap,
559	566	List<CenterOfAngle> centers, Map<Coord, Set<Way>> overlaps) {
560	567	CenterOfAngle coa = centerMap.get(p);
561	568	if (coa == null) {
562	569	coa = new CenterOfAngle(p, centerMap.size() + 1);
563	570	centerMap.put(p, coa);
564	571	centers.add(coa);
565		if (mode == MODE_ROADS && pass > 1) {
566		overlaps.computeIfAbsent(p, k -> new HashSet<>()).add(way);
	572	if (cw.isRoad() && pass > 1) {
	573	overlaps.computeIfAbsent(p, k -> new HashSet<>()).add(cw.getWay());
567	574	}
568	575	}
569	576	return coa;

589	596	* very close to 180 degrees angles in the real line or wrong points.
590	597	* Wrong points are those that produce wrong angles, so that
591	598	* removing them reduces the error.
592		* @param convertedWays
593	599	* @param modifiedRoads
594	600	*/
595		private void removeObsoletePoints(List<ConvertedWay> convertedWays, Map<Long, ConvertedWay> modifiedRoads) {
	601	private void removeObsoletePoints(Map<Long, ConvertedWay> modifiedRoads) {
596	602	ConvertedWay lastConvertedWay = null;
597	603	int numPointsRemoved = 0;
598	604	boolean lastWasModified = false;
599	605	List<Coord> removedInWay = new ArrayList<>();
600	606	List<Coord> obsoletePoints = new ArrayList<>();
601	607	List<Coord> modifiedPoints = new ArrayList<>();
602
	608	markEndPoints(convertedWays, true); // don't allow to remove end points of ways
603	609	for (ConvertedWay cw : convertedWays) {
604		if (!cw.isValid() \|\| cw.isOverlay())
	610	if (!cw.isValid())
605	611	continue;
606	612	Way way = cw.getWay();
607	613	if (lastConvertedWay != null && way.equals(lastConvertedWay.getWay())) {

666	672	keepThis = false;
667	673	} else if (c1.equals(c2)) {
668	674	// spike / overlap
669		log.debug("pass", pass, "roads=" + (mode == MODE_ROADS),
	675	log.debug("pass", pass, "roads=" + (cw.isRoad()),
670	676	"extra remove to remove spike or overlap near", cm.toDegreeString());
671	677	keepThis = false;
672	678

692	698	modifiedPoints.add(points.get(points.size() - 1));
693	699	points.clear();
694	700	points.addAll(modifiedPoints);
695		if (mode == MODE_ROADS)
	701	if (cw.isRoad())
696	702	modifiedRoads.put(way.getId(), cw);
697	703	if (DEBUG_PATH != null && (draw \|\| cw.isRoundabout())) {
698	704	GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, way.getId() + "_dpmod"), points, removedInWay);

700	706	}
701	707	}
702	708	if (DEBUG_PATH != null) {
703		GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, (mode == MODE_ROADS ? "roads" : "lines") + "_obsolete"),
	709	GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, "_obsolete"),
704	710	bbox.toCoords(), new ArrayList<>(obsoletePoints));
705	711	}
706		log.info("Removed", numPointsRemoved, "obsolete points in lines");
	712	log.info("Removed", numPointsRemoved, "obsolete points from lines");
707	713	}
708	714
709	715	/**

767	773	if (hasBadAngles)
768	774	badWays.add(cw);
769	775	}
770		GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, (mode==MODE_ROADS ? "roads_" : "lines_")+name), bbox.toCoords(), new ArrayList<>(badAngles));
	776	GpxCreator.createGpx(Utils.joinPath(DEBUG_PATH, name), bbox.toCoords(), new ArrayList<>(badAngles));
771	777	writeOSM(name, badWays);
772	778	}
773	779
774	780	/**
775		* Check if the point can safely be removed from a road.
	781	* Check if the point can safely be removed.
776	782	* @param p
777	783	* @return true if remove is okay
778	784	*/
779		private boolean allowedToRemove(Coord p){
780		if (p.getOnBoundary() \|\| p.getOnCountryBorder())
	785	private static boolean allowedToRemove(Coord p) {
	786	if (p.getOnBoundary() \|\| p.getOnCountryBorder() \|\| p.isEndOfWay())
781	787	return false;
782		if (mode == MODE_LINES && p.isEndOfWay())
	788	if (p instanceof CoordPOI && ((CoordPOI) p).isUsed())
783	789	return false;
784		if (p instanceof CoordPOI && ((CoordPOI) p).isUsed()){
785		return false;
786		}
	790
787	791	return p.getHighwayCount() < 2 && !p.isViaNodeOfRestriction();
788	792	}
789	793

891	895	toRepl.setReplaced(true);
892	896	if (toRepl instanceof CoordPOI) {
893	897	CoordPOI cp = (CoordPOI) toRepl;
894		if (cp.isUsed()) {
	898	if (cp.isUsed() ) {
895	899	replacement = new CoordPOI(replacement);
896	900	((CoordPOI) replacement).setNode(cp.getNode());
897	901	((CoordPOI) replacement).setUsed(true);

974	978	List<Coord> altPositions = currentCenter.getAlternativePositions();
975	979	for (Coord altCenter : altPositions) {
976	980	if (dupCheck.contains(altCenter)) {
977		log.debug("pass", pass, "roads=" + (mode == MODE_ROADS),
	981	log.debug("pass", pass,
978	982	"extra move to remove spike or overlap near", currentCenter.toDegreeString());
979	983	replaceCoord(currentCenter, altCenter, replacements);
980	984	return true;

1290	1294
1291	1295	@SuppressWarnings("unused")
1292	1296	private void createGPX(String gpxName, Map<Coord, Coord> replacements) {
1293		if (gpxName == null \|\| DEBUG_PATH == null)
	1297	if (DEBUG_PATH == null \|\| gpxName == null)
1294	1298	return;
1295	1299	if (gpxName.isEmpty())
1296	1300	gpxName = Utils.joinPath(DEBUG_PATH, id + "_no_info");

1404	1408	* @param convertedWays list of ways to filter
1405	1409	* @param modifiedRoads if ways are routable we add the modified ways to this map
1406	1410	*/
1407		private void prepWithDouglasPeucker(List<ConvertedWay> convertedWays, Map<Long, ConvertedWay> modifiedRoads) {
	1411	private void prepWithDouglasPeucker(Map<Long, ConvertedWay> modifiedRoads) {
1408	1412	// we don't want to remove end points of ways
1409		markEndPoints(convertedWays);
	1413	markEndPoints(convertedWays, true);
1410	1414	double maxErrorDistance = 0.05;
1411	1415	Way lastWay = null;
1412	1416	for (ConvertedWay cw : convertedWays) {
1413		if (!cw.isValid() \|\| cw.isOverlay() \|\| cw.getWay().equals(lastWay))
	1417	if (!cw.isValid() \|\| cw.getWay().equals(lastWay))
1414	1418	continue;
1415	1419	Way way = cw.getWay();
1416	1420	lastWay = way;

1432	1436	// Simplify the rest
1433	1437	DouglasPeuckerFilter.douglasPeucker(coords, 0, endIndex, maxErrorDistance);
1434	1438	if (coords.size() != points.size()) {
1435		if (mode == MODE_ROADS) {
	1439	if (cw.isRoad()) {
1436	1440	modifiedRoads.put(way.getId(), cw);
1437	1441	}
1438	1442	points.clear();
1439	1443	points.addAll(coords);
1440	1444	}
1441	1445	}
1442		}
1443
1444		private static void markEndPoints(List<ConvertedWay> convertedWays) {
	1446	markEndPoints(convertedWays, false);
	1447	}
	1448
	1449	private static void markEndPoints(List<ConvertedWay> convertedWays, boolean b) {
1445	1450	Way lastWay = null;
1446	1451	for (ConvertedWay cw : convertedWays) {
1447		if (!cw.isValid() \|\| cw.isOverlay() \|\| cw.getWay().equals(lastWay))
	1452	if (!cw.isValid() \|\| cw.getWay().equals(lastWay))
1448	1453	continue;
1449	1454	Way way = cw.getWay();
1450	1455	lastWay = way;
1451		way.getFirstPoint().setEndOfWay(true);
1452		way.getLastPoint().setEndOfWay(true);
	1456	way.getFirstPoint().setEndOfWay(b);
	1457	way.getLastPoint().setEndOfWay(b);
1453	1458	}
1454	1459	}
1455	1460

-0

src/uk/me/parabola/mkgmap/reader/osm/OsmMapDataSource.java less more

147	147	public void load(String name, boolean addBackground) throws FileNotFoundException {
148	148	try (InputStream is = Utils.openFile(name)) {
149	149	parse(is, name);
	150	} catch (FileNotFoundException e) {
	151	throw e;
150	152	} catch (IOException e) {
151	153	// exception thrown from implicit call to close() on resource variable 'is'
152	154	}

+12

-0

src/uk/me/parabola/mkgmap/reader/polish/PolishMapDataSource.java less more

55	55	import uk.me.parabola.mkgmap.general.ZipCodeInfo;
56	56	import uk.me.parabola.mkgmap.reader.MapperBasedMapDataSource;
57	57	import uk.me.parabola.mkgmap.reader.osm.FakeIdGenerator;
	58	import uk.me.parabola.mkgmap.reader.osm.FeatureKind;
58	59	import uk.me.parabola.mkgmap.reader.osm.GType;
59	60	import uk.me.parabola.mkgmap.reader.osm.GeneralRelation;
60	61	import uk.me.parabola.mkgmap.reader.osm.MultiPolygonRelation;

418	419	if (type <= 0xff)
419	420	type <<= 8;
420	421	point.setType(type);
	422	checkType(FeatureKind.POINT, point.getType());
421	423	} else if (name.equals("SubType")) {
422	424	int subtype = Integer.decode(value);
423	425	int type = point.getType();
424	426	point.setType(type \| subtype);
	427	checkType(FeatureKind.POINT, point.getType());
425	428	} else if (name.startsWith("Data") \|\| name.startsWith("Origin")) {
426	429	Coord co = makeCoord(value);
427	430	setResolution(point, name);

446	449	private void line(String name, String value) {
447	450	if (name.equals("Type")) {
448	451	polyline.setType(Integer.decode(value));
	452	checkType(FeatureKind.POLYLINE, polyline.getType());
449	453	} else if (name.startsWith("Data")) {
450	454	extractResolution(name);
451	455	addLineString(value, false);

584	588	if (type == 0x4a00)
585	589	type = 0x4a;
586	590	shape.setType(type);
	591	checkType(FeatureKind.POLYGON, type);
587	592	if(type == 0x4b)
588	593	havePolygon4B = true;
589	594	} else if (name.startsWith("Data")) {

1022	1027	public String getDefaultRegion() {
1023	1028	return defaultRegion;
1024	1029	}
	1030
	1031	private void checkType(FeatureKind kind, int type) {
	1032	if (!GType.checkType(kind, type)) {
	1033	throw new MapFailedException("invalid type " + GType.formatType(type) + " for " + kind + ", line " + lineNo);
	1034	}
	1035	}
	1036
1025	1037	}

+163

-0

tools/buildoptions/OptionsBuilder.java less more

	0	/*
	1	* Copyright (C) 2019.
	2	*
	3	* This program is free software; you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License version 3 or
	5	* version 2 as published by the Free Software Foundation.
	6	*
	7	* This program is distributed in the hope that it will be useful, but
	8	* WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	10	* General Public License for more details.
	11	*/
	12	package buildoptions;
	13
	14	import java.io.BufferedReader;
	15	import java.io.BufferedWriter;
	16	import java.io.File;
	17	import java.io.FileWriter;
	18	import java.io.IOException;
	19	import java.io.InputStreamReader;
	20
	21	/**
	22	* Convert options.txt to format needed in help file options.
	23	* Saves some manual edits to keep both files in sync.
	24	* Used with ant gen-options-file
	25	* @author Mike Baggaley
	26	*
	27	*/
	28	public class OptionsBuilder {
	29
	30	public static void main(String[] args) {
	31	final int indentSize = 4;
	32	boolean hasNonAscii = false;
	33	int lineNumber = 0;
	34	File outputFile = new File(args[0]);
	35	System.setProperty("line.separator", "\n");
	36	try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	37	BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile))) {
	38	String line;
	39	String previousLine = "";
	40	int indent = 0;
	41	boolean preformatted = false;
	42	while((line = br.readLine()) != null) {
	43	++lineNumber;
	44	if (!line.matches("\\p{ASCII}*")) {
	45	System.err.println("Line " + lineNumber + " contains one or more non-ASCII characters.\r\n" + line);
	46	hasNonAscii = true;
	47	}
	48	if (preformatted) {
	49	if (line.trim().compareToIgnoreCase("</pre>") == 0)
	50	preformatted = false;
	51	else {
	52	bw.write(line);
	53	bw.newLine();
	54	}
	55	} else {
	56	line = line.replaceAll("\\s+", " ");
	57	if (line.length() > 0) {
	58	if (line.startsWith(";")) {
	59	line = line.substring(1);
	60	indent = 0;
	61	if (!previousLine.isEmpty()) {
	62	bw.write(previousLine);
	63	bw.newLine();
	64	previousLine = "";
	65	}
	66	}
	67	else if (line.charAt(0) == ':') {
	68	if (!previousLine.isEmpty()) {
	69	bw.write(previousLine);
	70	bw.newLine();
	71	previousLine = "";
	72	}
	73	indent = 1;
	74	line = line.substring(1);
	75	while (line.charAt(0) == ':') {
	76	indent++;
	77	line = line.substring(1);
	78	}
	79	if (line.charAt(0) == ';')
	80	line = line.substring(1);
	81	}
	82	else if (line.trim().compareToIgnoreCase("<p>") == 0) {
	83	if (!previousLine.isEmpty()) {
	84	bw.write(previousLine);
	85	bw.newLine();
	86	previousLine = "";
	87	}
	88	line = "";
	89	bw.newLine();
	90	}
	91	else if (line.trim().compareToIgnoreCase("<pre>") == 0) {
	92	if (!previousLine.isEmpty()) {
	93	bw.write(previousLine);
	94	bw.newLine();
	95	previousLine = "";
	96	}
	97	line = "";
	98	preformatted = true;
	99	}
	100	line = line.trim();
	101	if (!previousLine.isEmpty()) {
	102	if (!line.isEmpty()) {
	103	previousLine += " " + line;
	104	}
	105	} else {
	106	previousLine = line;
	107	for (int i = 0; i < indent; i++) {
	108	for (int j = 0; j < indentSize; j++)
	109	previousLine = " " + previousLine;
	110	}
	111	}
	112	while (previousLine.length() > 79) {
	113	line = previousLine.substring(0, 80);
	114	int lastSpaceIndex = line.lastIndexOf(' ');
	115	int firstNonSpaceIndex = 0;
	116	while (firstNonSpaceIndex < 79) {
	117	if (line.charAt(firstNonSpaceIndex) != ' ')
	118	break;
	119	firstNonSpaceIndex++;
	120	}
	121	if (lastSpaceIndex > firstNonSpaceIndex) {
	122	line = line.substring(0, lastSpaceIndex);
	123	previousLine = previousLine.substring(lastSpaceIndex + 1);
	124	for (int i = 0; i < indent; i++) {
	125	for (int j = 0; j < indentSize; j++)
	126	previousLine = " " + previousLine;
	127	}
	128	bw.write(line);
	129	bw.newLine();
	130	}
	131	else {
	132	bw.write(previousLine);
	133	bw.newLine();
	134	previousLine = "";
	135	}
	136	}
	137	}
	138	else {
	139	indent = 0;
	140	if (!previousLine.isEmpty()) {
	141	bw.write(previousLine);
	142	bw.newLine();
	143	previousLine = "";
	144	}
	145	bw.newLine();
	146	}
	147	}
	148	}
	149	if (!previousLine.isEmpty()) {
	150	bw.write(previousLine);
	151	bw.newLine();
	152	}
	153	} catch (IOException e) {
	154	e.printStackTrace();
	155	System.exit(-1);
	156	}
	157	if (hasNonAscii) {
	158	System.exit(-1);
	159	}
	160	}
	161
	162	}