1 use std::path::Path;
2 use super::{ByteBuffer, Driver, Dataset, warp};
3 use gdal_sys::GDALDataType;
4 use metadata::Metadata;
5
6 #[cfg(feature = "ndarray")]
7 use ndarray::arr2;
8
9
10 macro_rules! fixture {
11 ($name:expr) => (
12 Path::new(file!())
13 .parent().unwrap()
14 .parent().unwrap()
15 .parent().unwrap()
16 .join("fixtures").as_path()
17 .join($name).as_path()
18 )
19 }
20
21
22 #[test]
test_open()23 fn test_open() {
24 let dataset = Dataset::open(fixture!("tinymarble.png"));
25 assert!(dataset.is_ok());
26
27 let missing_dataset = Dataset::open(fixture!("no_such_file.png"));
28 assert!(missing_dataset.is_err());
29 }
30
31
32 #[test]
test_get_raster_size()33 fn test_get_raster_size() {
34 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
35 let (size_x, size_y) = dataset.size();
36 assert_eq!(size_x, 100);
37 assert_eq!(size_y, 50);
38 }
39
40 #[test]
test_get_raster_block_size()41 fn test_get_raster_block_size() {
42 let band_index = 1;
43 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
44 let rasterband = dataset.rasterband(band_index).unwrap();
45 let (size_x, size_y) = rasterband.block_size();
46 assert_eq!(size_x, 100);
47 assert_eq!(size_y, 1);
48 }
49
50 #[test]
test_get_raster_count()51 fn test_get_raster_count() {
52 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
53 let count = dataset.count();
54 assert_eq!(count, 3);
55 }
56
57
58 #[test]
test_get_projection()59 fn test_get_projection() {
60 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
61 //dataset.set_projection("WGS84");
62 let projection = dataset.projection();
63 assert_eq!(projection.chars().take(16).collect::<String>(), "GEOGCS[\"WGS 84\",");
64 }
65
66
67 #[test]
test_read_raster()68 fn test_read_raster() {
69 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
70 let rv = dataset.read_raster(
71 1,
72 (20, 30),
73 (2, 3),
74 (2, 3)
75 ).unwrap();
76 assert_eq!(rv.size.0, 2);
77 assert_eq!(rv.size.1, 3);
78 assert_eq!(rv.data, vec!(7, 7, 7, 10, 8, 12));
79 }
80
81
82 #[test]
test_write_raster()83 fn test_write_raster() {
84 let driver = Driver::get("MEM").unwrap();
85 let dataset = driver.create("", 20, 10, 1).unwrap();
86
87 // create a 2x1 raster
88 let raster = ByteBuffer{
89 size: (2, 1),
90 data: vec!(50u8, 20u8)
91 };
92
93 // epand it to fill the image (20x10)
94 let res = dataset.write_raster(
95 1,
96 (0, 0),
97 (20, 10),
98 &raster
99 );
100 assert!(res.is_ok());
101
102 // read a pixel from the left side
103 let left = dataset.read_raster(
104 1,
105 (5, 5),
106 (1, 1),
107 (1, 1)
108 ).unwrap();
109 assert_eq!(left.data[0], 50u8);
110
111 // read a pixel from the right side
112 let right = dataset.read_raster(
113 1,
114 (15, 5),
115 (1, 1),
116 (1, 1)
117 ).unwrap();
118 assert_eq!(right.data[0], 20u8);
119 }
120
121
122 #[test]
test_get_dataset_driver()123 fn test_get_dataset_driver() {
124 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
125 let driver = dataset.driver();
126 assert_eq!(driver.short_name(), "PNG");
127 assert_eq!(driver.long_name(), "Portable Network Graphics");
128 }
129
130 #[test]
test_get_description()131 fn test_get_description() {
132
133 let driver = Driver::get("mem").unwrap();
134 assert_eq!(driver.description().unwrap(), "MEM".to_string());
135 }
136
137 #[test]
test_get_metadata_item()138 fn test_get_metadata_item() {
139 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
140 let key = "None";
141 let domain = "None";
142 let meta = dataset.metadata_item(key, domain);
143 assert_eq!(meta, None);
144
145 let key = "INTERLEAVE";
146 let domain = "IMAGE_STRUCTURE";
147 let meta = dataset.metadata_item(key, domain);
148 assert_eq!(meta, Some(String::from("PIXEL")));
149 }
150
151 #[test]
test_set_metadata_item()152 fn test_set_metadata_item() {
153 let driver = Driver::get("MEM").unwrap();
154 let mut dataset = driver.create("", 1, 1, 1).unwrap();
155
156 let key = "Test_Key";
157 let domain = "Test_Domain";
158 let value = "Test_Value";
159 let result = dataset.set_metadata_item(key, value, domain);
160 assert!(result.is_ok());
161
162 let result = dataset.metadata_item(key, domain);
163 assert_eq!(Some(value.to_owned()), result);
164 }
165
166 #[test]
test_create()167 fn test_create() {
168 let driver = Driver::get("MEM").unwrap();
169 let dataset = driver.create("", 10, 20, 3).unwrap();
170 assert_eq!(dataset.size(), (10, 20));
171 assert_eq!(dataset.count(), 3);
172 assert_eq!(dataset.driver().short_name(), "MEM");
173 }
174
175 #[test]
test_create_with_band_type()176 fn test_create_with_band_type() {
177 let driver = Driver::get("MEM").unwrap();
178 let dataset = driver.create_with_band_type::<f32>("", 10, 20, 3).unwrap();
179 assert_eq!(dataset.size(), (10, 20));
180 assert_eq!(dataset.count(), 3);
181 assert_eq!(dataset.driver().short_name(), "MEM");
182 assert_eq!(dataset.band_type(1).unwrap(), GDALDataType::GDT_Float32)
183 }
184
185 #[test]
test_create_copy()186 fn test_create_copy() {
187 let driver = Driver::get("MEM").unwrap();
188 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
189 let copy = dataset.create_copy(&driver, "").unwrap();
190 assert_eq!(copy.size(), (100, 50));
191 assert_eq!(copy.count(), 3);
192 }
193
194
195 #[test]
test_geo_transform()196 fn test_geo_transform() {
197 let driver = Driver::get("MEM").unwrap();
198 let dataset = driver.create("", 20, 10, 1).unwrap();
199 let transform = [0., 1., 0., 0., 0., 1.];
200 assert!(dataset.set_geo_transform(&transform).is_ok());
201 assert_eq!(dataset.geo_transform().unwrap(), transform);
202 }
203
204 #[test]
test_get_driver_by_name()205 fn test_get_driver_by_name() {
206 let missing_driver = Driver::get("wtf");
207 assert!(missing_driver.is_err());
208
209 let ok_driver = Driver::get("GTiff");
210 assert!(ok_driver.is_ok());
211 let driver = ok_driver.unwrap();
212 assert_eq!(driver.short_name(), "GTiff");
213 assert_eq!(driver.long_name(), "GeoTIFF");
214 }
215
216
217 #[test]
test_read_raster_as()218 fn test_read_raster_as() {
219 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
220 let rv = dataset.read_raster_as::<u8>(
221 1,
222 (20, 30),
223 (2, 3),
224 (2, 3)
225 ).unwrap();
226 assert_eq!(rv.data, vec!(7, 7, 7, 10, 8, 12));
227 assert_eq!(rv.size.0, 2);
228 assert_eq!(rv.size.1, 3);
229 assert_eq!(dataset.band_type(1).unwrap(), GDALDataType::GDT_Byte);
230 }
231
232 #[test]
233 #[cfg(feature = "ndarray")]
test_read_raster_as_array()234 fn test_read_raster_as_array() {
235 let band_index = 1;
236 let (left, top) = (19, 5);
237 let (window_size_x, window_size_y) = (3, 4);
238 let (array_size_x, array_size_y) = (3, 4);
239 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
240 let values = dataset.read_as_array::<u8>(
241 band_index,
242 (left, top),
243 (window_size_x, window_size_y),
244 (array_size_x, array_size_y)
245 ).unwrap();
246
247 let data = arr2(&[[226, 225, 157],
248 [215, 222, 225],
249 [213, 231, 229],
250 [171, 189, 192]]);
251
252 assert_eq!(values, data);
253 assert_eq!(dataset.band_type(band_index).unwrap(), GDALDataType::GDT_Byte);
254 }
255
256 #[test]
test_read_full_raster_as()257 fn test_read_full_raster_as() {
258 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
259 let rv = dataset.read_full_raster_as::<u8>(1).unwrap();
260 assert_eq!(rv.size.0, 100);
261 assert_eq!(rv.size.1, 50);
262 }
263
264 #[test]
265 #[cfg(feature = "ndarray")]
test_read_block_as_array()266 fn test_read_block_as_array() {
267 let band_index = 1;
268 let block_index = (0, 0);
269 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
270 let rasterband = dataset.rasterband(band_index).unwrap();
271 let result = rasterband.read_block::<u8>(block_index);
272 assert!(result.is_ok());
273 }
274
275 #[test]
276 #[cfg(feature = "ndarray")]
test_read_block_dimension()277 fn test_read_block_dimension() {
278 let band_index = 1;
279 let block = (0, 0);
280 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
281 let rasterband = dataset.rasterband(band_index).unwrap();
282 let array = rasterband.read_block::<u8>(block).unwrap();
283 let dimension = (1, 100);
284 assert_eq!(array.dim(), dimension);
285 }
286
287 #[test]
288 #[cfg(feature = "ndarray")]
test_read_block_last_dimension()289 fn test_read_block_last_dimension() {
290 let band_index = 1;
291 let block = (0, 49);
292 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
293 let rasterband = dataset.rasterband(band_index).unwrap();
294 let array = rasterband.read_block::<u8>(block).unwrap();
295 let dimension = (1, 100);
296 assert_eq!(array.dim(), dimension);
297 }
298
299 #[test]
300 #[cfg(feature = "ndarray")]
test_read_block_data()301 fn test_read_block_data() {
302 let band_index = 1;
303 let block = (0, 0);
304 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
305 let rasterband = dataset.rasterband(band_index).unwrap();
306 let array = rasterband.read_block::<u8>(block).unwrap();
307 assert_eq!(array[[0, 0]], 0);
308 assert_eq!(array[[0, 1]], 9);
309 assert_eq!(array[[0, 98]], 24);
310 assert_eq!(array[[0, 99]], 51);
311 }
312
313
314 #[test]
test_get_band_type()315 fn test_get_band_type() {
316 let driver = Driver::get("MEM").unwrap();
317 let dataset = driver.create("", 20, 10, 1).unwrap();
318 assert_eq!(dataset.band_type(1).unwrap(), GDALDataType::GDT_Byte);
319 assert!(dataset.band_type(2).is_err());
320 }
321
322 #[test]
test_get_rasterband()323 fn test_get_rasterband() {
324 let driver = Driver::get("MEM").unwrap();
325 let dataset = driver.create("", 20, 10, 1).unwrap();
326 let rasterband = dataset.rasterband(1);
327 assert!(rasterband.is_ok())
328 }
329
330 #[test]
test_get_no_data_value()331 fn test_get_no_data_value() {
332 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
333 let rasterband = dataset.rasterband(1).unwrap();
334 let no_data_value = rasterband.no_data_value();
335 assert!(no_data_value.is_none());
336
337 // let dataset = Dataset::open(fixture!("bluemarble.tif")).unwrap();
338 // let rasterband = dataset.get_rasterband(1).unwrap();
339 // let no_data_value = rasterband.get_no_data_value();
340 // assert_eq!(no_data_value, Some(0.0));
341 }
342
343 #[test]
test_set_no_data_value()344 fn test_set_no_data_value() {
345 let driver = Driver::get("MEM").unwrap();
346 let dataset = driver.create("", 20, 10, 1).unwrap();
347 let rasterband = dataset.rasterband(1).unwrap();
348 assert_eq!(rasterband.no_data_value(), None);
349 assert!(rasterband.set_no_data_value(3.14).is_ok());
350 assert_eq!(rasterband.no_data_value(), Some(3.14));
351 }
352
353 #[test]
test_get_scale()354 fn test_get_scale() {
355 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
356 let rasterband = dataset.rasterband(1).unwrap();
357 let scale = rasterband.scale();
358 assert_eq!(scale, Some(1.0));
359 }
360
361 #[test]
test_get_offset()362 fn test_get_offset() {
363 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
364 let rasterband = dataset.rasterband(1).unwrap();
365 let offset = rasterband.offset();
366 assert_eq!(offset, Some(0.0));
367 }
368
369
370 #[test]
test_get_rasterband_size()371 fn test_get_rasterband_size() {
372 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
373 let rasterband = dataset.rasterband(1).unwrap();
374 let size = rasterband.size();
375 assert_eq!(size, (100, 50));
376 }
377
378 #[test]
test_get_rasterband_block_size()379 fn test_get_rasterband_block_size() {
380 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
381 let rasterband = dataset.rasterband(1).unwrap();
382 let size = rasterband.block_size();
383 assert_eq!(size, (100, 1));
384 }
385
386 #[test]
387 #[cfg(feature = "gdal_2_2")]
test_get_rasterband_actual_block_size()388 fn test_get_rasterband_actual_block_size() {
389 let dataset = Dataset::open(fixture!("tinymarble.png")).unwrap();
390 let rasterband = dataset.rasterband(1).unwrap();
391 let size = rasterband.actual_block_size((0,40));
392 assert_eq!(size.unwrap(), (100, 1));
393 }
394