# Theory

* imagemagick : color-management
* users-guide-to-high-bit-depth-gimp by Ella Stone

## Introduction

* Your Friendly Guide to Colors in Data Visualisation by Lisa Charlotte Rost
* Playing with Gradient by rockraikar
* gimp concepts : gradients
* Ultra Fractal Gradient Hints by Janet Parke
* Image gradient at wikipedia
* Color gradient at wikipedia
* w3schools : css3 gradients
* gradients by Alan Gibson
* domain coloring
** DomainColoring by Emilia Petrisor
** dynamicmath : domain-coloring
** dctools by Juan Carlos Ponce Campuzano
** domain_coloring ( gnuplot)

## Types of color gradient

Color gradients can be named by :
* dimension
* color bit depth
* color model: hsv
* number of segments of gradient
* function used to create gradient
* special input values ( NAN, no data, high or low out-of-range values)
* Number of colors
* number type, range and precision
* perceptual uniformity
* monotonic
** Monotonic in hue
** Monotonic in saturation
** Monotonic in luminance

### Dimension
#### 1D

Here color of pixel is proportional to 1D variable. For example in 2D space ( complex plane where point z = x+y*i) :
* position with respect to x-axis of Cartesian coordinate system : x
* distance to origin : r=abs(z)
* potential
* complex angle angle=arg(z)
** cyclic-colormap-without-visual-distortions-for-use-in-phase-angle-plots
** rainbows by Charlie Loyd
* percepually uniform
An example of a function to return a color that is linearly between two given colors:
* 1D gradient with color proportional to x
* 1D gradient with color proportional to radius
* 1D gradient with color proportional to angle
* Hue circle for complex function plots
Code
* continous gradient
** 1D RGB color
** 1D gray color

#### 2D

Because color can be treated as more than 1D value it is used to represent more than one ( real or 1D) variable. For example :
* Robert Munafo uses 2 values from HSV model of color
* John J. G. Savard uses own function
* Domain coloring is a technique for visualizing functions of a complex variable
* matrixlab : rgb-images in MAtlab
* animated-contours from d3js.org
* Multiwave coloring for Mandelbrot by Paul Derbyshire
* 2D colormap by Gerrit:
** The angle of the final iterate is most naturally mapped to hue, which has the matching topology of a circle
** the number of iterations is mapped to saturation and value (colorspace is 3D, at least for most humans).

#### 3D

* Hans Lundmark page

### Color model

Color models description
The quality of 16-bit linear RGB is about equal to 12-bit sRGB (= nonlinear RGB), beacause linear color results in disproportionately more samples near white and fewer near black.
* RGB and RGBA image
Types :
* RGB is for the display
* CMYK is for printing
* other ( HSV, HSL, ...) are for choosing color, processing
** HSLuv
** YUV (Luminance and chrominance) it is a way of breaking the brightness and colours in the image down into numbers
** HWB

#### RGB

* RGB = "linear" color space
* sRGB
** sRGB = standard RGB. SRGBColorSpace (“srgb”) refers to the color space defined by the Rec. 709 primaries, D65 white point, and nonlinear sRGB transfer functions.
** The sRGB Linear space is the same as sRGB except that the transfer function is linear-light (there is no gamma-encoding

#### HSV

In Basic :

### Interpolating function

* One can use any function in each segment of gradient
* Output of function is scaled to range of color component
* interpolation between colors can be:
** lerp = Linear intERPolation, in sRGB color space
** nonlinear (quadratic, ...) classic in Photoshop
** linear color space interpolation: convert keys from sRGB to float Linear, lerp between them, convert back into fixed point sRGB
** perceptual color space interpolation ( OKlab): convert keys from sRGB to float Linear, then into Oklab, lerp between them, convert back into float Linear, then back into fixed point sRGB.
the tail of gradient Oklab evaluation function code by Aras Pranckevičius:
In CSS interpolation between two color values takes place by executing the following steps:
* (if required) converting them to a given color space which will be referred to as the interpolation color space below
* (if required) re-inserting carried-forward values in the converted colors
* (if required) fixing up the hues, depending on the selected <hue-interpolation-method>
* premultiplication of the color components
* linearly interpolating each component of the computed value of the color separately
* undoing premultiplication
Example 36. To interpolate:
* in the Lab color space
* the two colors: rgb(76% 62% 03%/0.4) and color(display-p3 0.84 0.19 0.72/0.6)
* they are first converted to lab: lab(66.927% 4.873 68.622/0.4) lab(53.503% 82.672 -33.901/0.6)
* premultiplication: then the L, a and b coordinates are premultiplied before interpolation: [26.771% 1.949 27.449] and [32.102% 49.603 -20.341].
* Interpolation: The midpoint of linearly interpolating these would be [29.4365% 25.776 3.554] which,
* premultiplication is undone: with an alpha value of 0.5, which gives lab(58.873% 51.552 7.108) / 0.5)

