[WIP] Add constant stride tiles

Author: vfdev-5

.gitignore

@@ -0,0 +1,88 @@
+# Created by https://www.gitignore.io/api/python, and modified...
+
+## Linux backup files
+*~
+
+## Arhives
+*.zip
+
+### Mac OS X stuff ###
+Desktop DF
+Desktop DB
+.Spotlight-V100
+.DS_Store
+.Trashes
+.com.apple.timemachine.supported
+.fseventsd
+.syncinfo
+.TemporaryItems
+report/
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+MANIFEST
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Idea
+.idea
+*.iml

.travis.yml

@@ -0,0 +1,19 @@
+sudo: required
+language: python
+matrix:
+    include:
+        - python: 3.5
+        - python: 2.7
+
+install:
+  - pip install numpy
+  - python setup.py install
+  - pip install flake8 coveralls pytest-cov
+
+# command to run tests
+script:
+  - py.test --cov tiling --cov-report term-missing
+  - flake8
+
+after_success:
+  - coveralls

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 vfdev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,48 @@
+# Image Tiling Utils
+
+Minimalistic set of image reader angostic tools to easily iterate over large images
+
+**Example 1**
+
+Let's iterate over a large image with overlapping and extracting always the 
+same size tiles (in pixels).  Let's assume the data access is provided with an example function
+```python
+def read_data(x, y, width, height, out_width=None, out_height=None):
+    out_width = width if out_width is None else out_width
+    out_height = height if out_height is None else out_height    
+    img.read(x, y, width, height, out_width, out_height)
+``` 
+Thus, overlapping tiles can be extracted as  
+```python
+from tiling import ConstStrideTiles
+
+
+tiles = ConstStrideTiles(image_size=(500, 500), tile_size=(256, 256), 
+                         stride=(100, 100))
+                       
+print("Number of tiles: %i" % len(tiles))
+for extent, out_size in tiles:
+    x, y, width, height = extent
+    data = read_data(x, y, width, height, 
+                     out_width=out_size[0], 
+                     out_height=out_size[1])
+    print("data.shape: {}".format(data.shape))
+    
+# Access a tile:
+i = len(tiles) // 2 
+extent, out_size  = tiles[i]
+```
+
+![example_tiles](examples/example_tiles.png)
+
+
+## Installation:
+
+Package installation is very simple
+```bash
+pip install git+https://github.com/vfdev-5/ImageTilingUtils.git
+```
+
+## Examples 
+
+For more practical examples, see this [notebook](examples/example_const_stride_tiling.ipynb)

examples/example_const_stride_tiling.ipynb

@@ -0,0 +1 @@
+numpy

examples/example_tiles.png

@@ -0,0 +1,7 @@
+[pep8]
+max-line-length = 120
+
+[flake8]
+max-line-length = 120
+ignore = F401,E402,F403
+exclude = venv

examples/test_image.jpg

@@ -0,0 +1,30 @@
+from codecs import open as codecs_open
+from setuptools import setup, find_packages
+from tiling import __version__
+
+
+# Get the long description from the relevant file
+with codecs_open('README.md', encoding='utf-8') as f:
+    long_description = f.read()
+
+
+setup(
+    name="tiling",
+    version=__version__,
+    description=u"Minimalistic set of image reader angostic tools to easily iterate over large images",
+    long_description=long_description,
+    author="vfdev-5",
+    author_email="vfdev dot 5 at gmail dot com",
+    packages=find_packages(exclude=['tests', 'examples']),
+    install_requires=[
+        'numpy',
+    ],
+    license='MIT',
+    test_suite="tests",
+    extras_require={
+        'tests': [
+            'pytest',
+            'pytest-cov'
+        ]
+    }
+)

requirements.txt

