Debian Codegraph @

tests/gis_tests/gdal_tests/test_raster.py

raw
1 import os
2 import shutil
3 import struct
4 import tempfile
5 import zipfile
6 from pathlib import Path
7 from unittest import mock
8
9 from django.contrib.gis.gdal import GDAL_VERSION, GDALRaster, SpatialReference
10 from django.contrib.gis.gdal.error import GDALException
11 from django.contrib.gis.gdal.raster.band import GDALBand
12 from django.contrib.gis.shortcuts import numpy
13 from django.core.files.temp import NamedTemporaryFile
14 from django.test import SimpleTestCase
15
16 from ..data.rasters.textrasters import JSON_RASTER
17
18
19 class GDALRasterTests(SimpleTestCase):
20 """
21 Test a GDALRaster instance created from a file (GeoTiff).
22 """
23
24 def setUp(self):
25 self.rs_path = os.path.join(
26 os.path.dirname(__file__), "../data/rasters/raster.tif"
27 )
28 self.rs = GDALRaster(self.rs_path)
29
30 def test_gdalraster_input_as_path(self):
31 rs_path = Path(__file__).parent.parent / "data" / "rasters" / "raster.tif"
32 rs = GDALRaster(rs_path)
33 self.assertEqual(str(rs_path), rs.name)
34
35 def test_rs_name_repr(self):
36 self.assertEqual(self.rs_path, self.rs.name)
37 self.assertRegex(repr(self.rs), r"<Raster object at 0x\w+>")
38
39 def test_rs_driver(self):
40 self.assertEqual(self.rs.driver.name, "GTiff")
41
42 def test_rs_size(self):
43 self.assertEqual(self.rs.width, 163)
44 self.assertEqual(self.rs.height, 174)
45
46 def test_rs_srs(self):
47 self.assertEqual(self.rs.srs.srid, 3086)
48 self.assertEqual(self.rs.srs.units, (1.0, "metre"))
49
50 def test_rs_srid(self):
51 rast = GDALRaster(
52 {
53 "width": 16,
54 "height": 16,
55 "srid": 4326,
56 }
57 )
58 self.assertEqual(rast.srid, 4326)
59 rast.srid = 3086
60 self.assertEqual(rast.srid, 3086)
61
62 def test_geotransform_and_friends(self):
63 # Assert correct values for file based raster
64 self.assertEqual(
65 self.rs.geotransform,
66 [511700.4680706557, 100.0, 0.0, 435103.3771231986, 0.0, -100.0],
67 )
68 self.assertEqual(self.rs.origin, [511700.4680706557, 435103.3771231986])
69 self.assertEqual(self.rs.origin.x, 511700.4680706557)
70 self.assertEqual(self.rs.origin.y, 435103.3771231986)
71 self.assertEqual(self.rs.scale, [100.0, -100.0])
72 self.assertEqual(self.rs.scale.x, 100.0)
73 self.assertEqual(self.rs.scale.y, -100.0)
74 self.assertEqual(self.rs.skew, [0, 0])
75 self.assertEqual(self.rs.skew.x, 0)
76 self.assertEqual(self.rs.skew.y, 0)
77 # Create in-memory rasters and change gtvalues
78 rsmem = GDALRaster(JSON_RASTER)
79 # geotransform accepts both floats and ints
80 rsmem.geotransform = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
81 self.assertEqual(rsmem.geotransform, [0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
82 rsmem.geotransform = range(6)
83 self.assertEqual(rsmem.geotransform, [float(x) for x in range(6)])
84 self.assertEqual(rsmem.origin, [0, 3])
85 self.assertEqual(rsmem.origin.x, 0)
86 self.assertEqual(rsmem.origin.y, 3)
87 self.assertEqual(rsmem.scale, [1, 5])
88 self.assertEqual(rsmem.scale.x, 1)
89 self.assertEqual(rsmem.scale.y, 5)
90 self.assertEqual(rsmem.skew, [2, 4])
91 self.assertEqual(rsmem.skew.x, 2)
92 self.assertEqual(rsmem.skew.y, 4)
93 self.assertEqual(rsmem.width, 5)
94 self.assertEqual(rsmem.height, 5)
95
96 def test_geotransform_bad_inputs(self):
97 rsmem = GDALRaster(JSON_RASTER)
98 error_geotransforms = [
99 [1, 2],
100 [1, 2, 3, 4, 5, "foo"],
101 [1, 2, 3, 4, 5, 6, "foo"],
102 ]
103 msg = "Geotransform must consist of 6 numeric values."
104 for geotransform in error_geotransforms:
105 with (
106 self.subTest(i=geotransform),
107 self.assertRaisesMessage(ValueError, msg),
108 ):
109 rsmem.geotransform = geotransform
110
111 def test_rs_extent(self):
112 self.assertEqual(
113 self.rs.extent,
114 (
115 511700.4680706557,
116 417703.3771231986,
117 528000.4680706557,
118 435103.3771231986,
119 ),
120 )
121
122 def test_rs_bands(self):
123 self.assertEqual(len(self.rs.bands), 1)
124 self.assertIsInstance(self.rs.bands[0], GDALBand)
125
126 def test_memory_based_raster_creation(self):
127 # Create uint8 raster with full pixel data range (0-255)
128 rast = GDALRaster(
129 {
130 "datatype": 1,
131 "width": 16,
132 "height": 16,
133 "srid": 4326,
134 "bands": [
135 {
136 "data": range(256),
137 "nodata_value": 255,
138 }
139 ],
140 }
141 )
142
143 # Get array from raster
144 result = rast.bands[0].data()
145 if numpy:
146 result = result.flatten().tolist()
147
148 # Assert data is same as original input
149 self.assertEqual(result, list(range(256)))
150
151 def test_file_based_raster_creation(self):
152 # Prepare tempfile
153 rstfile = NamedTemporaryFile(suffix=".tif")
154
155 # Create file-based raster from scratch
156 GDALRaster(
157 {
158 "datatype": self.rs.bands[0].datatype(),
159 "driver": "tif",
160 "name": rstfile.name,
161 "width": 163,
162 "height": 174,
163 "nr_of_bands": 1,
164 "srid": self.rs.srs.wkt,
165 "origin": (self.rs.origin.x, self.rs.origin.y),
166 "scale": (self.rs.scale.x, self.rs.scale.y),
167 "skew": (self.rs.skew.x, self.rs.skew.y),
168 "bands": [
169 {
170 "data": self.rs.bands[0].data(),
171 "nodata_value": self.rs.bands[0].nodata_value,
172 }
173 ],
174 }
175 )
176
177 # Reload newly created raster from file
178 restored_raster = GDALRaster(rstfile.name)
179 # Presence of TOWGS84 depend on GDAL/Proj versions.
180 self.assertEqual(
181 restored_raster.srs.wkt.replace("TOWGS84[0,0,0,0,0,0,0],", ""),
182 self.rs.srs.wkt.replace("TOWGS84[0,0,0,0,0,0,0],", ""),
183 )
184 self.assertEqual(restored_raster.geotransform, self.rs.geotransform)
185 if numpy:
186 numpy.testing.assert_equal(
187 restored_raster.bands[0].data(), self.rs.bands[0].data()
188 )
189 else:
190 self.assertEqual(restored_raster.bands[0].data(), self.rs.bands[0].data())
191
192 def test_nonexistent_file(self):
193 msg = 'Unable to read raster source input "nonexistent.tif".'
194 with self.assertRaisesMessage(GDALException, msg):
195 GDALRaster("nonexistent.tif")
196
197 def test_vsi_raster_creation(self):
198 # Open a raster as a file object.
199 with open(self.rs_path, "rb") as dat:
200 # Instantiate a raster from the file binary buffer.
201 vsimem = GDALRaster(dat.read())
202 # The data of the in-memory file is equal to the source file.
203 result = vsimem.bands[0].data()
204 target = self.rs.bands[0].data()
205 if numpy:
206 result = result.flatten().tolist()
207 target = target.flatten().tolist()
208 self.assertEqual(result, target)
209
210 def test_vsi_raster_deletion(self):
211 path = "/vsimem/raster.tif"
212 # Create a vsi-based raster from scratch.
213 vsimem = GDALRaster(
214 {
215 "name": path,
216 "driver": "tif",
217 "width": 4,
218 "height": 4,
219 "srid": 4326,
220 "bands": [
221 {
222 "data": range(16),
223 }
224 ],
225 }
226 )
227 # The virtual file exists.
228 rst = GDALRaster(path)
229 self.assertEqual(rst.width, 4)
230 # Delete GDALRaster.
231 del vsimem
232 del rst
233 # The virtual file has been removed.
234 msg = 'Could not open the datasource at "/vsimem/raster.tif"'
235 with self.assertRaisesMessage(GDALException, msg):
236 GDALRaster(path)
237
238 def test_vsi_invalid_buffer_error(self):
239 msg = "Failed creating VSI raster from the input buffer."
240 with self.assertRaisesMessage(GDALException, msg):
241 GDALRaster(b"not-a-raster-buffer")
242
243 def test_vsi_buffer_property(self):
244 # Create a vsi-based raster from scratch.
245 rast = GDALRaster(
246 {
247 "name": "/vsimem/raster.tif",
248 "driver": "tif",
249 "width": 4,
250 "height": 4,
251 "srid": 4326,
252 "bands": [
253 {
254 "data": range(16),
255 }
256 ],
257 }
258 )
259 # Do a round trip from raster to buffer to raster.
260 result = GDALRaster(rast.vsi_buffer).bands[0].data()
261 if numpy:
262 result = result.flatten().tolist()
263 # Band data is equal to nodata value except on input block of ones.
264 self.assertEqual(result, list(range(16)))
265 # The vsi buffer is None for rasters that are not vsi based.
266 self.assertIsNone(self.rs.vsi_buffer)
267
268 def test_vsi_vsizip_filesystem(self):
269 rst_zipfile = NamedTemporaryFile(suffix=".zip")
270 with zipfile.ZipFile(rst_zipfile, mode="w") as zf:
271 zf.write(self.rs_path, "raster.tif")
272 rst_path = "/vsizip/" + os.path.join(rst_zipfile.name, "raster.tif")
273 rst = GDALRaster(rst_path)
274 self.assertEqual(rst.driver.name, self.rs.driver.name)
275 self.assertEqual(rst.name, rst_path)
276 self.assertIs(rst.is_vsi_based, True)
277 self.assertIsNone(rst.vsi_buffer)
278
279 def test_offset_size_and_shape_on_raster_creation(self):
280 rast = GDALRaster(
281 {
282 "datatype": 1,
283 "width": 4,
284 "height": 4,
285 "srid": 4326,
286 "bands": [
287 {
288 "data": (1,),
289 "offset": (1, 1),
290 "size": (2, 2),
291 "shape": (1, 1),
292 "nodata_value": 2,
293 }
294 ],
295 }
296 )
297 # Get array from raster.
298 result = rast.bands[0].data()
299 if numpy:
300 result = result.flatten().tolist()
301 # Band data is equal to nodata value except on input block of ones.
302 self.assertEqual(result, [2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2])
303
304 def test_set_nodata_value_on_raster_creation(self):
305 # Create raster filled with nodata values.
306 rast = GDALRaster(
307 {
308 "datatype": 1,
309 "width": 2,
310 "height": 2,
311 "srid": 4326,
312 "bands": [{"nodata_value": 23}],
313 }
314 )
315 # Get array from raster.
316 result = rast.bands[0].data()
317 if numpy:
318 result = result.flatten().tolist()
319 # All band data is equal to nodata value.
320 self.assertEqual(result, [23] * 4)
321
322 def test_set_nodata_none_on_raster_creation(self):
323 # Create raster without data and without nodata value.
324 rast = GDALRaster(
325 {
326 "datatype": 1,
327 "width": 2,
328 "height": 2,
329 "srid": 4326,
330 "bands": [{"nodata_value": None}],
331 }
332 )
333 # Get array from raster.
334 result = rast.bands[0].data()
335 if numpy:
336 result = result.flatten().tolist()
337 # Band data is equal to zero because no nodata value has been specified.
338 self.assertEqual(result, [0] * 4)
339
340 def test_raster_metadata_property(self):
341 data = self.rs.metadata
342 self.assertEqual(data["DEFAULT"], {"AREA_OR_POINT": "Area"})
343 self.assertEqual(data["IMAGE_STRUCTURE"], {"INTERLEAVE": "BAND"})
344
345 # Create file-based raster from scratch
346 source = GDALRaster(
347 {
348 "datatype": 1,
349 "width": 2,
350 "height": 2,
351 "srid": 4326,
352 "bands": [{"data": range(4), "nodata_value": 99}],
353 }
354 )
355 # Set metadata on raster and on a band.
356 metadata = {
357 "DEFAULT": {"OWNER": "Django", "VERSION": "1.0", "AREA_OR_POINT": "Point"},
358 }
359 source.metadata = metadata
360 source.bands[0].metadata = metadata
361 self.assertEqual(source.metadata["DEFAULT"], metadata["DEFAULT"])
362 self.assertEqual(source.bands[0].metadata["DEFAULT"], metadata["DEFAULT"])
363 # Update metadata on raster.
364 metadata = {
365 "DEFAULT": {"VERSION": "2.0"},
366 }
367 source.metadata = metadata
368 self.assertEqual(source.metadata["DEFAULT"]["VERSION"], "2.0")
369 # Remove metadata on raster.
370 metadata = {
371 "DEFAULT": {"OWNER": None},
372 }
373 source.metadata = metadata
374 self.assertNotIn("OWNER", source.metadata["DEFAULT"])
375
376 def test_raster_info_accessor(self):
377 infos = self.rs.info
378 # Data
379 info_lines = [line.strip() for line in infos.split("\n") if line.strip() != ""]
380 for line in [
381 "Driver: GTiff/GeoTIFF",
382 "Files: {}".format(self.rs_path),
383 "Size is 163, 174",
384 "Origin = (511700.468070655711927,435103.377123198588379)",
385 "Pixel Size = (100.000000000000000,-100.000000000000000)",
386 "Metadata:",
387 "AREA_OR_POINT=Area",
388 "Image Structure Metadata:",
389 "INTERLEAVE=BAND",
390 "Band 1 Block=163x50 Type=Byte, ColorInterp=Gray",
391 "NoData Value=15",
392 ]:
393 self.assertIn(line, info_lines)
394 for line in [
395 r"Upper Left \( 511700.468, 435103.377\) "
396 r'\( 82d51\'46.1\d"W, 27d55\' 1.5\d"N\)',
397 r"Lower Left \( 511700.468, 417703.377\) "
398 r'\( 82d51\'52.0\d"W, 27d45\'37.5\d"N\)',
399 r"Upper Right \( 528000.468, 435103.377\) "
400 r'\( 82d41\'48.8\d"W, 27d54\'56.3\d"N\)',
401 r"Lower Right \( 528000.468, 417703.377\) "
402 r'\( 82d41\'55.5\d"W, 27d45\'32.2\d"N\)',
403 r"Center \( 519850.468, 426403.377\) "
404 r'\( 82d46\'50.6\d"W, 27d50\'16.9\d"N\)',
405 ]:
406 self.assertRegex(infos, line)
407 # CRS (skip the name because string depends on the GDAL/Proj versions).
408 self.assertIn("NAD83 / Florida GDL Albers", infos)
409
410 def test_compressed_file_based_raster_creation(self):
411 rstfile = NamedTemporaryFile(suffix=".tif")
412 # Make a compressed copy of an existing raster.
413 compressed = self.rs.warp(
414 {"papsz_options": {"compress": "packbits"}, "name": rstfile.name}
415 )
416 # Check physically if compression worked.
417 self.assertLess(os.path.getsize(compressed.name), os.path.getsize(self.rs.name))
418 # Create file-based raster with options from scratch.
419 papsz_options = {
420 "compress": "packbits",
421 "blockxsize": 23,
422 "blockysize": 23,
423 }
424 if GDAL_VERSION < (3, 7):
425 datatype = 1
426 papsz_options["pixeltype"] = "signedbyte"
427 else:
428 datatype = 14
429 compressed = GDALRaster(
430 {
431 "datatype": datatype,
432 "driver": "tif",
433 "name": rstfile.name,
434 "width": 40,
435 "height": 40,
436 "srid": 3086,
437 "origin": (500000, 400000),
438 "scale": (100, -100),
439 "skew": (0, 0),
440 "bands": [
441 {
442 "data": range(40 ^ 2),
443 "nodata_value": 255,
444 }
445 ],
446 "papsz_options": papsz_options,
447 }
448 )
449 # Check if options used on creation are stored in metadata.
450 # Reopening the raster ensures that all metadata has been written
451 # to the file.
452 compressed = GDALRaster(compressed.name)
453 self.assertEqual(
454 compressed.metadata["IMAGE_STRUCTURE"]["COMPRESSION"],
455 "PACKBITS",
456 )
457 self.assertEqual(compressed.bands[0].datatype(), datatype)
458 if GDAL_VERSION < (3, 7):
459 self.assertEqual(
460 compressed.bands[0].metadata["IMAGE_STRUCTURE"]["PIXELTYPE"],
461 "SIGNEDBYTE",
462 )
463 self.assertIn("Block=40x23", compressed.info)
464
465 def test_raster_warp(self):
466 # Create in memory raster
467 source = GDALRaster(
468 {
469 "datatype": 1,
470 "driver": "MEM",
471 "name": "sourceraster",
472 "width": 4,
473 "height": 4,
474 "nr_of_bands": 1,
475 "srid": 3086,
476 "origin": (500000, 400000),
477 "scale": (100, -100),
478 "skew": (0, 0),
479 "bands": [
480 {
481 "data": range(16),
482 "nodata_value": 255,
483 }
484 ],
485 }
486 )
487
488 # Test altering the scale, width, and height of a raster
489 data = {
490 "scale": [200, -200],
491 "width": 2,
492 "height": 2,
493 }
494 target = source.warp(data)
495 self.assertEqual(target.width, data["width"])
496 self.assertEqual(target.height, data["height"])
497 self.assertEqual(target.scale, data["scale"])
498 self.assertEqual(target.bands[0].datatype(), source.bands[0].datatype())
499 self.assertEqual(target.name, "sourceraster_copy.MEM")
500 result = target.bands[0].data()
501 if numpy:
502 result = result.flatten().tolist()
503 self.assertEqual(result, [5, 7, 13, 15])
504
505 # Test altering the name and datatype (to float)
506 data = {
507 "name": "/path/to/targetraster.tif",
508 "datatype": 6,
509 }
510 target = source.warp(data)
511 self.assertEqual(target.bands[0].datatype(), 6)
512 self.assertEqual(target.name, "/path/to/targetraster.tif")
513 self.assertEqual(target.driver.name, "MEM")
514 result = target.bands[0].data()
515 if numpy:
516 result = result.flatten().tolist()
517 self.assertEqual(
518 result,
519 [
520 0.0,
521 1.0,
522 2.0,
523 3.0,
524 4.0,
525 5.0,
526 6.0,
527 7.0,
528 8.0,
529 9.0,
530 10.0,
531 11.0,
532 12.0,
533 13.0,
534 14.0,
535 15.0,
536 ],
537 )
538
539 def test_raster_warp_nodata_zone(self):
540 # Create in memory raster.
541 source = GDALRaster(
542 {
543 "datatype": 1,
544 "driver": "MEM",
545 "width": 4,
546 "height": 4,
547 "srid": 3086,
548 "origin": (500000, 400000),
549 "scale": (100, -100),
550 "skew": (0, 0),
551 "bands": [
552 {
553 "data": range(16),
554 "nodata_value": 23,
555 }
556 ],
557 }
558 )
559 # Warp raster onto a location that does not cover any pixels of the original.
560 result = source.warp({"origin": (200000, 200000)}).bands[0].data()
561 if numpy:
562 result = result.flatten().tolist()
563 # The result is an empty raster filled with the correct nodata value.
564 self.assertEqual(result, [23] * 16)
565
566 def test_raster_clone(self):
567 rstfile = NamedTemporaryFile(suffix=".tif")
568 tests = [
569 ("MEM", "", 23), # In memory raster.
570 ("tif", rstfile.name, 99), # In file based raster.
571 ]
572 for driver, name, nodata_value in tests:
573 with self.subTest(driver=driver):
574 source = GDALRaster(
575 {
576 "datatype": 1,
577 "driver": driver,
578 "name": name,
579 "width": 4,
580 "height": 4,
581 "srid": 3086,
582 "origin": (500000, 400000),
583 "scale": (100, -100),
584 "skew": (0, 0),
585 "bands": [
586 {
587 "data": range(16),
588 "nodata_value": nodata_value,
589 }
590 ],
591 }
592 )
593 clone = source.clone()
594 self.assertNotEqual(clone.name, source.name)
595 self.assertEqual(clone._write, source._write)
596 self.assertEqual(clone.srs.srid, source.srs.srid)
597 self.assertEqual(clone.width, source.width)
598 self.assertEqual(clone.height, source.height)
599 self.assertEqual(clone.origin, source.origin)
600 self.assertEqual(clone.scale, source.scale)
601 self.assertEqual(clone.skew, source.skew)
602 self.assertIsNot(clone, source)
603
604 def test_raster_transform(self):
605 tests = [
606 3086,
607 "3086",
608 SpatialReference(3086),
609 ]
610 for srs in tests:
611 with self.subTest(srs=srs):
612 # Prepare tempfile and nodata value.
613 rstfile = NamedTemporaryFile(suffix=".tif")
614 ndv = 99
615 # Create in file based raster.
616 source = GDALRaster(
617 {
618 "datatype": 1,
619 "driver": "tif",
620 "name": rstfile.name,
621 "width": 5,
622 "height": 5,
623 "nr_of_bands": 1,
624 "srid": 4326,
625 "origin": (-5, 5),
626 "scale": (2, -2),
627 "skew": (0, 0),
628 "bands": [
629 {
630 "data": range(25),
631 "nodata_value": ndv,
632 }
633 ],
634 }
635 )
636
637 target = source.transform(srs)
638
639 # Reload data from disk.
640 target = GDALRaster(target.name)
641 self.assertEqual(target.srs.srid, 3086)
642 self.assertEqual(target.width, 7)
643 self.assertEqual(target.height, 7)
644 self.assertEqual(target.bands[0].datatype(), source.bands[0].datatype())
645 self.assertAlmostEqual(target.origin[0], 9124842.791079799, 3)
646 self.assertAlmostEqual(target.origin[1], 1589911.6476407414, 3)
647 self.assertAlmostEqual(target.scale[0], 223824.82664250192, 3)
648 self.assertAlmostEqual(target.scale[1], -223824.82664250192, 3)
649 self.assertEqual(target.skew, [0, 0])
650
651 result = target.bands[0].data()
652 if numpy:
653 result = result.flatten().tolist()
654 # The reprojection of a raster that spans over a large area
655 # skews the data matrix and might introduce nodata values.
656 self.assertEqual(
657 result,
658 [
659 ndv,
660 ndv,
661 ndv,
662 ndv,
663 4,
664 ndv,
665 ndv,
666 ndv,
667 ndv,
668 2,
669 3,
670 9,
671 ndv,
672 ndv,
673 ndv,
674 1,
675 2,
676 8,
677 13,
678 19,
679 ndv,
680 0,
681 6,
682 6,
683 12,
684 18,
685 18,
686 24,
687 ndv,
688 10,
689 11,
690 16,
691 22,
692 23,
693 ndv,
694 ndv,
695 ndv,
696 15,
697 21,
698 22,
699 ndv,
700 ndv,
701 ndv,
702 ndv,
703 20,
704 ndv,
705 ndv,
706 ndv,
707 ndv,
708 ],
709 )
710
711 def test_raster_transform_clone(self):
712 with mock.patch.object(GDALRaster, "clone") as mocked_clone:
713 # Create in file based raster.
714 rstfile = NamedTemporaryFile(suffix=".tif")
715 source = GDALRaster(
716 {
717 "datatype": 1,
718 "driver": "tif",
719 "name": rstfile.name,
720 "width": 5,
721 "height": 5,
722 "nr_of_bands": 1,
723 "srid": 4326,
724 "origin": (-5, 5),
725 "scale": (2, -2),
726 "skew": (0, 0),
727 "bands": [
728 {
729 "data": range(25),
730 "nodata_value": 99,
731 }
732 ],
733 }
734 )
735 # transform() returns a clone because it is the same SRID and
736 # driver.
737 source.transform(4326)
738 self.assertEqual(mocked_clone.call_count, 1)
739
740 def test_raster_transform_clone_name(self):
741 # Create in file based raster.
742 rstfile = NamedTemporaryFile(suffix=".tif")
743 source = GDALRaster(
744 {
745 "datatype": 1,
746 "driver": "tif",
747 "name": rstfile.name,
748 "width": 5,
749 "height": 5,
750 "nr_of_bands": 1,
751 "srid": 4326,
752 "origin": (-5, 5),
753 "scale": (2, -2),
754 "skew": (0, 0),
755 "bands": [
756 {
757 "data": range(25),
758 "nodata_value": 99,
759 }
760 ],
761 }
762 )
763 clone_name = rstfile.name + "_respect_name.GTiff"
764 target = source.transform(4326, name=clone_name)
765 self.assertEqual(target.name, clone_name)
766
767
768 class GDALBandTests(SimpleTestCase):
769 rs_path = os.path.join(os.path.dirname(__file__), "../data/rasters/raster.tif")
770
771 def test_band_data(self):
772 rs = GDALRaster(self.rs_path)
773 band = rs.bands[0]
774 self.assertEqual(band.width, 163)
775 self.assertEqual(band.height, 174)
776 self.assertEqual(band.description, "")
777 self.assertEqual(band.datatype(), 1)
778 self.assertEqual(band.datatype(as_string=True), "GDT_Byte")
779 self.assertEqual(band.color_interp(), 1)
780 self.assertEqual(band.color_interp(as_string=True), "GCI_GrayIndex")
781 self.assertEqual(band.nodata_value, 15)
782 if numpy:
783 data = band.data()
784 assert_array = numpy.loadtxt(
785 os.path.join(
786 os.path.dirname(__file__), "../data/rasters/raster.numpy.txt"
787 )
788 )
789 numpy.testing.assert_equal(data, assert_array)
790 self.assertEqual(data.shape, (band.height, band.width))
791
792 def test_band_statistics(self):
793 with tempfile.TemporaryDirectory() as tmp_dir:
794 rs_path = os.path.join(tmp_dir, "raster.tif")
795 shutil.copyfile(self.rs_path, rs_path)
796 rs = GDALRaster(rs_path)
797 band = rs.bands[0]
798 pam_file = rs_path + ".aux.xml"
799 smin, smax, smean, sstd = band.statistics(approximate=True)
800 self.assertEqual(smin, 0)
801 self.assertEqual(smax, 9)
802 self.assertAlmostEqual(smean, 2.842331288343558)
803 self.assertAlmostEqual(sstd, 2.3965567248965356)
804
805 smin, smax, smean, sstd = band.statistics(approximate=False, refresh=True)
806 self.assertEqual(smin, 0)
807 self.assertEqual(smax, 9)
808 self.assertAlmostEqual(smean, 2.828326634228898)
809 self.assertAlmostEqual(sstd, 2.4260526986669095)
810
811 self.assertEqual(band.min, 0)
812 self.assertEqual(band.max, 9)
813 self.assertAlmostEqual(band.mean, 2.828326634228898)
814 self.assertAlmostEqual(band.std, 2.4260526986669095)
815
816 # Statistics are persisted into PAM file on band close
817 rs = band = None
818 self.assertTrue(os.path.isfile(pam_file))
819
820 def _remove_aux_file(self):
821 pam_file = self.rs_path + ".aux.xml"
822 if os.path.isfile(pam_file):
823 os.remove(pam_file)
824
825 def test_read_mode_error(self):
826 # Open raster in read mode
827 rs = GDALRaster(self.rs_path, write=False)
828 band = rs.bands[0]
829 self.addCleanup(self._remove_aux_file)
830
831 # Setting attributes in write mode raises exception in the _flush method
832 with self.assertRaises(GDALException):
833 setattr(band, "nodata_value", 10)
834
835 def test_band_data_setters(self):
836 # Create in-memory raster and get band
837 rsmem = GDALRaster(
838 {
839 "datatype": 1,
840 "driver": "MEM",
841 "name": "mem_rst",
842 "width": 10,
843 "height": 10,
844 "nr_of_bands": 1,
845 "srid": 4326,
846 }
847 )
848 bandmem = rsmem.bands[0]
849
850 # Set nodata value
851 bandmem.nodata_value = 99
852 self.assertEqual(bandmem.nodata_value, 99)
853
854 # Set data for entire dataset
855 bandmem.data(range(100))
856 if numpy:
857 numpy.testing.assert_equal(
858 bandmem.data(), numpy.arange(100).reshape(10, 10)
859 )
860 else:
861 self.assertEqual(bandmem.data(), list(range(100)))
862
863 # Prepare data for setting values in subsequent tests
864 block = list(range(100, 104))
865 packed_block = struct.pack("<" + "B B B B", *block)
866
867 # Set data from list
868 bandmem.data(block, (1, 1), (2, 2))
869 result = bandmem.data(offset=(1, 1), size=(2, 2))
870 if numpy:
871 numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
872 else:
873 self.assertEqual(result, block)
874
875 # Set data from packed block
876 bandmem.data(packed_block, (1, 1), (2, 2))
877 result = bandmem.data(offset=(1, 1), size=(2, 2))
878 if numpy:
879 numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
880 else:
881 self.assertEqual(result, block)
882
883 # Set data from bytes
884 bandmem.data(bytes(packed_block), (1, 1), (2, 2))
885 result = bandmem.data(offset=(1, 1), size=(2, 2))
886 if numpy:
887 numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
888 else:
889 self.assertEqual(result, block)
890
891 # Set data from bytearray
892 bandmem.data(bytearray(packed_block), (1, 1), (2, 2))
893 result = bandmem.data(offset=(1, 1), size=(2, 2))
894 if numpy:
895 numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
896 else:
897 self.assertEqual(result, block)
898
899 # Set data from memoryview
900 bandmem.data(memoryview(packed_block), (1, 1), (2, 2))
901 result = bandmem.data(offset=(1, 1), size=(2, 2))
902 if numpy:
903 numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
904 else:
905 self.assertEqual(result, block)
906
907 # Set data from numpy array
908 if numpy:
909 bandmem.data(numpy.array(block, dtype="int8").reshape(2, 2), (1, 1), (2, 2))
910 numpy.testing.assert_equal(
911 bandmem.data(offset=(1, 1), size=(2, 2)),
912 numpy.array(block).reshape(2, 2),
913 )
914
915 # Test json input data
916 rsmemjson = GDALRaster(JSON_RASTER)
917 bandmemjson = rsmemjson.bands[0]
918 if numpy:
919 numpy.testing.assert_equal(
920 bandmemjson.data(), numpy.array(range(25)).reshape(5, 5)
921 )
922 else:
923 self.assertEqual(bandmemjson.data(), list(range(25)))
924
925 def test_band_statistics_automatic_refresh(self):
926 rsmem = GDALRaster(
927 {
928 "srid": 4326,
929 "width": 2,
930 "height": 2,
931 "bands": [{"data": [0] * 4, "nodata_value": 99}],
932 }
933 )
934 band = rsmem.bands[0]
935 # Populate statistics cache
936 self.assertEqual(band.statistics(), (0, 0, 0, 0))
937 # Change data
938 band.data([1, 1, 0, 0])
939 # Statistics are properly updated
940 self.assertEqual(band.statistics(), (0.0, 1.0, 0.5, 0.5))
941 # Change nodata_value
942 band.nodata_value = 0
943 # Statistics are properly updated
944 self.assertEqual(band.statistics(), (1.0, 1.0, 1.0, 0.0))
945
946 def test_band_statistics_empty_band(self):
947 rsmem = GDALRaster(
948 {
949 "srid": 4326,
950 "width": 1,
951 "height": 1,
952 "bands": [{"data": [0], "nodata_value": 0}],
953 }
954 )
955 self.assertEqual(rsmem.bands[0].statistics(), (None, None, None, None))
956
957 def test_band_delete_nodata(self):
958 rsmem = GDALRaster(
959 {
960 "srid": 4326,
961 "width": 1,
962 "height": 1,
963 "bands": [{"data": [0], "nodata_value": 1}],
964 }
965 )
966 rsmem.bands[0].nodata_value = None
967 self.assertIsNone(rsmem.bands[0].nodata_value)
968
969 def test_band_data_replication(self):
970 band = GDALRaster(
971 {
972 "srid": 4326,
973 "width": 3,
974 "height": 3,
975 "bands": [{"data": range(10, 19), "nodata_value": 0}],
976 }
977 ).bands[0]
978
979 # Variations for input (data, shape, expected result).
980 combos = (
981 ([1], (1, 1), [1] * 9),
982 (range(3), (1, 3), [0, 0, 0, 1, 1, 1, 2, 2, 2]),
983 (range(3), (3, 1), [0, 1, 2, 0, 1, 2, 0, 1, 2]),
984 )
985 for combo in combos:
986 band.data(combo[0], shape=combo[1])
987 if numpy:
988 numpy.testing.assert_equal(
989 band.data(), numpy.array(combo[2]).reshape(3, 3)
990 )
991 else:
992 self.assertEqual(band.data(), list(combo[2]))