ialdev-io 0.1.0__py3-none-any.whl

iad/io/__init__.py

@@ -0,0 +1,17 @@
+from .imread import imread
+from .imwrite import imsave
+
+
+def read_meta(path):
+    """Read file at path and return dict (e.g. YAML/JSON). Used by extract_attr when meta is a path."""
+    path = __import__('pathlib').Path(path)
+    suffix = path.suffix.lower()
+    if suffix in ('.yaml', '.yml'):
+        import yaml
+        return yaml.safe_load(path.read_text(encoding='utf-8')) or {}
+    if suffix in ('.json', '.js', '.jso', '.jsn'):
+        import json
+        return json.loads(path.read_text(encoding='utf-8'))
+    # fallback: try yaml
+    import yaml
+    return yaml.safe_load(path.read_text(encoding='utf-8')) or {}

iad/io/basic_formats.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from itertools import chain
+from typing import Callable, Any
+
+from .format import FileFormat, PathT, read_outputs, Content as CT, sfx_of
+
+
+class MiddleburyCalib(FileFormat, patterns="calib.txt", content=CT.CONFIG):
+    @classmethod
+    def read(cls, filename: PathT, *, content=CT.CONFIG, **kws):
+        from .special import middlebury_calib
+        assert not kws and cls.valid_content(content)
+        return middlebury_calib(filename)
+
+
+_cfg_sfx = [['.yaml', '.yml'], ['.json', '.jso', '.js', '.jsn'], ['.toml', '.tml', '.ini']]
+
+
+class ConfigFormat(FileFormat, desc="Nested Textual Configuration",
+                   content=CT.META | CT.CONFIG, patterns=[*chain(*_cfg_sfx)]):
+    from iad.core.param import TBox
+    _aliases = {sfx: grp[0].strip('.') for grp in _cfg_sfx for sfx in grp}
+
+    @classmethod
+    def read(cls, filename: PathT, *, content=CT.UNDEF, **kws):
+        assert cls.valid_content(content)
+        name = f'from_{cls._aliases[sfx_of(filename)]}'
+        return getattr(cls.TBox, name)(filename=filename, **kws)
+
+    @classmethod
+    def write(cls, filename: PathT, data: dict, **kws) -> Callable[[PathT], Any]:
+        """Acquire read function by the format"""
+        name = f'to_{cls._aliases[sfx_of(filename)]}'
+        return getattr(cls.TBox(data), name)(filename=filename, **kws)
+
+    @classmethod
+    def supports_write(cls, *, data=None, meta=None):
+        return meta is None and (
+                data is None or issubclass(data, dict))
+
+
+class TifFormat(FileFormat, desc="Tiff with metadata in ImageDescription Tag",
+                patterns=['.tiff', '.tif'],
+                content=CT.META | CT.IMAGE):
+    _meta_tag = "ImageDescription"
+
+    @classmethod
+    @read_outputs
+    def read(cls, filename: PathT, *, content=CT.DATA, **kws):
+        """No need for file_form"""
+        from tifffile import imread, tiffcomment
+        out = []
+        if content & CT.DATA:
+            out.append(imread(filename))
+        if content & CT.META:
+            import yaml
+            comment = tiffcomment(filename, tagcode=cls._meta_tag)
+            meta = yaml.load(comment, Loader=yaml.SafeLoader)
+            out.append(meta if isinstance(meta, dict) else None)
+        return tuple(out)
+
+
+class ImageFormat(FileFormat, desc="General image format",
+                  patterns=['.png', '.bmp', '.jpg'],
+                  content=CT.IMAGE):
+    @classmethod
+    def read(cls, filename: PathT):
+        from .imread import imread
+        return imread(filename)
+
+    @classmethod
+    def write(cls, filename: PathT, data, *, meta=None, **kws):
+        from .imread import imsave
+        assert meta is None
+        imsave(filename, data, **kws)
+
+
+class InuStereoFormat(FileFormat, desc="Inuitive Stereo Images with Cameras metadata",
+                      patterns=[
+                          r"StereoImage_\d+\.tif",
+                          r"Output_Video_(Left|Right)_\d+\.(bmp|png|tif|jpg)",
+                          r"Video_\d+\.(bmp|png|tif|jpg)"],
+                      content=CT.IMAGE | CT.META):
+    """Inuitive tif based format for 2 stereo images with custom tags."""
+
+    @classmethod
+    def read(cls, filename: PathT, content=CT.DATA, *kws):
+        """No need for file_form"""
+        assert not kws
+        out = []
+        if content & CT.META:
+            from iad.io.inu.utils.imread import imread_stereo
+            out.append(imread_stereo(str(filename), cam_info=False))
+        if content & CT.DATA:
+            from iad.io.inu.utils.imread import tiff_inu_cam
+            out.append(tiff_inu_cam(str(filename)))
+        return tuple(out) if len(out) > 1 else out if len(out) == 1 else 0