### Number of colors

Number of color is determined by color depth : from 2 colors to 16 mln of colors.
* 6-bit RGB uniform palette with black borders
* Image:6-bit RGB uniform palette
* 256 VGA color gradient
See also
* 16-bit (rgb-565) color name definitions in c by Nic Newdigate
* About RGB565 and how to convert into it November 14, 2018 by Thomas Barth

### Repetition and offset

Direct repetition :
Color is proportional to position <0;1> of color in color gradient. if position > 1 then we have repetition of colors. it maybe useful
Mirror repetition :
"colorCycleMirror - This will reflect the colour gradient so that it cycles smoothly "
Offset :

# How to use color gradients in computer programs

First find what format of color you need in your program.
Ways of making gradient :
* gradient functions
* gradient files
** A colour look-up table (CLUT) ) color map, palette
** palette
** mixed

## CLUT image

One can use CLUT image a a source of the gradient

## CLUT Array
### perl

Conversions :
* between FractInt and Fractal eXtreme palettes
lists:
* wikipedia : List_of_color_palettes

## Gradient functions

Name:
* coloring function
types
* continous
** linear
** non linear
* discrete
Examples :
* in JS using mandel.js by Christopher Williams
* Javascript using jQuery
* C++ function by Richel Bilderbeek
* Multiwave coloring for Mandelbrot
* histogram colouring
* Dave Green's `cubehelix' colour scheme
* css gradients
* stackoverflow question: how-to-create-colour-gradient-in-python
* complex_plot from Arb library and description

### HSV gradient

* explanation by Robert P. Munafo
* Basic code and images by Jean Debord
* c programs by Curtis T McMullen

### Linear RGB gradient with 6 segments

* rainbow gradient
* 2D RGB profile
* 2D HSV profile
* 3D RGB profile
Rainbow gradient
* in scientific computing
** SOMEWHERE OVER THE RAINBOW. How to Make Effective Use of Colors in Meteorological Visualizations by Reto Stauffer, Georg J. Mayr, Markus Dabernig, and Achim Zeileis
Here gradient consists from 6 segments. In each segment only one RGB component of color is changed using linear function.

#### C version

Input of function are 2 variables :
* position of color in gradient, (a normalized float between 0.0 and 1.0 )
* color as an array of RGB components ( integer without sign from 0 to 255 )
This function does not use direct outoput ( void) but changes input variables color. One can use it this way:

#### Cpp version
### Sine based gradient

* Cosine based gradient generation by Karsten Schmidt
* paletes by inigo quilez
"The idea is to change the color based on a sine wave. This gives a nice smooth gradient effect (although it’s not linear, which is not a requirement anyway). By changing the frequency of the RGB components (we could theoretically work with other color spaces such as HSV) we can get various gradients. Also, we can also play with the phase of each color component, creating a “shifting” effect. The basic implementation of such a gradient can be implemented like so:"
"Where:
* the Freq* are the frequencies of the respective RGB colors
* Phase* are the phase shift values.
Note that all calculations are done with floating point numbers (ranging from 0.0 to 1.0), converting to a WPF Color structure (in this case) at the very end. This is simply convenient, as we’re working with trigonometric functions, which like floating point numbers rather than integers. The result is normalized to the range 0 to 1, as the sine function produces results from –1 to 1, so we add one to get a range of 0 to 2 and finally divide by 2 to get to the desired range."

### cubehelix

* Cubehelix gradient
* 2D RGB profile
* 3D RGB profile
cubehelix gradient
* Gnuplot palette cubehelix

## Gradient files

* Color Look-Up Table (CLUT)

