Add files via upload
This commit is contained in:
ThereforeGames
@@ -0,0 +1,511 @@
|
||||
"""Provide blending functions and types.
|
||||
|
||||
Adapted from https://github.com/addisonElliott/pypdn/blob/master/pypdn/reader.py
|
||||
and https://gitlab.com/inklabapp/pyora/-/blob/master/pyora/BlendNonSep.py
|
||||
MIT License Copyright (c) 2020 FredHappyface
|
||||
|
||||
Credits to:
|
||||
|
||||
MIT License Copyright (c) 2019 Paul Jewell
|
||||
For implementing blending from the Open Raster Image Spec
|
||||
|
||||
MIT License Copyright (c) 2018 Addison Elliott
|
||||
For implementing blending from Paint.NET
|
||||
|
||||
MIT License Copyright (c) 2017 pashango
|
||||
For implementing a number of blending functions used by other popular image
|
||||
editors
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import warnings
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
from .blendtype import BlendType
|
||||
|
||||
|
||||
def normal(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.NORMAL."""
|
||||
del background # we don't care about this
|
||||
return foreground
|
||||
|
||||
|
||||
def multiply(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.MULTIPLY."""
|
||||
return np.clip(foreground * background, 0.0, 1.0)
|
||||
|
||||
|
||||
def additive(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.ADDITIVE."""
|
||||
return np.minimum(background + foreground, 1.0)
|
||||
|
||||
|
||||
def colourburn(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.COLOURBURN."""
|
||||
with np.errstate(divide="ignore"):
|
||||
return np.where(
|
||||
foreground != 0.0, np.maximum(1.0 - ((1.0 - background) / foreground), 0.0), 0.0
|
||||
)
|
||||
|
||||
|
||||
def colourdodge(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.COLOURDODGE."""
|
||||
with np.errstate(divide="ignore"):
|
||||
return np.where(foreground != 1.0, np.minimum(background / (1.0 - foreground), 1.0), 1.0)
|
||||
|
||||
|
||||
def reflect(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.REFLECT."""
|
||||
with np.errstate(divide="ignore"):
|
||||
return np.where(
|
||||
foreground != 1.0, np.minimum((background ** 2) / (1.0 - foreground), 1.0), 1.0
|
||||
)
|
||||
|
||||
|
||||
def glow(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.GLOW."""
|
||||
with np.errstate(divide="ignore"):
|
||||
return np.where(
|
||||
background != 1.0, np.minimum((foreground ** 2) / (1.0 - background), 1.0), 1.0
|
||||
)
|
||||
|
||||
|
||||
def overlay(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.OVERLAY."""
|
||||
return np.where(
|
||||
background < 0.5,
|
||||
2 * background * foreground,
|
||||
1.0 - (2 * (1.0 - background) * (1.0 - foreground)),
|
||||
)
|
||||
|
||||
|
||||
def difference(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.DIFFERENCE."""
|
||||
return np.abs(background - foreground)
|
||||
|
||||
|
||||
def negation(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.NEGATION."""
|
||||
return np.maximum(background - foreground, 0.0)
|
||||
|
||||
|
||||
def lighten(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.LIGHTEN."""
|
||||
return np.maximum(background, foreground)
|
||||
|
||||
|
||||
def darken(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.DARKEN."""
|
||||
return np.minimum(background, foreground)
|
||||
|
||||
|
||||
def screen(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.SCREEN."""
|
||||
return background + foreground - background * foreground
|
||||
|
||||
|
||||
def xor(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.XOR."""
|
||||
# XOR requires int values so convert to uint8
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("ignore")
|
||||
return imageIntToFloat(imageFloatToInt(background) ^ imageFloatToInt(foreground))
|
||||
|
||||
|
||||
def softlight(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.SOFTLIGHT."""
|
||||
return (1.0 - background) * background * foreground + background * (
|
||||
1.0 - (1.0 - background) * (1.0 - foreground)
|
||||
)
|
||||
|
||||
|
||||
def hardlight(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.HARDLIGHT."""
|
||||
return np.where(
|
||||
foreground < 0.5,
|
||||
np.minimum(background * 2 * foreground, 1.0),
|
||||
np.minimum(1.0 - ((1.0 - background) * (1.0 - (foreground - 0.5) * 2.0)), 1.0),
|
||||
)
|
||||
|
||||
|
||||
def grainextract(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.GRAINEXTRACT."""
|
||||
return np.clip(background - foreground + 0.5, 0.0, 1.0)
|
||||
|
||||
|
||||
def grainmerge(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.GRAINMERGE."""
|
||||
return np.clip(background + foreground - 0.5, 0.0, 1.0)
|
||||
|
||||
|
||||
def divide(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.DIVIDE."""
|
||||
return np.minimum((256.0 / 255.0 * background) / (1.0 / 255.0 + foreground), 1.0)
|
||||
|
||||
|
||||
def pinlight(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.PINLIGHT."""
|
||||
return np.minimum(background, 2 * foreground) * (foreground < 0.5) + np.maximum(
|
||||
background, 2 * (foreground - 0.5)
|
||||
) * (foreground >= 0.5)
|
||||
|
||||
|
||||
def vividlight(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.VIVIDLIGHT."""
|
||||
return colourburn(background, foreground * 2) * (foreground < 0.5) + colourdodge(
|
||||
background, 2 * (foreground - 0.5)
|
||||
) * (foreground >= 0.5)
|
||||
|
||||
|
||||
def exclusion(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.EXCLUSION."""
|
||||
return background + foreground - (2.0 * background * foreground)
|
||||
|
||||
|
||||
def _lum(colours: np.ndarray) -> np.ndarray:
|
||||
"""Luminosity.
|
||||
|
||||
:param colours: x by x by 3 matrix of rgb color components of pixels
|
||||
:return: x by x by 3 matrix of luminosity of pixels
|
||||
"""
|
||||
return (colours[:, :, 0] * 0.299) + (colours[:, :, 1] * 0.587) + (colours[:, :, 2] * 0.114)
|
||||
|
||||
|
||||
def _setLum(originalColours: np.ndarray, newLuminosity: np.ndarray) -> np.ndarray:
|
||||
"""Set a new luminosity value for the matrix of color."""
|
||||
_colours = originalColours.copy()
|
||||
_luminosity = _lum(_colours)
|
||||
deltaLum = newLuminosity - _luminosity
|
||||
_colours[:, :, 0] += deltaLum
|
||||
_colours[:, :, 1] += deltaLum
|
||||
_colours[:, :, 2] += deltaLum
|
||||
_luminosity = _lum(_colours)
|
||||
_minColours = np.min(_colours, axis=2)
|
||||
_MaxColours = np.max(_colours, axis=2)
|
||||
for i in range(_colours.shape[0]):
|
||||
for j in range(_colours.shape[1]):
|
||||
_colour = _colours[i][j]
|
||||
newLuminosity = _luminosity[i, j]
|
||||
minColour = _minColours[i, j]
|
||||
maxColour = _MaxColours[i, j]
|
||||
if minColour < 0:
|
||||
_colours[i][j] = newLuminosity + (
|
||||
((_colour - newLuminosity) * newLuminosity) / (newLuminosity - minColour)
|
||||
)
|
||||
if maxColour > 1:
|
||||
_colours[i][j] = newLuminosity + (
|
||||
((_colour - newLuminosity) * (1 - newLuminosity)) / (maxColour - newLuminosity)
|
||||
)
|
||||
return _colours
|
||||
|
||||
|
||||
def _sat(colours: np.ndarray) -> np.ndarray:
|
||||
"""Saturation.
|
||||
|
||||
:param colours: x by x by 3 matrix of rgb color components of pixels
|
||||
:return: int of saturation of pixels
|
||||
"""
|
||||
return np.max(colours, axis=2) - np.min(colours, axis=2)
|
||||
|
||||
|
||||
def _setSat(originalColours: np.ndarray, newSaturation: np.ndarray) -> np.ndarray:
|
||||
"""Set a new saturation value for the matrix of color.
|
||||
|
||||
The current implementation cannot be vectorized in an efficient manner,
|
||||
so it is very slow,
|
||||
O(m*n) at least. This might be able to be improved with openCL if that is
|
||||
the direction that the lib takes.
|
||||
:param c: x by x by 3 matrix of rgb color components of pixels
|
||||
:param s: int of the new saturation value for the matrix
|
||||
:return: x by x by 3 matrix of luminosity of pixels
|
||||
"""
|
||||
_colours = originalColours.copy()
|
||||
for i in range(_colours.shape[0]):
|
||||
for j in range(_colours.shape[1]):
|
||||
_colour = _colours[i][j]
|
||||
minI = 0
|
||||
midI = 1
|
||||
maxI = 2
|
||||
if _colour[midI] < _colour[minI]:
|
||||
minI, midI = midI, minI
|
||||
if _colour[maxI] < _colour[midI]:
|
||||
midI, maxI = maxI, midI
|
||||
if _colour[midI] < _colour[minI]:
|
||||
minI, midI = midI, minI
|
||||
if _colour[maxI] - _colour[minI] > 0.0:
|
||||
_colours[i][j][midI] = ((_colour[midI] - _colour[minI]) * newSaturation[i, j]) / (
|
||||
_colour[maxI] - _colour[minI]
|
||||
)
|
||||
_colours[i][j][maxI] = newSaturation[i, j]
|
||||
else:
|
||||
_colours[i][j][midI] = 0
|
||||
_colours[i][j][maxI] = 0
|
||||
_colours[i][j][minI] = 0
|
||||
return _colours
|
||||
|
||||
|
||||
def hue(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.HUE."""
|
||||
return _setLum(_setSat(foreground, _sat(background)), _lum(background))
|
||||
|
||||
|
||||
def saturation(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.SATURATION."""
|
||||
return _setLum(_setSat(background, _sat(foreground)), _lum(background))
|
||||
|
||||
|
||||
def colour(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.COLOUR."""
|
||||
return _setLum(foreground, _lum(background))
|
||||
|
||||
|
||||
def luminosity(background: np.ndarray, foreground: np.ndarray) -> np.ndarray:
|
||||
"""BlendType.LUMINOSITY."""
|
||||
return _setLum(background, _lum(foreground))
|
||||
|
||||
|
||||
def destin(
|
||||
backgroundAlpha: np.ndarray,
|
||||
foregroundAlpha: np.ndarray,
|
||||
backgroundColour: np.ndarray,
|
||||
foregroundColour: np.ndarray,
|
||||
):
|
||||
"""'clip' composite mode.
|
||||
|
||||
All parts of 'layer above' which are alpha in 'layer below' will be made
|
||||
also alpha in 'layer above'
|
||||
(to whatever degree of alpha they were)
|
||||
|
||||
Destination which overlaps the source, replaces the source.
|
||||
|
||||
Fa = 0; Fb = αs
|
||||
co = αb x Cb x αs
|
||||
αo = αb x αs
|
||||
"""
|
||||
del foregroundColour # Not used by function
|
||||
outAlpha = backgroundAlpha * foregroundAlpha
|
||||
with np.errstate(divide="ignore", invalid="ignore"):
|
||||
outRGB = np.divide(
|
||||
np.multiply((backgroundAlpha * foregroundAlpha)[:, :, None], backgroundColour),
|
||||
outAlpha[:, :, None],
|
||||
)
|
||||
return outRGB, outAlpha
|
||||
|
||||
|
||||
def destout(
|
||||
backgroundAlpha: np.ndarray,
|
||||
foregroundAlpha: np.ndarray,
|
||||
backgroundColour: np.ndarray,
|
||||
foregroundColour: np.ndarray,
|
||||
):
|
||||
"""Reverse 'Clip' composite mode.
|
||||
|
||||
All parts of 'layer below' which are alpha in 'layer above' will be made
|
||||
also alpha in 'layer below'
|
||||
(to whatever degree of alpha they were)
|
||||
|
||||
"""
|
||||
del foregroundColour # Not used by function
|
||||
outAlpha = backgroundAlpha * (1 - foregroundAlpha)
|
||||
with np.errstate(divide="ignore", invalid="ignore"):
|
||||
outRGB = np.divide(
|
||||
np.multiply((backgroundAlpha * (1 - foregroundAlpha))[:, :, None], backgroundColour),
|
||||
outAlpha[:, :, None],
|
||||
)
|
||||
return outRGB, outAlpha
|
||||
|
||||
|
||||
def destatop(
|
||||
backgroundAlpha: np.ndarray,
|
||||
foregroundAlpha: np.ndarray,
|
||||
backgroundColour: np.ndarray,
|
||||
foregroundColour: np.ndarray,
|
||||
):
|
||||
"""Place the layer below above the 'layer above' in places where the 'layer above' exists...
|
||||
|
||||
where 'layer below' does not exist, but 'layer above' does, place 'layer-above'
|
||||
|
||||
"""
|
||||
outAlpha = (foregroundAlpha * (1 - backgroundAlpha)) + (backgroundAlpha * foregroundAlpha)
|
||||
with np.errstate(divide="ignore", invalid="ignore"):
|
||||
outRGB = np.divide(
|
||||
np.multiply((foregroundAlpha * (1 - backgroundAlpha))[:, :, None], foregroundColour)
|
||||
+ np.multiply((backgroundAlpha * foregroundAlpha)[:, :, None], backgroundColour),
|
||||
outAlpha[:, :, None],
|
||||
)
|
||||
return outRGB, outAlpha
|
||||
|
||||
|
||||
def srcatop(
|
||||
backgroundAlpha: np.ndarray,
|
||||
foregroundAlpha: np.ndarray,
|
||||
backgroundColour: np.ndarray,
|
||||
foregroundColour: np.ndarray,
|
||||
):
|
||||
"""Place the layer below above the 'layer above' in places where the 'layer above' exists."""
|
||||
outAlpha = (foregroundAlpha * backgroundAlpha) + (backgroundAlpha * (1 - foregroundAlpha))
|
||||
with np.errstate(divide="ignore", invalid="ignore"):
|
||||
outRGB = np.divide(
|
||||
np.multiply((foregroundAlpha * backgroundAlpha)[:, :, None], foregroundColour)
|
||||
+ np.multiply((backgroundAlpha * (1 - foregroundAlpha))[:, :, None], backgroundColour),
|
||||
outAlpha[:, :, None],
|
||||
)
|
||||
|
||||
return outRGB, outAlpha
|
||||
|
||||
|
||||
def imageIntToFloat(image: np.ndarray) -> np.ndarray:
|
||||
"""Convert a numpy array representing an image to an array of floats.
|
||||
|
||||
Args:
|
||||
image (np.ndarray): numpy array of ints
|
||||
|
||||
Returns:
|
||||
np.ndarray: numpy array of floats
|
||||
"""
|
||||
return image / 255
|
||||
|
||||
|
||||
def imageFloatToInt(image: np.ndarray) -> np.ndarray:
|
||||
"""Convert a numpy array representing an image to an array of ints.
|
||||
|
||||
Args:
|
||||
image (np.ndarray): numpy array of floats
|
||||
|
||||
Returns:
|
||||
np.ndarray: numpy array of ints
|
||||
"""
|
||||
return (image * 255).astype(np.uint8)
|
||||
|
||||
|
||||
def blend(background: np.ndarray, foreground: np.ndarray, blendType: BlendType) -> np.ndarray:
|
||||
"""Blend pixels.
|
||||
|
||||
Args:
|
||||
background (np.ndarray): background
|
||||
foreground (np.ndarray): foreground
|
||||
blendType (BlendType): the blend type
|
||||
|
||||
Returns:
|
||||
np.ndarray: new array representing the image
|
||||
|
||||
background: np.ndarray,
|
||||
foreground: np.ndarray and the return are in the form
|
||||
|
||||
[[[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
...
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]]
|
||||
|
||||
...
|
||||
|
||||
[[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
...
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]
|
||||
[0. 0. 0.]]]
|
||||
"""
|
||||
blendLookup = {
|
||||
BlendType.NORMAL: normal,
|
||||
BlendType.MULTIPLY: multiply,
|
||||
BlendType.COLOURBURN: colourburn,
|
||||
BlendType.COLOURDODGE: colourdodge,
|
||||
BlendType.REFLECT: reflect,
|
||||
BlendType.OVERLAY: overlay,
|
||||
BlendType.DIFFERENCE: difference,
|
||||
BlendType.LIGHTEN: lighten,
|
||||
BlendType.DARKEN: darken,
|
||||
BlendType.SCREEN: screen,
|
||||
BlendType.SOFTLIGHT: softlight,
|
||||
BlendType.HARDLIGHT: hardlight,
|
||||
BlendType.GRAINEXTRACT: grainextract,
|
||||
BlendType.GRAINMERGE: grainmerge,
|
||||
BlendType.DIVIDE: divide,
|
||||
BlendType.HUE: hue,
|
||||
BlendType.SATURATION: saturation,
|
||||
BlendType.COLOUR: colour,
|
||||
BlendType.LUMINOSITY: luminosity,
|
||||
BlendType.XOR: xor,
|
||||
BlendType.NEGATION: negation,
|
||||
BlendType.PINLIGHT: pinlight,
|
||||
BlendType.VIVIDLIGHT: vividlight,
|
||||
BlendType.EXCLUSION: exclusion,
|
||||
}
|
||||
|
||||
if blendType not in blendLookup:
|
||||
return normal(background, foreground)
|
||||
return blendLookup[blendType](background, foreground)
|
||||
|
||||
|
||||
def blendLayers(
|
||||
background: Image.Image,
|
||||
foreground: Image.Image,
|
||||
blendType: BlendType | tuple[str, ...],
|
||||
opacity: float = 1.0,
|
||||
) -> Image.Image:
|
||||
"""Blend layers using numpy array.
|
||||
|
||||
Args:
|
||||
background (Image.Image): background layer
|
||||
foreground (Image.Image): foreground layer (must be same size as background)
|
||||
blendType (BlendType): The blendtype
|
||||
opacity (float): The opacity of the foreground image
|
||||
|
||||
Returns:
|
||||
Image.Image: combined image
|
||||
"""
|
||||
# Convert the Image.Image to a numpy array
|
||||
npForeground: np.ndarray = imageIntToFloat(np.array(foreground.convert("RGBA")))
|
||||
npBackground: np.ndarray = imageIntToFloat(np.array(background.convert("RGBA")))
|
||||
|
||||
# Get the alpha from the layers
|
||||
backgroundAlpha = npBackground[:, :, 3]
|
||||
foregroundAlpha = npForeground[:, :, 3] * opacity
|
||||
combinedAlpha = backgroundAlpha * foregroundAlpha
|
||||
|
||||
# Get the colour from the layers
|
||||
backgroundColor = npBackground[:, :, 0:3]
|
||||
foregroundColor = npForeground[:, :, 0:3]
|
||||
|
||||
# Some effects require alpha
|
||||
alphaFunc = {
|
||||
BlendType.DESTIN: destin,
|
||||
BlendType.DESTOUT: destout,
|
||||
BlendType.SRCATOP: srcatop,
|
||||
BlendType.DESTATOP: destatop,
|
||||
}
|
||||
|
||||
if blendType in alphaFunc:
|
||||
return Image.fromarray(
|
||||
imageFloatToInt(
|
||||
np.clip(
|
||||
np.dstack(
|
||||
alphaFunc[blendType](
|
||||
backgroundAlpha, foregroundAlpha, backgroundColor, foregroundColor
|
||||
)
|
||||
),
|
||||
a_min=0,
|
||||
a_max=1,
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
# Get the colours and the alpha for the new image
|
||||
colorComponents = (
|
||||
(backgroundAlpha - combinedAlpha)[:, :, None] * backgroundColor
|
||||
+ (foregroundAlpha - combinedAlpha)[:, :, None] * foregroundColor
|
||||
+ combinedAlpha[:, :, None] * blend(backgroundColor, foregroundColor, blendType)
|
||||
)
|
||||
alphaComponent = backgroundAlpha + foregroundAlpha - combinedAlpha
|
||||
|
||||
return Image.fromarray(
|
||||
imageFloatToInt(np.clip(np.dstack((colorComponents, alphaComponent)), a_min=0, a_max=1))
|
||||
)
|
||||
Reference in New Issue
Block a user