@@ -0,0 +1,100 @@
+#
+# import unittest
+#
+# import numpy as np
+#
+#
+# from tiling import ConstSizeTiles
+#
+#
+# class TestConstSizeTiles(unittest.TestCase):
+#
+#     def test__compute_number_of_tiles(self):
+#         res = ConstSizeTiles._compute_number_of_tiles(32, 100, 0)
+#         self.assertEqual(res, 4)
+#         res = ConstSizeTiles._compute_number_of_tiles(32, 100, 7)
+#         self.assertEqual(res, 4)
+#         scale = 2.0
+#         res = ConstSizeTiles._compute_number_of_tiles(3.0/scale, 10, 0)
+#         self.assertEqual(res, 7)
+#         res = ConstSizeTiles._compute_number_of_tiles(6.0/scale, 20, 1)
+#         self.assertEqual(res, 10)
+#
+#     def test__compute_float_overlapping(self):
+#         res = ConstSizeTiles._compute_float_overlapping(32, 100, 4)
+#         self.assertEqual(res, 28.0 / 3.0)
+#
+#     def test__compute_tile_params(self):
+#
+#         def _test(width, size, overlapping, scale):
+#
+#             offset,  = ConstSizeTiles._compute_tile_params()
+#
+#
+#         for scale in [0.7, 0.89, 0.99, 1.0, 1.78, 2.12]:
+#             for im_size in range(50, 100, 3):
+#                 for ext in range(12, int(im_size * scale) - 1):
+#                     for min_ovr in range(0, int(ext / scale) - 1):
+#                         _test(im_size, ext, min_ovr, scale)
+#
+#     def test_no_scale(self):
+#
+#         def _test(image_size, tile_size, min_overlapping):
+#
+#             tiles = ConstSizeTiles(image_size=image_size, tile_size=tile_size,
+#                                    min_overlapping=min_overlapping, scale=1.0)
+#
+#             true_image = np.random.rand(image_size[1], image_size[0], 3)
+#             tiled_image = np.zeros_like(true_image)
+#             count = 0
+#             for i, (x, y, width, height) in enumerate(tiles):
+#                 count += 1
+#                 self.assertTrue(0 <= x <= image_size[0] - tile_size[0],
+#                                 "{}: 0 <= {} <= {}".format(i, x, image_size[0] - tile_size[0]))
+#                 self.assertTrue(0 <= y <= image_size[1] - tile_size[1],
+#                                 "{}: 0 <= {} <= {}".format(i, y, image_size[1] - tile_size[1]))
+#                 self.assertEqual(width, tiles.tile_size[0])
+#                 self.assertEqual(height, tiles.tile_size[1])
+#                 self.assertTrue(x + width <= image_size[0],
+#                                 "{}: 0 <= {} <= {}".format(i, x + width, image_size[0]))
+#                 self.assertTrue(y + height <= image_size[1],
+#                                 "{}: 0 <= {} <= {}".format(i, y + height, image_size[1]))
+#                 tiled_image[y:y + height, x:x + width, :] = true_image[y:y + height, x:x + width, :]
+#
+#             self.assertEqual(len(tiles), count)
+#             err = float(np.sum(np.abs(tiled_image - true_image)))
+#             self.assertLess(err, 1e-10, "Err : %f" % err)
+#
+#         for o in [0, 5, 10, 15]:
+#             _test((123, 234), (23, 34), o)
+#             _test((256, 256), (32, 32), o)
+#             _test((512, 512), (128, 128), o)
+#
+#     def test_with_scale(self):
+#
+#         def _test(image_size, tile_size, min_overlapping, scale):
+#             tiles = ConstSizeTiles(image_size=image_size, tile_size=tile_size,
+#                                    min_overlapping=min_overlapping, scale=scale)
+#             count = 0
+#             for i, (x, y, width, height) in enumerate(tiles):
+#                 count += 1
+#                 self.assertTrue(0 <= x <= image_size[0]*scale - tile_size[0],
+#                                 "{}: 0 <= {} <= {}".format(i, x, image_size[0]*scale - tile_size[0]))
+#                 self.assertTrue(0 <= y <= image_size[1]*scale - tile_size[1],
+#                                 "{}: 0 <= {} <= {}".format(i, y, image_size[1]*scale - tile_size[1]))
+#                 # self.assertEqual(width, tiles.tile_size[0])
+#                 # self.assertEqual(height, tiles.tile_size[1])
+#                 # self.assertTrue(x + width <= image_size[0],
+#                 #                 "{}: 0 <= {} <= {}".format(i, x + width, image_size[0]))
+#                 # self.assertTrue(y + height <= image_size[1],
+#                 #                 "{}: 0 <= {} <= {}".format(i, y + height, image_size[1]))
+#
+#             self.assertEqual(len(tiles), count)
+#
+#         for s in [0.7, 0.88, 0.97, 1.0, 1.23, 1.89, 2.34]:
+#             _test((123, 234), (23, 34), 15, s)
+#             _test((256, 256), (32, 32), 15, s)
+#             _test((512, 512), (128, 128), 15, s)
+#
+# if __name__ == "__main__":
+#     unittest.main()