The dufy Reference Manual

4.1.1 dufy/dufy.asd

Source

dufy.asd.

Parent Component

dufy (system).

ASDF Systems

• dufy.
• dufy/core.
• dufy/internal.
• dufy/munsell.
• dufy/hsluv.

---

4.1.2 dufy/src/package.lisp

Source

dufy.asd.

Parent Component

src (module).

Packages

dufy.

---

4.1.3 dufy/core/core/package.lisp

Source

dufy.asd.

Parent Component

core (module).

Packages

dufy/core.

---

4.1.4 dufy/core/core/cmf-data.lisp

Source

dufy.asd.

Parent Component

core (module).

Internals

• +cmf-table-cie1931+ (special variable).
• +cmf-table-cie1964+ (special variable).

---

4.1.5 dufy/core/core/spectrum.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• +obs-cie1931+ (special variable).
• +obs-cie1964+ (special variable).
• approximate-spectrum (function).
• bb-spectrum (function).
• flat-spectrum (function).
• gen-illum-d-spectrum (function).
• gen-spectrum (function).
• illuminant (structure).
• illuminant-no-spd-p (function).
• illuminant-observer (reader).
• (setf illuminant-observer) (writer).
• illuminant-spectrum (reader).
• (setf illuminant-spectrum) (writer).
• illuminant-x (reader).
• (setf illuminant-x) (writer).
• illuminant-xy (function).
• illuminant-z (reader).
• (setf illuminant-z) (writer).
• make-illuminant (compiler macro).
• make-illuminant (function).
• make-observer (function).
• no-spd-error (condition).
• observer (structure).
• observer-begin-wl (reader).
• (setf observer-begin-wl) (writer).
• observer-cmf (reader).
• (setf observer-cmf) (writer).
• observer-cmf-x (reader).
• (setf observer-cmf-x) (writer).
• observer-cmf-y (reader).
• (setf observer-cmf-y) (writer).
• observer-cmf-z (reader).
• (setf observer-cmf-z) (writer).
• observer-end-wl (reader).
• (setf observer-end-wl) (writer).
• optimal-spectrum-peak (function).
• optimal-spectrum-trough (function).
• print-object (method).

Internals

• %make-illuminant (function).
• %make-observer (function).
• %spectrum-to-xyz (function).
• +s0-table+ (special variable).
• +s1-table+ (special variable).
• +s2-table+ (special variable).
• calc-to-spectrum-matrix (function).
• cond-illuminant (reader method).
• (setf cond-illuminant) (writer method).
• copy-observer (function).
• empty-spectrum (function).
• illuminant-p (function).
• illuminant-to-spectrum-matrix (reader).
• (setf illuminant-to-spectrum-matrix) (writer).
• make-illum-d-spectrum-array (function).
• observer-cmf-table (reader).
• (setf observer-cmf-table) (writer).
• observer-p (function).
• spectrum-function (type).

---

4.1.6 dufy/core/core/illuminants-data.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• +illum-a+ (special variable).
• +illum-c+ (special variable).
• +illum-d50+ (special variable).
• +illum-d65+ (special variable).
• +illum-e+ (special variable).

Internals

+illum-c-table+ (special variable).

---

4.1.7 dufy/core/core/xyz.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• spectrum-to-xyz (function).
• xyy-to-xyz (function).
• xyz-to-spectrum (function).
• xyz-to-xyy (function).

---

4.1.8 dufy/core/core/rgb.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• +srgb+ (special variable).
• delinearize (function).
• dequantize (function).
• gen-delinearizer (function).
• gen-linearizer (function).
• hsl-to-lrgb (function).
• hsl-to-qrgb (function).
• hsl-to-rgb (function).
• hsl-to-rgbpack (function).
• hsl-to-xyz (function).
• hsv-to-lrgb (function).
• hsv-to-qrgb (function).
• hsv-to-rgb (function).
• hsv-to-rgbpack (function).
• hsv-to-xyz (function).
• linearize (function).
• lrgb-out-of-gamut-p (function).
• lrgb-to-hsl (function).
• lrgb-to-hsv (function).
• lrgb-to-qrgb (function).
• lrgb-to-rgb (function).
• lrgb-to-rgbpack (function).
• lrgb-to-xyz (function).
• make-rgbspace (function).
• qrgb-out-of-gamut-p (function).
• qrgb-to-hsl (function).
• qrgb-to-hsv (function).
• qrgb-to-lrgb (function).
• qrgb-to-rgb (function).
• qrgb-to-rgbpack (function).
• qrgb-to-xyz (function).
• quantize (function).
• rgb-out-of-gamut-p (function).
• rgb-to-hsl (function).
• rgb-to-hsv (function).
• rgb-to-lrgb (function).
• rgb-to-qrgb (function).
• rgb-to-rgbpack (function).
• rgb-to-xyz (function).
• rgbpack-to-hsl (function).
• rgbpack-to-hsv (function).
• rgbpack-to-lrgb (function).
• rgbpack-to-qrgb (function).
• rgbpack-to-rgb (function).
• rgbpack-to-xyz (function).
• rgbspace (structure).
• rgbspace-bit-per-channel (reader).
• (setf rgbspace-bit-per-channel) (writer).
• rgbspace-delinearizer (reader).
• (setf rgbspace-delinearizer) (writer).
• rgbspace-from-xyz-matrix (reader).
• (setf rgbspace-from-xyz-matrix) (writer).
• rgbspace-illuminant (reader).
• (setf rgbspace-illuminant) (writer).
• rgbspace-linearizer (reader).
• (setf rgbspace-linearizer) (writer).
• rgbspace-lmax (reader).
• (setf rgbspace-lmax) (writer).
• rgbspace-lmin (reader).
• (setf rgbspace-lmin) (writer).
• rgbspace-max (reader).
• (setf rgbspace-max) (writer).
• rgbspace-min (reader).
• (setf rgbspace-min) (writer).
• rgbspace-normal (reader).
• (setf rgbspace-normal) (writer).
• rgbspace-qmax (reader).
• (setf rgbspace-qmax) (writer).
• rgbspace-to-xyz-matrix (reader).
• (setf rgbspace-to-xyz-matrix) (writer).
• rgbspace-xb (reader).
• (setf rgbspace-xb) (writer).
• rgbspace-xg (reader).
• (setf rgbspace-xg) (writer).
• rgbspace-xr (reader).
• (setf rgbspace-xr) (writer).
• rgbspace-yb (reader).
• (setf rgbspace-yb) (writer).
• rgbspace-yg (reader).
• (setf rgbspace-yg) (writer).
• rgbspace-yr (reader).
• (setf rgbspace-yr) (writer).
• xyz-to-hsl (function).
• xyz-to-hsv (function).
• xyz-to-lrgb (function).
• xyz-to-qrgb (function).
• xyz-to-rgb (function).
• xyz-to-rgbpack (function).

Internals

