# Algorithms

postprocessing = modification of the image = graphic algorithms = image processing
Algorithms by graphic type
* raster algorithms
* vector algorithms
Five classes of image processing algorithms:
* image restoration
* image analysis
* image synthesis
* image enhancement
* image compression.
List:
* Color Theory: Color gradient
* 2D Plane transformations
** 2D to 3D
*** heightmaps
*** slope
* Morphological operations on binary images
** morphological closing = dilation followed by erosion
** morphological opening = erosion followed by dilation
Postprocessing
* Two types of edge detection
* Pseudo-3D projections
* Star field generator
* Random dot stereograms (aka Magic Eye)
* Motion blur for animations
* Interlacing
* Embossing
* Antialiasing
* Palette emulation to allow color cycling on true-color displays
* True color emulation that provides dithering on 256-color display
Algorithms:
* coloring after and independently of the fractal creation using gradient maps
** histogram colorings
* gamma correction of dense images
* Histogram equalization in wikipedia
* (matrix) convolution ( = discrete convolution) is an element-wise multiplication of two matrices followed by a sum
** image convolution
*** LIC

## types
### range

The image processing operators ( algorithms) can be classified into the 4 categories
* pixel algorithms = pixel processing: the point operator acts on individual pixels : g = H(f)
** add two images: g(x)=f1(x)+f2(x)
** the histogram
** look-up table (LUT)
** windowing
* local algorithms = kernaling = local processing: "A local operator calculates the pixel value g(x) based not only on the value in the same position in the input image, i.e. f(x) , but it used several values in nearby points f(x+y). Local operators are at the heart of almost all image processing tasks."
** spatial location filtering (convolution),
** spatial frequency filtering using high- and low-pass digital filters,
** the unsharp masking technique
* geometric processing = geometric transformations: "Whereas a point operator changes the value of all pixels a geometrical operator doesn’t change the value but instead it ‘moves’ a pixel to a new position."
* Global Operators: "A global operator (potentially) needs al pixel values in the input image to calculate the value for just one pixel in the output image."

# Libraries

* DGtal = Digital Geometry Tools and Algorithms Library in C++
* CGAL - The Computational Geometry Algorithms Library in C++
* Habrador - Computational-geometry in C#
* Manipulation and analysis of geometric objects in Python

# Digital topology

* HIPR --- The Hypermedia Image Processing Reference by R. Fisher, S. Perkins, A. Walker and E. Wolfart.
* Topological tools for discrete shape analysis by John Chaussard

# geometry

* hyperbolic
** hyperbolic

# light

* image-based-lighting by Mikael Hvidtfeldt Christensen
* Global Illumination Compendium September 29, 2003 by Philip Dutré
* Light sources

# gamma correction

* gamma-correction by Mikael Hvidtfeldt Christensen

# dense image

Dense image
* downscaling with gamma correction
* path finding
* aliasing
* changing algorithm ( representation function) from discrete to continous, like from level set method of escape time to continous ( DEM )

# tiling

* tiling editor
* Tiling Bot by Roice Nelson
* draw the Wythoff construction of uniform tilings in hyperbolic plane
* EPINET = Euclidean Patterns In Non-Euclidean Tilings

# path finding

path finding
* old fractal forums : pathfinding-in-the-mandelbrot-set/
* fractalforums.org : pathfinding-in-the-mandelbrot-set-revisited
* 5-ways-to-find-the-shortest-path-in-a-graph by Johannes Baum
* mathreference - graph
Algorithms
* Depth-First Search (DFS) = the simplest algorithm
* Breadth-First Search (BFS)
* Bidirectional Search
* Dijkstra's algorithm (or Dijkstra's Shortest Path First algorithm, SPF algorithm)
** programiz : dijkstra-algorithm
** dyclassroom : dijkstra-algorithm-finding-shortest-path
* Bellman-Ford Algorithm

# size

* how to opern big image
** vliv: The principle behind Vliv (only load parts of the image that is visible, and leverage the TIFF format - tiled pyramidal images) can be implemented on any OS. The API for plugins consists only of 5 functions, see the vlivplugins repo for examples.

