tiledimage 0.3.1__tar.gz → 0.6.0__tar.gz

{tiledimage-0.3.1 → tiledimage-0.6.0}/PKG-INFO

@@ -1,18 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: tiledimage
-Version: 0.3.1
+Version: 0.6.0
 Summary: tools for tiled image that can be cached on a filesystem.
 License: MIT
 Author: vitroid
 Author-email: vitroid@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: opencv-python-headless (>=4.11.0.86,<5.0.0.0)
 Requires-Dist: pylru (>=1.2.1,<2.0.0)
+Requires-Dist: pyperbox (>=0.1.1,<0.2.0)
+Requires-Dist: rasterio (>=1.4.3,<2.0.0)
+Requires-Dist: tifffile (>=2025.9.9,<2026.0.0)
 Description-Content-Type: text/markdown
 
 #TiledImage

{tiledimage-0.3.1 → tiledimage-0.6.0}/pyproject.toml

@@ -1,15 +1,18 @@
 [tool.poetry]
 name = "tiledimage"
-version = "0.3.1"
+version = "0.6.0"
 description = "tools for tiled image that can be cached on a filesystem."
 authors = ["vitroid <vitroid@gmail.com>"]
 license = "MIT"
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = "^3.10"
+python = "^3.11"
 pylru = "^1.2.1"
 opencv-python-headless = "^4.11.0.86"
+tifffile = "^2025.9.9"
+rasterio = "^1.4.3"
+pyperbox = "^0.1.1"
 
 [tool.poetry.scripts]
 pngs2 = "tiledimage.pngs2:main"

tiledimage-0.6.0/tiledimage/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.0"
+

{tiledimage-0.3.1 → tiledimage-0.6.0}/tiledimage/cachedimage.py

@@ -5,6 +5,7 @@ import numpy as np
 
 from tiledimage.tiledimage import TiledImage
 import tiledimage.tilecache as tilecache
+from pyperbox import Rect, Range
 
 
 class CachedImage(TiledImage):
@@ -33,14 +34,42 @@ class CachedImage(TiledImage):
         self.modified = False
         if mode == "inherit":
             # read the info.txt in the dir.
-            self.region = [None, None]
-            with open(f"{dir}/info.json", "r") as file:
-                info = json.load(file)
-                self.region[0] = info["xrange"]
-                self.region[1] = info["yrange"]
-                self.tilesize = info["tilesize"]
-                self.bgcolor = info["bgcolor"]
-                self.fileext = info["filetype"]
+            self.rect = None
+            try:
+                with open(f"{dir}/info.json", "r") as file:
+                    info = json.load(file)
+                    self.rect = Rect(
+                        x_range=Range(
+                            min_val=info["xrange"][0], max_val=info["xrange"][1]
+                        ),
+                        y_range=Range(
+                            min_val=info["yrange"][0], max_val=info["yrange"][1]
+                        ),
+                    )
+                    self.tilesize = info["tilesize"]
+                    self.bgcolor = info["bgcolor"]
+                    self.fileext = info["filetype"]
+            except FileNotFoundError:
+                # backward compatibility
+                xrange = None
+                yrange = None
+                with open(f"{dir}/info.txt", "r") as file:
+                    while True:
+                        line = file.readline().strip()
+                        if len(line) == 0:
+                            break
+                        cols = line.split(" ")
+                        if cols[-1] == "xrange":
+                            xrange = Range(min_val=int(cols[0]), max_val=int(cols[1]))
+                        if cols[-1] == "yrange":
+                            yrange = Range(min_val=int(cols[0]), max_val=int(cols[1]))
+                        if cols[-1] == "tilesize":
+                            self.tilesize = [int(cols[0]), int(cols[1])]
+                        if cols[-1] == "bgcolor":
+                            self.bgcolor = [int(cols[0]), int(cols[1]), int(cols[2])]
+                        if cols[-1] == "filetype":
+                            self.fileext = cols[-1]
+                self.rect = Rect(x_range=xrange, y_range=yrange)
         defaulttile = np.zeros((self.tilesize[1], self.tilesize[0], 3), dtype=np.uint8)
         self.bgcolor = np.array(self.bgcolor)
         # logger.info("Color: {0}".format(self.bgcolor))