• %make-rgbspace (function).
• delinearize-srgb (function).
• linearize-srgb (function).
• qrgba-to-rgba (function).
• qrgba-to-rgbapack (function).
• rgba-to-qrgba (function).
• rgba-to-rgbapack (function).
• rgbapack-to-qrgba (function).
• rgbapack-to-rgba (function).
• rgbspace-/length (reader).
• (setf rgbspace-/length) (writer).
• rgbspace-length (reader).
• (setf rgbspace-length) (writer).
• rgbspace-length/qmax-float (reader).
• (setf rgbspace-length/qmax-float) (writer).
• rgbspace-p (function).
• rgbspace-qmax-float (reader).
• (setf rgbspace-qmax-float) (writer).
• rgbspace-qmax-float/length (reader).
• (setf rgbspace-qmax-float/length) (writer).

---

4.1.9 dufy/core/core/lab-and-luv.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• lab-to-lchab (function).
• lab-to-xyz (function).
• lchab-to-lab (function).
• lchab-to-xyz (function).
• lchuv-to-luv (function).
• lchuv-to-xyz (function).
• lstar-to-y (function).
• luv-to-lchuv (function).
• luv-to-xyz (function).
• xyz-to-lab (function).
• xyz-to-lchab (function).
• xyz-to-lchuv (function).
• xyz-to-luv (function).

Internals

• calc-uvprime (function).
• calc-uvprime-from-xyz (function).
• function-f (function).
• lab-to-xyy (function).
• lchab-to-xyy (function).
• xyy-to-lab (function).
• xyy-to-lchab (function).
• y-to-lstar (function).

---

4.1.10 dufy/core/core/cat.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• +bradford+ (special variable).
• +cat02+ (special variable).
• +cat97s-revised+ (special variable).
• +cmccat2000+ (special variable).
• +cmccat97+ (special variable).
• +von-kries+ (special variable).
• +xyz-scaling+ (special variable).
• cat (structure).
• cat-inv-matrix (reader).
• (setf cat-inv-matrix) (writer).
• cat-matrix (reader).
• (setf cat-matrix) (writer).
• copy-rgbspace (function).
• define-cat-function (macro).
• gen-cat-function (function).
• gen-rgbspace-changer (function).
• lms-to-xyz (function).
• make-cat (function).
• xyz-to-lms (function).

Internals

• %make-cat (function).
• calc-cat-matrix (function).
• calc-cat-matrix-for-lrgb (function).
• cat-p (function).
• copy-cat (function).

---

4.1.11 dufy/core/core/builtin-rgbspaces.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• +adobe+ (special variable).
• +adobe-16+ (special variable).
• +bg-srgb-10+ (special variable).
• +bg-srgb-12+ (special variable).
• +bg-srgb-16+ (special variable).
• +cie-rgb+ (special variable).
• +ntsc1953+ (special variable).
• +pal/secam+ (special variable).
• +prophoto+ (special variable).
• +prophoto-12+ (special variable).
• +prophoto-16+ (special variable).
• +scrgb-16+ (special variable).
• +scrgb-nl+ (special variable).
• +wide-gamut+ (special variable).

Internals

• delinearize-prophoto (function).
• delinearize-scrgb-nl (function).
• linearize-prophoto (function).
• linearize-scrgb-nl (function).

---

4.1.12 dufy/core/core/deltae.lisp

Source

dufy.asd.

Parent Component

core (module).

Public Interface

• lab-deltae00 (function).
• lab-deltae94 (function).
• lab-deltaeab (function).
• lab-deltaecmc (function).
• qrgb-deltae00 (function).
• qrgb-deltae94 (function).
• qrgb-deltaeab (function).
• qrgb-deltaecmc (function).
• xyz-deltae00 (function).
• xyz-deltae94 (function).
• xyz-deltaeab (function).
• xyz-deltaecmc (function).

---

4.1.13 dufy/internal/internal/package.lisp

Source

dufy.asd.

Parent Component

internal (module).

Packages

dufy/internal.

---

4.1.14 dufy/internal/internal/utilities.lisp

Source

dufy.asd.

Parent Component

internal (module).

Public Interface

• *dat-dir-path* (special variable).
• call-with-profiling (function).
• dotimes-unroll (macro).
• internal-real-time-after-gc (macro).
• nlet (macro).
• print-make-array (function).
• time-after-gc (macro).
• time-median (macro).
• tuple (type).
• with-ensuring-type (macro).
• with-profiling (macro).

Internals

• array-to-list (function).
• internal-real-time (macro).

---

4.1.15 dufy/internal/internal/arithmetic.lisp

Source

dufy.asd.

Parent Component

internal (module).

Public Interface

• +360/two-pi+ (constant).
• +two-pi/360+ (constant).
• circular-clamp (function).
• circular-lerp (function).
• circular-lerp-loose (function).
• circular-member (function).
• circular-nearer (function).
• degree-to-radian (function).
• nearly-equal (function).
• nearly-equal-values (macro).
• nearly<= (function).
• nearly= (function).
• pow (macro).
• radian-to-degree (function).
• square (function).
• two-pi (constant).

---

4.1.16 dufy/internal/internal/matrix.lisp

Source

dufy.asd.

Parent Component

internal (module).

Public Interface

• +empty-matrix+ (special variable).
• +identity-matrix+ (special variable).
• invert-matrix (function).
• matrix33 (type).
• multiply-mat-mat (function).
• multiply-mat-vec (function).
• multiply-matrices (function).

Internals

determinant (function).

---

4.1.17 dufy/internal/internal/colorspace.lisp

Source

dufy.asd.

Parent Component

internal (module).

Public Interface

• colorspace (structure).
• defconverter (macro).
• defconverters (macro).
• define-colorspace (macro).
• define-functional (macro).
• define-primary-converter (macro).
• (setf documentation) (method).
• documentation (method).
• extend-functional (macro).
• functional (structure).
• primary-converter (structure).

Internals

• %make-functional (function).
• %make-primary-converter (function).
• *colorspace-table* (special variable).
• *functional-table* (special variable).
• *primary-converter-table* (special variable).
• add-functional (function).
• add-primary-converter (function).
• circularize (function).
• collect-aux-arg-names (function).
• collect-aux-args (function).
• collect-key-arg-key-names (function).
• collect-key-arg-names (function).
• collect-key-args (function).
• colorspace-arg-types (reader).
• (setf colorspace-arg-types) (writer).
• colorspace-args (reader).
• (setf colorspace-args) (writer).
• colorspace-documentation (reader).
• (setf colorspace-documentation) (writer).
• colorspace-name (reader).
• (setf colorspace-name) (writer).
• colorspace-neighbors (reader).
• (setf colorspace-neighbors) (writer).
• colorspace-p (function).
• colorspace-return-types (reader).
• (setf colorspace-return-types) (writer).
• colorspace= (function).
• contains-allow-other-keys-p (function).
• copy-colorspace (function).
• copy-functional (function).
• copy-primary-converter (function).
• copy-queue (function).
• dequeue (function).
• duplicate-aux-and-key-p (function).
• enqueue (function).
• ensure-colorspace-name (function).
• expand-conversion-form (function).
• find-colorspace (function).
• find-converter-path (function).
• find-duplicates (function).
• functional-allow-other-keys (reader).
• (setf functional-allow-other-keys) (writer).
• functional-aux-args (reader).
• (setf functional-aux-args) (writer).
• functional-colorspace (reader).
• (setf functional-colorspace) (writer).
• functional-dimension (reader).
• (setf functional-dimension) (writer).
• functional-fname (reader).
• (setf functional-fname) (writer).
• functional-key-args (reader).
• (setf functional-key-args) (writer).
• functional-p (function).
• functional-term (reader).
• (setf functional-term) (writer).
• gen-args (function).
• gen-aux-args (function).
• gen-converter-name (function).
• gen-key-args (function).
• gen-local-key-args (function).
• gen-passed-args (function).
• get-allow-other-keys (function).
• get-arg-types (function).
• get-args (function).
• get-aux-args (function).
• get-aux-names (function).
• get-functional (function).
• get-key-arg-key-names (function).
• get-key-arg-names (function).
• get-key-args (function).
• get-neighbors (function).
• (setf get-neighbors) (function).
• get-primary-converter (function).
• get-primary-converter-name (function).
• get-return-types (function).
• key-arg= (function).
• lambda-list= (function).
• let-converter (macro).
• make-colorspace (function).
• make-functional (function).
• make-primary-converter (function).
• make-queue (function).
• primary-converter-allow-other-keys (reader).
• (setf primary-converter-allow-other-keys) (writer).
• primary-converter-aux-args (reader).
• (setf primary-converter-aux-args) (writer).
• primary-converter-from-colorspace (reader).
• (setf primary-converter-from-colorspace) (writer).
• primary-converter-key-args (reader).
• (setf primary-converter-key-args) (writer).
• primary-converter-name (reader).
• (setf primary-converter-name) (writer).
• primary-converter-p (function).
• primary-converter-to-colorspace (reader).
• (setf primary-converter-to-colorspace) (writer).
• print-hash-table (function).
• queue (structure).
• queue-list (reader).
• (setf queue-list) (writer).
• queue-p (function).
• queue-tail (reader).
• (setf queue-tail) (writer).