## resizing

Methods:
* Image Magic resize
* FF
* 2^x Image Super-Resolution
** Final2x
** image-super-resolution

# polygons

* geometric operations for two-dimensional polygons

## Testing if point is inside triangle

* description
* javascript code

## Orientation and area of the triangle

Orientation and area of the triangle : how to do it ?

## Testing if point is inside polygon

* stackoverflow
* description by W Muła
* point_in_polygon by Patrick Glauner
** A Simple and Correct Even-Odd Algorithm for the Point-in-Polygon Problem for Complex Polygons by Michael Galetzka, Patrick O. Glauner
** c code
* PNPOLY - Point Inclusion in Polygon Test - W. Randolph Franklin (WRF)

# curve

types:
* closed/open
* with/without multiple points
methods
* tracing /drawing : Generating Discrete Curves
* sketching
* sampling
* Pathfinding or pathing is the plotting, by a computer application, of the shortest route between two points
* clipping
* Approximation of digitized curves (with cubic Bézier splines )
* curve fitting
* Mending broken lines
* edge detection
Examples
* line
** bresenhams-drawing-algorithms
** antyaliasing
* circle

## Morton codes

* libmorton C++ header-only library with methods to efficiently encode/decode Morton codes in/from 2D/3D coordinates
* aavenel mortonlib

## morphing

* Interpolations from a circle to a triangle in p5.js by Golan Levin

## curve simplifying

reduce the number of points, but still keep the overall shape of the curve = PolyLine Reduction
* Ramer–Douglas–Peucker_algorithm
** JS interactive maps library by Vladimir Agafonkin, It uses a combination of Douglas-Peucker and Radial Distance algorithms.
* Visvalingam–Whyatt algorithm
** Permafacture: Py-Visvalingam-Whyatt ( Python code)

## curve fitting

* my curve fit: online curve fitting

## thick line drawing

thick line
* The Beauty of Bresenham's Algorithm by Alois Zingl
* Murphy's Modified Bresenham Line Drawing Algorithm
* stackoverflow question: how-do-i-create-a-line-of-arbitrary-thickness-using-bresenham

## curve drawing

* Curve-Drawing Algorithms for Raster Displays by JERRY VAN AKEN and MARK NOVAK
* A Rasterizing Algorithm for Drawing Curves by Alois Zingl Wien, 2012
* Curve-Drawing Algorithms for Raster Displays by JERRY VAN AKEN and MARK NOVAK
* A* Pathfinding for Beginners By Patrick Lester (Updated July 18, 2005)
* Max K. Agoston Computer Graphics and Geometric Modeling Implementation and Algorithms
* libspiro is the creation of Raph Levien. It simplifies the drawing of beautiful curves
* spiro An interpolating spline based on spirals
neighborhood variants of 2D algorithms:
* 8-way stepping (8WS) for 8-direction neighbors of a pixel p(x, y)
* 4-way stepping (4WS) 4-direction neighbors of a pixel p(x, y)
* 2D neighborhood
* 4
* 8

## curve sampling

* uniform = gives equidistant points
* adaptive. " an adaptive method for sampling the domain with respect to local curvature. Samples concentration is in proportion to this curvature, resulting in a more efficient approximation—in the limit, a flat curve is approximated by merely two endpoints."
* ocaml-curve-sampling by Christophe Troestler
* xahlee : adaptive_sampling_plot_math_curve

## Field lines

Field line
* Vector fied : Field line computing
* external rays
** parameter
** dynamic
* gravitational field lines by Chris Thomasson. Images and AS3 code

## Tracing

