yirgacheffe 1.2.0__py3-none-any.whl

yirgacheffe/layers/base.py

@@ -0,0 +1,265 @@
+
+from typing import Any, List, Optional, Tuple
+
+from ..operators import LayerMathMixin
+from ..rounding import almost_equal, are_pixel_scales_equal_enough, round_up_pixels, round_down_pixels
+from ..window import Area, PixelScale, Window
+
+class YirgacheffeLayer(LayerMathMixin):
+    """The common base class for the different layer types. Most still inherit from RasterLayer as deep down
+    they end up as pixels, but this is a start to make other layers that don't need to rasterize not have
+    to carry all that baggage."""
+
+    def __init__(self,
+        area: Area,
+        pixel_scale: Optional[PixelScale],
+        projection: str,
+        name: Optional[str] = None
+    ):
+        self._pixel_scale = pixel_scale
+        self._underlying_area = area
+        self._active_area = area
+        self._projection = projection
+        self._window: Optional[Window] = None
+        self.name = name
+
+        self.reset_window()
+
+    def close(self):
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    @property
+    def datatype(self) -> int:
+        raise NotImplementedError("Must be overridden by subclass")
+
+    @property
+    def projection(self) -> str:
+        return self._projection
+
+    @property
+    def pixel_scale(self) -> Optional[PixelScale]:
+        return self._pixel_scale
+
+    @property
+    def area(self) -> Area:
+        return self._active_area
+
+    @property
+    def window(self) -> Window:
+        if self._window is None:
+            raise AttributeError("Layer has no window")
+        return self._window
+
+    @staticmethod
+    def find_intersection(layers: List) -> Area:
+        if not layers:
+            raise ValueError("Expected list of layers")
+
+        # This only makes sense (currently) if all layers
+        # have the same pixel pitch (modulo desired accuracy)
+        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
+            raise ValueError("Not all layers are at the same pixel scale")
+
+        intersection = Area(
+            left=max(x._underlying_area.left for x in layers),
+            top=min(x._underlying_area.top for x in layers),
+            right=min(x._underlying_area.right for x in layers),
+            bottom=max(x._underlying_area.bottom for x in layers)
+        )
+        if (intersection.left >= intersection.right) or (intersection.bottom >= intersection.top):
+            raise ValueError('No intersection possible')
+        return intersection
+
+    @staticmethod
+    def find_union(layers: List) -> Area:
+        if not layers:
+            raise ValueError("Expected list of layers")
+
+        # This only makes sense (currently) if all layers
+        # have the same pixel pitch (modulo desired accuracy)
+        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
+            raise ValueError("Not all layers are at the same pixel scale")
+
+        return Area(
+            left=min(x._underlying_area.left for x in layers),
+            top=max(x._underlying_area.top for x in layers),
+            right=max(x._underlying_area.right for x in layers),
+            bottom=min(x._underlying_area.bottom for x in layers)
+        )
+
+    @property
+    def geo_transform(self) -> Tuple[float, float, float, float, float, float]:
+        if self._pixel_scale is None:
+            raise ValueError("No geo transform for layers without explicit pixel scale")
+        return (
+            self._active_area.left, self._pixel_scale.xstep, 0.0,
+            self._active_area.top, 0.0, self._pixel_scale.ystep
+        )
+
+    def check_pixel_scale(self, scale: PixelScale) -> bool:
+        our_scale = self.pixel_scale
+        if our_scale is None:
+            raise ValueError("No check for layers without explicit pixel scale")
+        return almost_equal(our_scale.xstep, scale.xstep) and \
+            almost_equal(our_scale.ystep, scale.ystep)
+
+    def set_window_for_intersection(self, new_area: Area) -> None:
+        if self._pixel_scale is None:
+            raise ValueError("Can not set Window without explicit pixel scale")
+
+        new_window = Window(
+            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._pixel_scale.ystep * -1.0),
+                self._pixel_scale.ystep * -1.0),
+            xsize=round_up_pixels(
+                (new_area.right - new_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep
+            ),
+            ysize=round_up_pixels(
+                (new_area.top - new_area.bottom) / (self._pixel_scale.ystep * -1.0),
+                (self._pixel_scale.ystep * -1.0)
+            ),
+        )
+        if (new_window.xoff < 0) or (new_window.yoff < 0):
+            raise ValueError('Window has negative offset')
+        # If there is an underlying raster for this layer, do a sanity check
+        try:
+            if ((new_window.xoff + new_window.xsize) > self._raster_xsize) or \
+                ((new_window.yoff + new_window.ysize) > self._raster_ysize):
+                raise ValueError(f'Window is bigger than dataset: raster is {self._raster_xsize}x{self._raster_ysize}'\
+                    f', new window is {new_window.xsize - new_window.xoff}x{new_window.ysize - new_window.yoff}')
+        except AttributeError:
+            pass
+        self._window = new_window
+        self._active_area = new_area
+
+    def set_window_for_union(self, new_area: Area) -> None:
+        if self._pixel_scale is None:
+            raise ValueError("Can not set Window without explicit pixel scale")
+
+        new_window = Window(
+            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._pixel_scale.ystep * -1.0),
+                self._pixel_scale.ystep * -1.0),
+            xsize=round_up_pixels(
+                (new_area.right - new_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep
+            ),
+            ysize=round_up_pixels(
+                (new_area.top - new_area.bottom) / (self._pixel_scale.ystep * -1.0),
+                (self._pixel_scale.ystep * -1.0)
+            ),
+        )
+        if (new_window.xoff > 0) or (new_window.yoff > 0):
+            raise ValueError('Window has positive offset')
+        # If there is an underlying raster for this layer, do a sanity check
+        try:
+            if ((new_window.xsize - new_window.xoff) < self._raster_xsize) or \
+                ((new_window.ysize - new_window.yoff) < self._raster_ysize):
+                raise ValueError(f'Window is smaller than dataset: raster is {self._raster_xsize}x{self._raster_ysize}'\
+                    f', new window is {new_window.xsize - new_window.xoff}x{new_window.ysize - new_window.yoff}')
+        except AttributeError:
+            pass
+        self._window = new_window
+        self._active_area = new_area
+
+    def reset_window(self):
+        self._active_area = self._underlying_area
+        if self._pixel_scale:
+            abs_xstep, abs_ystep = abs(self._pixel_scale.xstep), abs(self._pixel_scale.ystep)
+            self._window = Window(
+                xoff=0,
+                yoff=0,
+                xsize=round_up_pixels((self.area.right - self.area.left) / self._pixel_scale.xstep, abs_xstep),
+                ysize=round_up_pixels((self.area.bottom - self.area.top) / self._pixel_scale.ystep, abs_ystep),
+            )
+
+    def offset_window_by_pixels(self, offset: int):
+        """Grows (if pixels is positive) or shrinks (if pixels is negative) the window for the layer."""
+        if offset == 0:
+            return
+
+        if offset < 0:
+            if (offset * -2 >= self.window.xsize) or (offset * -2 >= self.window.ysize):
+                raise ValueError(f"Can not shrink window by {offset}, would make size 0 or fewer pixels.")
+
+        new_window = Window(
+            xoff=self.window.xoff - offset,
+            yoff=self.window.yoff - offset,
+            xsize=self.window.xsize + (2 * offset),
+            ysize=self.window.ysize + (2 * offset),
+        )
+        scale = self.pixel_scale
+        if scale is None:
+            raise ValueError("Can not offset Window without explicit pixel scale")
+
+        # Note we can't assume that we weren't already on an intersection when making the offset!
+        # But remember that window is always relative to underlying area, and new_window
+        # here is based off the existing window
+        new_left = self._underlying_area.left + (new_window.xoff * scale.xstep)
+        new_top = self._underlying_area.top + (new_window.yoff * scale.ystep)
+        new_area = Area(
+            left=new_left,
+            top=new_top,
+            right=new_left + (new_window.xsize * scale.xstep),
+            bottom=new_top + (new_window.ysize * scale.ystep)
+        )
+        self._window = new_window
+        self._active_area = new_area
+
+    def read_array_with_window(self, _x: int, _y: int, _xsize: int, _ysize: int, window: Window) -> Any:
+        raise NotImplementedError("Must be overridden by subclass")
+
+    def read_array_for_area(self, target_area: Area, x: int, y: int, width: int, height: int) -> Any:
+
+        target_window = Window(
+            xoff=round_down_pixels((target_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - target_area.top) / (self._pixel_scale.ystep * -1.0),
+                self._pixel_scale.ystep * -1.0),
+            xsize=round_up_pixels(
+                (target_area.right - target_area.left) / self._pixel_scale.xstep,
+                self._pixel_scale.xstep
+            ),
+            ysize=round_up_pixels(
+                (target_area.top - target_area.bottom) / (self._pixel_scale.ystep * -1.0),
+                (self._pixel_scale.ystep * -1.0)
+            ),
+        )
+        return self.read_array_with_window(x, y, width, height, target_window)
+
+    def read_array(self, x: int, y: int, width: int, height: int) -> Any:
+        return self.read_array_with_window(x, y, width, height, self.window)
+
+    def latlng_for_pixel(self, x_coord: int, y_coord: int) -> Tuple[float,float]:
+        """Get geo coords for pixel. This is relative to the set view window."""
+        if "WGS 84" not in self.projection:
+            raise NotImplementedError("Not yet supported for other projections")
+        pixel_scale = self.pixel_scale
+        if pixel_scale is None:
+            raise ValueError("Layer has no pixel scale")
+        return (
+            (y_coord * pixel_scale.ystep) + self.area.top,
+            (x_coord * pixel_scale.xstep) + self.area.left
+        )
+
+    def pixel_for_latlng(self, lat: float, lng: float) -> Tuple[int,int]:
+        """Get pixel for geo coords. This is relative to the set view window.
+        Result is rounded down to nearest pixel."""
+        if "WGS 84" not in self.projection:
+            raise NotImplementedError("Not yet supported for other projections")
+        pixel_scale = self.pixel_scale
+        if pixel_scale is None:
+            raise ValueError("Layer has no pixel scale")
+        return (
+            round_down_pixels((lng - self.area.left) / pixel_scale.xstep, abs(pixel_scale.xstep)),
+            round_down_pixels((lat - self.area.top) / pixel_scale.ystep, abs(pixel_scale.ystep)),
+        )