---

4.1.18 dufy/internal/internal/mb-line.lisp

Source

dufy.asd.

Parent Component

internal (module).

Public Interface

• make-mb-line (function).
• mb-line-distance-from-origin (function).
• mb-line-ray-intersect-distance (function).

Internals

• copy-mb-line (function).
• mb-line (structure).
• mb-line-intercept (reader).
• (setf mb-line-intercept) (writer).
• mb-line-p (function).
• mb-line-slope (reader).
• (setf mb-line-slope) (writer).

---

4.1.19 dufy/munsell/munsell/package.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Packages

dufy/munsell.

---

4.1.20 dufy/munsell/munsell/y-to-value-data.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Internals

+y-to-munsell-value-table+ (special variable).

---

4.1.21 dufy/munsell/munsell/renotation-data.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Internals

• +max-chroma-table+ (special variable).
• +max-chroma-table-dark+ (special variable).
• +mrd-table-ch+ (special variable).
• +mrd-table-ch-dark+ (special variable).
• +mrd-table-l+ (special variable).
• +mrd-table-l-dark+ (special variable).

---

4.1.22 dufy/munsell/munsell/inversed-renotation-data.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Internals

• +inversed-mrd-table-hc+ (special variable).
• +inversed-mrd-table-v+ (special variable).

---

4.1.23 dufy/munsell/munsell/fundamental.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Public Interface

• *most-positive-non-large-double-float* (special variable).
• invalid-mhvc-error (condition).
• lstar-to-munsell-value (function).
• max-chroma-in-mrd (function).
• mhvc-out-of-mrd-p (function).
• mhvc-to-munsell (function).
• munsell-out-of-mrd-p (function).
• munsell-to-mhvc (function).
• munsell-value-to-lstar (function).
• munsell-value-to-y (function).
• munsellspec-parse-error (condition).
• non-negative-non-large-double-float (type).
• y-to-munsell-value (function).

Internals

• *bit-length-of-most-positive-fixnum* (special variable).
• cond-chroma (reader method).
• (setf cond-chroma) (writer method).
• cond-spec (reader method).
• (setf cond-spec) (writer method).
• cond-value (reader method).
• (setf cond-value) (writer method).
• evaluate-error-of-y-to-munsell-value (function).
• mhvc-invalid-p (function).
• qrgb-to-munsell-value (function).

---

4.1.24 dufy/munsell/munsell/convert.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Public Interface

• mhvc-to-lchab-illum-c (function).
• mhvc-to-xyz (function).
• mhvc-to-xyz-illum-c (function).
• munsell-to-lchab-illum-c (function).
• munsell-to-xyz (function).
• munsell-to-xyz-illum-c (function).

Internals

• c-to-d65 (function).
• calc-isochroma-ovoid (function).
• calc-isochroma-ovoid-integer-case (function).
• max-chroma-lchab (function).
• mhvc-to-lchab-all-integer-case (function).
• mhvc-to-lchab-general-case (function).
• mhvc-to-lchab-value-chroma-integer-case (function).
• mhvc-to-lchab-value-integer-case (function).
• mhvc-to-xyy (function).
• munsell-to-xyy (function).

---

4.1.25 dufy/munsell/munsell/invert.lisp

Source

dufy.asd.

Parent Component

munsell (module).

Public Interface

• large-approximation-error (condition).
• lchab-to-mhvc-illum-c (function).
• lchab-to-munsell-illum-c (function).
• xyz-to-mhvc (function).
• xyz-to-mhvc-illum-c (function).
• xyz-to-munsell (function).
• xyz-to-munsell-illum-c (function).

Internals

• cartesian-to-mhvc (function).
• circular-delta (function).
• cond-message (reader method).
• (setf cond-message) (writer method).
• d65-to-c (function).
• invert-mhvc-to-lchab (function).
• lchab-to-mhvc-all-integer-case (function).
• lchab-to-mhvc-general-case (function).
• lchab-to-mhvc-l-c-integer-case (function).
• lchab-to-mhvc-l-integer-case (function).
• mhvc-to-cartesian (function).
• predict-lchab-to-mhvc (function).

---

4.1.26 dufy/hsluv/hsluv/package.lisp

Source

dufy.asd.

Parent Component

hsluv (module).

Packages

dufy/hsluv.

---

4.1.27 dufy/hsluv/hsluv/hsluv.lisp

Source

dufy.asd.

Parent Component

hsluv (module).

Public Interface

• hpluv-to-lchuv (function).
• hpluv-to-lrgb (function).
• hpluv-to-qrgb (function).
• hpluv-to-rgb (function).
• hpluv-to-rgbpack (function).
• hpluv-to-xyz (function).
• hsluv-to-lchuv (function).
• hsluv-to-lrgb (function).
• hsluv-to-qrgb (function).
• hsluv-to-rgb (function).
• hsluv-to-rgbpack (function).
• hsluv-to-xyz (function).
• lchuv-to-hpluv (function).
• lchuv-to-hsluv (function).
• lrgb-to-hpluv (function).
• lrgb-to-hsluv (function).
• qrgb-to-hpluv (function).
• qrgb-to-hsluv (function).
• rgb-to-hpluv (function).
• rgb-to-hsluv (function).
• rgbpack-to-hpluv (function).
• rgbpack-to-hsluv (function).
• xyz-to-hpluv (function).
• xyz-to-hsluv (function).

Internals

• +cieluv-epsilon+ (constant).
• +cieluv-kappa+ (constant).
• +m-bounds+ (constant).
• get-cieluv-bounds (function).
• max-chroma-for-lh (function).
• max-safe-chroma-for-l (function).

---

4.2.1 dufy/dat/ciede2000-test-data.csv

