tiledimage 0.2__py3-none-any.whl

tiledimage/__init__.py

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

tiledimage/cachedimage.py

@@ -0,0 +1,101 @@
+from logging import getLogger, basicConfig, DEBUG, INFO
+
+import json
+import numpy as np
+
+from tiledimage.tiledimage import TiledImage
+import tiledimage.tilecache as tilecache
+
+
+class CachedImage(TiledImage):
+    def __init__(
+        self,
+        mode,
+        dir="image.pngs",
+        tilesize=128,
+        cachesize=10,
+        fileext="png",
+        bgcolor=(0, 0, 0),
+        hook=None,
+        disposal=False,
+    ):
+        """
+        if mode == "new", flush the dir.
+        hook is a function like put_image, that is called then a tile is rewritten.
+        dir will be removed when disposal is True.
+        """
+        # logger = getLogger()
+        super(CachedImage, self).__init__(tilesize)
+        self.fileext = fileext
+        self.bgcolor = bgcolor
+        self.disposal = disposal
+        self.dir = dir
+        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"]
+        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))
+        defaulttile[:, :, :] = self.bgcolor[:3]
+        # logger.info("Tile: {0}".format(defaulttile))
+        self.tiles = tilecache.TileCache(
+            mode,
+            dir=dir,
+            cachesize=cachesize,
+            fileext=self.fileext,
+            default=defaulttile,
+            hook=hook,
+        )
+        # just for done()
+        self.dir = dir
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.modified:
+            self._write_info()
+        if self.disposal:
+            rmdir(self.dir)
+
+    def _write_info(self):
+        """
+        内部実装用：情報をJSONファイルに書き出す
+        """
+        bgcolor = self.bgcolor
+        if isinstance(bgcolor, np.ndarray):
+            bgcolor = bgcolor.tolist()
+        info = dict(
+            xrange=self.region[0],
+            yrange=self.region[1],
+            tilesize=self.tilesize,
+            bgcolor=bgcolor,
+            filetype=self.fileext,
+        )
+        with open(f"{self.dir}/info.json", "w") as file:
+            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)
+        self.modified = True
+        logger = getLogger()
+        nmiss, naccess, cachesize = self.tiles.cachemiss()
+        logger.info(
+            "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)

tiledimage/tilecache.py

@@ -0,0 +1,118 @@
+import logging
+import os
+import shutil
+
+# external modules
+import cv2
+import pylru  # "Least Recent Used" type cache
+
+
+def remove_folder(path):
+    # check if folder exists
+    if os.path.exists(path):
+        # remove if exists
+        shutil.rmtree(path)
+
+
+class TileCache:
+    """
+    A tile of images that are mostly stored in files
+    It does not care the integrity of the image.
+    """
+
+    def __init__(
+        self,
+        mode,
+        dir="tileimage",
+        cachesize=10,
+        default=None,
+        fileext="png",
+        hook=None,
+    ):
+        """
+        Hook is a function like put_image, that is called when a tile is rewritten
+        """
+        if mode == "new":
+            remove_folder(dir)
+            os.mkdir(dir)
+        self.dir = dir
+        self.cache = pylru.lrucache(cachesize, callback=self.writeback)
+        self.nget = 0
+        self.nmiss = 0
+        self.fileext = fileext
+        self.default = default
+        self.hook = hook
+
+    def set_hook(self, hook):
+        self.hook = hook
+
+    def key_to_filename(self, key):
+        return "{0}/{1},{2}.{3}".format(self.dir, *key, self.fileext)
+
+    def __getitem__(self, key):
+        logger = logging.getLogger()
+        logger.debug("getitem key:{0}".format(key))
+        self.nget += 1
+        try:
+            modified, value = self.cache[key]
+        except KeyError:
+            filename = self.key_to_filename(key)
+            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))
+                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))
+        self.cache[key] = [True, value]
+
+    def writeback(self, key, value):
+        """
+        write back when it is purged from cache
+        """
+        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):
+        # purge the cached images to disk
+        for k in self.cache:
+            self.writeback(k, self.cache.peek(k))  # peek do not affect the order
+
+    def cachemiss(self):
+        """
+        report cache miss ratio
+        """
+        return self.nmiss, self.nget, self.cache.size()
+
+    def adjust_cache_size(self):
+        """
+        Automatically optimize the cache size
+        Should not be adjusted in the final merging process
+        """
+        percent = self.nmiss * 100 // self.nget
+        if percent > 50:
+            self.cache.addTailNode(10)
+        elif percent > 20:
+            self.cache.addTailNode(1)