Tracing curve
Methods
* general, (analytic or systematic) = curve sketching
* local method
Task: draw a 2D curve when
* there is no equaation of the line
* there are all the numerical values for the line within a certain range
trace an external ray for angle t in turns, which means ( description by Claude Heiland-Allen)
* starting at a large circle (e.g. r = 65536, x = r cos(2 pi t), y = r sin(2 pi t))
* following the escape lines (like the edges of binary decomposition colouring with large escape radius) in towards the Mandelbrot set.
this algorithm is O(period^2), which means doubling the period takes 4x as long, so it's only really feasible for periods up to a few 1000.
Three Curve Tracing Models
* Pixel-by-Pixel tracing
* brute force: If your line is short enough (less than 10^6 points), you can do this by calculating the distance from point p to each point in your discretized line, and take the minimum of these distances.
* The bipartite receptive field operator
* The zoom lens operator
Images
* Images in category Curve tracing from commons
Problems:
* intersection and Breadth-first search
Examples
* Numerical Methods for Particle Tracing in Vector Fields by Kenneth I. Joy

## Curve rasterisation
### Ray

Ray can be parametrised with radius (r)

### Closed curve

Simple closed curve ("a connected curve that does not cross itself and ends at the same point where it begins" = having no endpoints) can be parametrized with angle (t).

## Border, boundary, contour, edge

* Filling contour
* Finds contours in a binary image
* CavalierContoursWebDemo aand code

### contour models

* snakes = active contour models

### border tracing

* Contour tracing algorithms by Abeer George Ghuneim
* Tracing Boundaries in 2D Images by V. Kovalevsky
* wikipedia : Boundary tracing
* Calculating contour curves for 2D scalar fields
** the marching squares algorithm for tracing contour curves on a scalar 2D field
* Smooth Contours
* contour polygons
* boundary in C++ by Shawn Halayka - 2019 and new code
* opencv_contour in C++ by Shawn Halayka
* CONREC A Contouring Subroutine Written by Paul Bourke July 1987 ( using triangulation)

### Filling contour

* Filling contour - simple procedure in c

### Edge detection

* Boundary scanning method for Julia set - BSM/J
* Boundary scanning method for Mandelbrot set - BSM/M
* edge detection in Matlab
* Marching squares algorithm to generate contour lines
* The Roberts cross operator is used in image processing and computer vision for edge detection.
* Level curves - edge detection (2 filters)
* Edge detection of boundaries of level sets of escape time

#### Sobel filter
##### Short introduction

Sobel filter G consist of 2 kernels (masks):
* Gh for horizontal changes.
* Gv for vertical changes.

###### Sobel kernels

The Sobel kernel contains weights for each pixel from the 8-point neighbourhood of a tested pixel. These are 3x3 kernels.
There are 2 Sobel kernels, one for computing horizontal changes and other for computing vertical changes. Notice that a large horizontal change may indicate a vertical border, and a large vertical change may indicate a horizontal border. The x-coordinate is here defined as increasing in the "right"-direction, and the y-coordinate is defined as increasing in the "down"-direction.
The Sobel kernel for computing horizontal changes is:
    $\mathbf {H} ={\begin{bmatrix}H_{1}&H_{2}&H_{3}\\H_{4}&H_{5}&H_{6}\\H_{7}&H_{8}&H_{9}\end{bmatrix}}={\begin{bmatrix}-1&0&+1\\-2&0&+2\\-1&0&+1\end{bmatrix}}$
The Sobel kernel for computing vertical changes is:
    $\mathbf {V} ={\begin{bmatrix}-1&-2&-1\\\ \ 0&\ \ 0&\ \ 0\\+1&+2&+1\end{bmatrix}}$
Note that:
* sum of weights of kernels are zero
$\sum _{i=1}^{9}H_{i}=0$
$\sum _{i=1}^{9}V_{i}=0$
* One kernel is simply the other rotated by 90 degrees.
* 3 weights in each kernal are zero.

###### Pixel kernel

Pixel kernel A containing central pixel $A_{5}$ with its 3x3 neighbourhood:
    $\mathbf {A} ={\begin{bmatrix}A_{1}&A_{2}&A_{3}\\A_{4}&A_{5}&A_{6}\\A_{7}&A_{8}&A_{9}\end{bmatrix}}$
Other notations for pixel kernel:
    $\mathbf {A} ={\begin{bmatrix}A_{1}&A_{2}&A_{3}\\A_{4}&A_{5}&A_{6}\\A_{7}&A_{8}&A_{9}\end{bmatrix}}={\begin{bmatrix}ul&um&ur\\ml&mm&mr\\ll&lm&lr\end{bmatrix}}$