Source

dufy.asd.

Parent Component

dat (module).

---

4.2.2 dufy/dat/FL3.x.tsv

Source

dufy.asd.

Parent Component

dat (module).

---

6.1.1 Constants

Constant: +360/two-pi+ ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Constant: +two-pi/360+ ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Constant: two-pi ¶

Package

dufy/internal.

Source

arithmetic.lisp.

---

6.1.2 Special variables

Special Variable: *dat-dir-path* ¶

Package

dufy/internal.

Source

utilities.lisp.

Special Variable: *most-positive-non-large-double-float* ¶

Package

dufy/munsell.

Source

fundamental.lisp.

Special Variable: +adobe+ ¶

Adobe RGB (1998), 8-bit per channel

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +adobe-16+ ¶

Adobe RGB (1998), 16-bit per channel.

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +bg-srgb-10+ ¶

bg-sRGB, 10-bit per channel http://www.color.org/chardata/rgb/bgsrgb.xalter

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +bg-srgb-12+ ¶

bg-sRGB, 12-bit per channel, http://www.color.org/chardata/rgb/bgsrgb.xalter

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +bg-srgb-16+ ¶

bg-sRGB, 16-bit per channel, http://www.color.org/chardata/rgb/bgsrgb.xalter

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +bradford+ ¶

Package

dufy/core.

Source

cat.lisp.

Special Variable: +cat02+ ¶

Note that the CAT function returned by (gen-cat-function ... :cat +cat02+) is different from the one in CIECAM02 since the latter is non-linear.

Package

dufy/core.

Source

cat.lisp.

Special Variable: +cat97s-revised+ ¶

Fairchild, Mark D. (2001)."A Revision of CIECAM97s for Practical Applications" http://rit-mcsl.org/fairchild//PDFs/PAP10.pdf

Package

dufy/core.

Source

cat.lisp.

Special Variable: +cie-rgb+ ¶

CIE RGB (1931), no gamma-correction, 8-bit per channel.

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +cmccat2000+ ¶

Package

dufy/core.

Source

cat.lisp.

Special Variable: +cmccat97+ ¶

Package

dufy/core.

Source

cat.lisp.

Special Variable: +empty-matrix+ ¶

Used instead of NIL

Package

dufy/internal.

Source

matrix.lisp.

Special Variable: +identity-matrix+ ¶

Package

dufy/internal.

Source

matrix.lisp.

Special Variable: +illum-a+ ¶

Package

dufy/core.

Source

illuminants-data.lisp.

Special Variable: +illum-c+ ¶

Package

dufy/core.

Source

illuminants-data.lisp.

Special Variable: +illum-d50+ ¶

Package

dufy/core.

Source

illuminants-data.lisp.

Special Variable: +illum-d65+ ¶

Package

dufy/core.

Source

illuminants-data.lisp.

Special Variable: +illum-e+ ¶

Package

dufy/core.

Source

illuminants-data.lisp.

Special Variable: +ntsc1953+ ¶

NTSC RGB, Rec. ITU-R BT.470-6, System M, 8-bit per channel. http://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.470-6-199811-S!!PDF-E.pdf

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +obs-cie1931+ ¶

CIE 1931 Standard Colorimetric Observer (2-degree).

Package

dufy/core.

Source

spectrum.lisp.

Special Variable: +obs-cie1964+ ¶

CIE 1964 Standard Colorimetric Observer (10-degree).

Package

dufy/core.

Source

spectrum.lisp.

Special Variable: +pal/secam+ ¶

PAL/SECAM RGB, Rec. ITU-R BT.470-6, 8-bit per channel. http://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.470-6-199811-S!!PDF-E.pdf

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +prophoto+ ¶

Prophoto RGB (also known as ROMM RGB), 8-bit per channel, http://www.color.org/ROMMRGB.pdf

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +prophoto-12+ ¶

Prophoto RGB (also known as ROMM RGB), 12-bit per channel, http://www.color.org/ROMMRGB.pdf

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +prophoto-16+ ¶

Prophoto RGB (also known as ROMM RGB), 16-bit per channel, http://www.color.org/ROMMRGB.pdf

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +scrgb-16+ ¶

scRGB(16), IEC 61966-2-2:2003 http://www.color.org/chardata/rgb/scrgb.xalter

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +scrgb-nl+ ¶

scRGB-nl, IEC 61966-2-2:2003 http://www.color.org/chardata/rgb/scrgb-nl.xalter

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +srgb+ ¶

sRGB, 8-bit per channel

Package

dufy/core.

Source

rgb.lisp.

Special Variable: +von-kries+ ¶

Package

dufy/core.

Source

cat.lisp.

Special Variable: +wide-gamut+ ¶

Wide-gamut RGB, 8-bit per channel.

Package

dufy/core.

Source

builtin-rgbspaces.lisp.

Special Variable: +xyz-scaling+ ¶

Package

dufy/core.

Source

cat.lisp.

---

6.1.3 Macros

Macro: defconverter (from-colorspace to-colorspace &key name exclude-args documentation) ¶

Generates and defines a converter function from FROM-COLORSPACE to TO-COLORSPACE automatically with linking primary converters.

These secondary converters are not inlined by default, different from primary converters. You can manually declare (inline <name>) to inline them. (Declared as sb-ext:maybe-inline on SBCL.)

Package

dufy/internal.

Source

colorspace.lisp.

Macro: defconverters (from-colorspaces to-colorspaces &key exclude-args) ¶

Generates and defines converter functions from each color space in FROM-COLORSPACES into each color space in TO-COLORSPACES.

Package

dufy/internal.

Source

colorspace.lisp.

Macro: define-cat-function (name from-illuminant to-illuminant &key cat) ¶

DEFINE-macro of GEN-CAT-FUNCTION. (define-cat-function d65-to-e +illum-d65+ +illum-e+) (d65-to-e 0.9504d0 1.0d0 1.0889d0)
;; => 0.9999700272441295d0
;; 0.999998887365445d0
;; 0.9999997282885571d0

Package

dufy/core.

Source

cat.lisp.

Macro: define-colorspace (name args &key arg-types return-types documentation) ¶

Package

dufy/internal.

Source

colorspace.lisp.

Macro: define-functional ((fname colorspace &key term) lambda-list &body body) ¶

Package

dufy/internal.

Source

colorspace.lisp.

Macro: define-primary-converter ((from-colorspace to-colorspace &key name) lambda-list &body body) ¶

Defines FOO-TO-BAR function as a primary converter. Only &key arguments (without supplied-p-parameter) and &aux arguments are allowed.

Package

dufy/internal.

Source

colorspace.lisp.

Macro: dotimes-unroll ((var count &optional result) &body body) ¶

Package

dufy/internal.

Source

utilities.lisp.

Macro: extend-functional (term colorspace &key fname exclude-args documentation) ¶

Generates and defines a functional on another color space. The name of the function is [COLORSPACE]-[TERM] if FNAME is not given.

Package

dufy/internal.

Source

colorspace.lisp.

Macro: internal-real-time-after-gc (&body body) ¶

INTERNAL-REAL-TIME macro after GC

Package

dufy/internal.

Source

utilities.lisp.

Macro: nearly-equal-values (threshold &rest forms) ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Macro: nlet (name args &body body) ¶

