Add files via upload

1 files changed, 511 insertions, 0 deletions

diff --git a/venv/Lib/site-packages/blendmodes/blend.py b/venv/Lib/site-packages/blendmodes/blend.py
new file mode 100644
index 00000000..4165bfa7
--- /dev/null
+++ b/venv/Lib/site-packages/blendmodes/blend.py
@@ -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))

+	)