tiledimage/tiledimage.py

@@ -0,0 +1,177 @@
+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)

tiledimage-0.2.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.1
+Name: tiledimage
+Version: 0.2
+Summary: tools for tiled image that can be cached on a filesystem.
+License: MIT
+Author: vitroid
+Author-email: vitroid@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pylru (>=1.2.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# TiledImage
+
+大きな画像を効率的に扱うための Python ライブラリです。メモリ使用量を抑えながら、大きな画像をタイル（小さな断片）に分割して管理します。
+
+## 特徴
+
+- 大きな画像をタイルに分割して管理
+- ファイルシステム上でのキャッシュ機能
+- メモリ効率の良い画像処理
+- コンテキストマネージャ（`with`文）による簡単な使用
+
+## インストール
+
+```bash
+pip install tiledimage
+```
+
+## 基本的な使い方
+
+### 画像の分割（PNG → PNGs）
+
+```python
+from tiledimage import CachedImage
+import cv2
+
+# 画像を読み込み
+img = cv2.imread("large_image.png")
+
+# タイル化して保存
+with CachedImage(
+    mode="new",
+    dir="output.pngs",
+    tilesize=(64, 64),
+    cachesize=10,
+    bgcolor=(255, 255, 255),  # 背景色（白）
+    fileext="jpg"
+) as tiled:
+    tiled.put_image((0, 0), img)  # 画像を配置
+```
+
+### 画像の結合（PNGs → PNG）
+
+```python
+from tiledimage import CachedImage
+import cv2
+
+# タイル化された画像を読み込み
+with CachedImage(mode="inherit", dir="input.pngs") as tiled:
+    # 全体の画像を取得
+    full_image = tiled.get_image()
+    # 保存
+    cv2.imwrite("combined_image.png", full_image)
+```
+
+### コマンドラインツール
+
+画像の分割：
+
+```bash
+pngs2 input.png output.pngs
+```
+
+画像の結合：
+
+```bash
+2pngs input.pngs output.png
+```
+
+## API リファレンス
+
+### CachedImage
+
+メインのクラス。タイル化された画像を管理します。
+
+```python
+CachedImage(
+    mode,           # "new" または "inherit"
+    dir="image.pngs",  # タイルの保存ディレクトリ
+    tilesize=128,   # タイルのサイズ（整数またはタプル）
+    cachesize=10,   # キャッシュサイズ
+    fileext="png",  # タイルのファイル形式
+    bgcolor=(0,0,0), # 背景色
+    hook=None,      # タイル書き換え時のフック関数
+    disposal=False  # 終了時にディレクトリを削除するか
+)
+```
+
+#### 主要メソッド
+
+- `put_image(pos, img, linear_alpha=None)`: 画像を配置
+- `get_image()`: 全体の画像を取得
+- `write_info()`: 情報を保存（通常は自動的に呼ばれる）
+
+### TiledImage
+
+基本的なタイル画像クラス。キャッシュ機能はありません。
+
+```python
+TiledImage(
+    tilesize=128,   # タイルのサイズ
+    bgcolor=(100,100,100)  # 背景色
+)
+```
+
+## 開発者向け情報
+
+### テスト
+
+```bash
+make test
+```
+
+### ビルド
+
+```bash
+make build
+```
+
+### デプロイ
+
+```bash
+make deploy
+```
+
+## ライセンス
+
+MIT License
+
+## 作者
+
+Masakazu Matsumoto (vitroid@gmail.com)
+

tiledimage-0.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+tiledimage/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+tiledimage/cachedimage.py,sha256=Mbxpl56dZTYiUENnqO7F6pI-0q5wvbsyUt0Gq0Z8j94,3239
+tiledimage/tilecache.py,sha256=gl1kzUJUfipS7tzfWoCxktFrvb5jsXoe2p24zYwh068,3413
+tiledimage/tiledimage.py,sha256=UslrUDLJlCapQRmcVmUMsCsnqY4jbmNk0tkLCpl0_SY,5823
+tiledimage-0.2.dist-info/METADATA,sha256=EQctWB4Oo0JdfxPi__K4als7zGfx0b5q-ze25lkLcoI,3178
+tiledimage-0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+tiledimage-0.2.dist-info/entry_points.txt,sha256=RiJU6UjfqclD9HizScQ4nX6PbysR7Tybr2DrKv0AXTQ,53
+tiledimage-0.2.dist-info/RECORD,,

tiledimage-0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tiledimage-0.2.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+2pngs=2pngs:main
+pngs2=pngs2:main
+