PostGIS  2.4.9dev-r@@SVN_REVISION@@

◆ test_raster_wkb()

static void test_raster_wkb ( )
static

Definition at line 28 of file cu_raster_wkb.c.

References ovdump::band, cu_free_raster(), ES_NONE, FALSE, free(), PT_16BSI, PT_1BB, PT_8BSI, PT_8BUI, rtrowdump::raster, raster_wkb_suite_setup(), rt_band_get_ext_band_num(), rt_band_get_ext_path(), rt_band_get_hasnodata_flag(), rt_band_get_nodata(), rt_band_get_pixel(), rt_band_get_pixtype(), rt_band_is_offline(), rt_raster_deserialize(), rt_raster_from_hexwkb(), rt_raster_get_band(), rt_raster_get_height(), rt_raster_get_num_bands(), rt_raster_get_srid(), rt_raster_get_width(), rt_raster_get_x_offset(), rt_raster_get_x_scale(), rt_raster_get_x_skew(), rt_raster_get_y_offset(), rt_raster_get_y_scale(), rt_raster_get_y_skew(), rt_raster_serialize(), and rt_raster_to_hexwkb().

Referenced by raster_wkb_suite_setup().

28  {
29  /* will use default allocators and message handlers */
30  rt_raster raster = NULL;
31  const char *hexwkb = NULL;
32  const char *out = NULL;
33  uint32_t len = 0;
34  int i = 0;
35 
36  /* ------------------------------------------------------ */
37  /* No bands, 7x8 - little endian */
38  /* ------------------------------------------------------ */
39 
40  hexwkb =
41 "01" /* little endian (uint8 ndr) */
42 "0000" /* version (uint16 0) */
43 "0000" /* nBands (uint16 0) */
44 "000000000000F03F" /* scaleX (float64 1) */
45 "0000000000000040" /* scaleY (float64 2) */
46 "0000000000000840" /* ipX (float64 3) */
47 "0000000000001040" /* ipY (float64 4) */
48 "0000000000001440" /* skewX (float64 5) */
49 "0000000000001840" /* skewY (float64 6) */
50 "0A000000" /* SRID (int32 10) */
51 "0700" /* width (uint16 7) */
52 "0800" /* height (uint16 8) */
53  ;
54 
55  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
56  CU_ASSERT(raster != NULL);
57  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 0);
58  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
59  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
60  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
61  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
62  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
63  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
64  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
65  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 7);
66  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 8);
67 
68  out = rt_raster_to_hexwkb(raster, FALSE, &len);
69 /*
70  printf(" in hexwkb len: %d\n", strlen(hexwkb));
71  printf("out hexwkb len: %d\n", len);
72  printf(" in hexwkb: %s\n", hexwkb);
73  printf("out hexwkb: %s\n", out);
74 */
75  CU_ASSERT_EQUAL(len, strlen(hexwkb));
76 /* would depend on machine endian...
77  CU_ASSERT_STRING_EQUAL(hexwkb, out);
78 */
79  free((/*no const*/ void*)out);
80 
81  {
82  void *serialized;
83  rt_raster rast2;
84 
85  serialized = rt_raster_serialize(raster);
86  rast2 = rt_raster_deserialize(serialized, FALSE);
87 
88  cu_free_raster(rast2);
89  free(serialized);
90  }
91 
92  cu_free_raster(raster);
93 
94  /* ------------------------------------------------------ */
95  /* No bands, 7x8 - big endian */
96  /* ------------------------------------------------------ */
97 
98  hexwkb =
99 "00" /* big endian (uint8 xdr) */
100 "0000" /* version (uint16 0) */
101 "0000" /* nBands (uint16 0) */
102 "3FF0000000000000" /* scaleX (float64 1) */
103 "4000000000000000" /* scaleY (float64 2) */
104 "4008000000000000" /* ipX (float64 3) */
105 "4010000000000000" /* ipY (float64 4) */
106 "4014000000000000" /* skewX (float64 5) */
107 "4018000000000000" /* skewY (float64 6) */
108 "0000000A" /* SRID (int32 10) */
109 "0007" /* width (uint16 7) */
110 "0008" /* height (uint16 8) */
111  ;
112 
113  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
114  CU_ASSERT(raster != NULL);
115  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 0);
116  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
117  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
118  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
119  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
120  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
121  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
122  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
123  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 7);
124  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 8);
125 
126  out = rt_raster_to_hexwkb(raster, FALSE, &len);
127 /*
128  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
129  printf("out hexwkb len: %u\n", len);
130  printf(" in hexwkb: %s\n", hexwkb);
131  printf("out hexwkb: %s\n", out);
132 */
133  CU_ASSERT_EQUAL(len, strlen(hexwkb));
134 /* would depend on machine endian...
135  CU_ASSERT_STRING_EQUAL(hexwkb, out);
136 */
137 
138  cu_free_raster(raster);
139  free((/*no const*/ void*)out);
140 
141  /* ------------------------------------------------------ */
142  /* 1x1, little endian, band0(1bb) */
143  /* ------------------------------------------------------ */
144 
145  hexwkb =
146 "01" /* little endian (uint8 ndr) */
147 "0000" /* version (uint16 0) */
148 "0100" /* nBands (uint16 1) */
149 "000000000000F03F" /* scaleX (float64 1) */
150 "0000000000000040" /* scaleY (float64 2) */
151 "0000000000000840" /* ipX (float64 3) */
152 "0000000000001040" /* ipY (float64 4) */
153 "0000000000001440" /* skewX (float64 5) */
154 "0000000000001840" /* skewY (float64 6) */
155 "0A000000" /* SRID (int32 10) */
156 "0100" /* width (uint16 1) */
157 "0100" /* height (uint16 1) */
158 "40" /* First band type (1BB, in memory, hasnodata) */
159 "00" /* nodata value (0) */
160 "01" /* pix(0,0) == 1 */
161  ;
162 
163  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
164  CU_ASSERT(raster != NULL);
165  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
166  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
167  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
168  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
169  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
170  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
171  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
172  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
173  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 1);
174  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 1);
175  {
176  double val;
177  int failure;
178  rt_band band = rt_raster_get_band(raster, 0);
179  CU_ASSERT(band != NULL);
180  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_1BB);
181  CU_ASSERT(!rt_band_is_offline(band));
182  CU_ASSERT(rt_band_get_hasnodata_flag(band));
183  rt_band_get_nodata(band, &val);
184  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
185  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
186  CU_ASSERT_EQUAL(failure, ES_NONE);
187  CU_ASSERT_DOUBLE_EQUAL(val, 1, DBL_EPSILON);
188  }
189 
190  out = rt_raster_to_hexwkb(raster, FALSE, &len);
191 /*
192  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
193  printf("out hexwkb len: %u\n", len);
194 */
195  CU_ASSERT_EQUAL(len, strlen(hexwkb));
196 /* would depend on machine endian...
197  CU_ASSERT_STRING_EQUAL(hexwkb, out);
198 */
199 
200  cu_free_raster(raster);
201  free((/*no const*/ void*)out);
202 
203  /* ------------------------------------------------------ */
204  /* 3x2, big endian, band0(8BSI) */
205  /* ------------------------------------------------------ */
206 
207  hexwkb =
208 "01" /* little endian (uint8 ndr) */
209 "0000" /* version (uint16 0) */
210 "0100" /* nBands (uint16 1) */
211 "000000000000F03F" /* scaleX (float64 1) */
212 "0000000000000040" /* scaleY (float64 2) */
213 "0000000000000840" /* ipX (float64 3) */
214 "0000000000001040" /* ipY (float64 4) */
215 "0000000000001440" /* skewX (float64 5) */
216 "0000000000001840" /* skewY (float64 6) */
217 "0A000000" /* SRID (int32 10) */
218 "0300" /* width (uint16 3) */
219 "0200" /* height (uint16 2) */
220 "43" /* First band type (8BSI, in memory, hasnodata) */
221 "FF" /* nodata value (-1) */
222 "FF" /* pix(0,0) == -1 */
223 "00" /* pix(1,0) == 0 */
224 "01" /* pix(2,0) == 1 */
225 "7F" /* pix(0,1) == 127 */
226 "0A" /* pix(1,1) == 10 */
227 "02" /* pix(2,1) == 2 */
228  ;
229 
230  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
231  CU_ASSERT(raster != NULL);
232  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
233  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
234  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
235  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
236  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
237  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
238  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
239  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
240  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 3);
241  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 2);
242  {
243  double val;
244  int failure;
245 
246  rt_band band = rt_raster_get_band(raster, 0);
247  CU_ASSERT(band != NULL);
248  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_8BSI);
249  CU_ASSERT(!rt_band_is_offline(band));
250  CU_ASSERT(rt_band_get_hasnodata_flag(band));
251  rt_band_get_nodata(band, &val);
252  CU_ASSERT_DOUBLE_EQUAL(val, -1, DBL_EPSILON);
253 
254  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
255  CU_ASSERT_EQUAL(failure, ES_NONE);
256  CU_ASSERT_DOUBLE_EQUAL(val, -1, DBL_EPSILON);
257 
258  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
259  CU_ASSERT_EQUAL(failure, ES_NONE);
260  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
261 
262  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
263  CU_ASSERT_EQUAL(failure, ES_NONE);
264  CU_ASSERT_DOUBLE_EQUAL(val, 1, DBL_EPSILON);
265 
266  failure = rt_band_get_pixel(band, 0, 1, &val, NULL);
267  CU_ASSERT_EQUAL(failure, ES_NONE);
268  CU_ASSERT_DOUBLE_EQUAL(val, 127, DBL_EPSILON);
269 
270  failure = rt_band_get_pixel(band, 1, 1, &val, NULL);
271  CU_ASSERT_EQUAL(failure, ES_NONE);
272  CU_ASSERT_DOUBLE_EQUAL(val, 10, DBL_EPSILON);
273 
274  failure = rt_band_get_pixel(band, 2, 1, &val, NULL);
275  CU_ASSERT_EQUAL(failure, ES_NONE);
276  CU_ASSERT_DOUBLE_EQUAL(val, 2, DBL_EPSILON);
277  }
278 
279  out = rt_raster_to_hexwkb(raster, FALSE, &len);
280 /*
281  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
282  printf("out hexwkb len: %u\n", len);
283 */
284  CU_ASSERT_EQUAL(len, strlen(hexwkb));
285 /* would depend on machine endian...
286  CU_ASSERT_STRING_EQUAL(hexwkb, out);
287 */
288 
289  free((/*no const*/ void*)out);
290 
291  {
292  void *serialized;
293  rt_raster rast2;
294 
295  serialized = rt_raster_serialize(raster);
296  rast2 = rt_raster_deserialize(serialized, FALSE);
297 
298  cu_free_raster(rast2);
299  free(serialized);
300 
301  }
302 
303  cu_free_raster(raster);
304 
305  /* ------------------------------------------------------ */
306  /* 3x2, little endian, band0(16BSI) */
307  /* ------------------------------------------------------ */
308 
309  hexwkb =
310 "01" /* little endian (uint8 ndr) */
311 "0000" /* version (uint16 0) */
312 "0100" /* nBands (uint16 1) */
313 "000000000000F03F" /* scaleX (float64 1) */
314 "0000000000000040" /* scaleY (float64 2) */
315 "0000000000000840" /* ipX (float64 3) */
316 "0000000000001040" /* ipY (float64 4) */
317 "0000000000001440" /* skewX (float64 5) */
318 "0000000000001840" /* skewY (float64 6) */
319 "0A000000" /* SRID (int32 10) */
320 "0300" /* width (uint16 3) */
321 "0200" /* height (uint16 2) */
322 "05" /* First band type (16BSI, in memory) */
323 "FFFF" /* nodata value (-1) */
324 "FFFF" /* pix(0,0) == -1 */
325 "0000" /* pix(1,0) == 0 */
326 "F0FF" /* pix(2,0) == -16 */
327 "7F00" /* pix(0,1) == 127 */
328 "0A00" /* pix(1,1) == 10 */
329 "0200" /* pix(2,1) == 2 */
330  ;
331 
332  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
333  CU_ASSERT(raster != NULL);
334  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
335  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
336  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
337  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
338  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
339  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
340  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
341  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
342  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 3);
343  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 2);
344  {
345  double val;
346  int failure;
347  rt_band band = rt_raster_get_band(raster, 0);
348  CU_ASSERT(band != NULL);
349  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_16BSI);
350  CU_ASSERT(!rt_band_is_offline(band));
351  CU_ASSERT(!rt_band_get_hasnodata_flag(band));
352 
353  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
354  CU_ASSERT_EQUAL(failure, ES_NONE);
355  CU_ASSERT_DOUBLE_EQUAL(val, -1, DBL_EPSILON);
356 
357  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
358  CU_ASSERT_EQUAL(failure, ES_NONE);
359  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
360 
361  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
362  CU_ASSERT_EQUAL(failure, ES_NONE);
363  CU_ASSERT_DOUBLE_EQUAL(val, -16, DBL_EPSILON);
364 
365  failure = rt_band_get_pixel(band, 0, 1, &val, NULL);
366  CU_ASSERT_EQUAL(failure, ES_NONE);
367  CU_ASSERT_DOUBLE_EQUAL(val, 127, DBL_EPSILON);
368 
369  failure = rt_band_get_pixel(band, 1, 1, &val, NULL);
370  CU_ASSERT_EQUAL(failure, ES_NONE);
371  CU_ASSERT_DOUBLE_EQUAL(val, 10, DBL_EPSILON);
372 
373  failure = rt_band_get_pixel(band, 2, 1, &val, NULL);
374  CU_ASSERT_EQUAL(failure, ES_NONE);
375  CU_ASSERT_DOUBLE_EQUAL(val, 2, DBL_EPSILON);
376  }
377 
378  out = rt_raster_to_hexwkb(raster, FALSE, &len);
379 /*
380  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
381  printf("out hexwkb len: %u\n", len);
382 */
383  CU_ASSERT_EQUAL(len, strlen(hexwkb));
384 /* would depend on machine endian
385  CU_ASSERT_STRING_EQUAL(hexwkb, out);
386 */
387 
388  cu_free_raster(raster);
389  free((/*no const*/ void*)out);
390 
391  /* ------------------------------------------------------ */
392  /* 3x2, big endian, band0(16BSI) */
393  /* ------------------------------------------------------ */
394 
395  hexwkb =
396 "00" /* big endian (uint8 xdr) */
397 "0000" /* version (uint16 0) */
398 "0001" /* nBands (uint16 1) */
399 "3FF0000000000000" /* scaleX (float64 1) */
400 "4000000000000000" /* scaleY (float64 2) */
401 "4008000000000000" /* ipX (float64 3) */
402 "4010000000000000" /* ipY (float64 4) */
403 "4014000000000000" /* skewX (float64 5) */
404 "4018000000000000" /* skewY (float64 6) */
405 "0000000A" /* SRID (int32 10) */
406 "0003" /* width (uint16 3) */
407 "0002" /* height (uint16 2) */
408 "05" /* First band type (16BSI, in memory) */
409 "FFFF" /* nodata value (-1) */
410 "FFFF" /* pix(0,0) == -1 */
411 "0000" /* pix(1,0) == 0 */
412 "FFF0" /* pix(2,0) == -16 */
413 "007F" /* pix(0,1) == 127 */
414 "000A" /* pix(1,1) == 10 */
415 "0002" /* pix(2,1) == 2 */
416  ;
417 
418  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
419  CU_ASSERT(raster != NULL);
420  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
421  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
422  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
423  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
424  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
425  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
426  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
427  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
428  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 3);
429  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 2);
430  {
431  double val;
432  int failure;
433  rt_band band = rt_raster_get_band(raster, 0);
434  CU_ASSERT(band != NULL);
435  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_16BSI);
436  CU_ASSERT(!rt_band_is_offline(band));
437  CU_ASSERT(!rt_band_get_hasnodata_flag(band));
438 
439  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
440  CU_ASSERT_EQUAL(failure, ES_NONE);
441  CU_ASSERT_DOUBLE_EQUAL(val, -1, DBL_EPSILON);
442 
443  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
444  CU_ASSERT_EQUAL(failure, ES_NONE);
445  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
446 
447  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
448  CU_ASSERT_EQUAL(failure, ES_NONE);
449  CU_ASSERT_DOUBLE_EQUAL(val, -16, DBL_EPSILON);
450 
451  failure = rt_band_get_pixel(band, 0, 1, &val, NULL);
452  CU_ASSERT_EQUAL(failure, ES_NONE);
453  CU_ASSERT_DOUBLE_EQUAL(val, 127, DBL_EPSILON);
454 
455  failure = rt_band_get_pixel(band, 1, 1, &val, NULL);
456  CU_ASSERT_EQUAL(failure, ES_NONE);
457  CU_ASSERT_DOUBLE_EQUAL(val, 10, DBL_EPSILON);
458 
459  failure = rt_band_get_pixel(band, 2, 1, &val, NULL);
460  CU_ASSERT_EQUAL(failure, ES_NONE);
461  CU_ASSERT_DOUBLE_EQUAL(val, 2, DBL_EPSILON);
462  }
463 
464  out = rt_raster_to_hexwkb(raster, FALSE, &len);
465 /*
466  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
467  printf("out hexwkb len: %u\n", len);
468 */
469  CU_ASSERT_EQUAL(len, strlen(hexwkb));
470 /* would depend on machine endian
471  CU_ASSERT_STRING_EQUAL(hexwkb, out);
472 */
473 
474  cu_free_raster(raster);
475  free((/*no const*/ void*)out);
476 
477  /* ------------------------------------------------------ */
478  /* 3x2, bit endian, band0(16BSI ext: 3;/tmp/t.tif) */
479  /* ------------------------------------------------------ */
480 
481  hexwkb =
482 "00" /* big endian (uint8 xdr) */
483 "0000" /* version (uint16 0) */
484 "0001" /* nBands (uint16 1) */
485 "3FF0000000000000" /* scaleX (float64 1) */
486 "4000000000000000" /* scaleY (float64 2) */
487 "4008000000000000" /* ipX (float64 3) */
488 "4010000000000000" /* ipY (float64 4) */
489 "4014000000000000" /* skewX (float64 5) */
490 "4018000000000000" /* skewY (float64 6) */
491 "0000000A" /* SRID (int32 10) */
492 "0003" /* width (uint16 3) */
493 "0002" /* height (uint16 2) */
494 "C5" /* First band type (16BSI, on disk, hasnodata) */
495 "FFFF" /* nodata value (-1) */
496 "03" /* ext band num == 3 */
497 /* ext band path == /tmp/t.tif */
498 "2F746D702F742E74696600"
499  ;
500 
501  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
502  CU_ASSERT(raster != NULL);
503  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
504  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 1, DBL_EPSILON);
505  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), 2, DBL_EPSILON);
506  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3, DBL_EPSILON);
507  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 4, DBL_EPSILON);
508  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 5, DBL_EPSILON);
509  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 6, DBL_EPSILON);
510  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 10);
511  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 3);
512  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 2);
513  {
514  double val;
515  uint8_t bandnum = 0;
516  rt_band band = rt_raster_get_band(raster, 0);
517  CU_ASSERT(band != NULL);
518  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_16BSI);
519  CU_ASSERT(rt_band_is_offline(band));
520  CU_ASSERT(rt_band_get_hasnodata_flag(band));
521  rt_band_get_nodata(band, &val);
522  CU_ASSERT_DOUBLE_EQUAL(val, -1, DBL_EPSILON);
523  CU_ASSERT_STRING_EQUAL(rt_band_get_ext_path(band), "/tmp/t.tif");
524  CU_ASSERT_EQUAL(rt_band_get_ext_band_num(band, &bandnum), ES_NONE);
525  CU_ASSERT_EQUAL(bandnum, 3);
526  }
527 
528  out = rt_raster_to_hexwkb(raster, FALSE, &len);
529 /*
530  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
531  printf("out hexwkb len: %u\n", len);
532 */
533  CU_ASSERT_EQUAL(len, strlen(hexwkb));
534 /* would depend on machine endian
535  CU_ASSERT_STRING_EQUAL(hexwkb, out);
536 */
537 
538  cu_free_raster(raster);
539  free((/*no const*/ void*)out);
540 
541  /* ------------------------------------------------------ */
542  /* 1x3, little endian, band0 16BSI, nodata 1, srid -1 */
543  /* ------------------------------------------------------ */
544 
545  hexwkb =
546 "01" /* little endian (uint8 ndr) */
547 "0000" /* version (uint16 0) */
548 "0100" /* nBands (uint16 1) */
549 "0000000000805640" /* scaleX (float64 90.0) */
550 "00000000008056C0" /* scaleY (float64 -90.0) */
551 "000000001C992D41" /* ipX (float64 969870.0) */
552 "00000000E49E2341" /* ipY (float64 642930.0) */
553 "0000000000000000" /* skewX (float64 0) */
554 "0000000000000000" /* skewY (float64 0) */
555 "FFFFFFFF" /* SRID (int32 -1) */
556 "0300" /* width (uint16 3) */
557 "0100" /* height (uint16 1) */
558 "45" /* First band type (16BSI, in memory, hasnodata) */
559 "0100" /* nodata value (1) */
560 "0100" /* pix(0,0) == 1 */
561 "B401" /* pix(1,0) == 436 */
562 "AF01" /* pix(2,0) == 431 */
563  ;
564 
565  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
566  CU_ASSERT(raster != NULL);
567  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 1);
568  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 90, DBL_EPSILON);
569  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), -90, DBL_EPSILON);
570  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 969870.0, DBL_EPSILON);
571  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 642930.0, DBL_EPSILON);
572  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 0, DBL_EPSILON);
573  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 0, DBL_EPSILON);
574  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 0);
575  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 3);
576  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 1);
577  {
578  double val;
579  int failure;
580  rt_band band = rt_raster_get_band(raster, 0);
581  CU_ASSERT(band != NULL);
582  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_16BSI);
583  CU_ASSERT(!rt_band_is_offline(band));
584  CU_ASSERT(rt_band_get_hasnodata_flag(band));
585  rt_band_get_nodata(band, &val);
586  CU_ASSERT_DOUBLE_EQUAL(val, 1, DBL_EPSILON);
587 
588  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
589  CU_ASSERT_EQUAL(failure, ES_NONE);
590  CU_ASSERT_DOUBLE_EQUAL(val, 1, DBL_EPSILON);
591 
592  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
593  CU_ASSERT_EQUAL(failure, ES_NONE);
594  CU_ASSERT_DOUBLE_EQUAL(val, 436, DBL_EPSILON);
595 
596  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
597  CU_ASSERT_EQUAL(failure, ES_NONE);
598  CU_ASSERT_DOUBLE_EQUAL(val, 431, DBL_EPSILON);
599  }
600 
601  out = rt_raster_to_hexwkb(raster, FALSE, &len);
602 /*
603  printf(" in hexwkb len: %d\n", strlen(hexwkb));
604  printf("out hexwkb len: %d\n", len);
605  printf(" in hexwkb: %s\n", hexwkb);
606  printf("out hexwkb: %s\n", out);
607 */
608  CU_ASSERT_EQUAL(len, strlen(hexwkb));
609 /* would depend on machine endian
610  CU_ASSERT_STRING_EQUAL(hexwkb, out);
611 */
612  free((/*no const*/ void*)out);
613 
614  {
615  void *serialized;
616  rt_raster rast2;
617 
618  serialized = rt_raster_serialize(raster);
619  rast2 = rt_raster_deserialize(serialized, FALSE);
620 
621  cu_free_raster(rast2);
622  free(serialized);
623  }
624 
625  cu_free_raster(raster);
626 
627  /* ------------------------------------------------------ */
628  /* 5x5, little endian, 3 x band 8BUI (RGB), */
629  /* nodata 0, srid -1 */
630  /* Test case completes regress/bug_test_car5.sql */
631  /* Test case repeated 4 times to mimic 4 tiles insertion */
632  /* ------------------------------------------------------ */
633  for (i = 0; i < 5; ++i)
634  {
635 
636  hexwkb =
637 "01" /* little endian (uint8 ndr) */
638 "0000" /* version (uint16 0) */
639 "0300" /* nBands (uint16 3) */
640 "9A9999999999A93F" /* scaleX (float64 0.050000) */
641 "9A9999999999A9BF" /* scaleY (float64 -0.050000) */
642 "000000E02B274A41" /* ipX (float64 3427927.750000) */
643 "0000000077195641" /* ipY (float64 5793244.000000) */
644 "0000000000000000" /* skewX (float64 0.000000) */
645 "0000000000000000" /* skewY (float64 0.000000) */
646 "FFFFFFFF" /* srid (int32 -1) */
647 "0500" /* width (uint16 5) */
648 "0500" /* height (uint16 5) */
649 "44" /* 1st band pixel type (8BUI, in memory, hasnodata) */
650 "00" /* 1st band nodata 0 */
651 "FDFEFDFEFEFDFEFEFDF9FAFEFEFCF9FBFDFEFEFDFCFAFEFEFE" /* 1st band pixels */
652 "44" /* 2nd band pixel type (8BUI, in memory, hasnodata) */
653 "00" /* 2nd band nodata 0 */
654 "4E627AADD16076B4F9FE6370A9F5FE59637AB0E54F58617087" /* 2nd band pixels */
655 "44" /* 3rd band pixel type (8BUI, in memory, hasnodata) */
656 "00" /* 3rd band nodata 0 */
657 "46566487A1506CA2E3FA5A6CAFFBFE4D566DA4CB3E454C5665" /* 3rd band pixels */
658 ;
659 
660  raster = rt_raster_from_hexwkb(hexwkb, strlen(hexwkb));
661  CU_ASSERT(raster != NULL);
662  CU_ASSERT_EQUAL(rt_raster_get_num_bands(raster), 3);
663  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_scale(raster), 0.05, DBL_EPSILON);
664  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_scale(raster), -0.05, DBL_EPSILON);
665  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_offset(raster), 3427927.75, DBL_EPSILON);
666  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_offset(raster), 5793244.00, DBL_EPSILON);
667  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_x_skew(raster), 0.0, DBL_EPSILON);
668  CU_ASSERT_DOUBLE_EQUAL(rt_raster_get_y_skew(raster), 0.0, DBL_EPSILON);
669  CU_ASSERT_EQUAL(rt_raster_get_srid(raster), 0);
670  CU_ASSERT_EQUAL(rt_raster_get_width(raster), 5);
671  CU_ASSERT_EQUAL(rt_raster_get_height(raster), 5);
672  {
673  /* Test 1st band */
674  double val;
675  int failure;
676  rt_band band = rt_raster_get_band(raster, 0);
677  CU_ASSERT(band != NULL);
678  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_8BUI);
679  CU_ASSERT(!rt_band_is_offline(band));
680  CU_ASSERT(rt_band_get_hasnodata_flag(band));
681  rt_band_get_nodata(band, &val);
682  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
683 
684  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
685  CU_ASSERT_EQUAL(failure, ES_NONE);
686  CU_ASSERT_DOUBLE_EQUAL(val, 253, DBL_EPSILON);
687 
688  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
689  CU_ASSERT_EQUAL(failure, ES_NONE);
690  CU_ASSERT_DOUBLE_EQUAL(val, 254, DBL_EPSILON);
691 
692  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
693  CU_ASSERT_EQUAL(failure, ES_NONE);
694  CU_ASSERT_DOUBLE_EQUAL(val, 253, DBL_EPSILON);
695 
696  failure = rt_band_get_pixel(band, 3, 0, &val, NULL);
697  CU_ASSERT_EQUAL(failure, ES_NONE);
698  CU_ASSERT_DOUBLE_EQUAL(val, 254, DBL_EPSILON);
699 
700  failure = rt_band_get_pixel(band, 4, 0, &val, NULL);
701  CU_ASSERT_EQUAL(failure, ES_NONE);
702  CU_ASSERT_DOUBLE_EQUAL(val, 254, DBL_EPSILON);
703  }
704 
705  {
706  /* Test 2nd band */
707  double val;
708  int failure;
709  rt_band band = rt_raster_get_band(raster, 1);
710  CU_ASSERT(band != NULL);
711  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_8BUI);
712  CU_ASSERT(!rt_band_is_offline(band));
713  CU_ASSERT(rt_band_get_hasnodata_flag(band));
714  rt_band_get_nodata(band, &val);
715  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
716 
717  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
718  CU_ASSERT_EQUAL(failure, ES_NONE);
719  CU_ASSERT_DOUBLE_EQUAL(val, 78, DBL_EPSILON);
720 
721  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
722  CU_ASSERT_EQUAL(failure, ES_NONE);
723  CU_ASSERT_DOUBLE_EQUAL(val, 98, DBL_EPSILON);
724 
725  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
726  CU_ASSERT_EQUAL(failure, ES_NONE);
727  CU_ASSERT_DOUBLE_EQUAL(val, 122, DBL_EPSILON);
728 
729  failure = rt_band_get_pixel(band, 3, 0, &val, NULL);
730  CU_ASSERT_EQUAL(failure, ES_NONE);
731  CU_ASSERT_DOUBLE_EQUAL(val, 173, DBL_EPSILON);
732 
733  failure = rt_band_get_pixel(band, 4, 0, &val, NULL);
734  CU_ASSERT_EQUAL(failure, ES_NONE);
735  CU_ASSERT_DOUBLE_EQUAL(val, 209, DBL_EPSILON);
736  }
737 
738  {
739  /* Test 3rd band */
740  double val;
741  int failure;
742  rt_band band = rt_raster_get_band(raster, 2);
743  CU_ASSERT(band != NULL);
744  CU_ASSERT_EQUAL(rt_band_get_pixtype(band), PT_8BUI);
745  CU_ASSERT(!rt_band_is_offline(band));
746  CU_ASSERT(rt_band_get_hasnodata_flag(band));
747  rt_band_get_nodata(band, &val);
748  CU_ASSERT_DOUBLE_EQUAL(val, 0, DBL_EPSILON);
749 
750  failure = rt_band_get_pixel(band, 0, 0, &val, NULL);
751  CU_ASSERT_EQUAL(failure, ES_NONE);
752  CU_ASSERT_DOUBLE_EQUAL(val, 70, DBL_EPSILON);
753 
754  failure = rt_band_get_pixel(band, 1, 0, &val, NULL);
755  CU_ASSERT_EQUAL(failure, ES_NONE);
756  CU_ASSERT_DOUBLE_EQUAL(val, 86, DBL_EPSILON);
757 
758  failure = rt_band_get_pixel(band, 2, 0, &val, NULL);
759  CU_ASSERT_EQUAL(failure, ES_NONE);
760  CU_ASSERT_DOUBLE_EQUAL(val, 100, DBL_EPSILON);
761 
762  failure = rt_band_get_pixel(band, 3, 0, &val, NULL);
763  CU_ASSERT_EQUAL(failure, ES_NONE);
764  CU_ASSERT_DOUBLE_EQUAL(val, 135, DBL_EPSILON);
765 
766  failure = rt_band_get_pixel(band, 4, 0, &val, NULL);
767  CU_ASSERT_EQUAL(failure, ES_NONE);
768  CU_ASSERT_DOUBLE_EQUAL(val, 161, DBL_EPSILON);
769  }
770 
771  out = rt_raster_to_hexwkb(raster, FALSE, &len);
772 /*
773  printf(" in hexwkb len: %u\n", (uint32_t) strlen(hexwkb));
774  printf("out hexwkb len: %u\n", len);
775 */
776  CU_ASSERT_EQUAL(len, strlen(hexwkb));
777 /* would depend on machine endian
778  CU_ASSERT_STRING_EQUAL(hexwkb, out);
779 */
780 
781  free((/*no const*/ void*)out);
782  {
783  void *serialized;
784  rt_raster rast2;
785 
786  serialized = rt_raster_serialize(raster);
787  rast2 = rt_raster_deserialize(serialized, FALSE);
788 
789  cu_free_raster(rast2);
790  free(serialized);
791  }
792  cu_free_raster(raster);
793 
794  } /* for-loop running car5 tests */
795 
796  /* ------------------------------------------------------ */
797  /* TODO: New test cases */
798  /* ------------------------------------------------------ */
799 
800  /* new test case */
801 
802  /* ------------------------------------------------------ */
803  /* Success summary */
804  /* ------------------------------------------------------ */
805 
806 /*
807  printf("All tests successful !\n");
808 */
809 }
rt_band_t
Definition: librtcore.h:2264
rt_raster_serialize
void * rt_raster_serialize(rt_raster raster)
Return this raster in serialized form.
Definition: rt_serialize.c:521
rt_raster_get_x_offset
double rt_raster_get_x_offset(rt_raster raster)
Get raster x offset, in projection units.
Definition: rt_raster.c:213
rt_raster_get_num_bands
int rt_raster_get_num_bands(rt_raster raster)
Definition: rt_raster.c:372
rt_raster_get_y_skew
double rt_raster_get_y_skew(rt_raster raster)
Get skew about the Y axis.
Definition: rt_raster.c:190
rtrowdump.raster
raster
Be careful!! Zeros function&#39;s input parameter can be a (height x width) array, not (width x height): ...
Definition: rtrowdump.py:121
ovdump.band
band
Definition: ovdump.py:57
rt_band_is_offline
int rt_band_is_offline(rt_band band)
Return non-zero if the given band data is on the filesystem.
Definition: rt_band.c:228
rt_band_get_nodata
rt_errorstate rt_band_get_nodata(rt_band band, double *nodata)
Get NODATA value.
Definition: rt_band.c:1597
rt_band_get_ext_path
const char * rt_band_get_ext_path(rt_band band)
Return band&#39;s external path (only valid when rt_band_is_offline returns non-zero).
Definition: rt_band.c:265
uint32_t
unsigned int uint32_t
Definition: uthash.h:78
cu_free_raster
void cu_free_raster(rt_raster raster)
Definition: raster/test/cunit/cu_tester.c:209
rt_band_get_pixel
rt_errorstate rt_band_get_pixel(rt_band band, int x, int y, double *value, int *nodata)
Get pixel value.
Definition: rt_band.c:1088
rt_raster_to_hexwkb
char * rt_raster_to_hexwkb(rt_raster raster, int outasin, uint32_t *hexwkbsize)
Return this raster in HEXWKB form (null-terminated hex)
Definition: rt_wkb.c:669
rt_raster_get_band
rt_band rt_raster_get_band(rt_raster raster, int bandNum)
Return Nth band, or NULL if unavailable.
Definition: rt_raster.c:381
rt_band_get_hasnodata_flag
int rt_band_get_hasnodata_flag(rt_band band)
Get hasnodata flag value.
Definition: rt_band.c:541
rt_raster_get_x_scale
double rt_raster_get_x_scale(rt_raster raster)
Get scale X in projection units.
Definition: rt_raster.c:150
rt_raster_get_srid
int32_t rt_raster_get_srid(rt_raster raster)
Get raster&#39;s SRID.
Definition: rt_raster.c:356
rt_raster_get_y_scale
double rt_raster_get_y_scale(rt_raster raster)
Get scale Y in projection units.
Definition: rt_raster.c:159
rt_raster_get_x_skew
double rt_raster_get_x_skew(rt_raster raster)
Get skew about the X axis.
Definition: rt_raster.c:181
rt_band_get_ext_band_num
rt_errorstate rt_band_get_ext_band_num(rt_band band, uint8_t *bandnum)
Return bands&#39; external band number (only valid when rt_band_is_offline returns non-zero).
Definition: rt_band.c:278
rt_raster_get_width
uint16_t rt_raster_get_width(rt_raster raster)
Definition: rt_raster.c:121
rt_raster_from_hexwkb
rt_raster rt_raster_from_hexwkb(const char *hexwkb, uint32_t hexwkbsize)
Construct an rt_raster from a text HEXWKB representation.
Definition: rt_wkb.c:406
FALSE
#define FALSE
Definition: dbfopen.c:168
rt_band_get_pixtype
rt_pixtype rt_band_get_pixtype(rt_band band)
Return pixeltype of this band.
Definition: rt_band.c:498
free
void free(void *)
rt_raster_t
Definition: librtcore.h:2235
rt_raster_get_height
uint16_t rt_raster_get_height(rt_raster raster)
Definition: rt_raster.c:129
uint8_t
unsigned char uint8_t
Definition: uthash.h:79
rt_raster_deserialize
rt_raster rt_raster_deserialize(void *serialized, int header_only)
Return a raster from a serialized form.
Definition: rt_serialize.c:717
rt_raster_get_y_offset
double rt_raster_get_y_offset(rt_raster raster)
Get raster y offset, in projection units.
Definition: rt_raster.c:222
Here is the call graph for this function:
Here is the caller graph for this function: