v0.4.0
The package exports one class, LayerImage, and __version__. Operations change the image in place and return it, so calls can be chained. Call clone() first to keep an unchanged copy. Pixel values are floats in [0, 1].
Open an image file with Pillow. EXIF orientation is applied, so photos from cameras and phones load upright. Any color mode is converted to RGB, or to RGBA when the image has transparency. Metadata such as EXIF data and ICC profiles is not kept.
Download an image over HTTP(S) with Requests, then open it the same way as from_file().
Wrap a NumPy array of floats with values in [0, 1].
In a Jupyter notebook, a LayerImage displays as the image itself. Its repr shows the mode and size, for example <LayerImage RGB 1536x1024>.
Write the image to a file. The format comes from the file extension: JPEG, PNG, BMP, TIFF, WebP or any other format Pillow can write. An RGBA image saved as JPEG is composited onto a white background.
Return the pixels as a float64 array with values in [0, 1] and shape (height, width, 3) or (height, width, 4). This is the underlying array, not a copy. For a photo loaded from a file or URL, it applies any pending per-channel operations and keeps the image in float64 from then on.
Return an independent copy, including any operations still pending in the lookup table. Changes to the copy do not affect the original.
Convert to grayscale with the ITU-R 601 luminance weights (0.2989, 0.5870, 0.1140). The alpha channel is kept.
Multiply every channel by 1 + factor and clip to [0, 1]. A factor above 0 brightens, below 0 darkens.
Scale each value around mid-gray, factor * (value - 0.5) + 0.5, and clip to [0, 1]. Above 1 increases contrast; between 0 and 1 decreases it.
Set every pixel's hue to target_hue while keeping saturation and value. This is a colorize-style adjustment.
Multiply saturation by 1 + factor and clip to [0, 1]. Above 0 boosts color, below 0 mutes it.
Blend toward white when factor is above 0, or toward black when it is below 0.
Remap tones through control points spaced evenly across [0, 1], on any combination of the red, green and blue channels.
Resize with Lanczos resampling. A photo loaded from a file or URL stays 8-bit.
Every blend mode has this signature: replace blend_mode with one of the 14 methods below. Each combines the image (the base, A) with a blend layer (B), then mixes the result back with the original by opacity. A hex color, or an array with one value per channel, keeps an 8-bit photo on the lookup-table path. A per-pixel array converts it to float64 first.
Run a sequence of operations described in a dictionary, in order. The operation types below list the keys each one takes.
image.apply_from_dict({
"operations": [
{"type": "grayscale"},
{"type": "brightness", "factor": 0.2},
{"type": "multiply", "hex": "#ff0000", "opacity": 0.5},
{"type": "resize", "width": 800, "height": 600},
{"type": "curve", "channels": "rgb", "curve_points": [0, 0.5, 1]},
]
})Load a JSON file with the same structure and pass it to apply_from_dict().
image.apply_from_json("pipeline.json")Each entry in the "operations" list is an object with a "type" and the keys below. Operations run in order. An entry with an unknown type or a missing required key is skipped without an error.
| Type | Keys | Calls |
|---|---|---|
| grayscale | none | grayscale() |
| brightness | factor | brightness(factor) |
| contrast | factor | contrast(factor) |
| saturation | factor | saturation(factor) |
| lightness | factor | lightness(factor) |
| hue | hue | hue(hue) |
| curve | channels, curve_points | curve(channels, curve_points) |
| resize | width, height | resize(width, height) |
| any blend mode, such as multiply | hex, opacity (optional, default 1.0) | multiply(hex, opacity) |
In a dict or JSON file, blend modes take a hex color only. To blend with a NumPy array, call the method directly.