where:
In array notation it is:
    $\mathbf {A} ={\begin{bmatrix}A[x-1][y+1]&A[x][y+1]&A[x+1][y+1]\\A[x-1][y]&A[x][y]&A[x+1][y]\\A[x-1][y-1]&A[x][y-1]&A[x+1][y-1]\end{bmatrix}}$
In geographic notation usede in cellular aotomats it is central pixel of Moore neighbourhood.
So central (tested) pixel is:
$A_{5}=mm=A[x][y]\,$

###### Sobel filters

Compute Sobel filters (where $*$ here denotes the 2-dimensional convolution operation not matrix multiplication). It is a sum of products of pixel and its weights:
    $\mathbf {G} _{h}=\mathbf {H} *A=A_{1}H_{1}+A_{2}H_{2}+\cdots +A_{9}H_{9}=\sum _{r=1}^{9}A_{r}H_{r},$
    $\mathbf {G} _{v}=\mathbf {V} *A=A_{1}V_{1}+A_{2}V_{2}+\cdots +A_{9}V_{9}=\sum _{r=1}^{9}A_{r}V_{r},$
Because 3 weights in each kernal are zero so there are only 6 products.

###### Result

Result is computed (magnitude of gradient):
    $\mathbf {G} (A_{5})={\sqrt {{\mathbf {G} _{h}}^{2}+{\mathbf {G} _{v}}^{2}}}$
It is a color of tested pixel.
One can also approximate result by sum of 2 magnitudes:
    $\mathbf {G} (A_{5})=\left|\mathbf {G} _{h}\right|+\left|\mathbf {G} _{v}\right|$
which is much faster to compute.

##### Algorithm

* choose pixel and its 3x3 neighberhood A
* compute Sobel filter for horizontal Gh and vertical lines Gv
* compute Sobel filter G
* compute color of pixel

##### Programming

Lets take array of 8-bit colors (image) called data. To find borders in this image simply do:
Note that here points on borders of array (iY= 0, iY = iYmax, iX=0, iX=iXmax) are skipped
Result is saved to another array called edge (with the same size).
One can save edge array to file showing only borders, or merge 2 arrays:
to have new image with marked borders.
Above example is for 8-bit or indexed color. For higher bit colors "the formula is applied to all three color channels separately" (from RoboRealm doc).
Other implementations:
* ImagMagic discussion: using a Sobel operator - edge detection
* Sobel in c from GIMP code
* Cpp code by Aaron Brooks - Brent Bolton - Jason O'Kane
* rosettacode: Image convolution
* C and opencl by royger
* C++ by Glenn Fiedler
* Convolution and Deconvolution
* Sobel Edge Detector by R. Fisher, S. Perkins, A. Walker and E. Wolfart with examples in Java
* Qt and GDI+ versions of the Sobel edge detection algorithm by Ken Earle
* Qt and OpenCV

##### Problems

Edge position:
In ImageMagick as "you can see, the edge is added only to areas with a color gradient that is more than 50% white! I don't know if this is a bug or intentional, but it means that the edge in the above is located almost completely in the white parts of the original mask image. This fact can be extremely important when making use of the results of the "-edge" operator."
The result is:
* doubling edges; "if you are edge detecting an image containing an black outline, the "-edge" operator will 'twin' the black lines, producing a weird result."
* lines are not meeting in good points.
See also new operators from 6 version of ImageMagick: EdgeIn and EdgeOut from Morphology

### Edge thickening

dilation

# SDF Signed Distance Function

* Vector_field SDF

# map projections

* Map projections in wikipedia
* Category:Map projections in commons
* commons Category:Map_projections_with_Tissot_s_indicatrix
* jkunimune Map-Projections

## Stereographic

