1 /*
2
3 test_map_noref.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
52 #include "rasterlite2/rasterlite2.h"
53
54 static int
execute_check(sqlite3 * sqlite,const char * sql)55 execute_check (sqlite3 * sqlite, const char *sql)
56 {
57 /* executing an SQL statement returning True/False */
58 sqlite3_stmt *stmt;
59 int ret;
60 int retcode = 0;
61
62 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
63 if (ret != SQLITE_OK)
64 return SQLITE_ERROR;
65 ret = sqlite3_step (stmt);
66 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
67 {
68 if (sqlite3_column_int (stmt, 0) == 1)
69 retcode = 1;
70 }
71 sqlite3_finalize (stmt);
72 if (retcode == 1)
73 return SQLITE_OK;
74 return SQLITE_ERROR;
75 }
76
77 static int
get_base_resolution(sqlite3 * sqlite,const char * coverage,double * x_res,double * y_res)78 get_base_resolution (sqlite3 * sqlite, const char *coverage, double *x_res,
79 double *y_res)
80 {
81 /* attempting to retrieve the Coverage's base resolution */
82 char *sql;
83 sqlite3_stmt *stmt;
84 int ret;
85 int ok = 0;
86
87 sql = sqlite3_mprintf ("SELECT horz_resolution, vert_resolution "
88 "FROM raster_coverages WHERE coverage_name = %Q",
89 coverage);
90 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
91 sqlite3_free (sql);
92 if (ret != SQLITE_OK)
93 return 0;
94
95 while (1)
96 {
97 /* scrolling the result set rows */
98 ret = sqlite3_step (stmt);
99 if (ret == SQLITE_DONE)
100 break; /* end of result set */
101 if (ret == SQLITE_ROW)
102 {
103 *x_res = sqlite3_column_double (stmt, 0);
104 *y_res = sqlite3_column_double (stmt, 1);
105 ok = 1;
106 }
107 }
108 sqlite3_finalize (stmt);
109 return ok;
110 }
111
112 static int
do_export_tiff(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,int scale)113 do_export_tiff (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom,
114 int scale)
115 {
116 /* exporting a plain Tiff */
117 char *sql;
118 char *path;
119 sqlite3_stmt *stmt;
120 int ret;
121 double x_res;
122 double y_res;
123 double xx_res;
124 double yy_res;
125 unsigned char *blob;
126 int blob_size;
127 int retcode = 0;
128
129 path = sqlite3_mprintf ("./%s_%d.tif", coverage, scale);
130
131 if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
132 return 0;
133 xx_res = x_res * (double) scale;
134 yy_res = y_res * (double) scale;
135
136 sql = "SELECT RL2_WriteTiff(?, ?, ?, ?, ?, ?, ?, ?)";
137 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
138 if (ret != SQLITE_OK)
139 return 0;
140 sqlite3_reset (stmt);
141 sqlite3_clear_bindings (stmt);
142 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
143 sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
144 sqlite3_bind_int (stmt, 3, 1024);
145 sqlite3_bind_int (stmt, 4, 1024);
146 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
147 sqlite3_bind_blob (stmt, 5, blob, blob_size, free);
148 sqlite3_bind_double (stmt, 6, xx_res);
149 sqlite3_bind_double (stmt, 7, yy_res);
150 sqlite3_bind_text (stmt, 8, "NONE", 7, SQLITE_TRANSIENT);
151 ret = sqlite3_step (stmt);
152 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
153 {
154 if (sqlite3_column_int (stmt, 0) == 1)
155 retcode = 1;
156 }
157 sqlite3_finalize (stmt);
158 unlink (path);
159 if (!retcode)
160 fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
161 sqlite3_free (path);
162 return retcode;
163 }
164
165 static gaiaGeomCollPtr
get_center_point(sqlite3 * sqlite,const char * coverage)166 get_center_point (sqlite3 * sqlite, const char *coverage)
167 {
168 /* attempting to retrieve the Coverage's Center Point */
169 char *sql;
170 sqlite3_stmt *stmt;
171 gaiaGeomCollPtr geom = NULL;
172 int ret;
173
174 sql = sqlite3_mprintf ("SELECT MakePoint("
175 "extent_minx + ((extent_maxx - extent_minx) / 2.0), "
176 "extent_miny + ((extent_maxy - extent_miny) / 2.0)) "
177 "FROM raster_coverages WHERE coverage_name = %Q",
178 coverage);
179 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
180 sqlite3_free (sql);
181 if (ret != SQLITE_OK)
182 return NULL;
183
184 while (1)
185 {
186 /* scrolling the result set rows */
187 ret = sqlite3_step (stmt);
188 if (ret == SQLITE_DONE)
189 break; /* end of result set */
190 if (ret == SQLITE_ROW)
191 {
192 const unsigned char *blob = sqlite3_column_blob (stmt, 0);
193 int blob_sz = sqlite3_column_bytes (stmt, 0);
194 geom = gaiaFromSpatiaLiteBlobWkb (blob, blob_sz);
195 }
196 }
197 sqlite3_finalize (stmt);
198 return geom;
199 }
200
201 static int
do_export_image(sqlite3 * sqlite,const char * coverage,gaiaGeomCollPtr geom,double radius,const char * suffix)202 do_export_image (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom,
203 double radius, const char *suffix)
204 {
205 /* exporting a PNG/JPEG/TIFF/PDF image */
206 char *sql;
207 char *path;
208 sqlite3_stmt *stmt;
209 int ret;
210 unsigned char *blob;
211 int blob_size;
212 int retcode = 0;
213 const char *mime_type = "text/plain";
214
215 path = sqlite3_mprintf ("./%s_%1.0f%s", coverage, radius, suffix);
216
217 sql =
218 "SELECT RL2_GetMapImage(?, ST_Buffer(?, ?), 512, 512, 'default', ?, '#ffffff', 1, 80)";
219 ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
220 if (ret != SQLITE_OK)
221 return 0;
222 sqlite3_reset (stmt);
223 sqlite3_clear_bindings (stmt);
224 sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
225 gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
226 sqlite3_bind_blob (stmt, 2, blob, blob_size, free);
227 sqlite3_bind_double (stmt, 3, radius);
228 if (strcmp (suffix, ".png") == 0)
229 mime_type = "image/png";
230 if (strcmp (suffix, ".jpg") == 0)
231 mime_type = "image/jpeg";
232 if (strcmp (suffix, ".tif") == 0)
233 mime_type = "image/tiff";
234 if (strcmp (suffix, ".pdf") == 0)
235 mime_type = "application/x-pdf";
236 sqlite3_bind_text (stmt, 4, mime_type, strlen (mime_type),
237 SQLITE_TRANSIENT);
238 ret = sqlite3_step (stmt);
239 if (ret == SQLITE_DONE || ret == SQLITE_ROW)
240 {
241 if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
242 {
243 FILE *out;
244 blob = (unsigned char *) sqlite3_column_blob (stmt, 0);
245 blob_size = sqlite3_column_bytes (stmt, 0);
246 out = fopen (path, "wb");
247 if (out != NULL)
248 {
249 /* writing the output image */
250 if ((int) fwrite (blob, 1, blob_size, out) == blob_size)
251 retcode = 1;
252 fclose (out);
253 }
254 }
255 }
256 sqlite3_finalize (stmt);
257 if (!retcode)
258 fprintf (stderr, "ERROR: unable to GetMap \"%s\"\n", path);
259 unlink (path);
260 sqlite3_free (path);
261 return retcode;
262 }
263
264 static int
test_coverage(sqlite3 * sqlite,const char * prefix,unsigned char pixel,unsigned char compression,int * retcode)265 test_coverage (sqlite3 * sqlite, const char *prefix, unsigned char pixel,
266 unsigned char compression, int *retcode)
267 {
268 /* testing some DBMS Coverage */
269 int ret;
270 char *err_msg = NULL;
271 const char *coverage;
272 const char *sample_name;
273 const char *pixel_name;
274 unsigned char num_bands;
275 const char *compression_name;
276 int qlty;
277 char *sql;
278 int tile_size;
279 gaiaGeomCollPtr geom;
280 char *cov_name;
281 const char *file_path;
282
283 /* setting the file path */
284 if (strcmp (prefix, "noref-rgb") == 0)
285 file_path = "./rgb-striped.tif";
286 if (strcmp (prefix, "noref-gray") == 0)
287 file_path = "./gray-striped.tif";
288 if (strcmp (prefix, "noref-mono") == 0)
289 file_path = "./mono3s.tif";
290 if (strcmp (prefix, "noref-plt") == 0)
291 file_path = "plt-striped.tif";
292
293 /* setting the coverage name */
294 switch (pixel)
295 {
296 case RL2_PIXEL_RGB:
297 switch (compression)
298 {
299 case RL2_COMPRESSION_NONE:
300 coverage = "rgb_none_256";
301 break;
302 case RL2_COMPRESSION_PNG:
303 coverage = "rgb_png_256";
304 break;
305 case RL2_COMPRESSION_JPEG:
306 coverage = "rgb_jpeg_256";
307 break;
308 case RL2_COMPRESSION_LOSSY_WEBP:
309 coverage = "rgb_webp_256";
310 break;
311 case RL2_COMPRESSION_LOSSLESS_WEBP:
312 coverage = "rgb_llwebp_256";
313 break;
314 };
315 break;
316 case RL2_PIXEL_GRAYSCALE:
317 switch (compression)
318 {
319 case RL2_COMPRESSION_NONE:
320 coverage = "gray_none_256";
321 break;
322 case RL2_COMPRESSION_PNG:
323 coverage = "gray_png_256";
324 break;
325 case RL2_COMPRESSION_JPEG:
326 coverage = "gray_jpeg_256";
327 break;
328 case RL2_COMPRESSION_LOSSY_WEBP:
329 coverage = "gray_webp_256";
330 break;
331 case RL2_COMPRESSION_LOSSLESS_WEBP:
332 coverage = "gray_llwebp_256";
333 break;
334 };
335 break;
336 case RL2_PIXEL_MONOCHROME:
337 switch (compression)
338 {
339 case RL2_COMPRESSION_NONE:
340 coverage = "mono_none_256";
341 break;
342 case RL2_COMPRESSION_PNG:
343 coverage = "mono_png_256";
344 break;
345 case RL2_COMPRESSION_CCITTFAX4:
346 coverage = "mono_fax4_256";
347 break;
348 };
349 break;
350 case RL2_PIXEL_PALETTE:
351 switch (compression)
352 {
353 case RL2_COMPRESSION_NONE:
354 coverage = "plt_none_256";
355 break;
356 case RL2_COMPRESSION_PNG:
357 coverage = "plt_png_256";
358 break;
359 };
360 break;
361 };
362
363 /* preparing misc Coverage's parameters */
364 sample_name = "UINT8";
365 switch (pixel)
366 {
367 case RL2_PIXEL_RGB:
368 num_bands = 3;
369 pixel_name = "RGB";
370 break;
371 case RL2_PIXEL_GRAYSCALE:
372 num_bands = 1;
373 pixel_name = "GRAYSCALE";
374 break;
375 case RL2_PIXEL_MONOCHROME:
376 num_bands = 1;
377 pixel_name = "MONOCHROME";
378 sample_name = "1-BIT";
379 break;
380 case RL2_PIXEL_PALETTE:
381 num_bands = 1;
382 pixel_name = "PALETTE";
383 break;
384 };
385 switch (compression)
386 {
387 case RL2_COMPRESSION_NONE:
388 compression_name = "NONE";
389 qlty = 100;
390 break;
391 case RL2_COMPRESSION_PNG:
392 compression_name = "PNG";
393 qlty = 100;
394 break;
395 case RL2_COMPRESSION_JPEG:
396 compression_name = "JPEG";
397 qlty = 80;
398 break;
399 case RL2_COMPRESSION_LOSSY_WEBP:
400 compression_name = "WEBP";
401 qlty = 80;
402 break;
403 case RL2_COMPRESSION_LOSSLESS_WEBP:
404 compression_name = "LL_WEBP";
405 qlty = 100;
406 break;
407 case RL2_COMPRESSION_CCITTFAX4:
408 compression_name = "FAX4";
409 qlty = 100;
410 break;
411 };
412 tile_size = 256;
413
414 /* creating the DBMS Coverage */
415 cov_name = sqlite3_mprintf ("%s_%s", prefix, coverage);
416 sql = sqlite3_mprintf ("SELECT RL2_CreateCoverage("
417 "%Q, %Q, %Q, %d, %Q, %d, %d, %d, %d, %1.16f, %1.16f)",
418 cov_name, sample_name, pixel_name, num_bands,
419 compression_name, qlty, tile_size, tile_size, -1,
420 1.0, 1.0);
421 ret = execute_check (sqlite, sql);
422 sqlite3_free (sql);
423 if (ret != SQLITE_OK)
424 {
425 fprintf (stderr, "CreateCoverage \"%s\" error: %s\n", cov_name,
426 err_msg);
427 sqlite3_free (err_msg);
428 *retcode += -1;
429 return 0;
430 }
431
432 /* loading the not-referenced image */
433 sql = sqlite3_mprintf ("SELECT RL2_LoadRaster(%Q, %Q, 0, -1, 1, 1)",
434 cov_name, file_path);
435 ret = execute_check (sqlite, sql);
436 sqlite3_free (sql);
437 if (ret != SQLITE_OK)
438 {
439 fprintf (stderr, "LoadRaster \"%s\" error: %s\n", cov_name, err_msg);
440 sqlite3_free (err_msg);
441 *retcode += -4;
442 return 0;
443 }
444
445 /* building the Pyramid Levels */
446 sql = sqlite3_mprintf ("SELECT RL2_Pyramidize(%Q, NULL, 0, 1)", cov_name);
447 ret = execute_check (sqlite, sql);
448 sqlite3_free (sql);
449 if (ret != SQLITE_OK)
450 {
451 fprintf (stderr, "Pyramidize \"%s\" error: %s\n", cov_name, err_msg);
452 sqlite3_free (err_msg);
453 *retcode += -5;
454 return 0;
455 }
456
457 /* export tests */
458 geom = get_center_point (sqlite, cov_name);
459 if (geom == NULL)
460 {
461 *retcode += -6;
462 return 0;
463 }
464 if (!do_export_tiff (sqlite, cov_name, geom, 1))
465 {
466 *retcode += -7;
467 return 0;
468 }
469 if (!do_export_tiff (sqlite, cov_name, geom, 2))
470 {
471 *retcode += -8;
472 return 0;
473 }
474 if (!do_export_tiff (sqlite, cov_name, geom, 4))
475 {
476 *retcode += -9;
477 return 0;
478 }
479 if (!do_export_tiff (sqlite, cov_name, geom, 8))
480 {
481 *retcode += -10;
482 return 0;
483 }
484 if (!do_export_image (sqlite, cov_name, geom, 256, ".jpg"))
485 {
486 *retcode += -11;
487 return 0;
488 }
489 if (!do_export_image (sqlite, cov_name, geom, 1111, ".jpg"))
490 {
491 *retcode += -12;
492 return 0;
493 }
494 if (!do_export_image (sqlite, cov_name, geom, 256, ".png"))
495 {
496 *retcode += -13;
497 return 0;
498 }
499 if (!do_export_image (sqlite, cov_name, geom, 1111, ".png"))
500 {
501 *retcode += -14;
502 return 0;
503 }
504 if (!do_export_image (sqlite, cov_name, geom, 256, ".tif"))
505 {
506 *retcode += -15;
507 return 0;
508 }
509 if (!do_export_image (sqlite, cov_name, geom, 1111, ".tif"))
510 {
511 *retcode += -16;
512 return 0;
513 }
514 if (!do_export_image (sqlite, cov_name, geom, 256, ".pdf"))
515 {
516 *retcode += -17;
517 return 0;
518 }
519 if (!do_export_image (sqlite, cov_name, geom, 1111, ".pdf"))
520 {
521 *retcode += -18;
522 return 0;
523 }
524 gaiaFreeGeomColl (geom);
525 sqlite3_free (cov_name);
526
527 return 1;
528 }
529
530 static int
drop_coverage(sqlite3 * sqlite,const char * prefix,unsigned char pixel,unsigned char compression,int * retcode)531 drop_coverage (sqlite3 * sqlite, const char *prefix, unsigned char pixel,
532 unsigned char compression, int *retcode)
533 {
534 /* dropping some DBMS Coverage */
535 int ret;
536 char *err_msg = NULL;
537 const char *coverage;
538 char *cov_name;
539 char *sql;
540
541 /* setting the coverage name */
542 switch (pixel)
543 {
544 case RL2_PIXEL_RGB:
545 switch (compression)
546 {
547 case RL2_COMPRESSION_NONE:
548 coverage = "rgb_none_256";
549 break;
550 case RL2_COMPRESSION_PNG:
551 coverage = "rgb_png_256";
552 break;
553 case RL2_COMPRESSION_JPEG:
554 coverage = "rgb_jpeg_256";
555 break;
556 case RL2_COMPRESSION_LOSSY_WEBP:
557 coverage = "rgb_webp_256";
558 break;
559 case RL2_COMPRESSION_LOSSLESS_WEBP:
560 coverage = "rgb_llwebp_256";
561 break;
562 };
563 break;
564 case RL2_PIXEL_GRAYSCALE:
565 switch (compression)
566 {
567 case RL2_COMPRESSION_NONE:
568 coverage = "gray_none_256";
569 break;
570 case RL2_COMPRESSION_PNG:
571 coverage = "gray_png_256";
572 break;
573 case RL2_COMPRESSION_JPEG:
574 coverage = "gray_jpeg_256";
575 break;
576 case RL2_COMPRESSION_LOSSY_WEBP:
577 coverage = "gray_webp_256";
578 break;
579 case RL2_COMPRESSION_LOSSLESS_WEBP:
580 coverage = "gray_llwebp_256";
581 break;
582 };
583 break;
584 case RL2_PIXEL_MONOCHROME:
585 switch (compression)
586 {
587 case RL2_COMPRESSION_NONE:
588 coverage = "mono_none_256";
589 break;
590 case RL2_COMPRESSION_PNG:
591 coverage = "mono_png_256";
592 break;
593 case RL2_COMPRESSION_CCITTFAX4:
594 coverage = "mono_fax4_256";
595 break;
596 };
597 break;
598 case RL2_PIXEL_PALETTE:
599 switch (compression)
600 {
601 case RL2_COMPRESSION_NONE:
602 coverage = "plt_none_256";
603 break;
604 case RL2_COMPRESSION_PNG:
605 coverage = "plt_png_256";
606 break;
607 };
608 break;
609 };
610
611 /* dropping the DBMS Coverage */
612 cov_name = sqlite3_mprintf ("%s_%s", prefix, coverage);
613 sql = sqlite3_mprintf ("SELECT RL2_DropCoverage(%Q, 1)", cov_name);
614 ret = execute_check (sqlite, sql);
615 sqlite3_free (sql);
616 if (ret != SQLITE_OK)
617 {
618 fprintf (stderr, "DropCoverage \"%s\" error: %s\n", cov_name,
619 err_msg);
620 sqlite3_free (err_msg);
621 *retcode += -1;
622 sqlite3_free (cov_name);
623 return 0;
624 }
625 sqlite3_free (cov_name);
626
627 return 1;
628 }
629
630 int
main(int argc,char * argv[])631 main (int argc, char *argv[])
632 {
633 int result = 0;
634 int ret;
635 char *err_msg = NULL;
636 sqlite3 *db_handle;
637 void *cache = spatialite_alloc_connection ();
638 char *old_SPATIALITE_SECURITY_ENV = NULL;
639
640 if (argc > 1 || argv[0] == NULL)
641 argc = 1; /* silencing stupid compiler warnings */
642
643 old_SPATIALITE_SECURITY_ENV = getenv ("SPATIALITE_SECURITY");
644 #ifdef _WIN32
645 putenv ("SPATIALITE_SECURITY=relaxed");
646 #else /* not WIN32 */
647 setenv ("SPATIALITE_SECURITY", "relaxed", 1);
648 #endif
649
650 /* opening and initializing the "memory" test DB */
651 ret = sqlite3_open_v2 (":memory:", &db_handle,
652 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
653 if (ret != SQLITE_OK)
654 {
655 fprintf (stderr, "sqlite3_open_v2() error: %s\n",
656 sqlite3_errmsg (db_handle));
657 return -1;
658 }
659 spatialite_init_ex (db_handle, cache, 0);
660 rl2_init (db_handle, 0);
661 ret =
662 sqlite3_exec (db_handle, "SELECT InitSpatialMetadata(1)", NULL, NULL,
663 &err_msg);
664 if (ret != SQLITE_OK)
665 {
666 fprintf (stderr, "InitSpatialMetadata() error: %s\n", err_msg);
667 sqlite3_free (err_msg);
668 return -2;
669 }
670 ret =
671 sqlite3_exec (db_handle, "SELECT CreateRasterCoveragesTable()", NULL,
672 NULL, &err_msg);
673 if (ret != SQLITE_OK)
674 {
675 fprintf (stderr, "CreateRasterCoveragesTable() error: %s\n", err_msg);
676 sqlite3_free (err_msg);
677 return -3;
678 }
679
680 /* RGB tests */
681 ret = -100;
682 if (!test_coverage
683 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_NONE, &ret))
684 return ret;
685 ret = -120;
686 if (!test_coverage
687 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_PNG, &ret))
688 return ret;
689 ret = -140;
690 if (!test_coverage
691 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_JPEG, &ret))
692 return ret;
693 ret = -160;
694 if (!test_coverage
695 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_LOSSY_WEBP,
696 &ret))
697 return ret;
698 ret = -170;
699 if (!test_coverage
700 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_LOSSLESS_WEBP,
701 &ret))
702 return ret;
703
704 /* GRAYSCALE tests */
705 ret = -300;
706 if (!test_coverage
707 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_NONE,
708 &ret))
709 return ret;
710 ret = -320;
711 if (!test_coverage
712 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_PNG,
713 &ret))
714 return ret;
715 ret = -340;
716 if (!test_coverage
717 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_JPEG,
718 &ret))
719 return ret;
720 ret = -360;
721 if (!test_coverage
722 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE,
723 RL2_COMPRESSION_LOSSY_WEBP, &ret))
724 return ret;
725 ret = -380;
726 if (!test_coverage
727 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE,
728 RL2_COMPRESSION_LOSSLESS_WEBP, &ret))
729 return ret;
730
731 /* MONOCHROME tests */
732 ret = -500;
733 if (!test_coverage
734 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME, RL2_COMPRESSION_NONE,
735 &ret))
736 return ret;
737 ret = -520;
738 if (!test_coverage
739 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME,
740 RL2_COMPRESSION_CCITTFAX4, &ret))
741 return ret;
742 ret = -540;
743 if (!test_coverage
744 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME, RL2_COMPRESSION_PNG,
745 &ret))
746 return ret;
747
748 /* PALETTE tests */
749 ret = -700;
750 if (!test_coverage
751 (db_handle, "noref-plt", RL2_PIXEL_PALETTE, RL2_COMPRESSION_NONE, &ret))
752 return ret;
753 ret = -720;
754 if (!test_coverage
755 (db_handle, "noref-plt", RL2_PIXEL_PALETTE, RL2_COMPRESSION_PNG, &ret))
756 return ret;
757
758 /* dropping all RGB Coverages */
759 ret = -200;
760 if (!drop_coverage
761 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_NONE, &ret))
762 return ret;
763 ret = -210;
764 if (!drop_coverage
765 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_PNG, &ret))
766 return ret;
767 ret = -220;
768 if (!drop_coverage
769 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_JPEG, &ret))
770 return ret;
771 ret = -230;
772 if (!drop_coverage
773 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_LOSSY_WEBP,
774 &ret))
775 return ret;
776 ret = -240;
777 if (!drop_coverage
778 (db_handle, "noref-rgb", RL2_PIXEL_RGB, RL2_COMPRESSION_LOSSLESS_WEBP,
779 &ret))
780 return ret;
781
782 /* dropping all GRAYSCALE Coverages */
783 ret = -400;
784 if (!drop_coverage
785 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_NONE,
786 &ret))
787 return ret;
788 ret = -410;
789 if (!drop_coverage
790 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_PNG,
791 &ret))
792 return ret;
793 ret = -420;
794 if (!drop_coverage
795 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE, RL2_COMPRESSION_JPEG,
796 &ret))
797 return ret;
798 ret = -430;
799 if (!drop_coverage
800 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE,
801 RL2_COMPRESSION_LOSSY_WEBP, &ret))
802 return ret;
803 ret = -440;
804 if (!drop_coverage
805 (db_handle, "noref-gray", RL2_PIXEL_GRAYSCALE,
806 RL2_COMPRESSION_LOSSLESS_WEBP, &ret))
807 return ret;
808
809 /* dropping all MONOCHROME Coverages */
810 ret = -600;
811 if (!drop_coverage
812 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME, RL2_COMPRESSION_NONE,
813 &ret))
814 return ret;
815 ret = -610;
816 if (!drop_coverage
817 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME,
818 RL2_COMPRESSION_CCITTFAX4, &ret))
819 return ret;
820 ret = -620;
821 if (!drop_coverage
822 (db_handle, "noref-mono", RL2_PIXEL_MONOCHROME, RL2_COMPRESSION_PNG,
823 &ret))
824 return ret;
825
826 /* dropping all PALETTE Coverages */
827 ret = -800;
828 if (!drop_coverage
829 (db_handle, "noref-plt", RL2_PIXEL_PALETTE, RL2_COMPRESSION_NONE, &ret))
830 return ret;
831 ret = -810;
832 if (!drop_coverage
833 (db_handle, "noref-plt", RL2_PIXEL_PALETTE, RL2_COMPRESSION_PNG, &ret))
834 return ret;
835
836 /* closing the DB */
837 sqlite3_close (db_handle);
838 spatialite_shutdown ();
839 if (old_SPATIALITE_SECURITY_ENV)
840 {
841 #ifdef _WIN32
842 char *env = sqlite3_mprintf ("SPATIALITE_SECURITY=%s",
843 old_SPATIALITE_SECURITY_ENV);
844 putenv (env);
845 sqlite3_free (env);
846 #else /* not WIN32 */
847 setenv ("SPATIALITE_SECURITY", old_SPATIALITE_SECURITY_ENV, 1);
848 #endif
849 }
850 else
851 {
852 #ifdef _WIN32
853 putenv ("SPATIALITE_SECURITY=");
854 #else /* not WIN32 */
855 unsetenv ("SPATIALITE_SECURITY");
856 #endif
857 }
858 return result;
859 }
860