Line data Source code
1 : ///////////////////////////////////////////////////////////////////////////////
2 : //
3 : // Project: C++ Test Suite for GDAL/OGR
4 : // Purpose: OGR Spatial Reference general features test.
5 : // Author: Mateusz Loskot <mateusz@loskot.net>
6 : //
7 : ///////////////////////////////////////////////////////////////////////////////
8 : // Copyright (c) 2006, Mateusz Loskot <mateusz@loskot.net>
9 : /*
10 : * Permission is hereby granted, free of charge, to any person obtaining a
11 : * copy of this software and associated documentation files (the "Software"),
12 : * to deal in the Software without restriction, including without limitation
13 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 : * and/or sell copies of the Software, and to permit persons to whom the
15 : * Software is furnished to do so, subject to the following conditions:
16 : *
17 : * The above copyright notice and this permission notice shall be included
18 : * in all copies or substantial portions of the Software.
19 : *
20 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 : * DEALINGS IN THE SOFTWARE.
27 : ****************************************************************************/
28 :
29 : #include "gdal_unit_test.h"
30 :
31 : #include "cpl_string.h"
32 : #include "ogr_srs_api.h"
33 : #include "ogr_spatialref.h"
34 :
35 : #include <algorithm>
36 : #include <cmath>
37 : #include <string>
38 :
39 : #include "gtest_include.h"
40 :
41 : namespace
42 : {
43 :
44 : // Common fixture with test data
45 : struct test_osr : public ::testing::Test
46 : {
47 : OGRErr err_ = OGRERR_NONE;
48 : OGRSpatialReferenceH srs_ = nullptr;
49 :
50 14 : void SetUp() override
51 : {
52 14 : srs_ = OSRNewSpatialReference(nullptr);
53 14 : ASSERT_TRUE(nullptr != srs_);
54 : }
55 :
56 14 : void TearDown() override
57 : {
58 14 : OSRDestroySpatialReference(srs_);
59 14 : srs_ = nullptr;
60 14 : }
61 : };
62 :
63 : // Test UTM WGS84 coordinate system and its various items
64 4 : TEST_F(test_osr, UTM_WGS84)
65 : {
66 1 : err_ = OSRSetUTM(srs_, 11, TRUE);
67 1 : ASSERT_EQ(err_, OGRERR_NONE);
68 :
69 1 : err_ = OSRSetWellKnownGeogCS(srs_, "WGS84");
70 1 : ASSERT_EQ(err_, OGRERR_NONE);
71 :
72 1 : double val = 0;
73 :
74 1 : val = OSRGetProjParm(srs_, SRS_PP_CENTRAL_MERIDIAN, -1111, &err_);
75 1 : EXPECT_NEAR(val, -117.0, .00000000000010);
76 :
77 1 : val = OSRGetProjParm(srs_, SRS_PP_LATITUDE_OF_ORIGIN, -1111, &err_);
78 1 : EXPECT_NEAR(val, 0.0, .00000000000010);
79 :
80 1 : val = OSRGetProjParm(srs_, SRS_PP_SCALE_FACTOR, -1111, &err_);
81 1 : EXPECT_NEAR(val, 0.9996, .00000000000010);
82 :
83 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_EASTING, -1111, &err_);
84 1 : EXPECT_NEAR(val, 500000, .00000000000010);
85 :
86 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_NORTHING, -1111, &err_);
87 1 : EXPECT_NEAR(val, 0.0, .00000000000010);
88 :
89 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "GEOGCS"), "EPSG");
90 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "GEOGCS"), "4326");
91 :
92 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "DATUM"), "EPSG");
93 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "DATUM"), "6326");
94 : }
95 :
96 : // Simple default NAD83 State Plane zone
97 4 : TEST_F(test_osr, NAD83_State_Plane)
98 : {
99 : // California III NAD83
100 1 : OSRSetStatePlane(srs_, 403, 1);
101 :
102 1 : double val = 0;
103 :
104 1 : val = OSRGetProjParm(srs_, SRS_PP_STANDARD_PARALLEL_1, -1111, &err_);
105 1 : EXPECT_NEAR(val, 38.43333333333333, 1e-12);
106 :
107 1 : val = OSRGetProjParm(srs_, SRS_PP_STANDARD_PARALLEL_2, -1111, &err_);
108 1 : EXPECT_NEAR(val, 37.06666666666667, 1e-12);
109 :
110 1 : val = OSRGetProjParm(srs_, SRS_PP_LATITUDE_OF_ORIGIN, -1111, &err_);
111 1 : EXPECT_NEAR(val, 36.5, 1e-12);
112 :
113 1 : val = OSRGetProjParm(srs_, SRS_PP_CENTRAL_MERIDIAN, -1111, &err_);
114 1 : EXPECT_NEAR(val, -120.5, 1e-12);
115 :
116 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_EASTING, -1111, &err_);
117 1 : EXPECT_NEAR(val, 2000000.0, 1e-12);
118 :
119 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_NORTHING, -1111, &err_);
120 1 : EXPECT_NEAR(val, 500000.0, 1e-12);
121 :
122 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "GEOGCS"), "EPSG");
123 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "GEOGCS"), "4269");
124 :
125 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "DATUM"), "EPSG");
126 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "DATUM"), "6269");
127 :
128 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "PROJCS"), "EPSG");
129 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "PROJCS"), "26943");
130 :
131 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "PROJCS|UNIT"), "EPSG");
132 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "PROJCS|UNIT"), "9001");
133 1 : }
134 :
135 : // NAD83 State Plane zone, but overridden to be in Feet
136 4 : TEST_F(test_osr, NAD83_State_Plane_Feet)
137 : {
138 : // California III NAD83 (feet)
139 1 : OSRSetStatePlaneWithUnits(srs_, 403, 1, "Foot", 0.3048006096012192);
140 :
141 1 : double val = 0;
142 :
143 1 : val = OSRGetProjParm(srs_, SRS_PP_STANDARD_PARALLEL_1, -1111, &err_);
144 1 : EXPECT_NEAR(val, 38.43333333333333, 1e-12);
145 :
146 1 : val = OSRGetProjParm(srs_, SRS_PP_STANDARD_PARALLEL_2, -1111, &err_);
147 1 : EXPECT_NEAR(val, 37.06666666666667, 1e-12);
148 :
149 1 : val = OSRGetProjParm(srs_, SRS_PP_LATITUDE_OF_ORIGIN, -1111, &err_);
150 1 : EXPECT_NEAR(val, 36.5, 1e-12);
151 :
152 1 : val = OSRGetProjParm(srs_, SRS_PP_CENTRAL_MERIDIAN, -1111, &err_);
153 1 : EXPECT_NEAR(val, -120.5, 1e-12);
154 :
155 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_EASTING, -1111, &err_);
156 1 : EXPECT_NEAR(val, 6561666.666666667, 1e-12);
157 :
158 1 : val = OSRGetProjParm(srs_, SRS_PP_FALSE_NORTHING, -1111, &err_);
159 1 : EXPECT_NEAR(val, 1640416.666666667, 1e-12);
160 :
161 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "GEOGCS"), "EPSG");
162 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "GEOGCS"), "4269");
163 :
164 1 : EXPECT_STREQ(OSRGetAuthorityName(srs_, "DATUM"), "EPSG");
165 1 : EXPECT_STREQ(OSRGetAuthorityCode(srs_, "DATUM"), "6269");
166 :
167 1 : EXPECT_TRUE(nullptr == OSRGetAuthorityName(srs_, "PROJCS"));
168 1 : EXPECT_TRUE(nullptr == OSRGetAuthorityCode(srs_, "PROJCS|UNIT"));
169 :
170 1 : char *unitsName = nullptr;
171 1 : val = OSRGetLinearUnits(srs_, &unitsName);
172 1 : ASSERT_TRUE(nullptr != unitsName);
173 1 : EXPECT_STREQ(unitsName, "Foot");
174 : }
175 :
176 : // Translate a coordinate system with NAD shift into to PROJ.4 and back.
177 : // Also, verify that the TOWGS84 parameters are preserved.
178 4 : TEST_F(test_osr, NAD_shift)
179 : {
180 1 : err_ = OSRSetGS(srs_, -117.0, 100000.0, 100000);
181 1 : EXPECT_EQ(err_, OGRERR_NONE);
182 :
183 1 : err_ = OSRSetGeogCS(srs_, "Test GCS", "Test Datum", "WGS84",
184 : SRS_WGS84_SEMIMAJOR, SRS_WGS84_INVFLATTENING, nullptr,
185 : 0, nullptr, 0);
186 1 : EXPECT_EQ(err_, OGRERR_NONE);
187 :
188 1 : err_ = OSRSetTOWGS84(srs_, 1, 2, 3, 0, 0, 0, 0);
189 1 : EXPECT_EQ(err_, OGRERR_NONE);
190 :
191 1 : const int coeffSize = 7;
192 1 : double coeff[coeffSize] = {0};
193 1 : const double expect[coeffSize] = {1, 2, 3, 0, 0, 0, 0};
194 :
195 1 : err_ = OSRGetTOWGS84(srs_, coeff, 7);
196 1 : EXPECT_EQ(err_, OGRERR_NONE);
197 1 : EXPECT_TRUE(std::equal(coeff, coeff + coeffSize, expect));
198 1 : OSRSetLinearUnits(srs_, "Metre", 1);
199 :
200 1 : char *proj4 = nullptr;
201 1 : err_ = OSRExportToProj4(srs_, &proj4);
202 1 : EXPECT_EQ(err_, OGRERR_NONE);
203 :
204 1 : OGRSpatialReferenceH srs2 = nullptr;
205 1 : srs2 = OSRNewSpatialReference(nullptr);
206 :
207 1 : err_ = OSRImportFromProj4(srs2, proj4);
208 1 : EXPECT_EQ(err_, OGRERR_NONE);
209 :
210 1 : err_ = OSRGetTOWGS84(srs2, coeff, 7);
211 1 : EXPECT_EQ(err_, OGRERR_NONE);
212 1 : EXPECT_TRUE(std::equal(coeff, coeff + coeffSize, expect));
213 :
214 1 : OSRDestroySpatialReference(srs2);
215 1 : CPLFree(proj4);
216 1 : }
217 :
218 : // Test URN support for OGC:CRS84
219 4 : TEST_F(test_osr, URN_OGC_CRS84)
220 : {
221 1 : err_ = OSRSetFromUserInput(srs_, "urn:ogc:def:crs:OGC:1.3:CRS84");
222 1 : ASSERT_EQ(err_, OGRERR_NONE);
223 :
224 1 : char *wkt1 = nullptr;
225 1 : err_ = OSRExportToWkt(srs_, &wkt1);
226 1 : EXPECT_EQ(err_, OGRERR_NONE);
227 1 : EXPECT_TRUE(nullptr != wkt1);
228 :
229 1 : CPLFree(wkt1);
230 : }
231 :
232 : // Test URN support for EPSG
233 4 : TEST_F(test_osr, URN_EPSG)
234 : {
235 1 : err_ = OSRSetFromUserInput(srs_, "urn:ogc:def:crs:EPSG::4326");
236 1 : ASSERT_EQ(err_, OGRERR_NONE);
237 :
238 1 : char *wkt1 = nullptr;
239 1 : err_ = OSRExportToWkt(srs_, &wkt1);
240 1 : EXPECT_EQ(err_, OGRERR_NONE);
241 1 : EXPECT_TRUE(nullptr != wkt1);
242 :
243 1 : err_ = OSRSetFromUserInput(srs_, "EPSGA:4326");
244 1 : EXPECT_EQ(err_, OGRERR_NONE);
245 :
246 1 : char *wkt2 = nullptr;
247 1 : err_ = OSRExportToWkt(srs_, &wkt2);
248 1 : EXPECT_EQ(err_, OGRERR_NONE);
249 1 : EXPECT_TRUE(nullptr != wkt2);
250 :
251 1 : EXPECT_STREQ(wkt1, wkt2);
252 1 : CPLFree(wkt1);
253 1 : CPLFree(wkt2);
254 : }
255 :
256 : // Test URN support for auto projection
257 4 : TEST_F(test_osr, URN_AUTO)
258 : {
259 1 : err_ = OSRSetFromUserInput(srs_, "urn:ogc:def:crs:OGC::AUTO42001:-117:33");
260 1 : ASSERT_EQ(err_, OGRERR_NONE);
261 :
262 2 : OGRSpatialReference oSRS;
263 1 : oSRS.importFromEPSG(32611);
264 :
265 1 : EXPECT_TRUE(oSRS.IsSame(OGRSpatialReference::FromHandle(srs_)));
266 : }
267 :
268 : // Test StripTOWGS84IfKnownDatum
269 4 : TEST_F(test_osr, StripTOWGS84IfKnownDatum)
270 : {
271 : // Not a boundCRS
272 : {
273 2 : OGRSpatialReference oSRS;
274 1 : oSRS.importFromEPSG(4326);
275 1 : EXPECT_TRUE(!oSRS.StripTOWGS84IfKnownDatum());
276 : }
277 : // Custom boundCRS --> do not strip TOWGS84
278 : {
279 2 : OGRSpatialReference oSRS;
280 1 : oSRS.SetFromUserInput(
281 : "+proj=longlat +ellps=GRS80 +towgs84=1,2,3,4,5,6,7");
282 1 : EXPECT_TRUE(!oSRS.StripTOWGS84IfKnownDatum());
283 1 : double vals[7] = {0};
284 1 : EXPECT_TRUE(oSRS.GetTOWGS84(vals, 7) == OGRERR_NONE);
285 : }
286 : // BoundCRS whose base CRS has a known code --> strip TOWGS84
287 : {
288 2 : OGRSpatialReference oSRS;
289 1 : oSRS.importFromEPSG(4326);
290 1 : oSRS.SetTOWGS84(1, 2, 3, 4, 5, 6, 7);
291 1 : EXPECT_TRUE(oSRS.StripTOWGS84IfKnownDatum());
292 1 : double vals[7] = {0};
293 1 : EXPECT_TRUE(oSRS.GetTOWGS84(vals, 7) != OGRERR_NONE);
294 : }
295 : // BoundCRS whose datum code is known --> strip TOWGS84
296 : {
297 2 : OGRSpatialReference oSRS;
298 1 : oSRS.SetFromUserInput("GEOGCS[\"bar\","
299 : "DATUM[\"foo\","
300 : "SPHEROID[\"WGS 84\",6378137,298.257223563],"
301 : "TOWGS84[1,2,3,4,5,6,7],"
302 : "AUTHORITY[\"FOO\",\"1\"]],"
303 : "PRIMEM[\"Greenwich\",0],"
304 : "UNIT[\"degree\",0.0174532925199433]]");
305 1 : EXPECT_TRUE(oSRS.StripTOWGS84IfKnownDatum());
306 1 : double vals[7] = {0};
307 1 : EXPECT_TRUE(oSRS.GetTOWGS84(vals, 7) != OGRERR_NONE);
308 : }
309 : // BoundCRS whose datum name is known --> strip TOWGS84
310 : {
311 2 : OGRSpatialReference oSRS;
312 1 : oSRS.SetFromUserInput("GEOGCS[\"WGS 84\","
313 : "DATUM[\"WGS_1984\","
314 : "SPHEROID[\"WGS 84\",6378137,298.257223563],"
315 : "TOWGS84[1,2,3,4,5,6,7]],"
316 : "PRIMEM[\"Greenwich\",0],"
317 : "UNIT[\"degree\",0.0174532925199433]]");
318 1 : EXPECT_TRUE(oSRS.StripTOWGS84IfKnownDatum());
319 1 : double vals[7] = {0};
320 1 : EXPECT_TRUE(oSRS.GetTOWGS84(vals, 7) != OGRERR_NONE);
321 : }
322 : // BoundCRS whose datum name is unknown --> do not strip TOWGS84
323 : {
324 2 : OGRSpatialReference oSRS;
325 1 : oSRS.SetFromUserInput("GEOGCS[\"WGS 84\","
326 : "DATUM[\"i am unknown\","
327 : "SPHEROID[\"WGS 84\",6378137,298.257223563],"
328 : "TOWGS84[1,2,3,4,5,6,7]],"
329 : "PRIMEM[\"Greenwich\",0],"
330 : "UNIT[\"degree\",0.0174532925199433]]");
331 1 : EXPECT_TRUE(!oSRS.StripTOWGS84IfKnownDatum());
332 1 : double vals[7] = {0};
333 1 : EXPECT_TRUE(oSRS.GetTOWGS84(vals, 7) == OGRERR_NONE);
334 : }
335 1 : }
336 :
337 : // Test GetEPSGGeogCS
338 4 : TEST_F(test_osr, GetEPSGGeogCS)
339 : {
340 : // When export to WKT1 is not possible
341 2 : OGRSpatialReference oSRS;
342 1 : oSRS.SetFromUserInput(
343 : "PROJCRS[\"World_Vertical_Perspective\",\n"
344 : " BASEGEOGCRS[\"WGS 84\",\n"
345 : " DATUM[\"World Geodetic System 1984\",\n"
346 : " ELLIPSOID[\"WGS 84\",6378137,298.257223563,\n"
347 : " LENGTHUNIT[\"metre\",1]]],\n"
348 : " PRIMEM[\"Greenwich\",0,\n"
349 : " ANGLEUNIT[\"Degree\",0.0174532925199433]]],\n"
350 : " CONVERSION[\"World_Vertical_Perspective\",\n"
351 : " METHOD[\"Vertical Perspective\",\n"
352 : " ID[\"EPSG\",9838]],\n"
353 : " PARAMETER[\"Latitude of topocentric origin\",0,\n"
354 : " ANGLEUNIT[\"Degree\",0.0174532925199433],\n"
355 : " ID[\"EPSG\",8834]],\n"
356 : " PARAMETER[\"Longitude of topocentric origin\",0,\n"
357 : " ANGLEUNIT[\"Degree\",0.0174532925199433],\n"
358 : " ID[\"EPSG\",8835]],\n"
359 : " PARAMETER[\"Viewpoint height\",35800000,\n"
360 : " LENGTHUNIT[\"metre\",1],\n"
361 : " ID[\"EPSG\",8840]]],\n"
362 : " CS[Cartesian,2],\n"
363 : " AXIS[\"(E)\",east,\n"
364 : " ORDER[1],\n"
365 : " LENGTHUNIT[\"metre\",1]],\n"
366 : " AXIS[\"(N)\",north,\n"
367 : " ORDER[2],\n"
368 : " LENGTHUNIT[\"metre\",1]],\n"
369 : " USAGE[\n"
370 : " SCOPE[\"Not known.\"],\n"
371 : " AREA[\"World.\"],\n"
372 : " BBOX[-90,-180,90,180]],\n"
373 : " ID[\"ESRI\",54049]]");
374 1 : EXPECT_EQ(oSRS.GetEPSGGeogCS(), 4326);
375 1 : }
376 :
377 : // Test GetOGCURN
378 4 : TEST_F(test_osr, GetOGCURN)
379 : {
380 : {
381 2 : OGRSpatialReference oSRS;
382 1 : char *pszRet = oSRS.GetOGCURN();
383 1 : EXPECT_TRUE(pszRet == nullptr);
384 1 : CPLFree(pszRet);
385 : }
386 : {
387 2 : OGRSpatialReference oSRS;
388 1 : oSRS.SetFromUserInput("+proj=longlat");
389 1 : char *pszRet = oSRS.GetOGCURN();
390 1 : EXPECT_TRUE(pszRet == nullptr);
391 1 : CPLFree(pszRet);
392 : }
393 :
394 : {
395 2 : OGRSpatialReference oSRS;
396 1 : oSRS.importFromEPSG(32631);
397 1 : char *pszRet = oSRS.GetOGCURN();
398 1 : EXPECT_TRUE(pszRet != nullptr);
399 1 : if (pszRet)
400 : {
401 1 : EXPECT_STREQ(pszRet, "urn:ogc:def:crs:EPSG::32631");
402 : }
403 1 : CPLFree(pszRet);
404 : }
405 :
406 : {
407 2 : OGRSpatialReference oSRS;
408 1 : oSRS.SetFromUserInput("EPSG:32631+5773");
409 1 : char *pszRet = oSRS.GetOGCURN();
410 1 : EXPECT_TRUE(pszRet != nullptr);
411 1 : if (pszRet)
412 : {
413 1 : EXPECT_STREQ(pszRet,
414 : "urn:ogc:def:crs,crs:EPSG::32631,crs:EPSG::5773");
415 : }
416 1 : CPLFree(pszRet);
417 : }
418 1 : }
419 :
420 : // Test constructors and assignment operators
421 4 : TEST_F(test_osr, constructors_assignment_operators)
422 : {
423 1 : OGRSpatialReference oSRS;
424 1 : oSRS.importFromEPSG(32631);
425 :
426 1 : OGRSpatialReference oSRS2(oSRS);
427 1 : ASSERT_TRUE(oSRS2.GetAuthorityCode(nullptr) != nullptr);
428 :
429 1 : OGRSpatialReference oSRS3;
430 1 : OGRSpatialReference &oSRSRef(oSRS);
431 1 : oSRS = oSRSRef;
432 1 : ASSERT_TRUE(oSRS.GetAuthorityCode(nullptr) != nullptr);
433 1 : oSRS3 = oSRS;
434 1 : ASSERT_TRUE(oSRS3.GetAuthorityCode(nullptr) != nullptr);
435 :
436 1 : OGRSpatialReference oSRS4(std::move(oSRS));
437 1 : ASSERT_TRUE(oSRS4.GetAuthorityCode(nullptr) != nullptr);
438 :
439 1 : OGRSpatialReference oSRS5;
440 1 : OGRSpatialReference &oSRS4Ref(oSRS4);
441 1 : oSRS4 = std::move(oSRS4Ref);
442 1 : ASSERT_TRUE(oSRS4.GetAuthorityCode(nullptr) != nullptr);
443 1 : oSRS5 = std::move(oSRS4);
444 1 : ASSERT_TRUE(oSRS5.GetAuthorityCode(nullptr) != nullptr);
445 : }
446 :
447 18 : static int GetEPSGCode(OGRSpatialReference &oSRS)
448 : {
449 18 : int nEPSG = 0;
450 18 : auto pszEPSG = oSRS.GetAuthorityCode("PROJCS");
451 18 : if (pszEPSG == nullptr)
452 : {
453 2 : pszEPSG = oSRS.GetAuthorityCode("GEOGCS");
454 : }
455 18 : if (pszEPSG == nullptr)
456 : {
457 2 : pszEPSG = oSRS.GetAuthorityCode("VERT_CS");
458 : }
459 18 : if (pszEPSG != nullptr)
460 : {
461 17 : nEPSG = atoi(pszEPSG);
462 : }
463 18 : return nEPSG;
464 : }
465 :
466 : // Test exportVertCSToPanorama
467 4 : TEST_F(test_osr, exportVertCSToPanorama)
468 : {
469 2 : OGRSpatialReference oSRS;
470 1 : oSRS.importFromEPSG(28407);
471 :
472 2 : OGRSpatialReference oVertSRS;
473 1 : oVertSRS.importFromEPSG(5705);
474 1 : EXPECT_TRUE(oVertSRS.IsVertical() == TRUE);
475 1 : EXPECT_STRNE(oVertSRS.GetAttrValue("VERT_CS"), "");
476 1 : EXPECT_STRNE(oVertSRS.GetAttrValue("VERT_DATUM"), "");
477 1 : EXPECT_EQ(GetEPSGCode(oVertSRS), 5705);
478 :
479 1 : oSRS.SetVertCS(oVertSRS.GetAttrValue("VERT_CS"),
480 : oVertSRS.GetAttrValue("VERT_DATUM"));
481 :
482 1 : int nVertID = 0;
483 1 : oSRS.exportVertCSToPanorama(&nVertID);
484 1 : EXPECT_EQ(nVertID, 25);
485 1 : }
486 :
487 : // Test importFromPanorama
488 4 : TEST_F(test_osr, importFromPanorama)
489 : {
490 2 : OGRSpatialReference oSRS;
491 1 : oSRS.importFromPanorama(35, 0, 45, nullptr);
492 1 : EXPECT_EQ(GetEPSGCode(oSRS), 3857);
493 :
494 1 : oSRS.importFromPanorama(35, 0, 9, nullptr);
495 1 : EXPECT_EQ(GetEPSGCode(oSRS), 3395);
496 :
497 1 : constexpr double TO_RADIANS = 0.017453292519943295769;
498 : {
499 : // WGS 84 / UTM zone 1
500 1 : double adfPrjParams[8] = {0.0, 0.0, 0.0, -177 * TO_RADIANS,
501 : 0.9996, 500000.0, 0.0, 0.0};
502 1 : oSRS.importFromPanorama(17, 2, 9, adfPrjParams);
503 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32601);
504 :
505 1 : oSRS.importFromPanorama(17, 2, 9, adfPrjParams, FALSE);
506 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32701);
507 : }
508 : {
509 : // WGS 84 / UTM zone 37
510 1 : double adfPrjParams[8] = {0.0, 0.0, 0.0, 39 * TO_RADIANS,
511 : 0.9996, 500000.0, 0.0, 0.0};
512 1 : oSRS.importFromPanorama(17, 2, 9, adfPrjParams);
513 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32637);
514 :
515 1 : oSRS.importFromPanorama(17, 2, 9, adfPrjParams, FALSE);
516 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32737);
517 : }
518 : {
519 : // Pulkovo 1942 / Gauss-Kruger zone 4
520 1 : double adfPrjParams[8] = {0.0, 0.0, 0.0, 21 * TO_RADIANS,
521 : 1.0, 4500000.0, 0.0, 0.0};
522 1 : oSRS.importFromPanorama(1, 1, 1, adfPrjParams);
523 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28404);
524 1 : oSRS.importFromPanorama(1, 0, 0, adfPrjParams);
525 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28404);
526 1 : adfPrjParams[7] = 4;
527 1 : oSRS.importFromPanorama(1, 1, 1, adfPrjParams);
528 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28404);
529 : }
530 : {
531 : // Pulkovo 1942 / Gauss-Kruger zone 31
532 1 : double adfPrjParams[8] = {0.0, 0.0, 0.0, -177 * TO_RADIANS,
533 : 1.0, 31500000.0, 0.0, 0.0};
534 1 : oSRS.importFromPanorama(1, 1, 1, adfPrjParams);
535 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28431);
536 1 : oSRS.importFromPanorama(1, 0, 0, adfPrjParams);
537 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28431);
538 1 : adfPrjParams[7] = 31;
539 1 : oSRS.importFromPanorama(1, 1, 1, adfPrjParams);
540 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28431);
541 : }
542 : {
543 : // Invalid data
544 1 : double adfPrjParams[8] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
545 1 : oSRS.importFromPanorama(0, 0, 0, adfPrjParams);
546 1 : EXPECT_EQ(oSRS.IsLocal(), true);
547 1 : EXPECT_EQ(GetEPSGCode(oSRS), 0);
548 : }
549 1 : }
550 :
551 : // Test exportToPanorama
552 4 : TEST_F(test_osr, exportToPanorama)
553 : {
554 1 : constexpr double RAD = 0.017453292519943295769;
555 1 : constexpr double EPS = 1e-12;
556 :
557 : {
558 2 : OGRSpatialReference oSRS;
559 1 : oSRS.importFromEPSG(32601); // WGS 84 / UTM zone 1N
560 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32601);
561 :
562 1 : long iProjSys = 0;
563 1 : long iDatum = 0;
564 1 : long iEllips = 0;
565 1 : long iZone = 0;
566 1 : double adfParams[7] = {0};
567 1 : oSRS.exportToPanorama(&iProjSys, &iDatum, &iEllips, &iZone, adfParams);
568 1 : EXPECT_EQ(iProjSys, 17);
569 1 : EXPECT_EQ(iDatum, 6);
570 1 : EXPECT_EQ(iEllips, 9);
571 1 : EXPECT_EQ(iZone, 1);
572 1 : EXPECT_NEAR(adfParams[2], 0.0, EPS); //latitude_of_origin
573 1 : EXPECT_NEAR(adfParams[3], -177 * RAD, EPS); //central_meridian
574 1 : EXPECT_NEAR(adfParams[4], 0.9996, EPS); //scale_factor
575 1 : EXPECT_NEAR(adfParams[5], 500000, EPS); //false_easting
576 1 : EXPECT_NEAR(adfParams[6], 0, EPS); //false_northing
577 : }
578 :
579 : {
580 2 : OGRSpatialReference oSRS;
581 1 : oSRS.importFromEPSG(32660); // WGS 84 / UTM zone 1N
582 1 : EXPECT_EQ(GetEPSGCode(oSRS), 32660);
583 :
584 1 : long iProjSys = 0;
585 1 : long iDatum = 0;
586 1 : long iEllips = 0;
587 1 : long iZone = 0;
588 1 : double adfParams[7] = {0};
589 1 : oSRS.exportToPanorama(&iProjSys, &iDatum, &iEllips, &iZone, adfParams);
590 1 : EXPECT_EQ(iProjSys, 17);
591 1 : EXPECT_EQ(iDatum, 6);
592 1 : EXPECT_EQ(iEllips, 9);
593 1 : EXPECT_EQ(iZone, 60);
594 1 : EXPECT_NEAR(adfParams[2], 0.0, EPS); //latitude_of_origin
595 1 : EXPECT_NEAR(adfParams[3], 177 * RAD, EPS); //central_meridian
596 1 : EXPECT_NEAR(adfParams[4], 0.9996, EPS); //scale_factor
597 1 : EXPECT_NEAR(adfParams[5], 500000, EPS); //false_easting
598 1 : EXPECT_NEAR(adfParams[6], 0, EPS); //false_northing
599 : }
600 :
601 : {
602 2 : OGRSpatialReference oSRS;
603 1 : oSRS.importFromEPSG(28404); // Pulkovo 1942 / Gauss-Kruger zone 4
604 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28404);
605 :
606 1 : long iProjSys = 0;
607 1 : long iDatum = 0;
608 1 : long iEllips = 0;
609 1 : long iZone = 0;
610 1 : double adfParams[7] = {0};
611 1 : oSRS.exportToPanorama(&iProjSys, &iDatum, &iEllips, &iZone, adfParams);
612 1 : EXPECT_EQ(iProjSys, 1);
613 1 : EXPECT_EQ(iDatum, 1);
614 1 : EXPECT_EQ(iEllips, 1);
615 1 : EXPECT_EQ(iZone, 4);
616 1 : EXPECT_NEAR(adfParams[2], 0.0, EPS); //latitude_of_origin
617 1 : EXPECT_NEAR(adfParams[3], 21 * RAD, EPS); //central_meridian
618 1 : EXPECT_NEAR(adfParams[4], 1.0, EPS); //scale_factor
619 1 : EXPECT_NEAR(adfParams[5], 4500000, EPS); //false_easting
620 1 : EXPECT_NEAR(adfParams[6], 0, EPS); //false_northing
621 : }
622 : {
623 2 : OGRSpatialReference oSRS;
624 1 : oSRS.importFromEPSG(28431); // Pulkovo 1942 / Gauss-Kruger zone 31
625 1 : EXPECT_EQ(GetEPSGCode(oSRS), 28431);
626 :
627 1 : long iProjSys = 0;
628 1 : long iDatum = 0;
629 1 : long iEllips = 0;
630 1 : long iZone = 0;
631 1 : double adfParams[7] = {0};
632 1 : oSRS.exportToPanorama(&iProjSys, &iDatum, &iEllips, &iZone, adfParams);
633 1 : EXPECT_EQ(iProjSys, 1);
634 1 : EXPECT_EQ(iDatum, 1);
635 1 : EXPECT_EQ(iEllips, 1);
636 1 : EXPECT_EQ(iZone, 31);
637 1 : EXPECT_NEAR(adfParams[2], 0.0, EPS); //latitude_of_origin
638 1 : EXPECT_NEAR(adfParams[3], -177 * RAD, EPS); //central_meridian
639 1 : EXPECT_NEAR(adfParams[4], 1.0, EPS); //scale_factor
640 1 : EXPECT_NEAR(adfParams[5], 31500000, EPS); //false_easting
641 1 : EXPECT_NEAR(adfParams[6], 0, EPS); //false_northing
642 : }
643 1 : }
644 : } // namespace
|
