source: josm/trunk/test/unit/org/openstreetmap/josm/data/projection/ProjectionRefTest.java @ 13618

Last change on this file since 13618 was 13618, checked in by Don-vip, 7 months ago

see #16129 - fix generation of projection reference data with French locale

  • Property svn:eol-style set to native
File size: 15.8 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.projection;
3
4import java.io.BufferedReader;
5import java.io.BufferedWriter;
6import java.io.File;
7import java.io.FileInputStream;
8import java.io.FileOutputStream;
9import java.io.IOException;
10import java.io.InputStream;
11import java.io.InputStreamReader;
12import java.io.OutputStream;
13import java.io.OutputStreamWriter;
14import java.nio.charset.StandardCharsets;
15import java.security.SecureRandom;
16import java.util.ArrayList;
17import java.util.Arrays;
18import java.util.Collection;
19import java.util.HashMap;
20import java.util.HashSet;
21import java.util.LinkedHashSet;
22import java.util.List;
23import java.util.Map;
24import java.util.Objects;
25import java.util.Random;
26import java.util.Set;
27import java.util.TreeMap;
28import java.util.TreeSet;
29import java.util.regex.Matcher;
30import java.util.regex.Pattern;
31
32import org.junit.Assert;
33import org.junit.Rule;
34import org.junit.Test;
35import org.openstreetmap.josm.data.Bounds;
36import org.openstreetmap.josm.data.coor.EastNorth;
37import org.openstreetmap.josm.data.coor.LatLon;
38import org.openstreetmap.josm.gui.preferences.projection.CodeProjectionChoice;
39import org.openstreetmap.josm.testutils.JOSMTestRules;
40import org.openstreetmap.josm.tools.Pair;
41import org.openstreetmap.josm.tools.Utils;
42
43import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
44
45/**
46 * Test projections using reference data from external program.
47 *
48 * To update the reference data file <code>data_nodist/projection/projection-reference-data</code>,
49 * run the main method of this class. For this, you need to have the cs2cs
50 * program from the proj.4 library in path (or use <code>CS2CS_EXE</code> to set
51 * the full path of the executable). Make sure the required *.gsb grid files
52 * can be accessed, i.e. copy them from <code>data_nodist/projection</code> to <code>/usr/share/proj</code> or
53 * wherever cs2cs expects them to be placed.
54 *
55 * The input parameter for the external library is <em>not</em> the projection code
56 * (e.g. "EPSG:25828"), but the entire definition, (e.g. "+proj=utm +zone=28 +ellps=GRS80 +nadgrids=null").
57 * This means the test does not verify our definitions, but the correctness
58 * of the algorithm, given a certain definition.
59 */
60public class ProjectionRefTest {
61
62    private static final String CS2CS_EXE = "cs2cs";
63
64    private static final String REFERENCE_DATA_FILE = "data_nodist/projection/projection-reference-data";
65    private static final String PROJ_LIB_DIR = "data_nodist/projection";
66
67    private static final int MAX_LENGTH = 524288;
68
69    private static class RefEntry {
70        String code;
71        String def;
72        List<Pair<LatLon, EastNorth>> data;
73
74        RefEntry(String code, String def) {
75            this.code = code;
76            this.def = def;
77            this.data = new ArrayList<>();
78        }
79    }
80
81    static Random rand = new SecureRandom();
82
83    static boolean debug;
84
85    /**
86     * Setup test.
87     */
88    @Rule
89    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
90    public JOSMTestRules test = new JOSMTestRules().platform().projectionNadGrids().timeout(30_000);
91
92    /**
93     * Program entry point.
94     * @param args no argument is expected
95     * @throws IOException in case of I/O error
96     */
97    public static void main(String[] args) throws IOException {
98        debug = args.length > 0 && "debug".equals(args[0]);
99        Collection<RefEntry> refs = readData();
100        refs = updateData(refs);
101        writeData(refs);
102    }
103
104    /**
105     * Reads data from the reference file.
106     * @return the data
107     * @throws IOException if any I/O error occurs
108     */
109    private static Collection<RefEntry> readData() throws IOException {
110        Collection<RefEntry> result = new ArrayList<>();
111        if (!new File(REFERENCE_DATA_FILE).exists()) {
112            System.err.println("Warning: refrence file does not exist.");
113            return result;
114        }
115        try (BufferedReader in = new BufferedReader(new InputStreamReader(
116                new FileInputStream(REFERENCE_DATA_FILE), StandardCharsets.UTF_8))) {
117            String line;
118            Pattern projPattern = Pattern.compile("<(.+?)>(.*)<>");
119            RefEntry curEntry = null;
120            while ((line = in.readLine()) != null) {
121                if (line.startsWith("#") || line.trim().isEmpty()) {
122                    continue;
123                }
124                if (line.startsWith("<")) {
125                    Matcher m = projPattern.matcher(line);
126                    if (!m.matches()) {
127                        Assert.fail("unable to parse line: " + line);
128                    }
129                    String code = m.group(1);
130                    String def = m.group(2).trim();
131                    curEntry = new RefEntry(code, def);
132                    result.add(curEntry);
133                } else if (curEntry != null) {
134                    String[] f = line.trim().split(",");
135                    double lon = Double.parseDouble(f[0]);
136                    double lat = Double.parseDouble(f[1]);
137                    double east = Double.parseDouble(f[2]);
138                    double north = Double.parseDouble(f[3]);
139                    curEntry.data.add(Pair.create(new LatLon(lat, lon), new EastNorth(east, north)));
140                }
141            }
142        }
143        return result;
144    }
145
146    /**
147     * Generates new reference data by calling external program cs2cs.
148     *
149     * Old data is kept, as long as the projection definition is still the same.
150     *
151     * @param refs old data
152     * @return updated data
153     */
154    private static Collection<RefEntry> updateData(Collection<RefEntry> refs) {
155        Set<String> failed = new LinkedHashSet<>();
156        final int N_POINTS = 8;
157
158        Map<String, RefEntry> refsMap = new HashMap<>();
159        for (RefEntry ref : refs) {
160            refsMap.put(ref.code, ref);
161        }
162
163        List<RefEntry> refsNew = new ArrayList<>();
164
165        Set<String> codes = new TreeSet<>(new CodeProjectionChoice.CodeComparator());
166        codes.addAll(Projections.getAllProjectionCodes());
167        for (String code : codes) {
168            String def = Projections.getInit(code);
169
170            RefEntry ref = new RefEntry(code, def);
171            RefEntry oldRef = refsMap.get(code);
172
173            if (oldRef != null && Objects.equals(def, oldRef.def)) {
174                for (int i = 0; i < N_POINTS && i < oldRef.data.size(); i++) {
175                    ref.data.add(oldRef.data.get(i));
176                }
177            }
178            if (ref.data.size() < N_POINTS) {
179                System.out.print(code);
180                System.out.flush();
181                Projection proj = Projections.getProjectionByCode(code);
182                Bounds b = proj.getWorldBoundsLatLon();
183                for (int i = ref.data.size(); i < N_POINTS; i++) {
184                    System.out.print(".");
185                    System.out.flush();
186                    LatLon ll = getRandom(b);
187                    EastNorth en = latlon2eastNorthProj4(def, ll);
188                    if (en != null) {
189                        ref.data.add(Pair.create(ll, en));
190                    } else {
191                        System.err.println("Warning: cannot convert "+code+" at "+ll);
192                        failed.add(code);
193                    }
194                }
195                System.out.println();
196            }
197            refsNew.add(ref);
198        }
199        if (!failed.isEmpty()) {
200            System.err.println("Error: the following " + failed.size() + " entries had errors: " + failed);
201        }
202        return refsNew;
203    }
204
205    /**
206     * Get random LatLon value within the bounds.
207     * @param b the bounds
208     * @return random LatLon value within the bounds
209     */
210    private static LatLon getRandom(Bounds b) {
211        double lat, lon;
212        lat = b.getMin().lat() + rand.nextDouble() * (b.getMax().lat() - b.getMin().lat());
213        double minlon = b.getMinLon();
214        double maxlon = b.getMaxLon();
215        if (b.crosses180thMeridian()) {
216            maxlon += 360;
217        }
218        lon = minlon + rand.nextDouble() * (maxlon - minlon);
219        lon = LatLon.toIntervalLon(lon);
220        return new LatLon(lat, lon);
221    }
222
223    /**
224     * Run external cs2cs command from the PROJ.4 library to convert lat/lon to east/north value.
225     * @param def the proj.4 projection definition string
226     * @param ll the LatLon
227     * @return projected EastNorth or null in case of error
228     */
229    @SuppressFBWarnings(value = "COMMAND_INJECTION")
230    private static EastNorth latlon2eastNorthProj4(String def, LatLon ll) {
231        List<String> args = new ArrayList<>();
232        args.add(CS2CS_EXE);
233        args.addAll(Arrays.asList("-f %.9f +proj=longlat +datum=WGS84 +to".split(" ")));
234        // proj.4 cannot read our ntf_r93_b.gsb file
235        // possibly because it is big endian. Use equivalent
236        // little endian file shipped with proj.4.
237        // see http://geodesie.ign.fr/contenu/fichiers/documentation/algorithmes/notice/NT111_V1_HARMEL_TransfoNTF-RGF93_FormatGrilleNTV2.pdf
238        def = def.replace("ntf_r93_b.gsb", "ntf_r93.gsb");
239        args.addAll(Arrays.asList(def.split(" ")));
240        ProcessBuilder pb = new ProcessBuilder(args);
241        pb.environment().put("PROJ_LIB", new File(PROJ_LIB_DIR).getAbsolutePath());
242
243        String output = "";
244        try {
245            Process process = pb.start();
246            OutputStream stdin = process.getOutputStream();
247            InputStream stdout = process.getInputStream();
248            InputStream stderr = process.getErrorStream();
249            try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stdin, StandardCharsets.UTF_8))) {
250                String s = String.format("%s %s%n",
251                        LatLon.cDdHighPecisionFormatter.format(ll.lon()),
252                        LatLon.cDdHighPecisionFormatter.format(ll.lat()));
253                if (debug) {
254                    System.out.println("\n" + String.join(" ", args) + "\n" + s);
255                }
256                writer.write(s);
257            }
258            try (BufferedReader reader = new BufferedReader(new InputStreamReader(stdout, StandardCharsets.UTF_8))) {
259                String line;
260                while (null != (line = reader.readLine())) {
261                    if (debug) {
262                        System.out.println("> " + line);
263                    }
264                    output = line;
265                }
266            }
267            try (BufferedReader reader = new BufferedReader(new InputStreamReader(stderr, StandardCharsets.UTF_8))) {
268                String line;
269                while (null != (line = reader.readLine())) {
270                    System.err.println("! " + line);
271                }
272            }
273        } catch (IOException e) {
274            System.err.println("Error: Running external command failed: " + e + "\nCommand was: "+Utils.join(" ", args));
275            return null;
276        }
277        Pattern p = Pattern.compile("(\\S+)\\s+(\\S+)\\s.*");
278        Matcher m = p.matcher(output);
279        if (!m.matches()) {
280            System.err.println("Error: Cannot parse cs2cs output: '" + output + "'");
281            return null;
282        }
283        String es = m.group(1);
284        String ns = m.group(2);
285        if ("*".equals(es) || "*".equals(ns)) {
286            System.err.println("Error: cs2cs is unable to convert coordinates.");
287            return null;
288        }
289        try {
290            return new EastNorth(Double.parseDouble(es), Double.parseDouble(ns));
291        } catch (NumberFormatException nfe) {
292            System.err.println("Error: Cannot parse cs2cs output: '" + es + "', '" + ns + "'" + "\nCommand was: "+Utils.join(" ", args));
293            return null;
294        }
295    }
296
297    /**
298     * Writes data to file.
299     * @param refs the data
300     * @throws IOException if any I/O error occurs
301     */
302    private static void writeData(Collection<RefEntry> refs) throws IOException {
303        Map<String, RefEntry> refsMap = new TreeMap<>(new CodeProjectionChoice.CodeComparator());
304        for (RefEntry ref : refs) {
305            refsMap.put(ref.code, ref);
306        }
307        try (BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
308                new FileOutputStream(REFERENCE_DATA_FILE), StandardCharsets.UTF_8))) {
309            for (Map.Entry<String, RefEntry> e : refsMap.entrySet()) {
310                RefEntry ref = e.getValue();
311                out.write("<" + ref.code + "> " + ref.def + "  <>\n");
312                for (Pair<LatLon, EastNorth> p : ref.data) {
313                    LatLon ll = p.a;
314                    EastNorth en = p.b;
315                    out.write("    " + ll.lon() + "," + ll.lat() + "," + en.east() + "," + en.north() + "\n");
316                }
317            }
318        }
319    }
320
321    /**
322     * Test projections.
323     * @throws IOException if any I/O error occurs
324     */
325    @Test
326    public void testProjections() throws IOException {
327        StringBuilder fail = new StringBuilder();
328        Set<String> allCodes = new HashSet<>(Projections.getAllProjectionCodes());
329        Collection<RefEntry> refs = readData();
330
331        for (RefEntry ref : refs) {
332            String def0 = Projections.getInit(ref.code);
333            if (def0 == null) {
334                Assert.fail("unknown code: "+ref.code);
335            }
336            if (!ref.def.equals(def0)) {
337                fail.append("definitions for ").append(ref.code).append(" do not match\n");
338            } else {
339                Projection proj = Projections.getProjectionByCode(ref.code);
340                double scale = ((CustomProjection) proj).getToMeter();
341                for (Pair<LatLon, EastNorth> p : ref.data) {
342                    LatLon ll = p.a;
343                    EastNorth enRef = p.b;
344                    enRef = new EastNorth(enRef.east() * scale, enRef.north() * scale); // convert to meter
345
346                    EastNorth en = proj.latlon2eastNorth(ll);
347                    if (proj.switchXY()) {
348                        en = new EastNorth(en.north(), en.east());
349                    }
350                    en = new EastNorth(en.east() * scale, en.north() * scale); // convert to meter
351                    final double EPSILON_EN = 1e-2; // 1cm
352                    if (!isEqual(enRef, en, EPSILON_EN, true)) {
353                        String errorEN = String.format("%s (%s): Projecting latlon(%s,%s):%n" +
354                                "        expected: eastnorth(%s,%s),%n" +
355                                "        but got:  eastnorth(%s,%s)!%n",
356                                proj.toString(), proj.toCode(), ll.lat(), ll.lon(), enRef.east(), enRef.north(), en.east(), en.north());
357                        fail.append(errorEN);
358                    }
359                }
360            }
361            allCodes.remove(ref.code);
362        }
363        if (!allCodes.isEmpty()) {
364            Assert.fail("no reference data for following projections: "+allCodes);
365        }
366        if (fail.length() > 0) {
367            String s = fail.toString();
368            if (s.length() > MAX_LENGTH) {
369                // SonarQube/Surefire can't parse XML attributes longer than 524288 characters
370                s = s.substring(0, MAX_LENGTH - 4) + "...";
371            }
372            System.err.println(s);
373            throw new AssertionError(s);
374        }
375    }
376
377    /**
378     * Check if two EastNorth objects are equal.
379     * @param en1 first value
380     * @param en2 second value
381     * @param epsilon allowed tolerance
382     * @param abs true if absolute value is compared; this is done as long as
383     * advanced axis configuration is not supported in JOSM
384     * @return true if both are considered equal
385     */
386    private static boolean isEqual(EastNorth en1, EastNorth en2, double epsilon, boolean abs) {
387        double east1 = en1.east();
388        double north1 = en1.north();
389        double east2 = en2.east();
390        double north2 = en2.north();
391        if (abs) {
392            east1 = Math.abs(east1);
393            north1 = Math.abs(north1);
394            east2 = Math.abs(east2);
395            north2 = Math.abs(north2);
396        }
397        return Math.abs(east1 - east2) < epsilon && Math.abs(north1 - north2) < epsilon;
398    }
399}
Note: See TracBrowser for help on using the repository browser.