""" Main library include this to use

-----------------------------------

| Copyright 2022 by Joel C. Alcarez |

| [[email protected]] |

|-----------------------------------|

| We make absolutely no warranty |

| of any kind, expressed or implied |

|-----------------------------------|

| The primary author and any |

| any subsequent code contributors |

| shall not be liable in any event |

| for incidental or consequential |

| damages in connection with, or |

| arising out from the use of this |

| code in current form or with any |

| modifications. |

|-----------------------------------|

| Contact primary author |

| if you plan to use this |

| in a commercial product at |

| [email protected] |

|-----------------------------------|

| Educational or hobby use is |

| highly encouraged... |

| have fun coding ! |

|-----------------------------------|

| This graphics library outputs |

| to a bitmap file. |

-----------------------------------

"""

from . import shims

from array import array

from math import(

sin,

cos,

radians,

pi

)

from os import (

TMP_MAX,

environ,

getcwd,

mkdir

)

from os.path import pathsep

from pathlib import Path

from random import random

from typing import Callable

from numbers import Number

from .proctimer import functimer

from .bmpconstants import(

bmpheaderid,

bmpfilesize,

bmphdrsize,

bmpcolorbits,

bmpx,

bmpy,

bmppal,

bmpheadersizedict

)

from .mathlib import(

addvect,

addvectinlist,

andvect,

anglebetween2Dlines,

centerpoint,

computerotvec,

cosaffin,

clamp,

delta,

dist,

enumbits,

getcomplexdomainbounds,

getdomainbounds,

histogram2D,

histogram2Dcomplex,

initmatrix,

intscalarmulvect,

isinrange,

lerp,

invlerp,

LSMslope,

LSMYint,

mirror,

polar2rectcoord2D,

range2baseanddelta,

ravel2D,

rotatebits,

roundvect,

setmax,

setmin,

setminmax,

scalarmulvect,

smoothstep,

smootherstep,

smootheststep,

smoothsteplerp,

smoothersteplerp,

smootheststeplerp,

invsmoothstep,

subvect,

swapxy,

trans,

vmag,

xorvect

)

from .primitives2D import(

arcvert,

bsplinevert,

circleinvolutevert,

cornuspiralvert,

eggcurvevert,

ellipsevert,

entirecircleisinboundary,

entireellipseisinboundary,

epicycloidvert,

flowervert,

gearcurvevert,

heartcurvevert,

horizontalvert,

hypotrochoidvert,

isinrectbnd,

iterbeziercurve,

iterbspline,

itercircle,

itercircleinvolute,

itercirclepart,

itercirclepartlineedge,

itercirclepartvertlineedge,

itercornuspiral,

iterdrawvec,

itereggcurve,

iterellipse,

iterellipsepart,

iterellipserot,

iterepicycloid,

iterflower,

itergearcurve,

itergetneighbors,

iterheartcurve,

iterhypotrochoid,

iterline,

iterlissajouscurve,

iterparallelogram,

iterspirograph,

itersquircle,

itersuperellipse,

lissajouscurvevert,

listinrecbnd,

rectboundarycoords,

recvert,

regpolygonvert,

sortrecpoints,

spiralcontrolpointsvert,

spirographvert,

squirclevert,

superellipsevert,

verticalvert

)

from .solids3D import(

conevertandsurface,

cubevert,

cylindervertandsurface,

decahedvertandsurface,

fillpolydata,

gensides,

getshapesidedict,

hexahedravert,

icosahedvertandsurface,

octahedravert,

perspective,

polyboundary,

rotvec3D,

spherevertandsurface,

surfplot3Dvertandsurface,

tetrahedravert

)

from .colors import(

applybrightnessadjtoBGRbuf,

applycolorfiltertoBGRbuf,

applygammaBGRbuf,

applymonochromefiltertoBGRbuf,

applythresholdadjtoBGRbuf,

bmpstdpal,

bmpvalidcolorbits,

brightnessadjust,

colorfilter,

colorfiltertoBGRbuf,

colormix,

dichromaticpal,

gammaBGRbuf,

gammacorrect,

getdefaultbitpal,

getdefaultlumrange,

interpolateRGB,

int2BGRarr,

int2RGB,

int2RGBarr,

int2RGBlist,

invertbitsinbuffer,

isvalidcolorbit,

makeBGRbuf,

matchRGBtopal,

monochrome,

monochromefiltertoBGRbuf,

monochromepal,

monoshiftablepal,

monoinverseshiftablepal,

monoinverseshiftableBGRpal,

monoinverseshiftableBGRApal,

probplotRGBto1bit,

RGB2BGRAlist,

RGB2BGRbuf,

RGB2HSL,

RGB2int,

RGBfactors2RGB,

RGBfactorstoBaseandRange,

RGB2BGRarr,

thresholdadjust

)

