1 /*
2
3 test_map_infrared.c -- RasterLite-2 Test Case
4
5 Author: Sandro Furieri <a.furieri@lqt.it>
6
7 ------------------------------------------------------------------------------
8
9 Version: MPL 1.1/GPL 2.0/LGPL 2.1
10
11 The contents of this file are subject to the Mozilla Public License Version
12 1.1 (the "License"); you may not use this file except in compliance with
13 the License. You may obtain a copy of the License at
14 http://www.mozilla.org/MPL/
15
16 Software distributed under the License is distributed on an "AS IS" basis,
17 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
18 for the specific language governing rights and limitations under the
19 License.
20
21 The Original Code is the SpatiaLite library
22
23 The Initial Developer of the Original Code is Alessandro Furieri
24
25 Portions created by the Initial Developer are Copyright (C) 2013
26 the Initial Developer. All Rights Reserved.
27
28 Contributor(s):
29
30 Alternatively, the contents of this file may be used under the terms of
31 either the GNU General Public License Version 2 or later (the "GPL"), or
32 the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
33 in which case the provisions of the GPL or the LGPL are applicable instead
34 of those above. If you wish to allow use of your version of this file only
35 under the terms of either the GPL or the LGPL, and not to allow others to
36 use your version of this file under the terms of the MPL, indicate your
37 decision by deleting the provisions above and replace them with the notice
38 and other provisions required by the GPL or the LGPL. If you do not delete
39 the provisions above, a recipient may use your version of this file under
40 the terms of any one of the MPL, the GPL or the LGPL.
41
42 */
43 #define _GNU_SOURCE
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <stdio.h>
47 #include <string.h>
48
49 #include "sqlite3.h"
50 #include "spatialite.h"
51 #include "spatialite/gaiaaux.h"
52
53 #include "rasterlite2/rasterlite2.h"
54
55 #define TILE_256 256
56 #define TILE_512 512
57 #define TILE_1024 1024
58
59 static int
execute_check(sqlite3 * sqlite,const char * sql)60 execute_check (sqlite3 * sqlite, const char *sql)
61 {
62 /* executing an SQL statement returning True/False */
63 sqlite3_stmt *stmt;
64 int ret;
65 int retcode = 0;
66
67 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
68 if (ret != SQLITE_OK)
69 return SQLITE_ERROR;
70 ret = sqlite3_step (stmt);
71 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
72 {
73 if (sqlite3_column_int (stmt, 0) == 1)
74 retcode = 1;
75 }
76 sqlite3_finalize (stmt);
77 if (retcode == 1)
78 return SQLITE_OK;
79 return SQLITE_ERROR;
80 }
81
82 static int
get_max_tile_id(sqlite3 * sqlite,const char * coverage)83 get_max_tile_id (sqlite3 * sqlite, const char *coverage)
84 {
85 /* retriving the Max tile_id for a given Coverage */
86 char *sql;
87 char *table;
88 char *xtable;
89 sqlite3_stmt *stmt;
90 int ret;
91 int max = 0;
92
93 table = sqlite3_mprintf ("%s_tile_data", coverage);
94 xtable = gaiaDoubleQuotedSql (table);
95 sqlite3_free (table);
96 sql = sqlite3_mprintf ("SELECT Max(tile_id) FROM \"%s\"", xtable);
97 free (xtable);
98 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
99 sqlite3_free (sql);
100 if (ret != SQLITE_OK)
101 return 0;
102 while (1)
103 {
104 /* scrolling the result set rows */
105 ret = sqlite3_step (stmt);
106 if (ret == SQLITE_DONE)
107 break; /* end of result set */
108 if (ret == SQLITE_ROW)
109 max = sqlite3_column_int (stmt, 0);
110 }
111 sqlite3_finalize (stmt);
112 return max;
113 }
114
115 static int
do_export_tile_image(sqlite3 * sqlite,const char * coverage,int tile_id,int band_mix)116 do_export_tile_image (sqlite3 * sqlite, const char *coverage, int tile_id,
117 int band_mix)
118 {
119 /* attempting to export a visible Tile */
120 char *sql;
121 char *path;
122 int ret;
123 int transparent = 1;
124 unsigned char red_band = 0;
125 unsigned char green_band = 1;
126 unsigned char blue_band = 2;
127
128 if (band_mix == 1)
129 {
130 red_band = 3;
131 green_band = 1;
132 blue_band = 2;
133 }
134 if (band_mix == 2)
135 {
136 red_band = 0;
137 green_band = 1;
138 blue_band = 3;
139 }
140 if (tile_id <= 1)
141 transparent = 0;
142 if (tile_id < 0)
143 tile_id = get_max_tile_id (sqlite, coverage);
144 path = sqlite3_mprintf ("./%s_tile_%d_%d.png", coverage, tile_id, band_mix);
145 sql =
146 sqlite3_mprintf
147 ("SELECT BlobToFile(RL2_GetTripleBandTileImage(%Q, %d, %d, %d, %d, '#e0ffe0', %d), %Q)",
148 coverage, tile_id, red_band, green_band, blue_band, transparent, path);
149 ret = execute_check (sqlite, sql);
150 sqlite3_free (sql);
151 unlink (path);
152 sqlite3_free (path);
153 if (ret != SQLITE_OK)
154 {
155 fprintf (stderr,
156 "ERROR: Unable to export an Image from \"%s\" tile_id=%d\n",
157 coverage, tile_id);
158 return 0;
159 }
160 return 1;
161 }
162
163 static int
do_export_mono_tile_image(sqlite3 * sqlite,const char * coverage,int tile_id,int band_mix)164 do_export_mono_tile_image (sqlite3 * sqlite, const char *coverage, int tile_id,
165 int band_mix)
166 {
167 /* attempting to export a visible Tile (Mono-Band) */
168 char *sql;
169 char *path;
170 int ret;
171 int transparent = 1;
172 unsigned char mono_band = 0;
173
174 if (band_mix == 1)
175 mono_band = 2;
176 if (band_mix == 2)
177 mono_band = 3;
178 if (tile_id <= 1)
179 transparent = 0;
180 if (tile_id < 0)
181 tile_id = get_max_tile_id (sqlite, coverage);
182 path =
183 sqlite3_mprintf ("./%s_mono_tile_%d_%d.png", coverage, tile_id,
184 band_mix);
185 sql =
186 sqlite3_mprintf
187 ("SELECT BlobToFile(RL2_GetMonoBandTileImage(%Q, %d, %d, '#e0ffe0', %d), %Q)",
188 coverage, tile_id, mono_band, transparent, path);
189 ret = execute_check (sqlite, sql);
190 sqlite3_free (sql);
191 unlink (path);
192 sqlite3_free (path);
193 if (ret != SQLITE_OK)
194 {
195 fprintf (stderr,
196 "ERROR: Unable to export an Image from \"%s\" tile_id=%d\n",
197 coverage, tile_id);
198 return 0;
199 }
200 return 1;
201 }
202
203 static int
get_base_resolution(sqlite3 * sqlite,const char * coverage,double * x_res,double * y_res)204 get_base_resolution (sqlite3 * sqlite, const char *coverage, double *x_res,
205 double *y_res)
206 {
207 /* attempting to retrieve the Coverage's base resolution */
208 char *sql;
209 sqlite3_stmt *stmt;
210 int ret;
211 int ok = 0;
212
213 sql = sqlite3_mprintf ("SELECT horz_resolution, vert_resolution "
214 "FROM raster_coverages WHERE coverage_name = %Q",
215 coverage);
216 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
217 sqlite3_free (sql);
218 if (ret != SQLITE_OK)
219 return 0;
220
221 while (1)
222 {
223 /* scrolling the result set rows */
224 ret = sqlite3_step (stmt);
225 if (ret == SQLITE_DONE)
226 break; /* end of result set */
227 if (ret == SQLITE_ROW)
228 {
229 *x_res = sqlite3_column_double (stmt, 0);
230 *y_res = sqlite3_column_double (stmt, 1);
231 ok = 1;
232 }
233 }
234 sqlite3_finalize (stmt);
235 return ok;
236 }
237
238 static int
do_export_geotiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale)239 do_export_geotiff (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom,
240 int scale)
241 {
242 /* exporting a GeoTiff */
243 char *sql;
244 char *path;
245 sqlite3_stmt *stmt;
246 int ret;
247 double x_res;
248 double y_res;
249 double xx_res;
250 double yy_res;
251 unsigned char *blob;
252 int blob_size;
253 int retcode = 0;
254
255 path = sqlite3_mprintf ("./%s_gt_%d.tif", coverage, scale);
256
257 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
258 return 0;
259 xx_res = x_res * (double) scale;
260 yy_res = y_res * (double) scale;
261
262 sql = "SELECT RL2_WriteGeoTiff(?, ?, ?, ?, ?, ?, ?, ?, ?)";
263 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
264 if (ret != SQLITE_OK)
265 return 0;
266 sqlite3_reset (stmt);
267 sqlite3_clear_bindings (stmt);
268 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
269 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
270 sqlite3_bind_int (stmt, 3, 1024);
271 sqlite3_bind_int (stmt, 4, 1024);
272 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
273 sqlite3_bind_blob (stmt, 5, blob, blob_size, free);
274 sqlite3_bind_double (stmt, 6, xx_res);
275 sqlite3_bind_double (stmt, 7, yy_res);
276 sqlite3_bind_int (stmt, 8, 0);
277 sqlite3_bind_text (stmt, 9, "NONE", 4, SQLITE_TRANSIENT);
278 ret = sqlite3_step (stmt);
279 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
280 {
281 if (sqlite3_column_int (stmt, 0) == 1)
282 retcode = 1;
283 }
284 sqlite3_finalize (stmt);
285 unlink (path);
286 if (!retcode)
287 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
288 sqlite3_free (path);
289 return retcode;
290 }
291
292 static int
do_export_band_composed_geotiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix,int with_worldfile)293 do_export_band_composed_geotiff (sqlite3 * sqlite, const char *coverage,
294 gaiaGeomCollPtr geom, int scale, int band_mix,
295 int with_worldfile)
296 {
297 /* exporting a GeoTiff */
298 char *sql;
299 char *path;
300 sqlite3_stmt *stmt;
301 int ret;
302 double x_res;
303 double y_res;
304 double xx_res;
305 double yy_res;
306 unsigned char *blob;
307 int blob_size;
308 int retcode = 0;
309 unsigned char red_band = 0;
310 unsigned char green_band = 1;
311 unsigned char blue_band = 2;
312
313 if (band_mix == 1)
314 {
315 red_band = 3;
316 green_band = 1;
317 blue_band = 2;
318 }
319 if (band_mix == 2)
320 {
321 red_band = 0;
322 green_band = 1;
323 blue_band = 3;
324 }
325
326 path = sqlite3_mprintf ("./%s_bc_gt_%d_%d.tif", coverage, scale, band_mix);
327
328 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
329 return 0;
330 xx_res = x_res * (double) scale;
331 yy_res = y_res * (double) scale;
332
333 sql =
334 "SELECT RL2_WriteTripleBandGeoTiff(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
335 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
336 if (ret != SQLITE_OK)
337 return 0;
338 sqlite3_reset (stmt);
339 sqlite3_clear_bindings (stmt);
340 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
341 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
342 sqlite3_bind_int (stmt, 3, 1024);
343 sqlite3_bind_int (stmt, 4, 1024);
344 sqlite3_bind_int (stmt, 5, red_band);
345 sqlite3_bind_int (stmt, 6, green_band);
346 sqlite3_bind_int (stmt, 7, blue_band);
347 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
348 sqlite3_bind_blob (stmt, 8, blob, blob_size, free);
349 sqlite3_bind_double (stmt, 9, xx_res);
350 sqlite3_bind_double (stmt, 10, yy_res);
351 sqlite3_bind_int (stmt, 11, with_worldfile);
352 sqlite3_bind_text (stmt, 12, "NONE", 4, SQLITE_TRANSIENT);
353 ret = sqlite3_step (stmt);
354 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
355 {
356 if (sqlite3_column_int (stmt, 0) == 1)
357 retcode = 1;
358 }
359 sqlite3_finalize (stmt);
360 unlink (path);
361 if (!retcode)
362 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
363 sqlite3_free (path);
364 path = sqlite3_mprintf ("./%s_bc_gt_%d_%d.tfw", coverage, scale, band_mix);
365 unlink (path);
366 sqlite3_free (path);
367 return retcode;
368 }
369
370 static int
do_export_band_composed_tiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix)371 do_export_band_composed_tiff (sqlite3 * sqlite, const char *coverage,
372 gaiaGeomCollPtr geom, int scale, int band_mix)
373 {
374 /* exporting a plain Tiff */
375 char *sql;
376 char *path;
377 sqlite3_stmt *stmt;
378 int ret;
379 double x_res;
380 double y_res;
381 double xx_res;
382 double yy_res;
383 unsigned char *blob;
384 int blob_size;
385 int retcode = 0;
386 unsigned char red_band = 0;
387 unsigned char green_band = 1;
388 unsigned char blue_band = 2;
389
390 if (band_mix == 1)
391 {
392 red_band = 3;
393 green_band = 1;
394 blue_band = 2;
395 }
396 if (band_mix == 2)
397 {
398 red_band = 0;
399 green_band = 1;
400 blue_band = 3;
401 }
402
403 path = sqlite3_mprintf ("./%s_bc_%d_%d.tif", coverage, scale, band_mix);
404
405 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
406 return 0;
407 xx_res = x_res * (double) scale;
408 yy_res = y_res * (double) scale;
409
410 sql = "SELECT RL2_WriteTripleBandTiff(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
411 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
412 if (ret != SQLITE_OK)
413 return 0;
414 sqlite3_reset (stmt);
415 sqlite3_clear_bindings (stmt);
416 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
417 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
418 sqlite3_bind_int (stmt, 3, 1024);
419 sqlite3_bind_int (stmt, 4, 1024);
420 sqlite3_bind_int (stmt, 5, red_band);
421 sqlite3_bind_int (stmt, 6, green_band);
422 sqlite3_bind_int (stmt, 7, blue_band);
423 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
424 sqlite3_bind_blob (stmt, 8, blob, blob_size, free);
425 sqlite3_bind_double (stmt, 9, xx_res);
426 sqlite3_bind_double (stmt, 10, yy_res);
427 sqlite3_bind_text (stmt, 11, "NONE", 4, SQLITE_TRANSIENT);
428 ret = sqlite3_step (stmt);
429 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
430 {
431 if (sqlite3_column_int (stmt, 0) == 1)
432 retcode = 1;
433 }
434 sqlite3_finalize (stmt);
435 unlink (path);
436 if (!retcode)
437 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
438 sqlite3_free (path);
439 return retcode;
440 }
441
442 static int
do_export_band_composed_tiff_tfw(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix)443 do_export_band_composed_tiff_tfw (sqlite3 * sqlite, const char *coverage,
444 gaiaGeomCollPtr geom, int scale, int band_mix)
445 {
446 /* exporting a Tiff+TFW */
447 char *sql;
448 char *path;
449 sqlite3_stmt *stmt;
450 int ret;
451 double x_res;
452 double y_res;
453 double xx_res;
454 double yy_res;
455 unsigned char *blob;
456 int blob_size;
457 int retcode = 0;
458 unsigned char red_band = 0;
459 unsigned char green_band = 1;
460 unsigned char blue_band = 2;
461
462 if (band_mix == 1)
463 {
464 red_band = 3;
465 green_band = 1;
466 blue_band = 2;
467 }
468 if (band_mix == 2)
469 {
470 red_band = 0;
471 green_band = 1;
472 blue_band = 3;
473 }
474
475 path = sqlite3_mprintf ("./%s_bc_tfw_%d_%d.tif", coverage, scale, band_mix);
476
477 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
478 return 0;
479 xx_res = x_res * (double) scale;
480 yy_res = y_res * (double) scale;
481
482 sql = "SELECT RL2_WriteTripleBandTiffTfw(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
483 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
484 if (ret != SQLITE_OK)
485 return 0;
486 sqlite3_reset (stmt);
487 sqlite3_clear_bindings (stmt);
488 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
489 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
490 sqlite3_bind_int (stmt, 3, 1024);
491 sqlite3_bind_int (stmt, 4, 1024);
492 sqlite3_bind_int (stmt, 5, red_band);
493 sqlite3_bind_int (stmt, 6, green_band);
494 sqlite3_bind_int (stmt, 7, blue_band);
495 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
496 sqlite3_bind_blob (stmt, 8, blob, blob_size, free);
497 sqlite3_bind_double (stmt, 9, xx_res);
498 sqlite3_bind_double (stmt, 10, yy_res);
499 sqlite3_bind_text (stmt, 11, "NONE", 4, SQLITE_TRANSIENT);
500 ret = sqlite3_step (stmt);
501 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
502 {
503 if (sqlite3_column_int (stmt, 0) == 1)
504 retcode = 1;
505 }
506 sqlite3_finalize (stmt);
507 unlink (path);
508 if (!retcode)
509 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
510 sqlite3_free (path);
511 path = sqlite3_mprintf ("./%s_bc_tfw_%d_%d.tfw", coverage, scale, band_mix);
512 unlink (path);
513 sqlite3_free (path);
514 return retcode;
515 }
516
517 static int
do_export_mono_band_geotiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix,int with_worldfile)518 do_export_mono_band_geotiff (sqlite3 * sqlite, const char *coverage,
519 gaiaGeomCollPtr geom, int scale, int band_mix,
520 int with_worldfile)
521 {
522 /* exporting a GeoTiff */
523 char *sql;
524 char *path;
525 sqlite3_stmt *stmt;
526 int ret;
527 double x_res;
528 double y_res;
529 double xx_res;
530 double yy_res;
531 unsigned char *blob;
532 int blob_size;
533 int retcode = 0;
534 unsigned char mono_band = 0;
535
536 if (band_mix == 1)
537 mono_band = 1;
538 if (band_mix == 2)
539 mono_band = 3;
540
541 path =
542 sqlite3_mprintf ("./%s_mono_gt_%d_%d.tif", coverage, scale, band_mix);
543
544 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
545 return 0;
546 xx_res = x_res * (double) scale;
547 yy_res = y_res * (double) scale;
548
549 sql = "SELECT RL2_WriteMonoBandGeoTiff(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
550 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
551 if (ret != SQLITE_OK)
552 return 0;
553 sqlite3_reset (stmt);
554 sqlite3_clear_bindings (stmt);
555 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
556 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
557 sqlite3_bind_int (stmt, 3, 1024);
558 sqlite3_bind_int (stmt, 4, 1024);
559 sqlite3_bind_int (stmt, 5, mono_band);
560 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
561 sqlite3_bind_blob (stmt, 6, blob, blob_size, free);
562 sqlite3_bind_double (stmt, 7, xx_res);
563 sqlite3_bind_double (stmt, 8, yy_res);
564 sqlite3_bind_int (stmt, 9, with_worldfile);
565 sqlite3_bind_text (stmt, 10, "NONE", 4, SQLITE_TRANSIENT);
566 ret = sqlite3_step (stmt);
567 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
568 {
569 if (sqlite3_column_int (stmt, 0) == 1)
570 retcode = 1;
571 }
572 sqlite3_finalize (stmt);
573 unlink (path);
574 if (!retcode)
575 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
576 sqlite3_free (path);
577 path =
578 sqlite3_mprintf ("./%s_mono_gt_%d_%d.tfw", coverage, scale, band_mix);
579 unlink (path);
580 sqlite3_free (path);
581 return retcode;
582 }
583
584 static int
do_export_mono_band_tiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix)585 do_export_mono_band_tiff (sqlite3 * sqlite, const char *coverage,
586 gaiaGeomCollPtr geom, int scale, int band_mix)
587 {
588 /* exporting a plain Tiff */
589 char *sql;
590 char *path;
591 sqlite3_stmt *stmt;
592 int ret;
593 double x_res;
594 double y_res;
595 double xx_res;
596 double yy_res;
597 unsigned char *blob;
598 int blob_size;
599 int retcode = 0;
600 unsigned char mono_band = 0;
601
602 if (band_mix == 1)
603 mono_band = 1;
604 if (band_mix == 2)
605 mono_band = 3;
606
607 path = sqlite3_mprintf ("./%s_mono_%d_%d.tif", coverage, scale, band_mix);
608
609 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
610 return 0;
611 xx_res = x_res * (double) scale;
612 yy_res = y_res * (double) scale;
613
614 sql = "SELECT RL2_WriteMonoBandTiff(?, ?, ?, ?, ?, ?, ?, ?, ?)";
615 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
616 if (ret != SQLITE_OK)
617 return 0;
618 sqlite3_reset (stmt);
619 sqlite3_clear_bindings (stmt);
620 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
621 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
622 sqlite3_bind_int (stmt, 3, 1024);
623 sqlite3_bind_int (stmt, 4, 1024);
624 sqlite3_bind_int (stmt, 5, mono_band);
625 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
626 sqlite3_bind_blob (stmt, 6, blob, blob_size, free);
627 sqlite3_bind_double (stmt, 7, xx_res);
628 sqlite3_bind_double (stmt, 8, yy_res);
629 sqlite3_bind_text (stmt, 9, "NONE", 4, SQLITE_TRANSIENT);
630 ret = sqlite3_step (stmt);
631 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
632 {
633 if (sqlite3_column_int (stmt, 0) == 1)
634 retcode = 1;
635 }
636 sqlite3_finalize (stmt);
637 unlink (path);
638 if (!retcode)
639 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
640 sqlite3_free (path);
641 return retcode;
642 }
643
644 static int
do_export_mono_band_tiff_tfw(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale,int band_mix)645 do_export_mono_band_tiff_tfw (sqlite3 * sqlite, const char *coverage,
646 gaiaGeomCollPtr geom, int scale, int band_mix)
647 {
648 /* exporting a Tiff+TFW */
649 char *sql;
650 char *path;
651 sqlite3_stmt *stmt;
652 int ret;
653 double x_res;
654 double y_res;
655 double xx_res;
656 double yy_res;
657 unsigned char *blob;
658 int blob_size;
659 int retcode = 0;
660 unsigned char mono_band = 0;
661
662 if (band_mix == 1)
663 mono_band = 1;
664 if (band_mix == 2)
665 mono_band = 3;
666
667 path =
668 sqlite3_mprintf ("./%s_mono_tfw_%d_%d.tif", coverage, scale, band_mix);
669
670 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
671 return 0;
672 xx_res = x_res * (double) scale;
673 yy_res = y_res * (double) scale;
674
675 sql = "SELECT RL2_WriteMonoBandTiffTfw(?, ?, ?, ?, ?, ?, ?, ?, ?)";
676 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
677 if (ret != SQLITE_OK)
678 return 0;
679 sqlite3_reset (stmt);
680 sqlite3_clear_bindings (stmt);
681 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
682 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
683 sqlite3_bind_int (stmt, 3, 1024);
684 sqlite3_bind_int (stmt, 4, 1024);
685 sqlite3_bind_int (stmt, 5, mono_band);
686 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
687 sqlite3_bind_blob (stmt, 6, blob, blob_size, free);
688 sqlite3_bind_double (stmt, 7, xx_res);
689 sqlite3_bind_double (stmt, 8, yy_res);
690 sqlite3_bind_text (stmt, 9, "NONE", 4, SQLITE_TRANSIENT);
691 ret = sqlite3_step (stmt);
692 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
693 {
694 if (sqlite3_column_int (stmt, 0) == 1)
695 retcode = 1;
696 }
697 sqlite3_finalize (stmt);
698 unlink (path);
699 if (!retcode)
700 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
701 sqlite3_free (path);
702 path =
703 sqlite3_mprintf ("./%s_mono_tfw_%d_%d.tfw", coverage, scale, band_mix);
704 unlink (path);
705 sqlite3_free (path);
706 return retcode;
707 }
708
709 static int
do_export_map_image(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,const char * style,const char * suffix,int monolithic)710 do_export_map_image (sqlite3 * sqlite, const char *coverage,
711 gaiaGeomCollPtr geom, const char *style,
712 const char *suffix, int monolithic)
713 {
714 /* exporting a Map Image (full rendered) */
715 char *sql;
716 char *path;
717 sqlite3_stmt *stmt;
718 int ret;
719 unsigned char *blob;
720 int blob_size;
721 int retcode = 0;
722 const char *format = "text/plain";
723
724 if (strcmp (suffix, "png") == 0)
725 format = "image/png";
726 if (strcmp (suffix, "jpg") == 0)
727 format = "image/jpeg";
728 if (strcmp (suffix, "tif") == 0)
729 format = "image/tiff";
730 if (strcmp (suffix, "pdf") == 0)
731 format = "application/x-pdf";
732
733 path =
734 sqlite3_mprintf ("./%s_%s_map_%s.%s", coverage,
735 monolithic ? "mono" : "sect", style, suffix);
736
737 sql =
738 "SELECT BlobToFile(RL2_GetMapImage(?, ST_Buffer(?, 100), ?, ?, ?, ?, ?, ?), ?)";
739 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
740 if (ret != SQLITE_OK)
741 return 0;
742 sqlite3_reset (stmt);
743 sqlite3_clear_bindings (stmt);
744 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
745 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
746 sqlite3_bind_blob (stmt, 2, blob, blob_size, free);
747 sqlite3_bind_int (stmt, 3, 1024);
748 sqlite3_bind_int (stmt, 4, 1024);
749 sqlite3_bind_text (stmt, 5, style, strlen (style), SQLITE_STATIC);
750 sqlite3_bind_text (stmt, 6, format, strlen (format), SQLITE_STATIC);
751 sqlite3_bind_text (stmt, 7, "#ffe0e0", 7, SQLITE_STATIC);
752 sqlite3_bind_int (stmt, 8, 1);
753 sqlite3_bind_text (stmt, 9, path, strlen (path), SQLITE_STATIC);
754 ret = sqlite3_step (stmt);
755 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
756 {
757 if (sqlite3_column_int (stmt, 0) == 1)
758 retcode = 1;
759 }
760 sqlite3_finalize (stmt);
761 unlink (path);
762 if (!retcode)
763 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
764 sqlite3_free (path);
765 return retcode;
766 }
767
768 static gaiaGeomCollPtr
get_center_point(sqlite3 * sqlite,const char * coverage)769 get_center_point (sqlite3 * sqlite, const char *coverage)
770 {
771 /* attempting to retrieve the Coverage's Center Point */
772 char *sql;
773 sqlite3_stmt *stmt;
774 gaiaGeomCollPtr geom = NULL;
775 int ret;
776
777 sql = sqlite3_mprintf ("SELECT MakePoint("
778 "extent_minx + ((extent_maxx - extent_minx) / 2.0), "
779 "extent_miny + ((extent_maxy - extent_miny) / 2.0)) "
780 "FROM raster_coverages WHERE coverage_name = %Q",
781 coverage);
782 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
783 sqlite3_free (sql);
784 if (ret != SQLITE_OK)
785 return NULL;
786
787 while (1)
788 {
789 /* scrolling the result set rows */
790 ret = sqlite3_step (stmt);
791 if (ret == SQLITE_DONE)
792 break; /* end of result set */
793 if (ret == SQLITE_ROW)
794 {
795 const unsigned char *blob = sqlite3_column_blob (stmt, 0);
796 int blob_sz = sqlite3_column_bytes (stmt, 0);
797 geom = gaiaFromSpatiaLiteBlobWkb (blob, blob_sz);
798 }
799 }
800 sqlite3_finalize (stmt);
801 return geom;
802 }
803
804 static int
test_coverage(sqlite3 * sqlite,unsigned char compression,int tile_sz,int * retcode)805 test_coverage (sqlite3 * sqlite, unsigned char compression, int tile_sz,
806 int *retcode)
807 {
808 /* testing some DBMS Coverage */
809 int ret;
810 char *err_msg = NULL;
811 const char *coverage;
812 const char *sample_name;
813 const char *pixel_name;
814 unsigned char num_bands;
815 const char *compression_name;
816 int qlty;
817 int tile_size;
818 char *sql;
819 gaiaGeomCollPtr geom;
820 int test_map_image = 0;
821
822 /* setting the coverage name */
823 switch (compression)
824 {
825 case RL2_COMPRESSION_NONE:
826 switch (tile_sz)
827 {
828 case TILE_256:
829 coverage = "infrared_none_256";
830 break;
831 case TILE_512:
832 coverage = "infrared_none_512";
833 break;
834 case TILE_1024:
835 coverage = "infrared_none_1024";
836 test_map_image = 1;
837 break;
838 };
839 break;
840 case RL2_COMPRESSION_DEFLATE:
841 switch (tile_sz)
842 {
843 case TILE_256:
844 coverage = "infrared_zip_256";
845 break;
846 case TILE_512:
847 coverage = "infrared_zip_512";
848 break;
849 case TILE_1024:
850 coverage = "infrared_zip_1024";
851 break;
852 };
853 break;
854 case RL2_COMPRESSION_LZMA:
855 switch (tile_sz)
856 {
857 case TILE_256:
858 coverage = "infrared_lzma_256";
859 break;
860 case TILE_512:
861 coverage = "infrared_lzma_512";
862 break;
863 case TILE_1024:
864 coverage = "infrared_lzma_1024";
865 break;
866 };
867 break;
868 };
869
870 /* preparing misc Coverage's parameters */
871 sample_name = "UINT8";
872 pixel_name = "MULTIBAND";
873 num_bands = 4;
874 switch (compression)
875 {
876 case RL2_COMPRESSION_NONE:
877 compression_name = "NONE";
878 qlty = 100;
879 break;
880 case RL2_COMPRESSION_DEFLATE:
881 compression_name = "DEFLATE";
882 qlty = 100;
883 break;
884 case RL2_COMPRESSION_LZMA:
885 compression_name = "LZMA";
886 qlty = 100;
887 break;
888 };
889 switch (tile_sz)
890 {
891 case TILE_256:
892 tile_size = 256;
893 break;
894 case TILE_512:
895 tile_size = 512;
896 break;
897 case TILE_1024:
898 tile_size = 1024;
899 break;
900 };
901
902 /* creating the DBMS Coverage */
903 sql = sqlite3_mprintf ("SELECT RL2_CreateCoverage("
904 "%Q, %Q, %Q, %d, %Q, %d, %d, %d, %d, %1.2f, %1.2f)",
905 coverage, sample_name, pixel_name, num_bands,
906 compression_name, qlty, tile_size, tile_size, 32632,
907 0.2, 0.2);
908 ret = execute_check (sqlite, sql);
909 sqlite3_free (sql);
910 if (ret != SQLITE_OK)
911 {
912 fprintf (stderr, "CreateCoverage \"%s\" error: %s\n", coverage,
913 err_msg);
914 sqlite3_free (err_msg);
915 *retcode += -1;
916 return 0;
917 }
918
919 /* loading the first section */
920 sql =
921 sqlite3_mprintf
922 ("SELECT RL2_LoadRaster(%Q, %Q, 0, 32632, 0, 1)", coverage,
923 "map_samples/tuscany-infrared/infrared1.tif");
924 ret = execute_check (sqlite, sql);
925 sqlite3_free (sql);
926 if (ret != SQLITE_OK)
927 {
928 fprintf (stderr, "LoadRasters #1 \"%s\" error: %s\n", coverage,
929 err_msg);
930 sqlite3_free (err_msg);
931 *retcode += -2;
932 return 0;
933 }
934
935 /* loading the second section */
936 sql = sqlite3_mprintf ("SELECT RL2_LoadRaster(%Q, %Q, 1, 32632, 0, 1)",
937 coverage,
938 "map_samples/tuscany-infrared/infrared2.tif");
939 ret = execute_check (sqlite, sql);
940 sqlite3_free (sql);
941 if (ret != SQLITE_OK)
942 {
943 fprintf (stderr, "LoadRaster #2 \"%s\" error: %s\n", coverage,
944 err_msg);
945 sqlite3_free (err_msg);
946 *retcode += -3;
947 return 0;
948 }
949
950 /* re-building the Pyramid Levels */
951 sql =
952 sqlite3_mprintf ("SELECT RL2_Pyramidize(%Q, %Q, 1, 1)", coverage,
953 "infrared2");
954 ret = execute_check (sqlite, sql);
955 sqlite3_free (sql);
956 if (ret != SQLITE_OK)
957 {
958 fprintf (stderr, "Pyramidize \"%s\" error: %s\n", coverage, err_msg);
959 sqlite3_free (err_msg);
960 *retcode += -4;
961 return 0;
962 }
963
964 /* destroying the Pyramid Levels */
965 sql = sqlite3_mprintf ("SELECT RL2_DePyramidize(%Q, NULL, 1)", coverage);
966 ret = execute_check (sqlite, sql);
967 sqlite3_free (sql);
968 if (ret != SQLITE_OK)
969 {
970 fprintf (stderr, "DePyramidize \"%s\" error: %s\n", coverage,
971 err_msg);
972 sqlite3_free (err_msg);
973 *retcode += -5;
974 return 0;
975 }
976
977 /* building yet again the Pyramid Levels */
978 sql =
979 sqlite3_mprintf ("SELECT RL2_Pyramidize(%Q, %Q, 1, 1)", coverage,
980 "infrared2");
981 ret = execute_check (sqlite, sql);
982 sqlite3_free (sql);
983 if (ret != SQLITE_OK)
984 {
985 fprintf (stderr, "Pyramidize \"%s\" error: %s\n", coverage, err_msg);
986 sqlite3_free (err_msg);
987 *retcode += -6;
988 return 0;
989 }
990
991 /* export tests */
992 geom = get_center_point (sqlite, coverage);
993 if (geom == NULL)
994 {
995 *retcode += -7;
996 return 0;
997 }
998 if (!do_export_geotiff (sqlite, coverage, geom, 1))
999 {
1000 *retcode += -8;
1001 return 0;
1002 }
1003 if (!do_export_geotiff (sqlite, coverage, geom, 2))
1004 {
1005 *retcode += -9;
1006 return 0;
1007 }
1008 if (!do_export_geotiff (sqlite, coverage, geom, 4))
1009 {
1010 *retcode += -10;
1011 return 0;
1012 }
1013 if (!do_export_geotiff (sqlite, coverage, geom, 8))
1014 {
1015 *retcode += -11;
1016 return 0;
1017 }
1018
1019 /* testing TripleBand (Geo)TIFF export */
1020 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 1, 0, 0))
1021 {
1022 *retcode += -12;
1023 return 0;
1024 }
1025 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 1, 1, 0))
1026 {
1027 *retcode += -13;
1028 return 0;
1029 }
1030 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 1, 2, 1))
1031 {
1032 *retcode += -14;
1033 return 0;
1034 }
1035 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 4, 0, 0))
1036 {
1037 *retcode += -15;
1038 return 0;
1039 }
1040 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 4, 1, 1))
1041 {
1042 *retcode += -16;
1043 return 0;
1044 }
1045 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 4, 2, 0))
1046 {
1047 *retcode += -17;
1048 return 0;
1049 }
1050 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 8, 0, 1))
1051 {
1052 *retcode += -18;
1053 return 0;
1054 }
1055 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 8, 1, 0))
1056 {
1057 *retcode += -19;
1058 return 0;
1059 }
1060 if (!do_export_band_composed_geotiff (sqlite, coverage, geom, 8, 2, 0))
1061 {
1062 *retcode += -20;
1063 return 0;
1064 }
1065
1066 if (!do_export_band_composed_tiff (sqlite, coverage, geom, 1, 0))
1067 {
1068 *retcode += -21;
1069 return 0;
1070 }
1071 if (!do_export_band_composed_tiff (sqlite, coverage, geom, 1, 1))
1072 {
1073 *retcode += -22;
1074 return 0;
1075 }
1076 if (!do_export_band_composed_tiff (sqlite, coverage, geom, 1, 2))
1077 {
1078 *retcode += -23;
1079 return 0;
1080 }
1081
1082 if (!do_export_band_composed_tiff_tfw (sqlite, coverage, geom, 1, 0))
1083 {
1084 *retcode += -24;
1085 return 0;
1086 }
1087 if (!do_export_band_composed_tiff_tfw (sqlite, coverage, geom, 1, 1))
1088 {
1089 *retcode += -25;
1090 return 0;
1091 }
1092 if (!do_export_band_composed_tiff_tfw (sqlite, coverage, geom, 1, 2))
1093 {
1094 *retcode += -26;
1095 return 0;
1096 }
1097
1098 /* testing MonoBand (Geo)TIFF export */
1099 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 1, 0, 0))
1100 {
1101 *retcode += -27;
1102 return 0;
1103 }
1104 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 1, 1, 0))
1105 {
1106 *retcode += -28;
1107 return 0;
1108 }
1109 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 1, 2, 1))
1110 {
1111 *retcode += -29;
1112 return 0;
1113 }
1114 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 4, 0, 0))
1115 {
1116 *retcode += -30;
1117 return 0;
1118 }
1119 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 4, 1, 1))
1120 {
1121 *retcode += -31;
1122 return 0;
1123 }
1124 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 4, 2, 0))
1125 {
1126 *retcode += -32;
1127 return 0;
1128 }
1129 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 8, 0, 1))
1130 {
1131 *retcode += -33;
1132 return 0;
1133 }
1134 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 8, 1, 0))
1135 {
1136 *retcode += -34;
1137 return 0;
1138 }
1139 if (!do_export_mono_band_geotiff (sqlite, coverage, geom, 8, 2, 0))
1140 {
1141 *retcode += -35;
1142 return 0;
1143 }
1144
1145 if (!do_export_mono_band_tiff (sqlite, coverage, geom, 1, 0))
1146 {
1147 *retcode += -36;
1148 return 0;
1149 }
1150 if (!do_export_mono_band_tiff (sqlite, coverage, geom, 1, 1))
1151 {
1152 *retcode += -37;
1153 return 0;
1154 }
1155 if (!do_export_mono_band_tiff (sqlite, coverage, geom, 1, 2))
1156 {
1157 *retcode += -38;
1158 return 0;
1159 }
1160
1161 if (!do_export_mono_band_tiff_tfw (sqlite, coverage, geom, 1, 0))
1162 {
1163 *retcode += -39;
1164 return 0;
1165 }
1166 if (!do_export_mono_band_tiff_tfw (sqlite, coverage, geom, 1, 1))
1167 {
1168 *retcode += -40;
1169 return 0;
1170 }
1171 if (!do_export_mono_band_tiff_tfw (sqlite, coverage, geom, 1, 2))
1172 {
1173 *retcode += -41;
1174 return 0;
1175 }
1176 if (!test_map_image)
1177 goto skip;
1178
1179 /* loading the RasterSymbolizers */
1180 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
1181 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
1182 "ir_false_color1.xml");
1183 ret = execute_check (sqlite, sql);
1184 sqlite3_free (sql);
1185 if (ret != SQLITE_OK)
1186 {
1187 fprintf (stderr, "RegisterRasterStyledLayer #1 \"%s\" error: %s\n",
1188 coverage, err_msg);
1189 sqlite3_free (err_msg);
1190 *retcode += -42;
1191 return 0;
1192 }
1193 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
1194 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
1195 "ir_false_color1_gamma.xml");
1196 ret = execute_check (sqlite, sql);
1197 sqlite3_free (sql);
1198 if (ret != SQLITE_OK)
1199 {
1200 fprintf (stderr, "RegisterRasterStyledLayer #1 \"%s\" error: %s\n",
1201 coverage, err_msg);
1202 sqlite3_free (err_msg);
1203 *retcode += -43;
1204 return 0;
1205 }
1206 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
1207 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
1208 "ir_gray.xml");
1209 ret = execute_check (sqlite, sql);
1210 sqlite3_free (sql);
1211 if (ret != SQLITE_OK)
1212 {
1213 fprintf (stderr, "RegisterRasterStyledLayer #2 \"%s\" error: %s\n",
1214 coverage, err_msg);
1215 sqlite3_free (err_msg);
1216 *retcode += -44;
1217 return 0;
1218 }
1219 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
1220 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
1221 "ir_gray_gamma.xml");
1222 ret = execute_check (sqlite, sql);
1223 sqlite3_free (sql);
1224 if (ret != SQLITE_OK)
1225 {
1226 fprintf (stderr, "RegisterRasterStyledLayer #3 \"%s\" error: %s\n",
1227 coverage, err_msg);
1228 sqlite3_free (err_msg);
1229 *retcode += -45;
1230 return 0;
1231 }
1232
1233 /* testing GetMapImage - IR false color */
1234 if (!do_export_map_image
1235 (sqlite, coverage, geom, "ir_false_color1", "png", 0))
1236 {
1237 *retcode += 46;
1238 return 0;
1239 }
1240 if (!do_export_map_image
1241 (sqlite, coverage, geom, "ir_false_color1", "jpg", 0))
1242 {
1243 *retcode += 47;
1244 return 0;
1245 }
1246 if (!do_export_map_image
1247 (sqlite, coverage, geom, "ir_false_color1", "tif", 0))
1248 {
1249 *retcode += 48;
1250 return 0;
1251 }
1252 if (!do_export_map_image
1253 (sqlite, coverage, geom, "ir_false_color1", "pdf", 0))
1254 {
1255 *retcode += 49;
1256 return 0;
1257 }
1258
1259 /* testing GetMapImage - IR false color - GammaValue */
1260 if (!do_export_map_image
1261 (sqlite, coverage, geom, "ir_false_color1_gamma", "png", 0))
1262 {
1263 *retcode += 50;
1264 return 0;
1265 }
1266 if (!do_export_map_image
1267 (sqlite, coverage, geom, "ir_false_color1_gamma", "jpg", 0))
1268 {
1269 *retcode += 51;
1270 return 0;
1271 }
1272 if (!do_export_map_image
1273 (sqlite, coverage, geom, "ir_false_color1_gamma", "tif", 0))
1274 {
1275 *retcode += 52;
1276 return 0;
1277 }
1278 if (!do_export_map_image
1279 (sqlite, coverage, geom, "ir_false_color1_gamma", "pdf", 0))
1280 {
1281 *retcode += 53;
1282 return 0;
1283 }
1284
1285 /* testing GetMapImage - IR gray */
1286 if (!do_export_map_image (sqlite, coverage, geom, "ir_gray", "png", 0))
1287 {
1288 *retcode += 54;
1289 return 0;
1290 }
1291 if (!do_export_map_image (sqlite, coverage, geom, "ir_gray", "jpg", 0))
1292 {
1293 *retcode += 55;
1294 return 0;
1295 }
1296 if (!do_export_map_image (sqlite, coverage, geom, "ir_gray", "tif", 0))
1297 {
1298 *retcode += 56;
1299 return 0;
1300 }
1301 if (!do_export_map_image (sqlite, coverage, geom, "ir_gray", "pdf", 0))
1302 {
1303 *retcode += 57;
1304 return 0;
1305 }
1306
1307 /* testing GetMapImage - IR gray - GammaValue */
1308 if (!do_export_map_image
1309 (sqlite, coverage, geom, "ir_gray_gamma", "png", 0))
1310 {
1311 *retcode += 58;
1312 return 0;
1313 }
1314 if (!do_export_map_image
1315 (sqlite, coverage, geom, "ir_gray_gamma", "jpg", 0))
1316 {
1317 *retcode += 59;
1318 return 0;
1319 }
1320 if (!do_export_map_image
1321 (sqlite, coverage, geom, "ir_gray_gamma", "tif", 0))
1322 {
1323 *retcode += 60;
1324 return 0;
1325 }
1326 if (!do_export_map_image
1327 (sqlite, coverage, geom, "ir_gray_gamma", "pdf", 0))
1328 {
1329 *retcode += 61;
1330 return 0;
1331 }
1332 skip:
1333 gaiaFreeGeomColl (geom);
1334
1335 /* testing GetTileImage() */
1336 if (!do_export_tile_image (sqlite, coverage, 1, 0))
1337 {
1338 *retcode += -62;
1339 return 0;
1340 }
1341 if (!do_export_tile_image (sqlite, coverage, 1, 1))
1342 {
1343 *retcode += -63;
1344 return 0;
1345 }
1346 if (!do_export_tile_image (sqlite, coverage, 1, 2))
1347 {
1348 *retcode += -64;
1349 return 0;
1350 }
1351 if (!do_export_tile_image (sqlite, coverage, -1, 0))
1352 {
1353 *retcode += -65;
1354 return 0;
1355 }
1356
1357 /* testing GetTileImage() - Mono-Band */
1358 if (!do_export_mono_tile_image (sqlite, coverage, 1, 0))
1359 {
1360 *retcode += -66;
1361 return 0;
1362 }
1363 if (!do_export_mono_tile_image (sqlite, coverage, 1, 1))
1364 {
1365 *retcode += -67;
1366 return 0;
1367 }
1368 if (!do_export_mono_tile_image (sqlite, coverage, 1, 2))
1369 {
1370 *retcode += -68;
1371 return 0;
1372 }
1373 if (!do_export_mono_tile_image (sqlite, coverage, -1, 0))
1374 {
1375 *retcode += -69;
1376 return 0;
1377 }
1378
1379 if (compression == RL2_COMPRESSION_NONE && tile_sz == TILE_1024)
1380 {
1381 /* testing a Monolithic Pyramid */
1382 geom = get_center_point (sqlite, coverage);
1383 if (geom == NULL)
1384 {
1385 *retcode += -70;
1386 return 0;
1387 }
1388 sql =
1389 sqlite3_mprintf ("SELECT RL2_PyramidizeMonolithic(%Q, 1, 1)",
1390 coverage);
1391 ret = execute_check (sqlite, sql);
1392 sqlite3_free (sql);
1393 if (ret != SQLITE_OK)
1394 {
1395 fprintf (stderr, "PyramidizeMonolithic \"%s\" error: %s\n",
1396 coverage, err_msg);
1397 sqlite3_free (err_msg);
1398 *retcode += -71;
1399 return 0;
1400 }
1401 if (!do_export_map_image
1402 (sqlite, coverage, geom, "ir_false_color1", "jpg", 1))
1403 {
1404 *retcode += 71;
1405 return 0;
1406 }
1407 if (!do_export_map_image
1408 (sqlite, coverage, geom, "ir_false_color1_gamma", "jpg", 1))
1409 {
1410 *retcode += 72;
1411 return 0;
1412 }
1413 if (!do_export_map_image
1414 (sqlite, coverage, geom, "ir_gray", "jpg", 1))
1415 {
1416 *retcode += 73;
1417 return 0;
1418 }
1419 if (!do_export_map_image
1420 (sqlite, coverage, geom, "ir_gray_gamma", "jpg", 1))
1421 {
1422 *retcode += 74;
1423 return 0;
1424 }
1425 gaiaFreeGeomColl (geom);
1426 }
1427
1428 return 1;
1429 }
1430
1431 static int
drop_coverage(sqlite3 * sqlite,unsigned char compression,int tile_sz,int * retcode)1432 drop_coverage (sqlite3 * sqlite, unsigned char compression, int tile_sz,
1433 int *retcode)
1434 {
1435 /* dropping some DBMS Coverage */
1436 int ret;
1437 char *err_msg = NULL;
1438 const char *coverage;
1439 char *sql;
1440
1441 /* setting the coverage name */
1442 switch (compression)
1443 {
1444 case RL2_COMPRESSION_NONE:
1445 switch (tile_sz)
1446 {
1447 case TILE_256:
1448 coverage = "infrared_none_256";
1449 break;
1450 case TILE_512:
1451 coverage = "infrared_none_512";
1452 break;
1453 case TILE_1024:
1454 coverage = "infrared_none_1024";
1455 break;
1456 };
1457 break;
1458 case RL2_COMPRESSION_DEFLATE:
1459 switch (tile_sz)
1460 {
1461 case TILE_256:
1462 coverage = "infrared_zip_256";
1463 break;
1464 case TILE_512:
1465 coverage = "infrared_zip_512";
1466 break;
1467 case TILE_1024:
1468 coverage = "infrared_zip_1024";
1469 break;
1470 };
1471 break;
1472 case RL2_COMPRESSION_LZMA:
1473 switch (tile_sz)
1474 {
1475 case TILE_256:
1476 coverage = "infrared_lzma_256";
1477 break;
1478 case TILE_512:
1479 coverage = "infrared_lzma_512";
1480 break;
1481 case TILE_1024:
1482 coverage = "infrared_lzma_1024";
1483 break;
1484 };
1485 break;
1486 };
1487
1488 /* dropping the DBMS Coverage */
1489 sql = sqlite3_mprintf ("SELECT RL2_DropCoverage(%Q, 1)", coverage);
1490 ret = execute_check (sqlite, sql);
1491 sqlite3_free (sql);
1492 if (ret != SQLITE_OK)
1493 {
1494 fprintf (stderr, "DropCoverage \"%s\" error: %s\n", coverage,
1495 err_msg);
1496 sqlite3_free (err_msg);
1497 *retcode += -1;
1498 return 0;
1499 }
1500
1501 return 1;
1502 }
1503
1504 int
main(int argc,char * argv[])1505 main (int argc, char *argv[])
1506 {
1507 int result = 0;
1508 int ret;
1509 char *err_msg = NULL;
1510 sqlite3 *db_handle;
1511 void *cache = spatialite_alloc_connection ();
1512 char *old_SPATIALITE_SECURITY_ENV = NULL;
1513
1514 if (argc > 1 || argv[0] == NULL)
1515 argc = 1; /* silencing stupid compiler warnings */
1516
1517 old_SPATIALITE_SECURITY_ENV = getenv ("SPATIALITE_SECURITY");
1518 #ifdef _WIN32
1519 putenv ("SPATIALITE_SECURITY=relaxed");
1520 #else /* not WIN32 */
1521 setenv ("SPATIALITE_SECURITY", "relaxed", 1);
1522 #endif
1523
1524 /* opening and initializing the "memory" test DB */
1525 ret = sqlite3_open_v2 (":memory:", &db_handle,
1526 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
1527 if (ret != SQLITE_OK)
1528 {
1529 fprintf (stderr, "sqlite3_open_v2() error: %s\n",
1530 sqlite3_errmsg (db_handle));
1531 return -1;
1532 }
1533 spatialite_init_ex (db_handle, cache, 0);
1534 rl2_init (db_handle, 0);
1535 ret =
1536 sqlite3_exec (db_handle, "SELECT InitSpatialMetadata(1)", NULL, NULL,
1537 &err_msg);
1538 if (ret != SQLITE_OK)
1539 {
1540 fprintf (stderr, "InitSpatialMetadata() error: %s\n", err_msg);
1541 sqlite3_free (err_msg);
1542 return -2;
1543 }
1544 ret =
1545 sqlite3_exec (db_handle, "SELECT CreateRasterCoveragesTable()", NULL,
1546 NULL, &err_msg);
1547 if (ret != SQLITE_OK)
1548 {
1549 fprintf (stderr, "CreateRasterCoveragesTable() error: %s\n", err_msg);
1550 sqlite3_free (err_msg);
1551 return -3;
1552 }
1553 ret =
1554 sqlite3_exec (db_handle, "SELECT CreateStylingTables()", NULL,
1555 NULL, &err_msg);
1556 if (ret != SQLITE_OK)
1557 {
1558 fprintf (stderr, "CreateStylingTables() error: %s\n", err_msg);
1559 sqlite3_free (err_msg);
1560 return 4;
1561 }
1562
1563 /* tests */
1564 ret = -100;
1565 if (!test_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_256, &ret))
1566 return ret;
1567 ret = -120;
1568 if (!test_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_512, &ret))
1569 return ret;
1570 ret = -140;
1571 if (!test_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1572 return ret;
1573 ret = -200;
1574 if (!test_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1575 return ret;
1576 ret = -220;
1577 if (!test_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_512, &ret))
1578 return ret;
1579 ret = -240;
1580 if (!test_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1581 return ret;
1582 ret = -300;
1583 if (!test_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1584 return ret;
1585 ret = -320;
1586 if (!test_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_512, &ret))
1587 return ret;
1588 ret = -340;
1589 if (!test_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1590 return ret;
1591
1592 /* dropping all Coverages */
1593 ret = -170;
1594 if (!drop_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_256, &ret))
1595 return ret;
1596 ret = -180;
1597 if (!drop_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_512, &ret))
1598 return ret;
1599 ret = -190;
1600 if (!drop_coverage (db_handle, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1601 return ret;
1602 ret = -270;
1603 if (!drop_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1604 return ret;
1605 ret = -280;
1606 if (!drop_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_512, &ret))
1607 return ret;
1608 ret = -290;
1609 if (!drop_coverage (db_handle, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1610 return ret;
1611 ret = -370;
1612 if (!drop_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1613 return ret;
1614 ret = -380;
1615 if (!drop_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_512, &ret))
1616 return ret;
1617 ret = -390;
1618 if (!drop_coverage (db_handle, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1619 return ret;
1620
1621 /* closing the DB */
1622 sqlite3_close (db_handle);
1623 spatialite_shutdown ();
1624 if (old_SPATIALITE_SECURITY_ENV)
1625 {
1626 #ifdef _WIN32
1627 char *env = sqlite3_mprintf ("SPATIALITE_SECURITY=%s",
1628 old_SPATIALITE_SECURITY_ENV);
1629 putenv (env);
1630 sqlite3_free (env);
1631 #else /* not WIN32 */
1632 setenv ("SPATIALITE_SECURITY", old_SPATIALITE_SECURITY_ENV, 1);
1633 #endif
1634 }
1635 else
1636 {
1637 #ifdef _WIN32
1638 putenv ("SPATIALITE_SECURITY=");
1639 #else /* not WIN32 */
1640 unsetenv ("SPATIALITE_SECURITY");
1641 #endif
1642 }
1643 return result;
1644 }
1645