Package

dufy/internal.

Source

utilities.lisp.

Macro: pow (base power) ¶

Does fast exponentiation by squaring. POWER must be a literal of type (integer 1).

Package

dufy/internal.

Source

arithmetic.lisp.

Macro: time-after-gc (&body body) ¶

TIME macro after GC

Package

dufy/internal.

Source

utilities.lisp.

Macro: time-median (num &body body) ¶

Repeats BODY NUM times and returns the median of elapsed (internal real) times.

Package

dufy/internal.

Source

utilities.lisp.

Macro: with-ensuring-type (type vars &body body) ¶

Ensures and declares that the type of variables are TYPE.

Package

dufy/internal.

Source

utilities.lisp.

Macro: with-profiling (names &body body) ¶

Works only on SBCL.

Package

dufy/internal.

Source

utilities.lisp.

---

6.1.4 Compiler macros

Compiler Macro: make-illuminant (&key x z spectrum observer begin-wl end-wl band compile-time) ¶

Package

dufy/core.

Source

spectrum.lisp.

---

6.1.5 Ordinary functions

Function: approximate-spectrum (spectrum &key begin-wl end-wl band) ¶

Generates an approximate spectrum of SPECTRUM by pieacewise linearization. It is used to lighten a "heavy" spectrum function.

Package

dufy/core.

Source

spectrum.lisp.

Function: bb-spectrum (wavelength-nm &optional temperature) ¶

Spectrum function of a blackbody. Note that it is not normalized.

Package

dufy/core.

Source

spectrum.lisp.

Function: call-with-profiling (names func) ¶

Works only on SBCL.

Package

dufy/internal.

Source

utilities.lisp.

Reader: cat-inv-matrix (instance) ¶

Writer: (setf cat-inv-matrix) (instance) ¶

Package

dufy/core.

Source

cat.lisp.

Target Slot

inv-matrix.

Reader: cat-matrix (instance) ¶

Writer: (setf cat-matrix) (instance) ¶

Package

dufy/core.

Source

cat.lisp.

Target Slot

matrix.

Function: circular-clamp (number min max &optional perimeter) ¶

A clamp function in a circle group. If NUMBER is not in
the (counterclockwise) closed interval [MIN, MAX], CIRCULAR-CLAMP returns MIN or MAX whichever is nearer to NUMBER.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: circular-lerp (coef theta1 theta2 &optional perimeter) ¶

Counterclockwise linear interpolation from THETA1 to THETA2 in a circle group. It is guaranteed that the returned value doesn’t exceed the given interval from THETA1 to THETA2 if COEF is in [0, 1]. It is, however, slower than CIRCULAR-LERP-LOOSE.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: circular-lerp-loose (coef theta1 theta2 &optional perimeter) ¶

Counterclockwise linear interpolation from THETA1 to THETA2 in a circle group. There is a possibility that the returned value slightly exceeds the interval [THETA1, THETA2] due to floating-point error. If that is incovenient, you should use CIRCULAR-LERP instead.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: circular-member (number theta1 theta2 &optional perimeter) ¶

Returns true if NUMBER is within the counterclockwise closed interval [THETA1, THETA2] in a circle group.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: circular-nearer (theta1 x theta2 &optional perimeter) ¶

Compares the counterclockwise distances between THETA1 and X and between X and THETA2, and returns THETA1 or THETA2 whichever is nearer.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: copy-rgbspace (rgbspace &key illuminant bit-per-channel cat) ¶

Returns a new RGBSPACE with different standard illuminant and/or bit-per-channel. All the parameters are properly recalculated. If both are nil, it is just a copier.

Package

dufy/core.

Source

cat.lisp.

