Line data Source code
1 : /*****************************************************************************
2 : *
3 : * Project: Idrisi Raster Image File Driver
4 : * Purpose: Read/write Idrisi Raster Image Format RST
5 : * Author: Ivan Lucena, [lucena_ivan at hotmail.com]
6 : *
7 : * Revised by Hongmei Zhu, February, 2013
8 : * honzhu@clarku.edu
9 : * Clark Labs/Clark University
10 : *
11 : ******************************************************************************
12 : * Copyright( c ) 2006, Ivan Lucena
13 : * Copyright (c) 2007-2012, Even Rouault <even dot rouault at spatialys.com>
14 : *
15 : * SPDX-License-Identifier: MIT
16 : ****************************************************************************/
17 :
18 : #include "cpl_conv.h"
19 : #include "cpl_string.h"
20 : #include "cpl_csv.h"
21 : #include "gdal_frmts.h"
22 : #include "gdal_pam.h"
23 : #include "gdal_alg.h"
24 : #include "gdal_priv.h"
25 : #include "gdal_rat.h"
26 : #include "ogr_spatialref.h"
27 : #include "idrisi.h"
28 :
29 : #include "proj_experimental.h"
30 : #include "ogr_proj_p.h"
31 :
32 : #include <cmath>
33 :
34 : #ifdef _WIN32
35 : #define PATHDELIM '\\'
36 : #else
37 : #define PATHDELIM '/'
38 : #endif
39 :
40 : //----- Safe numeric conversion, NULL as zero
41 : #define atoi_nz(s) (s == nullptr ? (int)0 : atoi(s))
42 : #define CPLAtof_nz(s) (s == nullptr ? (double)0.0 : CPLAtof(s))
43 :
44 : //----- file extensions:
45 : static const char *const extRST = "rst";
46 : static const char *const extRDC = "rdc";
47 : static const char *const extSMP = "smp";
48 : static const char *const extREF = "ref";
49 : // static const char * const extRSTu = "RST";
50 : static const char *const extRDCu = "RDC";
51 : static const char *const extSMPu = "SMP";
52 : static const char *const extREFu = "REF";
53 :
54 : //----- field names on rdc file:
55 : static const char *const rdcFILE_FORMAT = "file format ";
56 : static const char *const rdcFILE_TITLE = "file title ";
57 : static const char *const rdcDATA_TYPE = "data type ";
58 : static const char *const rdcFILE_TYPE = "file type ";
59 : static const char *const rdcCOLUMNS = "columns ";
60 : static const char *const rdcROWS = "rows ";
61 : static const char *const rdcREF_SYSTEM = "ref. system ";
62 : static const char *const rdcREF_UNITS = "ref. units ";
63 : static const char *const rdcUNIT_DIST = "unit dist. ";
64 : static const char *const rdcMIN_X = "min. X ";
65 : static const char *const rdcMAX_X = "max. X ";
66 : static const char *const rdcMIN_Y = "min. Y ";
67 : static const char *const rdcMAX_Y = "max. Y ";
68 : static const char *const rdcPOSN_ERROR = "pos'n error ";
69 : static const char *const rdcRESOLUTION = "resolution ";
70 : static const char *const rdcMIN_VALUE = "min. value ";
71 : static const char *const rdcMAX_VALUE = "max. value ";
72 : static const char *const rdcDISPLAY_MIN = "display min ";
73 : static const char *const rdcDISPLAY_MAX = "display max ";
74 : static const char *const rdcVALUE_UNITS = "value units ";
75 : static const char *const rdcVALUE_ERROR = "value error ";
76 : static const char *const rdcFLAG_VALUE = "flag value ";
77 : static const char *const rdcFLAG_DEFN = "flag def'n ";
78 : static const char *const rdcFLAG_DEFN2 = "flag def`n ";
79 : static const char *const rdcLEGEND_CATS = "legend cats ";
80 : static const char *const rdcLINEAGES = "lineage ";
81 : static const char *const rdcCOMMENTS = "comment ";
82 : static const char *const rdcCODE_N = "code %6d ";
83 :
84 : //----- ".ref" file field names:
85 : static const char *const refREF_SYSTEM = "ref. system ";
86 : static const char *const refREF_SYSTEM2 = "ref.system ";
87 : static const char *const refPROJECTION = "projection ";
88 : static const char *const refDATUM = "datum ";
89 : static const char *const refDELTA_WGS84 = "delta WGS84 ";
90 : static const char *const refELLIPSOID = "ellipsoid ";
91 : static const char *const refMAJOR_SAX = "major s-ax ";
92 : static const char *const refMINOR_SAX = "minor s-ax ";
93 : static const char *const refORIGIN_LONG = "origin long ";
94 : static const char *const refORIGIN_LAT = "origin lat ";
95 : static const char *const refORIGIN_X = "origin X ";
96 : static const char *const refORIGIN_Y = "origin Y ";
97 : static const char *const refSCALE_FAC = "scale fac ";
98 : static const char *const refUNITS = "units ";
99 : static const char *const refPARAMETERS = "parameters ";
100 : static const char *const refSTANDL_1 = "stand ln 1 ";
101 : static const char *const refSTANDL_2 = "stand ln 2 ";
102 :
103 : //----- standard values:
104 : static const char *const rstVERSION = "Idrisi Raster A.1";
105 : static const char *const rstBYTE = "byte";
106 : static const char *const rstINTEGER = "integer";
107 : static const char *const rstREAL = "real";
108 : static const char *const rstRGB24 = "rgb24";
109 : static const char *const rstDEGREE = "deg";
110 : static const char *const rstMETER = "m";
111 : static const char *const rstLATLONG = "latlong";
112 : static const char *const rstLATLONG2 = "lat/long";
113 : static const char *const rstPLANE = "plane";
114 : static const char *const rstUTM = "utm-%d%c";
115 : static const char *const rstSPC = "spc%2d%2s%d";
116 :
117 : //----- palette file( .smp ) header size:
118 : constexpr int smpHEADERSIZE = 18;
119 :
120 : //----- check if file exists:
121 : bool FileExists(const char *pszPath);
122 :
123 : //----- Reference Table
124 : struct ReferenceTab
125 : {
126 : int nCode;
127 : const char *pszName;
128 : };
129 :
130 : //----- USA State's reference table to USGS PCS Code
131 : constexpr ReferenceTab aoUSStateTable[] = {
132 : {101, "al"}, {201, "az"}, {301, "ar"}, {401, "ca"}, {501, "co"},
133 : {600, "ct"}, {700, "de"}, {901, "fl"}, {1001, "ga"}, {1101, "id"},
134 : {1201, "il"}, {1301, "in"}, {1401, "ia"}, {1501, "ks"}, {1601, "ky"},
135 : {1701, "la"}, {1801, "me"}, {1900, "md"}, {2001, "ma"}, {2111, "mi"},
136 : {2201, "mn"}, {2301, "ms"}, {2401, "mo"}, {2500, "mt"}, {2600, "ne"},
137 : {2701, "nv"}, {2800, "nh"}, {2900, "nj"}, {3001, "nm"}, {3101, "ny"},
138 : {3200, "nc"}, {3301, "nd"}, {3401, "oh"}, {3501, "ok"}, {3601, "or"},
139 : {3701, "pa"}, {3800, "ri"}, {3900, "sc"}, {4001, "sd"}, {4100, "tn"},
140 : {4201, "tx"}, {4301, "ut"}, {4400, "vt"}, {4501, "va"}, {4601, "wa"},
141 : {4701, "wv"}, {4801, "wv"}, {4901, "wy"}, {5001, "ak"}, {5101, "hi"},
142 : {5200, "pr"}};
143 :
144 : //---- The origin table for USA State Plane Systems
145 : struct OriginTab83
146 : {
147 : double longitude;
148 : double latitude;
149 : const char *spcs;
150 : };
151 :
152 : constexpr int ORIGIN_COUNT = 148;
153 :
154 : //---- USA State plane coordinate system in IDRISI
155 : static const OriginTab83 SPCS83Origin[] = {
156 : {85.83, 30.50, "SPC83AL1"}, {87.50, 30.00, "SPC83AL2"},
157 : {176.00, 51.00, "SPC83AK0"}, {142.00, 54.00, "SPC83AK2"},
158 : {146.00, 54.00, "SPC83AK3"}, {150.00, 54.00, "SPC83AK4"},
159 : {154.00, 54.00, "SPC83AK5"}, {158.00, 54.00, "SPC83AK6"},
160 : {162.00, 54.00, "SPC83AK7"}, {166.00, 54.00, "SPC83AK8"},
161 : {170.00, 54.00, "SPC83AK9"}, {110.17, 31.00, "SPC83AZ1"},
162 : {111.92, 31.00, "SPC83AZ2"}, {113.75, 31.00, "SPC83AZ3"},
163 : {92.00, 34.33, "SPC83AR1"}, {92.00, 32.67, "SPC83AR2"},
164 : {122.00, 39.33, "SPC83CA1"}, {122.00, 37.67, "SPC83CA2"},
165 : {120.50, 36.50, "SPC83CA3"}, {119.00, 35.33, "SPC83CA4"},
166 : {118.00, 33.50, "SPC83CA5"}, {116.25, 32.17, "SPC83CA6"},
167 : {105.50, 39.33, "SPC83CO1"}, {105.50, 37.83, "SPC83CO2"},
168 : {105.50, 36.67, "SPC83CO3"}, {72.75, 40.83, "SPC83CT1"},
169 : {75.42, 38.00, "SPC83DE1"}, {81.00, 24.33, "SPC83FL1"},
170 : {82.00, 24.33, "SPC83FL2"}, {84.50, 29.00, "SPC83FL3"},
171 : {82.17, 30.00, "SPC83GA1"}, {84.17, 30.00, "SPC83GA2"},
172 : {155.50, 18.83, "SPC83HI1"}, {156.67, 20.33, "SPC83HI2"},
173 : {158.00, 21.17, "SPC83HI3"}, {159.50, 21.83, "SPC83HI4"},
174 : {160.17, 21.67, "SPC83HI5"}, {112.17, 41.67, "SPC83ID1"},
175 : {114.00, 41.67, "SPC83ID2"}, {115.75, 41.67, "SPC83ID3"},
176 : {88.33, 36.67, "SPC83IL1"}, {90.17, 36.67, "SPC83IL1"},
177 : {85.67, 37.50, "SPC83IN1"}, {87.08, 37.50, "SPC83IN2"},
178 : {93.50, 41.50, "SPC83IA1"}, {93.50, 40.00, "SPC83IA1"},
179 : {98.00, 38.33, "SPC83KS1"}, {98.50, 36.67, "SPC83KS2"},
180 : {84.25, 37.50, "SPC83KY1"}, {85.75, 36.33, "SPC83KY2"},
181 : {92.50, 30.50, "SPC83LA1"}, {91.33, 28.50, "SPC83LA2"},
182 : {91.33, 25.50, "SPC83LA3"}, {92.50, 30.67, "SPC27LA1"}, // NAD27 system
183 : {91.33, 28.67, "SPC27LA2"}, {91.33, 25.67, "SPC27LA3"}, //
184 : {68.50, 43.67, "SPC83ME1"}, {68.50, 43.83, "SPC27ME1"}, // NAD27
185 : {70.17, 42.83, "SPC83ME2"}, {77.00, 37.67, "SPC83MD1"}, //
186 : {77.00, 37.83, "SPC27MD1"}, // NAD27
187 : {71.50, 41.00, "SPC83MA1"}, {70.50, 41.00, "SPC83MA2"},
188 : {87.00, 44.78, "SPC83MI1"}, {84.37, 43.32, "SPC83MI2"},
189 : {84.37, 41.50, "SPC83MI3"}, {84.33, 43.32, "SPC27MI2"}, // NAD27 L
190 : {84.33, 41.50, "SPC27MI3"}, // NAD27 L
191 : {83.67, 41.50, "SPC27MI4"}, // NAD27 TM
192 : {85.75, 41.50, "SPC27MI5"}, // NAD27 TM
193 : {88.75, 41.50, "SPC27MI6"}, // NAD27 TM
194 : {93.10, 46.50, "SPC83MN1"}, {94.25, 45.00, "SPC83MN2"},
195 : {94.00, 43.00, "SPC83MN3"}, {88.83, 29.50, "SPC83MS1"},
196 : {90.33, 29.50, "SPC83MS2"}, {88.83, 29.67, "SPC83MS1"}, // NAD27
197 : {90.33, 30.50, "SPC83MS2"}, //
198 : {90.50, 35.83, "SPC83MO1"}, {92.50, 35.83, "SPC83MO2"},
199 : {94.50, 36.17, "SPC83MO3"}, {109.50, 44.25, "SPC83MT1"},
200 : {109.50, 47.00, "SPC27MT1"}, // NAD27
201 : {109.50, 45.83, "SPC27MT2"}, {109.50, 44.00, "SPC27MT3"}, //
202 : {100.00, 39.83, "SPC83NE1"}, {115.58, 34.75, "SPC83NV1"},
203 : {116.67, 34.75, "SPC83NV2"}, {118.58, 34.75, "SPC83NV3"},
204 : {71.67, 42.50, "SPC83NH1"}, {74.50, 38.83, "SPC83NJ1"},
205 : {74.67, 38.83, "SPC27NJ1"}, // NAD27
206 : {104.33, 31.00, "SPC83NM1"}, {106.25, 31.00, "SPC83NM2"},
207 : {107.83, 31.00, "SPC83NM3"}, {74.50, 38.83, "SPC83NY1"},
208 : {76.58, 40.00, "SPC83NY2"}, {78.58, 40.00, "SPC83NY3"},
209 : {74.00, 40.17, "SPC83NY4"}, {74.33, 40.00, "SPC27NY1"}, // NAD27
210 : {74.00, 40.50, "SPC27NY4"}, //
211 : {79.00, 33.75, "SPC83NC1"}, {100.50, 47.00, "SPC83ND1"},
212 : {100.50, 45.67, "SPC83ND2"}, {82.50, 39.67, "SPC83OH1"},
213 : {82.50, 38.00, "SPC83OH2"}, {98.00, 35.00, "SPC83OK1"},
214 : {98.00, 33.33, "SPC83OK2"}, {120.50, 43.67, "SPC83OR1"},
215 : {120.50, 41.67, "SPC83OR2"}, {77.75, 40.17, "SPC83PA1"},
216 : {77.75, 39.33, "SPC83PA2"}, {71.50, 41.08, "SPC83RI1"},
217 : {81.00, 31.83, "SPC83SC1"}, {81.00, 33.00, "SPC27SC1"}, // NAD27
218 : {81.00, 31.83, "SPC27SC2"}, // NAD27
219 : {100.00, 43.83, "SPC83SD1"}, {100.33, 42.33, "SPC83SD2"},
220 : {86.00, 34.33, "SPC83TN1"}, {86.00, 34.67, "SPC27TN1"}, // NAD27
221 : {101.50, 34.00, "SPC83TX1"}, //
222 : {98.50, 31.67, "SPC83TX2"}, {100.33, 29.67, "SPC83TX3"},
223 : {99.00, 27.83, "SPC83TX4"}, {98.50, 25.67, "SPC83TX5"},
224 : {97.50, 31.67, "SPC27TX2"}, // NAD27
225 : {111.50, 40.33, "SPC83UT1"}, {111.50, 38.33, "SPC83UT2"},
226 : {111.50, 36.67, "SPC83UT3"}, {72.50, 42.50, "SPC83VT1"},
227 : {78.50, 37.67, "SPC83VA1"}, {78.50, 36.33, "SPC83VA2"},
228 : {120.83, 47.00, "SPC83WA1"}, {120.50, 45.33, "SPC83WA2"},
229 : {79.50, 38.50, "SPC83WV1"}, {81.00, 37.00, "SPC83WV2"},
230 : {90.00, 45.17, "SPC83WI1"}, {90.00, 43.83, "SPC83WI2"},
231 : {90.00, 42.00, "SPC83WI3"}, {105.17, 40.50, "SPC83WY1"},
232 : {107.33, 40.50, "SPC83WY2"}, {108.75, 40.50, "SPC83WY3"},
233 : {110.08, 40.50, "SPC83WY4"}, {105.17, 40.67, "SPC27WY1"}, // NAD27
234 : {105.33, 40.67, "SPC27WY2"}, {108.75, 40.67, "SPC27WY3"},
235 : {110.08, 40.67, "SPC27WY4"}, //
236 : {66.43, 17.83, "SPC83PR1"}};
237 :
238 : // Get IDRISI State Plane name by origin
239 : char *GetSpcs(double dfLon, double dfLat);
240 :
241 : // change NAD from 83 to 27
242 : void NAD83to27(char *pszOutRef, char *pszInRef);
243 :
244 : #define US_STATE_COUNT (sizeof(aoUSStateTable) / sizeof(ReferenceTab))
245 :
246 : //----- Get the Code of a US State
247 : int GetStateCode(const char *pszState);
248 :
249 : //----- Get the state name of a Code
250 : const char *GetStateName(int nCode);
251 :
252 : //----- Conversion Table definition
253 : struct ConversionTab
254 : {
255 : const char *pszName;
256 : int nDefaultI;
257 : int nDefaultG;
258 : double dfConv;
259 : };
260 :
261 : //----- Linear Unit Conversion Table
262 : static const ConversionTab aoLinearUnitsConv[] = {
263 : {"m", /* 0 */ 0, 1, 1.0},
264 : {SRS_UL_METER, /* 1 */ 0, 1, 1.0},
265 : {"meters", /* 2 */ 0, 1, 1.0},
266 : {"metre", /* 3 */ 0, 1, 1.0},
267 :
268 : {"ft", /* 4 */ 4, 5, 0.3048},
269 : {SRS_UL_FOOT, /* 5 */ 4, 5, 0.3048},
270 : {"feet", /* 6 */ 4, 5, 0.3048},
271 : {"foot_us", /* 7 */ 4, 5, 0.3048006},
272 : {"u.s. foot", /* 8 */ 4, 5, 0.3048006},
273 :
274 : {"mi", /* 9 */ 9, 10, 1612.9},
275 : {"mile", /* 10 */ 9, 10, 1612.9},
276 : {"miles", /* 11 */ 9, 10, 1612.9},
277 :
278 : {"km", /* 12 */ 12, 13, 1000.0},
279 : {"kilometers", /* 13 */ 12, 13, 1000.0},
280 : {"kilometer", /* 14 */ 12, 13, 1000.0},
281 : {"kilometre", /* 15 */ 12, 13, 1000.0},
282 :
283 : {"deg", /* 16 */ 16, 17, 0.0},
284 : {SRS_UA_DEGREE, /* 17 */ 16, 17, 0.0},
285 : {"degrees", /* 18 */ 16, 17, 0.0},
286 :
287 : {"rad", /* 19 */ 19, 20, 0.0},
288 : {SRS_UA_RADIAN, /* 20 */ 19, 20, 0.0},
289 : {"radians", /* 21 */ 19, 20, 0.0}};
290 : #define LINEAR_UNITS_COUNT (sizeof(aoLinearUnitsConv) / sizeof(ConversionTab))
291 :
292 : //----- Get the index of a given linear unit
293 : static int GetUnitIndex(const char *pszUnitName);
294 :
295 : //----- Get the default name
296 : static char *GetUnitDefault(const char *pszUnitName,
297 : const char *pszToMeter = nullptr);
298 :
299 : //----- Get the "to meter"
300 : static int GetToMeterIndex(const char *pszToMeter);
301 :
302 : //----- CSLSaveCRLF
303 : static int SaveAsCRLF(char **papszStrList, const char *pszFname);
304 :
305 : /************************************************************************/
306 : /* myCSLFetchNameValue() */
307 : /************************************************************************/
308 :
309 1192 : static const char *myCSLFetchNameValue(char **papszStrList, const char *pszName)
310 : {
311 1192 : if (papszStrList == nullptr || pszName == nullptr)
312 4 : return nullptr;
313 :
314 1188 : size_t nLen = strlen(pszName);
315 4541 : while (nLen > 0 && pszName[nLen - 1] == ' ')
316 3353 : nLen--;
317 20461 : while (*papszStrList != nullptr)
318 : {
319 20449 : if (EQUALN(*papszStrList, pszName, nLen))
320 : {
321 : size_t i;
322 4451 : for (i = nLen; (*papszStrList)[i] == ' '; ++i)
323 : {
324 : }
325 1176 : if ((*papszStrList)[i] == '=' || (*papszStrList)[i] == ':')
326 : {
327 1176 : return (*papszStrList) + i + 1;
328 : }
329 : }
330 19273 : ++papszStrList;
331 : }
332 12 : return nullptr;
333 : }
334 :
335 : /************************************************************************/
336 : /* myCSLSetNameValueSeparator() */
337 : /************************************************************************/
338 :
339 86 : static void myCSLSetNameValueSeparator(char **papszList,
340 : const char *pszSeparator)
341 : {
342 86 : const int nLines = CSLCount(papszList);
343 :
344 1926 : for (int iLine = 0; iLine < nLines; ++iLine)
345 : {
346 1840 : char *pszSep = strchr(papszList[iLine], '=');
347 1840 : if (pszSep == nullptr)
348 1164 : pszSep = strchr(papszList[iLine], ':');
349 1840 : if (pszSep == nullptr)
350 0 : continue;
351 1840 : *pszSep = '\0';
352 1840 : const char *pszKey = papszList[iLine];
353 1840 : const char *pszValue = pszSep + 1;
354 2626 : while (*pszValue == ' ')
355 786 : pszValue++;
356 :
357 3680 : char *pszNewLine = static_cast<char *>(CPLMalloc(
358 1840 : strlen(pszValue) + strlen(pszKey) + strlen(pszSeparator) + 1));
359 1840 : strcpy(pszNewLine, pszKey);
360 1840 : strcat(pszNewLine, pszSeparator);
361 1840 : strcat(pszNewLine, pszValue);
362 1840 : CPLFree(papszList[iLine]);
363 1840 : papszList[iLine] = pszNewLine;
364 : }
365 86 : }
366 :
367 : //----- Classes pre-definition:
368 : class IdrisiRasterBand;
369 :
370 : // ----------------------------------------------------------------------------
371 : // Idrisi GDALDataset
372 : // ----------------------------------------------------------------------------
373 :
374 : class IdrisiDataset final : public GDALPamDataset
375 : {
376 : friend class IdrisiRasterBand;
377 :
378 : private:
379 : VSILFILE *fp;
380 :
381 : char *pszFilename;
382 : char *pszDocFilename;
383 : char **papszRDC;
384 : double adfGeoTransform[6];
385 :
386 : mutable OGRSpatialReference m_oSRS{};
387 : char **papszCategories;
388 : char *pszUnitType;
389 : // Move GeoReference2Wkt() into header file.
390 : CPLErr Wkt2GeoReference(const OGRSpatialReference &oSRS,
391 : char **pszRefSystem, char **pszRefUnit);
392 :
393 : protected:
394 : GDALColorTable *poColorTable;
395 :
396 : public:
397 : IdrisiDataset();
398 : virtual ~IdrisiDataset();
399 :
400 : static GDALDataset *Open(GDALOpenInfo *poOpenInfo);
401 : static GDALDataset *Create(const char *pszFilename, int nXSize, int nYSize,
402 : int nBands, GDALDataType eType,
403 : char **papszOptions);
404 : static GDALDataset *CreateCopy(const char *pszFilename,
405 : GDALDataset *poSrcDS, int bStrict,
406 : char **papszOptions,
407 : GDALProgressFunc pfnProgress,
408 : void *pProgressData);
409 : virtual char **GetFileList(void) override;
410 : virtual CPLErr GetGeoTransform(double *padfTransform) override;
411 : virtual CPLErr SetGeoTransform(double *padfTransform) override;
412 :
413 : const OGRSpatialReference *GetSpatialRef() const override;
414 : CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;
415 : };
416 :
417 : // ----------------------------------------------------------------------------
418 : // Idrisi GDALPamRasterBand
419 : // ----------------------------------------------------------------------------
420 :
421 : class IdrisiRasterBand final : public GDALPamRasterBand
422 : {
423 : friend class IdrisiDataset;
424 :
425 : GDALRasterAttributeTable *poDefaultRAT;
426 :
427 : private:
428 : int nRecordSize;
429 : GByte *pabyScanLine;
430 :
431 : public:
432 : IdrisiRasterBand(IdrisiDataset *poDS, int nBand, GDALDataType eDataType);
433 : virtual ~IdrisiRasterBand();
434 :
435 : virtual double GetNoDataValue(int *pbSuccess = nullptr) override;
436 : virtual double GetMinimum(int *pbSuccess = nullptr) override;
437 : virtual double GetMaximum(int *pbSuccess = nullptr) override;
438 : virtual CPLErr IReadBlock(int nBlockXOff, int nBlockYOff,
439 : void *pImage) override;
440 : virtual CPLErr IWriteBlock(int nBlockXOff, int nBlockYOff,
441 : void *pImage) override;
442 : virtual GDALColorTable *GetColorTable() override;
443 : virtual GDALColorInterp GetColorInterpretation() override;
444 : virtual char **GetCategoryNames() override;
445 : virtual const char *GetUnitType() override;
446 :
447 : virtual CPLErr SetCategoryNames(char **papszCategoryNames) override;
448 : virtual CPLErr SetNoDataValue(double dfNoDataValue) override;
449 : virtual CPLErr SetColorTable(GDALColorTable *poColorTable) override;
450 : virtual CPLErr SetUnitType(const char *pszUnitType) override;
451 : virtual CPLErr SetStatistics(double dfMin, double dfMax, double dfMean,
452 : double dfStdDev) override;
453 : CPLErr SetMinMax(double dfMin, double dfMax);
454 : virtual GDALRasterAttributeTable *GetDefaultRAT() override;
455 : virtual CPLErr SetDefaultRAT(const GDALRasterAttributeTable *) override;
456 :
457 : float fMaximum;
458 : float fMinimum;
459 : bool bFirstVal;
460 : };
461 :
462 : // ------------------------------------------------------------------------ //
463 : // Implementation of IdrisiDataset //
464 : // ------------------------------------------------------------------------ //
465 :
466 : /************************************************************************/
467 : /* IdrisiDataset() */
468 : /************************************************************************/
469 :
470 36 : IdrisiDataset::IdrisiDataset()
471 : : fp(nullptr), pszFilename(nullptr), pszDocFilename(nullptr),
472 : papszRDC(nullptr), papszCategories(nullptr), pszUnitType(nullptr),
473 36 : poColorTable(new GDALColorTable())
474 : {
475 36 : m_oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
476 36 : adfGeoTransform[0] = 0.0;
477 36 : adfGeoTransform[1] = 1.0;
478 36 : adfGeoTransform[2] = 0.0;
479 36 : adfGeoTransform[3] = 0.0;
480 36 : adfGeoTransform[4] = 0.0;
481 36 : adfGeoTransform[5] = 1.0;
482 36 : }
483 :
484 : /************************************************************************/
485 : /* ~IdrisiDataset() */
486 : /************************************************************************/
487 :
488 72 : IdrisiDataset::~IdrisiDataset()
489 : {
490 36 : FlushCache(true);
491 :
492 36 : if (papszRDC != nullptr && eAccess == GA_Update)
493 : {
494 : // int bSuccessMin = FALSE;
495 : // int bSuccessMax = FALSE;
496 :
497 20 : double dfMin = 0.0;
498 20 : double dfMax = 0.0;
499 20 : double dfMean = 0.0;
500 20 : double dfStdDev = 0.0;
501 :
502 40 : for (int i = 0; i < nBands; i++)
503 : {
504 : IdrisiRasterBand *poBand =
505 20 : cpl::down_cast<IdrisiRasterBand *>(GetRasterBand(i + 1));
506 20 : poBand->ComputeStatistics(false, &dfMin, &dfMax, &dfMean, &dfStdDev,
507 20 : nullptr, nullptr);
508 : /*
509 : dfMin = poBand->GetMinimum( &bSuccessMin );
510 : dfMax = poBand->GetMaximum( &bSuccessMax );
511 :
512 : if( ! ( bSuccessMin && bSuccessMax ) )
513 : {
514 : poBand->GetStatistics( false, true, &dfMin, &dfMax, NULL, NULL );
515 : }
516 : */
517 20 : poBand->SetMinMax(dfMin, dfMax);
518 : }
519 :
520 20 : myCSLSetNameValueSeparator(papszRDC, ": ");
521 20 : SaveAsCRLF(papszRDC, pszDocFilename);
522 : }
523 36 : CSLDestroy(papszRDC);
524 :
525 36 : if (poColorTable)
526 : {
527 36 : delete poColorTable;
528 : }
529 36 : CPLFree(pszFilename);
530 36 : CPLFree(pszDocFilename);
531 36 : CSLDestroy(papszCategories);
532 36 : CPLFree(pszUnitType);
533 :
534 36 : if (fp != nullptr)
535 36 : VSIFCloseL(fp);
536 72 : }
537 :
538 : /************************************************************************/
539 : /* Open() */
540 : /************************************************************************/
541 :
542 34168 : GDALDataset *IdrisiDataset::Open(GDALOpenInfo *poOpenInfo)
543 : {
544 38368 : if ((poOpenInfo->fpL == nullptr) ||
545 4200 : (poOpenInfo->IsExtensionEqualToCI(extRST) == FALSE)) // modified
546 34127 : return nullptr;
547 :
548 : // --------------------------------------------------------------------
549 : // Check the documentation file .rdc
550 : // --------------------------------------------------------------------
551 :
552 : std::string osLDocFilename =
553 81 : CPLResetExtensionSafe(poOpenInfo->pszFilename, extRDC);
554 :
555 40 : if (!FileExists(osLDocFilename.c_str()))
556 : {
557 : osLDocFilename =
558 0 : CPLResetExtensionSafe(poOpenInfo->pszFilename, extRDCu);
559 :
560 0 : if (!FileExists(osLDocFilename.c_str()))
561 : {
562 0 : return nullptr;
563 : }
564 : }
565 :
566 40 : char **papszLRDC = CSLLoad(osLDocFilename.c_str());
567 :
568 40 : myCSLSetNameValueSeparator(papszLRDC, ":");
569 :
570 40 : const char *pszVersion = myCSLFetchNameValue(papszLRDC, rdcFILE_FORMAT);
571 :
572 40 : if (pszVersion == nullptr || !EQUAL(pszVersion, rstVERSION))
573 : {
574 4 : CSLDestroy(papszLRDC);
575 4 : return nullptr;
576 : }
577 :
578 : // --------------------------------------------------------------------
579 : // Create a corresponding GDALDataset
580 : // --------------------------------------------------------------------
581 :
582 36 : IdrisiDataset *poDS = new IdrisiDataset();
583 36 : poDS->eAccess = poOpenInfo->eAccess;
584 36 : poDS->pszFilename = CPLStrdup(poOpenInfo->pszFilename);
585 :
586 36 : if (poOpenInfo->eAccess == GA_ReadOnly)
587 : {
588 16 : poDS->fp = VSIFOpenL(poDS->pszFilename, "rb");
589 : }
590 : else
591 : {
592 20 : poDS->fp = VSIFOpenL(poDS->pszFilename, "r+b");
593 : }
594 :
595 36 : if (poDS->fp == nullptr)
596 : {
597 0 : CSLDestroy(papszLRDC);
598 0 : delete poDS;
599 0 : return nullptr;
600 : }
601 :
602 36 : poDS->pszDocFilename = CPLStrdup(osLDocFilename.c_str());
603 36 : poDS->papszRDC = CSLDuplicate(papszLRDC);
604 36 : CSLDestroy(papszLRDC);
605 :
606 : // --------------------------------------------------------------------
607 : // Load information from rdc
608 : // --------------------------------------------------------------------
609 :
610 36 : poDS->nRasterXSize =
611 36 : atoi_nz(myCSLFetchNameValue(poDS->papszRDC, rdcCOLUMNS));
612 36 : poDS->nRasterYSize = atoi_nz(myCSLFetchNameValue(poDS->papszRDC, rdcROWS));
613 36 : if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
614 : {
615 6 : delete poDS;
616 6 : return nullptr;
617 : }
618 :
619 : // --------------------------------------------------------------------
620 : // Create band information
621 : // --------------------------------------------------------------------
622 :
623 30 : const char *pszDataType = myCSLFetchNameValue(poDS->papszRDC, rdcDATA_TYPE);
624 30 : if (pszDataType == nullptr)
625 : {
626 0 : delete poDS;
627 0 : return nullptr;
628 : }
629 :
630 30 : if (EQUAL(pszDataType, rstBYTE))
631 : {
632 5 : poDS->nBands = 1;
633 5 : poDS->SetBand(1, new IdrisiRasterBand(poDS, 1, GDT_Byte));
634 : }
635 25 : else if (EQUAL(pszDataType, rstINTEGER))
636 : {
637 9 : poDS->nBands = 1;
638 9 : poDS->SetBand(1, new IdrisiRasterBand(poDS, 1, GDT_Int16));
639 : }
640 16 : else if (EQUAL(pszDataType, rstREAL))
641 : {
642 10 : poDS->nBands = 1;
643 10 : poDS->SetBand(1, new IdrisiRasterBand(poDS, 1, GDT_Float32));
644 : }
645 6 : else if (EQUAL(pszDataType, rstRGB24))
646 : {
647 6 : poDS->nBands = 3;
648 6 : poDS->SetBand(1, new IdrisiRasterBand(poDS, 1, GDT_Byte));
649 6 : poDS->SetBand(2, new IdrisiRasterBand(poDS, 2, GDT_Byte));
650 6 : poDS->SetBand(3, new IdrisiRasterBand(poDS, 3, GDT_Byte));
651 : }
652 : else
653 : {
654 0 : CPLError(CE_Failure, CPLE_AppDefined, "Unknown data type : %s",
655 : pszDataType);
656 0 : delete poDS;
657 0 : return nullptr;
658 : }
659 :
660 72 : for (int i = 0; i < poDS->nBands; i++)
661 : {
662 : IdrisiRasterBand *band =
663 42 : cpl::down_cast<IdrisiRasterBand *>(poDS->GetRasterBand(i + 1));
664 42 : if (band->pabyScanLine == nullptr)
665 : {
666 0 : delete poDS;
667 0 : return nullptr;
668 : }
669 : }
670 :
671 : // --------------------------------------------------------------------
672 : // Load the transformation matrix
673 : // --------------------------------------------------------------------
674 :
675 30 : const char *pszMinX = myCSLFetchNameValue(poDS->papszRDC, rdcMIN_X);
676 30 : const char *pszMaxX = myCSLFetchNameValue(poDS->papszRDC, rdcMAX_X);
677 30 : const char *pszMinY = myCSLFetchNameValue(poDS->papszRDC, rdcMIN_Y);
678 30 : const char *pszMaxY = myCSLFetchNameValue(poDS->papszRDC, rdcMAX_Y);
679 30 : const char *pszUnit = myCSLFetchNameValue(poDS->papszRDC, rdcUNIT_DIST);
680 :
681 30 : if (pszMinX != nullptr && strlen(pszMinX) > 0 && pszMaxX != nullptr &&
682 30 : strlen(pszMaxX) > 0 && pszMinY != nullptr && strlen(pszMinY) > 0 &&
683 30 : pszMaxY != nullptr && strlen(pszMaxY) > 0 && pszUnit != nullptr &&
684 30 : strlen(pszUnit) > 0)
685 : {
686 : double dfMinX, dfMaxX, dfMinY, dfMaxY, dfUnit, dfXPixSz, dfYPixSz;
687 :
688 30 : dfMinX = CPLAtof_nz(pszMinX);
689 30 : dfMaxX = CPLAtof_nz(pszMaxX);
690 30 : dfMinY = CPLAtof_nz(pszMinY);
691 30 : dfMaxY = CPLAtof_nz(pszMaxY);
692 30 : dfUnit = CPLAtof_nz(pszUnit);
693 :
694 30 : dfMinX = dfMinX * dfUnit;
695 30 : dfMaxX = dfMaxX * dfUnit;
696 30 : dfMinY = dfMinY * dfUnit;
697 30 : dfMaxY = dfMaxY * dfUnit;
698 :
699 30 : dfYPixSz = (dfMinY - dfMaxY) / poDS->nRasterYSize;
700 30 : dfXPixSz = (dfMaxX - dfMinX) / poDS->nRasterXSize;
701 :
702 30 : poDS->adfGeoTransform[0] = dfMinX;
703 30 : poDS->adfGeoTransform[1] = dfXPixSz;
704 30 : poDS->adfGeoTransform[2] = 0.0;
705 30 : poDS->adfGeoTransform[3] = dfMaxY;
706 30 : poDS->adfGeoTransform[4] = 0.0;
707 30 : poDS->adfGeoTransform[5] = dfYPixSz;
708 : }
709 :
710 : // --------------------------------------------------------------------
711 : // Set Color Table in the presence of a smp file
712 : // --------------------------------------------------------------------
713 :
714 30 : if (poDS->nBands != 3)
715 : {
716 : const std::string osSMPFilename =
717 48 : CPLResetExtensionSafe(poDS->pszFilename, extSMP);
718 24 : VSILFILE *fpSMP = VSIFOpenL(osSMPFilename.c_str(), "rb");
719 24 : if (fpSMP != nullptr)
720 : {
721 : int dfMaxValue =
722 0 : atoi_nz(myCSLFetchNameValue(poDS->papszRDC, rdcMAX_VALUE));
723 : int nCatCount =
724 0 : atoi_nz(myCSLFetchNameValue(poDS->papszRDC, rdcLEGEND_CATS));
725 0 : if (nCatCount == 0)
726 0 : dfMaxValue = 255;
727 0 : VSIFSeekL(fpSMP, smpHEADERSIZE, SEEK_SET);
728 : GDALColorEntry oEntry;
729 : unsigned char aucRGB[3];
730 0 : int i = 0;
731 0 : while ((VSIFReadL(&aucRGB, sizeof(aucRGB), 1, fpSMP)) &&
732 : (i <= dfMaxValue))
733 : {
734 0 : oEntry.c1 = (short)aucRGB[0];
735 0 : oEntry.c2 = (short)aucRGB[1];
736 0 : oEntry.c3 = (short)aucRGB[2];
737 0 : oEntry.c4 = (short)255;
738 0 : poDS->poColorTable->SetColorEntry(i, &oEntry);
739 0 : i++;
740 : }
741 0 : VSIFCloseL(fpSMP);
742 : }
743 : }
744 :
745 : // --------------------------------------------------------------------
746 : // Check for Unit Type
747 : // --------------------------------------------------------------------
748 :
749 : const char *pszValueUnit =
750 30 : myCSLFetchNameValue(poDS->papszRDC, rdcVALUE_UNITS);
751 :
752 30 : if (pszValueUnit == nullptr)
753 0 : poDS->pszUnitType = CPLStrdup("unspecified");
754 : else
755 : {
756 30 : if (STARTS_WITH_CI(pszValueUnit, "meter"))
757 : {
758 0 : poDS->pszUnitType = CPLStrdup("m");
759 : }
760 30 : else if (STARTS_WITH_CI(pszValueUnit, "feet"))
761 : {
762 0 : poDS->pszUnitType = CPLStrdup("ft");
763 : }
764 : else
765 30 : poDS->pszUnitType = CPLStrdup(pszValueUnit);
766 : }
767 :
768 : // --------------------------------------------------------------------
769 : // Check for category names.
770 : // --------------------------------------------------------------------
771 :
772 : int nCatCount =
773 30 : atoi_nz(myCSLFetchNameValue(poDS->papszRDC, rdcLEGEND_CATS));
774 :
775 30 : if (nCatCount > 0)
776 : {
777 : // ----------------------------------------------------------------
778 : // Sequentialize categories names, from 0 to the last "code n"
779 : // ----------------------------------------------------------------
780 :
781 0 : int nLine = -1;
782 0 : for (int i = 0; (i < CSLCount(poDS->papszRDC)) && (nLine == -1); i++)
783 0 : if (EQUALN(poDS->papszRDC[i], rdcLEGEND_CATS, 11))
784 0 : nLine = i; // get the line where legend cats is
785 :
786 0 : if (nLine > 0)
787 : {
788 0 : int nCode = 0;
789 0 : int nCount = 0;
790 0 : sscanf(poDS->papszRDC[++nLine], rdcCODE_N,
791 : &nCode); // assign legend cats to nCode
792 0 : for (int i = 0; (i < 255) && (nCount < nCatCount); i++)
793 : {
794 0 : if (i == nCode)
795 : {
796 0 : poDS->papszCategories = CSLAddString(
797 : poDS->papszCategories,
798 0 : CPLParseNameValue(poDS->papszRDC[nLine], nullptr));
799 0 : nCount++;
800 0 : if (nCount < nCatCount)
801 0 : sscanf(poDS->papszRDC[++nLine], rdcCODE_N, &nCode);
802 : }
803 : else
804 0 : poDS->papszCategories =
805 0 : CSLAddString(poDS->papszCategories, "");
806 : }
807 : }
808 : }
809 :
810 : /* -------------------------------------------------------------------- */
811 : /* Automatic Generated Color Table */
812 : /* -------------------------------------------------------------------- */
813 :
814 30 : if (poDS->papszCategories != nullptr &&
815 0 : (poDS->poColorTable->GetColorEntryCount() == 0))
816 : {
817 0 : int nEntryCount = CSLCount(poDS->papszCategories);
818 :
819 : GDALColorEntry sFromColor;
820 0 : sFromColor.c1 = (short)(255);
821 0 : sFromColor.c2 = (short)(0);
822 0 : sFromColor.c3 = (short)(0);
823 0 : sFromColor.c4 = (short)(255);
824 :
825 : GDALColorEntry sToColor;
826 0 : sToColor.c1 = (short)(0);
827 0 : sToColor.c2 = (short)(0);
828 0 : sToColor.c3 = (short)(255);
829 0 : sToColor.c4 = (short)(255);
830 :
831 0 : poDS->poColorTable->CreateColorRamp(0, &sFromColor, (nEntryCount - 1),
832 : &sToColor);
833 : }
834 :
835 : /* -------------------------------------------------------------------- */
836 : /* Initialize any PAM information. */
837 : /* -------------------------------------------------------------------- */
838 :
839 30 : poDS->SetDescription(poOpenInfo->pszFilename);
840 30 : poDS->TryLoadXML();
841 :
842 : /* -------------------------------------------------------------------- */
843 : /* Check for external overviews. */
844 : /* -------------------------------------------------------------------- */
845 :
846 30 : poDS->oOvManager.Initialize(poDS, poOpenInfo->pszFilename);
847 :
848 30 : return poDS;
849 : }
850 :
851 : /************************************************************************/
852 : /* Create() */
853 : /************************************************************************/
854 :
855 50 : GDALDataset *IdrisiDataset::Create(const char *pszFilename, int nXSize,
856 : int nYSize, int nBandsIn, GDALDataType eType,
857 : char ** /* papszOptions */)
858 : {
859 : // --------------------------------------------------------------------
860 : // Check input options
861 : // --------------------------------------------------------------------
862 :
863 50 : if (nBandsIn != 1 && nBandsIn != 3)
864 : {
865 4 : CPLError(CE_Failure, CPLE_AppDefined,
866 : "Attempt to create IDRISI dataset with an illegal number of "
867 : "bands(%d)."
868 : " Try again by selecting a specific band if possible. \n",
869 : nBandsIn);
870 4 : return nullptr;
871 : }
872 :
873 46 : if (nBandsIn == 3 && eType != GDT_Byte)
874 : {
875 13 : CPLError(
876 : CE_Failure, CPLE_AppDefined,
877 : "Attempt to create IDRISI dataset with an unsupported combination "
878 : "of the number of bands(%d) and data type(%s). \n",
879 : nBandsIn, GDALGetDataTypeName(eType));
880 13 : return nullptr;
881 : }
882 :
883 : // ----------------------------------------------------------------
884 : // Create the header file with minimum information
885 : // ----------------------------------------------------------------
886 :
887 33 : const char *pszLDataType = nullptr;
888 :
889 33 : switch (eType)
890 : {
891 17 : case GDT_Byte:
892 17 : if (nBandsIn == 1)
893 14 : pszLDataType = rstBYTE;
894 : else
895 3 : pszLDataType = rstRGB24;
896 17 : break;
897 2 : case GDT_Int16:
898 2 : pszLDataType = rstINTEGER;
899 2 : break;
900 3 : case GDT_Float32:
901 3 : pszLDataType = rstREAL;
902 3 : break;
903 : //--- process compatible data types
904 1 : case (GDT_UInt16):
905 1 : pszLDataType = rstINTEGER;
906 1 : CPLError(CE_Warning, CPLE_AppDefined,
907 : "This process requires a conversion from %s to signed "
908 : "16-bit %s, "
909 : "which may cause data loss.\n",
910 : GDALGetDataTypeName(eType), rstINTEGER);
911 1 : break;
912 1 : case GDT_UInt32:
913 1 : pszLDataType = rstINTEGER;
914 1 : CPLError(CE_Warning, CPLE_AppDefined,
915 : "This process requires a conversion from %s to signed "
916 : "16-bit %s, "
917 : "which may cause data loss.\n",
918 : GDALGetDataTypeName(eType), rstINTEGER);
919 1 : break;
920 1 : case GDT_Int32:
921 1 : pszLDataType = rstINTEGER;
922 1 : CPLError(CE_Warning, CPLE_AppDefined,
923 : "This process requires a conversion from %s to signed "
924 : "16-bit %s, "
925 : "which may cause data loss.\n",
926 : GDALGetDataTypeName(eType), rstINTEGER);
927 1 : break;
928 1 : case GDT_Float64:
929 1 : pszLDataType = rstREAL;
930 1 : CPLError(CE_Warning, CPLE_AppDefined,
931 : "This process requires a conversion from %s to float "
932 : "32-bit %s, "
933 : "which may cause data loss.\n",
934 : GDALGetDataTypeName(eType), rstREAL);
935 1 : break;
936 7 : default:
937 7 : CPLError(CE_Failure, CPLE_AppDefined,
938 : "Attempt to create IDRISI dataset with an illegal "
939 : "data type(%s).\n",
940 : GDALGetDataTypeName(eType));
941 7 : return nullptr;
942 : };
943 :
944 26 : char **papszLRDC = nullptr;
945 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcFILE_FORMAT, rstVERSION);
946 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcFILE_TITLE, "");
947 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcDATA_TYPE, pszLDataType);
948 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcFILE_TYPE, "binary");
949 : papszLRDC =
950 26 : CSLAddNameValue(papszLRDC, rdcCOLUMNS, CPLSPrintf("%d", nXSize));
951 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcROWS, CPLSPrintf("%d", nYSize));
952 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcREF_SYSTEM, "plane");
953 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcREF_UNITS, "m");
954 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcUNIT_DIST, "1");
955 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMIN_X, "0");
956 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMAX_X, CPLSPrintf("%d", nXSize));
957 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMIN_Y, "0");
958 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMAX_Y, CPLSPrintf("%d", nYSize));
959 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcPOSN_ERROR, "unspecified");
960 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcRESOLUTION, "1.0");
961 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMIN_VALUE, "0");
962 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcMAX_VALUE, "0");
963 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcDISPLAY_MIN, "0");
964 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcDISPLAY_MAX, "0");
965 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcVALUE_UNITS, "unspecified");
966 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcVALUE_ERROR, "unspecified");
967 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcFLAG_VALUE, "none");
968 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcFLAG_DEFN, "none");
969 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcLEGEND_CATS, "0");
970 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcLINEAGES, "");
971 26 : papszLRDC = CSLAddNameValue(papszLRDC, rdcCOMMENTS, "");
972 :
973 : const std::string osLDocFilename =
974 52 : CPLResetExtensionSafe(pszFilename, extRDC);
975 :
976 26 : myCSLSetNameValueSeparator(papszLRDC, ": ");
977 26 : SaveAsCRLF(papszLRDC, osLDocFilename.c_str());
978 26 : CSLDestroy(papszLRDC);
979 :
980 : // ----------------------------------------------------------------
981 : // Create an empty data file
982 : // ----------------------------------------------------------------
983 :
984 26 : VSILFILE *fp = VSIFOpenL(pszFilename, "wb+");
985 :
986 26 : if (fp == nullptr)
987 : {
988 2 : CPLError(CE_Failure, CPLE_OpenFailed,
989 : "Attempt to create file %s' failed.\n", pszFilename);
990 2 : return nullptr;
991 : }
992 :
993 36 : const int nTargetDTSize = EQUAL(pszLDataType, rstBYTE) ? 1
994 19 : : EQUAL(pszLDataType, rstINTEGER) ? 2
995 7 : : EQUAL(pszLDataType, rstRGB24) ? 3
996 : : 4;
997 24 : VSIFTruncateL(fp,
998 24 : static_cast<vsi_l_offset>(nXSize) * nYSize * nTargetDTSize);
999 24 : VSIFCloseL(fp);
1000 :
1001 24 : return (IdrisiDataset *)GDALOpen(pszFilename, GA_Update);
1002 : }
1003 :
1004 : /************************************************************************/
1005 : /* CreateCopy() */
1006 : /************************************************************************/
1007 :
1008 29 : GDALDataset *IdrisiDataset::CreateCopy(const char *pszFilename,
1009 : GDALDataset *poSrcDS, int bStrict,
1010 : char **papszOptions,
1011 : GDALProgressFunc pfnProgress,
1012 : void *pProgressData)
1013 : {
1014 29 : if (!pfnProgress(0.0, nullptr, pProgressData))
1015 0 : return nullptr;
1016 :
1017 : // ------------------------------------------------------------------------
1018 : // Check number of bands
1019 : // ------------------------------------------------------------------------
1020 29 : if (!(poSrcDS->GetRasterCount() == 1) && !(poSrcDS->GetRasterCount() == 3))
1021 : {
1022 4 : CPLError(CE_Failure, CPLE_AppDefined,
1023 : "Attempt to create IDRISI dataset with an illegal number of "
1024 : "bands(%d)."
1025 : " Try again by selecting a specific band if possible.\n",
1026 : poSrcDS->GetRasterCount());
1027 4 : return nullptr;
1028 : }
1029 27 : if ((poSrcDS->GetRasterCount() == 3) &&
1030 2 : ((poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte) ||
1031 2 : (poSrcDS->GetRasterBand(2)->GetRasterDataType() != GDT_Byte) ||
1032 2 : (poSrcDS->GetRasterBand(3)->GetRasterDataType() != GDT_Byte)))
1033 : {
1034 0 : CPLError(
1035 : CE_Failure, CPLE_AppDefined,
1036 : "Attempt to create IDRISI dataset with an unsupported "
1037 : "data type when there are three bands. Only BYTE allowed.\n"
1038 : "Try again by selecting a specific band to convert if possible.\n");
1039 0 : return nullptr;
1040 : }
1041 :
1042 : // ------------------------------------------------------------------------
1043 : // Check Data types
1044 : // ------------------------------------------------------------------------
1045 :
1046 46 : for (int i = 1; i <= poSrcDS->GetRasterCount(); i++)
1047 : {
1048 29 : GDALDataType eType = poSrcDS->GetRasterBand(i)->GetRasterDataType();
1049 :
1050 29 : if (bStrict)
1051 : {
1052 25 : if (eType != GDT_Byte && eType != GDT_Int16 && eType != GDT_Float32)
1053 : {
1054 8 : CPLError(CE_Failure, CPLE_AppDefined,
1055 : "Attempt to create IDRISI dataset in strict mode "
1056 : "with an illegal data type(%s).\n",
1057 : GDALGetDataTypeName(eType));
1058 8 : return nullptr;
1059 : }
1060 : }
1061 : else
1062 : {
1063 4 : if (eType != GDT_Byte && eType != GDT_Int16 &&
1064 0 : eType != GDT_UInt16 && eType != GDT_UInt32 &&
1065 0 : eType != GDT_Int32 && eType != GDT_Float32 &&
1066 : eType != GDT_Float64)
1067 : {
1068 0 : CPLError(CE_Failure, CPLE_AppDefined,
1069 : "Attempt to create IDRISI dataset with an illegal "
1070 : "data type(%s).\n",
1071 : GDALGetDataTypeName(eType));
1072 0 : return nullptr;
1073 : }
1074 : }
1075 : }
1076 :
1077 : // --------------------------------------------------------------------
1078 : // Define data type
1079 : // --------------------------------------------------------------------
1080 :
1081 17 : GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
1082 17 : GDALDataType eType = poBand->GetRasterDataType();
1083 :
1084 17 : int bSuccessMin = FALSE;
1085 17 : int bSuccessMax = FALSE;
1086 :
1087 17 : double dfMin = poBand->GetMinimum(&bSuccessMin);
1088 17 : double dfMax = poBand->GetMaximum(&bSuccessMax);
1089 :
1090 17 : if (!(bSuccessMin && bSuccessMax))
1091 : {
1092 6 : poBand->GetStatistics(false, true, &dfMin, &dfMax, nullptr, nullptr);
1093 : }
1094 :
1095 17 : if (!((eType == GDT_Byte) || (eType == GDT_Int16) ||
1096 : (eType == GDT_Float32)))
1097 : {
1098 0 : if (eType == GDT_Float64)
1099 : {
1100 0 : eType = GDT_Float32;
1101 : }
1102 : else
1103 : {
1104 0 : if ((dfMin < (double)SHRT_MIN) || (dfMax > (double)SHRT_MAX))
1105 : {
1106 0 : eType = GDT_Float32;
1107 : }
1108 : else
1109 : {
1110 0 : eType = GDT_Int16;
1111 : }
1112 : }
1113 : }
1114 :
1115 : // --------------------------------------------------------------------
1116 : // Create the dataset
1117 : // --------------------------------------------------------------------
1118 :
1119 17 : IdrisiDataset *poDS = cpl::down_cast<IdrisiDataset *>(IdrisiDataset::Create(
1120 : pszFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(),
1121 : poSrcDS->GetRasterCount(), eType, papszOptions));
1122 :
1123 17 : if (poDS == nullptr)
1124 12 : return nullptr;
1125 :
1126 : // --------------------------------------------------------------------
1127 : // Copy information to the dataset
1128 : // --------------------------------------------------------------------
1129 :
1130 : double adfGeoTransform[6];
1131 5 : if (poSrcDS->GetGeoTransform(adfGeoTransform) == CE_None)
1132 : {
1133 5 : poDS->SetGeoTransform(adfGeoTransform);
1134 : }
1135 :
1136 5 : if (!EQUAL(poSrcDS->GetProjectionRef(), ""))
1137 : {
1138 5 : poDS->SetProjection(poSrcDS->GetProjectionRef());
1139 : }
1140 :
1141 : // --------------------------------------------------------------------
1142 : // Copy information to the raster band(s)
1143 : // --------------------------------------------------------------------
1144 :
1145 14 : for (int i = 1; i <= poDS->nBands; i++)
1146 : {
1147 9 : GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(i);
1148 : IdrisiRasterBand *poDstBand =
1149 9 : cpl::down_cast<IdrisiRasterBand *>(poDS->GetRasterBand(i));
1150 :
1151 9 : if (poDS->nBands == 1)
1152 : {
1153 3 : poDstBand->SetUnitType(poSrcBand->GetUnitType());
1154 3 : poDstBand->SetColorTable(poSrcBand->GetColorTable());
1155 3 : poDstBand->SetCategoryNames(poSrcBand->GetCategoryNames());
1156 :
1157 3 : const GDALRasterAttributeTable *poRAT = poSrcBand->GetDefaultRAT();
1158 :
1159 3 : if (poRAT != nullptr)
1160 : {
1161 0 : poDstBand->SetDefaultRAT(poRAT);
1162 : }
1163 : }
1164 :
1165 9 : dfMin = poSrcBand->GetMinimum(nullptr);
1166 9 : dfMax = poSrcBand->GetMaximum(nullptr);
1167 9 : poDstBand->SetMinMax(dfMin, dfMax);
1168 : int bHasNoDataValue;
1169 9 : double dfNoDataValue = poSrcBand->GetNoDataValue(&bHasNoDataValue);
1170 9 : if (bHasNoDataValue)
1171 0 : poDstBand->SetNoDataValue(dfNoDataValue);
1172 : }
1173 :
1174 : // --------------------------------------------------------------------
1175 : // Copy image data
1176 : // --------------------------------------------------------------------
1177 :
1178 5 : if (GDALDatasetCopyWholeRaster((GDALDatasetH)poSrcDS, (GDALDatasetH)poDS,
1179 : nullptr, pfnProgress,
1180 5 : pProgressData) != CE_None)
1181 : {
1182 0 : delete poDS;
1183 0 : return nullptr;
1184 : }
1185 :
1186 : // --------------------------------------------------------------------
1187 : // Finalize
1188 : // --------------------------------------------------------------------
1189 :
1190 5 : poDS->FlushCache(false);
1191 :
1192 5 : return poDS;
1193 : }
1194 :
1195 : /************************************************************************/
1196 : /* GetFileList() */
1197 : /************************************************************************/
1198 :
1199 4 : char **IdrisiDataset::GetFileList()
1200 : {
1201 4 : char **papszFileList = GDALPamDataset::GetFileList();
1202 :
1203 : // --------------------------------------------------------------------
1204 : // Symbol table file
1205 : // --------------------------------------------------------------------
1206 :
1207 4 : std::string osAssociated = CPLResetExtensionSafe(pszFilename, extSMP);
1208 :
1209 4 : if (FileExists(osAssociated.c_str()))
1210 : {
1211 0 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1212 : }
1213 : else
1214 : {
1215 4 : osAssociated = CPLResetExtensionSafe(pszFilename, extSMPu);
1216 :
1217 4 : if (FileExists(osAssociated.c_str()))
1218 : {
1219 0 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1220 : }
1221 : }
1222 :
1223 : // --------------------------------------------------------------------
1224 : // Documentation file
1225 : // --------------------------------------------------------------------
1226 :
1227 4 : osAssociated = CPLResetExtensionSafe(pszFilename, extRDC);
1228 :
1229 4 : if (FileExists(osAssociated.c_str()))
1230 : {
1231 4 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1232 : }
1233 : else
1234 : {
1235 0 : osAssociated = CPLResetExtensionSafe(pszFilename, extRDCu);
1236 :
1237 0 : if (FileExists(osAssociated.c_str()))
1238 : {
1239 0 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1240 : }
1241 : }
1242 :
1243 : // --------------------------------------------------------------------
1244 : // Reference file
1245 : // --------------------------------------------------------------------
1246 :
1247 4 : osAssociated = CPLResetExtensionSafe(pszFilename, extREF);
1248 :
1249 4 : if (FileExists(osAssociated.c_str()))
1250 : {
1251 0 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1252 : }
1253 : else
1254 : {
1255 4 : osAssociated = CPLResetExtensionSafe(pszFilename, extREFu);
1256 :
1257 4 : if (FileExists(osAssociated.c_str()))
1258 : {
1259 0 : papszFileList = CSLAddString(papszFileList, osAssociated.c_str());
1260 : }
1261 : }
1262 :
1263 8 : return papszFileList;
1264 : }
1265 :
1266 : /************************************************************************/
1267 : /* GetGeoTransform() */
1268 : /************************************************************************/
1269 :
1270 9 : CPLErr IdrisiDataset::GetGeoTransform(double *padfTransform)
1271 : {
1272 9 : if (GDALPamDataset::GetGeoTransform(padfTransform) != CE_None)
1273 : {
1274 9 : memcpy(padfTransform, adfGeoTransform, sizeof(double) * 6);
1275 : /*
1276 : if( adfGeoTransform[0] == 0.0
1277 : && adfGeoTransform[1] == 1.0
1278 : && adfGeoTransform[2] == 0.0
1279 : && adfGeoTransform[3] == 0.0
1280 : && adfGeoTransform[4] == 0.0
1281 : && adfGeoTransform[5] == 1.0 )
1282 : return CE_Failure;
1283 : */
1284 : }
1285 :
1286 9 : return CE_None;
1287 : }
1288 :
1289 : /************************************************************************/
1290 : /* SetGeoTransform() */
1291 : /************************************************************************/
1292 :
1293 13 : CPLErr IdrisiDataset::SetGeoTransform(double *padfTransform)
1294 : {
1295 13 : if (padfTransform[2] != 0.0 || padfTransform[4] != 0.0)
1296 : {
1297 0 : CPLError(CE_Failure, CPLE_AppDefined,
1298 : "Attempt to set rotated geotransform on Idrisi Raster file.\n"
1299 : "Idrisi Raster does not support rotation.\n");
1300 0 : return CE_Failure;
1301 : }
1302 :
1303 : // --------------------------------------------------------------------
1304 : // Update the .rdc file
1305 : // --------------------------------------------------------------------
1306 :
1307 13 : double dfXPixSz = padfTransform[1];
1308 13 : double dfYPixSz = padfTransform[5];
1309 13 : double dfMinX = padfTransform[0];
1310 13 : double dfMaxX = (dfXPixSz * nRasterXSize) + dfMinX;
1311 :
1312 : double dfMinY, dfMaxY;
1313 13 : if (dfYPixSz < 0)
1314 : {
1315 13 : dfMaxY = padfTransform[3];
1316 13 : dfMinY = (dfYPixSz * nRasterYSize) + padfTransform[3];
1317 : }
1318 : else
1319 : {
1320 0 : dfMaxY = (dfYPixSz * nRasterYSize) + padfTransform[3];
1321 0 : dfMinY = padfTransform[3];
1322 : }
1323 :
1324 13 : papszRDC = CSLSetNameValue(papszRDC, rdcMIN_X, CPLSPrintf("%.7f", dfMinX));
1325 13 : papszRDC = CSLSetNameValue(papszRDC, rdcMAX_X, CPLSPrintf("%.7f", dfMaxX));
1326 13 : papszRDC = CSLSetNameValue(papszRDC, rdcMIN_Y, CPLSPrintf("%.7f", dfMinY));
1327 13 : papszRDC = CSLSetNameValue(papszRDC, rdcMAX_Y, CPLSPrintf("%.7f", dfMaxY));
1328 13 : papszRDC = CSLSetNameValue(papszRDC, rdcRESOLUTION,
1329 : CPLSPrintf("%.7f", fabs(dfYPixSz)));
1330 :
1331 : // --------------------------------------------------------------------
1332 : // Update the Dataset attribute
1333 : // --------------------------------------------------------------------
1334 :
1335 13 : memcpy(adfGeoTransform, padfTransform, sizeof(double) * 6);
1336 :
1337 13 : return CE_None;
1338 : }
1339 :
1340 : /************************************************************************/
1341 : /* GetSpatialRef() */
1342 : /************************************************************************/
1343 :
1344 1 : const OGRSpatialReference *IdrisiDataset::GetSpatialRef() const
1345 : {
1346 1 : const auto poSRS = GDALPamDataset::GetSpatialRef();
1347 1 : if (poSRS)
1348 0 : return poSRS;
1349 :
1350 1 : if (m_oSRS.IsEmpty())
1351 : {
1352 1 : const char *pszRefSystem = myCSLFetchNameValue(papszRDC, rdcREF_SYSTEM);
1353 1 : const char *pszRefUnit = myCSLFetchNameValue(papszRDC, rdcREF_UNITS);
1354 1 : if (pszRefSystem != nullptr && pszRefUnit != nullptr)
1355 1 : IdrisiGeoReference2Wkt(pszFilename, pszRefSystem, pszRefUnit,
1356 1 : m_oSRS);
1357 : }
1358 1 : return m_oSRS.IsEmpty() ? nullptr : &m_oSRS;
1359 : }
1360 :
1361 : /************************************************************************/
1362 : /* SetProjection() */
1363 : /************************************************************************/
1364 :
1365 13 : CPLErr IdrisiDataset::SetSpatialRef(const OGRSpatialReference *poSRS)
1366 : {
1367 13 : m_oSRS.Clear();
1368 13 : if (poSRS)
1369 13 : m_oSRS = *poSRS;
1370 :
1371 13 : char *pszRefSystem = nullptr;
1372 13 : char *pszRefUnit = nullptr;
1373 :
1374 13 : CPLErr eResult = Wkt2GeoReference(m_oSRS, &pszRefSystem, &pszRefUnit);
1375 :
1376 13 : papszRDC = CSLSetNameValue(papszRDC, rdcREF_SYSTEM, pszRefSystem);
1377 13 : papszRDC = CSLSetNameValue(papszRDC, rdcREF_UNITS, pszRefUnit);
1378 :
1379 13 : CPLFree(pszRefSystem);
1380 13 : CPLFree(pszRefUnit);
1381 :
1382 13 : return eResult;
1383 : }
1384 :
1385 : /************************************************************************/
1386 : /* IdrisiRasterBand() */
1387 : /************************************************************************/
1388 :
1389 42 : IdrisiRasterBand::IdrisiRasterBand(IdrisiDataset *poDSIn, int nBandIn,
1390 42 : GDALDataType eDataTypeIn)
1391 : : poDefaultRAT(nullptr),
1392 126 : nRecordSize(poDSIn->GetRasterXSize() * poDSIn->nBands *
1393 42 : GDALGetDataTypeSizeBytes(eDataTypeIn)),
1394 42 : pabyScanLine(static_cast<GByte *>(VSI_MALLOC3_VERBOSE(
1395 : poDSIn->GetRasterXSize(), GDALGetDataTypeSizeBytes(eDataTypeIn),
1396 : poDSIn->nBands))),
1397 84 : fMaximum(0.0), fMinimum(0.0), bFirstVal(true)
1398 : {
1399 42 : poDS = poDSIn;
1400 42 : nBand = nBandIn;
1401 42 : eDataType = eDataTypeIn;
1402 42 : nBlockYSize = 1;
1403 42 : nBlockXSize = poDS->GetRasterXSize();
1404 42 : }
1405 :
1406 : /************************************************************************/
1407 : /* ~IdrisiRasterBand() */
1408 : /************************************************************************/
1409 :
1410 84 : IdrisiRasterBand::~IdrisiRasterBand()
1411 : {
1412 42 : CPLFree(pabyScanLine);
1413 :
1414 42 : if (poDefaultRAT)
1415 : {
1416 0 : delete poDefaultRAT;
1417 : }
1418 84 : }
1419 :
1420 : /************************************************************************/
1421 : /* IReadBlock() */
1422 : /************************************************************************/
1423 :
1424 1392 : CPLErr IdrisiRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff,
1425 : void *pImage)
1426 : {
1427 1392 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1428 :
1429 1392 : if (VSIFSeekL(poGDS->fp, vsi_l_offset(nRecordSize) * nBlockYOff, SEEK_SET) <
1430 : 0)
1431 : {
1432 0 : CPLError(CE_Failure, CPLE_FileIO,
1433 : "Can't seek(%s) block with X offset %d and Y offset %d.\n%s",
1434 : poGDS->pszFilename, nBlockXOff, nBlockYOff,
1435 0 : VSIStrerror(errno));
1436 0 : return CE_Failure;
1437 : }
1438 :
1439 1392 : if ((int)VSIFReadL(pabyScanLine, 1, nRecordSize, poGDS->fp) < nRecordSize)
1440 : {
1441 0 : CPLError(CE_Failure, CPLE_FileIO,
1442 : "Can't read(%s) block with X offset %d and Y offset %d.\n%s",
1443 : poGDS->pszFilename, nBlockXOff, nBlockYOff,
1444 0 : VSIStrerror(errno));
1445 0 : return CE_Failure;
1446 : }
1447 :
1448 1392 : if (poGDS->nBands == 3)
1449 : {
1450 43380 : for (int i = 0, j = (3 - nBand); i < nBlockXSize; i++, j += 3)
1451 : {
1452 42800 : ((GByte *)pImage)[i] = pabyScanLine[j];
1453 : }
1454 : }
1455 : else
1456 : {
1457 812 : memcpy(pImage, pabyScanLine, nRecordSize);
1458 : }
1459 :
1460 : #ifdef CPL_MSB
1461 : if (eDataType == GDT_Float32)
1462 : GDALSwapWords(pImage, 4, nBlockXSize * nBlockYSize, 4);
1463 : #endif
1464 :
1465 1392 : return CE_None;
1466 : }
1467 :
1468 : /************************************************************************/
1469 : /* IWriteBlock() */
1470 : /************************************************************************/
1471 :
1472 230 : CPLErr IdrisiRasterBand::IWriteBlock(int nBlockXOff, int nBlockYOff,
1473 : void *pImage)
1474 : {
1475 230 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1476 :
1477 : #ifdef CPL_MSB
1478 : // Swap in input buffer if needed.
1479 : if (eDataType == GDT_Float32)
1480 : GDALSwapWords(pImage, 4, nBlockXSize * nBlockYSize, 4);
1481 : #endif
1482 :
1483 230 : if (poGDS->nBands == 1)
1484 : {
1485 50 : memcpy(pabyScanLine, pImage, nRecordSize);
1486 : }
1487 : else
1488 : {
1489 180 : if (nBand > 1)
1490 : {
1491 120 : VSIFSeekL(poGDS->fp, vsi_l_offset(nRecordSize) * nBlockYOff,
1492 : SEEK_SET);
1493 120 : VSIFReadL(pabyScanLine, 1, nRecordSize, poGDS->fp);
1494 : }
1495 : int i, j;
1496 7980 : for (i = 0, j = (3 - nBand); i < nBlockXSize; i++, j += 3)
1497 : {
1498 7800 : pabyScanLine[j] = ((GByte *)pImage)[i];
1499 : }
1500 : }
1501 :
1502 : #ifdef CPL_MSB
1503 : // Swap input buffer back to original form.
1504 : if (eDataType == GDT_Float32)
1505 : GDALSwapWords(pImage, 4, nBlockXSize * nBlockYSize, 4);
1506 : #endif
1507 :
1508 230 : VSIFSeekL(poGDS->fp, vsi_l_offset(nRecordSize) * nBlockYOff, SEEK_SET);
1509 :
1510 230 : if ((int)VSIFWriteL(pabyScanLine, 1, nRecordSize, poGDS->fp) < nRecordSize)
1511 : {
1512 0 : CPLError(CE_Failure, CPLE_FileIO,
1513 : "Can't write(%s) block with X offset %d and Y offset %d.\n%s",
1514 : poGDS->pszFilename, nBlockXOff, nBlockYOff,
1515 0 : VSIStrerror(errno));
1516 0 : return CE_Failure;
1517 : }
1518 :
1519 230 : int bHasNoDataValue = FALSE;
1520 230 : float fNoDataValue = (float)GetNoDataValue(&bHasNoDataValue);
1521 :
1522 : // --------------------------------------------------------------------
1523 : // Search for the minimum and maximum values
1524 : // --------------------------------------------------------------------
1525 :
1526 230 : if (eDataType == GDT_Float32)
1527 : {
1528 530 : for (int i = 0; i < nBlockXSize; i++)
1529 : {
1530 500 : float fVal =
1531 500 : reinterpret_cast<float *>(pabyScanLine)[i]; // this is fine
1532 500 : if (!bHasNoDataValue || fVal != fNoDataValue)
1533 : {
1534 500 : if (bFirstVal)
1535 : {
1536 2 : fMinimum = fVal;
1537 2 : fMaximum = fVal;
1538 2 : bFirstVal = false;
1539 : }
1540 : else
1541 : {
1542 498 : if (fVal < fMinimum)
1543 3 : fMinimum = fVal;
1544 498 : if (fVal > fMaximum)
1545 9 : fMaximum = fVal;
1546 : }
1547 : }
1548 : }
1549 : }
1550 200 : else if (eDataType == GDT_Int16)
1551 : {
1552 110 : for (int i = 0; i < nBlockXSize; i++)
1553 : {
1554 100 : float fVal = (float)(reinterpret_cast<GInt16 *>(pabyScanLine))[i];
1555 100 : if (!bHasNoDataValue || fVal != fNoDataValue)
1556 : {
1557 100 : if (bFirstVal)
1558 : {
1559 1 : fMinimum = fVal;
1560 1 : fMaximum = fVal;
1561 1 : bFirstVal = false;
1562 : }
1563 : else
1564 : {
1565 99 : if (fVal < fMinimum)
1566 0 : fMinimum = fVal;
1567 99 : if (fVal > fMaximum)
1568 0 : fMaximum = fVal;
1569 : }
1570 : }
1571 : }
1572 : }
1573 190 : else if (poGDS->nBands == 1)
1574 : {
1575 110 : for (int i = 0; i < nBlockXSize; i++)
1576 : {
1577 100 : float fVal = (float)((GByte *)pabyScanLine)[i];
1578 100 : if (!bHasNoDataValue || fVal != fNoDataValue)
1579 : {
1580 100 : if (bFirstVal)
1581 : {
1582 1 : fMinimum = fVal;
1583 1 : fMaximum = fVal;
1584 1 : bFirstVal = false;
1585 : }
1586 : else
1587 : {
1588 99 : if (fVal < fMinimum)
1589 0 : fMinimum =
1590 : fVal; // I don't change this part, keep it as it is
1591 99 : if (fVal > fMaximum)
1592 0 : fMaximum = fVal;
1593 : }
1594 : }
1595 : }
1596 : }
1597 : else
1598 : {
1599 7980 : for (int i = 0, j = (3 - nBand); i < nBlockXSize; i++, j += 3)
1600 : {
1601 7800 : float fVal = (float)((GByte *)pabyScanLine)[j];
1602 7800 : if (!bHasNoDataValue || fVal != fNoDataValue)
1603 : {
1604 7800 : if (bFirstVal)
1605 : {
1606 6 : fMinimum = fVal;
1607 6 : fMaximum = fVal;
1608 6 : bFirstVal = false;
1609 : }
1610 : else
1611 : {
1612 7794 : if (fVal < fMinimum)
1613 0 : fMinimum = fVal;
1614 7794 : if (fVal > fMaximum)
1615 28 : fMaximum = fVal;
1616 : }
1617 : }
1618 : }
1619 : }
1620 :
1621 230 : return CE_None;
1622 : }
1623 :
1624 : /************************************************************************/
1625 : /* GetMinimum() */
1626 : /************************************************************************/
1627 :
1628 0 : double IdrisiRasterBand::GetMinimum(int *pbSuccess)
1629 : {
1630 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1631 :
1632 0 : if (myCSLFetchNameValue(poGDS->papszRDC, rdcMIN_VALUE) == nullptr)
1633 0 : return GDALPamRasterBand::GetMinimum(pbSuccess);
1634 :
1635 : double adfMinValue[3];
1636 0 : CPLsscanf(myCSLFetchNameValue(poGDS->papszRDC, rdcMIN_VALUE), "%lf %lf %lf",
1637 : &adfMinValue[0], &adfMinValue[1], &adfMinValue[2]);
1638 :
1639 0 : if (pbSuccess)
1640 : {
1641 0 : *pbSuccess = true;
1642 : }
1643 :
1644 0 : return adfMinValue[this->nBand - 1];
1645 : }
1646 :
1647 : /************************************************************************/
1648 : /* GetMaximum() */
1649 : /************************************************************************/
1650 :
1651 0 : double IdrisiRasterBand::GetMaximum(int *pbSuccess)
1652 : {
1653 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1654 :
1655 0 : if (myCSLFetchNameValue(poGDS->papszRDC, rdcMAX_VALUE) == nullptr)
1656 0 : return GDALPamRasterBand::GetMaximum(pbSuccess);
1657 :
1658 : double adfMaxValue[3];
1659 0 : CPLsscanf(myCSLFetchNameValue(poGDS->papszRDC, rdcMAX_VALUE), "%lf %lf %lf",
1660 : &adfMaxValue[0], &adfMaxValue[1], &adfMaxValue[2]);
1661 :
1662 0 : if (pbSuccess)
1663 : {
1664 0 : *pbSuccess = true;
1665 : }
1666 :
1667 0 : return adfMaxValue[this->nBand - 1];
1668 : }
1669 :
1670 : /************************************************************************/
1671 : /* GetNoDataValue() */
1672 : /************************************************************************/
1673 :
1674 276 : double IdrisiRasterBand::GetNoDataValue(int *pbSuccess)
1675 : {
1676 276 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1677 :
1678 276 : const char *pszFlagDefn = nullptr;
1679 :
1680 276 : if (myCSLFetchNameValue(poGDS->papszRDC, rdcFLAG_DEFN) != nullptr)
1681 276 : pszFlagDefn = myCSLFetchNameValue(poGDS->papszRDC, rdcFLAG_DEFN);
1682 0 : else if (myCSLFetchNameValue(poGDS->papszRDC, rdcFLAG_DEFN2) != nullptr)
1683 0 : pszFlagDefn = myCSLFetchNameValue(poGDS->papszRDC, rdcFLAG_DEFN2);
1684 :
1685 : // ------------------------------------------------------------------------
1686 : // If Flag_Def is not "none", Flag_Value means "background"
1687 : // or "missing data"
1688 : // ------------------------------------------------------------------------
1689 :
1690 : double dfNoData;
1691 276 : if (pszFlagDefn != nullptr && !EQUAL(pszFlagDefn, "none"))
1692 : {
1693 0 : dfNoData =
1694 0 : CPLAtof_nz(myCSLFetchNameValue(poGDS->papszRDC, rdcFLAG_VALUE));
1695 0 : if (pbSuccess)
1696 0 : *pbSuccess = TRUE;
1697 : }
1698 : else
1699 : {
1700 276 : dfNoData = -9999.0; /* this value should be ignored */
1701 276 : if (pbSuccess)
1702 276 : *pbSuccess = FALSE;
1703 : }
1704 :
1705 276 : return dfNoData;
1706 : }
1707 :
1708 : /************************************************************************/
1709 : /* SetNoDataValue() */
1710 : /************************************************************************/
1711 :
1712 0 : CPLErr IdrisiRasterBand::SetNoDataValue(double dfNoDataValue)
1713 : {
1714 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1715 :
1716 0 : poGDS->papszRDC = CSLSetNameValue(poGDS->papszRDC, rdcFLAG_VALUE,
1717 : CPLSPrintf("%.7g", dfNoDataValue));
1718 0 : poGDS->papszRDC =
1719 0 : CSLSetNameValue(poGDS->papszRDC, rdcFLAG_DEFN, "missing data");
1720 :
1721 0 : return CE_None;
1722 : }
1723 :
1724 : /************************************************************************/
1725 : /* GetColorInterpretation() */
1726 : /************************************************************************/
1727 :
1728 0 : GDALColorInterp IdrisiRasterBand::GetColorInterpretation()
1729 : {
1730 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1731 :
1732 0 : if (poGDS->nBands == 3)
1733 : {
1734 0 : switch (nBand)
1735 : {
1736 0 : case 1:
1737 0 : return GCI_BlueBand;
1738 0 : case 2:
1739 0 : return GCI_GreenBand;
1740 0 : case 3:
1741 0 : return GCI_RedBand;
1742 : }
1743 : }
1744 0 : else if (poGDS->poColorTable->GetColorEntryCount() > 0)
1745 : {
1746 0 : return GCI_PaletteIndex;
1747 : }
1748 0 : return GCI_GrayIndex;
1749 : }
1750 :
1751 : /************************************************************************/
1752 : /* GetCategoryNames() */
1753 : /************************************************************************/
1754 :
1755 0 : char **IdrisiRasterBand::GetCategoryNames()
1756 : {
1757 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1758 :
1759 0 : return poGDS->papszCategories;
1760 : }
1761 :
1762 : /************************************************************************/
1763 : /* SetCategoryNames() */
1764 : /************************************************************************/
1765 :
1766 3 : CPLErr IdrisiRasterBand::SetCategoryNames(char **papszCategoryNames)
1767 : {
1768 3 : const int nCatCount = CSLCount(papszCategoryNames);
1769 :
1770 3 : if (nCatCount == 0)
1771 3 : return CE_None;
1772 :
1773 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1774 :
1775 0 : CSLDestroy(poGDS->papszCategories);
1776 0 : poGDS->papszCategories = CSLDuplicate(papszCategoryNames);
1777 :
1778 : // ------------------------------------------------------
1779 : // Search for the "Legend cats : N" line
1780 : // ------------------------------------------------------
1781 :
1782 0 : int nLine = -1;
1783 0 : for (int i = 0; (i < CSLCount(poGDS->papszRDC)) && (nLine == -1); i++)
1784 0 : if (EQUALN(poGDS->papszRDC[i], rdcLEGEND_CATS, 12))
1785 0 : nLine = i;
1786 :
1787 0 : if (nLine < 0)
1788 0 : return CE_None;
1789 :
1790 0 : int nCount = atoi_nz(myCSLFetchNameValue(poGDS->papszRDC, rdcLEGEND_CATS));
1791 :
1792 : // ------------------------------------------------------
1793 : // Delete old instance of the category names
1794 : // ------------------------------------------------------
1795 :
1796 0 : if (nCount > 0)
1797 0 : poGDS->papszRDC =
1798 0 : CSLRemoveStrings(poGDS->papszRDC, nLine + 1, nCount, nullptr);
1799 :
1800 0 : nCount = 0;
1801 :
1802 0 : for (int i = 0; i < nCatCount; i++)
1803 : {
1804 0 : if ((strlen(papszCategoryNames[i]) > 0))
1805 : {
1806 0 : poGDS->papszRDC =
1807 0 : CSLInsertString(poGDS->papszRDC, (nLine + nCount + 1),
1808 : CPLSPrintf("%s:%s", CPLSPrintf(rdcCODE_N, i),
1809 0 : papszCategoryNames[i]));
1810 0 : nCount++;
1811 : }
1812 : }
1813 :
1814 0 : poGDS->papszRDC =
1815 0 : CSLSetNameValue(poGDS->papszRDC, rdcLEGEND_CATS,
1816 : CPLSPrintf("%d", nCount)); // this is fine
1817 :
1818 0 : return CE_None;
1819 : }
1820 :
1821 : /************************************************************************/
1822 : /* GetColorTable() */
1823 : /************************************************************************/
1824 :
1825 0 : GDALColorTable *IdrisiRasterBand::GetColorTable()
1826 : {
1827 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1828 :
1829 0 : if (poGDS->poColorTable->GetColorEntryCount() == 0)
1830 : {
1831 0 : return nullptr;
1832 : }
1833 :
1834 0 : return poGDS->poColorTable;
1835 : }
1836 :
1837 : /************************************************************************/
1838 : /* SetColorTable() */
1839 : /************************************************************************/
1840 :
1841 3 : CPLErr IdrisiRasterBand::SetColorTable(GDALColorTable *poColorTable)
1842 : {
1843 3 : if (poColorTable == nullptr)
1844 : {
1845 3 : return CE_None;
1846 : }
1847 :
1848 0 : if (poColorTable->GetColorEntryCount() == 0)
1849 : {
1850 0 : return CE_None;
1851 : }
1852 :
1853 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1854 :
1855 0 : delete poGDS->poColorTable;
1856 :
1857 0 : poGDS->poColorTable = poColorTable->Clone();
1858 :
1859 : const std::string osSMPFilename =
1860 0 : CPLResetExtensionSafe(poGDS->pszFilename, extSMP);
1861 0 : VSILFILE *fpSMP = VSIFOpenL(osSMPFilename.c_str(), "w");
1862 :
1863 0 : if (fpSMP != nullptr)
1864 : {
1865 0 : VSIFWriteL("[Idrisi]", 8, 1, fpSMP);
1866 0 : GByte nPlatform = 1;
1867 0 : VSIFWriteL(&nPlatform, 1, 1, fpSMP);
1868 0 : GByte nVersion = 11;
1869 0 : VSIFWriteL(&nVersion, 1, 1, fpSMP);
1870 0 : GByte nDepth = 8;
1871 0 : VSIFWriteL(&nDepth, 1, 1, fpSMP);
1872 0 : GByte nHeadSz = 18;
1873 0 : VSIFWriteL(&nHeadSz, 1, 1, fpSMP);
1874 0 : GUInt16 nCount = 255;
1875 0 : VSIFWriteL(&nCount, 2, 1, fpSMP);
1876 0 : GUInt16 nMix = 0;
1877 0 : VSIFWriteL(&nMix, 2, 1, fpSMP);
1878 0 : GUInt16 nMax = 255;
1879 0 : VSIFWriteL(&nMax, 2, 1, fpSMP);
1880 :
1881 : GDALColorEntry oEntry;
1882 : GByte aucRGB[3];
1883 :
1884 0 : for (int i = 0; i < poColorTable->GetColorEntryCount(); i++)
1885 : {
1886 0 : poColorTable->GetColorEntryAsRGB(i, &oEntry);
1887 0 : aucRGB[0] = (GByte)oEntry.c1;
1888 0 : aucRGB[1] = (GByte)oEntry.c2;
1889 0 : aucRGB[2] = (GByte)oEntry.c3;
1890 0 : VSIFWriteL(&aucRGB, 3, 1, fpSMP);
1891 : }
1892 : /* smp files always have 256 occurrences. */
1893 0 : for (int i = poColorTable->GetColorEntryCount(); i <= 255; i++)
1894 : {
1895 0 : poColorTable->GetColorEntryAsRGB(i, &oEntry);
1896 0 : aucRGB[0] = (GByte)0;
1897 0 : aucRGB[1] = (GByte)0;
1898 0 : aucRGB[2] = (GByte)0;
1899 0 : VSIFWriteL(&aucRGB, 3, 1, fpSMP);
1900 : }
1901 0 : VSIFCloseL(fpSMP);
1902 : }
1903 :
1904 0 : return CE_None;
1905 : }
1906 :
1907 : /************************************************************************/
1908 : /* GetUnitType() */
1909 : /************************************************************************/
1910 :
1911 0 : const char *IdrisiRasterBand::GetUnitType()
1912 : {
1913 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1914 :
1915 0 : return poGDS->pszUnitType;
1916 : }
1917 :
1918 : /************************************************************************/
1919 : /* SetUnitType() */
1920 : /************************************************************************/
1921 :
1922 3 : CPLErr IdrisiRasterBand::SetUnitType(const char *pszUnitType)
1923 : {
1924 3 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1925 :
1926 3 : if (strlen(pszUnitType) == 0)
1927 : {
1928 3 : poGDS->papszRDC =
1929 3 : CSLSetNameValue(poGDS->papszRDC, rdcVALUE_UNITS, "unspecified");
1930 : }
1931 : else
1932 : {
1933 0 : poGDS->papszRDC =
1934 0 : CSLSetNameValue(poGDS->papszRDC, rdcVALUE_UNITS, pszUnitType);
1935 : }
1936 :
1937 3 : return CE_None;
1938 : }
1939 :
1940 : /************************************************************************/
1941 : /* SetMinMax() */
1942 : /************************************************************************/
1943 :
1944 49 : CPLErr IdrisiRasterBand::SetMinMax(double dfMin, double dfMax)
1945 : {
1946 49 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
1947 :
1948 49 : fMinimum = (float)dfMin;
1949 49 : fMaximum = (float)dfMax;
1950 :
1951 49 : double adfMin[3] = {0.0, 0.0, 0.0};
1952 49 : double adfMax[3] = {0.0, 0.0, 0.0};
1953 :
1954 49 : if (myCSLFetchNameValue(poGDS->papszRDC, rdcMIN_VALUE) != nullptr)
1955 49 : CPLsscanf(myCSLFetchNameValue(poGDS->papszRDC, rdcMIN_VALUE),
1956 : "%lf %lf %lf", &adfMin[0], &adfMin[1], &adfMin[2]);
1957 49 : if (myCSLFetchNameValue(poGDS->papszRDC, rdcMAX_VALUE) != nullptr)
1958 49 : CPLsscanf(myCSLFetchNameValue(poGDS->papszRDC, rdcMAX_VALUE),
1959 : "%lf %lf %lf", &adfMax[0], &adfMax[1], &adfMax[2]);
1960 :
1961 49 : adfMin[nBand - 1] = dfMin;
1962 49 : adfMax[nBand - 1] = dfMax;
1963 :
1964 49 : if (poGDS->nBands == 3)
1965 : {
1966 24 : poGDS->papszRDC = CSLSetNameValue(
1967 : poGDS->papszRDC, rdcMIN_VALUE,
1968 : CPLSPrintf("%.8g %.8g %.8g", adfMin[0], adfMin[1], adfMin[2]));
1969 24 : poGDS->papszRDC = CSLSetNameValue(
1970 : poGDS->papszRDC, rdcMAX_VALUE,
1971 : CPLSPrintf("%.8g %.8g %.8g", adfMax[0], adfMax[1], adfMax[2]));
1972 24 : poGDS->papszRDC = CSLSetNameValue(
1973 : poGDS->papszRDC, rdcDISPLAY_MIN,
1974 : CPLSPrintf("%.8g %.8g %.8g", adfMin[0], adfMin[1], adfMin[2]));
1975 24 : poGDS->papszRDC = CSLSetNameValue(
1976 : poGDS->papszRDC, rdcDISPLAY_MAX,
1977 : CPLSPrintf("%.8g %.8g %.8g", adfMax[0], adfMax[1], adfMax[2]));
1978 : }
1979 : else
1980 : {
1981 25 : poGDS->papszRDC = CSLSetNameValue(poGDS->papszRDC, rdcMIN_VALUE,
1982 : CPLSPrintf("%.8g", adfMin[0]));
1983 25 : poGDS->papszRDC = CSLSetNameValue(poGDS->papszRDC, rdcMAX_VALUE,
1984 : CPLSPrintf("%.8g", adfMax[0]));
1985 25 : poGDS->papszRDC = CSLSetNameValue(poGDS->papszRDC, rdcDISPLAY_MIN,
1986 : CPLSPrintf("%.8g", adfMin[0]));
1987 25 : poGDS->papszRDC = CSLSetNameValue(poGDS->papszRDC, rdcDISPLAY_MAX,
1988 : CPLSPrintf("%.8g", adfMax[0]));
1989 : }
1990 :
1991 49 : return CE_None;
1992 : }
1993 :
1994 : /************************************************************************/
1995 : /* SetStatistics() */
1996 : /************************************************************************/
1997 :
1998 20 : CPLErr IdrisiRasterBand::SetStatistics(double dfMin, double dfMax,
1999 : double dfMean, double dfStdDev)
2000 : {
2001 20 : SetMinMax(dfMin, dfMax);
2002 :
2003 20 : return GDALPamRasterBand::SetStatistics(dfMin, dfMax, dfMean, dfStdDev);
2004 : }
2005 :
2006 : /************************************************************************/
2007 : /* SetDefaultRAT() */
2008 : /************************************************************************/
2009 :
2010 0 : CPLErr IdrisiRasterBand::SetDefaultRAT(const GDALRasterAttributeTable *poRAT)
2011 : {
2012 0 : if (!poRAT)
2013 : {
2014 0 : return CE_Failure;
2015 : }
2016 :
2017 : // ----------------------------------------------------------
2018 : // Get field indices
2019 : // ----------------------------------------------------------
2020 :
2021 0 : int iValue = -1;
2022 0 : int iRed = poRAT->GetColOfUsage(GFU_Red);
2023 0 : int iGreen = poRAT->GetColOfUsage(GFU_Green);
2024 0 : int iBlue = poRAT->GetColOfUsage(GFU_Blue);
2025 :
2026 0 : GDALColorTable *poCT = nullptr;
2027 0 : char **papszNames = nullptr;
2028 :
2029 0 : int nFact = 1;
2030 :
2031 : // ----------------------------------------------------------
2032 : // Seek for "Value" field index (AGIS standards field name)
2033 : // ----------------------------------------------------------
2034 :
2035 0 : if (GetColorTable() == nullptr ||
2036 0 : GetColorTable()->GetColorEntryCount() == 0)
2037 : {
2038 0 : for (int i = 0; i < poRAT->GetColumnCount(); i++)
2039 : {
2040 0 : if (STARTS_WITH_CI(poRAT->GetNameOfCol(i), "Value"))
2041 : {
2042 0 : iValue = i;
2043 0 : break;
2044 : }
2045 : }
2046 :
2047 0 : if (iRed != -1 && iGreen != -1 && iBlue != -1)
2048 : {
2049 0 : poCT = new GDALColorTable();
2050 0 : nFact = poRAT->GetTypeOfCol(iRed) == GFT_Real ? 255 : 1;
2051 : }
2052 : }
2053 :
2054 : // ----------------------------------------------------------
2055 : // Seek for Name field index
2056 : // ----------------------------------------------------------
2057 :
2058 0 : int iName = -1;
2059 0 : if (CSLCount(GetCategoryNames()) == 0)
2060 : {
2061 0 : iName = poRAT->GetColOfUsage(GFU_Name);
2062 0 : if (iName == -1)
2063 : {
2064 0 : for (int i = 0; i < poRAT->GetColumnCount(); i++)
2065 : {
2066 0 : if (STARTS_WITH_CI(poRAT->GetNameOfCol(i), "Class_Name"))
2067 : {
2068 0 : iName = i;
2069 0 : break;
2070 : }
2071 0 : else if (STARTS_WITH_CI(poRAT->GetNameOfCol(i), "Categor"))
2072 : {
2073 0 : iName = i;
2074 0 : break;
2075 : }
2076 0 : else if (STARTS_WITH_CI(poRAT->GetNameOfCol(i), "Name"))
2077 : {
2078 0 : iName = i;
2079 0 : break;
2080 : }
2081 : }
2082 : }
2083 :
2084 : /* if still can't find it use the first String column */
2085 :
2086 0 : if (iName == -1)
2087 : {
2088 0 : for (int i = 0; i < poRAT->GetColumnCount(); i++)
2089 : {
2090 0 : if (poRAT->GetTypeOfCol(i) == GFT_String)
2091 : {
2092 0 : iName = i;
2093 0 : break;
2094 : }
2095 : }
2096 : }
2097 :
2098 : // ----------------------------------------------------------
2099 : // Incomplete Attribute Table;
2100 : // ----------------------------------------------------------
2101 :
2102 0 : if (iName == -1)
2103 : {
2104 0 : iName = iValue;
2105 : }
2106 : }
2107 :
2108 : // ----------------------------------------------------------
2109 : // Load values
2110 : // ----------------------------------------------------------
2111 :
2112 : GDALColorEntry sColor;
2113 0 : int iEntry = 0;
2114 0 : int iOut = 0;
2115 0 : int nEntryCount = poRAT->GetRowCount();
2116 0 : int nValue = 0;
2117 :
2118 0 : if (iValue != -1)
2119 : {
2120 0 : nValue = poRAT->GetValueAsInt(iEntry, iValue);
2121 : }
2122 :
2123 0 : for (iOut = 0; iOut < 65535 && (iEntry < nEntryCount); iOut++)
2124 : {
2125 0 : if (iOut == nValue)
2126 : {
2127 0 : if (poCT)
2128 : {
2129 0 : const double dRed = poRAT->GetValueAsDouble(iEntry, iRed);
2130 0 : const double dGreen = poRAT->GetValueAsDouble(iEntry, iGreen);
2131 0 : const double dBlue = poRAT->GetValueAsDouble(iEntry, iBlue);
2132 0 : sColor.c1 = (short)(dRed * nFact);
2133 0 : sColor.c2 = (short)(dGreen * nFact);
2134 0 : sColor.c3 = (short)(dBlue * nFact);
2135 0 : sColor.c4 = (short)(255 / nFact);
2136 0 : poCT->SetColorEntry(iEntry, &sColor);
2137 : }
2138 :
2139 0 : if (iName != -1)
2140 : {
2141 0 : papszNames = CSLAddString(
2142 0 : papszNames, poRAT->GetValueAsString(iEntry, iName));
2143 : }
2144 :
2145 : /* Advance on the table */
2146 :
2147 0 : if ((++iEntry) < nEntryCount)
2148 : {
2149 0 : if (iValue != -1)
2150 0 : nValue = poRAT->GetValueAsInt(iEntry, iValue);
2151 : else
2152 0 : nValue = iEntry;
2153 : }
2154 : }
2155 0 : else if (iOut < nValue)
2156 : {
2157 0 : if (poCT)
2158 : {
2159 0 : sColor.c1 = (short)0;
2160 0 : sColor.c2 = (short)0;
2161 0 : sColor.c3 = (short)0;
2162 0 : sColor.c4 = (short)255;
2163 0 : poCT->SetColorEntry(iEntry, &sColor);
2164 : }
2165 :
2166 0 : if (iName != -1)
2167 0 : papszNames = CSLAddString(papszNames, "");
2168 : }
2169 : }
2170 :
2171 : // ----------------------------------------------------------
2172 : // Set Color Table
2173 : // ----------------------------------------------------------
2174 :
2175 0 : if (poCT)
2176 : {
2177 0 : SetColorTable(poCT);
2178 0 : delete poCT;
2179 : }
2180 :
2181 : // ----------------------------------------------------------
2182 : // Update Category Names
2183 : // ----------------------------------------------------------
2184 :
2185 0 : if (papszNames)
2186 : {
2187 0 : SetCategoryNames(papszNames);
2188 0 : CSLDestroy(papszNames);
2189 : }
2190 :
2191 : // ----------------------------------------------------------
2192 : // Update Attribute Table
2193 : // ----------------------------------------------------------
2194 :
2195 0 : if (poDefaultRAT)
2196 : {
2197 0 : delete poDefaultRAT;
2198 : }
2199 :
2200 0 : poDefaultRAT = poRAT->Clone();
2201 :
2202 0 : return CE_None;
2203 : }
2204 :
2205 : /************************************************************************/
2206 : /* GetDefaultRAT() */
2207 : /************************************************************************/
2208 :
2209 0 : GDALRasterAttributeTable *IdrisiRasterBand::GetDefaultRAT()
2210 : {
2211 0 : IdrisiDataset *poGDS = cpl::down_cast<IdrisiDataset *>(poDS);
2212 :
2213 0 : if (poGDS->papszCategories == nullptr)
2214 : {
2215 0 : return nullptr;
2216 : }
2217 :
2218 0 : bool bHasColorTable = poGDS->poColorTable->GetColorEntryCount() > 0;
2219 :
2220 : // ----------------------------------------------------------
2221 : // Create the bands Attribute Table
2222 : // ----------------------------------------------------------
2223 :
2224 0 : if (poDefaultRAT)
2225 : {
2226 0 : delete poDefaultRAT;
2227 : }
2228 :
2229 0 : poDefaultRAT = new GDALDefaultRasterAttributeTable();
2230 :
2231 : // ----------------------------------------------------------
2232 : // Create (Value, Red, Green, Blue, Alpha, Class_Name) fields
2233 : // ----------------------------------------------------------
2234 :
2235 0 : poDefaultRAT->CreateColumn("Value", GFT_Integer, GFU_Generic);
2236 0 : poDefaultRAT->CreateColumn("Value_1", GFT_Integer, GFU_MinMax);
2237 :
2238 0 : if (bHasColorTable)
2239 : {
2240 0 : poDefaultRAT->CreateColumn("Red", GFT_Integer, GFU_Red);
2241 0 : poDefaultRAT->CreateColumn("Green", GFT_Integer, GFU_Green);
2242 0 : poDefaultRAT->CreateColumn("Blue", GFT_Integer, GFU_Blue);
2243 0 : poDefaultRAT->CreateColumn("Alpha", GFT_Integer, GFU_Alpha);
2244 : }
2245 0 : poDefaultRAT->CreateColumn("Class_name", GFT_String, GFU_Name);
2246 :
2247 : // ----------------------------------------------------------
2248 : // Loop through the Category Names.
2249 : // ----------------------------------------------------------
2250 :
2251 : GDALColorEntry sEntry;
2252 0 : int iName = poDefaultRAT->GetColOfUsage(GFU_Name);
2253 0 : int nEntryCount = CSLCount(poGDS->papszCategories);
2254 0 : int iRows = 0;
2255 :
2256 0 : for (int iEntry = 0; iEntry < nEntryCount; iEntry++)
2257 : {
2258 0 : if (EQUAL(poGDS->papszCategories[iEntry], ""))
2259 : {
2260 0 : continue; // Eliminate the empty ones
2261 : }
2262 0 : poDefaultRAT->SetRowCount(poDefaultRAT->GetRowCount() + 1);
2263 0 : poDefaultRAT->SetValue(iRows, 0, iEntry);
2264 0 : poDefaultRAT->SetValue(iRows, 1, iEntry);
2265 0 : if (bHasColorTable)
2266 : {
2267 0 : poGDS->poColorTable->GetColorEntryAsRGB(iEntry, &sEntry);
2268 0 : poDefaultRAT->SetValue(iRows, 2, sEntry.c1);
2269 0 : poDefaultRAT->SetValue(iRows, 3, sEntry.c2);
2270 0 : poDefaultRAT->SetValue(iRows, 4, sEntry.c3);
2271 0 : poDefaultRAT->SetValue(iRows, 5, sEntry.c4);
2272 : }
2273 0 : poDefaultRAT->SetValue(iRows, iName, poGDS->papszCategories[iEntry]);
2274 0 : iRows++;
2275 : }
2276 :
2277 0 : return poDefaultRAT;
2278 : }
2279 :
2280 : /************************************************************************/
2281 : /* IdrisiGeoReference2Wkt() */
2282 : /************************************************************************/
2283 :
2284 : /***
2285 : * Converts Idrisi geographic reference information to OpenGIS WKT.
2286 : *
2287 : * The Idrisi metadata file contain two fields that describe the
2288 : * geographic reference, RefSystem and RefUnit.
2289 : *
2290 : * RefSystem can contains the world "plane" or the name of a georeference
2291 : * file <refsystem>.ref that details the geographic reference
2292 : * system( coordinate system and projection parameters ). RefUnits
2293 : * indicates the unit of the image bounds.
2294 : *
2295 : * The georeference files are generally located in the product installation
2296 : * folder $IDRISIDIR\Georef, but they are first looked for in the same
2297 : * folder as the data file.
2298 : *
2299 : * If a Reference system names can be recognized by a name convention
2300 : * it will be interpreted without the need to read the georeference file.
2301 : * That includes "latlong" and all the UTM and State Plane zones.
2302 : *
2303 : * RefSystem "latlong" means that the data is not project and the coordinate
2304 : * system is WGS84. RefSystem "plane" means that the there is no coordinate
2305 : * system but the it is possible to calculate areas and distance by looking
2306 : * at the RefUnits.
2307 : *
2308 : * If the environment variable IDRISIDIR is not set and the georeference file
2309 : * need to be read then the projection string will result as unknown.
2310 : ***/
2311 :
2312 4 : CPLErr IdrisiGeoReference2Wkt(const char *pszFilename, const char *pszRefSystem,
2313 : const char *pszRefUnits,
2314 : OGRSpatialReference &oSRS)
2315 : {
2316 : // ---------------------------------------------------------
2317 : // Plane
2318 : // ---------------------------------------------------------
2319 :
2320 4 : if (EQUAL(pszRefSystem, rstPLANE))
2321 : {
2322 0 : oSRS.SetLocalCS("Plane");
2323 0 : int nUnit = GetUnitIndex(pszRefUnits);
2324 0 : if (nUnit > -1)
2325 : {
2326 0 : int nDeft = aoLinearUnitsConv[nUnit].nDefaultG;
2327 0 : oSRS.SetLinearUnits(aoLinearUnitsConv[nDeft].pszName,
2328 0 : aoLinearUnitsConv[nDeft].dfConv);
2329 : }
2330 0 : return CE_None;
2331 : }
2332 :
2333 : // ---------------------------------------------------------
2334 : // Latlong
2335 : // ---------------------------------------------------------
2336 :
2337 4 : if (EQUAL(pszRefSystem, rstLATLONG) || EQUAL(pszRefSystem, rstLATLONG2))
2338 : {
2339 1 : oSRS.SetWellKnownGeogCS("WGS84");
2340 1 : return CE_None;
2341 : }
2342 :
2343 : // ---------------------------------------------------------
2344 : // Prepare for scanning in lower case
2345 : // ---------------------------------------------------------
2346 :
2347 3 : char *pszRefSystemLower = CPLStrdup(pszRefSystem);
2348 3 : CPLStrlwr(pszRefSystemLower);
2349 :
2350 : // ---------------------------------------------------------
2351 : // UTM naming convention( ex.: utm-30n )
2352 : // ---------------------------------------------------------
2353 :
2354 3 : if (EQUALN(pszRefSystem, rstUTM, 3))
2355 : {
2356 : int nZone;
2357 : char cNorth;
2358 3 : sscanf(pszRefSystemLower, rstUTM, &nZone, &cNorth);
2359 3 : oSRS.SetWellKnownGeogCS("WGS84");
2360 3 : oSRS.SetUTM(nZone, (cNorth == 'n'));
2361 3 : CPLFree(pszRefSystemLower);
2362 3 : return CE_None;
2363 : }
2364 :
2365 : // ---------------------------------------------------------
2366 : // State Plane naming convention( ex.: spc83ma1 )
2367 : // ---------------------------------------------------------
2368 :
2369 0 : if (EQUALN(pszRefSystem, rstSPC, 3))
2370 : {
2371 : int nNAD;
2372 : int nZone;
2373 : char szState[3];
2374 0 : sscanf(pszRefSystemLower, rstSPC, &nNAD, szState, &nZone);
2375 0 : int nSPCode = GetStateCode(szState);
2376 0 : if (nSPCode != -1)
2377 : {
2378 0 : nZone = (nZone == 1 ? nSPCode : nSPCode + nZone - 1);
2379 :
2380 0 : if (oSRS.SetStatePlane(nZone, (nNAD == 83)) != OGRERR_FAILURE)
2381 : {
2382 0 : CPLFree(pszRefSystemLower);
2383 0 : return CE_None;
2384 : }
2385 :
2386 : // ----------------------------------------------------------
2387 : // If SetStatePlane fails, set GeoCS as NAD Datum and let it
2388 : // try to read the projection info from georeference file( * )
2389 : // ----------------------------------------------------------
2390 :
2391 0 : oSRS.SetWellKnownGeogCS(CPLSPrintf("NAD%d", nNAD));
2392 : }
2393 : }
2394 :
2395 0 : CPLFree(pszRefSystemLower);
2396 0 : pszRefSystemLower = nullptr;
2397 :
2398 : // ------------------------------------------------------------------
2399 : // Search for georeference file <RefSystem>.ref
2400 : // ------------------------------------------------------------------
2401 :
2402 : const char *pszFName =
2403 0 : CPLSPrintf("%s%c%s.ref", CPLGetDirnameSafe(pszFilename).c_str(),
2404 : PATHDELIM, pszRefSystem);
2405 :
2406 0 : if (!FileExists(pszFName))
2407 : {
2408 : // ------------------------------------------------------------------
2409 : // Look at $IDRISIDIR\Georef\<RefSystem>.ref
2410 : // ------------------------------------------------------------------
2411 :
2412 0 : const char *pszIdrisiDir = CPLGetConfigOption("IDRISIDIR", nullptr);
2413 :
2414 0 : if ((pszIdrisiDir) != nullptr)
2415 : {
2416 0 : pszFName = CPLSPrintf("%s%cgeoref%c%s.ref", pszIdrisiDir, PATHDELIM,
2417 : PATHDELIM, pszRefSystem);
2418 : }
2419 : }
2420 :
2421 : // ------------------------------------------------------------------
2422 : // Cannot find georeference file
2423 : // ------------------------------------------------------------------
2424 :
2425 0 : if (!FileExists(pszFName))
2426 : {
2427 0 : CPLDebug("RST", "Cannot find Idrisi georeference file %s",
2428 : pszRefSystem);
2429 :
2430 0 : if (oSRS.IsGeographic() == FALSE) /* see State Plane remarks( * ) */
2431 : {
2432 0 : oSRS.SetLocalCS("Unknown");
2433 0 : int nUnit = GetUnitIndex(pszRefUnits);
2434 0 : if (nUnit > -1)
2435 : {
2436 0 : int nDeft = aoLinearUnitsConv[nUnit].nDefaultG;
2437 0 : oSRS.SetLinearUnits(aoLinearUnitsConv[nDeft].pszName,
2438 0 : aoLinearUnitsConv[nDeft].dfConv);
2439 : }
2440 : }
2441 0 : return CE_Failure;
2442 : }
2443 :
2444 : // ------------------------------------------------------------------
2445 : // Read values from georeference file
2446 : // ------------------------------------------------------------------
2447 :
2448 0 : char **papszRef = CSLLoad(pszFName);
2449 0 : myCSLSetNameValueSeparator(papszRef, ":");
2450 :
2451 0 : char *pszGeorefName = nullptr;
2452 :
2453 0 : const char *pszREF_SYSTEM = myCSLFetchNameValue(papszRef, refREF_SYSTEM);
2454 0 : if (pszREF_SYSTEM != nullptr && EQUAL(pszREF_SYSTEM, "") == FALSE)
2455 : {
2456 0 : pszGeorefName = CPLStrdup(pszREF_SYSTEM);
2457 : }
2458 : else
2459 : {
2460 : pszGeorefName =
2461 0 : CPLStrdup(myCSLFetchNameValue(papszRef, refREF_SYSTEM2));
2462 : }
2463 0 : char *pszProjName = CPLStrdup(myCSLFetchNameValue(papszRef, refPROJECTION));
2464 0 : char *pszDatum = CPLStrdup(myCSLFetchNameValue(papszRef, refDATUM));
2465 0 : char *pszEllipsoid = CPLStrdup(myCSLFetchNameValue(papszRef, refELLIPSOID));
2466 : const double dfCenterLat =
2467 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refORIGIN_LAT));
2468 : const double dfCenterLong =
2469 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refORIGIN_LONG));
2470 : const double dfSemiMajor =
2471 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refMAJOR_SAX));
2472 : const double dfSemiMinor =
2473 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refMINOR_SAX));
2474 : const double dfFalseEasting =
2475 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refORIGIN_X));
2476 : const double dfFalseNorthing =
2477 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refORIGIN_Y));
2478 : const double dfStdP1 =
2479 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refSTANDL_1));
2480 : const double dfStdP2 =
2481 0 : CPLAtof_nz(myCSLFetchNameValue(papszRef, refSTANDL_2));
2482 : double dfScale;
2483 0 : double adfToWGS84[3] = {0.0, 0.0, 0.0};
2484 :
2485 0 : const char *pszToWGS84 = myCSLFetchNameValue(papszRef, refDELTA_WGS84);
2486 0 : if (pszToWGS84)
2487 0 : CPLsscanf(pszToWGS84, "%lf %lf %lf", &adfToWGS84[0], &adfToWGS84[1],
2488 : &adfToWGS84[2]);
2489 :
2490 0 : const char *pszSCALE_FAC = myCSLFetchNameValue(papszRef, refSCALE_FAC);
2491 0 : if (pszSCALE_FAC == nullptr || EQUAL(pszSCALE_FAC, "na"))
2492 0 : dfScale = 1.0;
2493 : else
2494 0 : dfScale = CPLAtof_nz(pszSCALE_FAC);
2495 :
2496 0 : CSLDestroy(papszRef);
2497 :
2498 : // ----------------------------------------------------------------------
2499 : // Set the Geographic Coordinate System
2500 : // ----------------------------------------------------------------------
2501 :
2502 0 : if (oSRS.IsGeographic() == FALSE) /* see State Plane remarks(*) */
2503 : {
2504 0 : int nEPSG = 0;
2505 :
2506 : // ----------------------------------------------------------------------
2507 : // Is it a WGS84 equivalent?
2508 : // ----------------------------------------------------------------------
2509 :
2510 0 : if ((STARTS_WITH_CI(pszEllipsoid, "WGS")) &&
2511 0 : (strstr(pszEllipsoid, "84")) && (STARTS_WITH_CI(pszDatum, "WGS")) &&
2512 0 : (strstr(pszDatum, "84")) && (adfToWGS84[0] == 0.0) &&
2513 0 : (adfToWGS84[1] == 0.0) && (adfToWGS84[2] == 0.0))
2514 : {
2515 0 : nEPSG = 4326;
2516 : }
2517 :
2518 : // ----------------------------------------------------------------------
2519 : // Match GCS's DATUM_NAME by using 'ApproxString' over Datum
2520 : // ----------------------------------------------------------------------
2521 :
2522 0 : if (nEPSG == 0)
2523 : {
2524 0 : const PJ_TYPE nObjType = PJ_TYPE_GEODETIC_REFERENCE_FRAME;
2525 : auto datumList =
2526 0 : proj_create_from_name(OSRGetProjTLSContext(), "EPSG", pszDatum,
2527 : &nObjType, 1, true, 1, nullptr);
2528 0 : if (datumList && proj_list_get_count(datumList) == 1)
2529 : {
2530 : auto datum =
2531 0 : proj_list_get(OSRGetProjTLSContext(), datumList, 0);
2532 0 : if (datum)
2533 : {
2534 0 : const char *datumCode = proj_get_id_code(datum, 0);
2535 0 : if (datumCode)
2536 : {
2537 0 : auto crsList = proj_query_geodetic_crs_from_datum(
2538 : OSRGetProjTLSContext(), "EPSG", "EPSG", datumCode,
2539 : "geographic 2D");
2540 0 : if (crsList && proj_list_get_count(crsList) != 0)
2541 : {
2542 0 : auto crs = proj_list_get(OSRGetProjTLSContext(),
2543 : crsList, 0);
2544 0 : if (crs)
2545 : {
2546 0 : const char *crsCode = proj_get_id_code(crs, 0);
2547 0 : if (crsCode)
2548 : {
2549 0 : nEPSG = atoi(crsCode);
2550 : }
2551 0 : proj_destroy(crs);
2552 : }
2553 : }
2554 0 : proj_list_destroy(crsList);
2555 : }
2556 0 : proj_destroy(datum);
2557 : }
2558 : }
2559 0 : proj_list_destroy(datumList);
2560 : }
2561 :
2562 : // ----------------------------------------------------------------------
2563 : // Match GCS's COORD_REF_SYS_NAME by using 'ApproxString' over Datum
2564 : // ----------------------------------------------------------------------
2565 :
2566 0 : if (nEPSG == 0)
2567 : {
2568 0 : const PJ_TYPE nObjType = PJ_TYPE_GEOGRAPHIC_2D_CRS;
2569 : auto crsList =
2570 0 : proj_create_from_name(OSRGetProjTLSContext(), "EPSG", pszDatum,
2571 : &nObjType, 1, true, 1, nullptr);
2572 0 : if (crsList && proj_list_get_count(crsList) != 0)
2573 : {
2574 0 : auto crs = proj_list_get(OSRGetProjTLSContext(), crsList, 0);
2575 0 : if (crs)
2576 : {
2577 0 : const char *crsCode = proj_get_id_code(crs, 0);
2578 0 : if (crsCode)
2579 : {
2580 0 : nEPSG = atoi(crsCode);
2581 : }
2582 0 : proj_destroy(crs);
2583 : }
2584 : }
2585 0 : proj_list_destroy(crsList);
2586 : }
2587 :
2588 0 : if (nEPSG != 0)
2589 : {
2590 0 : oSRS.importFromEPSG(nEPSG);
2591 : }
2592 : else
2593 : {
2594 : // --------------------------------------------------
2595 : // Create GeogCS based on the georeference file info
2596 : // --------------------------------------------------
2597 :
2598 0 : oSRS.SetGeogCS(pszRefSystem, pszDatum, pszEllipsoid, dfSemiMajor,
2599 : (dfSemiMinor == dfSemiMajor)
2600 : ? 0.0
2601 0 : : (-1.0 / (dfSemiMinor / dfSemiMajor - 1.0)));
2602 : }
2603 :
2604 : // ----------------------------------------------------------------------
2605 : // Note: That will override EPSG info:
2606 : // ----------------------------------------------------------------------
2607 :
2608 0 : oSRS.SetTOWGS84(adfToWGS84[0], adfToWGS84[1], adfToWGS84[2]);
2609 : }
2610 :
2611 : // ----------------------------------------------------------------------
2612 : // If the georeference file tells that it is a non project system:
2613 : // ----------------------------------------------------------------------
2614 :
2615 0 : if (EQUAL(pszProjName, "none"))
2616 : {
2617 0 : CPLFree(pszGeorefName);
2618 0 : CPLFree(pszProjName);
2619 0 : CPLFree(pszDatum);
2620 0 : CPLFree(pszEllipsoid);
2621 :
2622 0 : return CE_None;
2623 : }
2624 :
2625 : // ----------------------------------------------------------------------
2626 : // Create Projection information based on georeference file info
2627 : // ----------------------------------------------------------------------
2628 :
2629 : // Idrisi user's Manual, Supported Projection:
2630 : //
2631 : // Mercator
2632 : // Transverse Mercator
2633 : // Gauss-Kruger
2634 : // Lambert Conformal Conic
2635 : // Plate Carree
2636 : // Hammer Aitoff
2637 : // Lambert North Polar Azimuthal Equal Area
2638 : // Lambert South Polar Azimuthal Equal Area
2639 : // Lambert Transverse Azimuthal Equal Area
2640 : // Lambert Oblique Polar Azimuthal Equal Area
2641 : // North Polar Stereographic
2642 : // South Polar Stereographic
2643 : // Transverse Stereographic
2644 : // Oblique Stereographic
2645 : // Albers Equal Area Conic
2646 : // Sinusoidal
2647 : // Cylindrical Equal Area
2648 :
2649 0 : if (EQUAL(pszProjName, "Mercator"))
2650 : {
2651 0 : oSRS.SetMercator(dfCenterLat, dfCenterLong, dfScale, dfFalseEasting,
2652 : dfFalseNorthing);
2653 : }
2654 0 : else if (EQUAL(pszProjName, "Transverse Mercator"))
2655 : {
2656 0 : oSRS.SetTM(dfCenterLat, dfCenterLong, dfScale, dfFalseEasting,
2657 : dfFalseNorthing);
2658 : }
2659 0 : else if (EQUAL(pszProjName, "Gauss-Kruger"))
2660 : {
2661 0 : oSRS.SetTM(dfCenterLat, dfCenterLong, dfScale, dfFalseEasting,
2662 : dfFalseNorthing);
2663 : }
2664 0 : else if (EQUAL(pszProjName, "Lambert Conformal Conic"))
2665 : {
2666 0 : oSRS.SetLCC(dfStdP1, dfStdP2, dfCenterLat, dfCenterLong, dfFalseEasting,
2667 : dfFalseNorthing);
2668 : }
2669 0 : else if (EQUAL(pszProjName, "Plate Carr"
2670 : "\xE9"
2671 : "e")) /* 'eacute' in ISO-8859-1 */
2672 : {
2673 0 : oSRS.SetEquirectangular(dfCenterLat, dfCenterLong, dfFalseEasting,
2674 : dfFalseNorthing);
2675 : }
2676 0 : else if (EQUAL(pszProjName, "Hammer Aitoff"))
2677 : {
2678 0 : oSRS.SetProjection(pszProjName);
2679 0 : oSRS.SetProjParm(SRS_PP_LATITUDE_OF_ORIGIN, dfCenterLat);
2680 0 : oSRS.SetProjParm(SRS_PP_CENTRAL_MERIDIAN, dfCenterLong);
2681 0 : oSRS.SetProjParm(SRS_PP_FALSE_EASTING, dfFalseEasting);
2682 0 : oSRS.SetProjParm(SRS_PP_FALSE_NORTHING, dfFalseNorthing);
2683 : }
2684 0 : else if (EQUAL(pszProjName, "Lambert North Polar Azimuthal Equal Area") ||
2685 0 : EQUAL(pszProjName, "Lambert South Polar Azimuthal Equal Area") ||
2686 0 : EQUAL(pszProjName, "Lambert Transverse Azimuthal Equal Area") ||
2687 0 : EQUAL(pszProjName, "Lambert Oblique Polar Azimuthal Equal Area"))
2688 : {
2689 0 : oSRS.SetLAEA(dfCenterLat, dfCenterLong, dfFalseEasting,
2690 : dfFalseNorthing);
2691 : }
2692 0 : else if (EQUAL(pszProjName, "North Polar Stereographic") ||
2693 0 : EQUAL(pszProjName, "South Polar Stereographic"))
2694 : {
2695 0 : oSRS.SetPS(dfCenterLat, dfCenterLong, dfScale, dfFalseEasting,
2696 : dfFalseNorthing);
2697 : }
2698 0 : else if (EQUAL(pszProjName, "Transverse Stereographic"))
2699 : {
2700 0 : oSRS.SetStereographic(dfCenterLat, dfCenterLong, dfScale,
2701 : dfFalseEasting, dfFalseNorthing);
2702 : }
2703 0 : else if (EQUAL(pszProjName, "Oblique Stereographic"))
2704 : {
2705 0 : oSRS.SetOS(dfCenterLat, dfCenterLong, dfScale, dfFalseEasting,
2706 : dfFalseNorthing);
2707 : }
2708 0 : else if (EQUAL(pszProjName, "Alber's Equal Area Conic") ||
2709 0 : EQUAL(pszProjName, "Albers Equal Area Conic"))
2710 : {
2711 0 : oSRS.SetACEA(dfStdP1, dfStdP2, dfCenterLat, dfCenterLong,
2712 : dfFalseEasting, dfFalseNorthing);
2713 : }
2714 0 : else if (EQUAL(pszProjName, "Sinusoidal"))
2715 : {
2716 0 : oSRS.SetSinusoidal(dfCenterLong, dfFalseEasting, dfFalseNorthing);
2717 : }
2718 0 : else if (EQUAL(pszProjName, "CylindricalEA") ||
2719 0 : EQUAL(pszProjName, "Cylindrical Equal Area"))
2720 : {
2721 0 : oSRS.SetCEA(dfStdP1, dfCenterLong, dfFalseEasting, dfFalseNorthing);
2722 : }
2723 : else
2724 : {
2725 0 : CPLError(
2726 : CE_Warning, CPLE_NotSupported,
2727 : "Projection not listed on Idrisi User's Manual( v.15.0/2005 ).\n\t"
2728 : "[\"%s\" in georeference file \"%s\"]",
2729 : pszProjName, pszFName);
2730 0 : oSRS.Clear();
2731 :
2732 0 : CPLFree(pszGeorefName);
2733 0 : CPLFree(pszProjName);
2734 0 : CPLFree(pszDatum);
2735 0 : CPLFree(pszEllipsoid);
2736 :
2737 0 : return CE_Warning;
2738 : }
2739 :
2740 : // ----------------------------------------------------------------------
2741 : // Set the Linear Units
2742 : // ----------------------------------------------------------------------
2743 :
2744 0 : int nUnit = GetUnitIndex(pszRefUnits);
2745 0 : if (nUnit > -1)
2746 : {
2747 0 : int nDeft = aoLinearUnitsConv[nUnit].nDefaultG;
2748 0 : oSRS.SetLinearUnits(aoLinearUnitsConv[nDeft].pszName,
2749 0 : aoLinearUnitsConv[nDeft].dfConv);
2750 : }
2751 : else
2752 : {
2753 0 : oSRS.SetLinearUnits("unknown", 1.0);
2754 : }
2755 :
2756 : // ----------------------------------------------------------------------
2757 : // Name ProjCS with the name on the georeference file
2758 : // ----------------------------------------------------------------------
2759 :
2760 0 : oSRS.SetProjCS(pszGeorefName);
2761 :
2762 0 : CPLFree(pszGeorefName);
2763 0 : CPLFree(pszProjName);
2764 0 : CPLFree(pszDatum);
2765 0 : CPLFree(pszEllipsoid);
2766 :
2767 0 : return CE_None;
2768 : }
2769 :
2770 : /************************************************************************/
2771 : /* Wkt2GeoReference() */
2772 : /************************************************************************/
2773 :
2774 : /***
2775 : * Converts OpenGIS WKT to Idrisi geographic reference information.
2776 : *
2777 : * That function will fill up the two parameters RefSystem and RefUnit
2778 : * that goes into the Idrisi metadata. But it could also create
2779 : * a accompanying georeference file to the output if necessary.
2780 : *
2781 : * First it will try to identify the ProjString as Local, WGS84 or
2782 : * one of the Idrisi name convention reference systems
2783 : * otherwise, if the projection system is supported by Idrisi,
2784 : * it will create a accompanying georeference files.
2785 : ***/
2786 :
2787 13 : CPLErr IdrisiDataset::Wkt2GeoReference(const OGRSpatialReference &oSRS,
2788 : char **pszRefSystem, char **pszRefUnit)
2789 : {
2790 : // -----------------------------------------------------
2791 : // Plane with default "Meters"
2792 : // -----------------------------------------------------
2793 :
2794 13 : if (oSRS.IsEmpty())
2795 : {
2796 0 : *pszRefSystem = CPLStrdup(rstPLANE);
2797 0 : *pszRefUnit = CPLStrdup(rstMETER);
2798 0 : return CE_None;
2799 : }
2800 :
2801 : // -----------------------------------------------------
2802 : // Local => Plane + Linear Unit
2803 : // -----------------------------------------------------
2804 :
2805 13 : if (oSRS.IsLocal())
2806 : {
2807 0 : *pszRefSystem = CPLStrdup(rstPLANE);
2808 0 : *pszRefUnit = GetUnitDefault(oSRS.GetAttrValue("UNIT"),
2809 : CPLSPrintf("%f", oSRS.GetLinearUnits()));
2810 0 : return CE_None;
2811 : }
2812 :
2813 : // -----------------------------------------------------
2814 : // Test to identify WGS84 => Latlong + Angular Unit
2815 : // -----------------------------------------------------
2816 :
2817 13 : if (oSRS.IsGeographic())
2818 : {
2819 13 : char *pszSpheroid = CPLStrdup(oSRS.GetAttrValue("SPHEROID"));
2820 13 : char *pszAuthName = CPLStrdup(oSRS.GetAuthorityName("GEOGCS"));
2821 13 : char *pszDatum = CPLStrdup(oSRS.GetAttrValue("DATUM"));
2822 13 : int nGCSCode = -1;
2823 13 : if (EQUAL(pszAuthName, "EPSG"))
2824 : {
2825 1 : nGCSCode = atoi(oSRS.GetAuthorityCode("GEOGCS"));
2826 : }
2827 13 : if ((nGCSCode == 4326) ||
2828 12 : ((STARTS_WITH_CI(pszSpheroid, "WGS")) &&
2829 12 : (strstr(pszSpheroid, "84")) && (STARTS_WITH_CI(pszDatum, "WGS")) &&
2830 12 : (strstr(pszDatum, "84"))))
2831 : {
2832 13 : *pszRefSystem = CPLStrdup(rstLATLONG);
2833 13 : *pszRefUnit = CPLStrdup(rstDEGREE);
2834 :
2835 13 : CPLFree(pszSpheroid);
2836 13 : CPLFree(pszAuthName);
2837 13 : CPLFree(pszDatum);
2838 :
2839 13 : return CE_None;
2840 : }
2841 :
2842 0 : CPLFree(pszSpheroid);
2843 0 : CPLFree(pszAuthName);
2844 0 : CPLFree(pszDatum);
2845 : }
2846 :
2847 : // -----------------------------------------------------
2848 : // Prepare to match some projections
2849 : // -----------------------------------------------------
2850 :
2851 0 : const char *pszProjName = oSRS.GetAttrValue("PROJECTION");
2852 :
2853 0 : if (pszProjName == nullptr)
2854 : {
2855 0 : pszProjName = "";
2856 : }
2857 :
2858 : // -----------------------------------------------------
2859 : // Check for UTM zones
2860 : // -----------------------------------------------------
2861 :
2862 0 : if (EQUAL(pszProjName, SRS_PT_TRANSVERSE_MERCATOR))
2863 : {
2864 0 : int nZone = oSRS.GetUTMZone();
2865 :
2866 0 : if ((nZone != 0) && (EQUAL(oSRS.GetAttrValue("DATUM"), SRS_DN_WGS84)))
2867 : {
2868 0 : double dfNorth = oSRS.GetProjParm(SRS_PP_FALSE_NORTHING);
2869 0 : *pszRefSystem = CPLStrdup(
2870 : CPLSPrintf(rstUTM, nZone, (dfNorth == 0.0 ? 'n' : 's')));
2871 0 : *pszRefUnit = CPLStrdup(rstMETER);
2872 0 : return CE_None;
2873 : }
2874 : }
2875 :
2876 : // -----------------------------------------------------
2877 : // Check for State Plane
2878 : // -----------------------------------------------------
2879 :
2880 0 : if (EQUAL(pszProjName, SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP) ||
2881 0 : EQUAL(pszProjName, SRS_PT_TRANSVERSE_MERCATOR))
2882 : {
2883 0 : CPLString osPCSCode;
2884 0 : const char *pszID = oSRS.GetAuthorityCode("PROJCS");
2885 0 : if (pszID != nullptr && strlen(pszID) > 0)
2886 : {
2887 : const char *pszPCSCode =
2888 0 : CSVGetField(CSVFilename("stateplane.csv"), "EPSG_PCS_CODE",
2889 : pszID, CC_Integer, "ID");
2890 0 : osPCSCode = (pszPCSCode) ? pszPCSCode : "";
2891 0 : if (!osPCSCode.empty())
2892 : {
2893 0 : int nZone = osPCSCode.back() - '0';
2894 0 : int nSPCode = atoi(osPCSCode);
2895 :
2896 0 : if (nZone == 0)
2897 0 : nZone = 1;
2898 : else
2899 0 : nSPCode = nSPCode - nZone + 1;
2900 :
2901 0 : int nNADYear = 83;
2902 0 : if (nSPCode > 10000)
2903 : {
2904 0 : nNADYear = 27;
2905 0 : nSPCode -= 10000;
2906 : }
2907 0 : char *pszState = CPLStrdup(GetStateName(nSPCode));
2908 0 : if (!EQUAL(pszState, ""))
2909 : {
2910 0 : *pszRefSystem = CPLStrdup(
2911 : CPLSPrintf(rstSPC, nNADYear, pszState, nZone));
2912 0 : *pszRefUnit =
2913 0 : GetUnitDefault(oSRS.GetAttrValue("UNIT"),
2914 : CPLSPrintf("%f", oSRS.GetLinearUnits()));
2915 0 : CPLFree(pszState);
2916 0 : return CE_None;
2917 : }
2918 0 : CPLFree(pszState);
2919 : }
2920 : } //
2921 :
2922 : // if EPSG code is missing, go to following steps to work with origin
2923 :
2924 0 : const char *pszNAD83 = "83";
2925 0 : const char *pszNAD27 = "27";
2926 0 : bool bIsOldNAD = false;
2927 :
2928 0 : const char *pszDatumValue = oSRS.GetAttrValue("DATUM", 0);
2929 0 : if ((strstr(pszDatumValue, pszNAD83) == nullptr) &&
2930 0 : (strstr(pszDatumValue, pszNAD27) != nullptr))
2931 : // strcpy(pszNAD, "27");
2932 0 : bIsOldNAD = true;
2933 :
2934 0 : if ((oSRS.FindProjParm("central_meridian", nullptr) != -1) &&
2935 0 : (oSRS.FindProjParm("latitude_of_origin", nullptr) != -1))
2936 : {
2937 0 : double dfLon = oSRS.GetProjParm("central_meridian");
2938 0 : double dfLat = oSRS.GetProjParm("latitude_of_origin");
2939 0 : dfLon = (int)(fabs(dfLon) * 100 + 0.5) / 100.0;
2940 0 : dfLat = (int)(fabs(dfLat) * 100 + 0.5) / 100.0;
2941 0 : *pszRefSystem = CPLStrdup(GetSpcs(dfLon, dfLat));
2942 : }
2943 :
2944 0 : if (*pszRefSystem != nullptr)
2945 : {
2946 : // Convert 83 TO 27
2947 0 : if (bIsOldNAD)
2948 : {
2949 : char pszOutRefSystem[9];
2950 0 : NAD83to27(pszOutRefSystem, *pszRefSystem);
2951 0 : *pszRefSystem = CPLStrdup(pszOutRefSystem);
2952 : }
2953 0 : *pszRefUnit =
2954 0 : GetUnitDefault(oSRS.GetAttrValue("UNIT"),
2955 : CPLSPrintf("%f", oSRS.GetLinearUnits()));
2956 0 : return CE_None;
2957 : }
2958 : }
2959 :
2960 0 : const char *pszProjectionOut = nullptr;
2961 :
2962 0 : if (oSRS.IsProjected())
2963 : {
2964 : // ---------------------------------------------------------
2965 : // Check for supported projections
2966 : // ---------------------------------------------------------
2967 :
2968 0 : if (EQUAL(pszProjName, SRS_PT_MERCATOR_1SP))
2969 : {
2970 0 : pszProjectionOut = "Mercator";
2971 : }
2972 0 : else if (EQUAL(pszProjName, SRS_PT_TRANSVERSE_MERCATOR))
2973 : {
2974 0 : pszProjectionOut = "Transverse Mercator";
2975 : }
2976 0 : else if (EQUAL(pszProjName, SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP))
2977 : {
2978 0 : pszProjectionOut = "Lambert Conformal Conic";
2979 : }
2980 0 : else if (EQUAL(pszProjName, SRS_PT_EQUIRECTANGULAR))
2981 : {
2982 0 : pszProjectionOut = "Plate Carr"
2983 : "\xE9"
2984 : "e"; /* 'eacute' in ISO-8859-1 */
2985 : }
2986 0 : else if (EQUAL(pszProjName, SRS_PT_LAMBERT_AZIMUTHAL_EQUAL_AREA))
2987 : {
2988 : double dfCenterLat =
2989 0 : oSRS.GetProjParm(SRS_PP_LATITUDE_OF_ORIGIN, 0.0, nullptr);
2990 0 : if (dfCenterLat == 0.0)
2991 0 : pszProjectionOut = "Lambert Transverse Azimuthal Equal Area";
2992 0 : else if (fabs(dfCenterLat) == 90.0)
2993 0 : pszProjectionOut = "Lambert Oblique Polar Azimuthal Equal Area";
2994 0 : else if (dfCenterLat > 0.0)
2995 0 : pszProjectionOut = "Lambert North Oblique Azimuthal Equal Area";
2996 : else
2997 0 : pszProjectionOut = "Lambert South Oblique Azimuthal Equal Area";
2998 : }
2999 0 : else if (EQUAL(pszProjName, SRS_PT_POLAR_STEREOGRAPHIC))
3000 : {
3001 0 : if (oSRS.GetProjParm(SRS_PP_LATITUDE_OF_ORIGIN, 0.0, nullptr) > 0)
3002 0 : pszProjectionOut = "North Polar Stereographic";
3003 : else
3004 0 : pszProjectionOut = "South Polar Stereographic";
3005 : }
3006 0 : else if (EQUAL(pszProjName, SRS_PT_STEREOGRAPHIC))
3007 : {
3008 0 : pszProjectionOut = "Transverse Stereographic";
3009 : }
3010 0 : else if (EQUAL(pszProjName, SRS_PT_OBLIQUE_STEREOGRAPHIC))
3011 : {
3012 0 : pszProjectionOut = "Oblique Stereographic";
3013 : }
3014 0 : else if (EQUAL(pszProjName, SRS_PT_SINUSOIDAL))
3015 : {
3016 0 : pszProjectionOut = "Sinusoidal";
3017 : }
3018 0 : else if (EQUAL(pszProjName, SRS_PT_ALBERS_CONIC_EQUAL_AREA))
3019 : {
3020 0 : pszProjectionOut = "Alber's Equal Area Conic";
3021 : }
3022 0 : else if (EQUAL(pszProjName, SRS_PT_CYLINDRICAL_EQUAL_AREA))
3023 : {
3024 0 : pszProjectionOut = "Cylindrical Equal Area";
3025 : }
3026 :
3027 : // ---------------------------------------------------------
3028 : // Failure, Projection system not supported
3029 : // ---------------------------------------------------------
3030 :
3031 0 : if (pszProjectionOut == nullptr)
3032 : {
3033 0 : CPLDebug("RST", "Not supported by RST driver: PROJECTION[\"%s\"]",
3034 : pszProjName);
3035 :
3036 0 : *pszRefSystem = CPLStrdup(rstPLANE);
3037 0 : *pszRefUnit = CPLStrdup(rstMETER);
3038 0 : return CE_Failure;
3039 : }
3040 : }
3041 : else
3042 : {
3043 0 : pszProjectionOut = "none";
3044 : }
3045 :
3046 : // ---------------------------------------------------------
3047 : // Prepare to write ref file
3048 : // ---------------------------------------------------------
3049 :
3050 0 : char *pszGeorefName = CPLStrdup("Unknown");
3051 0 : char *pszDatum = CPLStrdup(oSRS.GetAttrValue("DATUM"));
3052 0 : char *pszEllipsoid = CPLStrdup(oSRS.GetAttrValue("SPHEROID"));
3053 0 : double dfSemiMajor = oSRS.GetSemiMajor();
3054 0 : double dfSemiMinor = oSRS.GetSemiMinor();
3055 : double adfToWGS84[3];
3056 0 : oSRS.GetTOWGS84(adfToWGS84, 3);
3057 :
3058 0 : double dfCenterLat = 0.0;
3059 0 : double dfCenterLong = 0.0;
3060 0 : double dfFalseNorthing = 0.0;
3061 0 : double dfFalseEasting = 0.0;
3062 0 : double dfScale = 1.0;
3063 0 : int nParameters = 0;
3064 0 : double dfStdP1 = 0.0;
3065 0 : double dfStdP2 = 0.0;
3066 0 : char *pszAngularUnit = CPLStrdup(oSRS.GetAttrValue("GEOGCS|UNIT"));
3067 0 : char *pszLinearUnit = nullptr;
3068 :
3069 0 : if (oSRS.IsProjected())
3070 : {
3071 0 : CPLFree(pszGeorefName);
3072 0 : pszGeorefName = CPLStrdup(oSRS.GetAttrValue("PROJCS"));
3073 0 : dfCenterLat = oSRS.GetProjParm(SRS_PP_LATITUDE_OF_ORIGIN, 0.0, nullptr);
3074 0 : dfCenterLong = oSRS.GetProjParm(SRS_PP_CENTRAL_MERIDIAN, 0.0, nullptr);
3075 0 : dfFalseNorthing = oSRS.GetProjParm(SRS_PP_FALSE_NORTHING, 0.0, nullptr);
3076 0 : dfFalseEasting = oSRS.GetProjParm(SRS_PP_FALSE_EASTING, 0.0, nullptr);
3077 0 : dfScale = oSRS.GetProjParm(SRS_PP_SCALE_FACTOR, 0.0, nullptr);
3078 0 : dfStdP1 = oSRS.GetProjParm(SRS_PP_STANDARD_PARALLEL_1, -0.1, nullptr);
3079 0 : if (EQUAL(pszProjectionOut, "Cylindrical Equal Area"))
3080 : {
3081 0 : dfStdP2 = -dfStdP1;
3082 0 : dfScale = 1.0;
3083 : }
3084 : else
3085 : {
3086 : dfStdP2 =
3087 0 : oSRS.GetProjParm(SRS_PP_STANDARD_PARALLEL_2, -0.1, nullptr);
3088 : }
3089 0 : if (dfStdP1 != -0.1)
3090 : {
3091 0 : nParameters = 1;
3092 0 : if (dfStdP2 != -0.1)
3093 0 : nParameters = 2;
3094 : }
3095 0 : pszLinearUnit = GetUnitDefault(oSRS.GetAttrValue("PROJCS|UNIT"),
3096 : CPLSPrintf("%f", oSRS.GetLinearUnits()));
3097 : }
3098 : else
3099 : {
3100 0 : pszLinearUnit = GetUnitDefault(pszAngularUnit);
3101 : }
3102 :
3103 : // ---------------------------------------------------------
3104 : // Create a companion georeference file for this dataset
3105 : // ---------------------------------------------------------
3106 :
3107 0 : char **papszRef = nullptr;
3108 0 : papszRef = CSLAddNameValue(papszRef, refREF_SYSTEM, pszGeorefName);
3109 0 : papszRef = CSLAddNameValue(papszRef, refPROJECTION, pszProjectionOut);
3110 0 : papszRef = CSLAddNameValue(papszRef, refDATUM, pszDatum);
3111 0 : papszRef = CSLAddNameValue(papszRef, refDELTA_WGS84,
3112 : CPLSPrintf("%.3g %.3g %.3g", adfToWGS84[0],
3113 : adfToWGS84[1], adfToWGS84[2]));
3114 0 : papszRef = CSLAddNameValue(papszRef, refELLIPSOID, pszEllipsoid);
3115 0 : papszRef = CSLAddNameValue(papszRef, refMAJOR_SAX,
3116 : CPLSPrintf("%.3f", dfSemiMajor));
3117 0 : papszRef = CSLAddNameValue(papszRef, refMINOR_SAX,
3118 : CPLSPrintf("%.3f", dfSemiMinor));
3119 0 : papszRef = CSLAddNameValue(papszRef, refORIGIN_LONG,
3120 : CPLSPrintf("%.9g", dfCenterLong));
3121 0 : papszRef = CSLAddNameValue(papszRef, refORIGIN_LAT,
3122 : CPLSPrintf("%.9g", dfCenterLat));
3123 0 : papszRef = CSLAddNameValue(papszRef, refORIGIN_X,
3124 : CPLSPrintf("%.9g", dfFalseEasting));
3125 0 : papszRef = CSLAddNameValue(papszRef, refORIGIN_Y,
3126 : CPLSPrintf("%.9g", dfFalseNorthing));
3127 : papszRef =
3128 0 : CSLAddNameValue(papszRef, refSCALE_FAC, CPLSPrintf("%.9g", dfScale));
3129 0 : papszRef = CSLAddNameValue(papszRef, refUNITS, pszLinearUnit);
3130 0 : papszRef = CSLAddNameValue(papszRef, refPARAMETERS,
3131 : CPLSPrintf("%1d", nParameters));
3132 0 : if (nParameters > 0)
3133 : papszRef =
3134 0 : CSLAddNameValue(papszRef, refSTANDL_1, CPLSPrintf("%.9g", dfStdP1));
3135 0 : if (nParameters > 1)
3136 : papszRef =
3137 0 : CSLAddNameValue(papszRef, refSTANDL_2, CPLSPrintf("%.9g", dfStdP2));
3138 0 : myCSLSetNameValueSeparator(papszRef, ": ");
3139 0 : SaveAsCRLF(papszRef, CPLResetExtensionSafe(pszFilename, extREF).c_str());
3140 0 : CSLDestroy(papszRef);
3141 :
3142 0 : *pszRefSystem = CPLStrdup(CPLGetBasenameSafe(pszFilename).c_str());
3143 0 : *pszRefUnit = CPLStrdup(pszLinearUnit);
3144 :
3145 0 : CPLFree(pszGeorefName);
3146 0 : CPLFree(pszDatum);
3147 0 : CPLFree(pszEllipsoid);
3148 0 : CPLFree(pszLinearUnit);
3149 0 : CPLFree(pszAngularUnit);
3150 :
3151 0 : return CE_None;
3152 : }
3153 :
3154 : /************************************************************************/
3155 : /* FileExists() */
3156 : /************************************************************************/
3157 :
3158 60 : bool FileExists(const char *pszPath)
3159 : {
3160 : VSIStatBufL sStat;
3161 :
3162 60 : return VSIStatL(pszPath, &sStat) == 0;
3163 : }
3164 :
3165 : /************************************************************************/
3166 : /* GetStateCode() */
3167 : /************************************************************************/
3168 :
3169 0 : int GetStateCode(const char *pszState)
3170 : {
3171 0 : for (unsigned int i = 0; i < US_STATE_COUNT; i++)
3172 : {
3173 0 : if (EQUAL(pszState, aoUSStateTable[i].pszName))
3174 : {
3175 0 : return aoUSStateTable[i].nCode;
3176 : }
3177 : }
3178 0 : return -1;
3179 : }
3180 :
3181 : /************************************************************************/
3182 : /* GetStateName() */
3183 : /************************************************************************/
3184 :
3185 0 : const char *GetStateName(int nCode)
3186 : {
3187 0 : for (unsigned int i = 0; i < US_STATE_COUNT; i++)
3188 : {
3189 0 : if (nCode == aoUSStateTable[i].nCode)
3190 : {
3191 0 : return aoUSStateTable[i].pszName;
3192 : }
3193 : }
3194 0 : return nullptr;
3195 : }
3196 :
3197 : /************************************************************************/
3198 : /* GetSpcs() */
3199 : /************************************************************************/
3200 :
3201 0 : char *GetSpcs(double dfLon, double dfLat)
3202 : {
3203 0 : for (int i = 0; i < ORIGIN_COUNT; i++)
3204 : {
3205 0 : if ((dfLon == SPCS83Origin[i].longitude) &&
3206 0 : (dfLat == SPCS83Origin[i].latitude))
3207 : {
3208 0 : return (char *)SPCS83Origin[i].spcs;
3209 : }
3210 : }
3211 0 : return nullptr;
3212 : }
3213 :
3214 : /************************************************************************/
3215 : /* NAD83to27() */
3216 : /************************************************************************/
3217 0 : void NAD83to27(char *pszOutRef, char *pszInRef)
3218 : {
3219 0 : char *pOutput = pszOutRef;
3220 0 : char *pInput = pszInRef;
3221 0 : strncpy(pOutput, pInput, 3);
3222 :
3223 0 : pOutput = pOutput + 3;
3224 0 : pInput = pInput + 3;
3225 :
3226 0 : memcpy(pOutput, "27", 2);
3227 0 : pOutput = pOutput + 2;
3228 0 : pInput = pInput + 2;
3229 0 : strcpy(pOutput, pInput);
3230 0 : }
3231 :
3232 : /************************************************************************/
3233 : /* GetUnitIndex() */
3234 : /************************************************************************/
3235 :
3236 0 : int GetUnitIndex(const char *pszUnitName)
3237 : {
3238 0 : for (int i = 0; i < (int)LINEAR_UNITS_COUNT; i++)
3239 : {
3240 0 : if (EQUAL(pszUnitName, aoLinearUnitsConv[i].pszName))
3241 : {
3242 0 : return i;
3243 : }
3244 : }
3245 0 : return -1;
3246 : }
3247 :
3248 : /************************************************************************/
3249 : /* GetToMeterIndex() */
3250 : /************************************************************************/
3251 :
3252 0 : int GetToMeterIndex(const char *pszToMeter)
3253 : {
3254 0 : const double dfToMeter = CPLAtof_nz(pszToMeter);
3255 :
3256 0 : if (dfToMeter != 0.0)
3257 : {
3258 0 : for (int i = 0; i < (int)LINEAR_UNITS_COUNT; i++)
3259 : {
3260 0 : if (std::abs(aoLinearUnitsConv[i].dfConv - dfToMeter) < 0.00001)
3261 : {
3262 0 : return i;
3263 : }
3264 : }
3265 : }
3266 :
3267 0 : return -1;
3268 : }
3269 :
3270 : /************************************************************************/
3271 : /* GetUnitDefault() */
3272 : /************************************************************************/
3273 :
3274 0 : char *GetUnitDefault(const char *pszUnitName, const char *pszToMeter)
3275 : {
3276 0 : int nIndex = GetUnitIndex(pszUnitName);
3277 :
3278 0 : if (nIndex == -1 && pszToMeter != nullptr)
3279 : {
3280 0 : nIndex = GetToMeterIndex(pszToMeter);
3281 : }
3282 :
3283 0 : if (nIndex == -1)
3284 : {
3285 0 : return CPLStrdup("Unknown");
3286 : }
3287 :
3288 0 : return CPLStrdup(
3289 0 : aoLinearUnitsConv[aoLinearUnitsConv[nIndex].nDefaultI].pszName);
3290 : }
3291 :
3292 : /************************************************************************/
3293 : /* CSLSaveCRLF() */
3294 : /************************************************************************/
3295 :
3296 : /***
3297 : * Write a stringlist to a CR + LF terminated text file.
3298 : *
3299 : * Returns the number of lines written, or 0 if the file could not
3300 : * be written.
3301 : */
3302 :
3303 46 : int SaveAsCRLF(char **papszStrList, const char *pszFname)
3304 : {
3305 46 : VSILFILE *fp = VSIFOpenL(pszFname, "wt");
3306 46 : int nLines = 0;
3307 :
3308 46 : if (papszStrList)
3309 : {
3310 46 : if (fp != nullptr)
3311 : {
3312 800 : while (*papszStrList != nullptr)
3313 : {
3314 766 : if (VSIFPrintfL(fp, "%s\r\n", *papszStrList) < 1)
3315 : {
3316 10 : CPLError(CE_Failure, CPLE_FileIO,
3317 : "CSLSaveCRLF(\"%s\") failed: unable to write to "
3318 : "output file.",
3319 : pszFname);
3320 10 : break;
3321 : }
3322 :
3323 756 : nLines++;
3324 756 : papszStrList++;
3325 : }
3326 :
3327 44 : VSIFCloseL(fp);
3328 : }
3329 : else
3330 : {
3331 2 : CPLError(CE_Failure, CPLE_OpenFailed,
3332 : "CSLSaveCRLF(\"%s\") failed: unable to open output file.",
3333 : pszFname);
3334 : }
3335 : }
3336 :
3337 46 : return nLines;
3338 : }
3339 :
3340 : /************************************************************************/
3341 : /* GDALRegister_IDRISI() */
3342 : /************************************************************************/
3343 :
3344 1889 : void GDALRegister_IDRISI()
3345 : {
3346 1889 : if (GDALGetDriverByName("RST") != nullptr)
3347 282 : return;
3348 :
3349 1607 : GDALDriver *poDriver = new GDALDriver();
3350 :
3351 1607 : poDriver->SetDescription("RST");
3352 1607 : poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
3353 1607 : poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, rstVERSION);
3354 1607 : poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC, "drivers/raster/Idrisi.html");
3355 1607 : poDriver->SetMetadataItem(GDAL_DMD_EXTENSION, extRST);
3356 1607 : poDriver->SetMetadataItem(GDAL_DMD_CREATIONDATATYPES, "Byte Int16 Float32");
3357 :
3358 1607 : poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");
3359 :
3360 1607 : poDriver->pfnOpen = IdrisiDataset::Open;
3361 1607 : poDriver->pfnCreate = IdrisiDataset::Create;
3362 1607 : poDriver->pfnCreateCopy = IdrisiDataset::CreateCopy;
3363 :
3364 1607 : GetGDALDriverManager()->RegisterDriver(poDriver);
3365 : }
|