Stereographic projection is a map projection obtained by projecting points P on the surface of sphere from the sphere's north pole N to point P' in a plane tangent to the south pole S.
take the north pole N to be the standard unit vector (0, 0, 1) and the center of the sphere to be the origin, so that the tangent plane at the south pole is has equation z = 1. Given a point P = (x, y, z) on the unit sphere which is not the north pole, its image is equal to
* A Cartesian grid on the plane appears distorted on the sphere. The grid lines are still perpendicular, but the areas of the grid squares shrink as they approach the north pole.
* A polar grid on the plane appears distorted on the sphere. The grid curves are still perpendicular, but the areas of the grid sectors shrink as they approach the north pole

## cylindrical
### Mercator projection

* conformal
* cylindrical = the Mercator projection maps from the sphere to an cylinder. Cylinder is cut along y axis and unrolled. It gives rectangle of infinite extent in both y-directions ( see truncation)
* cylindrical
* standard mercator ( cylindrical)
* Comparison of Mercator projections
Two equivalent constructions of standard Mercator projection:
* from sphere to cylinder ( one step)
* 2 steps :
** project the sphere to an intermediate ( stereographic) plane using the standard stereographic projection, which is conformal
** by equating the stereographic plane to the complex plane ( the image of this plane under the complex logarithm function, which is everywhere conformal except at the origin (with a branch cut) the
complex logarithm f(z) = ln(z). Effectively, a complex point z with polar coordinates (ρ,θ) is mapped to f(z) = ln(ρ) + iθ. This yields a horizontal strip,
the standard vertical Mercator mapping by rotating 90° afterwards, or equivalently f(z) can be defined as f(z) = i*ln(z).
| Normal Mercator | | Transverse Mercator |

#### truncution

Cylinder is nor finity so Mercator projections give ininite stripes with increasing distorion at poles of sphere. Thus the coordinate y of the Mercator projection becomes infinite at the poles and the map must be truncated ( cropped) at some latitude less than ninety degrees at both ends .
This need not be done symmetrically:
* Mercator's original map is truncated at 80°N and 66°S with the result that European countries were moved toward the centre of the map.

#### geometry of the earth

earth as sphere
Coordinate systems for the Earth in geography $(\phi ,\lambda )$
* latitude is a coordinate that specifies the north–south position of a point on the surface of the Earth or another celestial body. Latitude is given as an angle that ranges from –90° at the south pole to 90° at the north pole, with 0° at the Equator. is usually denoted by the Greek lower-case letter phi (ϕ or φ). It is measured in degrees, minutes and seconds or decimal degrees, north or south of the equator.
* Longitude is a geographic coordinate that specifies the east–west position of a point on the surface of the Earth. It is an angular measurement, usually expressed in degrees and denoted by the Geek letter lambda (λ).
* A perspective view of the Earth showing how latitude ($\phi$) and longitude ($\lambda$) are defined on a spherical model. The graticule spacing is 10 degrees.

#### equation

One step method:
Consider a point on the globe of radius R with longitude λ and latitude φ. The value λ$_0$ is the longitude of an arbitrary central meridian that is usually, but not always, that of Greenwich (i.e., zero). The angles λ and φ are expressed in radians.
Map from point P on the unit sphere $P=(R,\lambda ,\varphi )$ to point on the Cartesian plane $Q=(x,y)$
    ${\begin{matrix}x=R(\lambda -\lambda _{0})\\y=R\ln \left[\tan \left({\frac {\pi }{4}}+{\frac {\varphi }{2}}\right)\right]\end{matrix}}$
Two step method
* stereographic
* complex log
The spherical form of the stereographic projection is usually expressed in polar coordinates:
    ${\begin{matrix}r&=2R\tan \left({\frac {\pi }{4}}-{\frac {\varphi }{2}}\right)\\\theta &=\lambda \end{matrix}}$
where $R$ is the radius of the sphere, and $\varphi$ and $\lambda$ are the latitude and longitude, respectively.
rectangular coordinates
Assumption: A, B, C, and D are real numbers such that $A^{2}+B^{2}+C^{2}\neq 0$.
Definitions
* $\Sigma$ is defined to be the unit sphere in the Euclidean space, i.e.
* $N$ is defined to be the northern pole of the unit sphere, i.e. $N:=(0,0,1)$.
* $S$ is defined to be the stereographic projection, i.e. the function $S:\Sigma \setminus \{N\}\rightarrow \mathbb {R} ^{2}$ satisfying
for every $(x,y,z)\in \Sigma \setminus \{N\}$.
Cylindrical coordinates
Cylindrical coordinates (axial radius ρ, azimuth φ, elevation z) may be converted into spherical coordinates (central radius r, inclination θ, azimuth φ), by the formulas
${\begin{aligned}r&={\sqrt {\rho ^{2}+z^{2}}},\\\theta &=\arctan {\frac {\rho }{z}}=\arccos {\frac {z}{\sqrt {\rho ^{2}+z^{2}}}},\\\varphi &=\varphi .\end{aligned}}$
Conversely, the spherical coordinates may be converted into cylindrical coordinates by the formulae
${\begin{aligned}\rho &=r\sin \theta ,\\\varphi &=\varphi ,\\z&=r\cos \theta .\end{aligned}}$
These formulae assume that the two systems have the same origin and same reference plane, measure the azimuth angle φ in the same senses from the same axis, and that the spherical angle θ is inclination from the cylindrical z axis.
Code
* chinhsuanwu: 360-converter ( A C/C++ toolkit of 360 image conversions )

# Signal processing

Filter Linear continuous-time filters
* The frequency response can be classified into a number of different bandforms describing which frequency bands the filter passes (the passband) and which it rejects (the stopband):
** Low-pass filter – low frequencies are passed, high frequencies are attenuated.
** High-pass filter – high frequencies are passed, low frequencies are attenuated.
** Band-pass filter – only frequencies in a frequency band are passed.
** Band-stop filter or band-reject filter – only frequencies in a frequency band are attenuated.
** Notch filter – rejects just one specific frequency - an extreme band-stop filter.
** Comb filter – has multiple regularly spaced narrow passbands giving the bandform the appearance of a comb.
** All-pass filter – all frequencies are passed, but the phase of the output is modified.
* Cutoff frequency is the frequency beyond which the filter will not pass signals. It is usually measured at a specific attenuation such as 3 dB.
* Roll-off is the rate at which attenuation increases beyond the cut-off frequency.
* Transition band, the (usually narrow) band of frequencies between a passband and stopband.
* Ripple is the variation of the filter's insertion loss in the passband.
* The order of a filter is the degree of the approximating polynomial and in passive filters corresponds to the number of elements required to build it. Increasing order increases roll-off and brings the filter closer to the ideal response.

## time series
### smoothing time series data

* Smoothing with a moving average. A moving average filter is sometimes called a boxcar filter, especially when followed by decimation.
** Exponential smoothing
* Category:Smoothing_(time_series) in commons
* smoothish js program by Eamonn O'Brien-Strain

# Faq

* faqs.org: graphics algorithms-faq
* The Arcane Algorithm Archive

# References

* ↑ Michael Abrash's Graphics Programming Black Book Special Edition
* ↑ geometrictools Documentation
* ↑ list-of-algorithms by Ali Abbas
* ↑ Mitch Richling: 3D Mandelbrot Sets
* ↑ fractalforums : antialiasing-fractals-how-best-to-do-it/
* ↑ Matlab : images/morphological-filtering
* ↑ Tim Warburton : morphology in matlab
* ↑ A Cheritat wiki : see image showing gamma-correct downscale of dense part of Mandelbropt set
* ↑ Image processing by Rein van den Boomgaard.
* ↑ Seeram E, Seeram D. Image Postprocessing in Digital Radiology-A Primer for Technologists. J Med Imaging Radiat Sci. 2008 Mar;39(1):23-41. doi: 10.1016/j.jmir.2008.01.004. Epub 2008 Mar 22. PMID: 31051771.
* ↑ wikipedi : dense_set
* ↑ mathoverflow question : is-there-an-almost-dense-set-of-quadratic-polynomials-which-is-not-in-the-inte/254533#254533
* ↑ fractalforums : dense-image
* ↑ fractalforums.org : m andelbrot-set-various-structures
* ↑ fractalforums.org : technical-challenge-discussion-the-lichtenberg-figure
* ↑ A Cheritat wiki : see image showing gamma-correct downscale of dense part of Mandelbropt set
* ↑ fractal forums : pathfinding-in-the-mandelbrot-set/
* ↑ serious_statistics_aliasing by Guest_Jim
* ↑ fractalforums.org : newton-raphson-zooming
* ↑ fractalforums : gerrit-images
* ↑ 5-ways-to-find-the-shortest-path-in-a-graph by Johannes Baum
* ↑ d3-polygon - Geometric operations for two-dimensional polygons from d3js.org
* ↑ github repo for d3-polygon
* ↑ accurate-point-in-triangle-test by Cedric Jules
* ↑ stackoverflow question : how-to-determine-a-point-in-a-2d-triangle
* ↑ js code
* ↑ stackoverflow questions : How can I determine whether a 2D Point is within a Polygon?
* ↑ Punkt wewnątrz wielokąta - W Muła
* ↑ Matlab examples : curvefitting
* ↑ Mending broken lines by Alan Gibson.
* ↑ The Beauty of Bresenham's Algorithm by Alois Zingl
* ↑ bresenhams-drawing-algorithms
* ↑ Bresenham’s Line Drawing Algorithm by Peter Occil
* ↑ Peter Occil
* ↑ Algorytm Bresenhama by Wojciech Muła
* ↑ wolfram : NumberTheoreticConstructionOfDigitalCircles
* ↑ Drawing Thick Lines
* ↑ IV.4 - Adaptive Sampling of Parametric Curves by Luiz Henrique deFigueiredo
* ↑ wikipedia: Field line
* ↑ Curve sketching in wikipedia
* ↑ slides from MALLA REDDY ENGINEERING COLLEGE
* ↑ fractalforums.org: help-with-ideas-for-fractal-art
* ↑ Predicting the shape of distance functions in curve tracing: Evidence for a zoom lens operator by PETER A. McCORMICK and PIERRE JOLICOEUR
* ↑ math.stackexchange question: shortest-distance-between-a-point-and-a-numerical-2d-curve
* ↑ stackoverflow question: line-tracking-with-matlab
* ↑ mathwords: simple_closed_curve
* ↑ INSA : active-contour-models
* ↑ Tracing Boundaries in 2D Images by V. Kovalevsky
* ↑ Calculating contour curves for 2D scalar fields in Julia
* ↑ Smooth Contours from d3js.org
* ↑ d3-contour from d3js.org
* ↑ matrixlab - line-detection
* ↑ Sobel Edge Detector by R. Fisher, S. Perkins, A. Walker and E. Wolfart.
* ↑ NVIDIA Forums, CUDA GPU Computing discussion by kr1_karin
* ↑ Sobel Edge by RoboRealm
* ↑ nvidia forum: Sobel Filter Don't understand a little thing in the SDK example
* ↑ Sobel Edge Detector by R. Fisher, S. Perkins, A. Walker and E. Wolfart.
* ↑ ImageMagick doc
* ↑ Edge operator from ImageMagick docs
* ↑ ImageMagick doc: morphology / EdgeIn
* ↑ dilation at HIPR2 by Robert Fisher, Simon Perkins, Ashley Walker, Erik Wolfart
* ↑ ImageMagick doc: morphology, dilate
* ↑ Fred's ImageMagick Scripts
* ↑ Weisstein, Eric W. "Stereographic Projection." From MathWorld--A Wolfram Web Resource. https://mathworld.wolfram.com/StereographicProjection.html
* ↑ notes from University of California at Riverside
* ↑ paul bourke: transformation projection
* ↑ paul bourke: transformation projection
* c programs from GraphicsGems book
* GraphicsGems - Code for the "Graphics Gems" book series
* Code developed for articles in the "Journal of Graphics Tools"
* https://www.geeksforgeeks.org/fundamentals-of-algorithms/#GeometricAlgorithms
* VTK Book
* Algorithms by Jeff Erickson
* immersive linear algebra by J. Ström, K. Åström, and T. Akenine-Möller