Function: degree-to-radian (degree) ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Function: delinearize (x &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: dequantize (n &key rgbspace) ¶

Dequantizes a QRGB value to an RGB value

Package

dufy/core.

Source

rgb.lisp.

Function: flat-spectrum (wavelength-nm) ¶

(constantly 1d0)

Package

dufy/core.

Source

spectrum.lisp.

Function: gen-cat-function (from-illuminant to-illuminant &key cat) ¶

Returns a chromatic adaptation function.
(funcall (gen-cat-function +illum-a+ +illum-e+) 0.9504d0 1.0d0 1.0889d0) => 0.9999700272441295d0
0.999998887365445d0
0.9999997282885571d0 ; transformed white point

Package

dufy/core.

Source

cat.lisp.

Function: gen-delinearizer (gamma) ¶

Returns a gamma-correction function for a given gamma value. You shouldn’t call the returned function directly as it is not safe. Use DELINEARIZE instead.

Package

dufy/core.

Source

rgb.lisp.

Function: gen-illum-d-spectrum (temperature &key rectify) ¶

Generates the spectrum of the illuminant series D for a given
temperature (from 300 nm to 830 nm with band-width 1 nm). If RECTIFY is true, the temperature multiplied by 1.4388/1.438 is used instead. (roughly 6504K for 6500K, etc.)

Package

dufy/core.

Source

spectrum.lisp.

Function: gen-linearizer (gamma) ¶

Returns a linearization function for a given gamma value. You shouldn’t call the returned function directly as it is not safe. Use LINEARIZE instead.

Package

dufy/core.

Source

rgb.lisp.

Function: gen-rgbspace-changer (from-rgbspace to-rgbspace &key target cat) ¶

Returns a function for changing RGB working space.

(funcall (gen-rgbspace-changer +srgb+ +adobe+ :target :rgb) 0 1 0) ;; => 0.5649506908657044d0
;; 1.0d0
;; 0.2344342037422755d0
;; change from sRGB to Adobe RGB.

TARGET ::= :LRGB | :RGB | :QRGB | :RGBPACK

Note about clamping:
LRGB case: no clamping;
RGB case: no clamping;
QRGB case: with clamping;
RGBPACK case: with clamping.

Package

dufy/core.

Source

cat.lisp.

Function: gen-spectrum (spectrum-seq &optional begin-wl end-wl) ¶

GEN-SPECTRUM returns a spectral power distribution
function, #’(lambda (wavelength-nm) ...), which interpolates SPECTRUM-SEQ linearly.

Note: SPECTRUM-SEQ must be a sequence of double-float. If the type of SPECTRUM-SEQ is (simple-array double-float (*)), it is not copied but referenced, otherwise it is copied by (coerce spectrum-seq ’(simple-array double-float (*))).

Package

dufy/core.

Source

spectrum.lisp.

Function: hpluv-to-lchuv (huv psat lstar) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hpluv-to-lrgb (huv psat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hpluv-to-qrgb (huv psat lstar &key rgbspace clamp) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hpluv-to-rgb (huv psat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hpluv-to-rgbpack (huv psat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hpluv-to-xyz (huv psat lstar &key illuminant) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsl-to-lrgb (hue sat lum &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsl-to-qrgb (hue sat lum &key rgbspace clamp) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsl-to-rgb (hue sat lum) ¶

Non-normal RGB space is also accepted, though it depends on the situation whether the returned values are meaningful.

Package

dufy/core.

Source

rgb.lisp.

Function: hsl-to-rgbpack (hue sat lum &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsl-to-xyz (hue sat lum &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsluv-to-lchuv (huv sat lstar) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsluv-to-lrgb (huv sat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsluv-to-qrgb (huv sat lstar &key rgbspace clamp) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsluv-to-rgb (huv sat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsluv-to-rgbpack (huv sat lstar &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsluv-to-xyz (huv sat lstar &key illuminant) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: hsv-to-lrgb (hue sat val &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsv-to-qrgb (hue sat val &key rgbspace clamp) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsv-to-rgb (hue sat val) ¶

Non-normal RGB space is also accepted, though it depends on the situation whether the returned values are meaningful.

Package

dufy/core.

Source

rgb.lisp.

Function: hsv-to-rgbpack (hue sat val &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: hsv-to-xyz (hue sat val &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: illuminant-no-spd-p (illuminant) ¶

Package

dufy/core.

Source

spectrum.lisp.

Reader: illuminant-observer (instance) ¶

Writer: (setf illuminant-observer) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

observer.

Reader: illuminant-spectrum (instance) ¶

Writer: (setf illuminant-spectrum) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

spectrum.

Reader: illuminant-x (instance) ¶

Writer: (setf illuminant-x) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

x.

Function: illuminant-xy (illuminant) ¶

Returns the xy chromacity coordinates of a given illuminant.

Package

dufy/core.

Source

spectrum.lisp.

Reader: illuminant-z (instance) ¶

Writer: (setf illuminant-z) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

z.

Function: invert-matrix (mat) ¶

Package

dufy/internal.

Source

matrix.lisp.

Function: lab-deltae00 (l1 a1 b1 l2 a2 b2) ¶

CIEDE2000.

Tested with the test set by Sharma-Wu-Dalal. See "The CIEDE2000 Color-Difference Formula: Implementation Notes, Supplementary Test Data, and Mathematical Observations", 2004.

Package

dufy/core.

Source

deltae.lisp.

Function: lab-deltae94 (l1 a1 b1 l2 a2 b2 &key application) ¶

CIE 1994.
APPLICATION ::= :graphic-arts | :textiles

Package

dufy/core.

Source

deltae.lisp.

Function: lab-deltaeab (l1 a1 b1 l2 a2 b2) ¶

CIE 1976. Euclidean distance in L*a*b* space.

Package

dufy/core.

Source

deltae.lisp.

Function: lab-deltaecmc (l1 a1 b1 l2 a2 b2 &key l-factor c-factor) ¶

CMC l:c

Package

dufy/core.

Source

deltae.lisp.

Function: lab-to-lchab (lstar astar bstar) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: lab-to-xyz (lstar astar bstar &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: lchab-to-lab (lstar cstarab hab) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: lchab-to-mhvc-illum-c (lstar cstarab hab &key max-iteration if-reach-max factor threshold) ¶

Is an inverter of MHVC-TO-LCHAB-ILLUM-C with a simple iteration algorithm, which is almost same as the one in "An Open-Source Inversion Algorithm for the Munsell Renotation" by Paul Centore, 2011:

V := LSTAR-TO-MUNSELL-VALUE(L*);
C_0 := C*_ab / 5.5;
H_0 := h_ab / 9;
C_(n+1) := C_n + FACTOR * ΔC_n;
H_(n+1) := H_n + FACTOR * ΔH_n;

Δ(H_n) and Δ(C_n) are internally calculated at every step. This function returns Munsell HVC values if C_0 <= THRESHOLD or if V <= THRESHOLD or when max(Δ(H_n), Δ(C_n)) falls below THRESHOLD.

IF-REACH-MAX specifies the action to be taken if the loop reaches the MAX-ITERATION as follows:

:error: Error of type DUFY:LARGE-APPROXIMATION-ERROR is signaled. :return40: Three 40d0s are returned.
:raw: Just returns HVC as it is.

Package

dufy/munsell.

Source

invert.lisp.

Function: lchab-to-munsell-illum-c (lstar cstarab hab &key max-iteration if-reach-max factor threshold digits) ¶

Illuminant C

Package

dufy/munsell.

Source

invert.lisp.

Function: lchab-to-xyz (lstar cstarab hab &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: lchuv-to-hpluv (lstar cstaruv huv) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: lchuv-to-hsluv (lstar cstaruv huv) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: lchuv-to-luv (lstar cstaruv huv) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: lchuv-to-xyz (lstar cstaruv huv &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: linearize (x &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lms-to-xyz (l m s &key illuminant cat) ¶

ILLUMINANT can be NIL and in that case the transform is virtually equivalent to that of illuminant E.

Package

dufy/core.

Source

cat.lisp.

Function: lrgb-out-of-gamut-p (lr lg lb &key rgbspace threshold) ¶

Returns true if at least one of LR, LG, and LB is outside the interval [RGBSPACE-LMIN - THRESHOLD, RGBSPACE-LMAX + THRESHOLD].

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-hpluv (lr lg lb &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: lrgb-to-hsl (lr lg lb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-hsluv (lr lg lb &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: lrgb-to-hsv (lr lg lb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-qrgb (lr lg lb &key rgbspace clamp) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-rgb (lr lg lb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-rgbpack (lr lg lb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lrgb-to-xyz (lr lg lb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: lstar-to-munsell-value (lstar) ¶

Package

dufy/munsell.

Source

fundamental.lisp.

Function: lstar-to-y (lstar) ¶

L* (of L*a*b*) to Y (of XYZ)

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: luv-to-lchuv (lstar ustar vstar) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: luv-to-xyz (lstar ustar vstar &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: make-cat (mat) ¶

Generates a (linear) CAT model from a 3*3 matrix.

Package

dufy/core.

Source

cat.lisp.

Function: make-illuminant (&key x z spectrum observer compile-time begin-wl end-wl band) ¶

Generates an illuminant from a spectral distribution or a white point. If SPECTRUM is nil, the returned illuminant contains only a white point. If X and Z are nil, on the other hand, the white point (X, 1d0, Z) is automatically calculated from the spectrum. You can also specify the both though you should note that no error occurs even if the given white point and SPD contradicts to each other.

(make-illuminant :x 1.0 :z 1.0)
;; => illuminant without SPD

(make-illuminant :x 1.0 :z 1.0 :spectrum #’flat-spectrum)
(make-illuminant :spectrum #’flat-spectrum)
;; => (almost same) illuminants with SPD

(make-illuminant :x 0.9 :z 1.1 :spectrum #’flat-spectrum)
;; => (valid but meaningless) illuminant with SPD

If X and Y are NIL and COMPILE-TIME is T, the white point is
calculated at compile time. (Avoid side effects in this case as the parameters are EVALed.)

Package

dufy/core.

Source

spectrum.lisp.

Function: make-mb-line (&key slope intercept) ¶

Package

dufy/internal.

Source

mb-line.lisp.

Function: make-observer (cmf-table &optional begin-wl end-wl) ¶

Generates an observer object based on CMF arrays, which must be (SIMPLE-ARRAY DOUBLE-FLOAT (* 3)). The response outside the interval [begin-wl, end-wl] is regarded as 0.

Package

dufy/core.

Source

spectrum.lisp.

Function: make-rgbspace (xr yr xg yg xb yb &key illuminant lmin lmax linearizer delinearizer bit-per-channel force-normal) ¶

xr, yr, xg, yg, xb, yb := primary coordinates in the xy plane.
[lmin, lmax] := range of linear values ([0, 1] typically).

LINEARIZER and DELINEARIZER must be (FUNCTION * (VALUES DOUBLE-FLOAT &OPTIONAL)).

If FORCE-NORMAL is T, the nominal range of gamma-corrected values is forcibly set to [0d0, 1d0]. This option is used to avoid the computed range being e.g. [0d0, 0.9999999999999999d0].

Package

dufy/core.

Source

rgb.lisp.

Function: max-chroma-in-mrd (hue40 value &key use-dark) ¶

Returns the largest chroma in the Munsell Renotation Data (all.dat) for a given hue and value. If you want to ignore the data for value = 0.2, 0.4, 0.6, or 0.8, give NIL to USE-DARK(, though it is maybe only for development).

Package

dufy/munsell.

Source

fundamental.lisp.

Function: mb-line-distance-from-origin (line) ¶

Return the distance from the line to the origin.

Package

dufy/internal.

Source

mb-line.lisp.

Function: mb-line-ray-intersect-distance (theta line) ¶

Return the (signed) distance at which a ray, starting at the origin and travelling at angle THETA, intersects LINE.

Package

dufy/internal.

Source

mb-line.lisp.

Function: mhvc-out-of-mrd-p (hue40 value chroma) ¶

Checks if Munsell HVC is out of the Munsell Renotation data.

Package

dufy/munsell.

Source

fundamental.lisp.

Function: mhvc-to-lchab-illum-c (hue40 value chroma) ¶

Illuminant C.

Package

dufy/munsell.

Source

convert.lisp.

Function: mhvc-to-munsell (hue40 value chroma &key digits) ¶

Package

dufy/munsell.

Source

fundamental.lisp.

Function: mhvc-to-xyz (hue40 value chroma) ¶

Illuminant D65.
This converter involves the Bradford transformation from illuminant C to illuminant D65.

Package

dufy/munsell.

Source

convert.lisp.

Function: mhvc-to-xyz-illum-c (hue40 value chroma) ¶

Illuminant C.

Package

dufy/munsell.

Source

convert.lisp.

Function: multiply-mat-mat (mat1 mat2) ¶

Package

dufy/internal.

Source

matrix.lisp.

Function: multiply-mat-vec (matrix x y z) ¶

Package

dufy/internal.

Source

matrix.lisp.

Function: multiply-matrices (mat1 &rest mats) ¶

Package

dufy/internal.

Source

matrix.lisp.

Function: munsell-out-of-mrd-p (munsellspec) ¶

Package

dufy/munsell.

Source

fundamental.lisp.

Function: munsell-to-lchab-illum-c (munsellspec) ¶

Illuminant C.

Package

dufy/munsell.

Source

convert.lisp.

Function: munsell-to-mhvc (munsellspec) ¶

Usage Example:
(dufy:munsell-to-mhvc "0.02RP 0.9/3.5")
;; => 36.008d0
;; 0.9d0
;; 3.5d0

Many other notations of numbers are acceptable; an ugly specification as follows are also available:

(dufy:munsell-to-mhvc "2d-2RP .9/ #x0ffffff")
;; => 36.008d0
;; 0.9d0
;; 1.6777215d7

However, the capital letters and ’/’ are reserved:

(dufy:munsell-to-mhvc "2D-2RP 9/10 / #X0FFFFFF")
;; => ERROR,

Package

dufy/munsell.

Source

fundamental.lisp.

Function: munsell-to-xyz (munsellspec) ¶

Illuminant D65.

Package

dufy/munsell.

Source

convert.lisp.

Function: munsell-to-xyz-illum-c (munsellspec) ¶

Illuminant C.

Package

dufy/munsell.

Source

convert.lisp.

Function: munsell-value-to-lstar (v) ¶

Converts Munsell value to L*, whose nominal range is [0, 100].

Package

dufy/munsell.

Source

fundamental.lisp.

Function: munsell-value-to-y (v) ¶

Converts Munsell value to Y, whose nominal range is [0, 1]. The formula is based on ASTM D1535-08e1. Note that this function does no clamping even if V is outside the interval [0, 10].

Package

dufy/munsell.

Source

fundamental.lisp.

Function: nearly-equal (threshold lst1 &rest lsts) ¶

THRESHOLD is acceptable absolute error.

Package

dufy/internal.

Source

arithmetic.lisp.

Function: nearly<= (threshold number &rest more-numbers) ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Function: nearly= (threshold number &rest more-numbers) ¶

THRESHOLD is acceptable absolute error.

Package

dufy/internal.

Source

arithmetic.lisp.

Reader: observer-begin-wl (instance) ¶

Writer: (setf observer-begin-wl) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

begin-wl.

Reader: observer-cmf (instance) ¶

Writer: (setf observer-cmf) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

cmf.

Reader: observer-cmf-x (instance) ¶

Writer: (setf observer-cmf-x) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

cmf-x.

Reader: observer-cmf-y (instance) ¶

Writer: (setf observer-cmf-y) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

cmf-y.

Reader: observer-cmf-z (instance) ¶

Writer: (setf observer-cmf-z) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

cmf-z.

Reader: observer-end-wl (instance) ¶

Writer: (setf observer-end-wl) (instance) ¶

Package

dufy/core.

Source

spectrum.lisp.

Target Slot

end-wl.

Function: optimal-spectrum-peak (wavelength-nm &optional wl1 wl2) ¶

Spectrum function of optimal colors: f(x) = 1d0 if wl1 <= x <= wl2, f(x) = 0d0 otherwise.

Package

dufy/core.

Source

spectrum.lisp.

Function: optimal-spectrum-trough (wavelength-nm &optional wl1 wl2) ¶

Spectrum function of optimal colors: f(x) = 1d0 if x <= wl2 or wl1 <= x, f(x) = 0d0 otherwise.

Package

dufy/core.

Source

spectrum.lisp.

Function: print-make-array (var-name array &optional stream declaration load-time-value) ¶

Prints a form like (defparameter VAR-NAME (make-array ...)).

Package

dufy/internal.

Source

utilities.lisp.

Function: qrgb-deltae00 (qr1 qg1 qb1 qr2 qg2 qb2 &key rgbspace) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: qrgb-deltae94 (qr1 qg1 qb1 qr2 qg2 qb2 &key rgbspace application) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: qrgb-deltaeab (qr1 qg1 qb1 qr2 qg2 qb2 &key rgbspace) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: qrgb-deltaecmc (qr1 qg1 qb1 qr2 qg2 qb2 &key rgbspace l-factor c-factor) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: qrgb-out-of-gamut-p (qr qg qb &key rgbspace threshold) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-hpluv (qr qg qb &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: qrgb-to-hsl (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-hsluv (qr qg qb &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: qrgb-to-hsv (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-lrgb (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-rgb (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-rgbpack (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: qrgb-to-xyz (qr qg qb &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: quantize (x &key rgbspace clamp) ¶

Quantizes an RGB value to a QRGB value

Package

dufy/core.

Source

rgb.lisp.

Function: radian-to-degree (radian) ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Function: rgb-out-of-gamut-p (r g b &key rgbspace threshold) ¶

Returns true if at least one of R, G, and B is outside the interval [RGBSPACE-MIN - THRESHOLD, RGBSPACE-MAX + THRESHOLD].

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-hpluv (r g b &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: rgb-to-hsl (r g b) ¶

Non-normal RGB space is also accepted, though it depends on the situation whether the returned values are meaningful.

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-hsluv (r g b &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: rgb-to-hsv (r g b) ¶

Non-normal RGB space is also accepted, though it depends on the situation whether the returned values are meaningful.

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-lrgb (r g b &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-qrgb (r g b &key rgbspace clamp) ¶

Quantizes RGB values from [RGBSPACE-MIN, RGBSPACE-MAX] ([0, 1] typically) to 0, 1, ..., RGBSPACE-QMAX (255 typically), though it accepts all the real values and properly processes them as out-of-gamut color.

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-rgbpack (r g b &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgb-to-xyz (r g b &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-hpluv (int &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: rgbpack-to-hsl (int &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-hsluv (int &key rgbspace) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: rgbpack-to-hsv (int &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-lrgb (int &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-qrgb (int &key rgbspace) ¶

Decodes a packed RGB value, whose type depends on RGBSPACE but is typically unsigned 24-bit integer.

It is guaranteed that this converter can correctly process a packed RGBA value if its order is ARGB.

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-rgb (int &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: rgbpack-to-xyz (int &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Reader: rgbspace-bit-per-channel (instance) ¶

Writer: (setf rgbspace-bit-per-channel) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

bit-per-channel.

Reader: rgbspace-delinearizer (instance) ¶

Writer: (setf rgbspace-delinearizer) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

delinearizer.

Reader: rgbspace-from-xyz-matrix (instance) ¶

Writer: (setf rgbspace-from-xyz-matrix) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

from-xyz-matrix.

Reader: rgbspace-illuminant (instance) ¶

Writer: (setf rgbspace-illuminant) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

illuminant.

Reader: rgbspace-linearizer (instance) ¶

Writer: (setf rgbspace-linearizer) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

linearizer.

Reader: rgbspace-lmax (instance) ¶

Writer: (setf rgbspace-lmax) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

lmax.

Reader: rgbspace-lmin (instance) ¶

Writer: (setf rgbspace-lmin) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

lmin.

Reader: rgbspace-max (instance) ¶

Writer: (setf rgbspace-max) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

max.

Reader: rgbspace-min (instance) ¶

Writer: (setf rgbspace-min) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

min.

Reader: rgbspace-normal (instance) ¶

Writer: (setf rgbspace-normal) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

normal.

Reader: rgbspace-qmax (instance) ¶

Writer: (setf rgbspace-qmax) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

qmax.

Reader: rgbspace-to-xyz-matrix (instance) ¶

Writer: (setf rgbspace-to-xyz-matrix) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

to-xyz-matrix.

Reader: rgbspace-xb (instance) ¶

Writer: (setf rgbspace-xb) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

xb.

Reader: rgbspace-xg (instance) ¶

Writer: (setf rgbspace-xg) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

xg.

Reader: rgbspace-xr (instance) ¶

Writer: (setf rgbspace-xr) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

xr.

Reader: rgbspace-yb (instance) ¶

Writer: (setf rgbspace-yb) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

yb.

Reader: rgbspace-yg (instance) ¶

Writer: (setf rgbspace-yg) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

yg.

Reader: rgbspace-yr (instance) ¶

Writer: (setf rgbspace-yr) (instance) ¶

Package

dufy/core.

Source

rgb.lisp.

Target Slot

yr.

Function: spectrum-to-xyz (spectrum &key illuminant begin-wl end-wl band) ¶

Computes the XYZ values of SPECTRUM in reflective or transmissive case. The function SPECTRUM, a spectral reflectance, must be defined at least in [BEGIN-WL, END-WL]; the SPECTRUM is called for BEGIN-WL, BEGIN-WL + BAND, BEGIN-WL + 2*BAND, ..., BEGIN-WL + n*BAND (<= END-WL).

Package

dufy/core.

Source

xyz.lisp.

Function: square (x) ¶

Package

dufy/internal.

Source

arithmetic.lisp.

Function: xyy-to-xyz (small-x small-y y) ¶

Converts xyY to XYZ. The nominal range of Y is [0, 1], though all real values are accepted.

Package

dufy/core.

Source

xyz.lisp.

Function: xyz-deltae00 (x1 y1 z1 x2 y2 z2 &key illuminant) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: xyz-deltae94 (x1 y1 z1 x2 y2 z2 &key illuminant application) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: xyz-deltaeab (x1 y1 z1 x2 y2 z2 &key illuminant) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: xyz-deltaecmc (x1 y1 z1 x2 y2 z2 &key illuminant l-factor c-factor) ¶

Package

dufy/core.

Source

deltae.lisp.

Function: xyz-to-hpluv (x y z &key illuminant) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: xyz-to-hsl (x y z &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-hsluv (x y z &key illuminant) ¶

Package

dufy/hsluv.

Source

hsluv.lisp.

Function: xyz-to-hsv (x y z &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-lab (x y z &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: xyz-to-lchab (x y z &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: xyz-to-lchuv (x y z &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: xyz-to-lms (x y z &key illuminant cat) ¶

ILLUMINANT can be NIL and in that case the transform is virtually equivalent to that of illuminant E.

Package

dufy/core.

Source

cat.lisp.

Function: xyz-to-lrgb (x y z &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-luv (x y z &key illuminant) ¶

Package

dufy/core.

Source

lab-and-luv.lisp.

Function: xyz-to-mhvc (x y z &key max-iteration if-reach-max factor threshold) ¶

Illuminant D65.
This converter involves the Bradford transformation from illuminant D65 to illuminant C.

Package

dufy/munsell.

Source

invert.lisp.

Function: xyz-to-mhvc-illum-c (x y z &key max-iteration if-reach-max factor threshold) ¶

Illuminant C.

Package

dufy/munsell.

Source

invert.lisp.

Function: xyz-to-munsell (x y z &key max-iteration if-reach-max factor threshold digits) ¶

Illuminant D65.
This converter involves the Bradford transformation from illuminant D65 to illuminant C.

Package

dufy/munsell.

Source

invert.lisp.

Function: xyz-to-munsell-illum-c (x y z &key max-iteration if-reach-max factor threshold digits) ¶

Illuminant C.

Package

dufy/munsell.

Source

invert.lisp.

Function: xyz-to-qrgb (x y z &key rgbspace clamp) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-rgb (x y z &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-rgbpack (x y z &key rgbspace) ¶

Package

dufy/core.

Source

rgb.lisp.

Function: xyz-to-spectrum (x y z &key illuminant) ¶

Converts XYZ to spectrum, which is, of course, a spectrum among many and may contain a negative spectral density.

Package

dufy/core.

Source

xyz.lisp.

Function: xyz-to-xyy (x y z) ¶

Converts XYZ to xyY. The nominal range of Y is [0, 1], though all real values are accepted.

Package

dufy/core.

Source

xyz.lisp.

Function: y-to-munsell-value (y) ¶

Interpolates the inversion table of MUNSELL-VALUE-TO-Y linearly, whose band width is 1e-3. It is guaranteed that the round-trip error, (abs (- (y (munsell-value-to-y (y-to-munsell-value y))))), is smaller than 1e-5.

Package

dufy/munsell.

Source

fundamental.lisp.

---