iad/io/bit_streams.py

@@ -0,0 +1,98 @@
+""" Bit streams operations"""
+
+
+def save_bit_streams(full_file_name, streams, order=None):
+    """ Save bit stream
+
+    :param full_file_name: the full path of the .tiff file to be saved
+    :param streams: dict of dicts of streams. See my_streams in '__main__' for example
+    :param order: list of streams' names to record in specific order,
+                or list of fio {name:offset} to record in pre-defined offsets
+    :return: ---
+    """
+    import tifffile, json
+    from iad.core.binary import join_bits
+    streams = streams.copy()
+
+    def extract_bits_data(names):
+        return zip(*[(streams[name]['bits'], streams[name]['data']) for name in names])
+
+    bits, data_streams = extract_bits_data(streams)
+    check_clip = False
+    ord_streams = None
+
+    if order is not None:
+        if type(order) == dict:
+            offsets = [order[name] for name in streams]
+            for name in streams:     # ADD offsets TO streams to be used in unpacking
+                streams[name]['offset'] = order[name]
+            bits = list(zip(bits, offsets))
+        else:
+            assert hasattr(order, '__iter__')
+            bits, data_streams = extract_bits_data(order)
+            ord_streams = {name: streams[name] for name in order}
+
+    tiff_im = join_bits(bits, data_streams, check_clip)
+
+    for name in streams.keys():
+        del streams[name]['data']
+    metadata = json.dumps(streams if ord_streams is None else ord_streams)  # REMOVE 'data' FROM streams AND PACK INTO JSON
+
+    tifffile.imsave(full_file_name, tiff_im, description=metadata)
+
+
+def load_bit_streams(full_file_name):
+    """ Load bit streams from tiff file with YML metadata
+
+    :param full_file_name:  the full path of the .tiff file to be loaded.
+                            the file is assumed to contain YML metadata recorded by save_bit_streams()
+    :return: split data streams
+    """
+    from iad.core.binary import split_bits
+    from imread import imread
+    tiff_im, streams = imread(full_file_name, get_meta=True)
+
+    bits = [streams[name]['bits'] for name in streams.keys()]
+
+    if 'offset' in list(streams.values())[0].keys():  # list(streams.values())[0]['offset'] != None:
+        offsets = [streams[name]['offset'] for name in streams.keys()]
+        bits = list(zip(bits, offsets))
+
+    data = split_bits(tiff_im, bits)
+
+    for i, name in enumerate(streams):
+        streams[name]['data'] = data[i]
+
+    return streams
+
+
+if __name__ == '__main__':
+
+    sz_x = 10   #640
+    sz_y = 10   #480
+    import numpy as np
+    conf_inf_bits = 4
+    conf_inf = np.random.randint(2 ** conf_inf_bits, size=(sz_x, sz_y)).astype('uint8')
+
+    disp_inf_bits = 1
+    disp_inf = np.ones((sz_x, sz_y), dtype='uint8')
+
+    my_streams = {
+        'conf_inf': {
+            'data': conf_inf,
+            'bits': conf_inf_bits,
+            'info': 'information score estimated from confidence'
+        },
+        'disp_inf': {
+            'data': disp_inf,
+            'bits': disp_inf_bits,
+            'info': 'important estimated from disparity'
+        }
+    }
+
+    # Have to support order = None, order as list, and order as dictionary
+    order_my = ['disp_inf', 'conf_inf']
+    order_dict_my = {'disp_inf': 1, 'conf_inf': 3}  # name: offset.
+
+    save_bit_streams('some_file.tif', my_streams, None) #order_my)
+    res_streams = load_bit_streams('some_file.tif')