from .paramchecks import(

entirecircleinboundary,

entirerectinboundary,

func24bitonly,

func24bitonlyandentirecircleinboundary,

func24bitonlyandentirerectinboundary,

func8and24bitonly,

func4and8bitonly,

func8and24bitonlyandentirecircleinboundary,

func8and24bitonlyandentirerectinboundary,

intcircleparam,

intcircleparam24bitonly

)

from .bufferflip import(

flipnibbleinbuf,

rotatebitsinbuf

)

from .chartools import(

char2int,

enumletters,

enumreverseletters

)

from .conditionaltools import iif, swapif

from .dicttools import dict2descorderlist

from .fileutils import checklink, checklinks

from .fonts import(

font8x8,

font8x8thin,

font8x14,

font8x14thin,

font8x8sanserif,

font8x14sanserif,

getcharfont)

from .fractals import(

cliffordattractorlist,

fractaldomainparamdict,

fractaldreamattractorlist,

funcparamdict,

getIFSparams,

gumowskimiraattractorlist,

hilbertvert,

hopalongattractorlist,

ikedaattractorlist,

iterastroid,

iterbarnsleytree,

itercosjulia,

iterIFS,

iterlamdbafractal,

iterlemniscate,

itermarekdragon,

itermulti2ndtetrationbiomorph,

itermultibiomorph,

itermultibiomorphvariant,

itermultibiomorphphasevariant,

itermultibrot,

itermulticircle,

itermulticorn,

itermulticosbiomorph,

itermulticoshbiomorph,

itermultiexpbiomorph,

itermultihyperbola,

itermultijulia,

itermultisinbiomorph,

itermultisinhbiomorph,

itermultisuperellipse,

itermultitanbiomorph,

itermultitanhbiomorph,

itermultizconjugatebiomorph,

iternewtonsfractal,

iterngonfractal,

itersinjulia,

iterspiraljulia,

itertetration,

itertricorn,

iterxordivfractal,

iterxorfractal,

kochcurvevert,

kochsnowflakevert,

nattractorlist,

peterdejongattractorlist,

symmetriciconattractorlist,

duffingattractorlist

)

from .inttools import(

readint,

writeint,

int2buf,

buf2int

)

from .messages import sysmsg

from .funcmeta import getfuncmetastr

from .bufresize import(

adjustxbufsize,

resizebufNtimesbigger,

resizesmaller24bitbuf

)

from .charts import(

getdatalisttotal,

genpiechartdata

)

from .textgraphics import(

computetextrowandcolcnt,

plotbitsastext,

plot8bitpatternastext

)

from .colordict import(

getcolorname2RGBdict,

getcolorname2HSLdict,

getRGBfactors

)

from .X11colordict import(

getX11colorname2RGBdict,

getX11colorname2HSLdict,

getX11RGBfactors

)

from .XKCDcolordict import(

getXKCDcolorname2RGBdict,

getXKCDcolorname2HSLdict,

getXKCDRGBfactors

)

def _setx(bmp: array, xmax: int):

"""Sets the x value stored in the windows bmp header

Args:

bmp: unsigned byte array

with bmp format

int: value of x dimension

Returns:

byref modified unsigned byte array

"""

writeint(bmpx, 4, bmp, xmax)

def getmaxx(bmp: array) -> int:

"""Gets the x value stored in the windows bmp header

Args:

bmp: unsigned byte array

with bmp format

Returns:

int value of x bmp dimension

"""

return readint(bmpx, 4, bmp)

def _sety(bmp: array, ymax: int):

"""Sets the y value stored in the windows bmp header

Args:

bmp: unsigned byte array

with bmp format

int: value of y dimension

Returns:

byref modified unsigned byte array

"""

writeint(bmpy, 4, bmp, ymax)

def getmaxy(bmp: array) -> int:

"""Gets the y value stored in the windows bmp header

Args:

bmp: unsigned byte array

with bmp format

Returns:

int value of y bmp dimension

"""

return readint(bmpy, 4, bmp)

def getmaxxy(bmp: array) -> tuple:

"""Gets the max x and y values stored in the bmp header

Args:

bmp: unsigned byte array

with bmp format

Returns:

tuple (x:int,y:int)

"""

return (readint(bmpx, 4, bmp),

readint(bmpy, 4, bmp))

def bottomrightcoord(

bmp: array) -> tuple:

"""Gets the maximum bottom right coordinates of a bmp

Args:

bmp: unsigned byte array

with bmp format

Returns:

tuple (x:int,y:int)

"""

