root / org.gvsig.projection.jcrs / trunk / org.gvsig.projection.jcrs / org.gvsig.projection.jcrs.lib / src / main / java / org / gvsig / crs / Proj4.java @ 245
History | View | Annotate | Download (177 KB)
1 | 147 | jjdelcerro | /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
|
---|---|---|---|
2 | *
|
||
3 | * Copyright (C) 2006 Instituto de Desarrollo Regional and Generalitat Valenciana.
|
||
4 | *
|
||
5 | * This program is free software; you can redistribute it and/or
|
||
6 | * modify it under the terms of the GNU General Public License
|
||
7 | * as published by the Free Software Foundation; either version 2
|
||
8 | * of the License, or (at your option) any later version.
|
||
9 | *
|
||
10 | * This program is distributed in the hope that it will be useful,
|
||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
13 | * GNU General Public License for more details.
|
||
14 | *
|
||
15 | * You should have received a copy of the GNU General Public License
|
||
16 | * along with this program; if not, write to the Free Software
|
||
17 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
||
18 | *
|
||
19 | * For more information, contact:
|
||
20 | *
|
||
21 | * Generalitat Valenciana
|
||
22 | * Conselleria d'Infraestructures i Transport
|
||
23 | * Av. Blasco Ib??ez, 50
|
||
24 | * 46010 VALENCIA
|
||
25 | * SPAIN
|
||
26 | *
|
||
27 | * +34 963862235
|
||
28 | * gvsig@gva.es
|
||
29 | * www.gvsig.gva.es
|
||
30 | *
|
||
31 | * or
|
||
32 | *
|
||
33 | * Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)
|
||
34 | * Campus Universitario s/n
|
||
35 | * 02071 Alabacete
|
||
36 | * Spain
|
||
37 | *
|
||
38 | * +34 967 599 200
|
||
39 | */
|
||
40 | |||
41 | package org.gvsig.crs; |
||
42 | |||
43 | import java.util.ArrayList; |
||
44 | import java.util.Iterator; |
||
45 | |||
46 | import javax.units.ConversionException; |
||
47 | import javax.units.Unit; |
||
48 | |||
49 | import org.geotools.referencing.crs.DefaultGeographicCRS; |
||
50 | import org.geotools.referencing.crs.DefaultProjectedCRS; |
||
51 | import org.geotools.referencing.datum.DefaultGeodeticDatum; |
||
52 | import org.geotools.referencing.datum.DefaultPrimeMeridian; |
||
53 | import org.opengis.metadata.Identifier; |
||
54 | import org.opengis.referencing.crs.CoordinateReferenceSystem; |
||
55 | import org.opengis.referencing.datum.Ellipsoid; |
||
56 | import org.opengis.referencing.datum.PrimeMeridian; |
||
57 | |||
58 | |||
59 | /**
|
||
60 | * Clase para manejar la libreria proj4
|
||
61 | *
|
||
62 | * @author David Hern?ndez L?pez (david.hernandez@uclm.es)
|
||
63 | * @author Jos? Luis G?mez Mart?nez (JoseLuis.Gomez@uclm.es)
|
||
64 | *
|
||
65 | */
|
||
66 | |||
67 | public class Proj4 { |
||
68 | |||
69 | private ArrayList projectionNameList= new ArrayList(); |
||
70 | private ArrayList unitNameList= new ArrayList(); |
||
71 | private ArrayList projectionParameterNameList= new ArrayList(); |
||
72 | private ArrayList projectionParameterList= new ArrayList(); |
||
73 | private ArrayList projectionParameterDefaultValueList= new ArrayList(); |
||
74 | private ArrayList projectionParameterMaxValueList= new ArrayList(); |
||
75 | private ArrayList projectionParameterMinValueList= new ArrayList(); |
||
76 | private ArrayList projectionParameterUnitList= new ArrayList(); |
||
77 | private ArrayList projectionAcronymList= new ArrayList(); |
||
78 | private ArrayList projectionParameterAcronymList= new ArrayList(); |
||
79 | |||
80 | int divider=10000; |
||
81 | private static double angularTolerance=1.0/3600.0; |
||
82 | |||
83 | /**
|
||
84 | * Small tolerance factor for rounding errors.
|
||
85 | */
|
||
86 | private static final double EPS = 1E-8; |
||
87 | |||
88 | public Proj4() throws CrsException |
||
89 | { |
||
90 | //defineProjectionNames();
|
||
91 | //defineProjectionParameterNameList();
|
||
92 | //defineProjectionParameterUnitList();
|
||
93 | defineUnitNameList(); |
||
94 | defineProjectionParameterList(); |
||
95 | defineProjections(); |
||
96 | } |
||
97 | |||
98 | private void defineUnitNameList() throws CrsException |
||
99 | { |
||
100 | int count=0; |
||
101 | |||
102 | { |
||
103 | String[] unitName={"Angular"}; |
||
104 | unitNameList.add(count,unitName); |
||
105 | } |
||
106 | |||
107 | count++; |
||
108 | { |
||
109 | String[] unitName={"Linear"}; |
||
110 | unitNameList.add(count,unitName); |
||
111 | } |
||
112 | |||
113 | count++; |
||
114 | { |
||
115 | String[] unitName={"Unitless"}; |
||
116 | unitNameList.add(count,unitName); |
||
117 | addUnitName(count,"Adimensional");
|
||
118 | } |
||
119 | |||
120 | } |
||
121 | |||
122 | private void defineProjectionParameterList() throws CrsException |
||
123 | { |
||
124 | int count=0; |
||
125 | |||
126 | { // azimuth
|
||
127 | String[] parameterName={"azimuth"}; |
||
128 | projectionParameterNameList.add(count,parameterName); |
||
129 | addProjectionParameterName(count,"Azimuth of initial line");
|
||
130 | addProjectionParameterName(count,"AzimuthAngle");
|
||
131 | |||
132 | String[] parameterUnit={"Angular"}; |
||
133 | projectionParameterUnitList.add(count,parameterUnit); |
||
134 | } |
||
135 | |||
136 | count++; |
||
137 | { // central_meridian
|
||
138 | String[] parameterName={"central_meridian"}; |
||
139 | projectionParameterNameList.add(count,parameterName); |
||
140 | addProjectionParameterName(count,"Longitude of natural origin");
|
||
141 | addProjectionParameterName(count,"NatOriginLong");
|
||
142 | addProjectionParameterName(count,"Longitude of projection center");
|
||
143 | addProjectionParameterName(count,"Longitude_of_center");
|
||
144 | addProjectionParameterName(count,"ProjCenterLong");
|
||
145 | addProjectionParameterName(count,"Longitude of false origin");
|
||
146 | addProjectionParameterName(count,"FalseOriginLong");
|
||
147 | addProjectionParameterName(count,"StraightVertPoleLong");
|
||
148 | |||
149 | String[] parameterUnit={"Angular"}; |
||
150 | projectionParameterUnitList.add(count,parameterUnit); |
||
151 | } |
||
152 | |||
153 | count++; |
||
154 | { // false_easting
|
||
155 | String[] parameterName={"false_easting"}; |
||
156 | projectionParameterNameList.add(count,parameterName); |
||
157 | addProjectionParameterName(count,"Easting at projection centre");
|
||
158 | addProjectionParameterName(count,"Easting of false origin");
|
||
159 | addProjectionParameterName(count,"FalseEasting");
|
||
160 | addProjectionParameterName(count,"False_Easting");
|
||
161 | addProjectionParameterName(count,"FalseOriginEasting");
|
||
162 | |||
163 | String[] parameterUnit={"Linear"}; |
||
164 | projectionParameterUnitList.add(count,parameterUnit); |
||
165 | } |
||
166 | |||
167 | count++; |
||
168 | { // false_northing
|
||
169 | String[] parameterName={"false_northing"}; |
||
170 | projectionParameterNameList.add(count,parameterName); |
||
171 | addProjectionParameterName(count,"Northing at projection centre");
|
||
172 | addProjectionParameterName(count,"Northing of false origin");
|
||
173 | addProjectionParameterName(count,"FalseNorthing");
|
||
174 | addProjectionParameterName(count,"False_Northing");
|
||
175 | addProjectionParameterName(count,"FalseOriginNorthing");
|
||
176 | |||
177 | String[] parameterUnit={"Linear"}; |
||
178 | projectionParameterUnitList.add(count,parameterUnit); |
||
179 | } |
||
180 | |||
181 | count++; |
||
182 | { // latitude_of_center
|
||
183 | String[] parameterName={"latitude_of_center"}; |
||
184 | projectionParameterNameList.add(count,parameterName); |
||
185 | addProjectionParameterName(count,"CenterLat");
|
||
186 | addProjectionParameterName(count,"FalseOriginLat");
|
||
187 | addProjectionParameterName(count,"Latitude of false origin");
|
||
188 | addProjectionParameterName(count,"Latitude_of_origin");
|
||
189 | addProjectionParameterName(count,"Latitude of natural origin");
|
||
190 | addProjectionParameterName(count,"Latitude of projection center");
|
||
191 | addProjectionParameterName(count,"Latitude of projection centre");
|
||
192 | addProjectionParameterName(count,"NatOriginLat");
|
||
193 | addProjectionParameterName(count,"ProjCenterLat");
|
||
194 | addProjectionParameterName(count,"Spherical_latitude_of_origin");
|
||
195 | addProjectionParameterName(count,"Central_Parallel");
|
||
196 | |||
197 | String[] parameterUnit={"Angular"}; |
||
198 | projectionParameterUnitList.add(count,parameterUnit); |
||
199 | } |
||
200 | |||
201 | count++; |
||
202 | { // Latitude_Of_1st_Point
|
||
203 | String[] parameterName={"Latitude_Of_1st_Point"}; |
||
204 | projectionParameterNameList.add(count,parameterName); |
||
205 | //addProjectionParameterName(count,"CenterLat");
|
||
206 | |||
207 | String[] parameterUnit={"Angular"}; |
||
208 | projectionParameterUnitList.add(count,parameterUnit); |
||
209 | } |
||
210 | |||
211 | count++; |
||
212 | { // Latitude_Of_2nd_Point
|
||
213 | String[] parameterName={"Latitude_Of_2nd_Point"}; |
||
214 | projectionParameterNameList.add(count,parameterName); |
||
215 | //addProjectionParameterName(count,"CenterLat");
|
||
216 | |||
217 | String[] parameterUnit={"Angular"}; |
||
218 | projectionParameterUnitList.add(count,parameterUnit); |
||
219 | } |
||
220 | |||
221 | count++; |
||
222 | { // latitude_of_origin
|
||
223 | String[] parameterName={"latitude_of_origin"}; |
||
224 | projectionParameterNameList.add(count,parameterName); |
||
225 | addProjectionParameterName(count,"CenterLat");
|
||
226 | addProjectionParameterName(count,"FalseOriginLat");
|
||
227 | addProjectionParameterName(count,"Latitude of center");
|
||
228 | addProjectionParameterName(count,"Latitude of false origin");
|
||
229 | addProjectionParameterName(count,"Latitude of natural origin");
|
||
230 | addProjectionParameterName(count,"Latitude of projection center");
|
||
231 | addProjectionParameterName(count,"Latitude of projection centre");
|
||
232 | addProjectionParameterName(count,"NatOriginLat");
|
||
233 | addProjectionParameterName(count,"ProjCenterLat");
|
||
234 | |||
235 | String[] parameterUnit={"Angular"}; |
||
236 | projectionParameterUnitList.add(count,parameterUnit); |
||
237 | } |
||
238 | |||
239 | count++; |
||
240 | { // latitude_of_origin
|
||
241 | String[] parameterName={"latitude_of_standard_parallel"}; |
||
242 | projectionParameterNameList.add(count,parameterName); |
||
243 | addProjectionParameterName(count,"CenterLat");
|
||
244 | addProjectionParameterName(count,"FalseOriginLat");
|
||
245 | addProjectionParameterName(count,"Latitude of center");
|
||
246 | addProjectionParameterName(count,"Latitude of false origin");
|
||
247 | addProjectionParameterName(count,"Latitude of natural origin");
|
||
248 | addProjectionParameterName(count,"Latitude of projection center");
|
||
249 | addProjectionParameterName(count,"Latitude of projection centre");
|
||
250 | addProjectionParameterName(count,"Latitude_of_standard_parallel");
|
||
251 | addProjectionParameterName(count,"NatOriginLat");
|
||
252 | addProjectionParameterName(count,"ProjCenterLat");
|
||
253 | |||
254 | String[] parameterUnit={"Angular"}; |
||
255 | projectionParameterUnitList.add(count,parameterUnit); |
||
256 | } |
||
257 | |||
258 | count++; |
||
259 | { // longitude_of_center
|
||
260 | String[] parameterName={"longitude_of_center"}; |
||
261 | projectionParameterNameList.add(count,parameterName); |
||
262 | addProjectionParameterName(count,"Longitude of origin");
|
||
263 | addProjectionParameterName(count,"Longitude of false origin");
|
||
264 | addProjectionParameterName(count,"NatOriginLong");
|
||
265 | addProjectionParameterName(count,"central_meridian");
|
||
266 | addProjectionParameterName(count,"CenterLong");
|
||
267 | addProjectionParameterName(count,"Spherical_latitude_of_origin");
|
||
268 | |||
269 | String[] parameterUnit={"Angular"}; |
||
270 | projectionParameterUnitList.add(count,parameterUnit); |
||
271 | } |
||
272 | |||
273 | count++; |
||
274 | { // Longitude_Of_1st_Point
|
||
275 | String[] parameterName={"Longitude_Of_1st_Point"}; |
||
276 | projectionParameterNameList.add(count,parameterName); |
||
277 | //addProjectionParameterName(count,"CenterLat");
|
||
278 | |||
279 | String[] parameterUnit={"Angular"}; |
||
280 | projectionParameterUnitList.add(count,parameterUnit); |
||
281 | } |
||
282 | |||
283 | count++; |
||
284 | { // Longitude_Of_2nd_Point
|
||
285 | String[] parameterName={"Longitude_Of_2nd_Point"}; |
||
286 | projectionParameterNameList.add(count,parameterName); |
||
287 | //addProjectionParameterName(count,"CenterLat");
|
||
288 | |||
289 | String[] parameterUnit={"Angular"}; |
||
290 | projectionParameterUnitList.add(count,parameterUnit); |
||
291 | } |
||
292 | |||
293 | count++; |
||
294 | { // pseudo_standard_parallel_1
|
||
295 | String[] parameterName={"pseudo_standard_parallel_1"}; |
||
296 | projectionParameterNameList.add(count,parameterName); |
||
297 | addProjectionParameterName(count,"Latitude of Pseudo Standard Parallel");
|
||
298 | |||
299 | String[] parameterUnit={"Angular"}; |
||
300 | projectionParameterUnitList.add(count,parameterUnit); |
||
301 | } |
||
302 | |||
303 | count++; |
||
304 | { // satellite_height
|
||
305 | String[] parameterName={"rectified_grid_angle"}; |
||
306 | projectionParameterNameList.add(count,parameterName); |
||
307 | addProjectionParameterName(count,"Angle from Rectified to Skew Grid");
|
||
308 | addProjectionParameterName(count,"XY_Plane_Rotation");
|
||
309 | addProjectionParameterName(count,"RectifiedGridAngle");
|
||
310 | |||
311 | String[] parameterUnit={"Linear"}; |
||
312 | projectionParameterUnitList.add(count,parameterUnit); |
||
313 | } |
||
314 | |||
315 | count++; |
||
316 | { // satellite_height
|
||
317 | String[] parameterName={"satellite_height"}; |
||
318 | projectionParameterNameList.add(count,parameterName); |
||
319 | addProjectionParameterName(count,"Satellite Height");
|
||
320 | |||
321 | String[] parameterUnit={"Linear"}; |
||
322 | projectionParameterUnitList.add(count,parameterUnit); |
||
323 | } |
||
324 | |||
325 | count++; |
||
326 | { // scale_factor
|
||
327 | String[] parameterName={"scale_factor"}; |
||
328 | projectionParameterNameList.add(count,parameterName); |
||
329 | addProjectionParameterName(count,"Scale factor at natural origin");
|
||
330 | addProjectionParameterName(count,"ScaleAtNatOrigin");
|
||
331 | addProjectionParameterName(count,"ScaleAtCenter");
|
||
332 | |||
333 | String[] parameterUnit={"Unitless"}; |
||
334 | projectionParameterUnitList.add(count,parameterUnit); |
||
335 | } |
||
336 | |||
337 | count++; |
||
338 | { // standard_parallel_1
|
||
339 | String[] parameterName={"standard_parallel_1"}; |
||
340 | projectionParameterNameList.add(count,parameterName); |
||
341 | addProjectionParameterName(count,"Latitude of first standard parallel");
|
||
342 | addProjectionParameterName(count,"Latitude of origin");
|
||
343 | addProjectionParameterName(count,"StdParallel1");
|
||
344 | |||
345 | String[] parameterUnit={"Angular"}; |
||
346 | projectionParameterUnitList.add(count,parameterUnit); |
||
347 | } |
||
348 | |||
349 | count++; |
||
350 | { // standard_parallel_2
|
||
351 | String[] parameterName={"standard_parallel_2"}; |
||
352 | projectionParameterNameList.add(count,parameterName); |
||
353 | addProjectionParameterName(count,"Latitude of second standard parallel");
|
||
354 | addProjectionParameterName(count,"StdParallel2");
|
||
355 | |||
356 | String[] parameterUnit={"Angular"}; |
||
357 | projectionParameterUnitList.add(count,parameterUnit); |
||
358 | } |
||
359 | |||
360 | count++; |
||
361 | { // semi_major
|
||
362 | String[] parameterName={"semi_major"}; |
||
363 | projectionParameterNameList.add(count,parameterName); |
||
364 | addProjectionParameterName(count,"semi_major_axis");
|
||
365 | |||
366 | String[] parameterUnit={"Linear"}; |
||
367 | projectionParameterUnitList.add(count,parameterUnit); |
||
368 | } |
||
369 | |||
370 | count++; |
||
371 | { // semi_minor
|
||
372 | String[] parameterName={"semi_minor"}; |
||
373 | projectionParameterNameList.add(count,parameterName); |
||
374 | addProjectionParameterName(count,"semi_minor_axis");
|
||
375 | |||
376 | String[] parameterUnit={"Linear"}; |
||
377 | projectionParameterUnitList.add(count,parameterUnit); |
||
378 | } |
||
379 | |||
380 | count++; |
||
381 | { // height
|
||
382 | String[] parameterName={"Height"}; |
||
383 | projectionParameterNameList.add(count,parameterName); |
||
384 | addProjectionParameterName(count,"altitude");
|
||
385 | |||
386 | String[] parameterUnit={"Linear"}; |
||
387 | projectionParameterUnitList.add(count,parameterUnit); |
||
388 | } |
||
389 | |||
390 | } |
||
391 | |||
392 | private void defineProjections() throws CrsException |
||
393 | { |
||
394 | int count=0; |
||
395 | |||
396 | {// Aitoff
|
||
397 | String[] projectionName={"Aitoff"}; |
||
398 | projectionNameList.add(count,projectionName); |
||
399 | |||
400 | String[] parameterName={"central_meridian"}; |
||
401 | projectionParameterList.add(count,parameterName); |
||
402 | addProjectionParameter(count,"false_easting");
|
||
403 | addProjectionParameter(count,"false_northing");
|
||
404 | |||
405 | String[] parameterAcronym={"lon_0"}; |
||
406 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
407 | addProjectionParameterAcronymList(count,"x_0");
|
||
408 | addProjectionParameterAcronymList(count,"y_0");
|
||
409 | |||
410 | String[] parameterDefaultValue={"0.0"}; |
||
411 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
412 | addProjectionParameterDefaultValue(count,"0.0");
|
||
413 | addProjectionParameterDefaultValue(count,"0.0");
|
||
414 | |||
415 | String[] parameterMaxValue={"360.0"}; |
||
416 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
417 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
418 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
419 | |||
420 | String[] parameterMinValue={"-360.0"}; |
||
421 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
422 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
423 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
424 | |||
425 | String[] projectionAcronym={"aitoff"}; |
||
426 | projectionAcronymList.add(count,projectionAcronym); |
||
427 | } |
||
428 | |||
429 | count++; |
||
430 | {// Albers Equal-Area Conic
|
||
431 | String[] projectionName={"Albers_Conic_Equal_Area"}; |
||
432 | projectionNameList.add(count,projectionName); |
||
433 | addProjectionName(count,"Albers Equal-Area Conic");
|
||
434 | addProjectionName(count,"Albers Equal Area");
|
||
435 | addProjectionName(count,"9822");
|
||
436 | |||
437 | String[] parameterName={"standard_parallel_1"}; |
||
438 | projectionParameterList.add(count,parameterName); |
||
439 | addProjectionParameter(count,"standard_parallel_2");
|
||
440 | addProjectionParameter(count,"latitude_of_center");
|
||
441 | addProjectionParameter(count,"longitude_of_center");
|
||
442 | addProjectionParameter(count,"false_easting");
|
||
443 | addProjectionParameter(count,"false_northing");
|
||
444 | |||
445 | String[] parameterAcronym={"lat_1"}; |
||
446 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
447 | addProjectionParameterAcronymList(count,"lat_2");
|
||
448 | addProjectionParameterAcronymList(count,"lat_0");
|
||
449 | addProjectionParameterAcronymList(count,"lon_0");
|
||
450 | addProjectionParameterAcronymList(count,"x_0");
|
||
451 | addProjectionParameterAcronymList(count,"y_0");
|
||
452 | |||
453 | String[] parameterDefaultValue={"0.0"}; |
||
454 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
455 | addProjectionParameterDefaultValue(count,"0.0");
|
||
456 | addProjectionParameterDefaultValue(count,"0.0");
|
||
457 | addProjectionParameterDefaultValue(count,"0.0");
|
||
458 | addProjectionParameterDefaultValue(count,"0.0");
|
||
459 | addProjectionParameterDefaultValue(count,"0.0");
|
||
460 | |||
461 | String[] parameterMaxValue={"90.0"}; |
||
462 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
463 | addProjectionParameterMaxValue(count,"90.0");
|
||
464 | addProjectionParameterMaxValue(count,"90.0");
|
||
465 | addProjectionParameterMaxValue(count,"360.0");
|
||
466 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
467 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
468 | |||
469 | String[] parameterMinValue={"-90.0"}; |
||
470 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
471 | addProjectionParameterMinValue(count,"-90.0");
|
||
472 | addProjectionParameterMinValue(count,"-90.0");
|
||
473 | addProjectionParameterMinValue(count,"-360.0");
|
||
474 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
475 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
476 | |||
477 | String[] projectionAcronym={"aea"}; |
||
478 | projectionAcronymList.add(count,projectionAcronym); |
||
479 | } |
||
480 | |||
481 | count++; |
||
482 | {// Azimuthal_Equidistantt
|
||
483 | String[] projectionName={"Azimuthal_Equidistant"}; |
||
484 | projectionNameList.add(count,projectionName); |
||
485 | addProjectionName(count,"Azimuthal Equidistant");
|
||
486 | addProjectionName(count,"Azimuthal-Equidistant");
|
||
487 | addProjectionName(count,"Postel");
|
||
488 | addProjectionName(count,"Zenithal Equidistant");
|
||
489 | addProjectionName(count,"Zenithal-Equidistant");
|
||
490 | addProjectionName(count,"Zenithal_Equidistant");
|
||
491 | |||
492 | String[] parameterName={"latitude_of_center"}; |
||
493 | projectionParameterList.add(count,parameterName); |
||
494 | addProjectionParameter(count,"longitude_of_center");
|
||
495 | addProjectionParameter(count,"false_easting");
|
||
496 | addProjectionParameter(count,"false_northing");
|
||
497 | |||
498 | String[] parameterAcronym={"lat_0"}; |
||
499 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
500 | addProjectionParameterAcronymList(count,"lon_0");
|
||
501 | addProjectionParameterAcronymList(count,"x_0");
|
||
502 | addProjectionParameterAcronymList(count,"y_0");
|
||
503 | |||
504 | String[] parameterDefaultValue={"0.0"}; |
||
505 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
506 | addProjectionParameterDefaultValue(count,"0.0");
|
||
507 | addProjectionParameterDefaultValue(count,"0.0");
|
||
508 | addProjectionParameterDefaultValue(count,"0.0");
|
||
509 | |||
510 | String[] parameterMaxValue={"90.0"}; |
||
511 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
512 | addProjectionParameterMaxValue(count,"360.0");
|
||
513 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
514 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
515 | |||
516 | String[] parameterMinValue={"-90.0"}; |
||
517 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
518 | addProjectionParameterMinValue(count,"-360.0");
|
||
519 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
520 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
521 | |||
522 | String[] projectionAcronym={"aeqd"}; |
||
523 | projectionAcronymList.add(count,projectionAcronym); |
||
524 | } |
||
525 | |||
526 | count++; |
||
527 | {// Bonne
|
||
528 | String[] projectionName={"Bonne"}; |
||
529 | projectionNameList.add(count,projectionName); |
||
530 | addProjectionName(count,"Bonne");
|
||
531 | |||
532 | String[] parameterName={"central_meridian"}; |
||
533 | projectionParameterList.add(count,parameterName); |
||
534 | addProjectionParameter(count,"standard_parallel_1");
|
||
535 | addProjectionParameter(count,"false_easting");
|
||
536 | addProjectionParameter(count,"false_northing");
|
||
537 | |||
538 | String[] parameterAcronym={"lon_0"}; |
||
539 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
540 | addProjectionParameterAcronymList(count,"lat_1");
|
||
541 | addProjectionParameterAcronymList(count,"x_0");
|
||
542 | addProjectionParameterAcronymList(count,"y_0");
|
||
543 | |||
544 | String[] parameterDefaultValue={"0.0"}; |
||
545 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
546 | addProjectionParameterDefaultValue(count,"0.0");
|
||
547 | addProjectionParameterDefaultValue(count,"0.0");
|
||
548 | addProjectionParameterDefaultValue(count,"0.0");
|
||
549 | |||
550 | String[] parameterMaxValue={"360.0"}; |
||
551 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
552 | addProjectionParameterMaxValue(count,"90.0");
|
||
553 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
554 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
555 | |||
556 | String[] parameterMinValue={"-360.0"}; |
||
557 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
558 | addProjectionParameterMinValue(count,"-90.0");
|
||
559 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
560 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
561 | |||
562 | String[] projectionAcronym={"bonne"}; |
||
563 | projectionAcronymList.add(count,projectionAcronym); |
||
564 | } |
||
565 | |||
566 | count++; |
||
567 | {// Cassini_Soldner
|
||
568 | String[] projectionName={"Cassini_Soldner"}; |
||
569 | projectionNameList.add(count,projectionName); |
||
570 | addProjectionName(count,"Cassini-Soldner");
|
||
571 | addProjectionName(count,"Cassini");
|
||
572 | addProjectionName(count,"9806");
|
||
573 | |||
574 | String[] parameterName={"latitude_of_origin"}; |
||
575 | projectionParameterList.add(count,parameterName); |
||
576 | addProjectionParameter(count,"central_meridian");
|
||
577 | addProjectionParameter(count,"false_easting");
|
||
578 | addProjectionParameter(count,"false_northing");
|
||
579 | |||
580 | String[] parameterAcronym={"lat_0"}; |
||
581 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
582 | addProjectionParameterAcronymList(count,"lon_0");
|
||
583 | addProjectionParameterAcronymList(count,"x_0");
|
||
584 | addProjectionParameterAcronymList(count,"y_0");
|
||
585 | |||
586 | String[] parameterDefaultValue={"0.0"}; |
||
587 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
588 | addProjectionParameterDefaultValue(count,"0.0");
|
||
589 | addProjectionParameterDefaultValue(count,"0.0");
|
||
590 | addProjectionParameterDefaultValue(count,"0.0");
|
||
591 | |||
592 | String[] parameterMaxValue={"90.0"}; |
||
593 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
594 | addProjectionParameterMaxValue(count,"360.0");
|
||
595 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
596 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
597 | |||
598 | String[] parameterMinValue={"-90.0"}; |
||
599 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
600 | addProjectionParameterMinValue(count,"-360.0");
|
||
601 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
602 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
603 | |||
604 | String[] projectionAcronym={"cass"}; |
||
605 | projectionAcronymList.add(count,projectionAcronym); |
||
606 | } |
||
607 | |||
608 | count++; |
||
609 | {// Craster Parabolic
|
||
610 | String[] projectionName={"Craster_Parabolic"}; |
||
611 | projectionNameList.add(count,projectionName); |
||
612 | addProjectionName(count,"Craster-Parabolic");
|
||
613 | addProjectionName(count,"Craster Parabolic");
|
||
614 | |||
615 | String[] parameterName={"central_meridian"}; |
||
616 | projectionParameterList.add(count,parameterName); |
||
617 | addProjectionParameter(count,"false_easting");
|
||
618 | addProjectionParameter(count,"false_northing");
|
||
619 | |||
620 | String[] parameterAcronym={"lon_0"}; |
||
621 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
622 | addProjectionParameterAcronymList(count,"x_0");
|
||
623 | addProjectionParameterAcronymList(count,"y_0");
|
||
624 | |||
625 | String[] parameterDefaultValue={"0.0"}; |
||
626 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
627 | addProjectionParameterDefaultValue(count,"0.0");
|
||
628 | addProjectionParameterDefaultValue(count,"0.0");
|
||
629 | |||
630 | String[] parameterMaxValue={"360.0"}; |
||
631 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
632 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
633 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
634 | |||
635 | String[] parameterMinValue={"-360.0"}; |
||
636 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
637 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
638 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
639 | |||
640 | String[] projectionAcronym={"craster"}; |
||
641 | projectionAcronymList.add(count,projectionAcronym); |
||
642 | } |
||
643 | |||
644 | count++; |
||
645 | {// Cylindrical_Equal_Area
|
||
646 | String[] projectionName={"Cylindrical_Equal_Area"}; |
||
647 | projectionNameList.add(count,projectionName); |
||
648 | addProjectionName(count,"Cylindrical Equal Area");
|
||
649 | addProjectionName(count,"Normal Authalic Cylindrical (FME)");
|
||
650 | addProjectionName(count,"Lambert Cylindrical Equal Area");
|
||
651 | addProjectionName(count,"Lambert_Cylindrical_Equal_Area");
|
||
652 | addProjectionName(count,"Behrmann (standard parallel = 30)");
|
||
653 | addProjectionName(count,"Behrmann");
|
||
654 | addProjectionName(count,"Gall Orthographic (standard parallel = 45)");
|
||
655 | addProjectionName(count,"Gall Orthographic");
|
||
656 | addProjectionName(count,"Gall_Orthographic");
|
||
657 | addProjectionName(count,"Peters (approximated by Gall Orthographic)");
|
||
658 | addProjectionName(count,"Peters");
|
||
659 | addProjectionName(count,"Lambert Cylindrical Equal Area (Spherical)");
|
||
660 | |||
661 | String[] parameterName={"central_meridian"}; |
||
662 | projectionParameterList.add(count,parameterName); |
||
663 | addProjectionParameter(count,"standard_parallel_1");
|
||
664 | addProjectionParameter(count,"false_easting");
|
||
665 | addProjectionParameter(count,"false_northing");
|
||
666 | |||
667 | String[] parameterAcronym={"lon_0"}; |
||
668 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
669 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
670 | addProjectionParameterAcronymList(count,"x_0");
|
||
671 | addProjectionParameterAcronymList(count,"y_0");
|
||
672 | |||
673 | String[] parameterDefaultValue={"0.0"}; |
||
674 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
675 | addProjectionParameterDefaultValue(count,"0.0");
|
||
676 | addProjectionParameterDefaultValue(count,"0.0");
|
||
677 | addProjectionParameterDefaultValue(count,"0.0");
|
||
678 | |||
679 | String[] parameterMaxValue={"360.0"}; |
||
680 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
681 | addProjectionParameterMaxValue(count,"90.0");
|
||
682 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
683 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
684 | |||
685 | String[] parameterMinValue={"-360.0"}; |
||
686 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
687 | addProjectionParameterMinValue(count,"-90.0");
|
||
688 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
689 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
690 | |||
691 | String[] projectionAcronym={"cea"}; |
||
692 | projectionAcronymList.add(count,projectionAcronym); |
||
693 | } |
||
694 | |||
695 | count++; |
||
696 | {// Eckert_I
|
||
697 | String[] projectionName={"Eckert_I"}; |
||
698 | projectionNameList.add(count,projectionName); |
||
699 | addProjectionName(count,"Eckert I");
|
||
700 | |||
701 | String[] parameterName={"central_meridian"}; |
||
702 | projectionParameterList.add(count,parameterName); |
||
703 | addProjectionParameter(count,"false_easting");
|
||
704 | addProjectionParameter(count,"false_northing");
|
||
705 | |||
706 | String[] parameterAcronym={"lon_0"}; |
||
707 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
708 | addProjectionParameterAcronymList(count,"x_0");
|
||
709 | addProjectionParameterAcronymList(count,"y_0");
|
||
710 | |||
711 | String[] parameterDefaultValue={"0.0"}; |
||
712 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
713 | addProjectionParameterDefaultValue(count,"0.0");
|
||
714 | addProjectionParameterDefaultValue(count,"0.0");
|
||
715 | |||
716 | String[] parameterMaxValue={"360.0"}; |
||
717 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
718 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
719 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
720 | |||
721 | String[] parameterMinValue={"-360.0"}; |
||
722 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
723 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
724 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
725 | |||
726 | String[] projectionAcronym={"eck1"}; |
||
727 | projectionAcronymList.add(count,projectionAcronym); |
||
728 | } |
||
729 | |||
730 | count++; |
||
731 | {// Eckert_II
|
||
732 | String[] projectionName={"Eckert_II"}; |
||
733 | projectionNameList.add(count,projectionName); |
||
734 | addProjectionName(count,"Eckert II");
|
||
735 | |||
736 | String[] parameterName={"central_meridian"}; |
||
737 | projectionParameterList.add(count,parameterName); |
||
738 | addProjectionParameter(count,"false_easting");
|
||
739 | addProjectionParameter(count,"false_northing");
|
||
740 | |||
741 | String[] parameterAcronym={"lon_0"}; |
||
742 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
743 | addProjectionParameterAcronymList(count,"x_0");
|
||
744 | addProjectionParameterAcronymList(count,"y_0");
|
||
745 | |||
746 | String[] parameterDefaultValue={"0.0"}; |
||
747 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
748 | addProjectionParameterDefaultValue(count,"0.0");
|
||
749 | addProjectionParameterDefaultValue(count,"0.0");
|
||
750 | |||
751 | String[] parameterMaxValue={"360.0"}; |
||
752 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
753 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
754 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
755 | |||
756 | String[] parameterMinValue={"-360.0"}; |
||
757 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
758 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
759 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
760 | |||
761 | String[] projectionAcronym={"eck2"}; |
||
762 | projectionAcronymList.add(count,projectionAcronym); |
||
763 | } |
||
764 | |||
765 | count++; |
||
766 | {// Eckert_III
|
||
767 | String[] projectionName={"Eckert_III"}; |
||
768 | projectionNameList.add(count,projectionName); |
||
769 | addProjectionName(count,"Eckert III");
|
||
770 | |||
771 | String[] parameterName={"central_meridian"}; |
||
772 | projectionParameterList.add(count,parameterName); |
||
773 | addProjectionParameter(count,"false_easting");
|
||
774 | addProjectionParameter(count,"false_northing");
|
||
775 | |||
776 | String[] parameterAcronym={"lon_0"}; |
||
777 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
778 | addProjectionParameterAcronymList(count,"x_0");
|
||
779 | addProjectionParameterAcronymList(count,"y_0");
|
||
780 | |||
781 | String[] parameterDefaultValue={"0.0"}; |
||
782 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
783 | addProjectionParameterDefaultValue(count,"0.0");
|
||
784 | addProjectionParameterDefaultValue(count,"0.0");
|
||
785 | |||
786 | String[] parameterMaxValue={"360.0"}; |
||
787 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
788 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
789 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
790 | |||
791 | String[] parameterMinValue={"-360.0"}; |
||
792 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
793 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
794 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
795 | |||
796 | String[] projectionAcronym={"eck3"}; |
||
797 | projectionAcronymList.add(count,projectionAcronym); |
||
798 | } |
||
799 | |||
800 | count++; |
||
801 | {// Eckert_IV
|
||
802 | String[] projectionName={"Eckert_IV"}; |
||
803 | projectionNameList.add(count,projectionName); |
||
804 | addProjectionName(count,"Eckert IV");
|
||
805 | |||
806 | String[] parameterName={"central_meridian"}; |
||
807 | projectionParameterList.add(count,parameterName); |
||
808 | addProjectionParameter(count,"false_easting");
|
||
809 | addProjectionParameter(count,"false_northing");
|
||
810 | |||
811 | String[] parameterAcronym={"lon_0"}; |
||
812 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
813 | addProjectionParameterAcronymList(count,"x_0");
|
||
814 | addProjectionParameterAcronymList(count,"y_0");
|
||
815 | |||
816 | String[] parameterDefaultValue={"0.0"}; |
||
817 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
818 | addProjectionParameterDefaultValue(count,"0.0");
|
||
819 | addProjectionParameterDefaultValue(count,"0.0");
|
||
820 | |||
821 | String[] parameterMaxValue={"360.0"}; |
||
822 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
823 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
824 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
825 | |||
826 | String[] parameterMinValue={"-360.0"}; |
||
827 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
828 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
829 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
830 | |||
831 | String[] projectionAcronym={"eck4"}; |
||
832 | projectionAcronymList.add(count,projectionAcronym); |
||
833 | } |
||
834 | |||
835 | count++; |
||
836 | {// Eckert_V
|
||
837 | String[] projectionName={"Eckert_V"}; |
||
838 | projectionNameList.add(count,projectionName); |
||
839 | addProjectionName(count,"Eckert V");
|
||
840 | |||
841 | String[] parameterName={"central_meridian"}; |
||
842 | projectionParameterList.add(count,parameterName); |
||
843 | addProjectionParameter(count,"false_easting");
|
||
844 | addProjectionParameter(count,"false_northing");
|
||
845 | |||
846 | String[] parameterAcronym={"lon_0"}; |
||
847 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
848 | addProjectionParameterAcronymList(count,"x_0");
|
||
849 | addProjectionParameterAcronymList(count,"y_0");
|
||
850 | |||
851 | String[] parameterDefaultValue={"0.0"}; |
||
852 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
853 | addProjectionParameterDefaultValue(count,"0.0");
|
||
854 | addProjectionParameterDefaultValue(count,"0.0");
|
||
855 | |||
856 | String[] parameterMaxValue={"360.0"}; |
||
857 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
858 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
859 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
860 | |||
861 | String[] parameterMinValue={"-360.0"}; |
||
862 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
863 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
864 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
865 | |||
866 | String[] projectionAcronym={"eck5"}; |
||
867 | projectionAcronymList.add(count,projectionAcronym); |
||
868 | } |
||
869 | |||
870 | count++; |
||
871 | {// Eckert_VI
|
||
872 | String[] projectionName={"Eckert_VI"}; |
||
873 | projectionNameList.add(count,projectionName); |
||
874 | addProjectionName(count,"Eckert VI");
|
||
875 | |||
876 | String[] parameterName={"central_meridian"}; |
||
877 | projectionParameterList.add(count,parameterName); |
||
878 | addProjectionParameter(count,"false_easting");
|
||
879 | addProjectionParameter(count,"false_northing");
|
||
880 | |||
881 | String[] parameterAcronym={"lon_0"}; |
||
882 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
883 | addProjectionParameterAcronymList(count,"x_0");
|
||
884 | addProjectionParameterAcronymList(count,"y_0");
|
||
885 | |||
886 | String[] parameterDefaultValue={"0.0"}; |
||
887 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
888 | addProjectionParameterDefaultValue(count,"0.0");
|
||
889 | addProjectionParameterDefaultValue(count,"0.0");
|
||
890 | |||
891 | String[] parameterMaxValue={"360.0"}; |
||
892 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
893 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
894 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
895 | |||
896 | String[] parameterMinValue={"-360.0"}; |
||
897 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
898 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
899 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
900 | |||
901 | String[] projectionAcronym={"eck6"}; |
||
902 | projectionAcronymList.add(count,projectionAcronym); |
||
903 | } |
||
904 | |||
905 | count++; |
||
906 | {// Equidistant_Conic
|
||
907 | String[] projectionName={"Equidistant_Conic"}; |
||
908 | projectionNameList.add(count,projectionName); |
||
909 | addProjectionName(count,"Equidistant Conic");
|
||
910 | |||
911 | String[] parameterName={"latitude_of_center"}; |
||
912 | projectionParameterList.add(count,parameterName); |
||
913 | addProjectionParameter(count,"longitude_of_center");
|
||
914 | addProjectionParameter(count,"standard_parallel_1");
|
||
915 | addProjectionParameter(count,"standard_parallel_2");
|
||
916 | addProjectionParameter(count,"false_easting");
|
||
917 | addProjectionParameter(count,"false_northing");
|
||
918 | |||
919 | String[] parameterAcronym={"lat_0"}; |
||
920 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
921 | addProjectionParameterAcronymList(count,"lon_0");
|
||
922 | addProjectionParameterAcronymList(count,"lat_1");
|
||
923 | addProjectionParameterAcronymList(count,"lat_2");
|
||
924 | addProjectionParameterAcronymList(count,"x_0");
|
||
925 | addProjectionParameterAcronymList(count,"y_0");
|
||
926 | |||
927 | String[] parameterDefaultValue={"0.0"}; |
||
928 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
929 | addProjectionParameterDefaultValue(count,"0.0");
|
||
930 | addProjectionParameterDefaultValue(count,"0.0");
|
||
931 | addProjectionParameterDefaultValue(count,"0.0");
|
||
932 | addProjectionParameterDefaultValue(count,"0.0");
|
||
933 | addProjectionParameterDefaultValue(count,"0.0");
|
||
934 | |||
935 | String[] parameterMaxValue={"90.0"}; |
||
936 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
937 | addProjectionParameterMaxValue(count,"360.0");
|
||
938 | addProjectionParameterMaxValue(count,"90.0");
|
||
939 | addProjectionParameterMaxValue(count,"90.0");
|
||
940 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
941 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
942 | |||
943 | String[] parameterMinValue={"-90.0"}; |
||
944 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
945 | addProjectionParameterMinValue(count,"-360.0");
|
||
946 | addProjectionParameterMinValue(count,"-90.0");
|
||
947 | addProjectionParameterMinValue(count,"-90.0");
|
||
948 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
949 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
950 | |||
951 | String[] projectionAcronym={"eqdc"}; |
||
952 | projectionAcronymList.add(count,projectionAcronym); |
||
953 | } |
||
954 | |||
955 | count++; |
||
956 | {// Equirectangular
|
||
957 | String[] projectionName={"Equirectangular"}; |
||
958 | projectionNameList.add(count,projectionName); |
||
959 | addProjectionName(count,"Plate Caree");
|
||
960 | addProjectionName(count,"Plate Carree");
|
||
961 | addProjectionName(count,"Plate_Caree");
|
||
962 | addProjectionName(count,"Plate_Carree");
|
||
963 | addProjectionName(count,"Equidistant Cylindrical");
|
||
964 | addProjectionName(count,"Equidistant_Cylindrical");
|
||
965 | addProjectionName(count,"9823");
|
||
966 | |||
967 | String[] parameterName={"latitude_of_origin"}; |
||
968 | projectionParameterList.add(count,parameterName); |
||
969 | addProjectionParameter(count,"central_meridian");
|
||
970 | addProjectionParameter(count,"false_easting");
|
||
971 | addProjectionParameter(count,"false_northing");
|
||
972 | |||
973 | String[] parameterAcronym={"lat_ts"}; |
||
974 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
975 | addProjectionParameterAcronymList(count,"lon_0");
|
||
976 | addProjectionParameterAcronymList(count,"x_0");
|
||
977 | addProjectionParameterAcronymList(count,"y_0");
|
||
978 | |||
979 | String[] parameterDefaultValue={"0.0"}; |
||
980 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
981 | addProjectionParameterDefaultValue(count,"0.0");
|
||
982 | addProjectionParameterDefaultValue(count,"0.0");
|
||
983 | addProjectionParameterDefaultValue(count,"0.0");
|
||
984 | |||
985 | String[] parameterMaxValue={"90.0"}; |
||
986 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
987 | addProjectionParameterMaxValue(count,"360.0");
|
||
988 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
989 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
990 | |||
991 | String[] parameterMinValue={"-90.0"}; |
||
992 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
993 | addProjectionParameterMinValue(count,"-360.0");
|
||
994 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
995 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
996 | |||
997 | String[] projectionAcronym={"eqc"}; |
||
998 | projectionAcronymList.add(count,projectionAcronym); |
||
999 | } |
||
1000 | |||
1001 | count++; |
||
1002 | {// McBryde-Thomas Flat-Polar Quartic
|
||
1003 | String[] projectionName={"McBryde_Thomas_Flat_Polar_Quartic"}; |
||
1004 | projectionNameList.add(count,projectionName); |
||
1005 | addProjectionName(count,"McBryde-Thomas-Flat-Polar-Quartic");
|
||
1006 | addProjectionName(count,"McBryde Thomas Flat Polar Quartic");
|
||
1007 | addProjectionName(count,"Flat Polar Quartic");
|
||
1008 | addProjectionName(count,"Flat-Polar-Quartic");
|
||
1009 | addProjectionName(count,"Flat_Polar_Quartic");
|
||
1010 | |||
1011 | String[] parameterName={"central_meridian"}; |
||
1012 | projectionParameterList.add(count,parameterName); |
||
1013 | addProjectionParameter(count,"false_easting");
|
||
1014 | addProjectionParameter(count,"false_northing");
|
||
1015 | |||
1016 | String[] parameterAcronym={"lon_0"}; |
||
1017 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1018 | addProjectionParameterAcronymList(count,"x_0");
|
||
1019 | addProjectionParameterAcronymList(count,"y_0");
|
||
1020 | |||
1021 | String[] parameterDefaultValue={"0.0"}; |
||
1022 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1023 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1024 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1025 | |||
1026 | String[] parameterMaxValue={"360.0"}; |
||
1027 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1028 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1029 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1030 | |||
1031 | String[] parameterMinValue={"-360.0"}; |
||
1032 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1033 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1034 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1035 | |||
1036 | String[] projectionAcronym={"mbtfpq"}; |
||
1037 | projectionAcronymList.add(count,projectionAcronym); |
||
1038 | } |
||
1039 | |||
1040 | count++; |
||
1041 | {// Gall_Stereographic
|
||
1042 | String[] projectionName={"Gall_Stereographic"}; |
||
1043 | projectionNameList.add(count,projectionName); |
||
1044 | addProjectionName(count,"Gall Stereograpic");
|
||
1045 | addProjectionName(count,"Gall");
|
||
1046 | |||
1047 | String[] parameterName={"central_meridian"}; |
||
1048 | projectionParameterList.add(count,parameterName); |
||
1049 | addProjectionParameter(count,"false_easting");
|
||
1050 | addProjectionParameter(count,"false_northing");
|
||
1051 | |||
1052 | String[] parameterAcronym={"lon_0"}; |
||
1053 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1054 | addProjectionParameterAcronymList(count,"x_0");
|
||
1055 | addProjectionParameterAcronymList(count,"y_0");
|
||
1056 | |||
1057 | String[] parameterDefaultValue={"0.0"}; |
||
1058 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1059 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1060 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1061 | |||
1062 | String[] parameterMaxValue={"360.0"}; |
||
1063 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1064 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1065 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1066 | |||
1067 | String[] parameterMinValue={"-360.0"}; |
||
1068 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1069 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1070 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1071 | |||
1072 | String[] projectionAcronym={"gall"}; |
||
1073 | projectionAcronymList.add(count,projectionAcronym); |
||
1074 | } |
||
1075 | |||
1076 | count++; |
||
1077 | {// GEOS
|
||
1078 | String[] projectionName={"GEOS"}; |
||
1079 | projectionNameList.add(count,projectionName); |
||
1080 | addProjectionName(count,"Geostationary Satellite View");
|
||
1081 | addProjectionName(count,"Normalized Geostationary Projection");
|
||
1082 | |||
1083 | String[] parameterName={"central_meridian"}; |
||
1084 | projectionParameterList.add(count,parameterName); |
||
1085 | addProjectionParameter(count,"satellite_height");
|
||
1086 | addProjectionParameter(count,"false_easting");
|
||
1087 | addProjectionParameter(count,"false_northing");
|
||
1088 | |||
1089 | String[] parameterAcronym={"lon_0"}; |
||
1090 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1091 | addProjectionParameterAcronymList(count,"h");
|
||
1092 | addProjectionParameterAcronymList(count,"y_0");
|
||
1093 | |||
1094 | String[] parameterDefaultValue={"0.0"}; |
||
1095 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1096 | addProjectionParameterDefaultValue(count,"35785831.0");
|
||
1097 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1098 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1099 | |||
1100 | String[] parameterMaxValue={"360.0"}; |
||
1101 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1102 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1103 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1104 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1105 | |||
1106 | String[] parameterMinValue={"-360.0"}; |
||
1107 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1108 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1109 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1110 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1111 | |||
1112 | String[] projectionAcronym={"geos"}; |
||
1113 | projectionAcronymList.add(count,projectionAcronym); |
||
1114 | } |
||
1115 | |||
1116 | count++; |
||
1117 | {// Gnomonic
|
||
1118 | String[] projectionName={"Gnomonic"}; |
||
1119 | projectionNameList.add(count,projectionName); |
||
1120 | addProjectionName(count,"Gnomonic");
|
||
1121 | addProjectionName(count,"Central");
|
||
1122 | |||
1123 | String[] parameterName={"latitude_of_origin"}; |
||
1124 | projectionParameterList.add(count,parameterName); |
||
1125 | addProjectionParameter(count,"central_meridian");
|
||
1126 | addProjectionParameter(count,"false_easting");
|
||
1127 | addProjectionParameter(count,"false_northing");
|
||
1128 | |||
1129 | String[] parameterAcronym={"lat_0"}; |
||
1130 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1131 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1132 | addProjectionParameterAcronymList(count,"x_0");
|
||
1133 | addProjectionParameterAcronymList(count,"y_0");
|
||
1134 | |||
1135 | String[] parameterDefaultValue={"0.0"}; |
||
1136 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1137 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1138 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1139 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1140 | |||
1141 | String[] parameterMaxValue={"90.0"}; |
||
1142 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1143 | addProjectionParameterMaxValue(count,"360.0");
|
||
1144 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1145 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1146 | |||
1147 | String[] parameterMinValue={"-90.0"}; |
||
1148 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1149 | addProjectionParameterMinValue(count,"-360.0");
|
||
1150 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1151 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1152 | |||
1153 | String[] projectionAcronym={"gnom"}; |
||
1154 | projectionAcronymList.add(count,projectionAcronym); |
||
1155 | } |
||
1156 | |||
1157 | count++; |
||
1158 | {// Goode
|
||
1159 | String[] projectionName={"Goode"}; |
||
1160 | projectionNameList.add(count,projectionName); |
||
1161 | addProjectionName(count,"Homolosine");
|
||
1162 | |||
1163 | String[] parameterName={"central_meridian"}; |
||
1164 | projectionParameterList.add(count,parameterName); |
||
1165 | addProjectionParameter(count,"false_easting");
|
||
1166 | addProjectionParameter(count,"false_northing");
|
||
1167 | |||
1168 | String[] parameterAcronym={"lon_0"}; |
||
1169 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1170 | addProjectionParameterAcronymList(count,"x_0");
|
||
1171 | addProjectionParameterAcronymList(count,"y_0");
|
||
1172 | |||
1173 | String[] parameterDefaultValue={"0.0"}; |
||
1174 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1175 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1176 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1177 | |||
1178 | String[] parameterMaxValue={"360.0"}; |
||
1179 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1180 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1181 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1182 | |||
1183 | String[] parameterMinValue={"-360.0"}; |
||
1184 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1185 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1186 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1187 | |||
1188 | String[] projectionAcronym={"goode"}; |
||
1189 | projectionAcronymList.add(count,projectionAcronym); |
||
1190 | } |
||
1191 | |||
1192 | count++; |
||
1193 | {// Hammer-Aitoff
|
||
1194 | String[] projectionName={"Hammer_Aitoff"}; |
||
1195 | projectionNameList.add(count,projectionName); |
||
1196 | addProjectionName(count,"Hammer Aitoff");
|
||
1197 | addProjectionName(count,"Hammer-Aitoff");
|
||
1198 | addProjectionName(count,"Hammer");
|
||
1199 | |||
1200 | String[] parameterName={"central_meridian"}; |
||
1201 | projectionParameterList.add(count,parameterName); |
||
1202 | addProjectionParameter(count,"false_easting");
|
||
1203 | addProjectionParameter(count,"false_northing");
|
||
1204 | |||
1205 | String[] parameterAcronym={"lon_0"}; |
||
1206 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1207 | addProjectionParameterAcronymList(count,"x_0");
|
||
1208 | addProjectionParameterAcronymList(count,"y_0");
|
||
1209 | |||
1210 | String[] parameterDefaultValue={"0.0"}; |
||
1211 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1212 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1213 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1214 | |||
1215 | String[] parameterMaxValue={"360.0"}; |
||
1216 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1217 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1218 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1219 | |||
1220 | String[] parameterMinValue={"-360.0"}; |
||
1221 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1222 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1223 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1224 | |||
1225 | String[] projectionAcronym={"hammer"}; |
||
1226 | projectionAcronymList.add(count,projectionAcronym); |
||
1227 | } |
||
1228 | |||
1229 | count++; |
||
1230 | {// Krovak
|
||
1231 | String[] projectionName={"Krovak"}; |
||
1232 | projectionNameList.add(count,projectionName); |
||
1233 | addProjectionName(count,"Krovak Oblique Conic Conformal");
|
||
1234 | addProjectionName(count,"9819");
|
||
1235 | |||
1236 | String[] parameterName={"latitude_of_center"}; |
||
1237 | projectionParameterList.add(count,parameterName); |
||
1238 | addProjectionParameter(count,"longitude_of_center");
|
||
1239 | //addProjectionParameter(count,"azimuth");
|
||
1240 | addProjectionParameter(count,"scale_factor");
|
||
1241 | addProjectionParameter(count,"false_easting");
|
||
1242 | addProjectionParameter(count,"false_northing");
|
||
1243 | |||
1244 | String[] parameterAcronym={"lat_0"}; |
||
1245 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1246 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1247 | //addProjectionParameterAcronymList(count,"alpha");
|
||
1248 | addProjectionParameterAcronymList(count,"k");
|
||
1249 | addProjectionParameterAcronymList(count,"x_0");
|
||
1250 | addProjectionParameterAcronymList(count,"y_0");
|
||
1251 | |||
1252 | String[] parameterDefaultValue={"0.0"}; |
||
1253 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1254 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1255 | //addProjectionParameterDefaultValue(count,"0.0");
|
||
1256 | addProjectionParameterDefaultValue(count,"1.0");
|
||
1257 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1258 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1259 | |||
1260 | String[] parameterMaxValue={"90.0"}; |
||
1261 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1262 | addProjectionParameterMaxValue(count,"360.0");
|
||
1263 | //addProjectionParameterMaxValue(count,"360.0");
|
||
1264 | addProjectionParameterMaxValue(count,"10.0");
|
||
1265 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1266 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1267 | |||
1268 | String[] parameterMinValue={"-90.0"}; |
||
1269 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1270 | addProjectionParameterMinValue(count,"-360.0");
|
||
1271 | //addProjectionParameterMinValue(count,"-360.0");
|
||
1272 | addProjectionParameterMinValue(count,"0.0");
|
||
1273 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1274 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1275 | |||
1276 | String[] projectionAcronym={"krovak"}; |
||
1277 | projectionAcronymList.add(count,projectionAcronym); |
||
1278 | } |
||
1279 | |||
1280 | |||
1281 | count++; |
||
1282 | {// Laborde Madagascar
|
||
1283 | String[] projectionName={"Laborde_Madagascar"}; |
||
1284 | projectionNameList.add(count,projectionName); |
||
1285 | addProjectionName(count,"Laborde Madagascar");
|
||
1286 | addProjectionName(count,"Laborde");
|
||
1287 | addProjectionName(count,"9813");
|
||
1288 | |||
1289 | String[] parameterName={}; |
||
1290 | projectionParameterList.add(count,parameterName); |
||
1291 | |||
1292 | String[] parameterAcronym={}; |
||
1293 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1294 | |||
1295 | String[] parameterDefaultValue={}; |
||
1296 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1297 | |||
1298 | String[] parameterMaxValue={}; |
||
1299 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1300 | |||
1301 | String[] parameterMinValue={}; |
||
1302 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1303 | |||
1304 | String[] projectionAcronym={"labrd"}; |
||
1305 | projectionAcronymList.add(count,projectionAcronym); |
||
1306 | |||
1307 | /*String[] parameterName={"azimuth"};
|
||
1308 | projectionParameterList.add(count,parameterName);
|
||
1309 | |||
1310 | String[] parameterAcronym={"azi"};
|
||
1311 | projectionParameterAcronymList.add(count,parameterAcronym);
|
||
1312 | |||
1313 | String[] parameterDefaultValue={"18.9"};
|
||
1314 | projectionParameterDefaultValueList.add(count,parameterDefaultValue);
|
||
1315 | |||
1316 | String[] parameterMaxValue={"19"};
|
||
1317 | projectionParameterMaxValueList.add(count,parameterMaxValue);
|
||
1318 | |||
1319 | String[] parameterMinValue={"18"};
|
||
1320 | projectionParameterMinValueList.add(count,parameterMinValue);
|
||
1321 | |||
1322 | String[] projectionAcronym={"labrd"};
|
||
1323 | projectionAcronymList.add(count,projectionAcronym);*/
|
||
1324 | } |
||
1325 | |||
1326 | count++; |
||
1327 | {// Lambert_Azimuthal_Equal_Area
|
||
1328 | String[] projectionName={"Lambert_Azimuthal_Equal_Area"}; |
||
1329 | projectionNameList.add(count,projectionName); |
||
1330 | addProjectionName(count,"Lambert Azimuthal Equal Area");
|
||
1331 | addProjectionName(count,"Lambert Azimuthal Equal Area (Spherical)");
|
||
1332 | addProjectionName(count,"Lambert_Azimuthal_Equal_Area_(Spherical)");
|
||
1333 | addProjectionName(count,"Lorgna");
|
||
1334 | addProjectionName(count,"Zenithal Equal Area");
|
||
1335 | addProjectionName(count,"Zenithal Equal-Area");
|
||
1336 | addProjectionName(count,"Zenithal_Equal-Area");
|
||
1337 | addProjectionName(count,"Zenithal-Equal-Area");
|
||
1338 | addProjectionName(count,"Zenithal Eqivalent");
|
||
1339 | addProjectionName(count,"Zenithal-Eqivalent");
|
||
1340 | addProjectionName(count,"Zenithal_Eqivalent");
|
||
1341 | addProjectionName(count,"9820");
|
||
1342 | addProjectionName(count,"9821");
|
||
1343 | |||
1344 | String[] parameterName={"latitude_of_center"}; |
||
1345 | projectionParameterList.add(count,parameterName); |
||
1346 | addProjectionParameter(count,"longitude_of_center");
|
||
1347 | addProjectionParameter(count,"false_easting");
|
||
1348 | addProjectionParameter(count,"false_northing");
|
||
1349 | |||
1350 | String[] parameterAcronym={"lat_0"}; |
||
1351 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1352 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1353 | addProjectionParameterAcronymList(count,"x_0");
|
||
1354 | addProjectionParameterAcronymList(count,"y_0");
|
||
1355 | |||
1356 | String[] parameterDefaultValue={"0.0"}; |
||
1357 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1358 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1359 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1360 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1361 | |||
1362 | String[] parameterMaxValue={"90.0"}; |
||
1363 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1364 | addProjectionParameterMaxValue(count,"360.0");
|
||
1365 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1366 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1367 | |||
1368 | String[] parameterMinValue={"-90.0"}; |
||
1369 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1370 | addProjectionParameterMinValue(count,"-360.0");
|
||
1371 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1372 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1373 | |||
1374 | String[] projectionAcronym={"laea"}; |
||
1375 | projectionAcronymList.add(count,projectionAcronym); |
||
1376 | } |
||
1377 | count++; |
||
1378 | {// Lambert_Conformal_Conic_1SP
|
||
1379 | String[] projectionName={"Lambert_Conic_Near_Conformal"}; |
||
1380 | projectionNameList.add(count,projectionName); |
||
1381 | addProjectionName(count,"Lambert Conic Near-Conformal");
|
||
1382 | addProjectionName(count,"Lambert Conic Near Conformal");
|
||
1383 | addProjectionName(count,"Lambert_Conic_Near-Conformal");
|
||
1384 | addProjectionName(count,"9817");
|
||
1385 | |||
1386 | String[] parameterName={"latitude_of_origin"}; |
||
1387 | projectionParameterList.add(count,parameterName); |
||
1388 | addProjectionParameter(count,"central_meridian");
|
||
1389 | addProjectionParameter(count,"scale_factor");
|
||
1390 | addProjectionParameter(count,"false_easting");
|
||
1391 | addProjectionParameter(count,"false_northing");
|
||
1392 | |||
1393 | String[] parameterAcronym={"lat_0"}; |
||
1394 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1395 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1396 | addProjectionParameterAcronymList(count,"k_0");
|
||
1397 | addProjectionParameterAcronymList(count,"x_0");
|
||
1398 | addProjectionParameterAcronymList(count,"y_0");
|
||
1399 | |||
1400 | String[] parameterDefaultValue={"0.0"}; |
||
1401 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1402 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1403 | addProjectionParameterDefaultValue(count,"1.0");
|
||
1404 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1405 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1406 | |||
1407 | String[] parameterMaxValue={"90.0"}; |
||
1408 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1409 | addProjectionParameterMaxValue(count,"360.0");
|
||
1410 | addProjectionParameterMaxValue(count,"10.0");
|
||
1411 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1412 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1413 | |||
1414 | String[] parameterMinValue={"-90.0"}; |
||
1415 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1416 | addProjectionParameterMinValue(count,"-360.0");
|
||
1417 | addProjectionParameterMinValue(count,"0.0");
|
||
1418 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1419 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1420 | |||
1421 | String[] projectionAcronym={"lcca"}; |
||
1422 | projectionAcronymList.add(count,projectionAcronym); |
||
1423 | } |
||
1424 | |||
1425 | count++; |
||
1426 | {// Lambert_Conformal_Conic_1SP
|
||
1427 | String[] projectionName={"Lambert_Conformal_Conic_1SP"}; |
||
1428 | projectionNameList.add(count,projectionName); |
||
1429 | addProjectionName(count,"Lambert Conic Conformal (1SP)");
|
||
1430 | addProjectionName(count,"9801");
|
||
1431 | |||
1432 | String[] parameterName={"latitude_of_origin"}; |
||
1433 | projectionParameterList.add(count,parameterName); |
||
1434 | addProjectionParameter(count,"central_meridian");
|
||
1435 | addProjectionParameter(count,"scale_factor");
|
||
1436 | addProjectionParameter(count,"false_easting");
|
||
1437 | addProjectionParameter(count,"false_northing");
|
||
1438 | |||
1439 | String[] parameterAcronym={"lat_0"}; |
||
1440 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1441 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1442 | addProjectionParameterAcronymList(count,"k_0");
|
||
1443 | addProjectionParameterAcronymList(count,"x_0");
|
||
1444 | addProjectionParameterAcronymList(count,"y_0");
|
||
1445 | |||
1446 | String[] parameterDefaultValue={"0.0"}; |
||
1447 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1448 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1449 | addProjectionParameterDefaultValue(count,"1.0");
|
||
1450 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1451 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1452 | |||
1453 | String[] parameterMaxValue={"90.0"}; |
||
1454 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1455 | addProjectionParameterMaxValue(count,"360.0");
|
||
1456 | addProjectionParameterMaxValue(count,"10.0");
|
||
1457 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1458 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1459 | |||
1460 | String[] parameterMinValue={"-90.0"}; |
||
1461 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1462 | addProjectionParameterMinValue(count,"-360.0");
|
||
1463 | addProjectionParameterMinValue(count,"0.0");
|
||
1464 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1465 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1466 | |||
1467 | String[] projectionAcronym={"lcc"}; |
||
1468 | projectionAcronymList.add(count,projectionAcronym); |
||
1469 | } |
||
1470 | |||
1471 | count++; |
||
1472 | {// Lambert_Conformal_Conic_2SP
|
||
1473 | String[] projectionName={"Lambert_Conformal_Conic_2SP"}; |
||
1474 | projectionNameList.add(count,projectionName); |
||
1475 | addProjectionName(count,"Lambert Conic Conformal (2SP)");
|
||
1476 | addProjectionName(count,"9802");
|
||
1477 | |||
1478 | String[] parameterName={"standard_parallel_1"}; |
||
1479 | projectionParameterList.add(count,parameterName); |
||
1480 | addProjectionParameter(count,"standard_parallel_2");
|
||
1481 | addProjectionParameter(count,"latitude_of_origin");
|
||
1482 | addProjectionParameter(count,"central_meridian");
|
||
1483 | addProjectionParameter(count,"false_easting");
|
||
1484 | addProjectionParameter(count,"false_northing");
|
||
1485 | |||
1486 | String[] parameterAcronym={"lat_1"}; |
||
1487 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1488 | addProjectionParameterAcronymList(count,"lat_2");
|
||
1489 | addProjectionParameterAcronymList(count,"lat_0");
|
||
1490 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1491 | addProjectionParameterAcronymList(count,"x_0");
|
||
1492 | addProjectionParameterAcronymList(count,"y_0");
|
||
1493 | |||
1494 | String[] parameterDefaultValue={"0.0"}; |
||
1495 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1496 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1497 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1498 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1499 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1500 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1501 | |||
1502 | String[] parameterMaxValue={"90.0"}; |
||
1503 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1504 | addProjectionParameterMaxValue(count,"90.0");
|
||
1505 | addProjectionParameterMaxValue(count,"90.0");
|
||
1506 | addProjectionParameterMaxValue(count,"360.0");
|
||
1507 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1508 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1509 | |||
1510 | String[] parameterMinValue={"-90.0"}; |
||
1511 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1512 | addProjectionParameterMinValue(count,"-90.0");
|
||
1513 | addProjectionParameterMinValue(count,"-90.0");
|
||
1514 | addProjectionParameterMinValue(count,"-360.0");
|
||
1515 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1516 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1517 | |||
1518 | String[] projectionAcronym={"lcc"}; |
||
1519 | projectionAcronymList.add(count,projectionAcronym); |
||
1520 | } |
||
1521 | |||
1522 | count++; |
||
1523 | {// Lambert_Conformal_Conic
|
||
1524 | String[] projectionName={"Lambert_Conformal_Conic"}; |
||
1525 | projectionNameList.add(count,projectionName); |
||
1526 | addProjectionName(count,"Lambert Conic Conformal");
|
||
1527 | addProjectionName(count,"9801");
|
||
1528 | |||
1529 | String[] parameterName={"latitude_of_origin"}; |
||
1530 | projectionParameterList.add(count,parameterName); |
||
1531 | addProjectionParameter(count,"standard_parallel_1");
|
||
1532 | addProjectionParameter(count,"standard_parallel_2");
|
||
1533 | addProjectionParameter(count,"central_meridian");
|
||
1534 | addProjectionParameter(count,"scale_factor");
|
||
1535 | addProjectionParameter(count,"false_easting");
|
||
1536 | addProjectionParameter(count,"false_northing");
|
||
1537 | |||
1538 | String[] parameterAcronym={"lat_0"}; |
||
1539 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1540 | addProjectionParameterAcronymList(count,"lat_1");
|
||
1541 | addProjectionParameterAcronymList(count,"lat_2");
|
||
1542 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1543 | addProjectionParameterAcronymList(count,"k_0");
|
||
1544 | addProjectionParameterAcronymList(count,"x_0");
|
||
1545 | addProjectionParameterAcronymList(count,"y_0");
|
||
1546 | |||
1547 | String[] parameterDefaultValue={"0.0"}; |
||
1548 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1549 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1550 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1551 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1552 | addProjectionParameterDefaultValue(count,"1.0");
|
||
1553 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1554 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1555 | |||
1556 | String[] parameterMaxValue={"90.0"}; |
||
1557 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1558 | addProjectionParameterMaxValue(count,"90.0");
|
||
1559 | addProjectionParameterMaxValue(count,"90.0");
|
||
1560 | addProjectionParameterMaxValue(count,"360.0");
|
||
1561 | addProjectionParameterMaxValue(count,"10.0");
|
||
1562 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1563 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1564 | |||
1565 | String[] parameterMinValue={"-90.0"}; |
||
1566 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1567 | addProjectionParameterMinValue(count,"-90.0");
|
||
1568 | addProjectionParameterMinValue(count,"-90.0");
|
||
1569 | addProjectionParameterMinValue(count,"-360.0");
|
||
1570 | addProjectionParameterMinValue(count,"0.0");
|
||
1571 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1572 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1573 | |||
1574 | String[] projectionAcronym={"lcc"}; |
||
1575 | projectionAcronymList.add(count,projectionAcronym); |
||
1576 | } |
||
1577 | |||
1578 | count++; |
||
1579 | {// Lambert_Conformal_Conic_2SP_Belgium
|
||
1580 | String[] projectionName={"Lambert_Conformal_Conic_2SP_Belgium"}; |
||
1581 | projectionNameList.add(count,projectionName); |
||
1582 | addProjectionName(count,"Lambert Conic Conformal (2SP Belgium)");
|
||
1583 | addProjectionName(count,"9803");
|
||
1584 | |||
1585 | String[] parameterName={"standard_parallel_1"}; |
||
1586 | projectionParameterList.add(count,parameterName); |
||
1587 | addProjectionParameter(count,"standard_parallel_2");
|
||
1588 | addProjectionParameter(count,"latitude_of_origin");
|
||
1589 | addProjectionParameter(count,"central_meridian");
|
||
1590 | addProjectionParameter(count,"false_easting");
|
||
1591 | addProjectionParameter(count,"false_northing");
|
||
1592 | |||
1593 | String[] parameterAcronym={"lat_1"}; |
||
1594 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1595 | addProjectionParameterAcronymList(count,"lat_2");
|
||
1596 | addProjectionParameterAcronymList(count,"lat_0");
|
||
1597 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1598 | addProjectionParameterAcronymList(count,"x_0");
|
||
1599 | addProjectionParameterAcronymList(count,"y_0");
|
||
1600 | |||
1601 | String[] parameterDefaultValue={"0.0"}; |
||
1602 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1603 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1604 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1605 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1606 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1607 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1608 | |||
1609 | String[] parameterMaxValue={"90.0"}; |
||
1610 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1611 | addProjectionParameterMaxValue(count,"90.0");
|
||
1612 | addProjectionParameterMaxValue(count,"90.0");
|
||
1613 | addProjectionParameterMaxValue(count,"360.0");
|
||
1614 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1615 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1616 | |||
1617 | String[] parameterMinValue={"-90.0"}; |
||
1618 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1619 | addProjectionParameterMinValue(count,"-90.0");
|
||
1620 | addProjectionParameterMinValue(count,"-90.0");
|
||
1621 | addProjectionParameterMinValue(count,"-360.0");
|
||
1622 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1623 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1624 | |||
1625 | String[] projectionAcronym={"lcc"}; |
||
1626 | projectionAcronymList.add(count,projectionAcronym); |
||
1627 | } |
||
1628 | |||
1629 | count++; |
||
1630 | {// Loximuthal
|
||
1631 | String[] projectionName={"Loximuthal"}; |
||
1632 | projectionNameList.add(count,projectionName); |
||
1633 | //addProjectionName(count,"Winkel I");
|
||
1634 | |||
1635 | String[] parameterName={"central_meridian"}; |
||
1636 | projectionParameterList.add(count,parameterName); |
||
1637 | addProjectionParameter(count,"Central_Parallel");
|
||
1638 | addProjectionParameter(count,"false_easting");
|
||
1639 | addProjectionParameter(count,"false_northing");
|
||
1640 | |||
1641 | String[] parameterAcronym={"lon_0"}; |
||
1642 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1643 | addProjectionParameterAcronymList(count,"lat_1");
|
||
1644 | addProjectionParameterAcronymList(count,"x_0");
|
||
1645 | addProjectionParameterAcronymList(count,"y_0");
|
||
1646 | |||
1647 | String[] parameterDefaultValue={"0.0"}; |
||
1648 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1649 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1650 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1651 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1652 | |||
1653 | String[] parameterMaxValue={"360.0"}; |
||
1654 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1655 | addProjectionParameterMaxValue(count,"90.0");
|
||
1656 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1657 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1658 | |||
1659 | String[] parameterMinValue={"-360.0"}; |
||
1660 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1661 | addProjectionParameterMinValue(count,"-90.0");
|
||
1662 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1663 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1664 | |||
1665 | String[] projectionAcronym={"loxim"}; |
||
1666 | projectionAcronymList.add(count,projectionAcronym); |
||
1667 | } |
||
1668 | |||
1669 | count++; |
||
1670 | {// Mercator_1SP
|
||
1671 | String[] projectionName={"Mercator_1SP"}; |
||
1672 | projectionNameList.add(count,projectionName); |
||
1673 | addProjectionName(count,"Mercator");
|
||
1674 | addProjectionName(count,"Wright");
|
||
1675 | addProjectionName(count,"9804");
|
||
1676 | addProjectionName(count, "Mercator (1SP)");
|
||
1677 | addProjectionName(count, "Mercator_(1SP)");
|
||
1678 | 245 | jjdelcerro | addProjectionName(count,"Mercator_(variant_A)");
|
1679 | 147 | jjdelcerro | |
1680 | String[] parameterName={"central_meridian"}; |
||
1681 | projectionParameterList.add(count,parameterName); |
||
1682 | addProjectionParameter(count,"latitude_of_origin"); // o latitude_origin |
||
1683 | addProjectionParameter(count,"scale_factor"); // o latitude_origin |
||
1684 | addProjectionParameter(count,"false_easting");
|
||
1685 | addProjectionParameter(count,"false_northing");
|
||
1686 | |||
1687 | String[] parameterAcronym={"lon_0"}; |
||
1688 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1689 | addProjectionParameterAcronymList(count,"lat_ts"); // o lat_ts |
||
1690 | addProjectionParameterAcronymList(count,"k"); // o lat_ts |
||
1691 | addProjectionParameterAcronymList(count,"x_0");
|
||
1692 | addProjectionParameterAcronymList(count,"y_0");
|
||
1693 | |||
1694 | String[] parameterDefaultValue={"0.0"}; |
||
1695 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1696 | addProjectionParameterDefaultValue(count,"0.0"); // o 0.0 |
||
1697 | addProjectionParameterDefaultValue(count,"1.0"); // o 0.0 |
||
1698 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1699 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1700 | |||
1701 | String[] parameterMaxValue={"360.0"}; |
||
1702 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1703 | addProjectionParameterMaxValue(count,"90.0");
|
||
1704 | addProjectionParameterMaxValue(count,"10.0");
|
||
1705 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1706 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1707 | |||
1708 | String[] parameterMinValue={"-360.0"}; |
||
1709 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1710 | addProjectionParameterMinValue(count,"-90.0");
|
||
1711 | addProjectionParameterMinValue(count,"0.0");
|
||
1712 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1713 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1714 | |||
1715 | String[] projectionAcronym={"merc"}; |
||
1716 | projectionAcronymList.add(count,projectionAcronym); |
||
1717 | } |
||
1718 | |||
1719 | count++; |
||
1720 | {// Mercator_2SP
|
||
1721 | String[] projectionName={"Mercator_2SP"}; |
||
1722 | projectionNameList.add(count,projectionName); |
||
1723 | addProjectionName(count,"Mercator");
|
||
1724 | addProjectionName(count,"9805");
|
||
1725 | addProjectionName(count, "Mercator (2SP)");
|
||
1726 | |||
1727 | String[] parameterName={"central_meridian"}; |
||
1728 | projectionParameterList.add(count,parameterName); |
||
1729 | addProjectionParameter(count,"standard_parallel_1");
|
||
1730 | addProjectionParameter(count,"false_easting");
|
||
1731 | addProjectionParameter(count,"false_northing");
|
||
1732 | |||
1733 | String[] parameterAcronym={"lon_0"}; |
||
1734 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1735 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
1736 | addProjectionParameterAcronymList(count,"x_0");
|
||
1737 | addProjectionParameterAcronymList(count,"y_0");
|
||
1738 | |||
1739 | String[] parameterDefaultValue={"0.0"}; |
||
1740 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1741 | addProjectionParameterDefaultValue(count,"0.0"); // o 0.0 |
||
1742 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1743 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1744 | |||
1745 | String[] parameterMaxValue={"360.0"}; |
||
1746 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1747 | addProjectionParameterMaxValue(count,"90.0");
|
||
1748 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1749 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1750 | |||
1751 | String[] parameterMinValue={"-360.0"}; |
||
1752 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1753 | addProjectionParameterMinValue(count,"-90.0");
|
||
1754 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1755 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1756 | |||
1757 | String[] projectionAcronym={"merc"}; |
||
1758 | projectionAcronymList.add(count,projectionAcronym); |
||
1759 | } |
||
1760 | |||
1761 | count++; |
||
1762 | {// Miller_Cylindrical
|
||
1763 | String[] projectionName={"Miller_Cylindrical"}; |
||
1764 | projectionNameList.add(count,projectionName); |
||
1765 | addProjectionName(count,"Miller Cylindrical");
|
||
1766 | |||
1767 | String[] parameterName={"latitude_of_center"}; |
||
1768 | projectionParameterList.add(count,parameterName); |
||
1769 | addProjectionParameter(count,"longitude_of_center");
|
||
1770 | addProjectionParameter(count,"false_easting");
|
||
1771 | addProjectionParameter(count,"false_northing");
|
||
1772 | |||
1773 | String[] parameterAcronym={"lat_0"}; |
||
1774 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1775 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1776 | addProjectionParameterAcronymList(count,"x_0");
|
||
1777 | addProjectionParameterAcronymList(count,"y_0");
|
||
1778 | |||
1779 | String[] parameterDefaultValue={"0.0"}; |
||
1780 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1781 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1782 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1783 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1784 | |||
1785 | String[] parameterMaxValue={"90.0"}; |
||
1786 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1787 | addProjectionParameterMaxValue(count,"360.0");
|
||
1788 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1789 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1790 | |||
1791 | String[] parameterMinValue={"-90.0"}; |
||
1792 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1793 | addProjectionParameterMinValue(count,"-360.0");
|
||
1794 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1795 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1796 | |||
1797 | String[] projectionAcronym={"mill"}; |
||
1798 | projectionAcronymList.add(count,projectionAcronym); |
||
1799 | } |
||
1800 | |||
1801 | count++; |
||
1802 | {// Mollweide
|
||
1803 | String[] projectionName={"Mollweide"}; |
||
1804 | projectionNameList.add(count,projectionName); |
||
1805 | addProjectionName(count,"Homolographic");
|
||
1806 | addProjectionName(count,"Homalographic");
|
||
1807 | addProjectionName(count,"Babinet");
|
||
1808 | addProjectionName(count,"Elliptical");
|
||
1809 | |||
1810 | String[] parameterName={"central_meridian"}; |
||
1811 | projectionParameterList.add(count,parameterName); |
||
1812 | addProjectionParameter(count,"false_easting");
|
||
1813 | addProjectionParameter(count,"false_northing");
|
||
1814 | |||
1815 | String[] parameterAcronym={"lon_0"}; |
||
1816 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1817 | addProjectionParameterAcronymList(count,"x_0");
|
||
1818 | addProjectionParameterAcronymList(count,"y_0");
|
||
1819 | |||
1820 | String[] parameterDefaultValue={"0.0"}; |
||
1821 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1822 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1823 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1824 | |||
1825 | String[] parameterMaxValue={"360.0"}; |
||
1826 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1827 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1828 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1829 | |||
1830 | String[] parameterMinValue={"-360.0"}; |
||
1831 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1832 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1833 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1834 | |||
1835 | String[] projectionAcronym={"moll"}; |
||
1836 | projectionAcronymList.add(count,projectionAcronym); |
||
1837 | } |
||
1838 | |||
1839 | count++; |
||
1840 | {// Near-Sided Perspective
|
||
1841 | String[] projectionName={"Near_Sided_Perspective"}; |
||
1842 | projectionNameList.add(count,projectionName); |
||
1843 | addProjectionName(count,"Near Sided Perspective");
|
||
1844 | addProjectionName(count,"Near-Sided Perspective");
|
||
1845 | addProjectionName(count,"Near-Sided-Perspective");
|
||
1846 | addProjectionName(count,"Near-Sided_Perspective");
|
||
1847 | addProjectionName(count,"Vertical Near Side Perspective");
|
||
1848 | addProjectionName(count,"Vertical-Near-Side-Perspective");
|
||
1849 | addProjectionName(count,"Vertical_Near_Side_Perspective");
|
||
1850 | |||
1851 | String[] parameterName={"latitude_of_center"}; |
||
1852 | projectionParameterList.add(count,parameterName); |
||
1853 | addProjectionParameter(count,"longitude_of_center");
|
||
1854 | addProjectionParameter(count,"Height");
|
||
1855 | addProjectionParameter(count,"false_easting");
|
||
1856 | addProjectionParameter(count,"false_northing");
|
||
1857 | |||
1858 | String[] parameterAcronym={"lat_0"}; |
||
1859 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1860 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1861 | addProjectionParameterAcronymList(count,"h");
|
||
1862 | addProjectionParameterAcronymList(count,"x_0");
|
||
1863 | addProjectionParameterAcronymList(count,"y_0");
|
||
1864 | |||
1865 | String[] parameterDefaultValue={"0.0"}; |
||
1866 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1867 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1868 | addProjectionParameterDefaultValue(count,"0.001");
|
||
1869 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1870 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1871 | |||
1872 | String[] parameterMaxValue={"90.0"}; |
||
1873 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1874 | addProjectionParameterMaxValue(count,"360.0");
|
||
1875 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1876 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1877 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1878 | |||
1879 | String[] parameterMinValue={"-90.0"}; |
||
1880 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1881 | addProjectionParameterMinValue(count,"-360.0");
|
||
1882 | addProjectionParameterMinValue(count,"0.001");
|
||
1883 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1884 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1885 | |||
1886 | String[] projectionAcronym={"nsper"}; |
||
1887 | projectionAcronymList.add(count,projectionAcronym); |
||
1888 | } |
||
1889 | |||
1890 | count++; |
||
1891 | {// New_Zealand_Map_Grid
|
||
1892 | String[] projectionName={"New_Zealand_Map_Grid"}; |
||
1893 | projectionNameList.add(count,projectionName); |
||
1894 | addProjectionName(count,"New Zealand Map Grid");
|
||
1895 | addProjectionName(count,"9811");
|
||
1896 | |||
1897 | String[] parameterName={"latitude_of_origin"}; |
||
1898 | projectionParameterList.add(count,parameterName); |
||
1899 | addProjectionParameter(count,"central_meridian");
|
||
1900 | addProjectionParameter(count,"false_easting");
|
||
1901 | addProjectionParameter(count,"false_northing");
|
||
1902 | |||
1903 | String[] parameterAcronym={"lat_0"}; |
||
1904 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1905 | addProjectionParameterAcronymList(count,"lon_0");
|
||
1906 | addProjectionParameterAcronymList(count,"x_0");
|
||
1907 | addProjectionParameterAcronymList(count,"y_0");
|
||
1908 | |||
1909 | String[] parameterDefaultValue={"0.0"}; |
||
1910 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1911 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1912 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1913 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1914 | |||
1915 | String[] parameterMaxValue={"90.0"}; |
||
1916 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1917 | addProjectionParameterMaxValue(count,"360.0");
|
||
1918 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1919 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1920 | |||
1921 | String[] parameterMinValue={"-90.0"}; |
||
1922 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1923 | addProjectionParameterMinValue(count,"-360.0");
|
||
1924 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1925 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1926 | |||
1927 | String[] projectionAcronym={"nzmg"}; |
||
1928 | projectionAcronymList.add(count,projectionAcronym); |
||
1929 | } |
||
1930 | |||
1931 | count++; |
||
1932 | {// Oblique_Mercator
|
||
1933 | String[] projectionName={"Oblique_Mercator"}; |
||
1934 | projectionNameList.add(count,projectionName); |
||
1935 | addProjectionName(count,"Oblique Mercator");
|
||
1936 | addProjectionName(count,"9815");
|
||
1937 | addProjectionName(count,"CT_ObliqueMercator");
|
||
1938 | addProjectionName(count,"Hotine_Oblique_Mercator_Azimuth_Center");
|
||
1939 | addProjectionName(count,"Rectified_Skew_Orthomorphic_Center");
|
||
1940 | addProjectionName(count,"Hotine Oblique Mercator");
|
||
1941 | addProjectionName(count,"Hotine_Oblique_Mercator");
|
||
1942 | 245 | jjdelcerro | addProjectionName(count,"Hotine_Oblique_Mercator_(variant_B)");
|
1943 | 147 | jjdelcerro | |
1944 | String[] parameterName={"latitude_of_center"}; |
||
1945 | projectionParameterList.add(count,parameterName); |
||
1946 | addProjectionParameter(count,"longitude_of_center");
|
||
1947 | addProjectionParameter(count,"azimuth");
|
||
1948 | addProjectionParameter(count,"rectified_grid_angle");
|
||
1949 | addProjectionParameter(count,"scale_factor");
|
||
1950 | addProjectionParameter(count,"false_easting");
|
||
1951 | addProjectionParameter(count,"false_northing");
|
||
1952 | |||
1953 | String[] parameterAcronym={"lat_0"}; |
||
1954 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
1955 | addProjectionParameterAcronymList(count,"lonc");
|
||
1956 | addProjectionParameterAcronymList(count,"alpha");
|
||
1957 | addProjectionParameterAcronymList(count,"gamma");
|
||
1958 | addProjectionParameterAcronymList(count,"k");
|
||
1959 | addProjectionParameterAcronymList(count,"x_0");
|
||
1960 | addProjectionParameterAcronymList(count,"y_0");
|
||
1961 | |||
1962 | String[] parameterDefaultValue={"0.0"}; |
||
1963 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
1964 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1965 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1966 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1967 | addProjectionParameterDefaultValue(count,"1.0");
|
||
1968 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1969 | addProjectionParameterDefaultValue(count,"0.0");
|
||
1970 | |||
1971 | String[] parameterMaxValue={"90.0"}; |
||
1972 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
1973 | addProjectionParameterMaxValue(count,"360.0");
|
||
1974 | addProjectionParameterMaxValue(count,"360.0");
|
||
1975 | addProjectionParameterMaxValue(count,"360.0");
|
||
1976 | addProjectionParameterMaxValue(count,"10.0");
|
||
1977 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1978 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
1979 | |||
1980 | String[] parameterMinValue={"-90.0"}; |
||
1981 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
1982 | addProjectionParameterMinValue(count,"-360.0");
|
||
1983 | addProjectionParameterMinValue(count,"-360.0");
|
||
1984 | addProjectionParameterMinValue(count,"-360.0");
|
||
1985 | addProjectionParameterMinValue(count,"0.0");
|
||
1986 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1987 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
1988 | |||
1989 | String[] projectionAcronym={"omerc"}; |
||
1990 | projectionAcronymList.add(count,projectionAcronym); |
||
1991 | } |
||
1992 | |||
1993 | count++; |
||
1994 | {// Oblique_Mercator
|
||
1995 | String[] projectionName={"Hotine_Oblique_Mercator_Two_Point_Center"}; |
||
1996 | projectionNameList.add(count,projectionName); |
||
1997 | addProjectionName(count,"Hotine_Oblique_Mercator_Two_Point_Natural_Origin");
|
||
1998 | |||
1999 | /*SEMI_MAJOR, SEMI_MINOR,
|
||
2000 | LAT_OF_1ST_POINT, LONG_OF_1ST_POINT,
|
||
2001 | LAT_OF_2ND_POINT, LONG_OF_2ND_POINT,
|
||
2002 | LAT_OF_CENTRE, SCALE_FACTOR_LOCAL,
|
||
2003 | FALSE_EASTING_LOCAL, FALSE_NORTHING_LOCAL*/
|
||
2004 | |||
2005 | String[] parameterName={"Latitude_Of_1st_Point"}; |
||
2006 | projectionParameterList.add(count,parameterName); |
||
2007 | addProjectionParameter(count,"Longitude_Of_1st_Point");
|
||
2008 | addProjectionParameter(count,"Latitude_Of_2nd_Point");
|
||
2009 | addProjectionParameter(count,"Longitude_Of_2nd_Point");
|
||
2010 | addProjectionParameter(count,"scale_factor");
|
||
2011 | addProjectionParameter(count,"false_easting");
|
||
2012 | addProjectionParameter(count,"false_northing");
|
||
2013 | |||
2014 | String[] parameterAcronym={"lat_1"}; |
||
2015 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2016 | addProjectionParameterAcronymList(count,"lon_1");
|
||
2017 | addProjectionParameterAcronymList(count,"lat_2");
|
||
2018 | addProjectionParameterAcronymList(count,"lon_2");
|
||
2019 | addProjectionParameterAcronymList(count,"k");
|
||
2020 | addProjectionParameterAcronymList(count,"x_0");
|
||
2021 | addProjectionParameterAcronymList(count,"y_0");
|
||
2022 | |||
2023 | String[] parameterDefaultValue={"0.0"}; |
||
2024 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2025 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2026 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2027 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2028 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2029 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2030 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2031 | |||
2032 | String[] parameterMaxValue={"90.0"}; |
||
2033 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2034 | addProjectionParameterMaxValue(count,"360.0");
|
||
2035 | addProjectionParameterMaxValue(count,"90.0");
|
||
2036 | addProjectionParameterMaxValue(count,"360.0");
|
||
2037 | addProjectionParameterMaxValue(count,"10.0");
|
||
2038 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2039 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2040 | |||
2041 | String[] parameterMinValue={"-90.0"}; |
||
2042 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2043 | addProjectionParameterMinValue(count,"-360.0");
|
||
2044 | addProjectionParameterMinValue(count,"-90.0");
|
||
2045 | addProjectionParameterMinValue(count,"-360.0");
|
||
2046 | addProjectionParameterMinValue(count,"0.0");
|
||
2047 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2048 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2049 | |||
2050 | String[] projectionAcronym={"omerc"}; |
||
2051 | projectionAcronymList.add(count,projectionAcronym); |
||
2052 | } |
||
2053 | |||
2054 | count++; |
||
2055 | {// Oblique_Stereographic
|
||
2056 | String[] projectionName={"Oblique_Stereographic"}; |
||
2057 | projectionNameList.add(count,projectionName); |
||
2058 | addProjectionName(count,"Oblique Stereographic");
|
||
2059 | addProjectionName(count,"9809");
|
||
2060 | |||
2061 | String[] parameterName={"latitude_of_origin"}; |
||
2062 | projectionParameterList.add(count,parameterName); |
||
2063 | addProjectionParameter(count,"central_meridian");
|
||
2064 | addProjectionParameter(count,"scale_factor");
|
||
2065 | addProjectionParameter(count,"false_easting");
|
||
2066 | addProjectionParameter(count,"false_northing");
|
||
2067 | |||
2068 | String[] parameterAcronym={"lat_0"}; |
||
2069 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2070 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2071 | addProjectionParameterAcronymList(count,"k");
|
||
2072 | addProjectionParameterAcronymList(count,"x_0");
|
||
2073 | addProjectionParameterAcronymList(count,"y_0");
|
||
2074 | |||
2075 | String[] parameterDefaultValue={"0.0"}; |
||
2076 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2077 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2078 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2079 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2080 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2081 | |||
2082 | String[] parameterMaxValue={"90.0"}; |
||
2083 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2084 | addProjectionParameterMaxValue(count,"360.0");
|
||
2085 | addProjectionParameterMaxValue(count,"10.0");
|
||
2086 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2087 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2088 | |||
2089 | String[] parameterMinValue={"-90.0"}; |
||
2090 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2091 | addProjectionParameterMinValue(count,"-360.0");
|
||
2092 | addProjectionParameterMinValue(count,"0.0");
|
||
2093 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2094 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2095 | |||
2096 | String[] projectionAcronym={"sterea"}; |
||
2097 | projectionAcronymList.add(count,projectionAcronym); |
||
2098 | } |
||
2099 | |||
2100 | count++; |
||
2101 | {// Orthographic
|
||
2102 | String[] projectionName={"Orthographic"}; |
||
2103 | projectionNameList.add(count,projectionName); |
||
2104 | |||
2105 | String[] parameterName={"latitude_of_origin"}; |
||
2106 | projectionParameterList.add(count,parameterName); |
||
2107 | addProjectionParameter(count,"central_meridian");
|
||
2108 | addProjectionParameter(count,"false_easting");
|
||
2109 | addProjectionParameter(count,"false_northing");
|
||
2110 | |||
2111 | String[] parameterAcronym={"lat_0"}; |
||
2112 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2113 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2114 | addProjectionParameterAcronymList(count,"x_0");
|
||
2115 | addProjectionParameterAcronymList(count,"y_0");
|
||
2116 | |||
2117 | String[] parameterDefaultValue={"0.0"}; |
||
2118 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2119 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2120 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2121 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2122 | |||
2123 | String[] parameterMaxValue={"90.0"}; |
||
2124 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2125 | addProjectionParameterMaxValue(count,"360.0");
|
||
2126 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2127 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2128 | |||
2129 | String[] parameterMinValue={"-90.0"}; |
||
2130 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2131 | addProjectionParameterMinValue(count,"-360.0");
|
||
2132 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2133 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2134 | |||
2135 | String[] projectionAcronym={"ortho"}; |
||
2136 | projectionAcronymList.add(count,projectionAcronym); |
||
2137 | } |
||
2138 | |||
2139 | count++; |
||
2140 | {// Polar_Stereographic
|
||
2141 | String[] projectionName={"Polar_Stereographic"}; |
||
2142 | projectionNameList.add(count,projectionName); |
||
2143 | addProjectionName(count,"Polar Stereographic");
|
||
2144 | addProjectionName(count,"Polar_Stereographic_(variant_A)");
|
||
2145 | addProjectionName(count,"Polar_Stereographic_(variant_B)");
|
||
2146 | addProjectionName(count,"9810");
|
||
2147 | addProjectionName(count,"9829");
|
||
2148 | |||
2149 | String[] parameterName={"latitude_of_origin"}; |
||
2150 | projectionParameterList.add(count,parameterName); |
||
2151 | addProjectionParameter(count,"latitude_of_standard_parallel");
|
||
2152 | addProjectionParameter(count,"central_meridian");
|
||
2153 | addProjectionParameter(count,"scale_factor");
|
||
2154 | addProjectionParameter(count,"false_easting");
|
||
2155 | addProjectionParameter(count,"false_northing");
|
||
2156 | |||
2157 | String[] parameterAcronym={"lat_0"}; |
||
2158 | //lat_0=90 o lat_0=-90
|
||
2159 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2160 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2161 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2162 | addProjectionParameterAcronymList(count,"k_0");
|
||
2163 | addProjectionParameterAcronymList(count,"x_0");
|
||
2164 | addProjectionParameterAcronymList(count,"y_0");
|
||
2165 | |||
2166 | String[] parameterDefaultValue={"90.0"}; |
||
2167 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2168 | addProjectionParameterDefaultValue(count,"90.0");
|
||
2169 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2170 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2171 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2172 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2173 | |||
2174 | String[] parameterMaxValue={"90.0"}; |
||
2175 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2176 | addProjectionParameterMaxValue(count,"90.0");
|
||
2177 | addProjectionParameterMaxValue(count,"360.0");
|
||
2178 | addProjectionParameterMaxValue(count,"10.0");
|
||
2179 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2180 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2181 | |||
2182 | String[] parameterMinValue={"-90.0"}; |
||
2183 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2184 | addProjectionParameterMinValue(count,"-90.0");
|
||
2185 | addProjectionParameterMinValue(count,"-360.0");
|
||
2186 | addProjectionParameterMinValue(count,"0.0");
|
||
2187 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2188 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2189 | |||
2190 | String[] projectionAcronym={"stere"}; |
||
2191 | projectionAcronymList.add(count,projectionAcronym); |
||
2192 | } |
||
2193 | |||
2194 | count++; |
||
2195 | {// Polyconic
|
||
2196 | String[] projectionName={"Polyconic"}; |
||
2197 | projectionNameList.add(count,projectionName); |
||
2198 | addProjectionName(count,"American_Polyconic");
|
||
2199 | addProjectionName(count,"American Polyconic");
|
||
2200 | addProjectionName(count,"9818");
|
||
2201 | |||
2202 | String[] parameterName={"latitude_of_origin"}; |
||
2203 | projectionParameterList.add(count,parameterName); |
||
2204 | addProjectionParameter(count,"central_meridian");
|
||
2205 | addProjectionParameter(count,"false_easting");
|
||
2206 | addProjectionParameter(count,"false_northing");
|
||
2207 | |||
2208 | String[] parameterAcronym={"lat_0"}; |
||
2209 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2210 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2211 | addProjectionParameterAcronymList(count,"x_0");
|
||
2212 | addProjectionParameterAcronymList(count,"y_0");
|
||
2213 | |||
2214 | String[] parameterDefaultValue={"0.0"}; |
||
2215 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2216 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2217 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2218 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2219 | |||
2220 | String[] parameterMaxValue={"90.0"}; |
||
2221 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2222 | addProjectionParameterMaxValue(count,"360.0");
|
||
2223 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2224 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2225 | |||
2226 | String[] parameterMinValue={"-90.0"}; |
||
2227 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2228 | addProjectionParameterMinValue(count,"-360.0");
|
||
2229 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2230 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2231 | |||
2232 | String[] projectionAcronym={"poly"}; |
||
2233 | projectionAcronymList.add(count,projectionAcronym); |
||
2234 | } |
||
2235 | |||
2236 | count++; |
||
2237 | {// Quartic Authalic
|
||
2238 | String[] projectionName={"Quartic_Authalic"}; |
||
2239 | projectionNameList.add(count,projectionName); |
||
2240 | addProjectionName(count,"Quartic Authalic");
|
||
2241 | addProjectionName(count,"Quartic-Authalic");
|
||
2242 | |||
2243 | String[] parameterName={"central_meridian"}; |
||
2244 | projectionParameterList.add(count,parameterName); |
||
2245 | addProjectionParameter(count,"false_easting");
|
||
2246 | addProjectionParameter(count,"false_northing");
|
||
2247 | |||
2248 | String[] parameterAcronym={"lon_0"}; |
||
2249 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2250 | addProjectionParameterAcronymList(count,"x_0");
|
||
2251 | addProjectionParameterAcronymList(count,"y_0");
|
||
2252 | |||
2253 | String[] parameterDefaultValue={"0.0"}; |
||
2254 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2255 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2256 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2257 | |||
2258 | String[] parameterMaxValue={"360.0"}; |
||
2259 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2260 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2261 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2262 | |||
2263 | String[] parameterMinValue={"-360.0"}; |
||
2264 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2265 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2266 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2267 | |||
2268 | String[] projectionAcronym={"qua_aut"}; |
||
2269 | projectionAcronymList.add(count,projectionAcronym); |
||
2270 | } |
||
2271 | |||
2272 | count++; |
||
2273 | {// Robinson
|
||
2274 | String[] projectionName={"Robinson"}; |
||
2275 | projectionNameList.add(count,projectionName); |
||
2276 | addProjectionName(count,"Orthophanic");
|
||
2277 | |||
2278 | String[] parameterName={"longitude_of_center"}; |
||
2279 | projectionParameterList.add(count,parameterName); |
||
2280 | addProjectionParameter(count,"false_easting");
|
||
2281 | addProjectionParameter(count,"false_northing");
|
||
2282 | |||
2283 | String[] parameterAcronym={"lon_0"}; |
||
2284 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2285 | addProjectionParameterAcronymList(count,"x_0");
|
||
2286 | addProjectionParameterAcronymList(count,"y_0");
|
||
2287 | |||
2288 | String[] parameterDefaultValue={"0.0"}; |
||
2289 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2290 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2291 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2292 | |||
2293 | String[] parameterMaxValue={"360.0"}; |
||
2294 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2295 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2296 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2297 | |||
2298 | String[] parameterMinValue={"-360.0"}; |
||
2299 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2300 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2301 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2302 | |||
2303 | String[] projectionAcronym={"robin"}; |
||
2304 | projectionAcronymList.add(count,projectionAcronym); |
||
2305 | } |
||
2306 | |||
2307 | // Rosenmund Oblique Mercator - No en EPSG
|
||
2308 | |||
2309 | count++; |
||
2310 | {// Sinusoidal
|
||
2311 | String[] projectionName={"Sinusoidal"}; |
||
2312 | projectionNameList.add(count,projectionName); |
||
2313 | addProjectionName(count,"Sanson-Flamsteed");
|
||
2314 | addProjectionName(count,"Sanson Flamsteed");
|
||
2315 | addProjectionName(count,"Sanson_Flamsteed");
|
||
2316 | addProjectionName(count,"Mercator equal area");
|
||
2317 | addProjectionName(count,"Mercator_equal_area");
|
||
2318 | |||
2319 | String[] parameterName={"longitude_of_center"}; |
||
2320 | projectionParameterList.add(count,parameterName); |
||
2321 | addProjectionParameter(count,"false_easting");
|
||
2322 | addProjectionParameter(count,"false_northing");
|
||
2323 | |||
2324 | String[] parameterAcronym={"lon_0"}; |
||
2325 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2326 | addProjectionParameterAcronymList(count,"x_0");
|
||
2327 | addProjectionParameterAcronymList(count,"y_0");
|
||
2328 | |||
2329 | String[] parameterDefaultValue={"0.0"}; |
||
2330 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2331 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2332 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2333 | |||
2334 | String[] parameterMaxValue={"360.0"}; |
||
2335 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2336 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2337 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2338 | |||
2339 | String[] parameterMinValue={"-360.0"}; |
||
2340 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2341 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2342 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2343 | |||
2344 | String[] projectionAcronym={"sinu"}; |
||
2345 | projectionAcronymList.add(count,projectionAcronym); |
||
2346 | } |
||
2347 | |||
2348 | count++; |
||
2349 | {// Swiss_Oblique_Cylindrical
|
||
2350 | String[] projectionName={"Swiss_Oblique_Cylindrical"}; |
||
2351 | projectionNameList.add(count,projectionName); |
||
2352 | addProjectionName(count,"Swiss Oblique Cylindrical");
|
||
2353 | addProjectionName(count,"Swiss Oblique Mercator");
|
||
2354 | addProjectionName(count,"9814");
|
||
2355 | |||
2356 | String[] parameterName={"latitude_of_origin"}; |
||
2357 | projectionParameterList.add(count,parameterName); |
||
2358 | addProjectionParameter(count,"central_meridian");
|
||
2359 | addProjectionParameter(count,"false_easting");
|
||
2360 | addProjectionParameter(count,"false_northing");
|
||
2361 | |||
2362 | String[] parameterAcronym={"lat_0"}; |
||
2363 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2364 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2365 | addProjectionParameterAcronymList(count,"x_0");
|
||
2366 | addProjectionParameterAcronymList(count,"y_0");
|
||
2367 | |||
2368 | String[] parameterDefaultValue={"0.0"}; |
||
2369 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2370 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2371 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2372 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2373 | |||
2374 | String[] parameterMaxValue={"90.0"}; |
||
2375 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2376 | addProjectionParameterMaxValue(count,"360.0");
|
||
2377 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2378 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2379 | |||
2380 | String[] parameterMinValue={"-90.0"}; |
||
2381 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2382 | addProjectionParameterMinValue(count,"-360.0");
|
||
2383 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2384 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2385 | |||
2386 | String[] projectionAcronym={"somerc"}; |
||
2387 | projectionAcronymList.add(count,projectionAcronym); |
||
2388 | } |
||
2389 | |||
2390 | count++; |
||
2391 | {// Stereographic
|
||
2392 | String[] projectionName={"Stereographic"}; |
||
2393 | projectionNameList.add(count,projectionName); |
||
2394 | |||
2395 | String[] parameterName={"latitude_of_origin"}; |
||
2396 | projectionParameterList.add(count,parameterName); |
||
2397 | addProjectionParameter(count,"latitude_of_standard_parallel");
|
||
2398 | addProjectionParameter(count,"central_meridian");
|
||
2399 | addProjectionParameter(count,"scale_factor");
|
||
2400 | addProjectionParameter(count,"false_easting");
|
||
2401 | addProjectionParameter(count,"false_northing");
|
||
2402 | |||
2403 | String[] parameterAcronym={"lat_0"}; |
||
2404 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2405 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2406 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2407 | addProjectionParameterAcronymList(count,"k");
|
||
2408 | addProjectionParameterAcronymList(count,"x_0");
|
||
2409 | addProjectionParameterAcronymList(count,"y_0");
|
||
2410 | |||
2411 | String[] parameterDefaultValue={"0.0"}; |
||
2412 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2413 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2414 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2415 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2416 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2417 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2418 | |||
2419 | String[] parameterMaxValue={"90.0"}; |
||
2420 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2421 | addProjectionParameterMaxValue(count,"90.0");
|
||
2422 | addProjectionParameterMaxValue(count,"360.0");
|
||
2423 | addProjectionParameterMaxValue(count,"10.0");
|
||
2424 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2425 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2426 | |||
2427 | String[] parameterMinValue={"-90.0"}; |
||
2428 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2429 | addProjectionParameterMinValue(count,"-90.0");
|
||
2430 | addProjectionParameterMinValue(count,"-360.0");
|
||
2431 | addProjectionParameterMinValue(count,"0.0");
|
||
2432 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2433 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2434 | |||
2435 | String[] projectionAcronym={"stere"}; |
||
2436 | projectionAcronymList.add(count,projectionAcronym); |
||
2437 | } |
||
2438 | |||
2439 | count++; |
||
2440 | {// Stereographic North Pole
|
||
2441 | String[] projectionName={"Stereographic_North_Pole"}; |
||
2442 | projectionNameList.add(count,projectionName); |
||
2443 | |||
2444 | String[] parameterName={"latitude_of_origin"}; |
||
2445 | projectionParameterList.add(count,parameterName); |
||
2446 | addProjectionParameter(count,"standard_parallel_1");
|
||
2447 | addProjectionParameter(count,"central_meridian");
|
||
2448 | addProjectionParameter(count,"scale_factor");
|
||
2449 | addProjectionParameter(count,"false_easting");
|
||
2450 | addProjectionParameter(count,"false_northing");
|
||
2451 | |||
2452 | String[] parameterAcronym={"lat_0"}; |
||
2453 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2454 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2455 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2456 | addProjectionParameterAcronymList(count,"k");
|
||
2457 | addProjectionParameterAcronymList(count,"x_0");
|
||
2458 | addProjectionParameterAcronymList(count,"y_0");
|
||
2459 | |||
2460 | String[] parameterDefaultValue={"90.0"}; |
||
2461 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2462 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2463 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2464 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2465 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2466 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2467 | |||
2468 | String[] parameterMaxValue={"90.0"}; |
||
2469 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2470 | addProjectionParameterMaxValue(count,"90.0");
|
||
2471 | addProjectionParameterMaxValue(count,"360.0");
|
||
2472 | addProjectionParameterMaxValue(count,"10.0");
|
||
2473 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2474 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2475 | |||
2476 | String[] parameterMinValue={"-90.0"}; |
||
2477 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2478 | addProjectionParameterMinValue(count,"-90.0");
|
||
2479 | addProjectionParameterMinValue(count,"-360.0");
|
||
2480 | addProjectionParameterMinValue(count,"0.0");
|
||
2481 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2482 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2483 | |||
2484 | String[] projectionAcronym={"stere"}; |
||
2485 | projectionAcronymList.add(count,projectionAcronym); |
||
2486 | } |
||
2487 | |||
2488 | count++; |
||
2489 | {// Stereographic South Pole
|
||
2490 | String[] projectionName={"Stereographic_South_Pole"}; |
||
2491 | projectionNameList.add(count,projectionName); |
||
2492 | |||
2493 | String[] parameterName={"latitude_of_origin"}; |
||
2494 | projectionParameterList.add(count,parameterName); |
||
2495 | addProjectionParameter(count,"standard_parallel_1");
|
||
2496 | addProjectionParameter(count,"central_meridian");
|
||
2497 | addProjectionParameter(count,"scale_factor");
|
||
2498 | addProjectionParameter(count,"false_easting");
|
||
2499 | addProjectionParameter(count,"false_northing");
|
||
2500 | |||
2501 | String[] parameterAcronym={"lat_0"}; |
||
2502 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2503 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2504 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2505 | addProjectionParameterAcronymList(count,"k");
|
||
2506 | addProjectionParameterAcronymList(count,"x_0");
|
||
2507 | addProjectionParameterAcronymList(count,"y_0");
|
||
2508 | |||
2509 | String[] parameterDefaultValue={"-90.0"}; |
||
2510 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2511 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2512 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2513 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2514 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2515 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2516 | |||
2517 | String[] parameterMaxValue={"90.0"}; |
||
2518 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2519 | addProjectionParameterMaxValue(count,"90.0");
|
||
2520 | addProjectionParameterMaxValue(count,"360.0");
|
||
2521 | addProjectionParameterMaxValue(count,"10.0");
|
||
2522 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2523 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2524 | |||
2525 | String[] parameterMinValue={"-90.0"}; |
||
2526 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2527 | addProjectionParameterMinValue(count,"-90.0");
|
||
2528 | addProjectionParameterMinValue(count,"-360.0");
|
||
2529 | addProjectionParameterMinValue(count,"0.0");
|
||
2530 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2531 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2532 | |||
2533 | String[] projectionAcronym={"stere"}; |
||
2534 | projectionAcronymList.add(count,projectionAcronym); |
||
2535 | } |
||
2536 | |||
2537 | count++; |
||
2538 | {// Transverse_Mercator
|
||
2539 | String[] projectionName={"Transverse_Mercator"}; |
||
2540 | projectionNameList.add(count,projectionName); |
||
2541 | addProjectionName(count,"Transverse Mercator");
|
||
2542 | addProjectionName(count,"Gauss-Kruger");
|
||
2543 | addProjectionName(count,"Gauss_Kruger");
|
||
2544 | addProjectionName(count,"Gauss Conformal");
|
||
2545 | addProjectionName(count,"Transverse Cylindrical Orthomorphic");
|
||
2546 | addProjectionName(count,"9807");
|
||
2547 | |||
2548 | String[] parameterName={"latitude_of_origin"}; |
||
2549 | projectionParameterList.add(count,parameterName); |
||
2550 | addProjectionParameter(count,"central_meridian");
|
||
2551 | addProjectionParameter(count,"scale_factor");
|
||
2552 | addProjectionParameter(count,"false_easting");
|
||
2553 | addProjectionParameter(count,"false_northing");
|
||
2554 | |||
2555 | String[] parameterAcronym={"lat_0"}; |
||
2556 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2557 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2558 | addProjectionParameterAcronymList(count,"k");
|
||
2559 | addProjectionParameterAcronymList(count,"x_0");
|
||
2560 | addProjectionParameterAcronymList(count,"y_0");
|
||
2561 | |||
2562 | String[] parameterDefaultValue={"0.0"}; |
||
2563 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2564 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2565 | addProjectionParameterDefaultValue(count,"1.0");
|
||
2566 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2567 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2568 | |||
2569 | String[] parameterMaxValue={"90.0"}; |
||
2570 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2571 | addProjectionParameterMaxValue(count,"360.0");
|
||
2572 | addProjectionParameterMaxValue(count,"10.0");
|
||
2573 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2574 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2575 | |||
2576 | String[] parameterMinValue={"-90.0"}; |
||
2577 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2578 | addProjectionParameterMinValue(count,"-360.0");
|
||
2579 | addProjectionParameterMinValue(count,"0.0");
|
||
2580 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2581 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2582 | |||
2583 | String[] projectionAcronym={"tmerc"}; |
||
2584 | projectionAcronymList.add(count,projectionAcronym); |
||
2585 | } |
||
2586 | |||
2587 | /*
|
||
2588 | count++;
|
||
2589 | {// Tunisia_Mining_Grid
|
||
2590 | String[] projectionName={"Tunisia_Mining_Gridr"};
|
||
2591 | projectionNameList.add(count,projectionName);
|
||
2592 | addProjectionName(count,"Tunisia Mining Grid");
|
||
2593 | addProjectionName(count,"9816");
|
||
2594 | |||
2595 | String[] parameterName={"latitude_of_origin"};
|
||
2596 | projectionParameterList.add(count,parameterName);
|
||
2597 | addProjectionParameter(count,"central_meridian");
|
||
2598 | addProjectionParameter(count,"false_easting");
|
||
2599 | addProjectionParameter(count,"false_northing");
|
||
2600 | |||
2601 | String[] parameterAcronym={"lat_0"};
|
||
2602 | projectionParameterAcronymList.add(count,parameterAcronym);
|
||
2603 | addProjectionParameterAcronymList(count,"lon_0");
|
||
2604 | addProjectionParameterAcronymList(count,"x_0");
|
||
2605 | addProjectionParameterAcronymList(count,"y_0");
|
||
2606 | |||
2607 | String[] parameterDefaultValue={"0.0"};
|
||
2608 | projectionParameterDefaultValueList.add(count,parameterDefaultValue);
|
||
2609 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2610 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2611 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2612 | |||
2613 | String[] parameterMaxValue={"90.0"};
|
||
2614 | projectionParameterMaxValueList.add(count,parameterMaxValue);
|
||
2615 | addProjectionParameterMaxValue(count,"360.0");
|
||
2616 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2617 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2618 | |||
2619 | String[] parameterMinValue={"-90.0"};
|
||
2620 | projectionParameterMinValueList.add(count,parameterMinValue);
|
||
2621 | addProjectionParameterMinValue(count,"-360.0");
|
||
2622 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2623 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2624 | |||
2625 | String[] projectionAcronym={"cass"};
|
||
2626 | projectionAcronymList.add(count,projectionAcronym);
|
||
2627 | }
|
||
2628 | */
|
||
2629 | |||
2630 | count++; |
||
2631 | {// VanDerGrinten
|
||
2632 | String[] projectionName={"VanDerGrinten"}; |
||
2633 | projectionNameList.add(count,projectionName); |
||
2634 | addProjectionName(count,"VanDerGrinten I");
|
||
2635 | addProjectionName(count,"VanderGrinten");
|
||
2636 | addProjectionName(count,"Van_der_Grinten_I");
|
||
2637 | |||
2638 | String[] parameterName={"central_meridian"}; |
||
2639 | projectionParameterList.add(count,parameterName); |
||
2640 | addProjectionParameter(count,"false_easting");
|
||
2641 | addProjectionParameter(count,"false_northing");
|
||
2642 | |||
2643 | String[] parameterAcronym={"lon_0"}; |
||
2644 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2645 | addProjectionParameterAcronymList(count,"x_0");
|
||
2646 | addProjectionParameterAcronymList(count,"y_0");
|
||
2647 | |||
2648 | String[] parameterDefaultValue={"0.0"}; |
||
2649 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2650 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2651 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2652 | |||
2653 | String[] parameterMaxValue={"360.0"}; |
||
2654 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2655 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2656 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2657 | |||
2658 | String[] parameterMinValue={"-360.0"}; |
||
2659 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2660 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2661 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2662 | |||
2663 | String[] projectionAcronym={"vandg"}; |
||
2664 | projectionAcronymList.add(count,projectionAcronym); |
||
2665 | } |
||
2666 | |||
2667 | count++; |
||
2668 | {// Winkel_I
|
||
2669 | String[] projectionName={"Winkel_I"}; |
||
2670 | projectionNameList.add(count,projectionName); |
||
2671 | addProjectionName(count,"Winkel I");
|
||
2672 | addProjectionName(count,"Winkel-I");
|
||
2673 | |||
2674 | String[] parameterName={"central_meridian"}; |
||
2675 | projectionParameterList.add(count,parameterName); |
||
2676 | addProjectionParameter(count,"standard_parallel_1");
|
||
2677 | addProjectionParameter(count,"false_easting");
|
||
2678 | addProjectionParameter(count,"false_northing");
|
||
2679 | |||
2680 | String[] parameterAcronym={"lon_0"}; |
||
2681 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2682 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2683 | addProjectionParameterAcronymList(count,"x_0");
|
||
2684 | addProjectionParameterAcronymList(count,"y_0");
|
||
2685 | |||
2686 | String[] parameterDefaultValue={"0.0"}; |
||
2687 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2688 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2689 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2690 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2691 | |||
2692 | String[] parameterMaxValue={"360.0"}; |
||
2693 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2694 | addProjectionParameterMaxValue(count,"90.0");
|
||
2695 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2696 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2697 | |||
2698 | String[] parameterMinValue={"-360.0"}; |
||
2699 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2700 | addProjectionParameterMinValue(count,"-90.0");
|
||
2701 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2702 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2703 | |||
2704 | String[] projectionAcronym={"wink1"}; |
||
2705 | projectionAcronymList.add(count,projectionAcronym); |
||
2706 | } |
||
2707 | |||
2708 | count++; |
||
2709 | {// Winkel_II
|
||
2710 | String[] projectionName={"Winkel_II"}; |
||
2711 | projectionNameList.add(count,projectionName); |
||
2712 | addProjectionName(count,"Winkel II");
|
||
2713 | |||
2714 | String[] parameterName={"central_meridian"}; |
||
2715 | projectionParameterList.add(count,parameterName); |
||
2716 | addProjectionParameter(count,"standard_parallel_1");
|
||
2717 | addProjectionParameter(count,"false_easting");
|
||
2718 | addProjectionParameter(count,"false_northing");
|
||
2719 | |||
2720 | String[] parameterAcronym={"lon_0"}; |
||
2721 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2722 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2723 | addProjectionParameterAcronymList(count,"x_0");
|
||
2724 | addProjectionParameterAcronymList(count,"y_0");
|
||
2725 | |||
2726 | String[] parameterDefaultValue={"0.0"}; |
||
2727 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2728 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2729 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2730 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2731 | |||
2732 | String[] parameterMaxValue={"360.0"}; |
||
2733 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2734 | addProjectionParameterMaxValue(count,"90.0");
|
||
2735 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2736 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2737 | |||
2738 | String[] parameterMinValue={"-360.0"}; |
||
2739 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2740 | addProjectionParameterMinValue(count,"-90.0");
|
||
2741 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2742 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2743 | |||
2744 | String[] projectionAcronym={"wink2"}; |
||
2745 | projectionAcronymList.add(count,projectionAcronym); |
||
2746 | } |
||
2747 | |||
2748 | count++; |
||
2749 | {// Winkel Tripel
|
||
2750 | String[] projectionName={"Winkel_Tripel"}; |
||
2751 | projectionNameList.add(count,projectionName); |
||
2752 | addProjectionName(count,"Winkel-Tripel");
|
||
2753 | addProjectionName(count,"Winkel Tripel");
|
||
2754 | |||
2755 | String[] parameterName={"central_meridian"}; |
||
2756 | projectionParameterList.add(count,parameterName); |
||
2757 | addProjectionParameter(count,"standard_parallel_1");
|
||
2758 | addProjectionParameter(count,"false_easting");
|
||
2759 | addProjectionParameter(count,"false_northing");
|
||
2760 | |||
2761 | String[] parameterAcronym={"lon_0"}; |
||
2762 | projectionParameterAcronymList.add(count,parameterAcronym); |
||
2763 | addProjectionParameterAcronymList(count,"lat_ts");
|
||
2764 | addProjectionParameterAcronymList(count,"x_0");
|
||
2765 | addProjectionParameterAcronymList(count,"y_0");
|
||
2766 | |||
2767 | String[] parameterDefaultValue={"0.0"}; |
||
2768 | projectionParameterDefaultValueList.add(count,parameterDefaultValue); |
||
2769 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2770 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2771 | addProjectionParameterDefaultValue(count,"0.0");
|
||
2772 | |||
2773 | String[] parameterMaxValue={"360.0"}; |
||
2774 | projectionParameterMaxValueList.add(count,parameterMaxValue); |
||
2775 | addProjectionParameterMaxValue(count,"90.0");
|
||
2776 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2777 | addProjectionParameterMaxValue(count,"100000000.0");
|
||
2778 | |||
2779 | String[] parameterMinValue={"-360.0"}; |
||
2780 | projectionParameterMinValueList.add(count,parameterMinValue); |
||
2781 | addProjectionParameterMinValue(count,"-90.0");
|
||
2782 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2783 | addProjectionParameterMinValue(count,"-100000000.0");
|
||
2784 | |||
2785 | String[] projectionAcronym={"wintri"}; |
||
2786 | projectionAcronymList.add(count,projectionAcronym); |
||
2787 | } |
||
2788 | } |
||
2789 | |||
2790 | public void addProjectionName(int pos,String projectionName) throws CrsException |
||
2791 | { |
||
2792 | if(pos<0||pos>(projectionNameList.size()-1)) |
||
2793 | { |
||
2794 | throw new CrsException(new Exception("Error adding projection name '"+projectionName+"' position out of valid limits.")); |
||
2795 | } |
||
2796 | String[] projectionNames=(String[]) projectionNameList.get(pos); |
||
2797 | String[] newProjectionNames=new String[projectionNames.length+1]; |
||
2798 | for(int i=0;i<projectionNames.length;i++) |
||
2799 | { |
||
2800 | newProjectionNames[i]=projectionNames[i]; |
||
2801 | } |
||
2802 | newProjectionNames[projectionNames.length]=projectionName; |
||
2803 | projectionNameList.remove(pos); |
||
2804 | projectionNameList.add(pos,newProjectionNames); |
||
2805 | } |
||
2806 | |||
2807 | public void addUnitName(int pos,String unitName) throws CrsException |
||
2808 | { |
||
2809 | if(pos<0||pos>(unitNameList.size()-1)) |
||
2810 | { |
||
2811 | throw new CrsException(new Exception("Error adding unit name '"+unitName+"' position out of valid limits.")); |
||
2812 | } |
||
2813 | String[] unitNames=(String[]) unitNameList.get(pos); |
||
2814 | String[] newUnitNames=new String[unitNames.length+1]; |
||
2815 | for(int i=0;i<unitNames.length;i++) |
||
2816 | { |
||
2817 | newUnitNames[i]=unitNames[i]; |
||
2818 | } |
||
2819 | newUnitNames[unitNames.length]=unitName; |
||
2820 | unitNameList.remove(pos); |
||
2821 | unitNameList.add(pos,newUnitNames); |
||
2822 | } |
||
2823 | |||
2824 | public void addProjectionParameterName(int pos,String projectionParameterName) throws CrsException |
||
2825 | { |
||
2826 | if(pos<0||pos>(projectionParameterNameList.size()-1)) |
||
2827 | { |
||
2828 | throw new CrsException(new Exception("Error adding projection parameter name '"+projectionParameterName+"' position out of valid limits.")); |
||
2829 | } |
||
2830 | String[] projectionParameterNames=(String[]) projectionParameterNameList.get(pos); |
||
2831 | String[] newProjectionParameterNames=new String[projectionParameterNames.length+1]; |
||
2832 | for(int i=0;i<projectionParameterNames.length;i++) |
||
2833 | { |
||
2834 | newProjectionParameterNames[i]=projectionParameterNames[i]; |
||
2835 | } |
||
2836 | newProjectionParameterNames[projectionParameterNames.length]=projectionParameterName; |
||
2837 | projectionParameterNameList.remove(pos); |
||
2838 | projectionParameterNameList.add(pos,newProjectionParameterNames); |
||
2839 | } |
||
2840 | |||
2841 | public void addProjectionParameter(int pos,String projectionParameter) throws CrsException |
||
2842 | { |
||
2843 | if(pos<0||pos>(projectionParameterList.size()-1)) |
||
2844 | { |
||
2845 | throw new CrsException(new Exception("Error adding projection parameter '"+projectionParameter+"' position out of valid limits.")); |
||
2846 | } |
||
2847 | String[] projectionParameters=(String[]) projectionParameterList.get(pos); |
||
2848 | String[] newProjectionParameters=new String[projectionParameters.length+1]; |
||
2849 | for(int i=0;i<projectionParameters.length;i++) |
||
2850 | { |
||
2851 | newProjectionParameters[i]=projectionParameters[i]; |
||
2852 | } |
||
2853 | newProjectionParameters[projectionParameters.length]=projectionParameter; |
||
2854 | projectionParameterList.remove(pos); |
||
2855 | projectionParameterList.add(pos,newProjectionParameters); |
||
2856 | } |
||
2857 | |||
2858 | public void addProjectionParameterDefaultValue(int pos,String projectionParameterDefaultValue) throws CrsException |
||
2859 | { |
||
2860 | if(pos<0||pos>(projectionParameterDefaultValueList.size()-1)) |
||
2861 | { |
||
2862 | throw new CrsException(new Exception("Error adding default value to projection parameter '"+projectionParameterDefaultValue+"' position out of valid limits.")); |
||
2863 | } |
||
2864 | String[] projectionParameterDefaultValues=(String[]) projectionParameterDefaultValueList.get(pos); |
||
2865 | String[] newProjectionParameterDefaultValues=new String[projectionParameterDefaultValues.length+1]; |
||
2866 | for(int i=0;i<projectionParameterDefaultValues.length;i++) |
||
2867 | { |
||
2868 | newProjectionParameterDefaultValues[i]=projectionParameterDefaultValues[i]; |
||
2869 | } |
||
2870 | newProjectionParameterDefaultValues[projectionParameterDefaultValues.length]=projectionParameterDefaultValue; |
||
2871 | projectionParameterDefaultValueList.remove(pos); |
||
2872 | projectionParameterDefaultValueList.add(pos,newProjectionParameterDefaultValues); |
||
2873 | } |
||
2874 | |||
2875 | public void addProjectionParameterMaxValue(int pos,String projectionParameterMaxValue) throws CrsException |
||
2876 | { |
||
2877 | if(pos<0||pos>(projectionParameterMaxValueList.size()-1)) |
||
2878 | { |
||
2879 | throw new CrsException(new Exception("Error adding max value to projection parameter '"+projectionParameterMaxValue+"' position out of valid limits.")); |
||
2880 | } |
||
2881 | String[] projectionParameterMaxValues=(String[]) projectionParameterMaxValueList.get(pos); |
||
2882 | String[] newProjectionParameterMaxValues=new String[projectionParameterMaxValues.length+1]; |
||
2883 | for(int i=0;i<projectionParameterMaxValues.length;i++) |
||
2884 | { |
||
2885 | newProjectionParameterMaxValues[i]=projectionParameterMaxValues[i]; |
||
2886 | } |
||
2887 | newProjectionParameterMaxValues[projectionParameterMaxValues.length]=projectionParameterMaxValue; |
||
2888 | projectionParameterMaxValueList.remove(pos); |
||
2889 | projectionParameterMaxValueList.add(pos,newProjectionParameterMaxValues); |
||
2890 | } |
||
2891 | |||
2892 | public void addProjectionParameterMinValue(int pos,String projectionParameterMinValue) throws CrsException |
||
2893 | { |
||
2894 | if(pos<0||pos>(projectionParameterMinValueList.size()-1)) |
||
2895 | { |
||
2896 | throw new CrsException(new Exception("Error adding min value to projection parameter '"+projectionParameterMinValue+"' position out of valid limits.")); |
||
2897 | } |
||
2898 | String[] projectionParameterMinValues=(String[]) projectionParameterMinValueList.get(pos); |
||
2899 | String[] newProjectionParameterMinValues=new String[projectionParameterMinValues.length+1]; |
||
2900 | for(int i=0;i<projectionParameterMinValues.length;i++) |
||
2901 | { |
||
2902 | newProjectionParameterMinValues[i]=projectionParameterMinValues[i]; |
||
2903 | } |
||
2904 | newProjectionParameterMinValues[projectionParameterMinValues.length]=projectionParameterMinValue; |
||
2905 | projectionParameterMinValueList.remove(pos); |
||
2906 | projectionParameterMinValueList.add(pos,newProjectionParameterMinValues); |
||
2907 | } |
||
2908 | |||
2909 | public void addProjectionParameterAcronymList(int pos,String projectionParameterAcronym) throws CrsException |
||
2910 | { |
||
2911 | if(pos<0||pos>(projectionParameterAcronymList.size()-1)) |
||
2912 | { |
||
2913 | throw new CrsException(new Exception("Error adding projection acronym '"+projectionParameterAcronym+"' position out of valid limits.")); |
||
2914 | } |
||
2915 | String[] projectionParameterAcronyms=(String[]) projectionParameterAcronymList.get(pos); |
||
2916 | String[] newProjectionParameterAcronyms=new String[projectionParameterAcronyms.length+1]; |
||
2917 | for(int i=0;i<projectionParameterAcronyms.length;i++) |
||
2918 | { |
||
2919 | newProjectionParameterAcronyms[i]=projectionParameterAcronyms[i]; |
||
2920 | } |
||
2921 | newProjectionParameterAcronyms[projectionParameterAcronyms.length]=projectionParameterAcronym; |
||
2922 | projectionParameterAcronymList.remove(pos); |
||
2923 | projectionParameterAcronymList.add(pos,newProjectionParameterAcronyms); |
||
2924 | } |
||
2925 | |||
2926 | public int findProjection(String projectionName) |
||
2927 | { |
||
2928 | for(int i=0;i<projectionNameList.size();i++) |
||
2929 | { |
||
2930 | String[] projectionNames=(String[]) projectionNameList.get(i); |
||
2931 | for(int j=0;j<projectionNames.length;j++) |
||
2932 | { |
||
2933 | if(projectionNames[j].toLowerCase().replaceAll(" ","").equals(projectionName.toLowerCase().replaceAll(" ",""))) |
||
2934 | return i;
|
||
2935 | } |
||
2936 | } |
||
2937 | |||
2938 | return -1; |
||
2939 | } |
||
2940 | |||
2941 | public int findProjectionParameter(String parameterName) |
||
2942 | { |
||
2943 | for(int i=0;i<projectionParameterNameList.size();i++) |
||
2944 | { |
||
2945 | String[] parameterNames=(String[]) projectionParameterNameList.get(i); |
||
2946 | for(int j=0;j<parameterNames.length;j++) |
||
2947 | { |
||
2948 | if(parameterNames[j].toLowerCase().replaceAll(" ","").equals(parameterName.toLowerCase().replaceAll(" ",""))) |
||
2949 | return i;
|
||
2950 | } |
||
2951 | } |
||
2952 | |||
2953 | return -1; |
||
2954 | } |
||
2955 | |||
2956 | public int findProjectionParameters(String parameterName1, String parameterName2) |
||
2957 | { |
||
2958 | for(int i=0;i<projectionParameterNameList.size();i++) |
||
2959 | { |
||
2960 | boolean existsParameter1=false; |
||
2961 | boolean existsParameter2=false; |
||
2962 | |||
2963 | |||
2964 | String[] parameterNames=(String[]) projectionParameterNameList.get(i); |
||
2965 | if(parameterNames[0].toLowerCase().replaceAll(" ","").equals(parameterName2.toLowerCase().replaceAll(" ",""))) |
||
2966 | { |
||
2967 | existsParameter2=true;
|
||
2968 | for(int j=0;j<parameterNames.length;j++) |
||
2969 | { |
||
2970 | if(parameterNames[j].toLowerCase().replaceAll(" ","").equals(parameterName1.toLowerCase().replaceAll(" ",""))) |
||
2971 | { |
||
2972 | existsParameter1=true;
|
||
2973 | break;
|
||
2974 | } |
||
2975 | } |
||
2976 | } |
||
2977 | if(existsParameter1&&existsParameter2)
|
||
2978 | return i;
|
||
2979 | } |
||
2980 | |||
2981 | return -1; |
||
2982 | } |
||
2983 | |||
2984 | public int findUnit(String unitName) |
||
2985 | { |
||
2986 | for(int i=0;i<unitNameList.size();i++) |
||
2987 | { |
||
2988 | String[] unitNames=(String[]) unitNameList.get(i); |
||
2989 | for(int j=0;j<unitNames.length;j++) |
||
2990 | { |
||
2991 | if(unitNames[j].toLowerCase().replaceAll(" ","").equals(unitName.toLowerCase().replaceAll(" ",""))) |
||
2992 | return i;
|
||
2993 | } |
||
2994 | } |
||
2995 | |||
2996 | return -1; |
||
2997 | } |
||
2998 | |||
2999 | public String getProj4UnitName(int pos) throws CrsException |
||
3000 | { |
||
3001 | if(pos<0||pos>(unitNameList.size()-1)) |
||
3002 | { |
||
3003 | throw new CrsException(new Exception("Error retrieving unit name. Position out of valid limits.")); |
||
3004 | } |
||
3005 | return ((String[]) unitNameList.get(pos))[0]; |
||
3006 | } |
||
3007 | |||
3008 | public String getProj4ProjectionName(int pos) throws CrsException |
||
3009 | { |
||
3010 | if(pos<0||pos>(projectionNameList.size()-1)) |
||
3011 | { |
||
3012 | throw new CrsException(new Exception("Error retrieving projection name. Position out of valid limits.")); |
||
3013 | } |
||
3014 | return ((String[]) projectionNameList.get(pos))[0]; |
||
3015 | } |
||
3016 | |||
3017 | public String getProj4ProjectionParameterName(int pos) throws CrsException |
||
3018 | { |
||
3019 | // Ojo decir a Jose Luis que quite los parametros del elipsoide
|
||
3020 | if(pos<0||pos>(projectionParameterNameList.size()-1)) |
||
3021 | { |
||
3022 | throw new CrsException(new Exception("Error retrieving projection parameter name. Position out of valid limits.")); |
||
3023 | } |
||
3024 | return ((String[]) projectionParameterNameList.get(pos))[0]; |
||
3025 | } |
||
3026 | |||
3027 | public ArrayList getProj4ProjectionParameters(int pos) throws CrsException |
||
3028 | { |
||
3029 | |||
3030 | if(pos<0||pos>(projectionParameterList.size()-1)) |
||
3031 | throw new CrsException(new Exception()); |
||
3032 | String[] parameterList=(String[])projectionParameterList.get(pos); |
||
3033 | ArrayList parameters=new ArrayList(); |
||
3034 | for(int i=0;i<parameterList.length;i++) |
||
3035 | { |
||
3036 | String parameterName=parameterList[i];
|
||
3037 | int posParameter=findProjectionParameter(parameterName);
|
||
3038 | if(posParameter==-1) |
||
3039 | { |
||
3040 | throw new CrsException(new Exception("The parameter '"+parameterName+"' is not in parameter list.")); |
||
3041 | } |
||
3042 | //String parameterNameProj4=getProj4ProjectionParameterName(posParameter);
|
||
3043 | String parameterNameProj4=parameterName;
|
||
3044 | parameters.add(i,parameterNameProj4); |
||
3045 | } |
||
3046 | return parameters;
|
||
3047 | } |
||
3048 | |||
3049 | public ArrayList getProj4ProjectionParameterDefaultValues(int pos) throws CrsException |
||
3050 | { |
||
3051 | |||
3052 | if(pos<0||pos>(projectionParameterDefaultValueList.size()-1)) |
||
3053 | { |
||
3054 | throw new CrsException(new Exception("Error retrieving default value to projection parameter. Position out of valid limits.")); |
||
3055 | } |
||
3056 | String[] parameterDefaultValueList=(String[])projectionParameterDefaultValueList.get(pos); |
||
3057 | ArrayList parameterDefaultValues=new ArrayList(); |
||
3058 | for(int i=0;i<parameterDefaultValueList.length;i++) |
||
3059 | { |
||
3060 | String parameterDefaultValue=parameterDefaultValueList[i];
|
||
3061 | parameterDefaultValues.add(i,parameterDefaultValue); |
||
3062 | } |
||
3063 | return parameterDefaultValues;
|
||
3064 | } |
||
3065 | |||
3066 | public ArrayList getProj4ProjectionParameterMaxValues(int pos) throws CrsException |
||
3067 | { |
||
3068 | |||
3069 | if(pos<0||pos>(projectionParameterMaxValueList.size()-1)) |
||
3070 | { |
||
3071 | throw new CrsException(new Exception("Error retrieving max value value to projection parameter. Position out of valid limits.")); |
||
3072 | } |
||
3073 | String[] parameterMaxValueList=(String[])projectionParameterMaxValueList.get(pos); |
||
3074 | ArrayList parameterMaxValues=new ArrayList(); |
||
3075 | for(int i=0;i<parameterMaxValueList.length;i++) |
||
3076 | { |
||
3077 | String parameterMaxValue=parameterMaxValueList[i];
|
||
3078 | parameterMaxValues.add(i,parameterMaxValue); |
||
3079 | } |
||
3080 | return parameterMaxValues;
|
||
3081 | } |
||
3082 | |||
3083 | public ArrayList getProj4ProjectionParameterMinValues(int pos) throws CrsException |
||
3084 | { |
||
3085 | |||
3086 | if(pos<0||pos>(projectionParameterMinValueList.size()-1)) |
||
3087 | { |
||
3088 | throw new CrsException(new Exception("Error retrieving min value value to projection parameter. Position out of valid limits.")); |
||
3089 | } |
||
3090 | String[] parameterMinValueList=(String[])projectionParameterMinValueList.get(pos); |
||
3091 | ArrayList parameterMinValues=new ArrayList(); |
||
3092 | for(int i=0;i<parameterMinValueList.length;i++) |
||
3093 | { |
||
3094 | String parameterMinValue=parameterMinValueList[i];
|
||
3095 | parameterMinValues.add(i,parameterMinValue); |
||
3096 | } |
||
3097 | return parameterMinValues;
|
||
3098 | } |
||
3099 | |||
3100 | public ArrayList getProj4ProjectionParameterAcronyms(int pos) throws CrsException |
||
3101 | { |
||
3102 | |||
3103 | if(pos<0||pos>(projectionParameterAcronymList.size()-1)) |
||
3104 | { |
||
3105 | throw new CrsException(new Exception("Error retrieving projection acronym. Position out of valid limits.")); |
||
3106 | } |
||
3107 | String[] parameterAcronymList=(String[])projectionParameterAcronymList.get(pos); |
||
3108 | ArrayList parameterAcronyms=new ArrayList(); |
||
3109 | for(int i=0;i<parameterAcronymList.length;i++) |
||
3110 | { |
||
3111 | String parameterAcronym=parameterAcronymList[i];
|
||
3112 | parameterAcronyms.add(i,parameterAcronym); |
||
3113 | } |
||
3114 | return parameterAcronyms;
|
||
3115 | } |
||
3116 | |||
3117 | public String getProjectionParameterUnitList(int pos) throws CrsException { |
||
3118 | if(pos<0||pos>(projectionParameterUnitList.size()-1)) |
||
3119 | { |
||
3120 | throw new CrsException(new Exception("Error obtaining the unit list of projection parameter. Position out of valid limits.")); |
||
3121 | } |
||
3122 | String [] projParamUnit = (String[]) projectionParameterUnitList.get(pos); |
||
3123 | return projParamUnit[0]; |
||
3124 | } |
||
3125 | |||
3126 | public String exportToProj4(Crs crs) throws CrsException |
||
3127 | { |
||
3128 | String strProj4="+proj="; |
||
3129 | String strDatumName=""; |
||
3130 | String strDatumCode=""; |
||
3131 | String strProj4ToMeter=""; |
||
3132 | String strProj4Datum=""; |
||
3133 | String[] primeMeridian=crs.getCrsWkt().getPrimen(); |
||
3134 | String primeMeridianName=primeMeridian[0]; |
||
3135 | double primeMeridianValue=Double.parseDouble(primeMeridian[1]); // -> hacer el cambio de unidades |
||
3136 | String[] strPrimeMeridianProj4=primeMeridianToProj4(primeMeridianName,primeMeridianValue); |
||
3137 | primeMeridianValue=Double.parseDouble(strPrimeMeridianProj4[1]); |
||
3138 | primeMeridianName=strPrimeMeridianProj4[0];
|
||
3139 | String primeMeridianAcronym=strPrimeMeridianProj4[2]; // Puede ser cadena vacia->Analizar |
||
3140 | |||
3141 | // Extracci?n del c?digo de Datum
|
||
3142 | String codDatum="0"; |
||
3143 | strDatumName=crs.getCrsWkt().getDatumName(); |
||
3144 | int intCodDatum=0;//Integer.parseInt(codDatum); |
||
3145 | strProj4Datum=datumToProj4(strDatumName,intCodDatum); |
||
3146 | |||
3147 | |||
3148 | |||
3149 | String strProj=crs.getCrsWkt().getProjcs();
|
||
3150 | if(strProj.equals("")) |
||
3151 | { |
||
3152 | //System.out.println("Projection Name = "+"Geodetic");
|
||
3153 | strProj4+="longlat ";
|
||
3154 | } |
||
3155 | else
|
||
3156 | { |
||
3157 | // OJO ******************************************
|
||
3158 | /*
|
||
3159 | if(factor_to_meter!=1.0)
|
||
3160 | strProj4ToMeter="+to_meter="+factor_to_meter+" ";
|
||
3161 | else
|
||
3162 | strProj4ToMeter="+units=m ";
|
||
3163 | */
|
||
3164 | |||
3165 | |||
3166 | //System.out.println("Projection = "+strProj);
|
||
3167 | String strProjName=crs.getCrsWkt().getProjection();
|
||
3168 | //System.out.println("Projection Name = "+strProjName);
|
||
3169 | int indexProj=findProjection(strProjName);
|
||
3170 | if(indexProj==-1) |
||
3171 | { |
||
3172 | throw new CrsException(new Exception("The projection'"+strProjName+"' is not a proj4 projection.")); |
||
3173 | } |
||
3174 | String projectionName=(getProj4ProjectionName(indexProj)).trim();
|
||
3175 | ArrayList parameterNames=getProj4ProjectionParameters(indexProj);
|
||
3176 | ArrayList parameterAcronyms=getProj4ProjectionParameterAcronyms(indexProj);
|
||
3177 | ArrayList parameterValues=getProj4ProjectionParameterDefaultValues(indexProj);
|
||
3178 | ArrayList parameterMaxValues=getProj4ProjectionParameterMaxValues(indexProj);
|
||
3179 | ArrayList parameterMinValues=getProj4ProjectionParameterMinValues(indexProj);
|
||
3180 | //System.out.println("Parametros:"+parameterNames);
|
||
3181 | String[] gtParameterValues=crs.getCrsWkt().getParam_value(); |
||
3182 | String[] gtParameterNames=crs.getCrsWkt().getParam_name(); |
||
3183 | for(int i=0;i<parameterNames.size();i++) |
||
3184 | { |
||
3185 | boolean existsParameter=false; |
||
3186 | String parameterValue=""; |
||
3187 | for(int j=0;j<gtParameterNames.length;j++) |
||
3188 | { |
||
3189 | String gtParameterName=gtParameterNames[j].trim();
|
||
3190 | //int posGtParameter=findProjectionParameter(gtParameterName);
|
||
3191 | int posGtParameter=findProjectionParameters(gtParameterName,(String)parameterNames.get(i)); |
||
3192 | //int posParameter=findProjectionParameter((String)parameterNames.get(i));
|
||
3193 | //if(((String)parameterNames.get(i)).trim().equals(gtParameterNames[j].trim()))
|
||
3194 | if(posGtParameter!=-1) |
||
3195 | { |
||
3196 | gtParameterName=getProj4ProjectionParameterName(posGtParameter); |
||
3197 | gtParameterNames[j]=gtParameterName; |
||
3198 | existsParameter=true;
|
||
3199 | double maxValue=Double.parseDouble((String)parameterMaxValues.get(i)); |
||
3200 | double minValue=Double.parseDouble((String)parameterMinValues.get(i)); |
||
3201 | //parameterValue=Double.parseDouble(gtParameterValues[j]);
|
||
3202 | parameterValue=gtParameterValues[j]; // Ojo unidades -> analizar
|
||
3203 | double auxValue=Double.parseDouble(parameterValue); |
||
3204 | if((auxValue<minValue)||(auxValue>maxValue))
|
||
3205 | { |
||
3206 | throw new CrsException(new Exception("The parameter '"+gtParameterName+"' is out of domain.")); |
||
3207 | } |
||
3208 | else if (((String)parameterNames.get(i)).trim().equals("scale_factor") && (auxValue==minValue)) { |
||
3209 | throw new CrsException(new Exception("The parameter '"+gtParameterName+"' is out of domain.")); |
||
3210 | } |
||
3211 | break;
|
||
3212 | } |
||
3213 | /*else
|
||
3214 | {
|
||
3215 | String strError="El parametro recibido de GeoTools";
|
||
3216 | strError+=gtParameterName;
|
||
3217 | strError+=" no esta contemplado en la proyeccion";
|
||
3218 | System.out.println(strError);
|
||
3219 | throw new CrsException(new Exception());
|
||
3220 | }*/
|
||
3221 | } |
||
3222 | if(existsParameter)
|
||
3223 | { |
||
3224 | parameterValues.set(i,parameterValue); |
||
3225 | //System.out.println("- Parametro["+parameterNames.get(i)+"]="+parameterValue);
|
||
3226 | } |
||
3227 | /*
|
||
3228 | else
|
||
3229 | {
|
||
3230 | value=Double.parseDouble((String)parameterDefaultValues.get(i));
|
||
3231 | System.out.println("El parametro "+parameterNames.get(i)+" no figura en la lista geotools");
|
||
3232 | throw(new CrsException(new Exception()));
|
||
3233 | }
|
||
3234 | */
|
||
3235 | } |
||
3236 | boolean isSomerc=false; |
||
3237 | boolean isOmerc=false; |
||
3238 | double valueAlpha=0; |
||
3239 | double valueGamma=0; |
||
3240 | boolean existsAlpha=false; |
||
3241 | boolean existsGamma=false; |
||
3242 | String[] projectionAcronym=(String[])projectionAcronymList.get(indexProj); |
||
3243 | if(projectionName.equals("Oblique_Mercator")) |
||
3244 | { |
||
3245 | isOmerc=true;
|
||
3246 | for(int j=0;j<gtParameterNames.length;j++) |
||
3247 | { |
||
3248 | String gtParameterName=gtParameterNames[j].trim();
|
||
3249 | if(gtParameterName.equalsIgnoreCase("latitude_of_origin") |
||
3250 | ||gtParameterName.equalsIgnoreCase("standard_parallel_1")
|
||
3251 | ||gtParameterName.equalsIgnoreCase("latitude_of_center"))
|
||
3252 | { |
||
3253 | double value=Double.parseDouble(gtParameterValues[j]); |
||
3254 | if(Math.abs(Math.abs(value)-90.0)<0.0001) |
||
3255 | { |
||
3256 | throw new CrsException(new Exception("In proj4 projection 'Oblique_Mercator' not allow latitude origen close to the poles")); |
||
3257 | } |
||
3258 | } |
||
3259 | if(gtParameterName.equalsIgnoreCase("azimuth")) |
||
3260 | { |
||
3261 | valueAlpha=Double.parseDouble(gtParameterValues[j]);
|
||
3262 | if(Math.abs(valueAlpha-90.0)<0.0001) |
||
3263 | { |
||
3264 | throw new CrsException(new Exception("In proj4 projection 'Oblique_Mercator' not allow azimut close to 90")); |
||
3265 | } |
||
3266 | if(Math.abs(valueAlpha-270.0)<0.0001) |
||
3267 | { |
||
3268 | throw new CrsException(new Exception("In proj4 projection 'Oblique_Mercator' not allow azimut close to 270")); |
||
3269 | } |
||
3270 | existsAlpha=true;
|
||
3271 | } |
||
3272 | if(gtParameterName.equalsIgnoreCase("rectified_grid_angle")) |
||
3273 | { |
||
3274 | valueGamma=Double.parseDouble(gtParameterValues[j]);
|
||
3275 | existsGamma=true;
|
||
3276 | } |
||
3277 | } |
||
3278 | if(existsAlpha&&existsGamma)
|
||
3279 | { |
||
3280 | if(Math.abs(valueAlpha-valueGamma)>0.00000001) |
||
3281 | { |
||
3282 | throw new CrsException(new Exception("In proj4 projection 'Oblique_Mercator' not allow diferent azimut and spin axis")); |
||
3283 | } |
||
3284 | } |
||
3285 | |||
3286 | // Necesito buscar un caso de ejemplo
|
||
3287 | } |
||
3288 | if(projectionName.equals("Hotine_Oblique_Mercator_Two_Point_Center")) |
||
3289 | { |
||
3290 | double lat_1=0.0; |
||
3291 | double lat_2=0.0; |
||
3292 | boolean exists_Lat_1=false; |
||
3293 | boolean exists_Lat_2=false; |
||
3294 | for(int j=0;j<gtParameterNames.length;j++) |
||
3295 | { |
||
3296 | String gtParameterName=gtParameterNames[j].trim();
|
||
3297 | if(gtParameterName.equalsIgnoreCase("Latitude_Of_1st_Point")) |
||
3298 | { |
||
3299 | lat_1=Double.parseDouble(gtParameterValues[j]);
|
||
3300 | exists_Lat_1=true;
|
||
3301 | } |
||
3302 | if(gtParameterName.equalsIgnoreCase("Latitude_Of_2nd_Point")) |
||
3303 | { |
||
3304 | lat_2=Double.parseDouble(gtParameterValues[j]);
|
||
3305 | exists_Lat_2= true;
|
||
3306 | } |
||
3307 | } |
||
3308 | if(exists_Lat_1&&exists_Lat_2)
|
||
3309 | { |
||
3310 | if(Math.abs(lat_1-lat_2)<0.0001) |
||
3311 | { |
||
3312 | throw new CrsException(new Exception("In proj4 projection 'Hotine-Oblique Mercator Two Points' not allow lat_1 equals lat_2")); |
||
3313 | } |
||
3314 | if(Math.abs(lat_1)<0.0001) |
||
3315 | { |
||
3316 | throw new CrsException(new Exception("In proj4 projection 'Hotine-Oblique Mercator Two Points' not allow zero in lat_2")); |
||
3317 | } |
||
3318 | if(Math.abs(Math.abs(lat_2)-90)<0.0001) |
||
3319 | { |
||
3320 | throw new CrsException(new Exception("In proj4 projection 'Hotine-Oblique Mercator Two Points' not allow values 90 or minus 90 in lat_2")); |
||
3321 | } |
||
3322 | } |
||
3323 | } |
||
3324 | String strProjectionAcronym=projectionAcronym[0]; |
||
3325 | String strExtraProj4=""; |
||
3326 | // Control de casos especiales
|
||
3327 | boolean isLaborde=false; |
||
3328 | boolean isLcc1sp=false; |
||
3329 | boolean isMerc=false; |
||
3330 | boolean exists_sf=false; |
||
3331 | boolean exists_lo=false; |
||
3332 | boolean isSterePolar=false; |
||
3333 | boolean isStereOblique=false; // pondremos +proj=sterea |
||
3334 | boolean exists_stdPar=false; |
||
3335 | double value_stdPar=0.0; |
||
3336 | if(projectionAcronym[0].equals("merc")) // 1 - Mercator |
||
3337 | { |
||
3338 | isMerc=true;
|
||
3339 | double value_sf=0.0; |
||
3340 | double value_lo=0.0; |
||
3341 | for(int j=0;j<gtParameterNames.length;j++) |
||
3342 | { |
||
3343 | String gtParameterName=gtParameterNames[j].trim();
|
||
3344 | if(gtParameterName.equalsIgnoreCase("latitude_of_origin") |
||
3345 | ||gtParameterName.equalsIgnoreCase("standard_parallel_1")
|
||
3346 | ||gtParameterName.equalsIgnoreCase("latitude_of_center"))
|
||
3347 | { |
||
3348 | exists_lo=true;
|
||
3349 | value_lo=Double.parseDouble(gtParameterValues[j]);
|
||
3350 | } |
||
3351 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
3352 | { |
||
3353 | exists_sf=true;
|
||
3354 | value_sf=Double.parseDouble(gtParameterValues[j]);
|
||
3355 | } |
||
3356 | } |
||
3357 | if(exists_sf&&exists_lo)
|
||
3358 | { |
||
3359 | if(value_sf!=1.0&&value_lo!=0.0) |
||
3360 | { |
||
3361 | throw new CrsException(new Exception("In proj4 projection Mercator not allow scale factor and latitude of origin")); |
||
3362 | } |
||
3363 | else if(projectionName.equals("Mercator_1SP")) |
||
3364 | exists_lo=false;
|
||
3365 | else if(projectionName.equals("Mercator_2SP")) |
||
3366 | exists_sf=false;
|
||
3367 | /*
|
||
3368 | else if(value_sf!=1.0)
|
||
3369 | exists_lo=false;
|
||
3370 | else if(value_sf==1.0)
|
||
3371 | exists_sf=false;
|
||
3372 | */
|
||
3373 | } |
||
3374 | } |
||
3375 | else if(projectionAcronym[0].equals("lcc")) |
||
3376 | { |
||
3377 | if(projectionName.equalsIgnoreCase("Lambert_Conformal_Conic_1SP")) |
||
3378 | { |
||
3379 | isLcc1sp=true;
|
||
3380 | } |
||
3381 | } |
||
3382 | else if(projectionAcronym[0].equals("stere")) |
||
3383 | { |
||
3384 | if(projectionName.equalsIgnoreCase("Polar_Stereographic")) // lat_ts=lat_0={90 o -90) |
||
3385 | { |
||
3386 | isSterePolar=true;
|
||
3387 | for(int j=0;j<gtParameterNames.length;j++) |
||
3388 | { |
||
3389 | String gtParameterName=gtParameterNames[j].trim();
|
||
3390 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
3391 | { |
||
3392 | double value_sf=Double.parseDouble(gtParameterValues[j]); |
||
3393 | exists_sf=true;
|
||
3394 | //if(Math.abs(value_sf-1.0)>0.000001)
|
||
3395 | // exists_sf=true;
|
||
3396 | } |
||
3397 | if(gtParameterName.equalsIgnoreCase("latitude_of_standard_parallel")) |
||
3398 | { |
||
3399 | value_stdPar=Double.parseDouble(gtParameterValues[j]);
|
||
3400 | exists_stdPar=true;
|
||
3401 | } |
||
3402 | } |
||
3403 | } |
||
3404 | if(projectionName.equalsIgnoreCase("Stereographic")) // No admite lat_ts |
||
3405 | { |
||
3406 | // Comprobamos si es polar
|
||
3407 | boolean isPolar=false; |
||
3408 | for(int j=0;j<gtParameterNames.length;j++) |
||
3409 | { |
||
3410 | String gtParameterAcronymn=((String)parameterAcronyms.get(j)).trim(); |
||
3411 | if(gtParameterNames[j].equalsIgnoreCase("latitude_of_origin")) |
||
3412 | //if(gtParameterAcronymn.equalsIgnoreCase("lat_0"))
|
||
3413 | { |
||
3414 | double gtParameterValue=Double.parseDouble(gtParameterValues[j]); |
||
3415 | if(Math.abs(gtParameterValue-90.0)<angularTolerance) isPolar=true; |
||
3416 | else if(Math.abs(gtParameterValue-(-90.0))<angularTolerance) isPolar=true; |
||
3417 | break;
|
||
3418 | } |
||
3419 | } |
||
3420 | if(isPolar)
|
||
3421 | { |
||
3422 | isSterePolar=true;
|
||
3423 | strProjectionAcronym="stere";
|
||
3424 | for(int j=0;j<gtParameterNames.length;j++) |
||
3425 | { |
||
3426 | String gtParameterName=gtParameterNames[j].trim();
|
||
3427 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
3428 | { |
||
3429 | double value_sf=Double.parseDouble(gtParameterValues[j]); |
||
3430 | exists_sf=true;
|
||
3431 | //if(Math.abs(value_sf-1.0)>0.000001)
|
||
3432 | // exists_sf=true;
|
||
3433 | } |
||
3434 | if(gtParameterName.equalsIgnoreCase("latitude_of_standard_parallel")) |
||
3435 | { |
||
3436 | value_stdPar=Double.parseDouble(gtParameterValues[j]);
|
||
3437 | exists_stdPar=true;
|
||
3438 | } |
||
3439 | } |
||
3440 | } |
||
3441 | if(!isPolar)
|
||
3442 | { |
||
3443 | isStereOblique=true;
|
||
3444 | if(exists_stdPar)
|
||
3445 | { |
||
3446 | throw new CrsException(new Exception("In proj4 projection Oblique Stereographic does not allow parameter latitude of standard parallel.")); |
||
3447 | } |
||
3448 | strProjectionAcronym="sterea";
|
||
3449 | } |
||
3450 | } |
||
3451 | } |
||
3452 | else if(projectionAcronym[0].equals("omerc")) |
||
3453 | { |
||
3454 | boolean existsLat1=false; |
||
3455 | boolean existsLat2=false; |
||
3456 | boolean existsLon1=false; |
||
3457 | boolean existsLon2=false; |
||
3458 | // Necesito buscar un caso de ejemplo
|
||
3459 | } |
||
3460 | else if(projectionAcronym[0].equals("mill")) |
||
3461 | { |
||
3462 | strExtraProj4="+R_A ";
|
||
3463 | } |
||
3464 | else if(projectionAcronym[0].equals("vandg")) |
||
3465 | { |
||
3466 | strExtraProj4="+R_A ";
|
||
3467 | } |
||
3468 | else if(projectionAcronym[0].equals("labrd")) |
||
3469 | { |
||
3470 | isLaborde=true;
|
||
3471 | } |
||
3472 | |||
3473 | strProj4=strProj4+strProjectionAcronym+" ";
|
||
3474 | |||
3475 | for(int i=0;i<parameterNames.size();i++) |
||
3476 | { |
||
3477 | boolean control=true; |
||
3478 | String parameterName=((String)parameterNames.get(i)).trim(); |
||
3479 | String parameterAcronym=((String)parameterAcronyms.get(i)).trim(); |
||
3480 | String strParameterValue=((String)parameterValues.get(i)).trim(); |
||
3481 | if(isMerc)
|
||
3482 | { |
||
3483 | if(parameterName.equalsIgnoreCase("latitude_of_origin") |
||
3484 | ||parameterName.equalsIgnoreCase("standard_parallel_1")
|
||
3485 | ||parameterName.equalsIgnoreCase("latitude_of_center"))
|
||
3486 | { |
||
3487 | if(!exists_lo)
|
||
3488 | control=false;
|
||
3489 | } |
||
3490 | if(parameterName.equalsIgnoreCase("scale_factor")) |
||
3491 | { |
||
3492 | if(!exists_sf)
|
||
3493 | control=false;
|
||
3494 | } |
||
3495 | } |
||
3496 | if(isSterePolar)
|
||
3497 | { |
||
3498 | String gtParameterAcronymn=((String)parameterAcronyms.get(i)).trim(); |
||
3499 | if(gtParameterAcronymn.equalsIgnoreCase("lat_0")) // Esto resuelve el caso del EPSG:3031 |
||
3500 | { |
||
3501 | if(exists_stdPar){
|
||
3502 | double parameterValue=Double.parseDouble(strParameterValue); |
||
3503 | if((parameterValue>0)&&(value_stdPar<0)){ |
||
3504 | strParameterValue="-90.0";
|
||
3505 | } |
||
3506 | if((parameterValue<0)&&(value_stdPar>0)){ |
||
3507 | strParameterValue="90.0";
|
||
3508 | } |
||
3509 | } |
||
3510 | } |
||
3511 | |||
3512 | if(gtParameterAcronymn.equalsIgnoreCase("lat_ts")) |
||
3513 | { |
||
3514 | if(exists_sf)
|
||
3515 | control=false;
|
||
3516 | } |
||
3517 | if(parameterName.equalsIgnoreCase("scale_factor")) |
||
3518 | { |
||
3519 | if(!exists_sf)
|
||
3520 | control=false;
|
||
3521 | } |
||
3522 | } |
||
3523 | if(isSomerc)
|
||
3524 | { |
||
3525 | if(parameterName.equals("rectified_grid_angle")) |
||
3526 | control=false;
|
||
3527 | if(parameterName.equals("azimuth")) |
||
3528 | control=false;
|
||
3529 | } |
||
3530 | if(isOmerc)
|
||
3531 | { |
||
3532 | if(parameterName.equals("rectified_grid_angle")) |
||
3533 | { |
||
3534 | if(existsAlpha)
|
||
3535 | control=false;
|
||
3536 | else
|
||
3537 | parameterAcronym="alpha";
|
||
3538 | } |
||
3539 | } |
||
3540 | if(parameterAcronym.equals("lon_0") |
||
3541 | ||parameterAcronym.equals("lonc"))
|
||
3542 | { |
||
3543 | double parameterValue=Double.parseDouble(strParameterValue); |
||
3544 | if(!projectionAcronym[0].equalsIgnoreCase("krovak")) |
||
3545 | { |
||
3546 | parameterValue=parameterValue-primeMeridianValue; |
||
3547 | } |
||
3548 | strParameterValue=Double.toString(parameterValue);
|
||
3549 | } |
||
3550 | if(control)
|
||
3551 | strProj4=strProj4+"+"+parameterAcronym+"="+strParameterValue+" "; |
||
3552 | if(isLcc1sp)
|
||
3553 | { |
||
3554 | if(parameterAcronym.equals("lat_0")) |
||
3555 | { |
||
3556 | strProj4=strProj4+"+lat_1="+strParameterValue+" "; |
||
3557 | strProj4=strProj4+"+lat_2="+strParameterValue+" "; |
||
3558 | } |
||
3559 | } |
||
3560 | } |
||
3561 | if(isLaborde)
|
||
3562 | strProj4+="+azi=18.9 +lat_0=-18.9 +lon_0=44.1 +k_0=0.9995 +x_0=400000 +y_0=800000 +ellps=intl ";
|
||
3563 | strProj4+=strExtraProj4; |
||
3564 | //getProj4ProjectionName();
|
||
3565 | } |
||
3566 | |||
3567 | // Que pasa si no hay elipsoide? -> OGR por defecto pone WGS84
|
||
3568 | double a=0; |
||
3569 | double inv_f=0; |
||
3570 | String elipName=crs.getCrsWkt().getSpheroid()[0]; |
||
3571 | a=Double.parseDouble(crs.getCrsWkt().getSpheroid()[1]); |
||
3572 | inv_f=Double.parseDouble(crs.getCrsWkt().getSpheroid()[2]); |
||
3573 | String strEllipseAcronym=ellipseToProj4(a,inv_f);
|
||
3574 | String strEllipse=""; |
||
3575 | if(strEllipseAcronym.equals("")) |
||
3576 | { |
||
3577 | if (!Double.isInfinite(inv_f)) |
||
3578 | { |
||
3579 | if(inv_f>0.0) |
||
3580 | strEllipse="+a="+a+" +rf="+inv_f+" "; |
||
3581 | else
|
||
3582 | strEllipse="+R="+a+" "; |
||
3583 | } |
||
3584 | else
|
||
3585 | strEllipse="+R="+a+" "; |
||
3586 | } |
||
3587 | else
|
||
3588 | { |
||
3589 | strEllipse="+ellps="+strEllipseAcronym+" "; |
||
3590 | } |
||
3591 | strProj4+=strEllipse; |
||
3592 | //System.out.println("Elipsoide["+elipName+"]=("+a+","+inv_f+")");
|
||
3593 | if(!strProj4Datum.equals("")) |
||
3594 | { |
||
3595 | strProj4+=strProj4Datum; |
||
3596 | } |
||
3597 | strProj4+=primeMeridianAcronym; |
||
3598 | String strWkt=crs.getWKT();
|
||
3599 | if(!strProj4ToMeter.equals("")) |
||
3600 | strProj4+=strProj4ToMeter; |
||
3601 | |||
3602 | //System.out.println("- Cadena proj4: "+strProj4);
|
||
3603 | return strProj4;
|
||
3604 | } |
||
3605 | |||
3606 | public String exportToProj4(CoordinateReferenceSystem crs) throws CrsException |
||
3607 | { |
||
3608 | String strProj4="+proj="; |
||
3609 | String[] primeMeridian = new String[2]; |
||
3610 | String strProj=""; |
||
3611 | String strProjName=""; |
||
3612 | String strDatumName=""; |
||
3613 | String strDatumCode=""; |
||
3614 | String strProj4Datum=""; |
||
3615 | String strProj4ToMeter=""; |
||
3616 | String[] gtParameterValues=new String[1]; |
||
3617 | String[] gtParameterNames= new String[1]; |
||
3618 | String[] spheroid = new String[3]; |
||
3619 | double a=0; |
||
3620 | double inv_f=0; |
||
3621 | String elipName=""; |
||
3622 | if (crs instanceof DefaultProjectedCRS) { |
||
3623 | DefaultProjectedCRS crsProjected = (DefaultProjectedCRS) crs; |
||
3624 | primeMeridian = Primem(((DefaultGeodeticDatum) crsProjected.getDatum()).getPrimeMeridian()); |
||
3625 | String[] proj = crsProjected.getName().toString().split(":"); |
||
3626 | if (proj.length>1) |
||
3627 | strProj = proj[1];
|
||
3628 | else
|
||
3629 | strProj = proj[0];
|
||
3630 | strProjName = getName(crsProjected.getConversionFromBase().getMethod().getName()); |
||
3631 | gtParameterValues = new String[crsProjected.getConversionFromBase().getParameterValues().values().size()]; |
||
3632 | gtParameterNames = new String[crsProjected.getConversionFromBase().getParameterValues().values().size()]; |
||
3633 | String str;
|
||
3634 | for (int i=0; i< crsProjected.getConversionFromBase().getParameterValues().values().size();i++) { |
||
3635 | str = crsProjected.getConversionFromBase().getParameterValues().values().get(i).toString(); |
||
3636 | Unit u = crsProjected.getConversionFromBase().getParameterValues().parameter(str.split("=")[0]).getUnit(); |
||
3637 | double value = crsProjected.getConversionFromBase().getParameterValues().parameter(str.split("=")[0]).doubleValue(); |
||
3638 | value = convert(value, u.toString()); |
||
3639 | gtParameterNames[i] = str.split("=")[0]; |
||
3640 | gtParameterValues [i] = String.valueOf(value);
|
||
3641 | } |
||
3642 | spheroid = Spheroid(((DefaultGeodeticDatum) crsProjected.getDatum()).getEllipsoid()); |
||
3643 | elipName=spheroid[0];
|
||
3644 | a=Double.parseDouble(spheroid[1]); |
||
3645 | inv_f=Double.parseDouble(spheroid[2]); |
||
3646 | Ellipsoid ellip = ((DefaultGeodeticDatum) crsProjected.getDatum()).getEllipsoid(); |
||
3647 | Unit unit = ellip.getAxisUnit(); |
||
3648 | String[] i_un = unit.toString().split("[*]"); |
||
3649 | if (i_un.length>1) |
||
3650 | { |
||
3651 | try{
|
||
3652 | a=a*Double.parseDouble(i_un[1].replaceAll("]", "")); |
||
3653 | //factor_to_meter=Double.parseDouble(un[1].replaceAll("]", ""));
|
||
3654 | } |
||
3655 | catch(java.lang.NumberFormatException t){}
|
||
3656 | } |
||
3657 | else if (i_un[0].equals("m")) |
||
3658 | { |
||
3659 | try{
|
||
3660 | //factor_to_meter=Double.parseDouble(un[0]);
|
||
3661 | } |
||
3662 | catch(java.lang.NumberFormatException t){}
|
||
3663 | } else if (i_un[0].equals("ft")) { |
||
3664 | /**
|
||
3665 | * Cuando viene en otro formato, coger el valor de la unidad
|
||
3666 | * correspondiente...
|
||
3667 | */
|
||
3668 | //Caso de los pies
|
||
3669 | //factor_to_meter = 0.3048;
|
||
3670 | } |
||
3671 | // Extracci?n del c?digo de Datum
|
||
3672 | String codDatum="0"; |
||
3673 | String[] val=((DefaultProjectedCRS)crs).getDatum().getName().toString().split(":"); |
||
3674 | if (val.length<2) |
||
3675 | strDatumName=val[0];
|
||
3676 | else
|
||
3677 | strDatumName=val[1];
|
||
3678 | for (Iterator iter =((DefaultProjectedCRS)crs).getDatum().getIdentifiers().iterator();iter.hasNext();) { |
||
3679 | Identifier element = (Identifier) iter.next(); |
||
3680 | codDatum = element.getCode(); |
||
3681 | } |
||
3682 | int intCodDatum=Integer.parseInt(codDatum); |
||
3683 | strProj4Datum=datumToProj4(strDatumName,intCodDatum); |
||
3684 | double factor_to_meter=1.0; |
||
3685 | Unit u = crs.getCoordinateSystem().getAxis(0).getUnit();
|
||
3686 | String[] un = u.toString().split("[*]"); |
||
3687 | if (un.length>1) |
||
3688 | { |
||
3689 | try{
|
||
3690 | factor_to_meter=Double.parseDouble(un[1].replaceAll("]", "")); |
||
3691 | } |
||
3692 | catch(java.lang.NumberFormatException t){}
|
||
3693 | } |
||
3694 | else if (un[0].equals("m")) |
||
3695 | { |
||
3696 | try{
|
||
3697 | factor_to_meter=Double.parseDouble(un[0]); |
||
3698 | } |
||
3699 | catch(java.lang.NumberFormatException t){}
|
||
3700 | } else if (un[0].equals("ft")) { |
||
3701 | /**
|
||
3702 | * Cuando viene en otro formato, coger el valor de la unidad
|
||
3703 | * correspondiente...
|
||
3704 | */
|
||
3705 | //Caso de los pies
|
||
3706 | factor_to_meter = 0.3048;
|
||
3707 | } |
||
3708 | if(factor_to_meter!=1.0) |
||
3709 | strProj4ToMeter="+to_meter="+factor_to_meter+" "; |
||
3710 | else
|
||
3711 | strProj4ToMeter="+units=m ";
|
||
3712 | |||
3713 | } |
||
3714 | else if (crs instanceof DefaultGeographicCRS) { |
||
3715 | DefaultGeographicCRS crsGeographic = (DefaultGeographicCRS) crs; |
||
3716 | primeMeridian = Primem(((DefaultGeodeticDatum) crsGeographic.getDatum()).getPrimeMeridian()); |
||
3717 | spheroid = Spheroid(((DefaultGeodeticDatum) crsGeographic.getDatum()).getEllipsoid()); |
||
3718 | elipName=spheroid[0];
|
||
3719 | a=Double.parseDouble(spheroid[1]); |
||
3720 | inv_f=Double.parseDouble(spheroid[2]); |
||
3721 | Ellipsoid ellip = ((DefaultGeodeticDatum) crsGeographic.getDatum()).getEllipsoid(); |
||
3722 | Unit unit = ellip.getAxisUnit(); |
||
3723 | String[] i_un = unit.toString().split("[*]"); |
||
3724 | if (i_un.length>1) |
||
3725 | { |
||
3726 | try{
|
||
3727 | a=a*Double.parseDouble(i_un[1].replaceAll("]", "")); |
||
3728 | //factor_to_meter=Double.parseDouble(un[1].replaceAll("]", ""));
|
||
3729 | } |
||
3730 | catch(java.lang.NumberFormatException t){}
|
||
3731 | } |
||
3732 | else if (i_un[0].equals("m")) |
||
3733 | { |
||
3734 | try{
|
||
3735 | //factor_to_meter=Double.parseDouble(un[0]);
|
||
3736 | } |
||
3737 | catch(java.lang.NumberFormatException t){}
|
||
3738 | } else if (i_un[0].equals("ft")) { |
||
3739 | /**
|
||
3740 | * Cuando viene en otro formato, coger el valor de la unidad
|
||
3741 | * correspondiente...
|
||
3742 | */
|
||
3743 | //Caso de los pies
|
||
3744 | //factor_to_meter = 0.3048;
|
||
3745 | } |
||
3746 | |||
3747 | // Extracci?n del c?digo de Datum
|
||
3748 | String codDatum="0"; |
||
3749 | String[] val=((DefaultGeographicCRS)crs).getDatum().getName().toString().split(":"); |
||
3750 | if (val.length<2) |
||
3751 | strDatumName=val[0];
|
||
3752 | else
|
||
3753 | strDatumName=val[1];
|
||
3754 | for (Iterator iter =((DefaultGeographicCRS)crs).getDatum().getIdentifiers().iterator();iter.hasNext();) { |
||
3755 | Identifier element = (Identifier) iter.next(); |
||
3756 | codDatum = element.getCode(); |
||
3757 | } |
||
3758 | int intCodDatum=Integer.parseInt(codDatum); |
||
3759 | strProj4Datum=datumToProj4(strDatumName,intCodDatum); |
||
3760 | } |
||
3761 | else {
|
||
3762 | throw(new CrsException(new Exception("the crs is not a geographic nor projected CRS"))); |
||
3763 | } |
||
3764 | |||
3765 | String primeMeridianName=primeMeridian[0]; |
||
3766 | double primeMeridianValue = -1; |
||
3767 | if (primeMeridian[1] == null) { |
||
3768 | throw(new CrsException(new Exception("Null value not allowed for prime meridiam parameters"))); |
||
3769 | } else {
|
||
3770 | primeMeridianValue=Double.parseDouble(primeMeridian[1]); // -> hacer el cambio de unidades |
||
3771 | } |
||
3772 | String[] strPrimeMeridianProj4=primeMeridianToProj4(primeMeridianName,primeMeridianValue); |
||
3773 | primeMeridianValue=Double.parseDouble(strPrimeMeridianProj4[1]); |
||
3774 | primeMeridianName=strPrimeMeridianProj4[0];
|
||
3775 | String primeMeridianAcronym=strPrimeMeridianProj4[2]; // Puede ser cadena vacia->Analizar |
||
3776 | |||
3777 | if(strProj.equals("")) |
||
3778 | { |
||
3779 | //System.out.println("Projection Name = "+"Geodetic");
|
||
3780 | strProj4+="longlat ";
|
||
3781 | } |
||
3782 | else
|
||
3783 | { |
||
3784 | int indexProj=findProjection(strProjName);
|
||
3785 | if(indexProj==-1) { |
||
3786 | throw(new CrsException(new Exception("The projection '"+strProjName+"' not in proj4."))); |
||
3787 | } |
||
3788 | String projectionName=(getProj4ProjectionName(indexProj)).trim();
|
||
3789 | ArrayList parameterNames=getProj4ProjectionParameters(indexProj);
|
||
3790 | ArrayList parameterAcronyms=getProj4ProjectionParameterAcronyms(indexProj);
|
||
3791 | ArrayList parameterValues=getProj4ProjectionParameterDefaultValues(indexProj);
|
||
3792 | ArrayList parameterMaxValues=getProj4ProjectionParameterMaxValues(indexProj);
|
||
3793 | ArrayList parameterMinValues=getProj4ProjectionParameterMinValues(indexProj);
|
||
3794 | for(int i=0;i<parameterNames.size();i++) |
||
3795 | { |
||
3796 | boolean existsParameter=false; |
||
3797 | String parameterValue=""; |
||
3798 | for(int j=0;j<gtParameterNames.length;j++) |
||
3799 | { |
||
3800 | String gtParameterName=gtParameterNames[j].trim();
|
||
3801 | //System.out.println( gtParameterName);
|
||
3802 | //int posGtParameter=findProjectionParameter(gtParameterName);
|
||
3803 | int posGtParameter=findProjectionParameters(gtParameterName,(String)parameterNames.get(i)); |
||
3804 | //int posParameter=findProjectionParameter((String)parameterNames.get(i));
|
||
3805 | //if(((String)parameterNames.get(i)).trim().equals(gtParameterNames[j].trim()))
|
||
3806 | if(posGtParameter!=-1) |
||
3807 | { |
||
3808 | gtParameterName=getProj4ProjectionParameterName(posGtParameter); |
||
3809 | gtParameterNames[j]=gtParameterName; |
||
3810 | existsParameter=true;
|
||
3811 | double maxValue=Double.parseDouble((String)parameterMaxValues.get(i)); |
||
3812 | double minValue=Double.parseDouble((String)parameterMinValues.get(i)); |
||
3813 | //parameterValue=Double.parseDouble(gtParameterValues[j]);
|
||
3814 | parameterValue=gtParameterValues[j]; // Ojo unidades -> analizar
|
||
3815 | double auxValue=Double.parseDouble(parameterValue); |
||
3816 | if((auxValue<minValue)||(auxValue>maxValue)) {
|
||
3817 | throw(new CrsException(new Exception("The parameter '"+gtParameterName+"' is out of domain."))); |
||
3818 | } else if (((String)parameterNames.get(i)).trim().equals("scale_factor") && (auxValue==minValue)) { |
||
3819 | String strError="the_parameter"; |
||
3820 | String strError2=gtParameterName;
|
||
3821 | String strError3="out_of_domain"; |
||
3822 | throw(new CrsException(new Exception("The parameter '"+gtParameterName+"' is out of domain."))); |
||
3823 | } |
||
3824 | break;
|
||
3825 | } |
||
3826 | /*else
|
||
3827 | {
|
||
3828 | String strError="El parametro recibido de GeoTools ";
|
||
3829 | strError+=gtParameterName;
|
||
3830 | strError+=" no esta contemplado en la proyeccion";
|
||
3831 | System.out.println(strError);
|
||
3832 | throw new CrsException(new Exception());
|
||
3833 | }*/
|
||
3834 | } |
||
3835 | if(existsParameter)
|
||
3836 | { |
||
3837 | parameterValues.set(i,parameterValue); |
||
3838 | } |
||
3839 | } |
||
3840 | boolean isSomerc=false; |
||
3841 | boolean isOmerc=false; |
||
3842 | boolean isLcc=false; |
||
3843 | double valueAlpha=0; |
||
3844 | double valueGamma=0; |
||
3845 | boolean existsAlpha=false; |
||
3846 | boolean existsGamma=false; |
||
3847 | String[] projectionAcronym=(String[])projectionAcronymList.get(indexProj); |
||
3848 | if(projectionName.equals("Lambert_Conformal_Conic")) |
||
3849 | { |
||
3850 | for(int i=0;i<parameterNames.size();i++) |
||
3851 | { |
||
3852 | boolean control=true; |
||
3853 | String parameterName=((String)parameterNames.get(i)).trim(); |
||
3854 | if(parameterName.equalsIgnoreCase("standard_parallel_2")) |
||
3855 | isLcc=true;
|
||
3856 | } |
||
3857 | } |
||
3858 | if(projectionName.equals("Oblique_Mercator")) |
||
3859 | { |
||
3860 | isOmerc=true;
|
||
3861 | for(int j=0;j<gtParameterNames.length;j++) |
||
3862 | { |
||
3863 | String gtParameterName=gtParameterNames[j].trim();
|
||
3864 | if(gtParameterName.equalsIgnoreCase("latitude_of_origin") |
||
3865 | ||gtParameterName.equalsIgnoreCase("standard_parallel_1")
|
||
3866 | ||gtParameterName.equalsIgnoreCase("latitude_of_center"))
|
||
3867 | { |
||
3868 | double value=Double.parseDouble(gtParameterValues[j]); |
||
3869 | if(Math.abs(Math.abs(value)-90.0)<0.0001) |
||
3870 | { |
||
3871 | throw new CrsException(new Exception("The proj4 projection 'Oblique Mercator' not allow latitude origin close to the poles.")); |
||
3872 | } |
||
3873 | } |
||
3874 | if(gtParameterName.equalsIgnoreCase("azimuth")) |
||
3875 | { |
||
3876 | valueAlpha=Double.parseDouble(gtParameterValues[j]);
|
||
3877 | if(Math.abs(valueAlpha-90.0)<0.0001) |
||
3878 | { |
||
3879 | throw new CrsException(new Exception("The proj4 projection 'Oblique Mercator' not allow azimut close to 90.")); |
||
3880 | } |
||
3881 | if(Math.abs(valueAlpha-270.0)<0.0001) |
||
3882 | { |
||
3883 | throw new CrsException(new Exception("The proj4 projection 'Oblique Mercator' not allow azimut close to 270.")); |
||
3884 | } |
||
3885 | existsAlpha=true;
|
||
3886 | } |
||
3887 | if(gtParameterName.equalsIgnoreCase("rectified_grid_angle")) |
||
3888 | { |
||
3889 | valueGamma=Double.parseDouble(gtParameterValues[j]);
|
||
3890 | existsGamma=true;
|
||
3891 | } |
||
3892 | } |
||
3893 | if(existsAlpha&&existsGamma)
|
||
3894 | { |
||
3895 | if(Math.abs(valueAlpha-valueGamma)>0.00000001) |
||
3896 | { |
||
3897 | throw new CrsException(new Exception("The proj4 projection 'Oblique Mercator' not allow diferent azimut and spin axis.")); |
||
3898 | } |
||
3899 | } |
||
3900 | |||
3901 | // Necesito buscar un caso de ejemplo
|
||
3902 | } |
||
3903 | if(projectionName.equals("Hotine_Oblique_Mercator_Two_Point_Center")) |
||
3904 | { |
||
3905 | double lat_1=0.0; |
||
3906 | double lat_2=0.0; |
||
3907 | boolean exists_Lat_1=false; |
||
3908 | boolean exists_Lat_2=false; |
||
3909 | for(int j=0;j<gtParameterNames.length;j++) |
||
3910 | { |
||
3911 | String gtParameterName=gtParameterNames[j].trim();
|
||
3912 | if(gtParameterName.equalsIgnoreCase("Latitude_Of_1st_Point")) |
||
3913 | { |
||
3914 | double value=Double.parseDouble(gtParameterValues[j]); |
||
3915 | } |
||
3916 | if(gtParameterName.equalsIgnoreCase("Latitude_Of_2nd_Point")) |
||
3917 | { |
||
3918 | double value=Double.parseDouble(gtParameterValues[j]); |
||
3919 | } |
||
3920 | } |
||
3921 | if(exists_Lat_1&&exists_Lat_2)
|
||
3922 | { |
||
3923 | if(Math.abs(lat_1-lat_2)<0.0001) |
||
3924 | { |
||
3925 | throw new CrsException(new Exception("The proj4 projection 'Hotine-Oblique Mercator Two Points' not allow lat1 equal to lat2.")); |
||
3926 | } |
||
3927 | if(Math.abs(lat_1)<0.0001) |
||
3928 | { |
||
3929 | throw new CrsException(new Exception("The proj4 projection 'Hotine-Oblique Mercator Two Points' not allow not zero lat1.")); |
||
3930 | } |
||
3931 | if(Math.abs(Math.abs(lat_2)-90)<0.0001) |
||
3932 | { |
||
3933 | throw new CrsException(new Exception("The proj4 projection 'Hotine-Oblique Mercator Two Points' not allow values of 90 or minus 90 in lat2.")); |
||
3934 | } |
||
3935 | } |
||
3936 | } |
||
3937 | String projAcronym=projectionAcronym[0]; |
||
3938 | if(isLcc)
|
||
3939 | projAcronym="lcc";
|
||
3940 | String strExtraProj4=""; |
||
3941 | // Control de casos especiales
|
||
3942 | boolean isLaborde=false; |
||
3943 | boolean isLcc1sp=false; |
||
3944 | boolean isMerc=false; |
||
3945 | boolean exists_sf=false; |
||
3946 | boolean exists_lo=false; |
||
3947 | boolean isSterePolar=false; |
||
3948 | boolean isStereOblique=false; // pondremos +proj=sterea |
||
3949 | boolean exists_stdPar=false; |
||
3950 | double value_stdPar=0.0; |
||
3951 | if(projectionAcronym[0].equals("merc")) // 1 - Mercator |
||
3952 | { |
||
3953 | isMerc=true;
|
||
3954 | double value_sf=0.0; |
||
3955 | double value_lo=0.0; |
||
3956 | for(int j=0;j<gtParameterNames.length;j++) |
||
3957 | { |
||
3958 | String gtParameterName=gtParameterNames[j].trim();
|
||
3959 | if(gtParameterName.equalsIgnoreCase("latitude_of_origin") |
||
3960 | ||gtParameterName.equalsIgnoreCase("standard_parallel_1")
|
||
3961 | ||gtParameterName.equalsIgnoreCase("latitude_of_center"))
|
||
3962 | { |
||
3963 | exists_lo=true;
|
||
3964 | value_lo=Double.parseDouble(gtParameterValues[j]);
|
||
3965 | } |
||
3966 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
3967 | { |
||
3968 | exists_sf=true;
|
||
3969 | value_sf=Double.parseDouble(gtParameterValues[j]);
|
||
3970 | } |
||
3971 | } |
||
3972 | if(exists_sf&&exists_lo)
|
||
3973 | { |
||
3974 | if(value_sf!=1.0&&value_lo!=0.0) |
||
3975 | { |
||
3976 | throw new CrsException(new Exception("The proj4 projection 'Mercator' not allow scale factor and latitude of origin.")); |
||
3977 | } |
||
3978 | else if(projectionName.equals("Mercator_1SP")) |
||
3979 | exists_lo=false;
|
||
3980 | else if(projectionName.equals("Mercator_2SP")) |
||
3981 | exists_sf=false;
|
||
3982 | /*
|
||
3983 | else if(value_sf!=1.0)
|
||
3984 | exists_lo=false;
|
||
3985 | else if(value_sf==1.0)
|
||
3986 | exists_sf=false;
|
||
3987 | */
|
||
3988 | } |
||
3989 | } |
||
3990 | else if(projectionAcronym[0].equals("lcc")) |
||
3991 | { |
||
3992 | if(projectionName.equalsIgnoreCase("Lambert_Conformal_Conic_1SP")) |
||
3993 | { |
||
3994 | isLcc1sp=true;
|
||
3995 | } |
||
3996 | } |
||
3997 | else if(projectionAcronym[0].equals("stere")) |
||
3998 | { |
||
3999 | if(projectionName.equalsIgnoreCase("Polar_Stereographic")) // lat_ts=lat_0={90 o -90) |
||
4000 | { |
||
4001 | isSterePolar=true;
|
||
4002 | for(int j=0;j<gtParameterNames.length;j++) |
||
4003 | { |
||
4004 | String gtParameterName=gtParameterNames[j].trim();
|
||
4005 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
4006 | { |
||
4007 | double value_sf=Double.parseDouble(gtParameterValues[j]); |
||
4008 | exists_sf=true;
|
||
4009 | //if(Math.abs(value_sf-1.0)>0.000001)
|
||
4010 | // exists_sf=true;
|
||
4011 | } |
||
4012 | if(gtParameterName.equalsIgnoreCase("latitude_of_standard_parallel")) |
||
4013 | { |
||
4014 | value_stdPar=Double.parseDouble(gtParameterValues[j]);
|
||
4015 | exists_stdPar=true;
|
||
4016 | } |
||
4017 | } |
||
4018 | } |
||
4019 | } |
||
4020 | if(projectionName.equalsIgnoreCase("Stereographic")) // No admite lat_ts |
||
4021 | { |
||
4022 | // Comprobamos si es polar
|
||
4023 | boolean isPolar=false; |
||
4024 | for(int j=0;j<gtParameterNames.length;j++) |
||
4025 | { |
||
4026 | String gtParameterAcronymn=((String)parameterAcronyms.get(j)).trim(); |
||
4027 | //if(gtParameterAcronymn.equalsIgnoreCase("lat_0"))
|
||
4028 | if(gtParameterNames[j].equalsIgnoreCase("latitude_of_origin")) |
||
4029 | { |
||
4030 | double gtParameterValue=Double.parseDouble(gtParameterValues[j]); |
||
4031 | if(Math.abs(gtParameterValue-90.0)<angularTolerance) isPolar=true; |
||
4032 | else if(Math.abs(gtParameterValue-(-90.0))<angularTolerance) isPolar=true; |
||
4033 | break;
|
||
4034 | } |
||
4035 | } |
||
4036 | if(isPolar)
|
||
4037 | { |
||
4038 | isSterePolar=true;
|
||
4039 | projAcronym="stere";
|
||
4040 | for(int j=0;j<gtParameterNames.length;j++) |
||
4041 | { |
||
4042 | String gtParameterName=gtParameterNames[j].trim();
|
||
4043 | if(gtParameterName.equalsIgnoreCase("scale_factor")) |
||
4044 | { |
||
4045 | double value_sf=Double.parseDouble(gtParameterValues[j]); |
||
4046 | exists_sf=true;
|
||
4047 | //if(Math.abs(value_sf-1.0)>0.000001)
|
||
4048 | // exists_sf=true;
|
||
4049 | } |
||
4050 | if(gtParameterName.equalsIgnoreCase("latitude_of_standard_parallel")) |
||
4051 | { |
||
4052 | value_stdPar=Double.parseDouble(gtParameterValues[j]);
|
||
4053 | exists_stdPar=true;
|
||
4054 | } |
||
4055 | } |
||
4056 | } |
||
4057 | if(!isPolar)
|
||
4058 | { |
||
4059 | isStereOblique=true;
|
||
4060 | projAcronym="sterea";
|
||
4061 | if(exists_stdPar)
|
||
4062 | { |
||
4063 | throw new CrsException(new Exception("The proj4 projection 'Oblique Stereographic' not allow parameter latitude of standard parallel.")); |
||
4064 | } |
||
4065 | } |
||
4066 | } |
||
4067 | else if(projectionAcronym[0].equals("mill")) |
||
4068 | { |
||
4069 | strExtraProj4="+R_A ";
|
||
4070 | } |
||
4071 | else if(projectionAcronym[0].equals("vandg")) |
||
4072 | { |
||
4073 | strExtraProj4="+R_A ";
|
||
4074 | } |
||
4075 | else if(projectionAcronym[0].equals("labrd")) |
||
4076 | { |
||
4077 | isLaborde=true;
|
||
4078 | } |
||
4079 | strProj4=strProj4+projAcronym+" ";
|
||
4080 | |||
4081 | for(int i=0;i<parameterNames.size();i++) |
||
4082 | { |
||
4083 | boolean control=true; |
||
4084 | String parameterName=((String)parameterNames.get(i)).trim(); |
||
4085 | String parameterAcronym=((String)parameterAcronyms.get(i)).trim(); |
||
4086 | String strParameterValue=((String)parameterValues.get(i)).trim(); |
||
4087 | if(isMerc)
|
||
4088 | { |
||
4089 | if(parameterName.equalsIgnoreCase("latitude_of_origin") |
||
4090 | ||parameterName.equalsIgnoreCase("standard_parallel_1")
|
||
4091 | ||parameterName.equalsIgnoreCase("latitude_of_center"))
|
||
4092 | { |
||
4093 | if(!exists_lo)
|
||
4094 | control=false;
|
||
4095 | } |
||
4096 | if(parameterName.equalsIgnoreCase("scale_factor")) |
||
4097 | { |
||
4098 | if(!exists_sf)
|
||
4099 | control=false;
|
||
4100 | } |
||
4101 | } |
||
4102 | if(isSterePolar)
|
||
4103 | { |
||
4104 | String gtParameterAcronymn=((String)parameterAcronyms.get(i)).trim(); |
||
4105 | if(gtParameterAcronymn.equalsIgnoreCase("lat_0")) // Esto resuelve el caso del EPSG:3031 |
||
4106 | { |
||
4107 | if(exists_stdPar){
|
||
4108 | double parameterValue=Double.parseDouble(strParameterValue); |
||
4109 | if((parameterValue>0)&&(value_stdPar<0)){ |
||
4110 | strParameterValue="-90.0";
|
||
4111 | } |
||
4112 | if((parameterValue<0)&&(value_stdPar>0)){ |
||
4113 | strParameterValue="90.0";
|
||
4114 | } |
||
4115 | } |
||
4116 | } |
||
4117 | if(gtParameterAcronymn.equalsIgnoreCase("lat_ts")) |
||
4118 | { |
||
4119 | if(exists_sf)
|
||
4120 | control=false;
|
||
4121 | } |
||
4122 | if(parameterName.equalsIgnoreCase("scale_factor")) |
||
4123 | { |
||
4124 | if(!exists_sf)
|
||
4125 | control=false;
|
||
4126 | } |
||
4127 | } |
||
4128 | if(isSomerc)
|
||
4129 | { |
||
4130 | if(parameterName.equals("rectified_grid_angle")) |
||
4131 | control=false;
|
||
4132 | if(parameterName.equals("azimuth")) |
||
4133 | control=false;
|
||
4134 | } |
||
4135 | if(isOmerc)
|
||
4136 | { |
||
4137 | if(parameterName.equals("rectified_grid_angle")) |
||
4138 | { |
||
4139 | if(existsAlpha)
|
||
4140 | control=false;
|
||
4141 | else
|
||
4142 | parameterAcronym="alpha";
|
||
4143 | } |
||
4144 | } |
||
4145 | if(parameterAcronym.equals("lon_0") |
||
4146 | ||parameterAcronym.equals("lonc"))
|
||
4147 | { |
||
4148 | double parameterValue=Double.parseDouble(strParameterValue); |
||
4149 | if(!projectionAcronym[0].equalsIgnoreCase("krovak")) |
||
4150 | { |
||
4151 | parameterValue=parameterValue-primeMeridianValue; |
||
4152 | } |
||
4153 | strParameterValue=Double.toString(parameterValue);
|
||
4154 | } |
||
4155 | if(control)
|
||
4156 | strProj4=strProj4+"+"+parameterAcronym+"="+strParameterValue+" "; |
||
4157 | if(isLcc1sp)
|
||
4158 | { |
||
4159 | if(parameterAcronym.equals("lat_0")) |
||
4160 | { |
||
4161 | strProj4=strProj4+"+lat_1="+strParameterValue+" "; |
||
4162 | strProj4=strProj4+"+lat_2="+strParameterValue+" "; |
||
4163 | } |
||
4164 | } |
||
4165 | } |
||
4166 | if(isLaborde)
|
||
4167 | strProj4+="+azi=18.9 +lat_0=-18.9 +lon_0=44.1 +k_0=0.9995 +x_0=400000 +y_0=800000 +ellps=intl ";
|
||
4168 | strProj4+=strExtraProj4; |
||
4169 | //getProj4ProjectionName();
|
||
4170 | } |
||
4171 | |||
4172 | // Que pasa si no hay elipsoide? -> OGR por defecto pone WGS84
|
||
4173 | String strEllipseAcronym=ellipseToProj4(a,inv_f);
|
||
4174 | String strEllipse=""; |
||
4175 | if(strEllipseAcronym.equals("")) |
||
4176 | { |
||
4177 | if (!Double.isInfinite(inv_f)) |
||
4178 | { |
||
4179 | if(inv_f>0.0) |
||
4180 | strEllipse="+a="+a+" +rf="+inv_f+" "; |
||
4181 | else
|
||
4182 | strEllipse="+R="+a+" "; |
||
4183 | } |
||
4184 | else
|
||
4185 | strEllipse="+R="+a+" "; |
||
4186 | } |
||
4187 | else
|
||
4188 | { |
||
4189 | strEllipse="+ellps="+strEllipseAcronym+" "; |
||
4190 | } |
||
4191 | strProj4+=strEllipse; |
||
4192 | //System.out.println("Elipsoide["+elipName+"]=("+a+","+inv_f+")");
|
||
4193 | strProj4+=primeMeridianAcronym; |
||
4194 | if(!strProj4Datum.equals("")) |
||
4195 | strProj4+=strProj4Datum; |
||
4196 | if(!strProj4ToMeter.equals("")) |
||
4197 | strProj4+=strProj4ToMeter; |
||
4198 | String strWkt=crs.toWKT();
|
||
4199 | |||
4200 | //System.out.println("- Cadena proj4: "+strProj4);
|
||
4201 | return strProj4;
|
||
4202 | } |
||
4203 | |||
4204 | private String[] primeMeridianToProj4(String pmName,double pmValue) throws CrsException |
||
4205 | { |
||
4206 | String[] primeMeridian=new String[3]; |
||
4207 | String pszPM=""; |
||
4208 | String acronym=""; |
||
4209 | double dfFromGreenwich = 0.0; |
||
4210 | double tolerance=0.002/3600.0; |
||
4211 | int nPMCode = -1; |
||
4212 | |||
4213 | dfFromGreenwich=-(9+7/60.0+54.862/3600.0); |
||
4214 | if(pmName.equalsIgnoreCase("lisbon")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4215 | { |
||
4216 | pszPM="lisbon";
|
||
4217 | nPMCode = 8902;
|
||
4218 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4219 | { |
||
4220 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4221 | System.out.println(strError);
|
||
4222 | //throw new CrsException(new Exception(strError));
|
||
4223 | } |
||
4224 | pmValue=dfFromGreenwich; |
||
4225 | acronym="+pm="+pszPM+" "; |
||
4226 | } |
||
4227 | |||
4228 | dfFromGreenwich=(2+20/60.0+14.025/3600.0); |
||
4229 | if(pmName.equalsIgnoreCase("paris")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4230 | { |
||
4231 | pszPM="paris";
|
||
4232 | nPMCode = 8903;
|
||
4233 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4234 | { |
||
4235 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4236 | System.out.println(strError);
|
||
4237 | //throw new CrsException(new Exception(strError));
|
||
4238 | } |
||
4239 | pmValue=dfFromGreenwich; |
||
4240 | acronym="+pm="+pszPM+" "; |
||
4241 | } |
||
4242 | |||
4243 | dfFromGreenwich=-(74+4/60.0+51.3/3600.0); |
||
4244 | if(pmName.equalsIgnoreCase("bogota")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4245 | { |
||
4246 | pszPM="bogota";
|
||
4247 | nPMCode = 8904;
|
||
4248 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4249 | { |
||
4250 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4251 | System.out.println(strError);
|
||
4252 | //throw new CrsException(new Exception(strError));
|
||
4253 | } |
||
4254 | pmValue=dfFromGreenwich; |
||
4255 | acronym="+pm="+pszPM+" "; |
||
4256 | } |
||
4257 | |||
4258 | dfFromGreenwich=-(3+41/60.0+16.58/3600.0); // mal en ogr los segundos pone 16.48 |
||
4259 | if(pmName.equalsIgnoreCase("madrid")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4260 | { |
||
4261 | pszPM="madrid";
|
||
4262 | nPMCode = 8905;
|
||
4263 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4264 | { |
||
4265 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4266 | System.out.println(strError);
|
||
4267 | //throw new CrsException(new Exception(strError));
|
||
4268 | } |
||
4269 | pmValue=dfFromGreenwich; |
||
4270 | acronym="+pm="+pszPM+" "; |
||
4271 | } |
||
4272 | |||
4273 | dfFromGreenwich=(12+27/60.0+8.4/3600.0); |
||
4274 | if(pmName.equalsIgnoreCase("rome")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4275 | { |
||
4276 | pszPM="rome";
|
||
4277 | nPMCode = 8906;
|
||
4278 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4279 | { |
||
4280 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4281 | System.out.println(strError);
|
||
4282 | //throw new CrsException(new Exception(strError));
|
||
4283 | } |
||
4284 | pmValue=dfFromGreenwich; |
||
4285 | acronym="+pm="+pszPM+" "; |
||
4286 | } |
||
4287 | |||
4288 | dfFromGreenwich=(7+26/60.0+22.5/3600.0); |
||
4289 | if(pmName.equalsIgnoreCase("bern")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4290 | { |
||
4291 | pszPM="bern";
|
||
4292 | nPMCode = 8907;
|
||
4293 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4294 | { |
||
4295 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4296 | System.out.println(strError);
|
||
4297 | //throw new CrsException(new Exception(strError));
|
||
4298 | } |
||
4299 | pmValue=dfFromGreenwich; |
||
4300 | acronym="+pm="+pszPM+" "; |
||
4301 | } |
||
4302 | |||
4303 | dfFromGreenwich=(106+48/60.0+27.79/3600.0); |
||
4304 | if(pmName.equalsIgnoreCase("jakarta")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4305 | { |
||
4306 | pszPM="jakarta";
|
||
4307 | nPMCode = 8908;
|
||
4308 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4309 | { |
||
4310 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4311 | System.out.println(strError);
|
||
4312 | //throw new CrsException(new Exception(strError));
|
||
4313 | } |
||
4314 | pmValue=dfFromGreenwich; |
||
4315 | acronym="+pm="+pszPM+" "; |
||
4316 | } |
||
4317 | |||
4318 | dfFromGreenwich=-(17+40/60.0+0.0/3600.0); |
||
4319 | if(pmName.equalsIgnoreCase("ferro")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4320 | { |
||
4321 | pszPM="ferro";
|
||
4322 | nPMCode = 8909;
|
||
4323 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4324 | { |
||
4325 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4326 | System.out.println(strError);
|
||
4327 | //throw new CrsException(new Exception(strError));
|
||
4328 | } |
||
4329 | pmValue=dfFromGreenwich; |
||
4330 | acronym="+pm="+pszPM+" "; |
||
4331 | } |
||
4332 | |||
4333 | dfFromGreenwich=(4+22/60.0+4.71/3600.0); |
||
4334 | if(pmName.equalsIgnoreCase("brussels")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4335 | { |
||
4336 | pszPM="brussels";
|
||
4337 | nPMCode = 8910;
|
||
4338 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4339 | { |
||
4340 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4341 | System.out.println(strError);
|
||
4342 | //throw new CrsException(new Exception(strError));
|
||
4343 | } |
||
4344 | pmValue=dfFromGreenwich; |
||
4345 | acronym="+pm="+pszPM+" "; |
||
4346 | } |
||
4347 | |||
4348 | dfFromGreenwich=(18+3/60.0+29.8/3600.0); |
||
4349 | if(pmName.equalsIgnoreCase("stockholm")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4350 | { |
||
4351 | pszPM="stockholm";
|
||
4352 | nPMCode = 8911;
|
||
4353 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4354 | { |
||
4355 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4356 | System.out.println(strError);
|
||
4357 | //throw new CrsException(new Exception(strError));
|
||
4358 | } |
||
4359 | pmValue=dfFromGreenwich; |
||
4360 | acronym="+pm="+pszPM+" "; |
||
4361 | } |
||
4362 | |||
4363 | dfFromGreenwich=(23+42/60.0+58.815/3600.0); |
||
4364 | if(pmName.equalsIgnoreCase("athens")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4365 | { |
||
4366 | pszPM="athens";
|
||
4367 | nPMCode = 8912;
|
||
4368 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4369 | { |
||
4370 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4371 | System.out.println(strError);
|
||
4372 | //throw new CrsException(new Exception(strError));
|
||
4373 | } |
||
4374 | pmValue=dfFromGreenwich; |
||
4375 | acronym="+pm="+pszPM+" "; |
||
4376 | } |
||
4377 | |||
4378 | dfFromGreenwich=(10+43/60.0+22.5/3600.0); |
||
4379 | if(pmName.equalsIgnoreCase("oslo")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4380 | { |
||
4381 | pszPM="oslo";
|
||
4382 | nPMCode = 8913;
|
||
4383 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4384 | { |
||
4385 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4386 | System.out.println(strError);
|
||
4387 | //throw new CrsException(new Exception(strError));
|
||
4388 | } |
||
4389 | pmValue=dfFromGreenwich; |
||
4390 | acronym="+pm="+pszPM+" "; |
||
4391 | } |
||
4392 | |||
4393 | dfFromGreenwich=(0.0);
|
||
4394 | if(pmName.equalsIgnoreCase("Greenwich")||(Math.abs(dfFromGreenwich-pmValue)<tolerance)) |
||
4395 | { |
||
4396 | pszPM="Greenwich";
|
||
4397 | nPMCode = 0;
|
||
4398 | if(Math.abs(dfFromGreenwich-pmValue)>tolerance) |
||
4399 | { |
||
4400 | String strError="No concuerdan el nombre del meridiano origen y su valor"; |
||
4401 | System.out.println(strError);
|
||
4402 | //throw new CrsException(new Exception(strError));
|
||
4403 | } |
||
4404 | pmValue=dfFromGreenwich; |
||
4405 | } |
||
4406 | primeMeridian[0]=pszPM;
|
||
4407 | primeMeridian[1]=Double.toString(pmValue); |
||
4408 | primeMeridian[2]=acronym;
|
||
4409 | return primeMeridian;
|
||
4410 | } |
||
4411 | |||
4412 | private String ellipseToProj4(double dfSemiMajor, double dfInvFlattening) |
||
4413 | { |
||
4414 | double yo=Math.abs(4.5); |
||
4415 | String pszPROJ4Ellipse=""; |
||
4416 | if( Math.abs(dfSemiMajor-6378249.145) < 0.01 |
||
4417 | && Math.abs(dfInvFlattening-293.465) < 0.0001 ) |
||
4418 | { |
||
4419 | pszPROJ4Ellipse = "clrk80"; /* Clark 1880 */ |
||
4420 | } |
||
4421 | else if( Math.abs(dfSemiMajor-6378245.0) < 0.01 |
||
4422 | && Math.abs(dfInvFlattening-298.3) < 0.0001 ) |
||
4423 | { |
||
4424 | pszPROJ4Ellipse = "krass"; /* Krassovsky */ |
||
4425 | } |
||
4426 | else if( Math.abs(dfSemiMajor-6378388.0) < 0.01 |
||
4427 | && Math.abs(dfInvFlattening-297.0) < 0.0001 ) |
||
4428 | { |
||
4429 | pszPROJ4Ellipse = "intl"; /* International 1924 */ |
||
4430 | } |
||
4431 | else if( Math.abs(dfSemiMajor-6378160.0) < 0.01 |
||
4432 | && Math.abs(dfInvFlattening-298.25) < 0.0001 ) |
||
4433 | { |
||
4434 | pszPROJ4Ellipse = "aust_SA"; /* Australian */ |
||
4435 | } |
||
4436 | else if( Math.abs(dfSemiMajor-6377397.155) < 0.01 |
||
4437 | && Math.abs(dfInvFlattening-299.1528128) < 0.0001 ) |
||
4438 | { |
||
4439 | pszPROJ4Ellipse = "bessel"; /* Bessel 1841 */ |
||
4440 | } |
||
4441 | else if( Math.abs(dfSemiMajor-6377483.865) < 0.01 |
||
4442 | && Math.abs(dfInvFlattening-299.1528128) < 0.0001 ) |
||
4443 | { |
||
4444 | pszPROJ4Ellipse = "bess_nam"; /* Bessel 1841 (Namibia / Schwarzeck)*/ |
||
4445 | } |
||
4446 | else if( Math.abs(dfSemiMajor-6378160.0) < 0.01 |
||
4447 | && Math.abs(dfInvFlattening-298.247167427) < 0.0001 ) |
||
4448 | { |
||
4449 | pszPROJ4Ellipse = "GRS67"; /* GRS 1967 */ |
||
4450 | } |
||
4451 | else if( Math.abs(dfSemiMajor-6378137) < 0.01 |
||
4452 | && Math.abs(dfInvFlattening-298.257222101) < 0.000001 ) |
||
4453 | { |
||
4454 | pszPROJ4Ellipse = "GRS80"; /* GRS 1980 */ |
||
4455 | } |
||
4456 | else if( Math.abs(dfSemiMajor-6378206.4) < 0.01 |
||
4457 | && Math.abs(dfInvFlattening-294.9786982) < 0.0001 ) |
||
4458 | { |
||
4459 | pszPROJ4Ellipse = "clrk66"; /* Clarke 1866 */ |
||
4460 | } |
||
4461 | else if( Math.abs(dfSemiMajor-6378206.4) < 0.01 |
||
4462 | && Math.abs(dfInvFlattening-294.9786982) < 0.0001 ) |
||
4463 | { |
||
4464 | pszPROJ4Ellipse = "mod_airy"; /* Modified Airy */ |
||
4465 | } |
||
4466 | else if( Math.abs(dfSemiMajor-6377563.396) < 0.01 |
||
4467 | && Math.abs(dfInvFlattening-299.3249646) < 0.0001 ) |
||
4468 | { |
||
4469 | pszPROJ4Ellipse = "airy"; /* Modified Airy */ |
||
4470 | } |
||
4471 | else if( Math.abs(dfSemiMajor-6378200) < 0.01 |
||
4472 | && Math.abs(dfInvFlattening-298.3) < 0.0001 ) |
||
4473 | { |
||
4474 | pszPROJ4Ellipse = "helmert"; /* Helmert 1906 */ |
||
4475 | } |
||
4476 | else if( Math.abs(dfSemiMajor-6378155) < 0.01 |
||
4477 | && Math.abs(dfInvFlattening-298.3) < 0.0001 ) |
||
4478 | { |
||
4479 | pszPROJ4Ellipse = "fschr60m"; /* Modified Fischer 1960 */ |
||
4480 | } |
||
4481 | else if( Math.abs(dfSemiMajor-6377298.556) < 0.01 |
||
4482 | && Math.abs(dfInvFlattening-300.8017) < 0.0001 ) |
||
4483 | { |
||
4484 | pszPROJ4Ellipse = "evrstSS"; /* Everest (Sabah & Sarawak) */ |
||
4485 | } |
||
4486 | else if( Math.abs(dfSemiMajor-6378165.0) < 0.01 |
||
4487 | && Math.abs(dfInvFlattening-298.3) < 0.0001 ) |
||
4488 | { |
||
4489 | pszPROJ4Ellipse = "WGS60";
|
||
4490 | } |
||
4491 | else if( Math.abs(dfSemiMajor-6378145.0) < 0.01 |
||
4492 | && Math.abs(dfInvFlattening-298.25) < 0.0001 ) |
||
4493 | { |
||
4494 | pszPROJ4Ellipse = "WGS66";
|
||
4495 | } |
||
4496 | else if( Math.abs(dfSemiMajor-6378135.0) < 0.01 |
||
4497 | && Math.abs(dfInvFlattening-298.26) < 0.0001 ) |
||
4498 | { |
||
4499 | pszPROJ4Ellipse = "WGS72";
|
||
4500 | } |
||
4501 | else if( Math.abs(dfSemiMajor-6378137.0) < 0.01 |
||
4502 | && Math.abs(dfInvFlattening-298.257223563) < 0.000001 ) |
||
4503 | { |
||
4504 | pszPROJ4Ellipse = "WGS84";
|
||
4505 | } |
||
4506 | /*
|
||
4507 | else if( EQUAL(pszDatum,"North_American_Datum_1927") )
|
||
4508 | {
|
||
4509 | // pszPROJ4Ellipse = "clrk66:+datum=nad27"; // NAD 27
|
||
4510 | pszPROJ4Ellipse = "clrk66";
|
||
4511 | }
|
||
4512 | else if( EQUAL(pszDatum,"North_American_Datum_1983") )
|
||
4513 | {
|
||
4514 | // pszPROJ4Ellipse = "GRS80:+datum=nad83"; // NAD 83
|
||
4515 | pszPROJ4Ellipse = "GRS80";
|
||
4516 | }
|
||
4517 | */
|
||
4518 | return pszPROJ4Ellipse;
|
||
4519 | } |
||
4520 | |||
4521 | private String datumToProj4(String datumName,int epsgCode) |
||
4522 | { |
||
4523 | String datumProj4=""; |
||
4524 | String SRS_DN_NAD27="North_American_Datum_1927"; |
||
4525 | String SRS_DN_NAD83="North_American_Datum_1983"; |
||
4526 | String SRS_DN_WGS72="WGS_1972"; |
||
4527 | String SRS_DN_WGS84="WGS_1984"; |
||
4528 | if(datumName.equals("")) |
||
4529 | datumProj4="";
|
||
4530 | else if(datumName.equalsIgnoreCase(SRS_DN_NAD27) || epsgCode == 6267 ) |
||
4531 | datumProj4 = "+datum=NAD27 ";
|
||
4532 | |||
4533 | else if(datumName.equalsIgnoreCase(SRS_DN_NAD83) || epsgCode == 6269 ) |
||
4534 | datumProj4 = "+datum=NAD83 ";
|
||
4535 | |||
4536 | else if(datumName.equalsIgnoreCase(SRS_DN_WGS84) || epsgCode == 6326 ) |
||
4537 | datumProj4 = "+datum=WGS84 ";
|
||
4538 | |||
4539 | else if( epsgCode == 6314 ) |
||
4540 | datumProj4 = "+datum=potsdam ";
|
||
4541 | |||
4542 | else if( epsgCode == 6272 ) |
||
4543 | datumProj4 = "+datum=nzgd49 ";
|
||
4544 | return datumProj4;
|
||
4545 | } |
||
4546 | // Casos especiales
|
||
4547 | // - MERCATOR_1SP
|
||
4548 | // - HOTINE
|
||
4549 | // - MILLER
|
||
4550 | // - Polar_Stereographic
|
||
4551 | // - Polar_Stereographic
|
||
4552 | // - VanDerGrinten
|
||
4553 | // - Transverse Mercator
|
||
4554 | // - Cuando el meridiano origen no es 0 se pone pm=madrid y lon_0=
|
||
4555 | // +datum
|
||
4556 | |||
4557 | // Funciones privadas necesarias para el proceso
|
||
4558 | |||
4559 | private String getName(Identifier name) { |
||
4560 | String[] correctName = name.toString().split(":"); |
||
4561 | if (correctName.length<2) |
||
4562 | return correctName[0]; |
||
4563 | |||
4564 | else
|
||
4565 | return correctName[1]; |
||
4566 | } |
||
4567 | |||
4568 | private String[] Spheroid (Ellipsoid ellips) { |
||
4569 | String[] spheroid = new String[3]; |
||
4570 | Unit u = ellips.getAxisUnit(); |
||
4571 | double semi_major = convert( ellips.getSemiMajorAxis(), u.toString());
|
||
4572 | //double inv_f = convert( ellips.getInverseFlattening(), u.toString());
|
||
4573 | double inv_f = ellips.getInverseFlattening();
|
||
4574 | String[] val = ellips.getName().toString().split(":"); |
||
4575 | if (val.length<2) |
||
4576 | spheroid[0] = ellips.getName().toString().split(":")[0]; |
||
4577 | else
|
||
4578 | spheroid[0] = ellips.getName().toString().split(":")[1]; |
||
4579 | spheroid[1] = String.valueOf(semi_major); |
||
4580 | spheroid[2] = String.valueOf(inv_f); |
||
4581 | return spheroid;
|
||
4582 | } |
||
4583 | |||
4584 | private String[] Primem (PrimeMeridian prim) { |
||
4585 | String[] primem = new String[2]; |
||
4586 | DefaultPrimeMeridian pm = (DefaultPrimeMeridian) prim; |
||
4587 | Unit u = pm.getAngularUnit(); |
||
4588 | double value = convert( pm.getGreenwichLongitude(), u.toString());
|
||
4589 | String[] val = pm.getName().toString().split(":"); |
||
4590 | if (val.length<2) |
||
4591 | primem[0] = pm.getName().toString().split(":")[0]; |
||
4592 | else
|
||
4593 | primem[0] = pm.getName().toString().split(":")[1]; |
||
4594 | primem[1] = String.valueOf(value); |
||
4595 | return primem;
|
||
4596 | } |
||
4597 | |||
4598 | public double convert(double value, String measure) throws ConversionException { |
||
4599 | if (measure.equals("D.MS")) { |
||
4600 | value *= this.divider;
|
||
4601 | int deg,min;
|
||
4602 | deg = (int) (value/10000); value -= 10000*deg; |
||
4603 | min = (int) (value/ 100); value -= 100*min; |
||
4604 | if (min<=-60 || min>=60) { // Accepts NaN |
||
4605 | if (Math.abs(Math.abs(min) - 100) <= EPS) { |
||
4606 | if (min >= 0) deg++; else deg--; |
||
4607 | min = 0;
|
||
4608 | } else {
|
||
4609 | throw new ConversionException("Invalid minutes: "+min); |
||
4610 | } |
||
4611 | } |
||
4612 | if (value<=-60 || value>=60) { // Accepts NaN |
||
4613 | if (Math.abs(Math.abs(value) - 100) <= EPS) { |
||
4614 | if (value >= 0) min++; else min--; |
||
4615 | value = 0;
|
||
4616 | } else {
|
||
4617 | throw new ConversionException("Invalid secondes: "+value); |
||
4618 | } |
||
4619 | } |
||
4620 | value = ((value/60) + min)/60 + deg; |
||
4621 | return value;
|
||
4622 | } |
||
4623 | if (measure.equals("grad") || measure.equals("grade")) |
||
4624 | return ((value * 180.0) / 200.0); |
||
4625 | if (measure.equals(""+(char)176)) |
||
4626 | return value;
|
||
4627 | if (measure.equals("DMS") ) |
||
4628 | return value;
|
||
4629 | if (measure.equals("m") || measure.startsWith("[m")) |
||
4630 | return value;
|
||
4631 | if (measure.equals("")) |
||
4632 | return value;
|
||
4633 | if (measure.equalsIgnoreCase("ft")||measure.equalsIgnoreCase("foot")||measure.equalsIgnoreCase("feet")) |
||
4634 | return (value*0.3048/1.0); |
||
4635 | |||
4636 | throw new ConversionException("Conversion no contemplada: "+measure); |
||
4637 | } |
||
4638 | |||
4639 | public ArrayList getProjectionNameList(){ |
||
4640 | return projectionNameList;
|
||
4641 | } |
||
4642 | } |