yirgacheffe/layers/constant.py

@@ -0,0 +1,41 @@
+from typing import Any, Union
+
+from osgeo import gdal
+
+from ..window import Area, PixelScale, Window
+from .base import YirgacheffeLayer
+from ..backends import backend
+from .. import WGS_84_PROJECTION
+
+
+class ConstantLayer(YirgacheffeLayer):
+    """This is a layer that will return the identity value - can be used when an input layer is
+    missing (e.g., area) without having the calculation full of branches."""
+    def __init__(self, value: Union[int,float]): # pylint: disable=W0231
+        area = Area(
+            left = -180.0,
+            top = 90.0,
+            right = 180.0,
+            bottom = -90.0
+        )
+        super().__init__(area, None, WGS_84_PROJECTION)
+        self.value = float(value)
+
+    @property
+    def datatype(self) -> int:
+        return gdal.GDT_Float64
+
+    def check_pixel_scale(self, _scale: PixelScale) -> bool:
+        return True
+
+    def set_window_for_intersection(self, _intersection: Area) -> None:
+        pass
+
+    def read_array(self, _x: int, _y: int, width: int, height: int) -> Any:
+        return backend.full((height, width), self.value)
+
+    def read_array_with_window(self, _x: int, _y: int, width: int, height: int, _window: Window) -> Any:
+        return backend.full((height, width), self.value)
+
+    def read_array_for_area(self, _target_area: Area, x: int, y: int, width: int, height: int) -> Any:
+        return self.read_array(x, y, width, height)

