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