Delete venv/Lib/site-packages directory

1 files changed, 0 insertions, 511 deletions

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

-	)