Initial commit; all functionality in place, tested on Ubuntu 18.04

This commit constitutes release 0.1.0.

Author: toaarnio

.pylintrc

@@ -0,0 +1,16 @@
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=120
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=\".*\"
+
+# Allow certain single-character variable names
+good-names=f,w,h,c,i,j,k,x,y,z,r,g,b,e,assertRaisesRegex,assertRaisesRegexp
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=LF
+
+# Disable certain warnings that are not really applicable
+disable=too-many-instance-attributes,too-few-public-methods

.travis.yml

@@ -0,0 +1,10 @@
+os: linux
+dist: xenial
+language: python
+python:
+  - "3.6"
+  - "3.7"
+install:
+  - pip install -r requirements.txt
+script:
+  - python setup.py test

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Tomi Aarnio
+
+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.

MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+include requirements.txt

README.md

@@ -0,0 +1,27 @@
+# imsize
+
+[![Build Status](https://travis-ci.org/toaarnio/imsize.svg?branch=master)](https://travis-ci.org/toaarnio/imsize)
+
+Lightning-fast extraction of image dimensions & bit depth. Tested on Python 3.6+.
+
+Supports PGM / PPM / PNM / PNG / JPG / TIFF.
+
+**Installing on Linux:**
+```
+pip install imsize
+```
+
+**Building & installing from source:**
+```
+git clean -dfx
+python setup.py bdist_wheel
+pip uninstall imsize
+pip install --user dist/*.whl
+```
+
+**Releasing to PyPI:**
+```
+pip install --user --upgrade setuptools wheel twine
+python setup.py sdist bdist_wheel
+twine upload dist/*
+```

imsize/__init__.py

@@ -0,0 +1,15 @@
+"""
+Extracts image dimensions & bit depth. Supports PGM/PPM/PNM/JPG/TIFF.
+
+Example:
+  info = imsize.read("myfile.jpg")
+  factor = info.nbytes / info.filesize
+  print(f"{info.filespec}: compression factor = {factor.1f}")
+
+https://github.com/toaarnio/imsize
+"""
+
+from .imsize import *
+
+__version__ = "0.1.0"
+__all__ = ["read", "ImageInfo"]

imsize/imsize

@@ -0,0 +1,46 @@
+#!/usr/bin/python3 -B
+
+"""
+Parses a lowest common denominator set of metadata from the given
+PNG/PNM/JPEG/TIFF image, i.e., the dimensions and bit depth.
+"""
+
+import os              # built-in library
+import sys             # built-in library
+import glob            # built-in library
+import tqdm            # pip install tqdm
+import imsize          # pip install imsize
+
+
+if __name__ == "__main__":
+
+    filetypes = ["*.png", "*.pnm", "*.pgm", "*.ppm", "*.jpeg", "*.jpg", "*.tiff", "*.tif"]
+
+    allfiles = []
+
+    if len(sys.argv[1:]) == 0:
+        for filetype in filetypes:
+            allfiles += glob.glob(filetype)
+            allfiles += glob.glob(filetype.upper())
+
+    for path in sys.argv[1:]:
+        if os.path.isdir(path):
+            for filetype in filetypes:
+                allfiles += glob.glob(os.path.join(path, filetype))
+                allfiles += glob.glob(os.path.join(path, filetype.upper()))
+        elif os.path.isfile(path):
+            allfiles += [path]
+
+    total_compressed = 0
+    total_uncompressed = 0
+    processed_files = []
+    iterator = tqdm.tqdm if len(allfiles) > 100 else lambda lst: lst
+
+    for filespec in iterator(allfiles):
+        info = imsize.read(filespec)
+        if info is not None:
+            processed_files += [filespec]
+            total_uncompressed += info.nbytes / 1024**2
+            total_compressed += info.filesize / 1024**2
+
+    print(f"Scanned {len(processed_files)} images, total {total_compressed:.1f} MB compressed, {total_uncompressed:.1f} MB uncompressed")

imsize/imsize.py

@@ -0,0 +1,167 @@
+#!/usr/bin/python3 -B
+
+import os              # built-in library
+import numpy as np     # pip install numpy
+import piexif          # pip install piexif
+
+try:
+    # package mode
+    from imsize import pnghdr   # local import: pnghdr.py
+    from imsize import jpeghdr  # local import: jpeghdr.py
+    from imsize import pnm      # local import: pnm.py
+except ImportError:
+    # stand-alone mode
+    import pnghdr
+    import jpeghdr
+    import pnm
+
+
+######################################################################################
+#
+#  P U B L I C   A P I
+#
+######################################################################################
+
+
+class ImageInfo:
+    """
+    A container for image metadata, filled in and returned by read().
+
+    Attributes:
+      filespec (str): The filespec given to read(), copied verbatim
+      filetype (str): File type: "png", "pnm", "jpeg" or "exif"
+      filesize (int): Size of the file on disk in bytes
+      width (int): Width of the image in pixels (orientation ignored)
+      height (int): Height of the image in pixels (orientation ignored)
+      nchan (int): Number of color channels: 1, 2, 3 or 4
+      bitdepth (int): Bits per sample: 1 to 16
+      bytedepth (int): Bytes per sample: 1 or 2
+      maxval (int): Maximum representable sample value, e.g., 255
+      dtype (type): NumPy dtype for sample values: uint8 or uint16
+      nbytes (int): Size of the image in bytes, uncompressed
+    """
+    def __init__(self):
+        self.filespec = None
+        self.filetype = None
+        self.filesize = None
+        self.width = None
+        self.height = None
+        self.nchan = None
+        self.bitdepth = None
+        self.bytedepth = None
+        self.maxval = None
+        self.dtype = None
+        self.nbytes = None
+
+
+def read(filespec):
+    """
+    Parses a lowest common denominator set of metadata from the given
+    PNG/PNM/JPEG/TIFF image, i.e., the dimensions and bit depth. Does
+    not read the entire file but only what's necessary. Returns an
+    ImageInfo with all fields filled in, or None in case of failure.
+
+    Example:
+      info = imsize.read("myfile.jpg")
+      factor = info.nbytes / info.filesize
+      print(f"{info.filespec}: compression factor = {factor.1f}")
+    """
+    filename = os.path.basename(filespec)             # "path/image.ext" => "image.ext"
+    extension = os.path.splitext(filename)[-1]        # "image.ext" => ("image", ".ext")
+    filetype = extension.lower()[1:]                  # ".EXT" => "ext"
+    handlers = {"png": _read_png,
+                "pnm": _read_pnm,
+                "pgm": _read_pnm,
+                "ppm": _read_pnm,
+                "jpeg": _read_jpeg,
+                "jpg": _read_jpeg,
+                "tiff": _read_exif,
+                "tif": _read_exif,
+                "webp": _read_exif}
+    if filetype in handlers:
+        handler = handlers[filetype]
+        info = handler(filespec)
+        return info
+    return None
+
+
+######################################################################################
+#
+#  I N T E R N A L   F U N C T I O N S
+#
+######################################################################################
+
+
+def _read_png(filespec):
+    header = pnghdr.Png.from_file(filespec)
+    colortype = pnghdr.Png.ColorType
+    nchannels = {colortype.greyscale: 1,
+                 colortype.truecolor: 3,
+                 colortype.indexed: 3,
+                 colortype.greyscale_alpha: 2,
+                 colortype.truecolor_alpha: 4}
+    info = ImageInfo()
+    info.filespec = filespec
+    info.filetype = "png"
+    info.width = header.ihdr.width
+    info.height = header.ihdr.height
+    info.nchan = nchannels[header.ihdr.color_type]
+    info.bitdepth = header.ihdr.bit_depth
+    info = _complete(info)
+    return info
+
+
+def _read_pnm(filespec):
+    shape, maxval = pnm.dims(filespec)
+    info = ImageInfo()
+    info.filespec = filespec
+    info.filetype = "pnm"
+    info.width = shape[1]
+    info.height = shape[0]
+    info.nchan = shape[2]
+    info.maxval = maxval
+    info = _complete(info)
+    return info
+
+
+def _read_exif(filespec):
+    try:
+        exif = piexif.load(filespec).pop("0th")
+        info = ImageInfo()
+        info.filespec = filespec
+        info.filetype = "exif"
+        info.width = exif.get(piexif.ImageIFD.ImageWidth)
+        info.height = exif.get(piexif.ImageIFD.ImageLength)
+        info.nchan = exif.get(piexif.ImageIFD.SamplesPerPixel)
+        info.bitdepth = exif.get(piexif.ImageIFD.BitsPerSample)[0]
+        info = _complete(info)
+        return info
+    except TypeError:
+        print(f"Unable to parse {filespec}: missing/broken EXIF metadata.")
+        return None
+
+
+def _read_jpeg(filespec):
+    info = ImageInfo()
+    info.filespec = filespec
+    info.filetype = "jpeg"
+    data = jpeghdr.Jpeg.from_file(filespec)
+    for seg in data.segments:
+        if seg.marker == seg.MarkerEnum.sof0:
+            info.width = seg.data.image_width
+            info.height = seg.data.image_height
+            info.nchan = seg.data.num_components
+            info.bitdepth = seg.data.bits_per_sample
+            info = _complete(info)
+            break
+    return info
+
+
+def _complete(info):
+    info.filesize = os.path.getsize(info.filespec)
+    info.maxval = info.maxval or 2 ** info.bitdepth - 1
+    info.bitdepth = info.bitdepth or int(np.log2(info.maxval + 1))
+    info.bytedepth = 2 if info.maxval > 255 else 1
+    info.dtype = np.uint16 if info.maxval > 255 else np.uint8
+    info.nbytes = info.width * info.height * info.nchan * info.bytedepth
+    return info