return (readint(bmpx, 4, bmp) - 1,

readint(bmpy, 4, bmp) - 1)

def centercoord(bmp: array) -> tuple:

"""Gets the central coordinates of a BMP

Args:

bmp: unsigned byte array

with bmp format

Returns:

tuple (x:int,y:int)

"""

return ((readint(bmpx, 4, bmp) - 1) >> 1,

(readint(bmpy, 4, bmp) - 1) >> 1)

def isinBMPrectbnd(bmp: array,

x: int, y: int) -> bool:

"""Checks if (x,y) coordinates are within the BMP

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int value

of location

in x-axis and y-axis

Returns:

True if within bounds

False if out of bounds

"""

return (x < readint(bmpx, 4, bmp) and

y < readint(bmpy, 4, bmp)) and \

(x > -1 and y > -1)

def listinBMPrecbnd(bmp: array,

xylist: list) -> bool:

"""Checks if a list of (x, y) coordinates are within the BMP

Args:

bmp : unsigned byte array

with bmp format

xylist: list of (x, y)

coordinates

to be checked

Returns:

True if within bounds

False if out of bounds

"""

for (x, y) in xylist:

if isinBMPrectbnd(

bmp, x, y) == False:

break

return True

def _getclrbits(bmp: array) -> int:

"""Get the bit depth of BMP

Args:

bmp: unsigned byte array

with bmp format

Returns:

int value of bit depth

(1, 4, 8, 24) bits

"""

return bmp[bmpcolorbits]

def _xchrcnt(bmp: array) -> int:

"""Get the chars or bytes in row of a BMP

Args:

bmp: unsigned byte array

with bmp format

Returns:

count of bytes or

chars in a row (x dim)

"""

return _xbytes(

readint(bmpx, 4, bmp),

bmp[bmpcolorbits])

def _setflsz(bmp: array, size: int):

"""Set the file size of a BMP

Args:

bmp : unsigned byte array

with bmp format

size : unsigned int value

of size of

the bmp file

Returns:

byref modified unsigned byte array

with new file size

"""

writeint(bmpfilesize, 8, bmp, size)

def _flsz(bmp: array) -> int:

"""Get the file size of a win bmp

from its bmp header

Args:

bmp: unsigned byte array

with bmp format

Returns:

unsigned int value of size

of the bmp header

"""

return readint(bmpfilesize, 8, bmp)

def _sethdsz(bmp: array, hdsize: int):

"""Set the header size of a win bmp

Args:

bmp : unsigned byte array

with bmp format

hdsize: unsigned int value

of size of the

bmp header

Returns:

byref modified byte array

with new header size

"""

writeint(bmphdrsize, 4, bmp, hdsize)

def _hdsz(bmp: array) -> int:

"""Get the header size of a BMP

Args:

bmp: unsigned byte array

with bmp format

Returns:

int value of header size

"""

return readint(bmphdrsize, 4, bmp)

def getmaxcolors(bmp: array) -> int:

"""Get the maximum number of colors supported by a BMP

Args:

bmp: unsigned byte array

with bmp format

Returns:

int value

"""

return 1 << bmp[bmpcolorbits]

def _24bmof(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array with RGB data given x and y

Args:

bmp: unsigned byte array

with bmp format

x,y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x * 3) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 24))

def _24bmofhd(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with RGB data given x and y with bmp header

Args:

bmp: unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x * 3) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 24 )) + 54

def _8bmof(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 8 bit color data given x and y data

Args:

bmp: unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to

that data in byte array

"""

return x + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 8))

def _8bmofhd(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 8 bit color data given

x and y with adjustments

made for a bmp header

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to

that data in byte array

"""

return x + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 8)) + \

1078

def _4bmof(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 4 bit color data given x and y data

Args:

bmp: unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x >> 1) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 4))

def _1bmof(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 1 bit color data given x and y data

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x >> 3) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 1))

def _4bmofhd(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 4 bit color data given

x and y with adjustments

made due to a header

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x >> 1) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 4)) + \

118

def _1bmofhd(bmp: array,

x: int, y: int) -> int:

"""Get the offset in a byte array

with 1 bit color data given

x and y with adjustments

made for a bmp header

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int value

of location in

x-axis and y-axis

Returns:

int value of offset to that data in byte array

"""

return (x >> 3) + \

((readint(bmpy, 4, bmp) - y - 1) * \

_xbytes(readint(bmpx, 4, bmp), 1)) + \

62

def _getBMoffhdfunc(bmp: array):