@@ -74,8 +103,8 @@ class CachedImage(TiledImage):
         if isinstance(bgcolor, np.ndarray):
             bgcolor = bgcolor.tolist()
         info = dict(
-            xrange=self.region[0],
-            yrange=self.region[1],
+            xrange=self.rect.x_range.as_list(),
+            yrange=self.rect.y_range.as_list(),
             tilesize=self.tilesize,
             bgcolor=bgcolor,
             filetype=self.fileext,
@@ -84,15 +113,36 @@ class CachedImage(TiledImage):
             json.dump(info, file)
         self.tiles.done()  # タイルキャッシュの終了処理を呼び出す
 
-    def put_image(self, pos, img, linear_alpha=None):
-        super(CachedImage, self).put_image(pos, img, linear_alpha)
+    def put_image(self, pos, img, linear_alpha=None, full_alpha=None):
+        super(CachedImage, self).put_image(pos, img, linear_alpha, full_alpha)
         self.modified = True
         logger = getLogger()
         nmiss, naccess, cachesize = self.tiles.cachemiss()
-        logger.info(
+        logger.debug(
             "Cache miss {0}% @ {1} tiles".format(nmiss * 100 // naccess, cachesize)
         )
         self.tiles.adjust_cache_size()
 
     def set_hook(self, hook):
         self.tiles.set_hook(hook)
+
+
+def test():
+    import sys
+    import cv2
+
+    png = sys.argv[1]
+    tilesize = int(sys.argv[2])
+    with CachedImage("new", tilesize=tilesize) as tiled_image:
+        tiled_image[10:, 20:] = cv2.imread(png)
+        tiled_image[-10:, -20:] = cv2.imread(png)
+        image = tiled_image[:, :]
+
+    with CachedImage("inherit", dir="image.pngs") as tiled_image:
+        cv2.imshow("image", tiled_image.get_image(width=100))
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    test()

{tiledimage-0.3.1 → tiledimage-0.6.0}/tiledimage/pngs2.py

@@ -1,11 +1,7 @@
 #!/usr/bin/env python
 
-from __future__ import print_function
-
 import sys
-
 import cv2
-
 import tiledimage.cachedimage as ci
 
 

tiledimage-0.6.0/tiledimage/simpleimage.py

@@ -0,0 +1,175 @@
+import logging
+
+# external modules
+import numpy as np
+from pyperbox import Rect
+
+
+class SimpleImage:
+
+    def __init__(self, bgcolor=(100, 100, 100)):
+        self.rect = None
+        self.bgcolor = np.array(bgcolor, dtype=np.uint8)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass  # TiledImageは特別なクリーンアップ処理は必要ありません
+
+    def _parse_slice(self, key):
+        """スライスを解析してRectに変換する
+
+        Args:
+            key: スライスまたはタプル。例: (slice(0, 10), slice(0, 20))
+
+        Returns:
+            Rect: スライスに対応する領域
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            raise IndexError("2次元のスライスを指定してください")
+
+        y_slice, x_slice = key
+        if not (isinstance(y_slice, slice) and isinstance(x_slice, slice)):
+            raise IndexError("スライスを指定してください")
+
+        # スライスの開始と終了を取得
+        y_start = y_slice.start if y_slice.start is not None else 0
+        y_stop = y_slice.stop if y_slice.stop is not None else float("inf")
+        x_start = x_slice.start if x_slice.start is not None else 0
+        x_stop = x_slice.stop if x_slice.stop is not None else float("inf")
+
+        # ステップは未対応
+        if y_slice.step is not None or x_slice.step is not None:
+            raise NotImplementedError("ステップ付きスライスには未対応です")
+
+        return Rect.from_bounds(x_start, x_stop, y_start, y_stop)
+
+    def __getitem__(self, key):
+        """スライスで領域を取得する
+
+        Example:
+            image = tiled_image[10:20, 30:40]  # 10:20行、30:40列の領域を取得
+        """
+        region = self._parse_slice(key)
+        return self.get_region(region)
+
+    def __setitem__(self, key, value):
+        """スライスで領域を設定する
+
+        Example:
+            tiled_image[10:20, 30:40] = image  # 10:20行、30:40列の領域に画像を設定
+        """
+        if not isinstance(value, np.ndarray):
+            raise TypeError("NumPy配列を指定してください")
+
+        region = self._parse_slice(key)
+        self.put_image((region.x_range.min_val, region.y_range.min_val), value)
+
+    def get_region(self, rect: Rect | None = None):
+        logger = logging.getLogger()
+        if rect is None:
+            rect = self.rect
+        if rect is None:
+            return
+        logger.debug(f"get_region region:{rect}")
+        # # region.x_rangeが0:や:infの場合には、それぞれself.regionのx_rangeを使用する
+        if rect.left == 0:
+            rect.x_range.min_val = self.rect.left
+        if rect.right == float("inf"):
+            rect.x_range.max_val = self.rect.right
+        if rect.top == 0:
+            rect.y_range.min_val = self.rect.top
+        if rect.bottom == float("inf"):
+            rect.y_range.max_val = self.rect.bottom
+
+        dst_width = rect.width
+        dst_height = rect.height
+
+        image = np.zeros((dst_height, dst_width, 3), dtype=np.uint8) + self.bgcolor
+        crop = self.rect & rect
+        image[
+            crop.top - rect.top : crop.bottom - rect.top,
+            crop.left - rect.left : crop.right - rect.left,
+        ] = self.image[
+            crop.top - self.rect.top : crop.bottom - self.rect.top,
+            crop.left - self.rect.left : crop.right - self.rect.left,
+        ]
+        return image
+
+    def put_image(self, position, image, linear_alpha=None, full_alpha=None):
+        """
+        split the existent tiles
+        and put a big single tile.
+        the image must be larger than a single tile.
+        otherwise, a different algorithm is required.
+        """
+        h, w = image.shape[:2]
+        rect = Rect.from_bounds(
+            position[0], position[0] + w, position[1], position[1] + h
+        )
+        # expand the canvas
+        if self.rect is None:
+            self.rect = rect
+            self.image = image.copy()
+        else:
+            newrect = self.rect | rect
+            new_image = (
+                np.zeros([newrect.height, newrect.width, 3], dtype=np.uint8)
+                + self.bgcolor
+            )
+            new_image[
+                self.rect.top - newrect.top : self.rect.bottom - newrect.top,
+                self.rect.left - newrect.left : self.rect.right - newrect.left,
+            ] = self.image
+            self.image = new_image
+            self.rect = newrect
+
+            if linear_alpha is None and full_alpha is None:
+                self.image[
+                    rect.top - self.rect.top : rect.bottom - self.rect.top,
+                    rect.left - self.rect.left : rect.right - self.rect.left,
+                ] = image
+            else:
+                if full_alpha is not None:
+                    alpha = full_alpha[:, :, np.newaxis]
+                else:
+                    alpha = linear_alpha[np.newaxis, :, np.newaxis]
+                self.image[
+                    rect.top - self.rect.top : rect.bottom - self.rect.top,
+                    rect.left - self.rect.left : rect.right - self.rect.left,
+                    :,
+                ] = (
+                    alpha * image
+                    + (1 - alpha)
+                    * self.image[
+                        rect.top - self.rect.top : rect.bottom - self.rect.top,
+                        rect.left - self.rect.left : rect.right - self.rect.left,
+                        :,
+                    ]
+                )
+
+    def get_image(self):
+        # widthを指定すると縮小する。
+        return self.get_region(self.rect)
+
+
+def test():
+    import sys
+    import cv2
+    import logging
+
+    logging.basicConfig(level=logging.DEBUG)
+
+    png = sys.argv[1]
+    with SimpleImage() as canvas:
+        canvas[20:, 40:] = cv2.imread(png)
+        canvas[10:, 20:] = cv2.imread(png)
+        image = canvas[:, :]
+        cv2.imshow("image", image)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    test()

{tiledimage-0.3.1 → tiledimage-0.6.0}/tiledimage/tilecache.py

@@ -47,11 +47,11 @@ class TileCache:
         self.hook = hook
 
     def key_to_filename(self, key):
-        return "{0}/{1},{2}.{3}".format(self.dir, *key, self.fileext)
+        return f"{self.dir}/{key[0]},{key[1]}.{self.fileext}"
 
     def __getitem__(self, key):
         logger = logging.getLogger()
-        logger.debug("getitem key:{0}".format(key))
+        logger.debug(f"getitem key:{key}")
         self.nget += 1
         try:
             modified, value = self.cache[key]
@@ -60,17 +60,15 @@ class TileCache:
             if os.path.exists(filename):
                 value = cv2.imread(filename)
                 self.nmiss += 1
-                # logger.info("cache miss key:{0}".format(key))
             else:
-                # first access is not a "miss"
-                logger.info("blank key:{0}".format(key))
+                logger.info(f"blank key:{key}")
                 value = self.default
             self.cache[key] = [False, value]
         return value
 
     def __setitem__(self, key, value):
         logger = logging.getLogger()
-        logger.debug("update key:{0}".format(key))
+        logger.debug(f"update key:{key}")
         self.cache[key] = [True, value]
 
     def writeback(self, key, value):
@@ -79,20 +77,15 @@ class TileCache:
         """
         logger = logging.getLogger()
         if value[0]:
-            # logger.info("purge key:{0}".format(key))
             filename = self.key_to_filename(key)
             cv2.imwrite(filename, value[1])
             if self.hook is not None:
                 self.hook(key, value[1])
 
     def __contains__(self, key):
-        # logger = logging.getLogger()
-        # logger.debug("Query: {0}".format(key))
         if key in self.cache:
-            # logger.debug("On cache: {0}".format(key))
             return True
         filename = self.key_to_filename(key)
-        # logger.debug("On file: {0}".format(filename))
         return os.path.exists(filename)
 
     def done(self):

tiledimage-0.6.0/tiledimage/tiledimage.py

@@ -0,0 +1,207 @@
+import logging
+
+# external modules
+import numpy as np
+from pyperbox import Rect, Range
+import cv2
+
+from tiledimage.simpleimage import SimpleImage
+
+
+class TiledImage(SimpleImage):
+    """
+    it has no size.
+    size is determined by the tiles.
+    !!!   it is better to fix the tile size. (128x128, for example)
+    """
+
+    def __init__(self, tilesize=128, bgcolor=(100, 100, 100)):
+        super(TiledImage, self).__init__(bgcolor)
+        self.tiles = dict()
+        if type(tilesize) is int:
+            self.tilesize = (tilesize, tilesize)
+        else:
+            assert type(tilesize) is tuple
+            self.tilesize = tilesize
+
+    def tiles_containing(self, rect: Rect, includeempty=False):
+        """
+        return the tiles containing the given region
+        """
+        logger = logging.getLogger()
+        t = []
+        xran = (
+            rect.x_range.min_val // self.tilesize[0],
+            (rect.x_range.max_val + self.tilesize[0] - 1) // self.tilesize[0],
+        )
+        yran = (
+            rect.y_range.min_val // self.tilesize[1],
+            (rect.y_range.max_val + self.tilesize[1] - 1) // self.tilesize[1],
+        )
+        for ix in range(xran[0], xran[1]):
+            for iy in range(yran[0], yran[1]):
+                tile = (ix * self.tilesize[0], iy * self.tilesize[1])
+                logger.debug("Tile: {0}".format(tile))
+                if (tile in self.tiles) or includeempty:
+                    tregion = Rect.from_bounds(
+                        tile[0],
+                        tile[0] + self.tilesize[0],
+                        tile[1],
+                        tile[1] + self.tilesize[1],
+                    )
+                    o = tregion & rect
+                    t.append((tile, o))
+        return t
+
+    def get_region(self, rect: Rect | None = None, width: int = 0):
+        logger = logging.getLogger()
+        if rect is None:
+            rect = self.rect
+        if rect is None:
+            return
+        logger.debug(f"get_region region:{rect}")
+        # # region.x_rangeが0:や:infの場合には、それぞれself.regionのx_rangeを使用する
+        if rect.left == 0:
+            rect.x_range.min_val = self.rect.left
+        if rect.right == float("inf"):
+            rect.x_range.max_val = self.rect.right
+        if rect.top == 0:
+            rect.y_range.min_val = self.rect.top
+        if rect.bottom == float("inf"):
+            rect.y_range.max_val = self.rect.bottom
+
+        if width:
+            dst_width = int(width)
+            dst_height = int(width * rect.height) // rect.width
+            scale = width / rect.width
+        else:
+            dst_width = rect.width
+            dst_height = rect.height
+            scale = 1.0
+
+        image = np.zeros((dst_height, dst_width, 3), dtype=np.uint8)
+        image[:, :] = self.bgcolor
+        for tile, overlap in self.tiles_containing(rect):
+            if overlap is None:
+                continue
+            src = self.tiles[tile]
+            if src is None:
+                continue
+            originx, originy = tile
+            src_top = overlap.top - originy
+            src_bottom = overlap.bottom - originy
+            src_left = overlap.left - originx
+            src_right = overlap.right - originx
+            src_image = src[src_top:src_bottom, src_left:src_right]
+
+            dst_top = int((overlap.top - rect.top) * scale)
+            dst_bottom = int((overlap.bottom - rect.top) * scale)
+            dst_left = int((overlap.left - rect.left) * scale)
+            dst_right = int((overlap.right - rect.left) * scale)
+
+            src_image = cv2.resize(
+                src_image, (dst_right - dst_left, dst_bottom - dst_top)
+            )
+            image[dst_top:dst_bottom, dst_left:dst_right] = src_image
+            # dst_bottom = overlap.bottom-rect.top
+            # dst_left = overlap.left-rect.left
+            # dst_right = overlap.right-rect.left
+            # image[
+            #     overlap.y_range.min_val
+            #     - rect.y_range.min_val : overlap.y_range.max_val
+            #     - rect.y_range.min_val,
+            #     overlap.x_range.min_val
+            #     - rect.x_range.min_val : overlap.x_range.max_val
+            #     - rect.x_range.min_val,
+            # ] = src[
+            #     overlap.y_range.min_val - originy : overlap.y_range.max_val - originy,
+            #     overlap.x_range.min_val - originx : overlap.x_range.max_val - originx,
+            # ]
+        return image
+
+    def put_image(self, position, image, linear_alpha=None, full_alpha=None):
+        """
+        split the existent tiles
+        and put a big single tile.
+        the image must be larger than a single tile.
+        otherwise, a different algorithm is required.
+        """
+        h, w = image.shape[:2]
+        rect = Rect.from_bounds(
+            position[0], position[0] + w, position[1], position[1] + h
+        )
+        # expand the canvas
+        if self.rect is None:
+            self.rect = rect
+        else:
+            self.rect |= rect
+        for tile, overlap in self.tiles_containing(rect, includeempty=True):
+            if overlap is None:
+                continue
+            if tile not in self.tiles:
+                self.tiles[tile] = np.zeros(
+                    (self.tilesize[1], self.tilesize[0], 3), dtype=np.uint8
+                )
+                self.tiles[tile][:, :] = self.bgcolor
+            src = self.tiles[tile]
+            originx, originy = tile
+
+            dy0 = overlap.top - originy
+            dy1 = overlap.bottom - originy
+            dx0 = overlap.left - originx
+            dx1 = overlap.right - originx
+            sx0 = overlap.left - rect.left
+            sx1 = overlap.right - rect.left
+            sy0 = overlap.top - rect.top
+            sy1 = overlap.bottom - rect.top
+            if linear_alpha is None and full_alpha is None:
+                src[
+                    dy0:dy1,
+                    dx0:dx1,
+                ] = image[
+                    sy0:sy1,
+                    sx0:sx1,
+                ]
+            else:
+                if full_alpha is not None:
+                    alpha = full_alpha[:, :, np.newaxis]
+                    src[dy0:dy1, dx0:dx1, :] = (
+                        alpha[sy0:sy1, sx0:sx1, :] * image[sy0:sy1, sx0:sx1, :]
+                        + (1 - alpha[sy0:sy1, sx0:sx1, :]) * src[dy0:dy1, dx0:dx1, :]
+                    )
+                else:
+                    alpha = linear_alpha[np.newaxis, :, np.newaxis]
+                    src[dy0:dy1, dx0:dx1, :] = (
+                        alpha[:, sx0:sx1, :] * image[sy0:sy1, sx0:sx1, :]
+                        + (1 - alpha[:, sx0:sx1, :]) * src[dy0:dy1, dx0:dx1, :]
+                    )
+
+            # rewrite the item explicitly (for caching)
+            self.tiles[tile] = src
+
+    def get_image(self, width: int = 0):
+        # widthを指定すると縮小する。
+        return self.get_region(self.rect, width)
+
+
+def test():
+    import sys
+    import cv2
+    import logging
+
+    logging.basicConfig(level=logging.DEBUG)
+
+    png = sys.argv[1]
+    tilesize = int(sys.argv[2])
+    with TiledImage(tilesize=tilesize) as tiled_image:
+        tiled_image[20:, 40:] = cv2.imread(png)
+        tiled_image[10:, 20:] = cv2.imread(png)
+        image = tiled_image[:, :]
+        image = tiled_image.get_image(width=100)
+        cv2.imshow("image", image)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    test()

tiledimage-0.3.1/tiledimage/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.1"

tiledimage-0.3.1/tiledimage/tiledimage.py

@@ -1,177 +0,0 @@
-import logging
-
-# external modules
-import numpy as np
-
-# a range is always spacified with the min and max=min+width
-# 2d region consists of two ranges.
-
-
-def overlap(r1, r2):
-    """
-    True if the give regions (1D) overlap
-
-    there are 6 possible orders
-    ( ) [ ] x
-    ( [ ) ] o
-    ( [ ] ) o
-    [ ( ) ] o
-    [ ( ] ) o
-    [ ] ( ) x
-    ! { ) [ | ] ( }
-    ie [ ) && ( ]
-    """
-    if r1[0] < r2[1] and r2[0] < r1[1]:
-        return max(r1[0], r2[0]), min(r1[1], r2[1])
-    return None
-
-
-# It should also return the overlapping region
-def overlap2D(r1, r2):
-    x = overlap(r1[0], r2[0])
-    if x is not None:
-        y = overlap(r1[1], r2[1])
-        if y is not None:
-            return x, y
-    return None
-
-
-class TiledImage:
-    """
-    it has no size.
-    size is determined by the tiles.
-    !!!   it is better to fix the tile size. (128x128, for example)
-    """
-
-    def __init__(self, tilesize=128, bgcolor=(100, 100, 100)):
-        self.tiles = dict()
-        if type(tilesize) is int:
-            self.tilesize = (tilesize, tilesize)
-        else:
-            assert type(tilesize) is tuple
-            self.tilesize = tilesize
-        self.region = None
-        self.bgcolor = np.array(bgcolor)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass  # TiledImageは特別なクリーンアップ処理は必要ありません
-
-    def tiles_containing(self, region, includeempty=False):
-        """
-        return the tiles containing the given region
-        """
-        logger = logging.getLogger()
-        t = []
-        xran, yran = region
-        xran = (
-            xran[0] // self.tilesize[0],
-            (xran[1] + self.tilesize[0] - 1) // self.tilesize[0],
-        )
-        yran = (
-            yran[0] // self.tilesize[1],
-            (yran[1] + self.tilesize[1] - 1) // self.tilesize[1],
-        )
-        for ix in range(xran[0], xran[1]):
-            for iy in range(yran[0], yran[1]):
-                tile = (ix * self.tilesize[0], iy * self.tilesize[1])
-                logger.debug("Tile: {0}".format(tile))
-                if (tile in self.tiles) or includeempty:
-                    tregion = (
-                        (tile[0], tile[0] + self.tilesize[0]),
-                        (tile[1], tile[1] + self.tilesize[1]),
-                    )
-                    o = overlap2D(tregion, region)
-                    t.append((tile, o))
-        return t
-
-    def get_region(self, region=None):
-        logger = logging.getLogger()
-        # logger.debug("Get region {0} {1}".format(region,self.tiles))
-        if region is None:
-            region = self.region
-        xrange, yrange = region
-        image = np.zeros(
-            (yrange[1] - yrange[0], xrange[1] - xrange[0], 3), dtype=np.uint8
-        )
-        image[:, :] = self.bgcolor
-        for tile, overlap in self.tiles_containing(region):
-            # logger.debug("Should get a tile at {0} {1}".format(tile,self.tiles))
-            src = self.tiles[tile]
-            originx, originy = tile
-            xr, yr = overlap
-            image[
-                yr[0] - yrange[0] : yr[1] - yrange[0],
-                xr[0] - xrange[0] : xr[1] - xrange[0],
-                :,
-            ] = src[
-                yr[0] - originy : yr[1] - originy, xr[0] - originx : xr[1] - originx, :
-            ]
-        return image
-
-    def put_image(self, position, image, linear_alpha=None):
-        """
-        split the existent tiles
-        and put a big single tile.
-        the image must be larger than a single tile.
-        otherwise, a different algorithm is required.
-        """
-        h, w = image.shape[:2]
-        xrange, yrange = (position[0], position[0] + w), (position[1], position[1] + h)
-        region = (xrange, yrange)
-        for tile, overlap in self.tiles_containing(region, includeempty=True):
-            if tile not in self.tiles:
-                self.tiles[tile] = np.zeros(
-                    (self.tilesize[1], self.tilesize[0], 3), dtype=np.uint8
-                )
-                self.tiles[tile][:, :] = self.bgcolor
-            src = self.tiles[tile]
-            originx, originy = tile
-            xr, yr = overlap
-            if linear_alpha is None:
-                src[
-                    yr[0] - originy : yr[1] - originy,
-                    xr[0] - originx : xr[1] - originx,
-                    :,
-                ] = image[
-                    yr[0] - yrange[0] : yr[1] - yrange[0],
-                    xr[0] - xrange[0] : xr[1] - xrange[0],
-                    :,
-                ]
-            else:
-                dy0 = yr[0] - originy
-                dy1 = yr[1] - originy
-                dx0 = xr[0] - originx
-                dx1 = xr[1] - originx
-                sx0 = xr[0] - xrange[0]
-                sx1 = xr[1] - xrange[0]
-                sy0 = yr[0] - yrange[0]
-                sy1 = yr[1] - yrange[0]
-                src[dy0:dy1, dx0:dx1, :] = (
-                    linear_alpha[sx0:sx1, :] * image[sy0:sy1, sx0:sx1, :]
-                    + (1 - linear_alpha[sx0:sx1, :]) * src[dy0:dy1, dx0:dx1, :]
-                )
-
-            # rewrite the item explicitly (for caching)
-            self.tiles[tile] = src
-        if self.region is None:
-            self.region = (
-                (position[0], position[0] + w),
-                (position[1], position[1] + h),
-            )
-        else:
-            self.region = (
-                (
-                    min(self.region[0][0], position[0]),
-                    max(self.region[0][1], position[0] + w),
-                ),
-                (
-                    min(self.region[1][0], position[1]),
-                    max(self.region[1][1], position[1] + h),
-                ),
-            )
-
-    def get_image(self):
-        return self.get_region(self.region)