Statistics
| Revision:

root / branches / F2 / libraries / libJCRS / src / org / gvsig / crs / Proj4.java @ 11135

History | View | Annotate | Download (98.3 KB)

1
package org.gvsig.crs;
2

    
3
import java.util.ArrayList;
4

    
5
public class Proj4 {
6

    
7
        private static ArrayList projectionNameList= new ArrayList();
8
        private static ArrayList unitNameList= new ArrayList();
9
        private static ArrayList projectionParameterNameList= new ArrayList();
10
        private static ArrayList projectionParameterList= new ArrayList();
11
        private static ArrayList projectionParameterDefaultValueList= new ArrayList();
12
        private static ArrayList projectionParameterMaxValueList= new ArrayList();
13
        private static ArrayList projectionParameterMinValueList= new ArrayList();
14
        private static ArrayList projectionParameterUnitList= new ArrayList();
15
        private static ArrayList projectionAcronymList= new ArrayList();
16
        private static ArrayList projectionParameterAcronymList= new ArrayList();
17
        
18
        
19
        public Proj4() throws CrsException
20
        {
21
                //defineProjectionNames();
22
                //defineProjectionParameterNameList();
23
                //defineProjectionParameterUnitList();
24
                defineUnitNameList();
25
                defineProjectionParameterList();
26
                defineProjections();
27
        }
28
        
29
        private void defineUnitNameList() throws CrsException
30
        {
31
                int count=0;
32
                
33
                {
34
                        String[] unitName={"Angular"};
35
                        unitNameList.add(count,unitName);
36
                }
37
                
38
                count++;
39
                {
40
                        String[] unitName={"Linear"};
41
                        unitNameList.add(count,unitName);
42
                }
43
                
44
                count++;
45
                {
46
                        String[] unitName={"Unitless"};
47
                        unitNameList.add(count,unitName);
48
                        addUnitName(count,"Adimensional");
49
                }
50
                
51
        }
52
        
53
        private void defineProjectionParameterList() throws CrsException
54
        {
55
                int count=0;
56

    
57
                { // azimuth
58
                        String[] parameterName={"azimuth"};
59
                        projectionParameterNameList.add(count,parameterName);
60
                        addProjectionParameterName(count,"Azimuth of initial line");                
61
                        addProjectionParameterName(count,"AzimuthAngle");                
62

    
63
                        String[] parameterUnit={"Angular"};
64
                        projectionParameterUnitList.add(count,parameterUnit);
65
                }
66

    
67
                count++;
68
                { // central_meridian
69
                        String[] parameterName={"central_meridian"};
70
                        projectionParameterNameList.add(count,parameterName);
71
                        addProjectionParameterName(count,"Longitude of natural origin");                
72
                        addProjectionParameterName(count,"NatOriginLong");                
73
                        addProjectionParameterName(count,"Longitude of projection center");
74
                        addProjectionParameterName(count,"ProjCenterLong");
75
                        addProjectionParameterName(count,"Longitude of false origin");                
76
                        addProjectionParameterName(count,"FalseOriginLong");                
77
                        addProjectionParameterName(count,"StraightVertPoleLong");                
78
                        
79
                        String[] parameterUnit={"Angular"};
80
                        projectionParameterUnitList.add(count,parameterUnit);
81
                }
82
                
83
                count++;
84
                { // false_easting
85
                        String[] parameterName={"false_easting"};
86
                        projectionParameterNameList.add(count,parameterName);
87
                        addProjectionParameterName(count,"Easting of false origin");                
88
                        addProjectionParameterName(count,"FalseEasting");                
89
                        addProjectionParameterName(count,"FalseOriginEasting");                
90

    
91
                        String[] parameterUnit={"Linear"};
92
                        projectionParameterUnitList.add(count,parameterUnit);
93
                }
94
                
95
                count++;
96
                { // false_northing
97
                        String[] parameterName={"false_northing"};
98
                        projectionParameterNameList.add(count,parameterName);
99
                        addProjectionParameterName(count,"Northing of false origin");                
100
                        addProjectionParameterName(count,"FalseNorthing");                
101
                        addProjectionParameterName(count,"FalseOriginNorthing");                
102

    
103
                        String[] parameterUnit={"Linear"};
104
                        projectionParameterUnitList.add(count,parameterUnit);
105
                }
106

    
107
                count++;
108
                { // latitude_of_center
109
                        String[] parameterName={"latitude_of_center"};
110
                        projectionParameterNameList.add(count,parameterName);
111
                        addProjectionParameterName(count,"Latitude of false origin");                
112
                        addProjectionParameterName(count,"NatOriginLat");                
113
                        addProjectionParameterName(count,"CenterLat");                
114

    
115
                        String[] parameterUnit={"Angular"};
116
                        projectionParameterUnitList.add(count,parameterUnit);
117
                }
118

    
119
                count++;
120
                { // latitude_of_origin
121
                        String[] parameterName={"latitude_of_origin"};
122
                        projectionParameterNameList.add(count,parameterName);
123
                        addProjectionParameterName(count,"Latitude of natural origin");
124
                        addProjectionParameterName(count,"NatOriginLat");
125
                        addProjectionParameterName(count,"Latitude of projection center");
126
                        addProjectionParameterName(count,"ProjCenterLat");
127
                        addProjectionParameterName(count,"Latitude of false origin");                
128
                        addProjectionParameterName(count,"FalseOriginLat");
129
                        
130
                        String[] parameterUnit={"Angular"};
131
                        projectionParameterUnitList.add(count,parameterUnit);
132
                }
133

    
134
                count++;
135
                { // longitude_of_center
136
                        String[] parameterName={"longitude_of_center"};
137
                        projectionParameterNameList.add(count,parameterName);
138
                        addProjectionParameterName(count,"Longitude of false origin");                
139
                        addProjectionParameterName(count,"NatOriginLong");                
140
                        addProjectionParameterName(count,"CenterLong");                
141

    
142
                        String[] parameterUnit={"Angular"};
143
                        projectionParameterUnitList.add(count,parameterUnit);
144
                }
145

    
146
                count++;
147
                { // pseudo_standard_parallel_1
148
                        String[] parameterName={"pseudo_standard_parallel_1"};
149
                        projectionParameterNameList.add(count,parameterName);
150
                        addProjectionParameterName(count,"Latitude of Pseudo Standard Parallel");                
151

    
152
                        String[] parameterUnit={"Angular"};
153
                        projectionParameterUnitList.add(count,parameterUnit);
154
                }
155
                
156
                count++;
157
                { // satellite_height
158
                        String[] parameterName={"satellite_height"};
159
                        projectionParameterNameList.add(count,parameterName);
160
                        addProjectionParameterName(count,"Satellite Height");                
161

    
162
                        String[] parameterUnit={"Linear"};
163
                        projectionParameterUnitList.add(count,parameterUnit);
164
                }
165
                
166
                count++;
167
                { // scale_factor
168
                        String[] parameterName={"scale_factor"};
169
                        projectionParameterNameList.add(count,parameterName);
170
                        addProjectionParameterName(count,"Scale factor at natural origin");                
171
                        addProjectionParameterName(count,"ScaleAtNatOrigin");                
172
                        addProjectionParameterName(count,"ScaleAtCenter");                
173

    
174
                        String[] parameterUnit={"Unitless"};
175
                        projectionParameterUnitList.add(count,parameterUnit);
176
                }
177

    
178
                count++;
179
                { // standard_parallel_1
180
                        String[] parameterName={"standard_parallel_1"};
181
                        projectionParameterNameList.add(count,parameterName);
182
                        addProjectionParameterName(count,"Latitude of first standard parallel");                
183
                        addProjectionParameterName(count,"StdParallel1");                
184

    
185
                        String[] parameterUnit={"Angular"};
186
                        projectionParameterUnitList.add(count,parameterUnit);
187
                }
188

    
189
                count++;
190
                { // standard_parallel_2
191
                        String[] parameterName={"standard_parallel_2"};
192
                        projectionParameterNameList.add(count,parameterName);
193
                        addProjectionParameterName(count,"Latitude of second standard parallel");                
194
                        addProjectionParameterName(count,"StdParallel2");                
195

    
196
                        String[] parameterUnit={"Angular"};
197
                        projectionParameterUnitList.add(count,parameterUnit);
198
                }
199

    
200
                count++;
201
                { // semi_major
202
                        String[] parameterName={"semi_major"};
203
                        projectionParameterNameList.add(count,parameterName);
204
                        addProjectionParameterName(count,"semi_major_axis");                
205

    
206
                        String[] parameterUnit={"Linear"};
207
                        projectionParameterUnitList.add(count,parameterUnit);
208
                }
209

    
210
                count++;
211
                { // semi_minor
212
                        String[] parameterName={"semi_minor"};
213
                        projectionParameterNameList.add(count,parameterName);
214
                        addProjectionParameterName(count,"semi_minor_axis");                
215

    
216
                        String[] parameterUnit={"Linear"};
217
                        projectionParameterUnitList.add(count,parameterUnit);
218
                }
219

    
220
        }
221
        
222
        private void defineProjections() throws CrsException
223
        {
224
                int count=0;
225
                
226
                {// Albers Equal-Area Conic
227
                        String[] projectionName={"Albers_Conic_Equal_Area"};
228
                        projectionNameList.add(count,projectionName);
229
                        addProjectionName(count,"Albers Equal-Area Conic");
230
                        addProjectionName(count,"9822");
231
                        
232
                        String[] parameterName={"standard_parallel_1"};
233
                        projectionParameterList.add(count,parameterName);
234
                        addProjectionParameter(count,"standard_parallel_2");
235
                        addProjectionParameter(count,"latitude_of_center");
236
                        addProjectionParameter(count,"longitude_of_center");
237
                        addProjectionParameter(count,"false_easting");
238
                        addProjectionParameter(count,"false_northing");
239

    
240
                        String[] parameterAcronym={"lat_1"};
241
                        projectionParameterAcronymList.add(count,parameterAcronym);
242
                        addProjectionParameterAcronymList(count,"lat_2");
243
                        addProjectionParameterAcronymList(count,"lat_0");
244
                        addProjectionParameterAcronymList(count,"lon_0");
245
                        addProjectionParameterAcronymList(count,"x_0");
246
                        addProjectionParameterAcronymList(count,"y_0");
247

    
248
                        String[] parameterDefaultValue={"0.0"};
249
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
250
                        addProjectionParameterDefaultValue(count,"0.0");
251
                        addProjectionParameterDefaultValue(count,"0.0");
252
                        addProjectionParameterDefaultValue(count,"0.0");
253
                        addProjectionParameterDefaultValue(count,"0.0");
254
                        addProjectionParameterDefaultValue(count,"0.0");
255

    
256
                        String[] parameterMaxValue={"90.0"};
257
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
258
                        addProjectionParameterMaxValue(count,"90.0");
259
                        addProjectionParameterMaxValue(count,"90.0");
260
                        addProjectionParameterMaxValue(count,"360.0");
261
                        addProjectionParameterMaxValue(count,"100000000.0");
262
                        addProjectionParameterMaxValue(count,"100000000.0");
263

    
264
                        String[] parameterMinValue={"-90.0"};
265
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
266
                        addProjectionParameterMinValue(count,"-90.0");
267
                        addProjectionParameterMinValue(count,"-90.0");
268
                        addProjectionParameterMinValue(count,"-360.0");
269
                        addProjectionParameterMinValue(count,"-100000000.0");
270
                        addProjectionParameterMinValue(count,"-100000000.0");
271

    
272
                        String[] projectionAcronym={"aea"};
273
                        projectionAcronymList.add(count,projectionAcronym);
274
                }
275
                
276
                count++;
277
                {// Azimuthal_Equidistantt
278
                        String[] projectionName={"Azimuthal_Equidistant"};
279
                        projectionNameList.add(count,projectionName);
280
                        addProjectionName(count,"Azimuthal Equidistant");
281
                        
282
                        String[] parameterName={"latitude_of_center"};
283
                        projectionParameterList.add(count,parameterName);
284
                        addProjectionParameter(count,"longitude_of_center");
285
                        addProjectionParameter(count,"false_easting");
286
                        addProjectionParameter(count,"false_northing");
287

    
288
                        String[] parameterAcronym={"lat_0"};
289
                        projectionParameterAcronymList.add(count,parameterAcronym);
290
                        addProjectionParameterAcronymList(count,"lon_0");
291
                        addProjectionParameterAcronymList(count,"x_0");
292
                        addProjectionParameterAcronymList(count,"y_0");
293

    
294
                        String[] parameterDefaultValue={"0.0"};
295
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
296
                        addProjectionParameterDefaultValue(count,"0.0");
297
                        addProjectionParameterDefaultValue(count,"0.0");
298
                        addProjectionParameterDefaultValue(count,"0.0");
299

    
300
                        String[] parameterMaxValue={"90.0"};
301
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
302
                        addProjectionParameterMaxValue(count,"360.0");
303
                        addProjectionParameterMaxValue(count,"100000000.0");
304
                        addProjectionParameterMaxValue(count,"100000000.0");
305

    
306
                        String[] parameterMinValue={"-90.0"};
307
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
308
                        addProjectionParameterMinValue(count,"-360.0");
309
                        addProjectionParameterMinValue(count,"-100000000.0");
310
                        addProjectionParameterMinValue(count,"-100000000.0");
311

    
312
                        String[] projectionAcronym={"aeqd"};
313
                        projectionAcronymList.add(count,projectionAcronym);
314
                }
315

    
316
                count++;
317
                {// Bonne
318
                        String[] projectionName={"Bonne"};
319
                        projectionNameList.add(count,projectionName);
320
                        addProjectionName(count,"Bonne");
321

    
322
                        String[] parameterName={"central_meridian"};
323
                        projectionParameterList.add(count,parameterName);
324
                        addProjectionParameter(count,"standard_parallel_1");
325
                        addProjectionParameter(count,"false_easting");
326
                        addProjectionParameter(count,"false_northing");
327

    
328
                        String[] parameterAcronym={"lon_0"};
329
                        projectionParameterAcronymList.add(count,parameterAcronym);
330
                        addProjectionParameterAcronymList(count,"lat_1");
331
                        addProjectionParameterAcronymList(count,"x_0");
332
                        addProjectionParameterAcronymList(count,"y_0");
333

    
334
                        String[] parameterDefaultValue={"0.0"};
335
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
336
                        addProjectionParameterDefaultValue(count,"0.0");
337
                        addProjectionParameterDefaultValue(count,"0.0");
338
                        addProjectionParameterDefaultValue(count,"0.0");
339

    
340
                        String[] parameterMaxValue={"360.0"};
341
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
342
                        addProjectionParameterMaxValue(count,"90.0");
343
                        addProjectionParameterMaxValue(count,"100000000.0");
344
                        addProjectionParameterMaxValue(count,"100000000.0");
345

    
346
                        String[] parameterMinValue={"-360.0"};
347
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
348
                        addProjectionParameterMinValue(count,"-90.0");
349
                        addProjectionParameterMinValue(count,"-100000000.0");
350
                        addProjectionParameterMinValue(count,"-100000000.0");
351

    
352
                        String[] projectionAcronym={"bonne"};
353
                        projectionAcronymList.add(count,projectionAcronym);
354
                }
355
                
356
                count++;
357
                {// Cassini_Soldner
358
                        String[] projectionName={"Cassini_Soldner"};
359
                        projectionNameList.add(count,projectionName);
360
                        addProjectionName(count,"Cassini-Soldner");
361
                        addProjectionName(count,"9806");
362

    
363
                        String[] parameterName={"latitude_of_origin"};
364
                        projectionParameterList.add(count,parameterName);
365
                        addProjectionParameter(count,"central_meridian");
366
                        addProjectionParameter(count,"false_easting");
367
                        addProjectionParameter(count,"false_northing");
368

    
369
                        String[] parameterAcronym={"lat_0"};
370
                        projectionParameterAcronymList.add(count,parameterAcronym);
371
                        addProjectionParameterAcronymList(count,"lon_0");
372
                        addProjectionParameterAcronymList(count,"x_0");
373
                        addProjectionParameterAcronymList(count,"y_0");
374

    
375
                        String[] parameterDefaultValue={"0.0"};
376
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
377
                        addProjectionParameterDefaultValue(count,"0.0");
378
                        addProjectionParameterDefaultValue(count,"0.0");
379
                        addProjectionParameterDefaultValue(count,"0.0");
380

    
381
                        String[] parameterMaxValue={"90.0"};
382
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
383
                        addProjectionParameterMaxValue(count,"360.0");
384
                        addProjectionParameterMaxValue(count,"100000000.0");
385
                        addProjectionParameterMaxValue(count,"100000000.0");
386

    
387
                        String[] parameterMinValue={"-90.0"};
388
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
389
                        addProjectionParameterMinValue(count,"-360.0");
390
                        addProjectionParameterMinValue(count,"-100000000.0");
391
                        addProjectionParameterMinValue(count,"-100000000.0");
392

    
393
                        String[] projectionAcronym={"cass"};
394
                        projectionAcronymList.add(count,projectionAcronym);
395
                }
396

    
397
                count++;
398
                {// Cylindrical_Equal_Area
399
                        String[] projectionName={"Cylindrical_Equal_Area"};
400
                        projectionNameList.add(count,projectionName);
401
                        addProjectionName(count,"Cylindrical Equal Area");
402
                        addProjectionName(count,"Normal Authalic Cylindrical (FME)");
403
                        addProjectionName(count,"Lambert Cylindrical Equal Area");
404
                        addProjectionName(count,"Behrmann (standard parallel = 30)");
405
                        addProjectionName(count,"Gall Orthographic (standard parallel = 45)");
406
                        addProjectionName(count,"Peters (approximated by Gall Orthographic)");
407

    
408
                        String[] parameterName={"central_meridian"};
409
                        projectionParameterList.add(count,parameterName);
410
                        addProjectionParameter(count,"standard_parallel_1");
411
                        addProjectionParameter(count,"false_easting");
412
                        addProjectionParameter(count,"false_northing");
413

    
414
                        String[] parameterAcronym={"lon_0"};
415
                        projectionParameterAcronymList.add(count,parameterAcronym);
416
                        addProjectionParameterAcronymList(count,"lat_ts");
417
                        addProjectionParameterAcronymList(count,"x_0");
418
                        addProjectionParameterAcronymList(count,"y_0");
419

    
420
                        String[] parameterDefaultValue={"0.0"};
421
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
422
                        addProjectionParameterDefaultValue(count,"0.0");
423
                        addProjectionParameterDefaultValue(count,"0.0");
424
                        addProjectionParameterDefaultValue(count,"0.0");
425

    
426
                        String[] parameterMaxValue={"360.0"};
427
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
428
                        addProjectionParameterMaxValue(count,"90.0");
429
                        addProjectionParameterMaxValue(count,"100000000.0");
430
                        addProjectionParameterMaxValue(count,"100000000.0");
431

    
432
                        String[] parameterMinValue={"-360.0"};
433
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
434
                        addProjectionParameterMinValue(count,"-90.0");
435
                        addProjectionParameterMinValue(count,"-100000000.0");
436
                        addProjectionParameterMinValue(count,"-100000000.0");
437

    
438
                        String[] projectionAcronym={"cea"};
439
                        projectionAcronymList.add(count,projectionAcronym);
440
                }
441

    
442
                count++;
443
                {// Eckert_IV
444
                        String[] projectionName={"Eckert_IV"};
445
                        projectionNameList.add(count,projectionName);
446
                        addProjectionName(count,"Eckert IV");
447

    
448
                        String[] parameterName={"central_meridian"};
449
                        projectionParameterList.add(count,parameterName);
450
                        addProjectionParameter(count,"false_easting");
451
                        addProjectionParameter(count,"false_northing");
452

    
453
                        String[] parameterAcronym={"lon_0"};
454
                        projectionParameterAcronymList.add(count,parameterAcronym);
455
                        addProjectionParameterAcronymList(count,"x_0");
456
                        addProjectionParameterAcronymList(count,"y_0");
457

    
458
                        String[] parameterDefaultValue={"0.0"};
459
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
460
                        addProjectionParameterDefaultValue(count,"0.0");
461
                        addProjectionParameterDefaultValue(count,"0.0");
462

    
463
                        String[] parameterMaxValue={"360.0"};
464
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
465
                        addProjectionParameterMaxValue(count,"100000000.0");
466
                        addProjectionParameterMaxValue(count,"100000000.0");
467

    
468
                        String[] parameterMinValue={"-360.0"};
469
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
470
                        addProjectionParameterMinValue(count,"-100000000.0");
471
                        addProjectionParameterMinValue(count,"-100000000.0");
472

    
473
                        String[] projectionAcronym={"eck4"};
474
                        projectionAcronymList.add(count,projectionAcronym);
475
                }
476

    
477
                count++;
478
                {// Eckert_VI
479
                        String[] projectionName={"Eckert_VI"};
480
                        projectionNameList.add(count,projectionName);
481
                        addProjectionName(count,"Eckert VI");
482

    
483
                        String[] parameterName={"central_meridian"};
484
                        projectionParameterList.add(count,parameterName);
485
                        addProjectionParameter(count,"false_easting");
486
                        addProjectionParameter(count,"false_northing");
487

    
488
                        String[] parameterAcronym={"lon_0"};
489
                        projectionParameterAcronymList.add(count,parameterAcronym);
490
                        addProjectionParameterAcronymList(count,"x_0");
491
                        addProjectionParameterAcronymList(count,"y_0");
492

    
493
                        String[] parameterDefaultValue={"0.0"};
494
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
495
                        addProjectionParameterDefaultValue(count,"0.0");
496
                        addProjectionParameterDefaultValue(count,"0.0");
497

    
498
                        String[] parameterMaxValue={"360.0"};
499
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
500
                        addProjectionParameterMaxValue(count,"100000000.0");
501
                        addProjectionParameterMaxValue(count,"100000000.0");
502

    
503
                        String[] parameterMinValue={"-360.0"};
504
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
505
                        addProjectionParameterMinValue(count,"-100000000.0");
506
                        addProjectionParameterMinValue(count,"-100000000.0");
507

    
508
                        String[] projectionAcronym={"eck6"};
509
                        projectionAcronymList.add(count,projectionAcronym);
510
                }
511
                
512
                count++;
513
                {// Equidistant_Conic
514
                        String[] projectionName={"Equidistant_Conic"};
515
                        projectionNameList.add(count,projectionName);
516
                        addProjectionName(count,"Equidistant Conic");
517
                        
518
                        String[] parameterName={"latitude_of_center"};
519
                        projectionParameterList.add(count,parameterName);
520
                        addProjectionParameter(count,"longitude_of_center");
521
                        addProjectionParameter(count,"standard_parallel_1");
522
                        addProjectionParameter(count,"standard_parallel_2");
523
                        addProjectionParameter(count,"false_easting");
524
                        addProjectionParameter(count,"false_northing");
525

    
526
                        String[] parameterAcronym={"lat_0"};
527
                        projectionParameterAcronymList.add(count,parameterAcronym);
528
                        addProjectionParameterAcronymList(count,"lon_0");
529
                        addProjectionParameterAcronymList(count,"lat_1");
530
                        addProjectionParameterAcronymList(count,"lat_2");
531
                        addProjectionParameterAcronymList(count,"x_0");
532
                        addProjectionParameterAcronymList(count,"y_0");
533

    
534
                        String[] parameterDefaultValue={"0.0"};
535
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
536
                        addProjectionParameterDefaultValue(count,"0.0");
537
                        addProjectionParameterDefaultValue(count,"0.0");
538
                        addProjectionParameterDefaultValue(count,"0.0");
539
                        addProjectionParameterDefaultValue(count,"0.0");
540
                        addProjectionParameterDefaultValue(count,"0.0");
541

    
542
                        String[] parameterMaxValue={"90.0"};
543
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
544
                        addProjectionParameterMaxValue(count,"360.0");
545
                        addProjectionParameterMaxValue(count,"90.0");
546
                        addProjectionParameterMaxValue(count,"90.0");
547
                        addProjectionParameterMaxValue(count,"100000000.0");
548
                        addProjectionParameterMaxValue(count,"100000000.0");
549

    
550
                        String[] parameterMinValue={"-90.0"};
551
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
552
                        addProjectionParameterMinValue(count,"-360.0");
553
                        addProjectionParameterMinValue(count,"-90.0");
554
                        addProjectionParameterMinValue(count,"-90.0");
555
                        addProjectionParameterMinValue(count,"-100000000.0");
556
                        addProjectionParameterMinValue(count,"-100000000.0");
557

    
558
                        String[] projectionAcronym={"eqdc"};
559
                        projectionAcronymList.add(count,projectionAcronym);
560
                }
561

    
562
                count++;
563
                {// Equirectangular
564
                        String[] projectionName={"Equirectangular"};
565
                        projectionNameList.add(count,projectionName);
566
                        addProjectionName(count,"Plate Caree");
567
                        addProjectionName(count,"Equidistant Cylindrical");
568
                        addProjectionName(count,"9823");
569

    
570
                        String[] parameterName={"latitude_of_origin"};
571
                        projectionParameterList.add(count,parameterName);
572
                        addProjectionParameter(count,"central_meridian");
573
                        addProjectionParameter(count,"false_easting");
574
                        addProjectionParameter(count,"false_northing");
575

    
576
                        String[] parameterAcronym={"lat_ts"};
577
                        projectionParameterAcronymList.add(count,parameterAcronym);
578
                        addProjectionParameterAcronymList(count,"lon_0");
579
                        addProjectionParameterAcronymList(count,"x_0");
580
                        addProjectionParameterAcronymList(count,"y_0");
581

    
582
                        String[] parameterDefaultValue={"0.0"};
583
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
584
                        addProjectionParameterDefaultValue(count,"0.0");
585
                        addProjectionParameterDefaultValue(count,"0.0");
586
                        addProjectionParameterDefaultValue(count,"0.0");
587

    
588
                        String[] parameterMaxValue={"90.0"};
589
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
590
                        addProjectionParameterMaxValue(count,"360.0");
591
                        addProjectionParameterMaxValue(count,"100000000.0");
592
                        addProjectionParameterMaxValue(count,"100000000.0");
593

    
594
                        String[] parameterMinValue={"-90.0"};
595
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
596
                        addProjectionParameterMinValue(count,"-360.0");
597
                        addProjectionParameterMinValue(count,"-100000000.0");
598
                        addProjectionParameterMinValue(count,"-100000000.0");
599

    
600
                        String[] projectionAcronym={"eqc"};
601
                        projectionAcronymList.add(count,projectionAcronym);
602
                }
603

    
604
                count++;
605
                {// Gall_Stereographic
606
                        String[] projectionName={"Gall_Stereographic"};
607
                        projectionNameList.add(count,projectionName);
608
                        addProjectionName(count,"Gall Stereograpic");
609
                        addProjectionName(count,"Gall");
610

    
611
                        String[] parameterName={"central_meridian"};
612
                        projectionParameterList.add(count,parameterName);
613
                        addProjectionParameter(count,"false_easting");
614
                        addProjectionParameter(count,"false_northing");
615

    
616
                        String[] parameterAcronym={"lon_0"};
617
                        projectionParameterAcronymList.add(count,parameterAcronym);
618
                        addProjectionParameterAcronymList(count,"x_0");
619
                        addProjectionParameterAcronymList(count,"y_0");
620

    
621
                        String[] parameterDefaultValue={"0.0"};
622
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
623
                        addProjectionParameterDefaultValue(count,"0.0");
624
                        addProjectionParameterDefaultValue(count,"0.0");
625

    
626
                        String[] parameterMaxValue={"360.0"};
627
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
628
                        addProjectionParameterMaxValue(count,"100000000.0");
629
                        addProjectionParameterMaxValue(count,"100000000.0");
630

    
631
                        String[] parameterMinValue={"-360.0"};
632
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
633
                        addProjectionParameterMinValue(count,"-100000000.0");
634
                        addProjectionParameterMinValue(count,"-100000000.0");
635

    
636
                        String[] projectionAcronym={"gall"};
637
                        projectionAcronymList.add(count,projectionAcronym);
638
                }
639

    
640
                count++;
641
                {// GEOS
642
                        String[] projectionName={"GEOS"};
643
                        projectionNameList.add(count,projectionName);
644
                        addProjectionName(count,"Geostationary Satellite View");
645
                        addProjectionName(count,"Normalized Geostationary Projection");
646

    
647
                        String[] parameterName={"central_meridian"};
648
                        projectionParameterList.add(count,parameterName);
649
                        addProjectionParameter(count,"satellite_height");
650
                        addProjectionParameter(count,"false_easting");
651
                        addProjectionParameter(count,"false_northing");
652

    
653
                        String[] parameterAcronym={"lon_0"};
654
                        projectionParameterAcronymList.add(count,parameterAcronym);
655
                        addProjectionParameterAcronymList(count,"h");
656
                        addProjectionParameterAcronymList(count,"y_0");
657

    
658
                        String[] parameterDefaultValue={"0.0"};
659
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
660
                        addProjectionParameterDefaultValue(count,"35785831.0");
661
                        addProjectionParameterDefaultValue(count,"0.0");
662
                        addProjectionParameterDefaultValue(count,"0.0");
663

    
664
                        String[] parameterMaxValue={"360.0"};
665
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
666
                        addProjectionParameterMaxValue(count,"100000000.0");
667
                        addProjectionParameterMaxValue(count,"100000000.0");
668
                        addProjectionParameterMaxValue(count,"100000000.0");
669

    
670
                        String[] parameterMinValue={"-360.0"};
671
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
672
                        addProjectionParameterMinValue(count,"-100000000.0");
673
                        addProjectionParameterMinValue(count,"-100000000.0");
674
                        addProjectionParameterMinValue(count,"-100000000.0");
675

    
676
                        String[] projectionAcronym={"geos"};
677
                        projectionAcronymList.add(count,projectionAcronym);
678
                }
679

    
680
                count++;
681
                {// Gnomonic
682
                        String[] projectionName={"Gnomonic"};
683
                        projectionNameList.add(count,projectionName);
684
                        addProjectionName(count,"Gnomonic");
685

    
686
                        String[] parameterName={"latitude_of_origin"};
687
                        projectionParameterList.add(count,parameterName);
688
                        addProjectionParameter(count,"central_meridian");
689
                        addProjectionParameter(count,"false_easting");
690
                        addProjectionParameter(count,"false_northing");
691

    
692
                        String[] parameterAcronym={"lat_0"};
693
                        projectionParameterAcronymList.add(count,parameterAcronym);
694
                        addProjectionParameterAcronymList(count,"lon_0");
695
                        addProjectionParameterAcronymList(count,"x_0");
696
                        addProjectionParameterAcronymList(count,"y_0");
697

    
698
                        String[] parameterDefaultValue={"0.0"};
699
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
700
                        addProjectionParameterDefaultValue(count,"0.0");
701
                        addProjectionParameterDefaultValue(count,"0.0");
702
                        addProjectionParameterDefaultValue(count,"0.0");
703

    
704
                        String[] parameterMaxValue={"90.0"};
705
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
706
                        addProjectionParameterMaxValue(count,"360.0");
707
                        addProjectionParameterMaxValue(count,"100000000.0");
708
                        addProjectionParameterMaxValue(count,"100000000.0");
709

    
710
                        String[] parameterMinValue={"-90.0"};
711
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
712
                        addProjectionParameterMinValue(count,"-360.0");
713
                        addProjectionParameterMinValue(count,"-100000000.0");
714
                        addProjectionParameterMinValue(count,"-100000000.0");
715

    
716
                        String[] projectionAcronym={"gnom"};
717
                        projectionAcronymList.add(count,projectionAcronym);
718
                }
719

    
720
                count++;
721
                {// Goode
722
                        String[] projectionName={"Goode"};
723
                        projectionNameList.add(count,projectionName);
724

    
725
                        String[] parameterName={"central_meridian"};
726
                        projectionParameterList.add(count,parameterName);
727
                        addProjectionParameter(count,"false_easting");
728
                        addProjectionParameter(count,"false_northing");
729

    
730
                        String[] parameterAcronym={"lon_0"};
731
                        projectionParameterAcronymList.add(count,parameterAcronym);
732
                        addProjectionParameterAcronymList(count,"x_0");
733
                        addProjectionParameterAcronymList(count,"y_0");
734

    
735
                        String[] parameterDefaultValue={"0.0"};
736
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
737
                        addProjectionParameterDefaultValue(count,"0.0");
738
                        addProjectionParameterDefaultValue(count,"0.0");
739

    
740
                        String[] parameterMaxValue={"360.0"};
741
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
742
                        addProjectionParameterMaxValue(count,"100000000.0");
743
                        addProjectionParameterMaxValue(count,"100000000.0");
744

    
745
                        String[] parameterMinValue={"-360.0"};
746
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
747
                        addProjectionParameterMinValue(count,"-100000000.0");
748
                        addProjectionParameterMinValue(count,"-100000000.0");
749

    
750
                        String[] projectionAcronym={"goode"};
751
                        projectionAcronymList.add(count,projectionAcronym);
752
                }
753

    
754
                count++;
755
                {// hotine_oblique_mercator
756
                        String[] projectionName={"hotine_oblique_mercator"};
757
                        projectionNameList.add(count,projectionName);
758
                        addProjectionName(count,"Hotine Oblique Mercator");
759
                        addProjectionName(count,"9812");
760

    
761
                        String[] parameterName={"latitude_of_center"};
762
                        projectionParameterList.add(count,parameterName);
763
                        addProjectionParameter(count,"longitude_of_center");
764
                        addProjectionParameter(count,"azimuth");
765
                        //addProjectionParameter(count,"rectified_grid_angle");
766
                        addProjectionParameter(count,"scale_factor");
767
                        addProjectionParameter(count,"false_easting");
768
                        addProjectionParameter(count,"false_northing");
769

    
770
                        String[] parameterAcronym={"lat_0"};
771
                        projectionParameterAcronymList.add(count,parameterAcronym);
772
                        addProjectionParameterAcronymList(count,"lonc");
773
                        addProjectionParameterAcronymList(count,"alpha");
774
                        addProjectionParameterAcronymList(count,"k");
775
                        addProjectionParameterAcronymList(count,"x_0");
776
                        addProjectionParameterAcronymList(count,"y_0");
777

    
778
                        String[] parameterDefaultValue={"0.0"};
779
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
780
                        addProjectionParameterDefaultValue(count,"0.0");
781
                        addProjectionParameterDefaultValue(count,"1.0");
782
                        addProjectionParameterDefaultValue(count,"0.0");
783
                        addProjectionParameterDefaultValue(count,"0.0");
784

    
785
                        String[] parameterMaxValue={"90.0"};
786
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
787
                        addProjectionParameterMaxValue(count,"360.0");
788
                        addProjectionParameterMaxValue(count,"360.0");
789
                        addProjectionParameterMaxValue(count,"10.0");
790
                        addProjectionParameterMaxValue(count,"100000000.0");
791
                        addProjectionParameterMaxValue(count,"100000000.0");
792

    
793
                        String[] parameterMinValue={"-90.0"};
794
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
795
                        addProjectionParameterMinValue(count,"-360.0");
796
                        addProjectionParameterMinValue(count,"-360.0");
797
                        addProjectionParameterMinValue(count,"0.0");
798
                        addProjectionParameterMinValue(count,"-100000000.0");
799
                        addProjectionParameterMinValue(count,"-100000000.0");
800

    
801
                        String[] projectionAcronym={"omerc"};
802
                        projectionAcronymList.add(count,projectionAcronym);
803
                }
804
                
805
                count++;
806
                {// Krovak
807
                        String[] projectionName={"Krovak"};
808
                        projectionNameList.add(count,projectionName);
809
                        addProjectionName(count,"Krovak Oblique Conic Conformal");
810
                        addProjectionName(count,"9819");
811

    
812
                        String[] parameterName={"latitude_of_center"};
813
                        projectionParameterList.add(count,parameterName);
814
                        addProjectionParameter(count,"longitude_of_center");
815
                        addProjectionParameter(count,"azimuth");
816
                        addProjectionParameter(count,"scale_factor");
817
                        addProjectionParameter(count,"false_easting");
818
                        addProjectionParameter(count,"false_northing");
819

    
820
                        String[] parameterAcronym={"lat_0"};
821
                        projectionParameterAcronymList.add(count,parameterAcronym);
822
                        addProjectionParameterAcronymList(count,"lon_0");
823
                        addProjectionParameterAcronymList(count,"alpha");
824
                        addProjectionParameterAcronymList(count,"k");
825
                        addProjectionParameterAcronymList(count,"x_0");
826
                        addProjectionParameterAcronymList(count,"y_0");
827

    
828
                        String[] parameterDefaultValue={"0.0"};
829
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
830
                        addProjectionParameterDefaultValue(count,"0.0");
831
                        addProjectionParameterDefaultValue(count,"0.0");
832
                        addProjectionParameterDefaultValue(count,"1.0");
833
                        addProjectionParameterDefaultValue(count,"0.0");
834
                        addProjectionParameterDefaultValue(count,"0.0");
835

    
836
                        String[] parameterMaxValue={"90.0"};
837
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
838
                        addProjectionParameterMaxValue(count,"360.0");
839
                        addProjectionParameterMaxValue(count,"360.0");
840
                        addProjectionParameterMaxValue(count,"10.0");
841
                        addProjectionParameterMaxValue(count,"100000000.0");
842
                        addProjectionParameterMaxValue(count,"100000000.0");
843

    
844
                        String[] parameterMinValue={"-90.0"};
845
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
846
                        addProjectionParameterMinValue(count,"-360.0");
847
                        addProjectionParameterMinValue(count,"-360.0");
848
                        addProjectionParameterMinValue(count,"0.0");
849
                        addProjectionParameterMinValue(count,"-100000000.0");
850
                        addProjectionParameterMinValue(count,"-100000000.0");
851

    
852
                        String[] projectionAcronym={"krovak"};
853
                        projectionAcronymList.add(count,projectionAcronym);
854
                }
855
                
856
                // Laborde_Oblique_Mercator - Similar a hotine_oblique_mercator
857

    
858
                count++;
859
                {// Lambert_Azimuthal_Equal_Area
860
                        String[] projectionName={"Lambert_Azimuthal_Equal_Area"};
861
                        projectionNameList.add(count,projectionName);
862
                        addProjectionName(count,"Lambert Azimuthal Equal Area");
863
                        addProjectionName(count,"9820");
864

    
865
                        String[] parameterName={"latitude_of_center"};
866
                        projectionParameterList.add(count,parameterName);
867
                        addProjectionParameter(count,"longitude_of_center");
868
                        addProjectionParameter(count,"false_easting");
869
                        addProjectionParameter(count,"false_northing");
870

    
871
                        String[] parameterAcronym={"lat_0"};
872
                        projectionParameterAcronymList.add(count,parameterAcronym);
873
                        addProjectionParameterAcronymList(count,"lon_0");
874
                        addProjectionParameterAcronymList(count,"x_0");
875
                        addProjectionParameterAcronymList(count,"y_0");
876

    
877
                        String[] parameterDefaultValue={"0.0"};
878
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
879
                        addProjectionParameterDefaultValue(count,"0.0");
880
                        addProjectionParameterDefaultValue(count,"0.0");
881
                        addProjectionParameterDefaultValue(count,"0.0");
882

    
883
                        String[] parameterMaxValue={"90.0"};
884
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
885
                        addProjectionParameterMaxValue(count,"360.0");
886
                        addProjectionParameterMaxValue(count,"100000000.0");
887
                        addProjectionParameterMaxValue(count,"100000000.0");
888

    
889
                        String[] parameterMinValue={"-90.0"};
890
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
891
                        addProjectionParameterMinValue(count,"-360.0");
892
                        addProjectionParameterMinValue(count,"-100000000.0");
893
                        addProjectionParameterMinValue(count,"-100000000.0");
894

    
895
                        String[] projectionAcronym={"laea"};
896
                        projectionAcronymList.add(count,projectionAcronym);
897
                }
898
                
899
                count++;
900
                {// Lambert_Conformal_Conic_1SP
901
                        String[] projectionName={"Lambert_Conformal_Conic_1SP"};
902
                        projectionNameList.add(count,projectionName);
903
                        addProjectionName(count,"Lambert Conic Conformal (1SP)");
904
                        addProjectionName(count,"9801");
905

    
906
                        String[] parameterName={"latitude_of_origin"};
907
                        projectionParameterList.add(count,parameterName);
908
                        addProjectionParameter(count,"latitude_of_origin"); // lat_1=lat_0
909
                        addProjectionParameter(count,"central_meridian");
910
                        addProjectionParameter(count,"scale_factor");
911
                        addProjectionParameter(count,"false_easting");
912
                        addProjectionParameter(count,"false_northing");
913

    
914
                        String[] parameterAcronym={"lat_1"};
915
                        projectionParameterAcronymList.add(count,parameterAcronym);
916
                        addProjectionParameterAcronymList(count,"lat_0");
917
                        addProjectionParameterAcronymList(count,"lon_0");
918
                        addProjectionParameterAcronymList(count,"k_0");
919
                        addProjectionParameterAcronymList(count,"x_0");
920
                        addProjectionParameterAcronymList(count,"y_0");
921

    
922
                        String[] parameterDefaultValue={"0.0"};
923
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
924
                        addProjectionParameterDefaultValue(count,"0.0");
925
                        addProjectionParameterDefaultValue(count,"0.0");
926
                        addProjectionParameterDefaultValue(count,"1.0");
927
                        addProjectionParameterDefaultValue(count,"0.0");
928
                        addProjectionParameterDefaultValue(count,"0.0");
929

    
930
                        String[] parameterMaxValue={"90.0"};
931
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
932
                        addProjectionParameterMaxValue(count,"90.0");
933
                        addProjectionParameterMaxValue(count,"360.0");
934
                        addProjectionParameterMaxValue(count,"10.0");
935
                        addProjectionParameterMaxValue(count,"100000000.0");
936
                        addProjectionParameterMaxValue(count,"100000000.0");
937

    
938
                        String[] parameterMinValue={"-90.0"};
939
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
940
                        addProjectionParameterMinValue(count,"-90.0");
941
                        addProjectionParameterMinValue(count,"-360.0");
942
                        addProjectionParameterMinValue(count,"0.0");
943
                        addProjectionParameterMinValue(count,"-100000000.0");
944
                        addProjectionParameterMinValue(count,"-100000000.0");
945

    
946
                        String[] projectionAcronym={"lcc"};
947
                        projectionAcronymList.add(count,projectionAcronym);
948
                }
949
                
950
                count++;
951
                {// Lambert_Conformal_Conic_2SP
952
                        String[] projectionName={"Lambert_Conformal_Conic_2SP"};
953
                        projectionNameList.add(count,projectionName);
954
                        addProjectionName(count,"Lambert Conic Conformal (2SP)");
955
                        addProjectionName(count,"9802");
956

    
957
                        String[] parameterName={"standard_parallel_1"};
958
                        projectionParameterList.add(count,parameterName);
959
                        addProjectionParameter(count,"standard_parallel_2");
960
                        addProjectionParameter(count,"latitude_of_origin");
961
                        addProjectionParameter(count,"central_meridian");
962
                        addProjectionParameter(count,"false_easting");
963
                        addProjectionParameter(count,"false_northing");
964

    
965
                        String[] parameterAcronym={"lat_1"};
966
                        projectionParameterAcronymList.add(count,parameterAcronym);
967
                        addProjectionParameterAcronymList(count,"lat_2");
968
                        addProjectionParameterAcronymList(count,"lat_0");
969
                        addProjectionParameterAcronymList(count,"lon_0");
970
                        addProjectionParameterAcronymList(count,"x_0");
971
                        addProjectionParameterAcronymList(count,"y_0");
972

    
973
                        String[] parameterDefaultValue={"0.0"};
974
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
975
                        addProjectionParameterDefaultValue(count,"0.0");
976
                        addProjectionParameterDefaultValue(count,"0.0");
977
                        addProjectionParameterDefaultValue(count,"0.0");
978
                        addProjectionParameterDefaultValue(count,"0.0");
979
                        addProjectionParameterDefaultValue(count,"0.0");
980

    
981
                        String[] parameterMaxValue={"90.0"};
982
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
983
                        addProjectionParameterMaxValue(count,"90.0");
984
                        addProjectionParameterMaxValue(count,"90.0");
985
                        addProjectionParameterMaxValue(count,"360.0");
986
                        addProjectionParameterMaxValue(count,"100000000.0");
987
                        addProjectionParameterMaxValue(count,"100000000.0");
988

    
989
                        String[] parameterMinValue={"-90.0"};
990
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
991
                        addProjectionParameterMinValue(count,"-90.0");
992
                        addProjectionParameterMinValue(count,"-90.0");
993
                        addProjectionParameterMinValue(count,"-360.0");
994
                        addProjectionParameterMinValue(count,"-100000000.0");
995
                        addProjectionParameterMinValue(count,"-100000000.0");
996

    
997
                        String[] projectionAcronym={"lcc"};
998
                        projectionAcronymList.add(count,projectionAcronym);
999
                }
1000
                
1001
                count++;
1002
                {// Lambert_Conformal_Conic_2SP_Belgium
1003
                        String[] projectionName={"Lambert_Conformal_Conic_2SP_Belgium"};
1004
                        projectionNameList.add(count,projectionName);
1005
                        addProjectionName(count,"Lambert Conic Conformal (2SP Belgium)");
1006
                        addProjectionName(count,"9803");
1007

    
1008
                        String[] parameterName={"standard_parallel_1"};
1009
                        projectionParameterList.add(count,parameterName);
1010
                        addProjectionParameter(count,"standard_parallel_2");
1011
                        addProjectionParameter(count,"latitude_of_origin");
1012
                        addProjectionParameter(count,"central_meridian");
1013
                        addProjectionParameter(count,"false_easting");
1014
                        addProjectionParameter(count,"false_northing");
1015

    
1016
                        String[] parameterAcronym={"lat_1"};
1017
                        projectionParameterAcronymList.add(count,parameterAcronym);
1018
                        addProjectionParameterAcronymList(count,"lat_2");
1019
                        addProjectionParameterAcronymList(count,"lat_0");
1020
                        addProjectionParameterAcronymList(count,"lon_0");
1021
                        addProjectionParameterAcronymList(count,"x_0");
1022
                        addProjectionParameterAcronymList(count,"y_0");
1023

    
1024
                        String[] parameterDefaultValue={"0.0"};
1025
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1026
                        addProjectionParameterDefaultValue(count,"0.0");
1027
                        addProjectionParameterDefaultValue(count,"0.0");
1028
                        addProjectionParameterDefaultValue(count,"0.0");
1029
                        addProjectionParameterDefaultValue(count,"0.0");
1030
                        addProjectionParameterDefaultValue(count,"0.0");
1031

    
1032
                        String[] parameterMaxValue={"90.0"};
1033
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1034
                        addProjectionParameterMaxValue(count,"90.0");
1035
                        addProjectionParameterMaxValue(count,"90.0");
1036
                        addProjectionParameterMaxValue(count,"360.0");
1037
                        addProjectionParameterMaxValue(count,"100000000.0");
1038
                        addProjectionParameterMaxValue(count,"100000000.0");
1039

    
1040
                        String[] parameterMinValue={"-90.0"};
1041
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1042
                        addProjectionParameterMinValue(count,"-90.0");
1043
                        addProjectionParameterMinValue(count,"-90.0");
1044
                        addProjectionParameterMinValue(count,"-360.0");
1045
                        addProjectionParameterMinValue(count,"-100000000.0");
1046
                        addProjectionParameterMinValue(count,"-100000000.0");
1047

    
1048
                        String[] projectionAcronym={"lcc"};
1049
                        projectionAcronymList.add(count,projectionAcronym);
1050
                }
1051
                
1052
                count++;
1053
                {// Mercator_1SP
1054
                        String[] projectionName={"Mercator_1SP"};
1055
                        projectionNameList.add(count,projectionName);
1056
                        addProjectionName(count,"Mercator");
1057
                        addProjectionName(count,"9804");
1058

    
1059
                        String[] parameterName={"central_meridian"};
1060
                        projectionParameterList.add(count,parameterName);
1061
                        addProjectionParameter(count,"scale_factor");  // o latitude_origin
1062
                        addProjectionParameter(count,"false_easting");
1063
                        addProjectionParameter(count,"false_northing");
1064

    
1065
                        String[] parameterAcronym={"lon_0"};
1066
                        projectionParameterAcronymList.add(count,parameterAcronym);
1067
                        addProjectionParameterAcronymList(count,"k"); // o lat_ts
1068
                        addProjectionParameterAcronymList(count,"x_0");
1069
                        addProjectionParameterAcronymList(count,"y_0");
1070

    
1071
                        String[] parameterDefaultValue={"0.0"};
1072
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1073
                        addProjectionParameterDefaultValue(count,"1.0"); // o 0.0
1074
                        addProjectionParameterDefaultValue(count,"0.0");
1075
                        addProjectionParameterDefaultValue(count,"0.0");
1076

    
1077
                        String[] parameterMaxValue={"360.0"};
1078
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1079
                        addProjectionParameterMaxValue(count,"10.0");
1080
                        addProjectionParameterMaxValue(count,"100000000.0");
1081
                        addProjectionParameterMaxValue(count,"100000000.0");
1082

    
1083
                        String[] parameterMinValue={"-360.0"};
1084
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1085
                        addProjectionParameterMinValue(count,"0.0");
1086
                        addProjectionParameterMinValue(count,"-100000000.0");
1087
                        addProjectionParameterMinValue(count,"-100000000.0");
1088

    
1089
                        String[] projectionAcronym={"merc"};
1090
                        projectionAcronymList.add(count,projectionAcronym);
1091
                }
1092
                
1093
                count++;
1094
                {// Mercator_2SP
1095
                        String[] projectionName={"Mercator_2SP"};
1096
                        projectionNameList.add(count,projectionName);
1097
                        addProjectionName(count,"Mercator");
1098
                        addProjectionName(count,"9805");
1099

    
1100
                        String[] parameterName={"central_meridian"};
1101
                        projectionParameterList.add(count,parameterName);
1102
                        addProjectionParameter(count,"standard_parallel_1");
1103
                        addProjectionParameter(count,"false_easting");
1104
                        addProjectionParameter(count,"false_northing");
1105

    
1106
                        String[] parameterAcronym={"lon_0"};
1107
                        projectionParameterAcronymList.add(count,parameterAcronym);
1108
                        addProjectionParameterAcronymList(count,"lat_ts");
1109
                        addProjectionParameterAcronymList(count,"x_0");
1110
                        addProjectionParameterAcronymList(count,"y_0");
1111

    
1112
                        String[] parameterDefaultValue={"0.0"};
1113
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1114
                        addProjectionParameterDefaultValue(count,"0.0"); // o 0.0
1115
                        addProjectionParameterDefaultValue(count,"0.0");
1116
                        addProjectionParameterDefaultValue(count,"0.0");
1117

    
1118
                        String[] parameterMaxValue={"360.0"};
1119
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1120
                        addProjectionParameterMaxValue(count,"90.0");
1121
                        addProjectionParameterMaxValue(count,"100000000.0");
1122
                        addProjectionParameterMaxValue(count,"100000000.0");
1123

    
1124
                        String[] parameterMinValue={"-360.0"};
1125
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1126
                        addProjectionParameterMinValue(count,"-90.0");
1127
                        addProjectionParameterMinValue(count,"-100000000.0");
1128
                        addProjectionParameterMinValue(count,"-100000000.0");
1129

    
1130
                        String[] projectionAcronym={"merc"};
1131
                        projectionAcronymList.add(count,projectionAcronym);
1132
                }
1133

    
1134
                count++;
1135
                {// Miller_Cylindrical
1136
                        String[] projectionName={"Miller_Cylindrical"};
1137
                        projectionNameList.add(count,projectionName);
1138
                        addProjectionName(count,"Miller Cylindrical");
1139

    
1140
                        String[] parameterName={"latitude_of_center"};
1141
                        projectionParameterList.add(count,parameterName);
1142
                        addProjectionParameter(count,"longitude_of_center");
1143
                        addProjectionParameter(count,"false_easting");
1144
                        addProjectionParameter(count,"false_northing");
1145

    
1146
                        String[] parameterAcronym={"lat_0"};
1147
                        projectionParameterAcronymList.add(count,parameterAcronym);
1148
                        addProjectionParameterAcronymList(count,"lon_0");
1149
                        addProjectionParameterAcronymList(count,"x_0");
1150
                        addProjectionParameterAcronymList(count,"y_0");
1151

    
1152
                        String[] parameterDefaultValue={"0.0"};
1153
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1154
                        addProjectionParameterDefaultValue(count,"0.0");
1155
                        addProjectionParameterDefaultValue(count,"0.0");
1156
                        addProjectionParameterDefaultValue(count,"0.0");
1157

    
1158
                        String[] parameterMaxValue={"90.0"};
1159
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1160
                        addProjectionParameterMaxValue(count,"360.0");
1161
                        addProjectionParameterMaxValue(count,"100000000.0");
1162
                        addProjectionParameterMaxValue(count,"100000000.0");
1163

    
1164
                        String[] parameterMinValue={"-90.0"};
1165
                        addProjectionParameterMinValue(count,"-360.0");
1166
                        addProjectionParameterMinValue(count,"-100000000.0");
1167
                        addProjectionParameterMinValue(count,"-100000000.0");
1168

    
1169
                        String[] projectionAcronym={"mill"};
1170
                        projectionAcronymList.add(count,projectionAcronym);
1171
                }
1172
                
1173
                count++;
1174
                {// Mollweide
1175
                        String[] projectionName={"Mollweide"};
1176
                        projectionNameList.add(count,projectionName);
1177
                        addProjectionName(count,"Hornolographic");
1178
                        addProjectionName(count,"Babinet");
1179
                        addProjectionName(count,"Elliptical");
1180

    
1181
                        String[] parameterName={"central_meridian"};
1182
                        projectionParameterList.add(count,parameterName);
1183
                        addProjectionParameter(count,"false_easting");
1184
                        addProjectionParameter(count,"false_northing");
1185

    
1186
                        String[] parameterAcronym={"lon_0"};
1187
                        projectionParameterAcronymList.add(count,parameterAcronym);
1188
                        addProjectionParameterAcronymList(count,"x_0");
1189
                        addProjectionParameterAcronymList(count,"y_0");
1190

    
1191
                        String[] parameterDefaultValue={"0.0"};
1192
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1193
                        addProjectionParameterDefaultValue(count,"0.0");
1194
                        addProjectionParameterDefaultValue(count,"0.0");
1195

    
1196
                        String[] parameterMaxValue={"360.0"};
1197
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1198
                        addProjectionParameterMaxValue(count,"100000000.0");
1199
                        addProjectionParameterMaxValue(count,"100000000.0");
1200

    
1201
                        String[] parameterMinValue={"-360.0"};
1202
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1203
                        addProjectionParameterMinValue(count,"-100000000.0");
1204
                        addProjectionParameterMinValue(count,"-100000000.0");
1205

    
1206
                        String[] projectionAcronym={"moll"};
1207
                        projectionAcronymList.add(count,projectionAcronym);
1208
                }
1209

    
1210
                count++;
1211
                {// New_Zealand_Map_Grid
1212
                        String[] projectionName={"New_Zealand_Map_Grid"};
1213
                        projectionNameList.add(count,projectionName);
1214
                        addProjectionName(count,"New Zealand Map Grid");
1215
                        addProjectionName(count,"9811");
1216

    
1217
                        String[] parameterName={"latitude_of_origin"};
1218
                        projectionParameterList.add(count,parameterName);
1219
                        addProjectionParameter(count,"central_meridian");
1220
                        addProjectionParameter(count,"false_easting");
1221
                        addProjectionParameter(count,"fase_northing");
1222

    
1223
                        String[] parameterAcronym={"lat_0"};
1224
                        projectionParameterAcronymList.add(count,parameterAcronym);
1225
                        addProjectionParameterAcronymList(count,"lon_0");
1226
                        addProjectionParameterAcronymList(count,"x_0");
1227
                        addProjectionParameterAcronymList(count,"y_0");
1228

    
1229
                        String[] parameterDefaultValue={"0.0"};
1230
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1231
                        addProjectionParameterDefaultValue(count,"0.0");
1232
                        addProjectionParameterDefaultValue(count,"0.0");
1233
                        addProjectionParameterDefaultValue(count,"0.0");
1234

    
1235
                        String[] parameterMaxValue={"90.0"};
1236
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1237
                        addProjectionParameterMaxValue(count,"360.0");
1238
                        addProjectionParameterMaxValue(count,"100000000.0");
1239
                        addProjectionParameterMaxValue(count,"100000000.0");
1240

    
1241
                        String[] parameterMinValue={"-90.0"};
1242
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1243
                        addProjectionParameterMinValue(count,"-360.0");
1244
                        addProjectionParameterMinValue(count,"-100000000.0");
1245
                        addProjectionParameterMinValue(count,"-100000000.0");
1246

    
1247
                        String[] projectionAcronym={"nzmg"};
1248
                        projectionAcronymList.add(count,projectionAcronym);
1249
                }
1250

    
1251
                count++;
1252
                {// Oblique_Mercator
1253
                        String[] projectionName={"Oblique_Mercator"};
1254
                        projectionNameList.add(count,projectionName);
1255
                        addProjectionName(count,"Oblique Mercator");
1256
                        addProjectionName(count,"9815");
1257

    
1258
                        String[] parameterName={"latitude_of_center"};
1259
                        projectionParameterList.add(count,parameterName);
1260
                        addProjectionParameter(count,"longitude_of_center");
1261
                        addProjectionParameter(count,"azimuth");
1262
                        //addProjectionParameter(count,"rectified_grid_angle");
1263
                        addProjectionParameter(count,"scale_factor");
1264
                        addProjectionParameter(count,"false_easting");
1265
                        addProjectionParameter(count,"fase_northing");
1266

    
1267
                        String[] parameterAcronym={"lat_0"};
1268
                        projectionParameterAcronymList.add(count,parameterAcronym);
1269
                        addProjectionParameterAcronymList(count,"lonc");
1270
                        addProjectionParameterAcronymList(count,"alpha");
1271
                        addProjectionParameterAcronymList(count,"k");
1272
                        addProjectionParameterAcronymList(count,"x_0");
1273
                        addProjectionParameterAcronymList(count,"y_0");
1274

    
1275
                        String[] parameterDefaultValue={"0.0"};
1276
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1277
                        addProjectionParameterDefaultValue(count,"0.0");
1278
                        addProjectionParameterDefaultValue(count,"1.0");
1279
                        addProjectionParameterDefaultValue(count,"0.0");
1280
                        addProjectionParameterDefaultValue(count,"0.0");
1281

    
1282
                        String[] parameterMaxValue={"90.0"};
1283
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1284
                        addProjectionParameterMaxValue(count,"360.0");
1285
                        addProjectionParameterMaxValue(count,"360.0");
1286
                        addProjectionParameterMaxValue(count,"10.0");
1287
                        addProjectionParameterMaxValue(count,"100000000.0");
1288
                        addProjectionParameterMaxValue(count,"100000000.0");
1289

    
1290
                        String[] parameterMinValue={"-90.0"};
1291
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1292
                        addProjectionParameterMinValue(count,"-360.0");
1293
                        addProjectionParameterMinValue(count,"-360.0");
1294
                        addProjectionParameterMinValue(count,"0.0");
1295
                        addProjectionParameterMinValue(count,"-100000000.0");
1296
                        addProjectionParameterMinValue(count,"-100000000.0");
1297

    
1298
                        String[] projectionAcronym={"omerc"};
1299
                        projectionAcronymList.add(count,projectionAcronym);
1300
                }
1301

    
1302
                count++;
1303
                {// Oblique_Stereographic
1304
                        String[] projectionName={"Oblique_Stereographic"};
1305
                        projectionNameList.add(count,projectionName);
1306
                        addProjectionName(count,"Oblique Stereographic");
1307
                        addProjectionName(count,"9809");
1308

    
1309
                        String[] parameterName={"latitude_of_origin"};
1310
                        projectionParameterList.add(count,parameterName);
1311
                        addProjectionParameter(count,"central_meridian");
1312
                        addProjectionParameter(count,"scale_factor");
1313
                        addProjectionParameter(count,"false_easting");
1314
                        addProjectionParameter(count,"fase_northing");
1315

    
1316
                        String[] parameterAcronym={"lat_0"};
1317
                        projectionParameterAcronymList.add(count,parameterAcronym);
1318
                        addProjectionParameterAcronymList(count,"lon_0");
1319
                        addProjectionParameterAcronymList(count,"k");
1320
                        addProjectionParameterAcronymList(count,"x_0");
1321
                        addProjectionParameterAcronymList(count,"y_0");
1322

    
1323
                        String[] parameterDefaultValue={"0.0"};
1324
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1325
                        addProjectionParameterDefaultValue(count,"0.0");
1326
                        addProjectionParameterDefaultValue(count,"1.0");
1327
                        addProjectionParameterDefaultValue(count,"0.0");
1328
                        addProjectionParameterDefaultValue(count,"0.0");
1329

    
1330
                        String[] parameterMaxValue={"90.0"};
1331
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1332
                        addProjectionParameterMaxValue(count,"360.0");
1333
                        addProjectionParameterMaxValue(count,"10.0");
1334
                        addProjectionParameterMaxValue(count,"100000000.0");
1335
                        addProjectionParameterMaxValue(count,"100000000.0");
1336

    
1337
                        String[] parameterMinValue={"-90.0"};
1338
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1339
                        addProjectionParameterMinValue(count,"-360.0");
1340
                        addProjectionParameterMinValue(count,"0.0");
1341
                        addProjectionParameterMinValue(count,"-100000000.0");
1342
                        addProjectionParameterMinValue(count,"-100000000.0");
1343

    
1344
                        String[] projectionAcronym={"sterea"};
1345
                        projectionAcronymList.add(count,projectionAcronym);
1346
                }
1347

    
1348
                count++;
1349
                {// Orthographic
1350
                        String[] projectionName={"Orthographic"};
1351
                        projectionNameList.add(count,projectionName);
1352

    
1353
                        String[] parameterName={"latitude_of_origin"};
1354
                        projectionParameterList.add(count,parameterName);
1355
                        addProjectionParameter(count,"central_meridian");
1356
                        addProjectionParameter(count,"false_easting");
1357
                        addProjectionParameter(count,"fase_northing");
1358

    
1359
                        String[] parameterAcronym={"lat_0"};
1360
                        projectionParameterAcronymList.add(count,parameterAcronym);
1361
                        addProjectionParameterAcronymList(count,"lon_0");
1362
                        addProjectionParameterAcronymList(count,"x_0");
1363
                        addProjectionParameterAcronymList(count,"y_0");
1364

    
1365
                        String[] parameterDefaultValue={"0.0"};
1366
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1367
                        addProjectionParameterDefaultValue(count,"0.0");
1368
                        addProjectionParameterDefaultValue(count,"0.0");
1369
                        addProjectionParameterDefaultValue(count,"0.0");
1370

    
1371
                        String[] parameterMaxValue={"90.0"};
1372
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1373
                        addProjectionParameterMaxValue(count,"360.0");
1374
                        addProjectionParameterMaxValue(count,"100000000.0");
1375
                        addProjectionParameterMaxValue(count,"100000000.0");
1376

    
1377
                        String[] parameterMinValue={"-90.0"};
1378
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1379
                        addProjectionParameterMinValue(count,"-360.0");
1380
                        addProjectionParameterMinValue(count,"-100000000.0");
1381
                        addProjectionParameterMinValue(count,"-100000000.0");
1382

    
1383
                        String[] projectionAcronym={"ortho"};
1384
                        projectionAcronymList.add(count,projectionAcronym);
1385
                }
1386

    
1387
                count++;
1388
                {// Polar_Stereographic
1389
                        String[] projectionName={"Polar_Stereographic"};
1390
                        projectionNameList.add(count,projectionName);
1391
                        addProjectionName(count,"Polar Stereographic");
1392
                        addProjectionName(count,"9810");
1393

    
1394
                        String[] parameterName={"latitude_of_origin"};
1395
                        projectionParameterList.add(count,parameterName);
1396
                        addProjectionParameter(count,"latitude_of_origin");
1397
                        addProjectionParameter(count,"central_meridian");
1398
                        addProjectionParameter(count,"scale_factor");
1399
                        addProjectionParameter(count,"false_easting");
1400
                        addProjectionParameter(count,"fase_northing");
1401

    
1402
                        String[] parameterAcronym={"lat_0"};
1403
                        //lat_0=90 o lat_0=-90
1404
                        projectionParameterAcronymList.add(count,parameterAcronym);
1405
                        addProjectionParameterAcronymList(count,"lat_ts");
1406
                        addProjectionParameterAcronymList(count,"lon_0");
1407
                        addProjectionParameterAcronymList(count,"k");
1408
                        addProjectionParameterAcronymList(count,"x_0");
1409
                        addProjectionParameterAcronymList(count,"y_0");
1410

    
1411
                        String[] parameterDefaultValue={"90.0"};
1412
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1413
                        addProjectionParameterDefaultValue(count,"90.0");
1414
                        addProjectionParameterDefaultValue(count,"0.0");
1415
                        addProjectionParameterDefaultValue(count,"1.0");
1416
                        addProjectionParameterDefaultValue(count,"0.0");
1417
                        addProjectionParameterDefaultValue(count,"0.0");
1418

    
1419
                        String[] parameterMaxValue={"90.0"};
1420
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1421
                        addProjectionParameterMaxValue(count,"90.0");
1422
                        addProjectionParameterMaxValue(count,"360.0");
1423
                        addProjectionParameterMaxValue(count,"10.0");
1424
                        addProjectionParameterMaxValue(count,"100000000.0");
1425
                        addProjectionParameterMaxValue(count,"100000000.0");
1426

    
1427
                        String[] parameterMinValue={"-90.0"};
1428
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1429
                        addProjectionParameterMinValue(count,"-90.0");
1430
                        addProjectionParameterMinValue(count,"-360.0");
1431
                        addProjectionParameterMinValue(count,"0.0");
1432
                        addProjectionParameterMinValue(count,"-100000000.0");
1433
                        addProjectionParameterMinValue(count,"-100000000.0");
1434

    
1435
                        String[] projectionAcronym={"stere"};
1436
                        projectionAcronymList.add(count,projectionAcronym);
1437
                }
1438

    
1439
                count++;
1440
                {// Polyconic
1441
                        String[] projectionName={"Polyconic"};
1442
                        projectionNameList.add(count,projectionName);
1443

    
1444
                        String[] parameterName={"latitude_of_origin"};
1445
                        projectionParameterList.add(count,parameterName);
1446
                        addProjectionParameter(count,"central_meridian");
1447
                        addProjectionParameter(count,"false_easting");
1448
                        addProjectionParameter(count,"fase_northing");
1449

    
1450
                        String[] parameterAcronym={"lat_0"};
1451
                        projectionParameterAcronymList.add(count,parameterAcronym);
1452
                        addProjectionParameterAcronymList(count,"lon_0");
1453
                        addProjectionParameterAcronymList(count,"x_0");
1454
                        addProjectionParameterAcronymList(count,"y_0");
1455

    
1456
                        String[] parameterDefaultValue={"0.0"};
1457
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1458
                        addProjectionParameterDefaultValue(count,"0.0");
1459
                        addProjectionParameterDefaultValue(count,"0.0");
1460
                        addProjectionParameterDefaultValue(count,"0.0");
1461

    
1462
                        String[] parameterMaxValue={"90.0"};
1463
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1464
                        addProjectionParameterMaxValue(count,"360.0");
1465
                        addProjectionParameterMaxValue(count,"100000000.0");
1466
                        addProjectionParameterMaxValue(count,"100000000.0");
1467

    
1468
                        String[] parameterMinValue={"-90.0"};
1469
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1470
                        addProjectionParameterMinValue(count,"-360.0");
1471
                        addProjectionParameterMinValue(count,"-100000000.0");
1472
                        addProjectionParameterMinValue(count,"-100000000.0");
1473

    
1474
                        String[] projectionAcronym={"poly"};
1475
                        projectionAcronymList.add(count,projectionAcronym);
1476
                }
1477

    
1478
                count++;
1479
                {// Robinson
1480
                        String[] projectionName={"Robinson"};
1481
                        projectionNameList.add(count,projectionName);
1482

    
1483
                        String[] parameterName={"longitude_of_center"};
1484
                        projectionParameterList.add(count,parameterName);
1485
                        addProjectionParameter(count,"false_easting");
1486
                        addProjectionParameter(count,"fase_northing");
1487

    
1488
                        String[] parameterAcronym={"lon_0"};
1489
                        projectionParameterAcronymList.add(count,parameterAcronym);
1490
                        addProjectionParameterAcronymList(count,"x_0");
1491
                        addProjectionParameterAcronymList(count,"y_0");
1492

    
1493
                        String[] parameterDefaultValue={"0.0"};
1494
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1495
                        addProjectionParameterDefaultValue(count,"0.0");
1496
                        addProjectionParameterDefaultValue(count,"0.0");
1497

    
1498
                        String[] parameterMaxValue={"360.0"};
1499
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1500
                        addProjectionParameterMaxValue(count,"100000000.0");
1501
                        addProjectionParameterMaxValue(count,"100000000.0");
1502

    
1503
                        String[] parameterMinValue={"-360.0"};
1504
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1505
                        addProjectionParameterMinValue(count,"-100000000.0");
1506
                        addProjectionParameterMinValue(count,"-100000000.0");
1507

    
1508
                        String[] projectionAcronym={"robin"};
1509
                        projectionAcronymList.add(count,projectionAcronym);
1510
                }
1511

    
1512
                //         Rosenmund Oblique Mercator - No en EPSG
1513

    
1514
                count++;
1515
                {// Sinusoidal
1516
                        String[] projectionName={"Sinusoidal"};
1517
                        projectionNameList.add(count,projectionName);
1518

    
1519
                        String[] parameterName={"longitude_of_center"};
1520
                        projectionParameterList.add(count,parameterName);
1521
                        addProjectionParameter(count,"false_easting");
1522
                        addProjectionParameter(count,"fase_northing");
1523

    
1524
                        String[] parameterAcronym={"lon_0"};
1525
                        projectionParameterAcronymList.add(count,parameterAcronym);
1526
                        addProjectionParameterAcronymList(count,"x_0");
1527
                        addProjectionParameterAcronymList(count,"y_0");
1528

    
1529
                        String[] parameterDefaultValue={"0.0"};
1530
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1531
                        addProjectionParameterDefaultValue(count,"0.0");
1532
                        addProjectionParameterDefaultValue(count,"0.0");
1533

    
1534
                        String[] parameterMaxValue={"360.0"};
1535
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1536
                        addProjectionParameterMaxValue(count,"100000000.0");
1537
                        addProjectionParameterMaxValue(count,"100000000.0");
1538

    
1539
                        String[] parameterMinValue={"-360.0"};
1540
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1541
                        addProjectionParameterMinValue(count,"-100000000.0");
1542
                        addProjectionParameterMinValue(count,"-100000000.0");
1543

    
1544
                        String[] projectionAcronym={"sinu"};
1545
                        projectionAcronymList.add(count,projectionAcronym);
1546
                }
1547

    
1548
                count++;
1549
                {// Swiss_Oblique_Cylindrical
1550
                        String[] projectionName={"Swiss_Oblique_Cylindrical"};
1551
                        projectionNameList.add(count,projectionName);
1552
                        addProjectionName(count,"Swiss Oblique Cylindrical");
1553
                        addProjectionName(count,"Swiss Oblique Mercator");
1554
                        addProjectionName(count,"9814");
1555

    
1556
                        String[] parameterName={"latitude_of_origin"};
1557
                        projectionParameterList.add(count,parameterName);
1558
                        addProjectionParameter(count,"central_meridian");
1559
                        addProjectionParameter(count,"false_easting");
1560
                        addProjectionParameter(count,"fase_northing");
1561

    
1562
                        String[] parameterAcronym={"lat_0"};
1563
                        projectionParameterAcronymList.add(count,parameterAcronym);
1564
                        addProjectionParameterAcronymList(count,"lon_0");
1565
                        addProjectionParameterAcronymList(count,"x_0");
1566
                        addProjectionParameterAcronymList(count,"y_0");
1567

    
1568
                        String[] parameterDefaultValue={"0.0"};
1569
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1570
                        addProjectionParameterDefaultValue(count,"0.0");
1571
                        addProjectionParameterDefaultValue(count,"0.0");
1572
                        addProjectionParameterDefaultValue(count,"0.0");
1573

    
1574
                        String[] parameterMaxValue={"90.0"};
1575
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1576
                        addProjectionParameterMaxValue(count,"360.0");
1577
                        addProjectionParameterMaxValue(count,"100000000.0");
1578
                        addProjectionParameterMaxValue(count,"100000000.0");
1579

    
1580
                        String[] parameterMinValue={"-90.0"};
1581
                        addProjectionParameterMinValue(count,"-360.0");
1582
                        addProjectionParameterMinValue(count,"-100000000.0");
1583
                        addProjectionParameterMinValue(count,"-100000000.0");
1584

    
1585
                        String[] projectionAcronym={"somerc"};
1586
                        projectionAcronymList.add(count,projectionAcronym);
1587
                }
1588

    
1589
                count++;
1590
                {// Stereographic
1591
                        String[] projectionName={"Stereographic"};
1592
                        projectionNameList.add(count,projectionName);
1593

    
1594
                        String[] parameterName={"latitude_of_origin"};
1595
                        projectionParameterList.add(count,parameterName);
1596
                        addProjectionParameter(count,"central_meridian");
1597
                        addProjectionParameter(count,"scale_factor");
1598
                        addProjectionParameter(count,"false_easting");
1599
                        addProjectionParameter(count,"fase_northing");
1600

    
1601
                        String[] parameterAcronym={"lat_0"};
1602
                        projectionParameterAcronymList.add(count,parameterAcronym);
1603
                        addProjectionParameterAcronymList(count,"lon_0");
1604
                        addProjectionParameterAcronymList(count,"k");
1605
                        addProjectionParameterAcronymList(count,"x_0");
1606
                        addProjectionParameterAcronymList(count,"y_0");
1607

    
1608
                        String[] parameterDefaultValue={"0.0"};
1609
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1610
                        addProjectionParameterDefaultValue(count,"0.0");
1611
                        addProjectionParameterDefaultValue(count,"1.0");
1612
                        addProjectionParameterDefaultValue(count,"0.0");
1613
                        addProjectionParameterDefaultValue(count,"0.0");
1614

    
1615
                        String[] parameterMaxValue={"90.0"};
1616
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1617
                        addProjectionParameterMaxValue(count,"360.0");
1618
                        addProjectionParameterMaxValue(count,"10.0");
1619
                        addProjectionParameterMaxValue(count,"100000000.0");
1620
                        addProjectionParameterMaxValue(count,"100000000.0");
1621

    
1622
                        String[] parameterMinValue={"-90.0"};
1623
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1624
                        addProjectionParameterMinValue(count,"-360.0");
1625
                        addProjectionParameterMinValue(count,"0.0");
1626
                        addProjectionParameterMinValue(count,"-100000000.0");
1627
                        addProjectionParameterMinValue(count,"-100000000.0");
1628

    
1629
                        String[] projectionAcronym={"stere"};
1630
                        projectionAcronymList.add(count,projectionAcronym);
1631
                }
1632

    
1633
                count++;
1634
                {// Transverse_Mercator
1635
                        String[] projectionName={"Transverse_Mercator"};
1636
                        projectionNameList.add(count,projectionName);
1637
                        addProjectionName(count,"Transverse Mercator");
1638
                        addProjectionName(count,"Gauss-Kruger");
1639
                        addProjectionName(count,"9807");
1640

    
1641
                        String[] parameterName={"latitude_of_origin"};
1642
                        projectionParameterList.add(count,parameterName);
1643
                        addProjectionParameter(count,"central_meridian");
1644
                        addProjectionParameter(count,"scale_factor");
1645
                        addProjectionParameter(count,"false_easting");
1646
                        addProjectionParameter(count,"false_northing");
1647

    
1648
                        String[] parameterAcronym={"lat_0"};
1649
                        projectionParameterAcronymList.add(count,parameterAcronym);
1650
                        addProjectionParameterAcronymList(count,"lon_0");
1651
                        addProjectionParameterAcronymList(count,"k");
1652
                        addProjectionParameterAcronymList(count,"x_0");
1653
                        addProjectionParameterAcronymList(count,"y_0");
1654

    
1655
                        String[] parameterDefaultValue={"0.0"};
1656
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1657
                        addProjectionParameterDefaultValue(count,"0.0");
1658
                        addProjectionParameterDefaultValue(count,"1.0");
1659
                        addProjectionParameterDefaultValue(count,"0.0");
1660
                        addProjectionParameterDefaultValue(count,"0.0");
1661

    
1662
                        String[] parameterMaxValue={"90.0"};
1663
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1664
                        addProjectionParameterMaxValue(count,"360.0");
1665
                        addProjectionParameterMaxValue(count,"10.0");
1666
                        addProjectionParameterMaxValue(count,"100000000.0");
1667
                        addProjectionParameterMaxValue(count,"100000000.0");
1668

    
1669
                        String[] parameterMinValue={"-90.0"};
1670
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1671
                        addProjectionParameterMinValue(count,"-360.0");
1672
                        addProjectionParameterMinValue(count,"0.0");
1673
                        addProjectionParameterMinValue(count,"-100000000.0");
1674
                        addProjectionParameterMinValue(count,"-100000000.0");
1675

    
1676
                        String[] projectionAcronym={"tmerc"};
1677
                        projectionAcronymList.add(count,projectionAcronym);
1678
                }
1679

    
1680
                //         Transverse Mercator (Modified Alaska) - No en EPSG
1681

    
1682
                count++;
1683
                {// Transverse_Mercator_South_Orientated
1684
                        String[] projectionName={"Transverse_Mercator_South_Orientated"};
1685
                        projectionNameList.add(count,projectionName);
1686
                        addProjectionName(count,"Transverse Mercator (South Oriented)");
1687
                        addProjectionName(count,"9808");
1688

    
1689
                        String[] parameterName={"latitude_of_origin"};
1690
                        projectionParameterList.add(count,parameterName);
1691
                        addProjectionParameter(count,"central_meridian");
1692
                        addProjectionParameter(count,"scale_factor");
1693
                        addProjectionParameter(count,"false_easting");
1694
                        addProjectionParameter(count,"fase_northing");
1695

    
1696
                        String[] parameterAcronym={"lat_0"};
1697
                        projectionParameterAcronymList.add(count,parameterAcronym);
1698
                        addProjectionParameterAcronymList(count,"lon_0");
1699
                        addProjectionParameterAcronymList(count,"k");
1700
                        addProjectionParameterAcronymList(count,"x_0");
1701
                        addProjectionParameterAcronymList(count,"y_0");
1702

    
1703
                        String[] parameterDefaultValue={"0.0"};
1704
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1705
                        addProjectionParameterDefaultValue(count,"0.0");
1706
                        addProjectionParameterDefaultValue(count,"1.0");
1707
                        addProjectionParameterDefaultValue(count,"0.0");
1708
                        addProjectionParameterDefaultValue(count,"0.0");
1709

    
1710
                        String[] parameterMaxValue={"90.0"};
1711
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1712
                        addProjectionParameterMaxValue(count,"360.0");
1713
                        addProjectionParameterMaxValue(count,"10.0");
1714
                        addProjectionParameterMaxValue(count,"100000000.0");
1715
                        addProjectionParameterMaxValue(count,"100000000.0");
1716

    
1717
                        String[] parameterMinValue={"-90.0"};
1718
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1719
                        addProjectionParameterMinValue(count,"-360.0");
1720
                        addProjectionParameterMinValue(count,"0.0");
1721
                        addProjectionParameterMinValue(count,"-100000000.0");
1722
                        addProjectionParameterMinValue(count,"-100000000.0");
1723

    
1724
                        String[] projectionAcronym={"tmerc"};
1725
                        projectionAcronymList.add(count,projectionAcronym);
1726
                }
1727

    
1728
                /*
1729
                count++;
1730
                {// Tunisia_Mining_Grid
1731
                        String[] projectionName={"Tunisia_Mining_Grid"};
1732
                        projectionNameList.add(count,projectionName);
1733
                        addProjectionName(count,"Tunisia Mining Grid");
1734
                        addProjectionName(count,"9816");
1735

1736
                        String[] parameterName={"latitude_of_origin"};
1737
                        projectionParameterList.add(count,parameterName);
1738
                        addProjectionParameter(count,"central_meridian");
1739
                        addProjectionParameter(count,"false_easting");
1740
                        addProjectionParameter(count,"fase_northing");
1741
                }
1742
                */
1743

    
1744
                count++;
1745
                {// VanDerGrinten
1746
                        String[] projectionName={"VanDerGrinten"};
1747
                        projectionNameList.add(count,projectionName);
1748
                        addProjectionName(count,"VanDerGrinten I");
1749

    
1750
                        String[] parameterName={"central_meridian"};
1751
                        projectionParameterList.add(count,parameterName);
1752
                        addProjectionParameter(count,"false_easting");
1753
                        addProjectionParameter(count,"fase_northing");
1754

    
1755
                        String[] parameterAcronym={"lon_0"};
1756
                        projectionParameterAcronymList.add(count,parameterAcronym);
1757
                        addProjectionParameterAcronymList(count,"x_0");
1758
                        addProjectionParameterAcronymList(count,"y_0");
1759

    
1760
                        String[] parameterDefaultValue={"0.0"};
1761
                        projectionParameterDefaultValueList.add(count,parameterDefaultValue);
1762
                        addProjectionParameterDefaultValue(count,"0.0");
1763
                        addProjectionParameterDefaultValue(count,"0.0");
1764

    
1765
                        String[] parameterMaxValue={"360.0"};
1766
                        projectionParameterDefaultValueList.add(count,parameterMaxValue);
1767
                        addProjectionParameterMaxValue(count,"100000000.0");
1768
                        addProjectionParameterMaxValue(count,"100000000.0");
1769

    
1770
                        String[] parameterMinValue={"-360.0"};
1771
                        projectionParameterDefaultValueList.add(count,parameterMinValue);
1772
                        addProjectionParameterMinValue(count,"-100000000.0");
1773
                        addProjectionParameterMinValue(count,"-100000000.0");
1774

    
1775
                        String[] projectionAcronym={"sinu"};
1776
                        projectionAcronymList.add(count,projectionAcronym);
1777
                }
1778
        }
1779
        
1780
        public void addProjectionName(int pos,String projectionName) throws CrsException
1781
        {
1782
                if(pos<0||pos>(projectionNameList.size()-1))
1783
                        throw new CrsException(new Exception());
1784
                String[] projectionNames=(String[]) projectionNameList.get(pos);
1785
                String[] newProjectionNames=new String[projectionNames.length+1];
1786
                for(int i=0;i<projectionNames.length;i++)
1787
                {
1788
                        newProjectionNames[i]=projectionNames[i];
1789
                }
1790
                newProjectionNames[projectionNames.length]=projectionName;
1791
                projectionNameList.remove(pos);
1792
                projectionNameList.add(pos,newProjectionNames);
1793
        }
1794
        
1795
        public void addUnitName(int pos,String unitName) throws CrsException
1796
        {
1797
                if(pos<0||pos>(unitNameList.size()-1))
1798
                        throw new CrsException(new Exception());
1799
                String[] unitNames=(String[]) unitNameList.get(pos);
1800
                String[] newUnitNames=new String[unitNames.length+1];
1801
                for(int i=0;i<unitNames.length;i++)
1802
                {
1803
                        newUnitNames[i]=unitNames[i];
1804
                }
1805
                newUnitNames[unitNames.length]=unitName;
1806
                unitNameList.remove(pos);
1807
                unitNameList.add(pos,newUnitNames);
1808
        }
1809
        
1810
        public void addProjectionParameterName(int pos,String projectionParameterName) throws CrsException
1811
        {
1812
                if(pos<0||pos>(projectionParameterNameList.size()-1))
1813
                        throw new CrsException(new Exception());
1814
                String[] projectionParameterNames=(String[]) projectionParameterNameList.get(pos);
1815
                String[] newProjectionParameterNames=new String[projectionParameterNames.length+1];
1816
                for(int i=0;i<projectionParameterNames.length;i++)
1817
                {
1818
                        newProjectionParameterNames[i]=projectionParameterNames[i];
1819
                }
1820
                newProjectionParameterNames[projectionParameterNames.length]=projectionParameterName;
1821
                projectionParameterNameList.remove(pos);
1822
                projectionParameterNameList.add(pos,newProjectionParameterNames);
1823
        }
1824
        
1825
        public void addProjectionParameter(int pos,String projectionParameter) throws CrsException
1826
        {
1827
                if(pos<0||pos>(projectionParameterList.size()-1))
1828
                        throw new CrsException(new Exception());
1829
                String[] projectionParameters=(String[]) projectionParameterList.get(pos);
1830
                String[] newProjectionParameters=new String[projectionParameters.length+1];
1831
                for(int i=0;i<projectionParameters.length;i++)
1832
                {
1833
                        newProjectionParameters[i]=projectionParameters[i];
1834
                }
1835
                newProjectionParameters[projectionParameters.length]=projectionParameter;
1836
                projectionParameterList.remove(pos);
1837
                projectionParameterList.add(pos,newProjectionParameters);
1838
        }
1839
        
1840
        public void addProjectionParameterDefaultValue(int pos,String projectionParameterDefaultValue) throws CrsException
1841
        {
1842
                if(pos<0||pos>(projectionParameterDefaultValueList.size()-1))
1843
                        throw new CrsException(new Exception());
1844
                String[] projectionParameterDefaultValues=(String[]) projectionParameterDefaultValueList.get(pos);
1845
                String[] newProjectionParameterDefaultValues=new String[projectionParameterDefaultValues.length+1];
1846
                for(int i=0;i<projectionParameterDefaultValues.length;i++)
1847
                {
1848
                        newProjectionParameterDefaultValues[i]=projectionParameterDefaultValues[i];
1849
                }
1850
                newProjectionParameterDefaultValues[projectionParameterDefaultValues.length]=projectionParameterDefaultValue;
1851
                projectionParameterDefaultValueList.remove(pos);
1852
                projectionParameterDefaultValueList.add(pos,newProjectionParameterDefaultValues);
1853
        }
1854
        
1855
        public void addProjectionParameterMaxValue(int pos,String projectionParameterMaxValue) throws CrsException
1856
        {
1857
                if(pos<0||pos>(projectionParameterMaxValueList.size()-1))
1858
                        throw new CrsException(new Exception());
1859
                String[] projectionParameterMaxValues=(String[]) projectionParameterMaxValueList.get(pos);
1860
                String[] newProjectionParameterMaxValues=new String[projectionParameterMaxValues.length+1];
1861
                for(int i=0;i<projectionParameterMaxValues.length;i++)
1862
                {
1863
                        newProjectionParameterMaxValues[i]=projectionParameterMaxValues[i];
1864
                }
1865
                newProjectionParameterMaxValues[projectionParameterMaxValues.length]=projectionParameterMaxValue;
1866
                projectionParameterMaxValueList.remove(pos);
1867
                projectionParameterMaxValueList.add(pos,newProjectionParameterMaxValues);
1868
        }
1869
        
1870
        public void addProjectionParameterMinValue(int pos,String projectionParameterMinValue) throws CrsException
1871
        {
1872
                if(pos<0||pos>(projectionParameterMinValueList.size()-1))
1873
                        throw new CrsException(new Exception());
1874
                String[] projectionParameterMinValues=(String[]) projectionParameterMinValueList.get(pos);
1875
                String[] newProjectionParameterMinValues=new String[projectionParameterMinValues.length+1];
1876
                for(int i=0;i<projectionParameterMinValues.length;i++)
1877
                {
1878
                        newProjectionParameterMinValues[i]=projectionParameterMinValues[i];
1879
                }
1880
                newProjectionParameterMinValues[projectionParameterMinValues.length]=projectionParameterMinValue;
1881
                projectionParameterMinValueList.remove(pos);
1882
                projectionParameterMinValueList.add(pos,newProjectionParameterMinValues);
1883
        }
1884
        
1885
        public void addProjectionParameterAcronymList(int pos,String projectionParameterAcronym) throws CrsException
1886
        {
1887
                if(pos<0||pos>(projectionParameterAcronymList.size()-1))
1888
                        throw new CrsException(new Exception());
1889
                String[] projectionParameterAcronyms=(String[]) projectionParameterAcronymList.get(pos);
1890
                String[] newProjectionParameterAcronyms=new String[projectionParameterAcronyms.length+1];
1891
                for(int i=0;i<projectionParameterAcronyms.length;i++)
1892
                {
1893
                        newProjectionParameterAcronyms[i]=projectionParameterAcronyms[i];
1894
                }
1895
                newProjectionParameterAcronyms[projectionParameterAcronyms.length]=projectionParameterAcronym;
1896
                projectionParameterAcronymList.remove(pos);
1897
                projectionParameterAcronymList.add(pos,newProjectionParameterAcronyms);
1898
        }
1899
        
1900
        public int findProjection(String projectionName)
1901
        {
1902
                for(int i=0;i<projectionNameList.size();i++)
1903
                {
1904
                        String[] projectionNames=(String[]) projectionNameList.get(i);
1905
                        for(int j=0;j<projectionNames.length;j++)
1906
                        {
1907
                                if(projectionNames[j].toLowerCase().replaceAll(" ","").equals(projectionName.toLowerCase().replaceAll(" ","")))
1908
                                        return i;
1909
                        }
1910
                }
1911
                        
1912
                return -1;
1913
        }
1914
        
1915
        public int findProjectionParameter(String parameterName)
1916
        {
1917
                for(int i=0;i<projectionParameterNameList.size();i++)
1918
                {
1919
                        String[] parameterNames=(String[]) projectionParameterNameList.get(i);
1920
                        for(int j=0;j<parameterNames.length;j++)
1921
                        {
1922
                                if(parameterNames[j].toLowerCase().replaceAll(" ","").equals(parameterName.toLowerCase().replaceAll(" ","")))
1923
                                        return i;
1924
                        }
1925
                }
1926
                        
1927
                return -1;
1928
        }
1929
        
1930
        public int findUnit(String unitName)
1931
        {
1932
                for(int i=0;i<unitNameList.size();i++)
1933
                {
1934
                        String[] unitNames=(String[]) unitNameList.get(i);
1935
                        for(int j=0;j<unitNames.length;j++)
1936
                        {
1937
                                if(unitNames[j].toLowerCase().replaceAll(" ","").equals(unitName.toLowerCase().replaceAll(" ","")))
1938
                                        return i;
1939
                        }
1940
                }
1941
                        
1942
                return -1;
1943
        }
1944
        
1945
        public String getProj4UnitName(int pos) throws CrsException 
1946
        {
1947
                if(pos<0||pos>(unitNameList.size()-1))
1948
                                throw new CrsException(new Exception());
1949
                return ((String[]) unitNameList.get(pos))[0];
1950
        }
1951
        
1952
        public String getProj4ProjectionName(int pos) throws CrsException 
1953
        {
1954
                if(pos<0||pos>(projectionNameList.size()-1))
1955
                                throw new CrsException(new Exception());
1956
                return ((String[]) projectionNameList.get(pos))[0];
1957
        }
1958
        
1959
        public String getProj4ProjectionParameterName(int pos) throws CrsException 
1960
        {
1961
                // Ojo decir a Jose Luis que quite los parametros del elipsoide
1962
                if(pos<0||pos>(projectionParameterNameList.size()-1))
1963
                                throw new CrsException(new Exception());
1964
                return ((String[]) projectionParameterNameList.get(pos))[0];
1965
        }
1966
        
1967
        public ArrayList getProj4ProjectionParameters(int pos) throws CrsException 
1968
        {
1969
                
1970
                if(pos<0||pos>(projectionParameterList.size()-1))
1971
                                throw new CrsException(new Exception());
1972
                String[] parameterList=(String[])projectionParameterList.get(pos);
1973
                ArrayList parameters=new ArrayList();
1974
                for(int i=0;i<parameterList.length;i++)
1975
                {
1976
                        String parameterName=parameterList[i];
1977
                        int posParameter=findProjectionParameter(parameterName);
1978
                        if(posParameter==-1)
1979
                        {
1980
                                System.out.println("El parametro = "+parameterName+" no esta en la lista de parametros");
1981
                                throw new CrsException(new Exception());
1982
                        }
1983
                        //String parameterNameProj4=getProj4ProjectionParameterName(posParameter);
1984
                        String parameterNameProj4=parameterName;
1985
                        parameters.add(i,parameterNameProj4);
1986
                }
1987
                return parameters;
1988
        }
1989
        
1990
        public ArrayList getProj4ProjectionParameterDefaultValues(int pos) throws CrsException 
1991
        {
1992
                
1993
                if(pos<0||pos>(projectionParameterDefaultValueList.size()-1))
1994
                                throw new CrsException(new Exception());
1995
                String[] parameterDefaultValueList=(String[])projectionParameterDefaultValueList.get(pos);
1996
                ArrayList parameterDefaultValues=new ArrayList();
1997
                for(int i=0;i<parameterDefaultValueList.length;i++)
1998
                {
1999
                        String parameterDefaultValue=parameterDefaultValueList[i];
2000
                        parameterDefaultValues.add(i,parameterDefaultValue);
2001
                }
2002
                return parameterDefaultValues;
2003
        }
2004
        
2005
        public ArrayList getProj4ProjectionParameterMaxValues(int pos) throws CrsException 
2006
        {
2007
                
2008
                if(pos<0||pos>(projectionParameterMaxValueList.size()-1))
2009
                                throw new CrsException(new Exception());
2010
                String[] parameterMaxValueList=(String[])projectionParameterMaxValueList.get(pos);
2011
                ArrayList parameterMaxValues=new ArrayList();
2012
                for(int i=0;i<parameterMaxValueList.length;i++)
2013
                {
2014
                        String parameterMaxValue=parameterMaxValueList[i];
2015
                        parameterMaxValues.add(i,parameterMaxValue);
2016
                }
2017
                return parameterMaxValues;
2018
        }
2019
        
2020
        public ArrayList getProj4ProjectionParameterMinValues(int pos) throws CrsException 
2021
        {
2022
                
2023
                if(pos<0||pos>(projectionParameterMinValueList.size()-1))
2024
                                throw new CrsException(new Exception());
2025
                String[] parameterMinValueList=(String[])projectionParameterMinValueList.get(pos);
2026
                ArrayList parameterMinValues=new ArrayList();
2027
                for(int i=0;i<parameterMinValueList.length;i++)
2028
                {
2029
                        String parameterMinValue=parameterMinValueList[i];
2030
                        parameterMinValues.add(i,parameterMinValue);
2031
                }
2032
                return parameterMinValues;
2033
        }
2034
        
2035
        public ArrayList getProj4ProjectionParameterAcronyms(int pos) throws CrsException 
2036
        {
2037
                
2038
                if(pos<0||pos>(projectionParameterAcronymList.size()-1))
2039
                                throw new CrsException(new Exception());
2040
                String[] parameterAcronymList=(String[])projectionParameterAcronymList.get(pos);
2041
                ArrayList parameterAcronyms=new ArrayList();
2042
                for(int i=0;i<parameterAcronymList.length;i++)
2043
                {
2044
                        String parameterAcronym=parameterAcronymList[i];
2045
                        parameterAcronyms.add(i,parameterAcronym);
2046
                }
2047
                return parameterAcronyms;
2048
        }
2049

    
2050
        public String exportToProj4(Crs crs) throws CrsException
2051
        {
2052
                String strProj4="+proj=";
2053
                
2054
                String[] primeMeridian=crs.getCrsWkt().getPrimen();
2055
                String primeMeridianName=primeMeridian[0];
2056
                double primeMeridianValue=Double.parseDouble(primeMeridian[1]); // -> hacer el cambio de unidades
2057
                String[] strPrimeMeridianProj4=primeMeridianToProj4(primeMeridianName,primeMeridianValue);
2058
                primeMeridianValue=Double.parseDouble(strPrimeMeridianProj4[1]);
2059
                primeMeridianName=strPrimeMeridianProj4[0];
2060
                String primeMeridianAcronym=strPrimeMeridianProj4[2]; // Puede ser cadena vacia->Analizar
2061

    
2062
                String strProj=crs.getCrsWkt().getProjcs();
2063
                if(strProj.equals(""))
2064
                {
2065
                        System.out.println("Projection Name = "+"Geodetic");
2066
                        strProj4+="longlat ";
2067
                }
2068
                else
2069
                {
2070
                        System.out.println("Projection      = "+strProj);
2071
                        String strProjName=crs.getCrsWkt().getProjection();
2072
                        System.out.println("Projection Name = "+strProjName);
2073
                        int indexProj=findProjection(strProjName);
2074
                        if(indexProj==-1)
2075
                        {
2076
                                System.out.println("La proyeccion "+strProjName+" no figura en la lista Proj4");
2077
                                throw(new CrsException(new Exception()));
2078
                        }
2079
                        String projectionName=(getProj4ProjectionName(indexProj)).trim();
2080
                        ArrayList parameterNames=getProj4ProjectionParameters(indexProj);
2081
                        ArrayList parameterAcronyms=getProj4ProjectionParameterAcronyms(indexProj);
2082
                        ArrayList parameterValues=getProj4ProjectionParameterDefaultValues(indexProj);
2083
                        ArrayList parameterMaxValues=getProj4ProjectionParameterMaxValues(indexProj);
2084
                        ArrayList parameterMinValues=getProj4ProjectionParameterMinValues(indexProj);
2085
                        System.out.println("Parametros:"+parameterNames);
2086
                        String[] gtParameterValues=crs.getCrsWkt().getParam_value();
2087
                        String[] gtParameterNames=crs.getCrsWkt().getParam_name();
2088
                        for(int i=0;i<parameterNames.size();i++)
2089
                        {
2090
                                boolean existsParameter=false;
2091
                                String parameterValue="";
2092
                                for(int j=0;j<gtParameterNames.length;j++)
2093
                                {
2094
                                        String gtParameterName=gtParameterNames[j].trim();
2095
                                        int posGtParameter=findProjectionParameter(gtParameterName);
2096
                                        gtParameterName=getProj4ProjectionParameterName(posGtParameter);
2097
                                        gtParameterNames[j]=gtParameterName;
2098
                                        //if(((String)parameterNames.get(i)).trim().equals(gtParameterNames[j].trim()))
2099
                                        if(((String)parameterNames.get(i)).trim().equals(gtParameterNames[j].trim()))
2100
                                        {
2101
                                                existsParameter=true;
2102
                                                double maxValue=Double.parseDouble((String)parameterMaxValues.get(j));
2103
                                                double minValue=Double.parseDouble((String)parameterMinValues.get(j));
2104
                                                //parameterValue=Double.parseDouble(gtParameterValues[j]);
2105
                                                parameterValue=gtParameterValues[j]; // Ojo unidades -> analizar
2106
                                                double auxValue=Double.parseDouble(parameterValue);
2107
                                                if((auxValue<minValue)||(auxValue>maxValue))
2108
                                                {
2109
                                                        String strError="El parametro ";
2110
                                                        strError+=gtParameterName;
2111
                                                        strError+=" esta fuera de dominio";
2112
                                                        System.out.println(strError);
2113
                                                        throw new CrsException(new Exception());
2114
                                                }
2115
                                                break;
2116
                                        }
2117
                                }
2118
                                if(existsParameter)
2119
                                {
2120
                                        parameterValues.set(i,parameterValue);
2121
                                        System.out.println("- Parametro["+parameterNames.get(i)+"]="+parameterValue);
2122
                                }
2123
                                /*
2124
                                else
2125
                                {
2126
                                        value=Double.parseDouble((String)parameterDefaultValues.get(i));
2127
                                        System.out.println("El parametro "+parameterNames.get(i)+" no figura en la lista geotools");
2128
                                        throw(new CrsException(new Exception()));
2129
                                }
2130
                                */
2131
                        }
2132
                        String[] projectionAcronym=(String[])projectionAcronymList.get(indexProj);
2133
                        strProj4=strProj4+projectionAcronym[0]+" ";
2134
                        String strExtraProj4="";
2135
                        // Control de casos especiales
2136
                        if(projectionAcronym.equals("merc")) // 1 - Mercator
2137
                        {
2138
                                if(projectionName.equalsIgnoreCase("Mercator_1SP")) // No deberia tener lat_ts
2139
                                {
2140
                                        for(int j=0;j<gtParameterNames.length;j++)
2141
                                        {
2142
                                                String gtParameterName=gtParameterNames[j].trim();
2143
                                                if(gtParameterName.equalsIgnoreCase("latitude_of_origin"))
2144
                                                {
2145
                                                        double gtParameterValue=Double.parseDouble(gtParameterValues[j]);
2146
                                                        if(gtParameterValue!=0.0)
2147
                                                        {
2148
                                                                String strError="La proyecci?n con latitude_origin deber?a ser MERCATOR_2SP";
2149
                                                                System.out.println(strError);
2150
                                                                throw new CrsException(new Exception());
2151
                                                        }
2152
                                                        break;
2153
                                                }
2154
                                        }
2155
                                }
2156
                                if(projectionName.equalsIgnoreCase("Mercator_2SP")) // No deberia tener lat_ts
2157
                                {
2158
                                        for(int j=0;j<gtParameterNames.length;j++)
2159
                                        {
2160
                                                String gtParameterName=gtParameterNames[j].trim();
2161
                                                if(gtParameterName.equalsIgnoreCase("scale_factor"))
2162
                                                {
2163
                                                        double gtParameterValue=Double.parseDouble(gtParameterValues[j]);
2164
                                                        if(gtParameterValue!=0.0)
2165
                                                        {
2166
                                                                String strError="La proyecci?n con scale_factor deber?a ser MERCATOR_1SP";
2167
                                                                System.out.println(strError);
2168
                                                                throw new CrsException(new Exception());
2169
                                                        }
2170
                                                        break;
2171
                                                }
2172
                                        }
2173
                                }
2174
                        }
2175
                        else if(projectionAcronym.equals("stere"))
2176
                        {
2177
                                if(projectionName.equalsIgnoreCase("Polar_Stereographic")) // lat_ts=lat_0={90 o -90)
2178
                                {
2179
                                        boolean isNorthPole=true;
2180
                                        for(int j=0;j<gtParameterNames.length;j++)
2181
                                        {
2182
                                                String gtParameterName=gtParameterNames[j].trim();
2183
                                                if(gtParameterName.equalsIgnoreCase("latitude_of_origin"))
2184
                                                {
2185
                                                        double gtParameterValue=Double.parseDouble(gtParameterValues[j]);
2186
                                                        if(gtParameterValue==90.0) isNorthPole=true;
2187
                                                        else if(gtParameterValue==-90.0)  isNorthPole=false;
2188
                                                        else
2189
                                                        {
2190
                                                                String strError="La proyecci?n estereogr?fica polar debe tener latitud origen 90 o -90";
2191
                                                                System.out.println(strError);
2192
                                                                throw new CrsException(new Exception());
2193
                                                        }
2194
                                                        break;
2195
                                                }
2196
                                        }
2197
                                        String strLatitudeOrigin="90.0";
2198
                                        if(!isNorthPole) strLatitudeOrigin="-90.0";
2199
                                        for(int k=0;k<parameterNames.size();k++)
2200
                                        {
2201
                                                String parameterName=(String)parameterNames.get(k);
2202
                                                if(parameterName.equalsIgnoreCase("latitude_of_origin"))
2203
                                                {
2204
                                                        parameterValues.set(k,strLatitudeOrigin);
2205
                                                }
2206
                                        }
2207
                                }
2208
                        }
2209
                        else if(projectionAcronym.equals("omerc"))
2210
                        {
2211
                                boolean existsLat1=false;
2212
                                boolean existsLat2=false;
2213
                                boolean existsLon1=false;
2214
                                boolean existsLon2=false;
2215
                                // Necesito buscar un caso de ejemplo
2216
                        }
2217
                        else if(projectionAcronym.equals("mill"))
2218
                        {
2219
                                strExtraProj4="+R_A ";
2220
                        }
2221
                        else if(projectionAcronym.equals("vandg"))
2222
                        {
2223
                                strExtraProj4="+R_A ";
2224
                        }
2225
                        
2226
                        for(int i=0;i<parameterNames.size();i++)
2227
                        {
2228
                                String parameterName=((String)parameterNames.get(i)).trim();
2229
                                String parameterAcronym=((String)parameterAcronyms.get(i)).trim();
2230
                                String strParameterValue=((String)parameterValues.get(i)).trim();
2231
                                if(parameterAcronym.equals("lon_0")
2232
                                                ||parameterAcronym.equals("lonc"))
2233
                                {
2234
                                        double parameterValue=Double.parseDouble(strParameterValue);
2235
                                        parameterValue=parameterValue-primeMeridianValue;
2236
                                        strParameterValue=Double.toString(parameterValue);
2237
                                }
2238
                                strProj4=strProj4+"+"+parameterAcronym+"="+strParameterValue+" ";
2239
                        }
2240
                        strProj4+=strExtraProj4;
2241
                        //getProj4ProjectionName();
2242
                }
2243
                
2244
                // ?Que pasa si no hay elipsoide? -> OGR por defecto pone WGS84
2245
                double a=0;
2246
                double inv_f=0;
2247
                String elipName=crs.getCrsWkt().getSpheroid()[0];
2248
                a=Double.parseDouble(crs.getCrsWkt().getSpheroid()[1]);
2249
                inv_f=Double.parseDouble(crs.getCrsWkt().getSpheroid()[2]);
2250
                String strEllipseAcronym=ellipseToProj4(a,inv_f);
2251
                String strEllipse="";
2252
                if(strEllipseAcronym.equals(""))
2253
                {
2254
                        strEllipse="+a="+a+" +rf="+inv_f+" ";
2255
                }
2256
                else
2257
                {
2258
                        strEllipse="+ellps="+strEllipseAcronym+" ";
2259
                }
2260
                strProj4+=strEllipse;
2261
                System.out.println("Elipsoide["+elipName+"]=("+a+","+inv_f+")");
2262
                strProj4+=primeMeridianAcronym;
2263
                String strWkt=crs.getWKT();
2264
                
2265
                System.out.println("- Cadena proj4: "+strProj4);
2266
                return strWkt;                
2267
        }
2268

    
2269
        private String[] primeMeridianToProj4(String pmName,double pmValue) throws CrsException
2270
        {
2271
            String[] primeMeridian=new String[3];
2272
                String pszPM="";
2273
                String acronym="";
2274
            double dfFromGreenwich = 0.0;
2275
            double tolerance=0.002/3600.0;
2276
            int    nPMCode = -1;
2277

    
2278
            dfFromGreenwich=-(9+7/60.0+54.862/3600.0);
2279
        if(pmName.equalsIgnoreCase("lisbon")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2280
        {
2281
            pszPM="lisbon";
2282
            nPMCode = 8902;
2283
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2284
            {
2285
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2286
                                System.out.println(strError);
2287
                                //throw new CrsException(new Exception());
2288
            }
2289
            pmValue=dfFromGreenwich;
2290
            acronym="+pm="+pszPM+" ";
2291
        }
2292
        
2293
        dfFromGreenwich=(2+20/60.0+14.025/3600.0); 
2294
        if(pmName.equalsIgnoreCase("paris")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2295
        {
2296
            pszPM="paris";
2297
            nPMCode = 8903;
2298
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2299
            {
2300
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2301
                                System.out.println(strError);
2302
                                //throw new CrsException(new Exception());
2303
            }
2304
            pmValue=dfFromGreenwich;
2305
            acronym="+pm="+pszPM+" ";
2306
        }
2307
        
2308
        dfFromGreenwich=-(74+4/60.0+51.3/3600.0);
2309
        if(pmName.equalsIgnoreCase("bogota")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2310
        {
2311
            pszPM="bogota";
2312
            nPMCode = 8904;
2313
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2314
            {
2315
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2316
                                System.out.println(strError);
2317
                                //throw new CrsException(new Exception());
2318
            }
2319
            pmValue=dfFromGreenwich;
2320
            acronym="+pm="+pszPM+" ";
2321
        }
2322
        
2323
        dfFromGreenwich=-(3+41/60.0+16.58/3600.0);  // mal en ogr los segundos pone 16.48
2324
        if(pmName.equalsIgnoreCase("madrid")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2325
        {
2326
            pszPM="madrid";
2327
            nPMCode = 8905;
2328
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2329
            {
2330
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2331
                                System.out.println(strError);
2332
                                //throw new CrsException(new Exception());
2333
            }
2334
            pmValue=dfFromGreenwich;
2335
            acronym="+pm="+pszPM+" ";
2336
        }
2337
        
2338
        dfFromGreenwich=(12+27/60.0+8.4/3600.0);
2339
        if(pmName.equalsIgnoreCase("rome")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2340
        {
2341
            pszPM="rome";
2342
            nPMCode = 8906;
2343
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2344
            {
2345
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2346
                                System.out.println(strError);
2347
                                //throw new CrsException(new Exception());
2348
            }
2349
            pmValue=dfFromGreenwich;
2350
            acronym="+pm="+pszPM+" ";
2351
        }
2352
        
2353
        dfFromGreenwich=(7+26/60.0+22.5/3600.0);
2354
        if(pmName.equalsIgnoreCase("bern")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2355
        {
2356
            pszPM="bern";
2357
            nPMCode = 8907;
2358
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2359
            {
2360
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2361
                                System.out.println(strError);
2362
                                //throw new CrsException(new Exception());
2363
            }
2364
            pmValue=dfFromGreenwich;
2365
            acronym="+pm="+pszPM+" ";
2366
        }
2367
        
2368
        dfFromGreenwich=(106+48/60.0+27.79/3600.0);
2369
        if(pmName.equalsIgnoreCase("jakarta")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2370
        {
2371
            pszPM="jakarta";
2372
            nPMCode = 8908;
2373
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2374
            {
2375
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2376
                                System.out.println(strError);
2377
                                //throw new CrsException(new Exception());
2378
            }
2379
            pmValue=dfFromGreenwich;
2380
            acronym="+pm="+pszPM+" ";
2381
        }
2382
        
2383
        dfFromGreenwich=-(17+40/60.0+0.0/3600.0);
2384
        if(pmName.equalsIgnoreCase("ferro")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2385
        {
2386
            pszPM="ferro";
2387
            nPMCode = 8909;
2388
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2389
            {
2390
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2391
                                System.out.println(strError);
2392
                                //throw new CrsException(new Exception());
2393
            }
2394
            pmValue=dfFromGreenwich;
2395
            acronym="+pm="+pszPM+" ";
2396
        }
2397
        
2398
        dfFromGreenwich=(4+22/60.0+4.71/3600.0);
2399
        if(pmName.equalsIgnoreCase("brussels")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2400
        {
2401
            pszPM="brussels";
2402
            nPMCode = 8910;
2403
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2404
            {
2405
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2406
                                System.out.println(strError);
2407
                                //throw new CrsException(new Exception());
2408
            }
2409
            pmValue=dfFromGreenwich;
2410
            acronym="+pm="+pszPM+" ";
2411
        }
2412
        
2413
        dfFromGreenwich=(18+3/60.0+29.8/3600.0);
2414
        if(pmName.equalsIgnoreCase("stockholm")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2415
        {
2416
            pszPM="stockholm";
2417
            nPMCode = 8911;
2418
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2419
            {
2420
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2421
                                System.out.println(strError);
2422
                                //throw new CrsException(new Exception());
2423
            }
2424
            pmValue=dfFromGreenwich;
2425
            acronym="+pm="+pszPM+" ";
2426
        }
2427
        
2428
        dfFromGreenwich=(23+42/60.0+58.815/3600.0);
2429
        if(pmName.equalsIgnoreCase("athens")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2430
        {
2431
            pszPM="athens";
2432
            nPMCode = 8912;
2433
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2434
            {
2435
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2436
                                System.out.println(strError);
2437
                                //throw new CrsException(new Exception());
2438
            }
2439
            pmValue=dfFromGreenwich;
2440
            acronym="+pm="+pszPM+" ";
2441
        }
2442
        
2443
        dfFromGreenwich=(10+43/60.0+22.5/3600.0);
2444
        if(pmName.equalsIgnoreCase("oslo")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2445
        {
2446
            pszPM="oslo";
2447
            nPMCode = 8913;
2448
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2449
            {
2450
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2451
                                System.out.println(strError);
2452
                                //throw new CrsException(new Exception());
2453
            }
2454
            pmValue=dfFromGreenwich;
2455
            acronym="+pm="+pszPM+" ";
2456
        }
2457
        
2458
        dfFromGreenwich=(0.0);
2459
        if(pmName.equalsIgnoreCase("Greenwich")||(Math.abs(dfFromGreenwich-pmValue)<tolerance))
2460
        {
2461
            pszPM="Greenwich";
2462
            nPMCode = 0;
2463
            if(Math.abs(dfFromGreenwich-pmValue)>tolerance)
2464
            {
2465
                                String strError="No concuerdan el nombre del meridiano origen y su valor";
2466
                                System.out.println(strError);
2467
                                //throw new CrsException(new Exception());
2468
            }
2469
            pmValue=dfFromGreenwich;
2470
        }
2471
        primeMeridian[0]=pszPM;
2472
        primeMeridian[1]=Double.toString(pmValue);
2473
        primeMeridian[2]=acronym;
2474
                return primeMeridian;
2475
        }
2476

    
2477
        private String ellipseToProj4(double dfSemiMajor, double dfInvFlattening)
2478
        {
2479
                double yo=Math.abs(4.5);
2480
                String pszPROJ4Ellipse="";
2481
            if( Math.abs(dfSemiMajor-6378249.145) < 0.01
2482
                && Math.abs(dfInvFlattening-293.465) < 0.0001 )
2483
            {
2484
                pszPROJ4Ellipse = "clrk80";     /* Clark 1880 */
2485
            }
2486
            else if( Math.abs(dfSemiMajor-6378245.0) < 0.01
2487
                     && Math.abs(dfInvFlattening-298.3) < 0.0001 )
2488
            {
2489
                pszPROJ4Ellipse = "krass";      /* Krassovsky */
2490
            }
2491
            else if( Math.abs(dfSemiMajor-6378388.0) < 0.01
2492
                     && Math.abs(dfInvFlattening-297.0) < 0.0001 )
2493
            {
2494
                pszPROJ4Ellipse = "intl";       /* International 1924 */
2495
            }
2496
            else if( Math.abs(dfSemiMajor-6378160.0) < 0.01
2497
                     && Math.abs(dfInvFlattening-298.25) < 0.0001 )
2498
            {
2499
                pszPROJ4Ellipse = "aust_SA";    /* Australian */
2500
            }
2501
            else if( Math.abs(dfSemiMajor-6377397.155) < 0.01
2502
                     && Math.abs(dfInvFlattening-299.1528128) < 0.0001 )
2503
            {
2504
                pszPROJ4Ellipse = "bessel";     /* Bessel 1841 */
2505
            }
2506
            else if( Math.abs(dfSemiMajor-6377483.865) < 0.01
2507
                     && Math.abs(dfInvFlattening-299.1528128) < 0.0001 )
2508
            {
2509
                pszPROJ4Ellipse = "bess_nam";   /* Bessel 1841 (Namibia / Schwarzeck)*/
2510
            }
2511
            else if( Math.abs(dfSemiMajor-6378160.0) < 0.01
2512
                     && Math.abs(dfInvFlattening-298.247167427) < 0.0001 )
2513
            {
2514
                pszPROJ4Ellipse = "GRS67";      /* GRS 1967 */
2515
            }
2516
            else if( Math.abs(dfSemiMajor-6378137) < 0.01
2517
                     && Math.abs(dfInvFlattening-298.257222101) < 0.000001 )
2518
            {
2519
                pszPROJ4Ellipse = "GRS80";      /* GRS 1980 */
2520
            }
2521
            else if( Math.abs(dfSemiMajor-6378206.4) < 0.01
2522
                     && Math.abs(dfInvFlattening-294.9786982) < 0.0001 )
2523
            {
2524
                pszPROJ4Ellipse = "clrk66";     /* Clarke 1866 */
2525
            }
2526
            else if( Math.abs(dfSemiMajor-6378206.4) < 0.01
2527
                     && Math.abs(dfInvFlattening-294.9786982) < 0.0001 )
2528
            {
2529
                pszPROJ4Ellipse = "mod_airy";   /* Modified Airy */
2530
            }
2531
            else if( Math.abs(dfSemiMajor-6377563.396) < 0.01
2532
                     && Math.abs(dfInvFlattening-299.3249646) < 0.0001 )
2533
            {
2534
                pszPROJ4Ellipse = "airy";       /* Modified Airy */
2535
            }
2536
            else if( Math.abs(dfSemiMajor-6378200) < 0.01
2537
                     && Math.abs(dfInvFlattening-298.3) < 0.0001 )
2538
            {
2539
                pszPROJ4Ellipse = "helmert";    /* Helmert 1906 */
2540
            }
2541
            else if( Math.abs(dfSemiMajor-6378155) < 0.01
2542
                     && Math.abs(dfInvFlattening-298.3) < 0.0001 )
2543
            {
2544
                pszPROJ4Ellipse = "fschr60m";   /* Modified Fischer 1960 */
2545
            }
2546
            else if( Math.abs(dfSemiMajor-6377298.556) < 0.01
2547
                     && Math.abs(dfInvFlattening-300.8017) < 0.0001 )
2548
            {
2549
                pszPROJ4Ellipse = "evrstSS";    /* Everest (Sabah & Sarawak) */
2550
            }
2551
            else if( Math.abs(dfSemiMajor-6378165.0) < 0.01
2552
                     && Math.abs(dfInvFlattening-298.3) < 0.0001 )
2553
            {
2554
                pszPROJ4Ellipse = "WGS60";      
2555
            }
2556
            else if( Math.abs(dfSemiMajor-6378145.0) < 0.01
2557
                     && Math.abs(dfInvFlattening-298.25) < 0.0001 )
2558
            {
2559
                pszPROJ4Ellipse = "WGS66";      
2560
            }
2561
            else if( Math.abs(dfSemiMajor-6378135.0) < 0.01
2562
                     && Math.abs(dfInvFlattening-298.26) < 0.0001 )
2563
            {
2564
                pszPROJ4Ellipse = "WGS72";      
2565
            }
2566
            else if( Math.abs(dfSemiMajor-6378137.0) < 0.01
2567
                     && Math.abs(dfInvFlattening-298.257223563) < 0.000001 )
2568
            {
2569
                pszPROJ4Ellipse = "WGS84";
2570
            }
2571
            /*
2572
            else if( EQUAL(pszDatum,"North_American_Datum_1927") )
2573
            {
2574
//                pszPROJ4Ellipse = "clrk66:+datum=nad27"; // NAD 27 
2575
                pszPROJ4Ellipse = "clrk66";
2576
            }
2577
            else if( EQUAL(pszDatum,"North_American_Datum_1983") )
2578
            {
2579
//                pszPROJ4Ellipse = "GRS80:+datum=nad83";       // NAD 83 
2580
                pszPROJ4Ellipse = "GRS80";
2581
            }
2582
            */
2583
            return pszPROJ4Ellipse;
2584
        }
2585

    
2586
        // Casos especiales
2587
        // - MERCATOR_1SP
2588
        // - HOTINE
2589
        // - MILLER
2590
        // - Polar_Stereographic
2591
        // - Polar_Stereographic
2592
        // - VanDerGrinten
2593
        // - Transverse Mercator
2594
        // - Cuando el meridiano origen no es 0 se pone pm=madrid y lon_0=
2595
        // +datum
2596
}