yirgacheffe/layers/group.py

@@ -0,0 +1,357 @@
+import copy
+import glob
+import os
+from typing import Any, List, Optional, TypeVar
+
+import numpy as np
+
+from ..rounding import are_pixel_scales_equal_enough, round_down_pixels
+from ..window import Area, Window
+from .base import YirgacheffeLayer
+from .rasters import RasterLayer
+from ..backends import backend
+
+GroupLayerT = TypeVar("GroupLayerT", bound="GroupLayer")
+
+class GroupLayerEmpty(ValueError):
+    def __init__(self, msg):
+        self.msg = msg
+
+class GroupLayer(YirgacheffeLayer):
+
+    @classmethod
+    def layer_from_directory(
+        cls,
+        directory_path: str,
+        name: Optional[str] = None,
+        matching: str = "*.tif"
+    ) -> GroupLayerT:
+        if directory_path is None:
+            raise ValueError("Directory path is None")
+        files = [os.path.join(directory_path, x) for x in glob.glob(matching, root_dir=directory_path)]
+        if len(files) < 1:
+            raise GroupLayerEmpty(directory_path)
+        return cls.layer_from_files(files, name)
+
+    @classmethod
+    def layer_from_files(cls, filenames: List[str], name: Optional[str] = None) -> GroupLayerT:
+        if filenames is None:
+            raise ValueError("filenames argument is None")
+        if len(filenames) < 1:
+            raise GroupLayerEmpty("No files found")
+        rasters = [RasterLayer.layer_from_file(x) for x in filenames]
+        return cls(rasters, name)
+
+    def __init__(self, layers: List[YirgacheffeLayer], name: Optional[str] = None) -> None:
+        if not layers:
+            raise GroupLayerEmpty("Expected one or more layers")
+        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
+            raise ValueError("Not all layers are at the same pixel scale")
+        if not all(x.projection == layers[0].projection for x in layers):
+            raise ValueError("Not all layers are the same projection")
+        for layer in layers:
+            if layer._active_area != layer._underlying_area:
+                raise ValueError("Layers can not currently be constrained")
+
+        # area/window are superset of all tiles
+        union = YirgacheffeLayer.find_union(layers)
+        super().__init__(union, layers[0].pixel_scale, layers[0].projection, name=name)
+
+        # We store them in reverse order so that from the user's perspective
+        # the first layer in the list will be the most important in terms
+        # over overlapping.
+        self._underlying_layers = copy.copy(layers)
+        self._underlying_layers.reverse()
+        self.layers = self._underlying_layers
+
+    def _park(self):
+        for layer in self.layers:
+            try:
+                layer._park()
+            except AttributeError:
+                pass
+
+    @property
+    def datatype(self):
+        return self.layers[0].datatype
+
+    def set_window_for_intersection(self, new_area: Area) -> None:
+        super().set_window_for_intersection(new_area)
+
+        # filter out layers we don't care about
+        self.layers = [layer for layer in self._underlying_layers if layer.area.overlaps(new_area)]
+
+    def set_window_for_union(self, new_area: Area) -> None:
+        super().set_window_for_union(new_area)
+
+        # filter out layers we don't care about
+        self.layers = [layer for layer in self._underlying_layers if layer.area.overlaps(new_area)]
+
+    def reset_window(self) -> None:
+        super().reset_window()
+        try:
+            self.layers = self._underlying_layers
+        except AttributeError:
+            pass # called from Base constructor before we've added the extra field
+
+    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+
+        if (xsize <= 0) or (ysize <= 0):
+            raise ValueError("Request dimensions must be positive and non-zero")
+
+        scale = self.pixel_scale
+        assert scale is not None
+
+        target_window = Window(
+            window.xoff + xoffset,
+            window.yoff + yoffset,
+            xsize,
+            ysize
+        )
+
+        contributing_layers = []
+        for layer in self.layers:
+            # Normally this is hidden with set_window_for_...
+            adjusted_layer_window = Window(
+                layer.window.xoff + \
+                    round_down_pixels(((layer.area.left - self._underlying_area.left) / scale.xstep), abs(scale.xstep)),
+                layer.window.yoff + \
+                    round_down_pixels(((layer.area.top - self._underlying_area.top) / scale.ystep), abs(scale.ystep)),
+                layer.window.xsize,
+                layer.window.ysize,
+            )
+            intersection = Window.find_intersection_no_throw([target_window, adjusted_layer_window])
+            if intersection is not None:
+                contributing_layers.append((layer, adjusted_layer_window, intersection))
+
+        # Adding the numpy arrays over each other is relatively expensive, so if we only intersect
+        # with a single layer, turn this into a direct read
+        if len(contributing_layers) == 1:
+            layer, adjusted_layer_window, intersection = contributing_layers[0]
+            if target_window == intersection:
+                return layer.read_array(
+                    intersection.xoff - adjusted_layer_window.xoff,
+                    intersection.yoff - adjusted_layer_window.yoff,
+                    intersection.xsize,
+                    intersection.ysize
+                )
+
+        result = np.zeros((ysize, xsize), dtype=float)
+        for layer, adjusted_layer_window, intersection in contributing_layers:
+            data = layer.read_array(
+                intersection.xoff - adjusted_layer_window.xoff,
+                intersection.yoff - adjusted_layer_window.yoff,
+                intersection.xsize,
+                intersection.ysize
+            )
+            result_x_offset = (intersection.xoff - xoffset) - window.xoff
+            result_y_offset = (intersection.yoff - yoffset) - window.yoff
+            result[
+                result_y_offset:result_y_offset + intersection.ysize,
+                result_x_offset:result_x_offset + intersection.xsize
+            ] = data
+
+        return backend.promote(result)
+
+class TileData:
+    """This class exists just to let me sort the tiles into the correct order for processing."""
+
+    def __init__(self, data, x, y):
+        self.data = data
+        self.x = x
+        self.y = y
+
+    @property
+    def origin(self):
+        return (self.x, self.y)
+
+    @property
+    def width(self):
+        return self.data.shape[1]
+
+    @property
+    def height(self):
+        return self.data.shape[0]
+
+    def __cmp__(self, other):
+        if self.y != other.y:
+            return self.y.cmp(other.y)
+        else:
+            return self.x.cmp(other.x)
+
+    def __gt__(self, other):
+        if self.y > other.y:
+            return True
+        if self.y < other.y:
+            return False
+        return self.x.__gt__(other.x)
+
+    def __repr__(self):
+        if self.data is not None:
+            return f"<Tile: {self.x} {self.y} {self.data.shape[1]} {self.data.shape[0]}>"
+        else:
+            return "<Tile: sentinal>"
+
+class TiledGroupLayer(GroupLayer):
+    """An optimised version of GroupLayer for the case where you have a grid of regular sized
+    layers, e.g., map tiles.
+
+    This class exists as assembling arbitrary shaped tiles into a group is quite slow due
+    to numpy being slow to modify one array with the contents of another. This class does
+    away with that at the expense of needing to know all tiles have the same shape.__abs__()
+
+    Two notes:
+    * You can have missing tiles, and it'll fill in zeros.
+    * The tiles can overlap - e.g., JRC Annual Change tiles all overlap by a few pixels on all edges.
+    """
+    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+        if (xsize <= 0) or (ysize <= 0):
+            raise ValueError("Request dimensions must be positive and non-zero")
+
+        scale = self.pixel_scale
+        assert scale is not None
+
+        target_window = Window(
+            window.xoff + xoffset,
+            window.yoff + yoffset,
+            xsize,
+            ysize
+        )
+
+        partials = []
+        for layer in self.layers:
+            # Normally this is hidden with set_window_for_...
+            adjusted_layer_window = Window(
+                layer.window.xoff + \
+                    round_down_pixels(((layer.area.left - self._underlying_area.left) / scale.xstep), abs(scale.xstep)),
+                layer.window.yoff + \
+                    round_down_pixels(((layer.area.top - self._underlying_area.top) / scale.ystep), abs(scale.ystep)),
+                layer.window.xsize,
+                layer.window.ysize,
+            )
+            intersection = Window.find_intersection_no_throw([target_window, adjusted_layer_window])
+            if intersection is None:
+                continue
+            data = layer.read_array(
+                intersection.xoff - adjusted_layer_window.xoff,
+                intersection.yoff - adjusted_layer_window.yoff,
+                intersection.xsize,
+                intersection.ysize
+            )
+            result_x_offset = (intersection.xoff - xoffset) - window.xoff
+            result_y_offset = (intersection.yoff - yoffset) - window.yoff
+            partials.append(TileData(data, result_x_offset, result_y_offset))
+
+        sorted_partials = sorted(partials)
+
+        # When tiles overlap (hello JRC Annual Change!), then if the read aligns
+        # with the edge of a tile, then we can end up with multiple results at the same
+        # offset as we get the dregs of the above/left tile and the bulk of the data from
+        # the "obvious" tile. In which case, we should reject the smaller section. If we have
+        # two tiles at the same offset and one is not a perfect subset of the other then the
+        # tile set we were given is not regularly shaped, and so we should give up.
+        combed_partials = []
+        previous_tile = None
+        for tile in sorted_partials:
+            if previous_tile is None:
+                previous_tile = tile
+                continue
+
+            if previous_tile.origin == tile.origin:
+                if (tile.width >= previous_tile.width) and \
+                    (tile.height >= previous_tile.height):
+                    previous_tile = tile
+                continue
+
+            combed_partials.append(previous_tile)
+            previous_tile = tile
+        if previous_tile:
+            combed_partials.append(previous_tile)
+
+        # Add a terminator to force the last row to be added
+        combed_partials.append(TileData(None, 0, -1))
+        last_y_offset = None
+        last_y_height = 0
+        expected_next_x = 0
+        expected_next_y = 0
+        data = None
+        row_chunk = None
+
+        # Allow for reading off top
+        if combed_partials:
+            if combed_partials[0].y > 0:
+                row_chunk = np.zeros((combed_partials[0].y, xsize))
+                last_y_offset = 0
+                last_y_height = combed_partials[0].y
+
+        for tile in combed_partials:
+            if tile.y == last_y_offset:
+                assert row_chunk is not None
+                if row_chunk.shape[0] < tile.data.shape[0]:
+                    assert last_y_height == row_chunk.shape[0]
+                    row_chunk = np.vstack(
+                        (row_chunk, np.zeros((tile.data.shape[0] - row_chunk.shape[0], row_chunk.shape[1])))
+                    )
+                    last_y_height = row_chunk.shape[0]
+                new_data = tile.data
+                if row_chunk.shape[0] != new_data.shape[0]:
+                    assert row_chunk.shape[0] > new_data.shape[0]
+                    # we have some overlap data from oversized tiles (hello JRC) when there's a GAP in general
+                    new_data = np.vstack(
+                        (new_data, np.zeros((row_chunk.shape[0] - new_data.shape[0], new_data.shape[1])))
+                    )
+                assert row_chunk.shape[0] == new_data.shape[0]
+
+                # We're adding a tile to an existing row
+                x_offset = expected_next_x - tile.x
+                if x_offset == 0:
+                    # Tiles line up neatly!
+                    row_chunk = np.hstack((row_chunk, new_data))
+                    expected_next_x = expected_next_x + new_data.shape[1]
+                elif x_offset > 0:
+                    # tiles overlap
+                    remainder = new_data.shape[1] - xoffset
+                    if remainder > 0:
+                        subdata = np.delete(new_data, np.s_[0:x_offset], 1)
+                        row_chunk = np.hstack((row_chunk, subdata))
+                        expected_next_x = expected_next_x + subdata.shape[1]
+                else:
+                    # Gap between tiles, so fill it before adding new data
+                    row_chunk = np.hstack((row_chunk, np.zeros((new_data.shape[0], -x_offset))))
+                    row_chunk = np.hstack((row_chunk, new_data))
+                    expected_next_x = expected_next_x + new_data.shape[1] + -x_offset
+            else:
+                # This is a new row, so we need to add the row in progress
+                # and start a new one
+                if row_chunk is not None:
+                    if row_chunk.shape[1] != xsize:
+                        assert row_chunk.shape[1] < xsize, f"row is too wide: expected {xsize}, is {row_chunk.shape[1]}"
+                        # Missing tile at end of row, so fill in
+                        row_chunk = np.hstack((row_chunk, np.zeros((last_y_height, xsize - row_chunk.shape[1]))))
+                    if data is None:
+                        data = row_chunk
+                        expected_next_y += last_y_height
+                    else:
+                        if last_y_offset == expected_next_y:
+                            data = np.vstack((data, row_chunk))
+                            expected_next_y += last_y_height
+                        else:
+                            diff = expected_next_y - last_y_offset
+                            assert diff > 0, f"{expected_next_y} - {last_y_offset} <= 0 (aka {diff})"
+                            subdata = np.delete(row_chunk, np.s_[0:diff], 0)
+                            data = np.vstack((data, subdata))
+                            expected_next_y += subdata.shape[0]
+                if tile.data is not None:
+                    if tile.x != 0:
+                        row_chunk = np.hstack((np.zeros((tile.data.shape[0], tile.x)), tile.data))
+                    else:
+                        row_chunk = tile.data
+                    last_y_offset = tile.y
+                    last_y_height = tile.data.shape[0]
+                    expected_next_x = tile.data.shape[1] + tile.x
+
+        if (last_y_offset + last_y_height) < ysize:
+            data = np.vstack((data, np.zeros((ysize - (last_y_offset + last_y_height), xsize))))
+
+        assert data.shape == (ysize, xsize)
+        return backend.promote(data)