### File types for color gradient

There are special file types for color gradients:
* The GIMP uses the files with .ggr extension
* Fractint uses .map files
* UltraFractal uses .ugr - These files can contain multiple gradients
* ual - old Ultra Fractal gradient file
* rgb, pal, gpf - gnuplot files
* The Matplotlib colormap is a lookup table
* csv files
* maps in WHIP format ( Autodesk) by Paul Bourke
* Gnofract4D saves gradients only inside the graphic file, not as separate file.
* MatLab
* Python
* R
* GMT
* QGIS
* Ncview
* Ferret
* Plotly
* Paraview
* VisIt
* Mathematica
* Surfer
* d3
* SKUA-GOCAD
* Petrel
* Fledermaus
* Qimera
* ImageJ
* Fiji
* Inkscape
* XML
* text
* SASS style sheet
* LESS - http://lesscss.org style sheet
* CSS - Cascading Style Sheet

#### csv files

a small table containing 33 values ( stored in a csv file) by Kenneth Moreland

#### CSS syntax

CSS syntax
The default color space for mixing (and gradients) in CSS is oklab

##### Linear gradients
###### Non-repeating

Color gradients
| Css code | description |
| linear-gradient(in lab to right, white, #01E) | CIE Lab gradient, which avoids the too-dark midpoint but has a significant purple cast; |
| linear-gradient(in srgb to right, white, #01E) | gamma-encoded sRGB gradient, is too dark at the midpoint, is a little desaturated, and has a slight purplish cast |
| linear-gradient(in Oklab to right, white, #01E) | Oklab gradient, giving a more perceptually uniform result with no purple cast at all |
| linear-gradient(to right, #a8c0ff, #3f2b96); | Ocean View |
| linear-gradient(in Oklab to right, #44C, #795) | Oklab gradient, perceptually uniform result with no purple cast at all |
| linear-gradient(in Oklab to right, black, #01E) | Oklab gradient, perceptually uniform result |
| linear-gradient(cyan, yellow); | |
| linear-gradient(to left, violet, indigo, blue, green, yellow, orange, red); | VIBGYOR rainbow |
| linear-gradient(90deg, rgba(2,0,36,1) 0%, rgba(9,9,121,1) 35%, rgba(0,212,255,1) 100%); | |
black-to-white-gradient-in-each-space
* description
* Oklab, perceptually uniform result
* oklch
* lab
* lch
* srgb
* srgb-linear
* hsl
* hwb
* xyz
* xyz-d50
* xyz-d65

###### Repeating

* Code
* .gradient5 {
* background-image: repeating-linear-gradient(cyan 0%, yellow 50%);
* .gradient6 {
* background-image: repeating-linear-gradient(to right, blue 0%, magenta 10%);
* .gradient7 {
* background-image: repeating-linear-gradient(60deg, cyan 0%, teal 23%, lime 31%);

##### conic

Conic gradient in CSS
/* Hue wheel */ background: conic-gradient(red, yellow, lime, aqua, blue, magenta, red); border-radius: 50%
| Css code | description | Preview image |
| conic-gradient(red, yellow, lime, aqua, blue, magenta, red); border-radius: 50% | color wheel | |

#### Fractint map files

The default filetype extension for color-map files is ".MAP". These are ASCII text files. Consist of a series of RGB triplet values (one triplet per line, encoded as the red, green, and blue [RGB] components of the color). Color map ( or palette) is used as a colour look-up table Default color map is in the Default.map file :

#### Gimp/Inscape gpl files

Used by : Gimp, Inscape, Aseprite, Drawpile, Krita, MyPaint
Syntax:
* ASCII files ( text files)
* Comments must start with a #. In non-empty lines that don't, the first three tokens are parsed as numbers
* There is no alpha support
* GIMP Palette - it must be the first line of the file
* Name: <name> - sets the name of the color palette.
* Columns: <number> - is just an indication for displaying the palette inside GIMP.
* # <comment> - comments must start with a #. All comments are ignored by GIMP.
* 0 0 0 Black - RGB values for the color followed by the color name
Source code of loader function
GIMP palettes are stored using a special file format, in files with the extension .gpl.
Directory:
* ~/.config/GIMP/x.y/palettes/ directory (where x.y is the GIMP version number)
* ~/.config/inkscape/palettes/

#### Gimp ggr files

"The gradients that are supplied with GIMP are stored in a system gradients folder. By default, gradients that you create are stored in a folder called gradients in your personal GIMP directory. Any gradient files (ending with the extension .ggr) found in one of these folders, will automatically be loaded when you start GIMP" ( from gimp doc ) Default gradients are in /usr/share/gimp/2.0/gradients directory ( check it in a window : Edit/preferences/directories)
Git repo
* https://git.gnome.org/browse/gimp/tree/data/gradients
Gimp gradients can be created thru :
* GUI
* manually in text editor ( use predefined gradients as a base)
* in own programs
Gimp gradient file format is described in:
* GIMP Application Reference Manual
* source files :
** app/gradient.c and app/gradient_header.h for GIMP 1.3 version.
** gimp-2.6.0/app/core/gimpgradient.c
Gimp Gradient Segment format :
In GimpConfig style format:
First line says it is a gimp gradient file.
Second line is a gradient's name.
Third line tells the number of segments in the gradient.
Each line following defines the property of each segment in following order :"
* position of left stoppoint
* position of middle point
* position of right stoppoint
* R for left stoppoint
* G for left stoppoint
* B for left stoppoint
* A for left stoppoint
* R for right stoppoint
* G for right stoppoint
* B for right stoppoint
* A for right stoppoint
* Blending function constant
* coloring type constant
There are only two constants at the end of each line:
* the blending function constant of the segment (apparently 0=Linear, 1=Curved, 2=Sinusoidal, 3=Spherical (increasing), 4=Spherical (decreasing))
* the coloring type constant of the segment (probably 0=RGB, 1=HSV (counter-clockwise hue), 2=HSV (clockwise hue)

#### json

* json object

### links

* cpp code by Patrick Ross
* Reading gimp ggr files in python by Ned Batchelder
* Python Pil library functions for reading GIMP gradient files ( in file GimpGradientFile.py)
* perl scripts to convert gimp-1.2.x palettes and gradients into a 1.3 form by Jeff Trefftzs
* Gimp Python plugin: make-gradient.py by Giuseppe Conte
* gimp gradient files - lisp code from Polypen by Yannick Gingras
* Perl functions from GIMP pdb - gradient.pdb
* stackoverflow : javascript-color-gradient
* c pseudocode and js code by Christopher Williams
* Lode's Computer Graphics Tutorial : Light and Color
* bruce lindbloom : color equations

### Collections of gradients / colormaps

* gradcentral
* Cpt-city
* gimp gradients (ggr files) are in directory : /usr/share/gimp/2.0/gradients/
* The COLOURlovers site hosts a million 5-colour palettes in several formats
* thi.ng
* SciVisColor
* Fabio Crameri: scientific colourmaps in provided in all major formats

# programs

* Color tools for design systems
* gnuplot
* mdigi tools color: Color tools for the web listed alphabetically
* The CCC-Tool is a general tool for the creation, analyzing and testing of colormaps with the effort to minimize the needed interaction components.
* image magic
* OpenCV library
* python
** colorAide A library to aid in using colors
** coloria Tools for color research
** colour-science: Colour is an open-source Python package providing a comprehensive number of algorithms and datasets for colour science.
** colour = color representations manipulation library (RGB, HSL, web, ...) by Valentin Lab
** njsmith: colorspacious: A powerful, accurate, and easy-to-use Python library for doing colorspace conversions
** Colour is an open-source Python package providing a comprehensive number of algorithms and datasets for colour science. It is freely available under the New BSD License terms. Colour is an affiliated project of NumFOCUS, a 501(c)(3) nonprofit in the United States.
** matplotlib
*** matplotlib: viscm A tool for visualizing and designing colormaps using colorspacious and matplotlib
* math3d : sphere colormap
* VIVID GRADIENT GENERATOR TOOL by learn ui design
* paletton- color scheme designer and generator
* Image Magic
** snibgo's ImageMagick pages: Gradients Cookbook
** snibgo's ImageMagick pages: Gradient contours

## color convert

* qConv.com - The quick converter and color manager. The powerful color database for designers and agencies.
* hextoral color converter
* colormine color-converter
** java lib
** ColorMine for POV-Ray byMichael Horvath
** C# by hvaldi
* ColorSpace: C++ library for converting between color spaces and comparing colors by Nicolae Berendea
** farver: High Performance Colourspace Manipulation in R. Src code in c++. It provides an interface to a modified version of the ColorSpace C++ library.

## color gradient convert

* ggr2glsl is a simple utility to convert GIMP gradient files to GLSL functions.
* gradient-converter-apophysis-to-kalles-fraktaler

# tests

Test your :
* monitor ( gamut)
* graphic card
* printer
* own

## Test your color abilities

* The X-Rite Color Challenge and Hue Test
* The FM100 Hue Test is an easy-to-administer test and a highly effective method for evaluating an individual's ability to discern color.

# How to choose color gradient ?

* How to Choose Colours Procedurally (Algorithms) 29 Jul, 2012 by Herman Tulleken
* perceptually-smooth-multi-color-linear-gradients by Matt DesLauriers Jan 25, 2021
* Nonlinear Color Scales for Interactive Exploration by Young Hyun
* gencolormap
* Color Maps for Scientific Visualization by Kenneth Moreland
** Color Map Advice for Scientific Visualization
** git
* In Search of a Perfect Colormap by Peter Karpov
* Good Colour Maps: How to Design Them by Peter Kovesi
* Rainbow Color Map Critiques: An Overview and Annotated Bibliography By Steve Eddins, MathWorks
* scivis tutorials
* Matteo Niccoli
* bids: Colormap recommendation

## How to visualize/test/evaluate/compare colormaps?

In python to visualize matplotlib built-in colormaps:
To visualize one of viscm colormaps:
In gnuplot use test command:
Results: 2D profiles of each color channel
One can also make curve through RGB colorspace:
* curve through RGB colorspace
* gray
* cubehelix
* HSV rainbow
* diverging
R code
Tips:
* A good discrete palette has distinct colors
* A good continuous colormap does not show boundaries between colors
See also
* How to evaluate and compare color maps by SEG
* pals: R programming language package to evaluate colormaps
* colorcet test image
* matplotlib color map manipultions
* Kenneth Moreland: color-advice
* David Johnstone: lch-lab-colour-gradient-picker
* ccc tool
* scivis color : color moves app
* color brewer colomaps

## How to make perceptually uniform gradient?

* How to generate a perceptually uniform gradient with CAM16UCS colour model?
* stackoverflow qestion: more-perceptually-uniform-colormaps
* CMasher: Scientific, perceptually uniform colormaps
* colorcet : Perceptually Uniform Colour Maps by Peter Kovesi
* matplotlib cmocean : Beautiful colormaps for oceanography. Most of the colormaps started from matplotlib colormaps, but have now been adjusted using the viscm tool to be perceptually uniform.

## How to make colormap with maximum distinguishable colours?

* stackoverflow question: colormap-with-maximum-distinguishable-colours
* Colorgorical To generate a palette with n colors,

## How to use special values in colormap?

* stackoverflow question: how-can-i-plot-nan-values-as-a-special-color-with-imshow

# How to Calculate the average color of an image ?

Averaging RGB should be correct assuming you do it in linear RGB. If your images are in sRGB, you can remove the gamma correction by doing something like the following for each of the R, G, and B components:
You can then average together all of the red values in the image, all of the green values in the image, and all of the blue values in the image after they've been run through the above conversion. You can then do the opposite conversion to get back to sRGB:
Note that alpha makes things slightly more complicated. If you're using premultiplied alpha, you can simply apply the above calculations for the average. If you're using straight alpha, you'll want to multiply each of the R, G, and B components by the alpha before doing the averaging.

# How to render light spectrum?

* Colour Rendering of Spectra by John Walker 25th April 1996
* Lightness approximations by Peter Karpov

# How to read(pick) color from the image ?

* Pick Color From Image by ginifab
* pick-a-color-from-an-image-using-canvas-and-javascript by nakome
* developer mozilla: getting_the_pixel_data_for_a_context
* How to get the pixel color from a canvas on click or mouse event with Javascript from ourcodeworld

# How to read color gradient from image ?

* online
** color.adobe tool
** color-loom/ Colorloom is a tool developed by the Sculpting Vis Collaborative and inspired to mimic palette creation in the arts. The tool extracts a selection of hues from images and enables users to create continuous colormaps by dragging these extracted hues into a desired order, all within the same interface. These colormaps can be exported in a variety of formats for use in major visualization software.

# How to extract color palette from image ?

* Colores.py—extract color palettes from your favorite images
* Color Scheme Extraction
* using Image Magic
* using Gimp
* "There is this small tool in fractalshades that interactively grabs a colormap from a line you draw on an image, the editor looks like the attached picture. Not perfect, but I found it useful (in the 'tools' section). The cmap can then be used in the program or exported for later use (for the time being, exports only to a txt format specific to this program.)" Geoffroy Billotey (GBillotey)

# How to extract ICC profile from the image file ?

Using Image Magic:
How to view ICC profile ?
Example output:

# How to find lighter and darker colors based on any initial color ?

* 0to255 a color tool by Shaun Chapman uses the lightness (L) scale from HSL
* stackoverflow : formula-to-determine-brightness-of-rgb-color
* stackoverflow : programmatically-lighten-or-darken-a-hex-color-or-rgb-and-blend-colors
* learnwebgl: model_color by C. Wayne Brown: To change a color (r,g,b) to make it lighter, move it closer to (1,1,1). To change a color (r,g,b) to make it darker, move it closer to (0,0,0).

# How to remove gradient banding ?

* dither
** no more banding by Jeff Broderick
* graphicdesign.stackexchange question: how-do-you-avoid-bands-of-prominent-color-in-gradients

# How to generate and refine palettes of optimally distinct colors

* avoid-equidistant-hsv-colors
* choose colors for data scientists
* rich colors

# How to make quality images?

* How to make quality 2D static images ?

# Gradient contours

* description by Alan Gibson.

# Examples of beautiful gradients

* Mandelbrot 109 - Mandelflake by olbaid-st
* a slight motion in the colour gradient
** Into The Purple - Mandelbrot Fractal Zoom by Maths Town

# See also

* Color_calibration
* Color correction
* Color terms
* Swatch Book = color palette in digital terminology, collection of material fragments in different colors, Paper color swatch book, Wool swatch book
** swatche books
* Image noise
* Commons Category:Color in computer graphics
* stackoverflow questions tagged gradient
* github topics
* scratchapixel: simulating-sky
* Color by Bruce MacEvoy
* The X-Rite Color Challenge and Hue Test
* colour lovers: Color/s, Pattern/s, Palette/s, Lover/s or stats
* gamma correction
** Gamma_correctionin wikipedia
** WHAT EVERY CODER SHOULD KNOW ABOUT GAMMA by JOHN NOVAK
** Power law transform
* coloring algorithms
** by Christopher Williams
** by Junpei Sekino
* perceptually uniform color space
** OK LAB by Björn Ottosson
** kenneth moreland github
* bruce lindbloom
* gradient maps by bjango: Gradient maps in Photoshop use brightness to assign corresponding colours taken from a gradient of your choice

# References

* ↑ dsp.stackexchange question: why-do-we-use-the-hsv-colour-space-so-often-in-vision-and-image-processing
* ↑ stackoverflow question:how-can-i-plot-nan-values-as-a-special-color-with-imshow
* ↑ matplotlib: Colormap set_bad
* ↑ Completely Painless Programmer's Guide to XYZ, RGB, ICC, xyY, and TRCs by Elle Stone
* ↑ fractalforums.org: smooth-1d-coloring
* ↑ observablehq mjbo: perceptually-uniform-color-models
* ↑ R2.1/2.C(1/2) by Robert Munafo
* ↑ Color by Robert Munafo
* ↑ Mandelbrot and Julia sets with PANORAMIC and FreeBASIC By jdebord
* ↑ The Mandelbrot Function by John J. G. Savard
* ↑ The Mandelbrot Function 2 by John J. G. Savard
* ↑ fractalforums.org/: 2d-coloring
* ↑ Visualizing complex analytic functions using domain coloring by Hans Lundmark
* ↑ w3docs color-hwb
* ↑ New gradient interpolation options ( Last updated on May 24, 2023) from Adobe
* ↑ Optimizing Oklab gradients by Aras Pranckevičius.
* ↑ drafts csswg org: css-color-4
* ↑ drafts csswg.org: css-color-4
* ↑ The Fractal Explorer Pixel Bender filters by Tom Beddard
* ↑ What's Delphi TColor format? at ACASystems
* ↑ Delhi TColor at efg2.com
* ↑ wikipedia :Colour_look-up_table
* ↑ fractalforums : creating-a-good-palette-using-bezier-interpolation
* ↑ FracTest : palettes
* ↑ stefanbion : fraktal-generator and colormapping/
* ↑ nvidia gpu gems2 : using-lookup-tables-accelerate-color
* ↑ Paul Tol's notes
* ↑ gmic : color_presets
* ↑ Fractal Forums > Fractal Software > Fractal Programs > Windows Fractal Software > Fractal eXtreme > Converting between FractInt and Fractal eXtreme palettes
* ↑ stackoverflow question : smooth-spectrum-for-mandelbrot-set-rendering
* ↑ on-rainbows by Charlie Loyd
* ↑ Stefan Bion : color mapping
* ↑ stackoverflow question : which-color-gradient-is-used-to-color-mandelbrot-in-wikipedia
* ↑ Making annoying rainbows in javascript A tutorial by jim bumgardner
* ↑ mandel.js by Christopher Williams
* ↑ Custom Palettes by Christopher Williams
* ↑ Gradient jQuery plugin Posted by David Wees
* ↑ C++ function by Richel Bilderbeek
* ↑ Multiwave coloring for Mandelbrot
* ↑ histogram colouring is really streching (not true histogram)
* ↑ Color by Robert Munafo
* ↑ Mandelbrot and Julia sets with PANORAMIC and FreeBASIC By Jean Debord
* ↑ c programs by Curtis T McMullen
* ↑ color-gradient-generator by Pavel
* ↑ Color gradient file formats explained
* ↑ 29 Colour Map Formats... by Peter Kovesi
* ↑ GIMP add-ons: types, installation, management by Alexandre Prokoudine
* ↑ Fractint Palette Maps and map files
* ↑ matplotlib: colormap-manipulation
* ↑ matplotlib colormaps
* ↑ wikipedia: Lookup table
* ↑ gnofract4d manual
* ↑ kenneth moreland: color-maps
* ↑ w3.org docs : gradient
* ↑ stackoverflow question : how-is-a-css-gradient-path-calculated ?
* ↑ New functions, gradients, and hues in CSS colors (Level 4) by Smith 3 May 2023
* ↑ developer chrome articles: css-color-mix
* ↑ w:Colour look-up table
* ↑ About A collection of RGB color palettes for GIMP and Inkscape (but also Aseprite, Drawpile, Krita and MyPaint) by Dezmerean Robert
* ↑ stackoverflow question: gimp-palette-file-gpl-format-syntax
* ↑ Add custom color palettes to GIMP and Inkscape by Dezmerean Robert
* ↑ Source code of gimp load palette function
* ↑ gimp-gradient-editor-dialog doc
* ↑ GimpGradient doc at GIMP Application Reference Manual
* ↑ [Gimp-developer] Format of GIMP gradient files
* ↑ [Gimp-developer] Format of GIMP gradient files
* ↑ [Gimp-developer] Format of GIMP gradient files
* ↑ gpr format description by Vinay S Raikar
* ↑ Emulating ggr/GIMP gradient in JavaFx
* ↑ CCC-Tool
* ↑ imagemagick : gradient
* ↑ Dave Green's 'cubehelix' colour scheme
* ↑ Diverging Color Maps for Scientific Visualization - Kenneth Moreland
* ↑ computergraphics SE question: calculate-the-average-color-of-an-image
* ↑ extract color palletes from your favorite images by John Mangual
* ↑ algorithmia : create-a-custom-color-scheme-from-your-favorite-website/
* ↑ ImageMagick v6 Examples -- Color Quantization and Dithering
* ↑ Tool to extract palette / color table from image
* ↑ fractalforums.org : beautiful-and-effective-coloring-of-fractals
* ↑ rawpedia: how to extract and examine ICC profiles ?
* ↑ gradint contours by Alan Gibson
* awesome-colour: A curated list of awesome colour science resources.
* stackoverflow questions tagged colormap
* github repo colour-science