"""Returns the correct function

to use in computing offsets

with headers in a given bmp

Args:

bmp: unsigned byte array

with bmp format

Returns:

function to compute offsets with headers

"""

return {24: _24bmofhd,

8: _8bmofhd,

4: _4bmofhd,

1: _1bmofhd}[bmp[bmpcolorbits]]

def _getBMofffunc(bmp: array):

"""Returns the correct function

to use in computing the offset

in a given bitmap

Args:

bmp: unsigned byte array

with bmp format

Returns:

function to compute offsets

"""

return {24: _24bmof,

8: _8bmof,

4: _4bmof,

1: _1bmof}[bmp[bmpcolorbits]]

def _BMoffset(bmp: array,

x: int, y: int) -> int:

"""Returns the offset given a bmp and (x, y) coordinates

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int location

in x-axis and y-axis

Returns:

unsigned int offset to data in buffer

"""

return _getBMofffunc(bmp)(bmp, x, y)

def _BMoffsethd(bmp: array,

x: int, y: int) -> int:

"""Returns the offset given a bmp

and (x, y) coordinates with header considered

Args:

bmp : unsigned byte array

with bmp format

x, y: unsigned int location

in x-axis and y-axis

Returns:

unsigned int offset to data in buffer

"""

return _getBMoffhdfunc(bmp)(bmp, x, y)

def getmaxxyandbits(bmp: array) -> tuple:

"""Returns bitmap metadata

(x-dimension, y-dimension, bit depth)

Args:

bmp: unsigned byte array

with bmp format

Returns:

(x-dimension, y-dimension, bit depth)

"""

return (((readint(bmpx, 4, bmp),

readint(bmpy, 4, bmp)),

bmp[bmpcolorbits]))

def _xbytes(x: int, bits: int) -> int:

"""Get the number of bytes in

a bmp row given x dimension and bit depth

Args:

x : unsigned int value of

x-dimension

bits: unsigned int value of

bit depth (1, 4, 8, 24)

Returns:

int value of number of bytes in a row

"""

if bits <= 8:

xperbyte = 8 // bits

xbytes, rem = divmod(x, xperbyte)

if rem > 0:

xbytes += 1

if bits == 24:

xbytes = x * 3

rem = xbytes & 3

if rem > 0:

xbytes = xbytes + (4 - rem)

return xbytes

def _pdbytes(x: int, bits: int) -> int:

"""Get the number of bytes used to pad for

32-bit alignment given x dimension and bit depth

Args:

x : unsigned int value of

x-dimension

bits: unsigned int value of

bit depth (1, 4, 8, 24)

Returns:

int value of number of pad bytes

"""

if bits <= 8:

xperbyte = 8 // bits

xbytes, rem = divmod(x, xperbyte)

if rem > 0:

xbytes += 1

if bits == 24:

xbytes = x * 3

rem = xbytes & 3

return iif(rem > 0, 4 - rem, 0)

def _getbmflsz(x: int, y: int,

bits: int) -> int:

"""Computes bitmap file size

Args:

x, y: unsigned int value

of x and y dimensions

bits: bit depth (1, 4, 8, 24)

Returns:

int value of file size

"""

return _xbytes(x, bits) * y + \

bmpheadersizedict[bits]

def _bmmeta(x: int, y: int,

bits: int) -> tuple:

"""Computes bitmap meta data

Args:

x, y : unsigned int

values of the

x and y dimension

bits : bit depth (1, 4, 8, 24)

Returns:

unsigned int values for

(filesize, headersize,

xdim, ydim, bitdepth)

"""

return (_getbmflsz(x, y, bits),

bmpheadersizedict[bits], x, y, bits)

def isdefaultpal(bmp: array) -> bool:

"""Checks if bitmap has a default RGB color palette

Args:

bmp: unsigned byte array

with bmp format

Returns:

True if default

False if not default

"""

return getdefaultbitpal(_getclrbits(bmp)) == \

getallRGBpal(bmp)

def getBMPimgbytes(bmp: array) -> list:

"""Gets the raw image buffer of a bmp without the header

Args:

bmp: unsigned byte array

with bmp format

Returns:

list of unsigned bytes

"""

return bmp[_hdsz(bmp): _flsz(bmp)]

def setBMPimgbytes(

bmp: array, buf: array):

"""Sets the raw image buffer of a bitmap

Args:

bmp: unsigned byte array

with bmp format

buf: array of unsigned bytes

Returns:

byref modified unsigned byte array

"""

bmp[_hdsz(bmp): _flsz(bmp)] = buf

def setbmppal(bmp: array,

pallist: list):

"""Sets the RGB palette of a bitmap

Args:

bmp : unsigned byte array

with bmp format