1 /*
2
3 test_map_srtm.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_1024 1024
57
58 static int
execute_check(sqlite3 * sqlite,const char * sql)59 execute_check (sqlite3 * sqlite, const char *sql)
60 {
61 /* executing an SQL statement returning True/False */
62 sqlite3_stmt *stmt;
63 int ret;
64 int retcode = 0;
65
66 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
67 if (ret != SQLITE_OK)
68 return SQLITE_ERROR;
69 ret = sqlite3_step (stmt);
70 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
71 {
72 if (sqlite3_column_int (stmt, 0) == 1)
73 retcode = 1;
74 }
75 sqlite3_finalize (stmt);
76 if (retcode == 1)
77 return SQLITE_OK;
78 return SQLITE_ERROR;
79 }
80
81 static int
get_max_tile_id(sqlite3 * sqlite,const char * coverage)82 get_max_tile_id (sqlite3 * sqlite, const char *coverage)
83 {
84 /* retriving the Max tile_id for a given Coverage */
85 char *sql;
86 char *table;
87 char *xtable;
88 sqlite3_stmt *stmt;
89 int ret;
90 int max = 0;
91
92 table = sqlite3_mprintf ("%s_tile_data", coverage);
93 xtable = gaiaDoubleQuotedSql (table);
94 sqlite3_free (table);
95 sql = sqlite3_mprintf ("SELECT Max(tile_id) FROM \"%s\"", xtable);
96 free (xtable);
97 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
98 sqlite3_free (sql);
99 if (ret != SQLITE_OK)
100 return 0;
101 while (1)
102 {
103 /* scrolling the result set rows */
104 ret = sqlite3_step (stmt);
105 if (ret == SQLITE_DONE)
106 break; /* end of result set */
107 if (ret == SQLITE_ROW)
108 max = sqlite3_column_int (stmt, 0);
109 }
110 sqlite3_finalize (stmt);
111 return max;
112 }
113
114 static int
do_export_tile_image(sqlite3 * sqlite,const char * coverage,int tile_id,int transparent)115 do_export_tile_image (sqlite3 * sqlite, const char *coverage, int tile_id,
116 int transparent)
117 {
118 /* attempting to export a visible Tile */
119 char *sql;
120 char *path;
121 int ret;
122
123 if (tile_id < 0)
124 tile_id = get_max_tile_id (sqlite, coverage);
125 path =
126 sqlite3_mprintf ("./%s_mono_tile_%d_%d.png", coverage, tile_id,
127 transparent);
128 sql =
129 sqlite3_mprintf
130 ("SELECT BlobToFile(RL2_GetTileImage(%Q, %d, '#e0ffe0', %d), %Q)",
131 coverage, tile_id, transparent, path);
132 ret = execute_check (sqlite, sql);
133 sqlite3_free (sql);
134 unlink (path);
135 sqlite3_free (path);
136 if (ret != SQLITE_OK)
137 {
138 fprintf (stderr,
139 "ERROR: Unable to export an Image from \"%s\" tile_id=%d\n",
140 coverage, tile_id);
141 return 0;
142 }
143 return 1;
144 }
145
146 static int
get_base_resolution(sqlite3 * sqlite,const char * coverage,double * x_res,double * y_res)147 get_base_resolution (sqlite3 * sqlite, const char *coverage, double *x_res,
148 double *y_res)
149 {
150 /* attempting to retrieve the Coverage's base resolution */
151 char *sql;
152 sqlite3_stmt *stmt;
153 int ret;
154 int ok = 0;
155
156 sql = sqlite3_mprintf ("SELECT horz_resolution, vert_resolution "
157 "FROM raster_coverages WHERE coverage_name = %Q",
158 coverage);
159 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
160 sqlite3_free (sql);
161 if (ret != SQLITE_OK)
162 return 0;
163
164 while (1)
165 {
166 /* scrolling the result set rows */
167 ret = sqlite3_step (stmt);
168 if (ret == SQLITE_DONE)
169 break; /* end of result set */
170 if (ret == SQLITE_ROW)
171 {
172 *x_res = sqlite3_column_double (stmt, 0);
173 *y_res = sqlite3_column_double (stmt, 1);
174 ok = 1;
175 }
176 }
177 sqlite3_finalize (stmt);
178 return ok;
179 }
180
181 static int
do_export_geotiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale)182 do_export_geotiff (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom,
183 int scale)
184 {
185 /* exporting a GeoTiff + Worldfile */
186 char *sql;
187 char *path;
188 sqlite3_stmt *stmt;
189 int ret;
190 double x_res;
191 double y_res;
192 double xx_res;
193 double yy_res;
194 unsigned char *blob;
195 int blob_size;
196 int retcode = 0;
197
198 path = sqlite3_mprintf ("./%s_gt_%d.tif", coverage, scale);
199
200 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
201 return 0;
202 xx_res = x_res * (double) scale;
203 yy_res = y_res * (double) scale;
204
205 sql = "SELECT RL2_WriteGeoTiff(?, ?, ?, ?, ?, ?, ?, ?, ?)";
206 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
207 if (ret != SQLITE_OK)
208 return 0;
209 sqlite3_reset (stmt);
210 sqlite3_clear_bindings (stmt);
211 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
212 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
213 sqlite3_bind_int (stmt, 3, 1024);
214 sqlite3_bind_int (stmt, 4, 1024);
215 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
216 sqlite3_bind_blob (stmt, 5, blob, blob_size, free);
217 sqlite3_bind_double (stmt, 6, xx_res);
218 sqlite3_bind_double (stmt, 7, yy_res);
219 sqlite3_bind_int (stmt, 8, 1);
220 sqlite3_bind_text (stmt, 9, "NONE", 4, SQLITE_TRANSIENT);
221 ret = sqlite3_step (stmt);
222 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
223 {
224 if (sqlite3_column_int (stmt, 0) == 1)
225 retcode = 1;
226 }
227 sqlite3_finalize (stmt);
228 unlink (path);
229 if (!retcode)
230 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
231 sqlite3_free (path);
232 path = sqlite3_mprintf ("./%s_gt_%d.tfw", coverage, scale);
233 unlink (path);
234 sqlite3_free (path);
235 return retcode;
236 }
237
238 static int
do_export_tiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale)239 do_export_tiff (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom,
240 int scale)
241 {
242 /* exporting a Tiff (no Worldfile) */
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_plain_%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_WriteTiff(?, ?, ?, ?, ?, ?, ?, ?)";
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_text (stmt, 8, "DEFLATE", 7, SQLITE_TRANSIENT);
277 ret = sqlite3_step (stmt);
278 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
279 {
280 if (sqlite3_column_int (stmt, 0) == 1)
281 retcode = 1;
282 }
283 sqlite3_finalize (stmt);
284 unlink (path);
285 if (!retcode)
286 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
287 sqlite3_free (path);
288 return retcode;
289 }
290
291 static int
do_export_map_image(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,const char * style,const char * suffix)292 do_export_map_image (sqlite3 * sqlite, const char *coverage,
293 gaiaGeomCollPtr geom, const char *style,
294 const char *suffix)
295 {
296 /* exporting a Map Image (full rendered) */
297 char *sql;
298 char *path;
299 sqlite3_stmt *stmt;
300 int ret;
301 unsigned char *blob;
302 int blob_size;
303 int retcode = 0;
304 const char *format = "text/plain";
305
306 if (strcmp (suffix, "png") == 0)
307 format = "image/png";
308 if (strcmp (suffix, "jpg") == 0)
309 format = "image/jpeg";
310 if (strcmp (suffix, "tif") == 0)
311 format = "image/tiff";
312 if (strcmp (suffix, "pdf") == 0)
313 format = "application/x-pdf";
314
315 path = sqlite3_mprintf ("./%s_map_%s.%s", coverage, style, suffix);
316
317 sql =
318 "SELECT BlobToFile(RL2_GetMapImage(?, ST_Buffer(?, 0.65), ?, ?, ?, ?, ?, ?), ?)";
319 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
320 if (ret != SQLITE_OK)
321 return 0;
322 sqlite3_reset (stmt);
323 sqlite3_clear_bindings (stmt);
324 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
325 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
326 sqlite3_bind_blob (stmt, 2, blob, blob_size, free);
327 sqlite3_bind_int (stmt, 3, 1024);
328 sqlite3_bind_int (stmt, 4, 1024);
329 sqlite3_bind_text (stmt, 5, style, strlen (style), SQLITE_STATIC);
330 sqlite3_bind_text (stmt, 6, format, strlen (format), SQLITE_STATIC);
331 sqlite3_bind_text (stmt, 7, "#ffe0e0", 7, SQLITE_STATIC);
332 sqlite3_bind_int (stmt, 8, 1);
333 sqlite3_bind_text (stmt, 9, path, strlen (path), SQLITE_STATIC);
334 ret = sqlite3_step (stmt);
335 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
336 {
337 if (sqlite3_column_int (stmt, 0) == 1)
338 retcode = 1;
339 }
340 sqlite3_finalize (stmt);
341 unlink (path);
342 if (!retcode)
343 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
344 sqlite3_free (path);
345 return retcode;
346 }
347
348 static gaiaGeomCollPtr
get_center_point(sqlite3 * sqlite,const char * coverage)349 get_center_point (sqlite3 * sqlite, const char *coverage)
350 {
351 /* attempting to retrieve the Coverage's Center Point */
352 char *sql;
353 sqlite3_stmt *stmt;
354 gaiaGeomCollPtr geom = NULL;
355 int ret;
356
357 sql = sqlite3_mprintf ("SELECT MakePoint("
358 "extent_minx + ((extent_maxx - extent_minx) / 2.0), "
359 "extent_miny + ((extent_maxy - extent_miny) / 2.0)) "
360 "FROM raster_coverages WHERE coverage_name = %Q",
361 coverage);
362 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
363 sqlite3_free (sql);
364 if (ret != SQLITE_OK)
365 return NULL;
366
367 while (1)
368 {
369 /* scrolling the result set rows */
370 ret = sqlite3_step (stmt);
371 if (ret == SQLITE_DONE)
372 break; /* end of result set */
373 if (ret == SQLITE_ROW)
374 {
375 const unsigned char *blob = sqlite3_column_blob (stmt, 0);
376 int blob_sz = sqlite3_column_bytes (stmt, 0);
377 geom = gaiaFromSpatiaLiteBlobWkb (blob, blob_sz);
378 }
379 }
380 sqlite3_finalize (stmt);
381 return geom;
382 }
383
384 static int
test_coverage(sqlite3 * sqlite,unsigned char sample,unsigned char compression,int tile_sz,int * retcode)385 test_coverage (sqlite3 * sqlite, unsigned char sample,
386 unsigned char compression, int tile_sz, int *retcode)
387 {
388 /* testing some DBMS Coverage */
389 int ret;
390 char *err_msg = NULL;
391 const char *coverage;
392 const char *sample_name;
393 const char *pixel_name;
394 unsigned char num_bands;
395 const char *compression_name;
396 int qlty;
397 char *sql;
398 int tile_size;
399 gaiaGeomCollPtr geom;
400 int test_map_image = 0;
401
402 /* setting the coverage name */
403 switch (sample)
404 {
405 case RL2_SAMPLE_INT8:
406 switch (compression)
407 {
408 case RL2_COMPRESSION_NONE:
409 switch (tile_sz)
410 {
411 case TILE_256:
412 coverage = "grid_8_none_256";
413 break;
414 case TILE_1024:
415 coverage = "grid_8_none_1024";
416 test_map_image = 1;
417 break;
418 };
419 break;
420 case RL2_COMPRESSION_DEFLATE:
421 switch (tile_sz)
422 {
423 case TILE_256:
424 coverage = "grid_8_deflate_256";
425 break;
426 case TILE_1024:
427 coverage = "grid_8_deflate_1024";
428 break;
429 };
430 break;
431 case RL2_COMPRESSION_LZMA:
432 switch (tile_sz)
433 {
434 case TILE_256:
435 coverage = "grid_8_lzma_256";
436 break;
437 case TILE_1024:
438 coverage = "grid_8_lzma_1024";
439 break;
440 };
441 break;
442 };
443 break;
444 case RL2_SAMPLE_UINT8:
445 switch (compression)
446 {
447 case RL2_COMPRESSION_NONE:
448 switch (tile_sz)
449 {
450 case TILE_256:
451 coverage = "grid_u8_none_256";
452 test_map_image = 1;
453 break;
454 case TILE_1024:
455 coverage = "grid_u8_none_1024";
456 break;
457 };
458 break;
459 case RL2_COMPRESSION_DEFLATE:
460 switch (tile_sz)
461 {
462 case TILE_256:
463 coverage = "grid_u8_deflate_256";
464 break;
465 case TILE_1024:
466 coverage = "grid_u8_deflate_1024";
467 break;
468 };
469 break;
470 case RL2_COMPRESSION_LZMA:
471 switch (tile_sz)
472 {
473 case TILE_256:
474 coverage = "grid_u8_lzma_256";
475 break;
476 case TILE_1024:
477 coverage = "grid_u8_lzma_1024";
478 break;
479 };
480 break;
481 };
482 break;
483 case RL2_SAMPLE_INT16:
484 switch (compression)
485 {
486 case RL2_COMPRESSION_NONE:
487 switch (tile_sz)
488 {
489 case TILE_256:
490 coverage = "grid_16_none_256";
491 break;
492 case TILE_1024:
493 coverage = "grid_16_none_1024";
494 test_map_image = 1;
495 break;
496 };
497 break;
498 case RL2_COMPRESSION_DEFLATE:
499 switch (tile_sz)
500 {
501 case TILE_256:
502 coverage = "grid_16_deflate_256";
503 break;
504 case TILE_1024:
505 coverage = "grid_16_deflate_1024";
506 break;
507 };
508 break;
509 case RL2_COMPRESSION_LZMA:
510 switch (tile_sz)
511 {
512 case TILE_256:
513 coverage = "grid_16_lzma_256";
514 break;
515 case TILE_1024:
516 coverage = "grid_16_lzma_1024";
517 break;
518 };
519 break;
520 };
521 break;
522 case RL2_SAMPLE_UINT16:
523 switch (compression)
524 {
525 case RL2_COMPRESSION_NONE:
526 switch (tile_sz)
527 {
528 case TILE_256:
529 coverage = "grid_u16_none_256";
530 test_map_image = 1;
531 break;
532 case TILE_1024:
533 coverage = "grid_u16_none_1024";
534 break;
535 };
536 break;
537 case RL2_COMPRESSION_DEFLATE:
538 switch (tile_sz)
539 {
540 case TILE_256:
541 coverage = "grid_u16_deflate_256";
542 break;
543 case TILE_1024:
544 coverage = "grid_u16_deflate_1024";
545 break;
546 };
547 break;
548 case RL2_COMPRESSION_LZMA:
549 switch (tile_sz)
550 {
551 case TILE_256:
552 coverage = "grid_u16_lzma_256";
553 break;
554 case TILE_1024:
555 coverage = "grid_u16_lzma_1024";
556 break;
557 };
558 break;
559 };
560 break;
561 case RL2_SAMPLE_INT32:
562 switch (compression)
563 {
564 case RL2_COMPRESSION_NONE:
565 switch (tile_sz)
566 {
567 case TILE_256:
568 coverage = "grid_32_none_256";
569 break;
570 case TILE_1024:
571 coverage = "grid_32_none_1024";
572 test_map_image = 1;
573 break;
574 };
575 break;
576 case RL2_COMPRESSION_DEFLATE:
577 switch (tile_sz)
578 {
579 case TILE_256:
580 coverage = "grid_32_deflate_256";
581 break;
582 case TILE_1024:
583 coverage = "grid_32_deflate_1024";
584 break;
585 };
586 break;
587 case RL2_COMPRESSION_LZMA:
588 switch (tile_sz)
589 {
590 case TILE_256:
591 coverage = "grid_32_lzma_256";
592 break;
593 case TILE_1024:
594 coverage = "grid_32_lzma_1024";
595 break;
596 };
597 break;
598 };
599 break;
600 case RL2_SAMPLE_UINT32:
601 switch (compression)
602 {
603 case RL2_COMPRESSION_NONE:
604 switch (tile_sz)
605 {
606 case TILE_256:
607 coverage = "grid_u32_none_256";
608 break;
609 case TILE_1024:
610 coverage = "grid_u32_none_1024";
611 test_map_image = 1;
612 break;
613 };
614 break;
615 case RL2_COMPRESSION_DEFLATE:
616 switch (tile_sz)
617 {
618 case TILE_256:
619 coverage = "grid_u32_deflate_256";
620 break;
621 case TILE_1024:
622 coverage = "grid_u32_deflate_1024";
623 break;
624 };
625 break;
626 case RL2_COMPRESSION_LZMA:
627 switch (tile_sz)
628 {
629 case TILE_256:
630 coverage = "grid_u32_lzma_256";
631 break;
632 case TILE_1024:
633 coverage = "grid_u32_lzma_1024";
634 break;
635 };
636 break;
637 };
638 break;
639 case RL2_SAMPLE_FLOAT:
640 switch (compression)
641 {
642 case RL2_COMPRESSION_NONE:
643 switch (tile_sz)
644 {
645 case TILE_256:
646 coverage = "grid_flt_none_256";
647 break;
648 case TILE_1024:
649 coverage = "grid_flt_none_1024";
650 test_map_image = 1;
651 break;
652 };
653 break;
654 case RL2_COMPRESSION_DEFLATE:
655 switch (tile_sz)
656 {
657 case TILE_256:
658 coverage = "grid_flt_deflate_256";
659 break;
660 case TILE_1024:
661 coverage = "grid_flt_deflate_1024";
662 break;
663 };
664 break;
665 case RL2_COMPRESSION_LZMA:
666 switch (tile_sz)
667 {
668 case TILE_256:
669 coverage = "grid_flt_lzma_256";
670 break;
671 case TILE_1024:
672 coverage = "grid_flt_lzma_1024";
673 break;
674 };
675 break;
676 };
677 break;
678 case RL2_SAMPLE_DOUBLE:
679 switch (compression)
680 {
681 case RL2_COMPRESSION_NONE:
682 switch (tile_sz)
683 {
684 case TILE_256:
685 coverage = "grid_dbl_none_256";
686 test_map_image = 1;
687 break;
688 case TILE_1024:
689 coverage = "grid_dbl_none_1024";
690 break;
691 };
692 break;
693 case RL2_COMPRESSION_DEFLATE:
694 switch (tile_sz)
695 {
696 case TILE_256:
697 coverage = "grid_dbl_deflate_256";
698 break;
699 case TILE_1024:
700 coverage = "grid_dbl_deflate_1024";
701 break;
702 };
703 break;
704 case RL2_COMPRESSION_LZMA:
705 switch (tile_sz)
706 {
707 case TILE_256:
708 coverage = "grid_dbl_lzma_256";
709 break;
710 case TILE_1024:
711 coverage = "grid_dbl_lzma_1024";
712 break;
713 };
714 break;
715 };
716 break;
717 };
718
719 /* preparing misc Coverage's parameters */
720 pixel_name = "DATAGRID";
721 switch (sample)
722 {
723 case RL2_SAMPLE_INT8:
724 sample_name = "INT8";
725 break;
726 case RL2_SAMPLE_UINT8:
727 sample_name = "UINT8";
728 break;
729 case RL2_SAMPLE_INT16:
730 sample_name = "INT16";
731 break;
732 case RL2_SAMPLE_UINT16:
733 sample_name = "UINT16";
734 break;
735 case RL2_SAMPLE_INT32:
736 sample_name = "INT32";
737 break;
738 case RL2_SAMPLE_UINT32:
739 sample_name = "UINT32";
740 break;
741 case RL2_SAMPLE_FLOAT:
742 sample_name = "FLOAT";
743 break;
744 case RL2_SAMPLE_DOUBLE:
745 sample_name = "DOUBLE";
746 break;
747 };
748 num_bands = 1;
749 switch (compression)
750 {
751 case RL2_COMPRESSION_NONE:
752 compression_name = "NONE";
753 qlty = 100;
754 break;
755 case RL2_COMPRESSION_DEFLATE:
756 compression_name = "DEFLATE";
757 qlty = 100;
758 break;
759 case RL2_COMPRESSION_LZMA:
760 compression_name = "LZMA";
761 qlty = 100;
762 break;
763 };
764 switch (tile_sz)
765 {
766 case TILE_256:
767 tile_size = 256;
768 break;
769 case TILE_1024:
770 tile_size = 1024;
771 break;
772 };
773
774 /* creating the DBMS Coverage */
775 sql = sqlite3_mprintf ("SELECT RL2_CreateCoverage("
776 "%Q, %Q, %Q, %d, %Q, %d, %d, %d, %d, %1.8f, %1.8f, "
777 "RL2_SetPixelValue(RL2_CreatePixel(%Q, %Q, 1), 0, 0))",
778 coverage, sample_name, pixel_name, num_bands,
779 compression_name, qlty, tile_size, tile_size, 4326,
780 0.0008333333333333, 0.0008333333333333, sample_name,
781 pixel_name);
782 ret = execute_check (sqlite, sql);
783 sqlite3_free (sql);
784 if (ret != SQLITE_OK)
785 {
786 fprintf (stderr, "CreateCoverage \"%s\" error: %s\n", coverage,
787 err_msg);
788 sqlite3_free (err_msg);
789 *retcode += -1;
790 return 0;
791 }
792
793 /* loading from directory */
794 sql =
795 sqlite3_mprintf
796 ("SELECT RL2_LoadRastersFromDir(%Q, %Q, %Q, 0, 4326, 0, 1)", coverage,
797 "map_samples/usgs-srtm", ".tif");
798 ret = execute_check (sqlite, sql);
799 sqlite3_free (sql);
800 if (ret != SQLITE_OK)
801 {
802 fprintf (stderr, "LoadRastersFromDir \"%s\" error: %s\n", coverage,
803 err_msg);
804 sqlite3_free (err_msg);
805 *retcode += -2;
806 return 0;
807 }
808
809 /* deleting the first section */
810 sql = sqlite3_mprintf ("SELECT RL2_DeleteSection(%Q, %Q, 1)",
811 coverage, "srtm1");
812 ret = execute_check (sqlite, sql);
813 sqlite3_free (sql);
814 if (ret != SQLITE_OK)
815 {
816 fprintf (stderr, "DeleteSection \"%s\" error: %s\n", coverage,
817 err_msg);
818 sqlite3_free (err_msg);
819 *retcode += -3;
820 return 0;
821 }
822
823 /* re-loading yet again the first section */
824 sql = sqlite3_mprintf ("SELECT RL2_LoadRaster(%Q, %Q, 0, 4326, 0, 1)",
825 coverage, "map_samples/usgs-srtm/srtm1.tif");
826 ret = execute_check (sqlite, sql);
827 sqlite3_free (sql);
828 if (ret != SQLITE_OK)
829 {
830 fprintf (stderr, "LoadRaster \"%s\" error: %s\n", coverage, err_msg);
831 sqlite3_free (err_msg);
832 *retcode += -4;
833 return 0;
834 }
835
836 /* export tests */
837 geom = get_center_point (sqlite, coverage);
838 if (geom == NULL)
839 {
840 *retcode += -5;
841 return 0;
842 }
843 if (!do_export_geotiff (sqlite, coverage, geom, 1))
844 {
845 *retcode += -6;
846 return 0;
847 }
848 if (!do_export_geotiff (sqlite, coverage, geom, 2))
849 {
850 *retcode += -7;
851 return 0;
852 }
853 if (!do_export_geotiff (sqlite, coverage, geom, 4))
854 {
855 *retcode += -8;
856 return 0;
857 }
858 if (!do_export_geotiff (sqlite, coverage, geom, 8))
859 {
860 *retcode += -9;
861 return 0;
862 }
863 if (!do_export_tiff (sqlite, coverage, geom, 1))
864 {
865 *retcode += -10;
866 return 0;
867 }
868 if (!do_export_tiff (sqlite, coverage, geom, 2))
869 {
870 *retcode += -11;
871 return 0;
872 }
873 if (!do_export_tiff (sqlite, coverage, geom, 4))
874 {
875 *retcode += -12;
876 return 0;
877 }
878 if (!do_export_tiff (sqlite, coverage, geom, 8))
879 {
880 *retcode += -13;
881 return 0;
882 }
883 if (!test_map_image)
884 goto skip;
885
886 /* testing GetMapImage - no style */
887 if (!do_export_map_image (sqlite, coverage, geom, "default", "png"))
888 {
889 *retcode += 14;
890 return 0;
891 }
892 if (!do_export_map_image (sqlite, coverage, geom, "default", "jpg"))
893 {
894 *retcode += 15;
895 return 0;
896 }
897 if (!do_export_map_image (sqlite, coverage, geom, "default", "tif"))
898 {
899 *retcode += 16;
900 return 0;
901 }
902 if (!do_export_map_image (sqlite, coverage, geom, "default", "pdf"))
903 {
904 *retcode += 17;
905 return 0;
906 }
907
908 /* loading the RasterSymbolizers */
909 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
910 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
911 "srtm_categ.xml");
912 ret = execute_check (sqlite, sql);
913 sqlite3_free (sql);
914 if (ret != SQLITE_OK)
915 {
916 fprintf (stderr, "RegisterRasterStyledLayer #1 \"%s\" error: %s\n",
917 coverage, err_msg);
918 sqlite3_free (err_msg);
919 *retcode += -19;
920 return 0;
921 }
922 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
923 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
924 "srtm_interp.xml");
925 ret = execute_check (sqlite, sql);
926 sqlite3_free (sql);
927 if (ret != SQLITE_OK)
928 {
929 fprintf (stderr, "RegisterRasterStyledLayer #2 \"%s\" error: %s\n",
930 coverage, err_msg);
931 sqlite3_free (err_msg);
932 *retcode += -20;
933 return 0;
934 }
935 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
936 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
937 "gray_gamma.xml");
938 ret = execute_check (sqlite, sql);
939 sqlite3_free (sql);
940 if (ret != SQLITE_OK)
941 {
942 fprintf (stderr, "RegisterRasterStyledLayer #3 \"%s\" error: %s\n",
943 coverage, err_msg);
944 sqlite3_free (err_msg);
945 *retcode += -21;
946 return 0;
947 }
948 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
949 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
950 "gray_histogram.xml");
951 ret = execute_check (sqlite, sql);
952 sqlite3_free (sql);
953 if (ret != SQLITE_OK)
954 {
955 fprintf (stderr, "RegisterRasterStyledLayer #4 \"%s\" error: %s\n",
956 coverage, err_msg);
957 sqlite3_free (err_msg);
958 *retcode += -22;
959 return 0;
960 }
961 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
962 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
963 "gray_normalize.xml");
964 ret = execute_check (sqlite, sql);
965 sqlite3_free (sql);
966 if (ret != SQLITE_OK)
967 {
968 fprintf (stderr, "RegisterRasterStyledLayer #5 \"%s\" error: %s\n",
969 coverage, err_msg);
970 sqlite3_free (err_msg);
971 *retcode += -23;
972 return 0;
973 }
974 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
975 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
976 "srtm_relief_25.xml");
977 ret = execute_check (sqlite, sql);
978 sqlite3_free (sql);
979 if (ret != SQLITE_OK)
980 {
981 fprintf (stderr, "RegisterRasterStyledLayer #6 \"%s\" error: %s\n",
982 coverage, err_msg);
983 sqlite3_free (err_msg);
984 *retcode += -24;
985 return 0;
986 }
987 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
988 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
989 "srtm_relief_75.xml");
990 ret = execute_check (sqlite, sql);
991 sqlite3_free (sql);
992 if (ret != SQLITE_OK)
993 {
994 fprintf (stderr, "RegisterRasterStyledLayer #7 \"%s\" error: %s\n",
995 coverage, err_msg);
996 sqlite3_free (err_msg);
997 *retcode += -25;
998 return 0;
999 }
1000 sql = sqlite3_mprintf ("SELECT RegisterRasterStyledLayer(%Q, "
1001 "XB_Create(XB_LoadXML(%Q), 1, 1))", coverage,
1002 "srtm_brightness.xml");
1003 ret = execute_check (sqlite, sql);
1004 sqlite3_free (sql);
1005 if (ret != SQLITE_OK)
1006 {
1007 fprintf (stderr, "RegisterRasterStyledLayer #7 \"%s\" error: %s\n",
1008 coverage, err_msg);
1009 sqlite3_free (err_msg);
1010 *retcode += -26;
1011 return 0;
1012 }
1013
1014 /* testing GetMapImage - Categorize Color Map */
1015 if (!do_export_map_image (sqlite, coverage, geom, "srtm_categ", "png"))
1016 {
1017 *retcode += 27;
1018 return 0;
1019 }
1020 if (!do_export_map_image (sqlite, coverage, geom, "srtm_categ", "jpg"))
1021 {
1022 *retcode += 28;
1023 return 0;
1024 }
1025 if (!do_export_map_image (sqlite, coverage, geom, "srtm_categ", "tif"))
1026 {
1027 *retcode += 29;
1028 return 0;
1029 }
1030 if (!do_export_map_image (sqlite, coverage, geom, "srtm_categ", "pdf"))
1031 {
1032 *retcode += 30;
1033 return 0;
1034 }
1035
1036 /* testing GetMapImage - Categorize Color Map */
1037 if (!do_export_map_image (sqlite, coverage, geom, "srtm_interp", "png"))
1038 {
1039 *retcode += 31;
1040 return 0;
1041 }
1042 if (!do_export_map_image (sqlite, coverage, geom, "srtm_interp", "jpg"))
1043 {
1044 *retcode += 32;
1045 return 0;
1046 }
1047 if (!do_export_map_image (sqlite, coverage, geom, "srtm_interp", "tif"))
1048 {
1049 *retcode += 33;
1050 return 0;
1051 }
1052 if (!do_export_map_image (sqlite, coverage, geom, "srtm_interp", "pdf"))
1053 {
1054 *retcode += 34;
1055 return 0;
1056 }
1057
1058 /* testing GetMapImage - Gray GammaValue */
1059 if (!do_export_map_image (sqlite, coverage, geom, "gray_gamma", "png"))
1060 {
1061 *retcode += 35;
1062 return 0;
1063 }
1064 if (!do_export_map_image (sqlite, coverage, geom, "gray_gamma", "jpg"))
1065 {
1066 *retcode += 36;
1067 return 0;
1068 }
1069 if (!do_export_map_image (sqlite, coverage, geom, "gray_gamma", "tif"))
1070 {
1071 *retcode += 37;
1072 return 0;
1073 }
1074 if (!do_export_map_image (sqlite, coverage, geom, "gray_gamma", "pdf"))
1075 {
1076 *retcode += 38;
1077 return 0;
1078 }
1079
1080 /* testing GetMapImage - Gray Histogram */
1081 if (!do_export_map_image (sqlite, coverage, geom, "gray_histogram", "png"))
1082 {
1083 *retcode += 39;
1084 return 0;
1085 }
1086 if (!do_export_map_image (sqlite, coverage, geom, "gray_histogram", "jpg"))
1087 {
1088 *retcode += 40;
1089 return 0;
1090 }
1091 if (!do_export_map_image (sqlite, coverage, geom, "gray_histogram", "tif"))
1092 {
1093 *retcode += 41;
1094 return 0;
1095 }
1096 if (!do_export_map_image (sqlite, coverage, geom, "gray_histogram", "pdf"))
1097 {
1098 *retcode += 42;
1099 return 0;
1100 }
1101
1102 /* testing GetMapImage - Gray Normalize */
1103 if (!do_export_map_image (sqlite, coverage, geom, "gray_normalize", "png"))
1104 {
1105 *retcode += 43;
1106 return 0;
1107 }
1108 if (!do_export_map_image (sqlite, coverage, geom, "gray_normalize", "jpg"))
1109 {
1110 *retcode += 44;
1111 return 0;
1112 }
1113 if (!do_export_map_image (sqlite, coverage, geom, "gray_normalize", "tif"))
1114 {
1115 *retcode += 45;
1116 return 0;
1117 }
1118 if (!do_export_map_image (sqlite, coverage, geom, "gray_normalize", "pdf"))
1119 {
1120 *retcode += 46;
1121 return 0;
1122 }
1123
1124 /* testing GetMapImage - ShadedRelief ReliefFactor 25 */
1125 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_25", "png"))
1126 {
1127 *retcode += 47;
1128 return 0;
1129 }
1130 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_25", "jpg"))
1131 {
1132 *retcode += 48;
1133 return 0;
1134 }
1135 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_25", "tif"))
1136 {
1137 *retcode += 49;
1138 return 0;
1139 }
1140 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_25", "pdf"))
1141 {
1142 *retcode += 50;
1143 return 0;
1144 }
1145
1146 /* testing GetMapImage - ShadedRelief ReliefFactor 75 */
1147 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_75", "png"))
1148 {
1149 *retcode += 51;
1150 return 0;
1151 }
1152 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_75", "jpg"))
1153 {
1154 *retcode += 52;
1155 return 0;
1156 }
1157 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_75", "tif"))
1158 {
1159 *retcode += 53;
1160 return 0;
1161 }
1162 if (!do_export_map_image (sqlite, coverage, geom, "srtm_relief_75", "pdf"))
1163 {
1164 *retcode += 54;
1165 return 0;
1166 }
1167
1168 /* testing GetMapImage - ShadedRelief BrightnessOnly */
1169 if (!do_export_map_image (sqlite, coverage, geom, "srtm_brightness", "png"))
1170 {
1171 *retcode += 55;
1172 return 0;
1173 }
1174 if (!do_export_map_image (sqlite, coverage, geom, "srtm_brightness", "jpg"))
1175 {
1176 *retcode += 56;
1177 return 0;
1178 }
1179 if (!do_export_map_image (sqlite, coverage, geom, "srtm_brightness", "tif"))
1180 {
1181 *retcode += 57;
1182 return 0;
1183 }
1184 if (!do_export_map_image (sqlite, coverage, geom, "srtm_brightness", "pdf"))
1185 {
1186 *retcode += 58;
1187 return 0;
1188 }
1189 skip:
1190 gaiaFreeGeomColl (geom);
1191
1192 /* testing GetTileImage() */
1193 if (!do_export_tile_image (sqlite, coverage, 1, 0))
1194 {
1195 *retcode += -59;
1196 return 0;
1197 }
1198 if (!do_export_tile_image (sqlite, coverage, 1, 1))
1199 {
1200 *retcode += -60;
1201 return 0;
1202 }
1203 if (!do_export_tile_image (sqlite, coverage, -1, 0))
1204 {
1205 *retcode += -61;
1206 return 0;
1207 }
1208 if (!do_export_tile_image (sqlite, coverage, -1, 1))
1209 {
1210 *retcode += -62;
1211 return 0;
1212 }
1213
1214 return 1;
1215 }
1216
1217 static int
drop_coverage(sqlite3 * sqlite,unsigned char sample,unsigned char compression,int tile_sz,int * retcode)1218 drop_coverage (sqlite3 * sqlite, unsigned char sample,
1219 unsigned char compression, int tile_sz, int *retcode)
1220 {
1221 /* dropping some DBMS Coverage */
1222 int ret;
1223 char *err_msg = NULL;
1224 const char *coverage;
1225 char *sql;
1226
1227 /* setting the coverage name */
1228 switch (sample)
1229 {
1230 case RL2_SAMPLE_INT8:
1231 switch (compression)
1232 {
1233 case RL2_COMPRESSION_NONE:
1234 switch (tile_sz)
1235 {
1236 case TILE_256:
1237 coverage = "grid_8_none_256";
1238 break;
1239 case TILE_1024:
1240 coverage = "grid_8_none_1024";
1241 break;
1242 };
1243 break;
1244 case RL2_COMPRESSION_DEFLATE:
1245 switch (tile_sz)
1246 {
1247 case TILE_256:
1248 coverage = "grid_8_deflate_256";
1249 break;
1250 case TILE_1024:
1251 coverage = "grid_8_deflate_1024";
1252 break;
1253 };
1254 break;
1255 case RL2_COMPRESSION_LZMA:
1256 switch (tile_sz)
1257 {
1258 case TILE_256:
1259 coverage = "grid_8_lzma_256";
1260 break;
1261 case TILE_1024:
1262 coverage = "grid_8_lzma_1024";
1263 break;
1264 };
1265 break;
1266 };
1267 break;
1268 case RL2_SAMPLE_UINT8:
1269 switch (compression)
1270 {
1271 case RL2_COMPRESSION_NONE:
1272 switch (tile_sz)
1273 {
1274 case TILE_256:
1275 coverage = "grid_u8_none_256";
1276 break;
1277 case TILE_1024:
1278 coverage = "grid_u8_none_1024";
1279 break;
1280 };
1281 break;
1282 case RL2_COMPRESSION_DEFLATE:
1283 switch (tile_sz)
1284 {
1285 case TILE_256:
1286 coverage = "grid_u8_deflate_256";
1287 break;
1288 case TILE_1024:
1289 coverage = "grid_u8_deflate_1024";
1290 break;
1291 };
1292 break;
1293 case RL2_COMPRESSION_LZMA:
1294 switch (tile_sz)
1295 {
1296 case TILE_256:
1297 coverage = "grid_u8_lzma_256";
1298 break;
1299 case TILE_1024:
1300 coverage = "grid_u8_lzma_1024";
1301 break;
1302 };
1303 break;
1304 };
1305 break;
1306 case RL2_SAMPLE_INT16:
1307 switch (compression)
1308 {
1309 case RL2_COMPRESSION_NONE:
1310 switch (tile_sz)
1311 {
1312 case TILE_256:
1313 coverage = "grid_16_none_256";
1314 break;
1315 case TILE_1024:
1316 coverage = "grid_16_none_1024";
1317 break;
1318 };
1319 break;
1320 case RL2_COMPRESSION_DEFLATE:
1321 switch (tile_sz)
1322 {
1323 case TILE_256:
1324 coverage = "grid_16_deflate_256";
1325 break;
1326 case TILE_1024:
1327 coverage = "grid_16_deflate_1024";
1328 break;
1329 };
1330 break;
1331 case RL2_COMPRESSION_LZMA:
1332 switch (tile_sz)
1333 {
1334 case TILE_256:
1335 coverage = "grid_16_lzma_256";
1336 break;
1337 case TILE_1024:
1338 coverage = "grid_16_lzma_1024";
1339 break;
1340 };
1341 break;
1342 };
1343 break;
1344 case RL2_SAMPLE_UINT16:
1345 switch (compression)
1346 {
1347 case RL2_COMPRESSION_NONE:
1348 switch (tile_sz)
1349 {
1350 case TILE_256:
1351 coverage = "grid_u16_none_256";
1352 break;
1353 case TILE_1024:
1354 coverage = "grid_u16_none_1024";
1355 break;
1356 };
1357 break;
1358 case RL2_COMPRESSION_DEFLATE:
1359 switch (tile_sz)
1360 {
1361 case TILE_256:
1362 coverage = "grid_u16_deflate_256";
1363 break;
1364 case TILE_1024:
1365 coverage = "grid_u16_deflate_1024";
1366 break;
1367 };
1368 break;
1369 case RL2_COMPRESSION_LZMA:
1370 switch (tile_sz)
1371 {
1372 case TILE_256:
1373 coverage = "grid_u16_lzma_256";
1374 break;
1375 case TILE_1024:
1376 coverage = "grid_u16_lzma_1024";
1377 break;
1378 };
1379 break;
1380 };
1381 break;
1382 case RL2_SAMPLE_INT32:
1383 switch (compression)
1384 {
1385 case RL2_COMPRESSION_NONE:
1386 switch (tile_sz)
1387 {
1388 case TILE_256:
1389 coverage = "grid_32_none_256";
1390 break;
1391 case TILE_1024:
1392 coverage = "grid_32_none_1024";
1393 break;
1394 };
1395 break;
1396 case RL2_COMPRESSION_DEFLATE:
1397 switch (tile_sz)
1398 {
1399 case TILE_256:
1400 coverage = "grid_32_deflate_256";
1401 break;
1402 case TILE_1024:
1403 coverage = "grid_32_deflate_1024";
1404 break;
1405 };
1406 break;
1407 case RL2_COMPRESSION_LZMA:
1408 switch (tile_sz)
1409 {
1410 case TILE_256:
1411 coverage = "grid_32_lzma_256";
1412 break;
1413 case TILE_1024:
1414 coverage = "grid_32_lzma_1024";
1415 break;
1416 };
1417 break;
1418 };
1419 break;
1420 case RL2_SAMPLE_UINT32:
1421 switch (compression)
1422 {
1423 case RL2_COMPRESSION_NONE:
1424 switch (tile_sz)
1425 {
1426 case TILE_256:
1427 coverage = "grid_u32_none_256";
1428 break;
1429 case TILE_1024:
1430 coverage = "grid_u32_none_1024";
1431 break;
1432 };
1433 break;
1434 case RL2_COMPRESSION_DEFLATE:
1435 switch (tile_sz)
1436 {
1437 case TILE_256:
1438 coverage = "grid_u32_deflate_256";
1439 break;
1440 case TILE_1024:
1441 coverage = "grid_u32_deflate_1024";
1442 break;
1443 };
1444 break;
1445 case RL2_COMPRESSION_LZMA:
1446 switch (tile_sz)
1447 {
1448 case TILE_256:
1449 coverage = "grid_u32_lzma_256";
1450 break;
1451 case TILE_1024:
1452 coverage = "grid_u32_lzma_1024";
1453 break;
1454 };
1455 break;
1456 };
1457 break;
1458 case RL2_SAMPLE_FLOAT:
1459 switch (compression)
1460 {
1461 case RL2_COMPRESSION_NONE:
1462 switch (tile_sz)
1463 {
1464 case TILE_256:
1465 coverage = "grid_flt_none_256";
1466 break;
1467 case TILE_1024:
1468 coverage = "grid_flt_none_1024";
1469 break;
1470 };
1471 break;
1472 case RL2_COMPRESSION_DEFLATE:
1473 switch (tile_sz)
1474 {
1475 case TILE_256:
1476 coverage = "grid_flt_deflate_256";
1477 break;
1478 case TILE_1024:
1479 coverage = "grid_flt_deflate_1024";
1480 break;
1481 };
1482 break;
1483 case RL2_COMPRESSION_LZMA:
1484 switch (tile_sz)
1485 {
1486 case TILE_256:
1487 coverage = "grid_flt_lzma_256";
1488 break;
1489 case TILE_1024:
1490 coverage = "grid_flt_lzma_1024";
1491 break;
1492 };
1493 break;
1494 };
1495 break;
1496 case RL2_SAMPLE_DOUBLE:
1497 switch (compression)
1498 {
1499 case RL2_COMPRESSION_NONE:
1500 switch (tile_sz)
1501 {
1502 case TILE_256:
1503 coverage = "grid_dbl_none_256";
1504 break;
1505 case TILE_1024:
1506 coverage = "grid_dbl_none_1024";
1507 break;
1508 };
1509 break;
1510 case RL2_COMPRESSION_DEFLATE:
1511 switch (tile_sz)
1512 {
1513 case TILE_256:
1514 coverage = "grid_dbl_deflate_256";
1515 break;
1516 case TILE_1024:
1517 coverage = "grid_dbl_deflate_1024";
1518 break;
1519 };
1520 break;
1521 case RL2_COMPRESSION_LZMA:
1522 switch (tile_sz)
1523 {
1524 case TILE_256:
1525 coverage = "grid_dbl_lzma_256";
1526 break;
1527 case TILE_1024:
1528 coverage = "grid_dbl_lzma_1024";
1529 break;
1530 };
1531 break;
1532 };
1533 break;
1534 };
1535
1536 /* dropping the DBMS Coverage */
1537 sql = sqlite3_mprintf ("SELECT RL2_DropCoverage(%Q, 1)", coverage);
1538 ret = execute_check (sqlite, sql);
1539 sqlite3_free (sql);
1540 if (ret != SQLITE_OK)
1541 {
1542 fprintf (stderr, "DropCoverage \"%s\" error: %s\n", coverage,
1543 err_msg);
1544 sqlite3_free (err_msg);
1545 *retcode += -1;
1546 return 0;
1547 }
1548
1549 return 1;
1550 }
1551
1552 int
main(int argc,char * argv[])1553 main (int argc, char *argv[])
1554 {
1555 int result = 0;
1556 int ret;
1557 char *err_msg = NULL;
1558 sqlite3 *db_handle;
1559 void *cache = spatialite_alloc_connection ();
1560 char *old_SPATIALITE_SECURITY_ENV = NULL;
1561
1562 if (argc > 1 || argv[0] == NULL)
1563 argc = 1; /* silencing stupid compiler warnings */
1564
1565 old_SPATIALITE_SECURITY_ENV = getenv ("SPATIALITE_SECURITY");
1566 #ifdef _WIN32
1567 putenv ("SPATIALITE_SECURITY=relaxed");
1568 #else /* not WIN32 */
1569 setenv ("SPATIALITE_SECURITY", "relaxed", 1);
1570 #endif
1571
1572 /* opening and initializing the "memory" test DB */
1573 ret = sqlite3_open_v2 (":memory:", &db_handle,
1574 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
1575 if (ret != SQLITE_OK)
1576 {
1577 fprintf (stderr, "sqlite3_open_v2() error: %s\n",
1578 sqlite3_errmsg (db_handle));
1579 return -1;
1580 }
1581 spatialite_init_ex (db_handle, cache, 0);
1582 rl2_init (db_handle, 0);
1583 ret =
1584 sqlite3_exec (db_handle, "SELECT InitSpatialMetadata(1)", NULL, NULL,
1585 &err_msg);
1586 if (ret != SQLITE_OK)
1587 {
1588 fprintf (stderr, "InitSpatialMetadata() error: %s\n", err_msg);
1589 sqlite3_free (err_msg);
1590 return -2;
1591 }
1592 ret =
1593 sqlite3_exec (db_handle, "SELECT CreateRasterCoveragesTable()", NULL,
1594 NULL, &err_msg);
1595 if (ret != SQLITE_OK)
1596 {
1597 fprintf (stderr, "CreateRasterCoveragesTable() error: %s\n", err_msg);
1598 sqlite3_free (err_msg);
1599 return -3;
1600 }
1601 ret =
1602 sqlite3_exec (db_handle, "SELECT CreateStylingTables()", NULL,
1603 NULL, &err_msg);
1604 if (ret != SQLITE_OK)
1605 {
1606 fprintf (stderr, "CreateStylingTables() error: %s\n", err_msg);
1607 sqlite3_free (err_msg);
1608 return 4;
1609 }
1610
1611 /* SRTM (GRID) tests */
1612 ret = -100;
1613 if (!test_coverage
1614 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_NONE, TILE_256, &ret))
1615 return ret;
1616 ret = -120;
1617 if (!test_coverage
1618 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1619 return ret;
1620 ret = -200;
1621 if (!test_coverage
1622 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1623 return ret;
1624 ret = -220;
1625 if (!test_coverage
1626 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1627 return ret;
1628 ret = -300;
1629 if (!test_coverage
1630 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1631 return ret;
1632 ret = -320;
1633 if (!test_coverage
1634 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1635 return ret;
1636
1637 /* UINT16 tests */
1638 ret = -150;
1639 if (!test_coverage
1640 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_NONE, TILE_256, &ret))
1641 return ret;
1642 ret = -170;
1643 if (!test_coverage
1644 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1645 return ret;
1646 ret = -250;
1647 if (!test_coverage
1648 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1649 return ret;
1650 ret = -270;
1651 if (!test_coverage
1652 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_DEFLATE, TILE_1024,
1653 &ret))
1654 return ret;
1655 ret = -350;
1656 if (!test_coverage
1657 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1658 return ret;
1659 ret = -370;
1660 if (!test_coverage
1661 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1662 return ret;
1663
1664 /* INT32 tests */
1665 ret = -400;
1666 if (!test_coverage
1667 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_NONE, TILE_256, &ret))
1668 return ret;
1669 ret = -420;
1670 if (!test_coverage
1671 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1672 return ret;
1673 ret = -500;
1674 if (!test_coverage
1675 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1676 return ret;
1677 ret = -520;
1678 if (!test_coverage
1679 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1680 return ret;
1681 ret = -600;
1682 if (!test_coverage
1683 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1684 return ret;
1685 ret = -620;
1686 if (!test_coverage
1687 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1688 return ret;
1689
1690 /* UINT32 tests */
1691 ret = -450;
1692 if (!test_coverage
1693 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_NONE, TILE_256, &ret))
1694 return ret;
1695 ret = -470;
1696 if (!test_coverage
1697 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1698 return ret;
1699 ret = -550;
1700 if (!test_coverage
1701 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1702 return ret;
1703 ret = -570;
1704 if (!test_coverage
1705 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_DEFLATE, TILE_1024,
1706 &ret))
1707 return ret;
1708 ret = -650;
1709 if (!test_coverage
1710 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1711 return ret;
1712 ret = -670;
1713 if (!test_coverage
1714 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1715 return ret;
1716
1717 /* FLOAT tests */
1718 ret = -700;
1719 if (!test_coverage
1720 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_NONE, TILE_256, &ret))
1721 return ret;
1722 ret = -720;
1723 if (!test_coverage
1724 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1725 return ret;
1726 ret = -800;
1727 if (!test_coverage
1728 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1729 return ret;
1730 ret = -820;
1731 if (!test_coverage
1732 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1733 return ret;
1734 ret = -900;
1735 if (!test_coverage
1736 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1737 return ret;
1738 ret = -920;
1739 if (!test_coverage
1740 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1741 return ret;
1742
1743 /* INT8 tests */
1744 ret = -750;
1745 if (!test_coverage
1746 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_NONE, TILE_256, &ret))
1747 return ret;
1748 ret = -770;
1749 if (!test_coverage
1750 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1751 return ret;
1752 ret = -850;
1753 if (!test_coverage
1754 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1755 return ret;
1756 ret = -870;
1757 if (!test_coverage
1758 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1759 return ret;
1760 ret = -950;
1761 if (!test_coverage
1762 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1763 return ret;
1764 ret = -970;
1765 if (!test_coverage
1766 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1767 return ret;
1768
1769 /* DOUBLE tests */
1770 ret = -1000;
1771 if (!test_coverage
1772 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_NONE, TILE_256, &ret))
1773 return ret;
1774 ret = -1020;
1775 if (!test_coverage
1776 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1777 return ret;
1778 ret = -1100;
1779 if (!test_coverage
1780 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1781 return ret;
1782 ret = -1120;
1783 if (!test_coverage
1784 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_DEFLATE, TILE_1024,
1785 &ret))
1786 return ret;
1787 ret = -1200;
1788 if (!test_coverage
1789 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1790 return ret;
1791 ret = -1220;
1792 if (!test_coverage
1793 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1794 return ret;
1795
1796 /* UINT8 tests */
1797 ret = -1050;
1798 if (!test_coverage
1799 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_NONE, TILE_256, &ret))
1800 return ret;
1801 ret = -1070;
1802 if (!test_coverage
1803 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1804 return ret;
1805 ret = -1150;
1806 if (!test_coverage
1807 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1808 return ret;
1809 ret = -1170;
1810 if (!test_coverage
1811 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1812 return ret;
1813 ret = -1250;
1814 if (!test_coverage
1815 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1816 return ret;
1817 ret = -1270;
1818 if (!test_coverage
1819 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1820 return ret;
1821
1822 /* dropping all SRTM INT16 Coverages */
1823 ret = -130;
1824 if (!drop_coverage
1825 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_NONE, TILE_256, &ret))
1826 return ret;
1827 ret = -140;
1828 if (!drop_coverage
1829 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1830 return ret;
1831 ret = -230;
1832 if (!drop_coverage
1833 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1834 return ret;
1835 ret = -240;
1836 if (!drop_coverage
1837 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1838 return ret;
1839 ret = -330;
1840 if (!drop_coverage
1841 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1842 return ret;
1843 ret = -340;
1844 if (!drop_coverage
1845 (db_handle, RL2_SAMPLE_INT16, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1846 return ret;
1847
1848 /* dropping all SRTM UINT16 Coverages */
1849 ret = -180;
1850 if (!drop_coverage
1851 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_NONE, TILE_256, &ret))
1852 return ret;
1853 ret = -190;
1854 if (!drop_coverage
1855 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1856 return ret;
1857 ret = -280;
1858 if (!drop_coverage
1859 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1860 return ret;
1861 ret = -290;
1862 if (!drop_coverage
1863 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_DEFLATE, TILE_1024,
1864 &ret))
1865 return ret;
1866 ret = -380;
1867 if (!drop_coverage
1868 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1869 return ret;
1870 ret = -390;
1871 if (!drop_coverage
1872 (db_handle, RL2_SAMPLE_UINT16, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1873 return ret;
1874
1875 /* dropping all INT32 Coverages */
1876 ret = -430;
1877 if (!drop_coverage
1878 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_NONE, TILE_256, &ret))
1879 return ret;
1880 ret = -440;
1881 if (!drop_coverage
1882 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1883 return ret;
1884 ret = -530;
1885 if (!drop_coverage
1886 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1887 return ret;
1888 ret = -540;
1889 if (!drop_coverage
1890 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1891 return ret;
1892 ret = -630;
1893 if (!drop_coverage
1894 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1895 return ret;
1896 ret = -640;
1897 if (!drop_coverage
1898 (db_handle, RL2_SAMPLE_INT32, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1899 return ret;
1900
1901 /* dropping all UINT32 Coverages */
1902 ret = -480;
1903 if (!drop_coverage
1904 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_NONE, TILE_256, &ret))
1905 return ret;
1906 ret = -490;
1907 if (!drop_coverage
1908 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1909 return ret;
1910 ret = -580;
1911 if (!drop_coverage
1912 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1913 return ret;
1914 ret = -590;
1915 if (!drop_coverage
1916 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_DEFLATE, TILE_1024,
1917 &ret))
1918 return ret;
1919 ret = -680;
1920 if (!drop_coverage
1921 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1922 return ret;
1923 ret = -690;
1924 if (!drop_coverage
1925 (db_handle, RL2_SAMPLE_UINT32, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1926 return ret;
1927
1928 /* dropping all FLOAT Coverages */
1929 ret = -740;
1930 if (!drop_coverage
1931 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_NONE, TILE_256, &ret))
1932 return ret;
1933 ret = -750;
1934 if (!drop_coverage
1935 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1936 return ret;
1937 ret = -840;
1938 if (!drop_coverage
1939 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1940 return ret;
1941 ret = -850;
1942 if (!drop_coverage
1943 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1944 return ret;
1945 ret = -940;
1946 if (!drop_coverage
1947 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1948 return ret;
1949 ret = -950;
1950 if (!drop_coverage
1951 (db_handle, RL2_SAMPLE_FLOAT, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1952 return ret;
1953
1954 /* dropping all INT8 Coverages */
1955 ret = -780;
1956 if (!drop_coverage
1957 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_NONE, TILE_256, &ret))
1958 return ret;
1959 ret = -790;
1960 if (!drop_coverage
1961 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1962 return ret;
1963 ret = -880;
1964 if (!drop_coverage
1965 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1966 return ret;
1967 ret = -890;
1968 if (!drop_coverage
1969 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
1970 return ret;
1971 ret = -980;
1972 if (!drop_coverage
1973 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_LZMA, TILE_256, &ret))
1974 return ret;
1975 ret = -990;
1976 if (!drop_coverage
1977 (db_handle, RL2_SAMPLE_INT8, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
1978 return ret;
1979
1980 /* dropping all DOUBLE Coverages */
1981 ret = -1030;
1982 if (!drop_coverage
1983 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_NONE, TILE_256, &ret))
1984 return ret;
1985 ret = -1040;
1986 if (!drop_coverage
1987 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_NONE, TILE_1024, &ret))
1988 return ret;
1989 ret = -1130;
1990 if (!drop_coverage
1991 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
1992 return ret;
1993 ret = -1140;
1994 if (!drop_coverage
1995 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_DEFLATE, TILE_1024,
1996 &ret))
1997 return ret;
1998 ret = -1230;
1999 if (!drop_coverage
2000 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_LZMA, TILE_256, &ret))
2001 return ret;
2002 ret = -1240;
2003 if (!drop_coverage
2004 (db_handle, RL2_SAMPLE_DOUBLE, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
2005 return ret;
2006
2007 /* dropping all UINT8 Coverages */
2008 ret = -1030;
2009 if (!drop_coverage
2010 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_NONE, TILE_256, &ret))
2011 return ret;
2012 ret = -1040;
2013 if (!drop_coverage
2014 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_NONE, TILE_1024, &ret))
2015 return ret;
2016 ret = -1130;
2017 if (!drop_coverage
2018 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_DEFLATE, TILE_256, &ret))
2019 return ret;
2020 ret = -1140;
2021 if (!drop_coverage
2022 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_DEFLATE, TILE_1024, &ret))
2023 return ret;
2024 ret = -1230;
2025 if (!drop_coverage
2026 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_LZMA, TILE_256, &ret))
2027 return ret;
2028 ret = -1240;
2029 if (!drop_coverage
2030 (db_handle, RL2_SAMPLE_UINT8, RL2_COMPRESSION_LZMA, TILE_1024, &ret))
2031 return ret;
2032
2033 /* closing the DB */
2034 sqlite3_close (db_handle);
2035 spatialite_shutdown ();
2036 if (old_SPATIALITE_SECURITY_ENV)
2037 {
2038 #ifdef _WIN32
2039 char *env = sqlite3_mprintf ("SPATIALITE_SECURITY=%s",
2040 old_SPATIALITE_SECURITY_ENV);
2041 putenv (env);
2042 sqlite3_free (env);
2043 #else /* not WIN32 */
2044 setenv ("SPATIALITE_SECURITY", old_SPATIALITE_SECURITY_ENV, 1);
2045 #endif
2046 }
2047 else
2048 {
2049 #ifdef _WIN32
2050 putenv ("SPATIALITE_SECURITY=");
2051 #else /* not WIN32 */
2052 unsetenv ("SPATIALITE_SECURITY");
2053 #endif
2054 }
2055 return result;
2056 }
2057