Gecko [ nrupathungauniversityblr.ac.in ]

Name	Size	Permission
.deps	[ DIR ]	drwxrwxr-x
.libs	[ DIR ]	drwxrwxr-x
.dirstamp	0 B	-rw-rw-r--
ImageMagick-7.Q16HDRI.pc	867 B	-rw-rw-r--
ImageMagick.pc	867 B	-rw-rw-r--
ImageMagick.pc.in	575 B	-rw-rw-r--
MagickCore-7.Q16HDRI.pc	916 B	-rw-rw-r--
MagickCore-config	1.5 KB	-rwxrwxr-x
MagickCore-config.1	1.85 KB	-rw-rw-r--
MagickCore-config.in	1.57 KB	-rw-rw-r--
MagickCore.h	4.94 KB	-rw-rw-r--
MagickCore.pc	916 B	-rw-rw-r--
MagickCore.pc.in	688 B	-rw-rw-r--
Makefile.am	14.76 KB	-rw-rw-r--
accelerate-kernels-private.h	102.16 KB	-rw-rw-r--
accelerate-private.h	2.63 KB	-rw-rw-r--
accelerate.c	169.72 KB	-rw-rw-r--
animate-private.h	1.23 KB	-rw-rw-r--
animate.c	103.29 KB	-rw-rw-r--
animate.h	979 B	-rw-rw-r--
annotate-private.h	1022 B	-rw-rw-r--
annotate.c	71.69 KB	-rw-rw-r--
annotate.h	1.26 KB	-rw-rw-r--
artifact.c	18.74 KB	-rw-rw-r--
artifact.h	1.35 KB	-rw-rw-r--
attribute.c	69.33 KB	-rw-rw-r--
attribute.h	1.78 KB	-rw-rw-r--
blob-private.h	4.07 KB	-rw-rw-r--
blob.c	207.68 KB	-rw-rw-r--
blob.h	3.29 KB	-rw-rw-r--
cache-private.h	6.63 KB	-rw-rw-r--
cache-view.c	44.83 KB	-rw-rw-r--
cache-view.h	3.63 KB	-rw-rw-r--
cache.c	211.11 KB	-rw-rw-r--
cache.h	2.5 KB	-rw-rw-r--
channel.c	41.69 KB	-rw-rw-r--
channel.h	1.28 KB	-rw-rw-r--
cipher.c	40.58 KB	-rw-rw-r--
cipher.h	1.11 KB	-rw-rw-r--
client.c	7.37 KB	-rw-rw-r--
client.h	1.03 KB	-rw-rw-r--
coder-private.h	1005 B	-rw-rw-r--
coder.c	20.03 KB	-rw-rw-r--
coder.h	1.28 KB	-rw-rw-r--
color-private.h	2.28 KB	-rw-rw-r--
color.c	105.5 KB	-rw-rw-r--
color.h	2.22 KB	-rw-rw-r--
colormap-private.h	1.8 KB	-rw-rw-r--
colormap.c	13.3 KB	-rw-rw-r--
colormap.h	1.05 KB	-rw-rw-r--
colorspace-private.h	4.23 KB	-rw-rw-r--
colorspace.c	99.03 KB	-rw-rw-r--
colorspace.h	2.35 KB	-rw-rw-r--
compare.c	72.32 KB	-rw-rw-r--
compare.h	1.86 KB	-rw-rw-r--
composite-private.h	5.5 KB	-rw-rw-r--
composite.c	81.18 KB	-rw-rw-r--
composite.h	2.85 KB	-rw-rw-r--
compress.c	39.93 KB	-rw-rw-r--
compress.h	2.15 KB	-rw-rw-r--
configure-private.h	1019 B	-rw-rw-r--
configure.c	44.68 KB	-rw-rw-r--
configure.h	1.65 KB	-rw-rw-r--
constitute-private.h	890 B	-rw-rw-r--
constitute.c	50.54 KB	-rw-rw-r--
constitute.h	1.45 KB	-rw-rw-r--
decorate.c	31.1 KB	-rw-rw-r--
decorate.h	1.34 KB	-rw-rw-r--
delegate-private.h	2.16 KB	-rw-rw-r--
delegate.c	83.77 KB	-rw-rw-r--
delegate.h	1.98 KB	-rw-rw-r--
deprecate.c	13.45 KB	-rw-rw-r--
deprecate.h	1.21 KB	-rw-rw-r--
display-private.h	1.24 KB	-rw-rw-r--
display.c	515.56 KB	-rw-rw-r--
display.h	1.05 KB	-rw-rw-r--
distort.c	134.29 KB	-rw-rw-r--
distort.h	2.65 KB	-rw-rw-r--
distribute-cache-private.h	2.24 KB	-rw-rw-r--
distribute-cache.c	49.1 KB	-rw-rw-r--
distribute-cache.h	997 B	-rw-rw-r--
draw-private.h	2.1 KB	-rw-rw-r--
draw.c	245.29 KB	-rw-rw-r--
draw.h	5.55 KB	-rw-rw-r--
effect.c	125.86 KB	-rw-rw-r--
effect.h	2.85 KB	-rw-rw-r--
enhance.c	137.51 KB	-rw-rw-r--
enhance.h	2.32 KB	-rw-rw-r--
exception-private.h	3.18 KB	-rw-rw-r--
exception.c	44.49 KB	-rw-rw-r--
exception.h	4.35 KB	-rw-rw-r--
feature.c	83.79 KB	-rw-rw-r--
feature.h	1.7 KB	-rw-rw-r--
fourier.c	49.36 KB	-rw-rw-r--
fourier.h	1.38 KB	-rw-rw-r--
fx-private.h	1.21 KB	-rw-rw-r--
fx.c	87.87 KB	-rw-rw-r--
fx.h	956 B	-rw-rw-r--
gem-private.h	6.28 KB	-rw-rw-r--
gem.c	53.31 KB	-rw-rw-r--
gem.h	1.15 KB	-rw-rw-r--
geometry.c	55.44 KB	-rw-rw-r--
geometry.h	3.98 KB	-rw-rw-r--
histogram.c	39.72 KB	-rw-rw-r--
histogram.h	1.35 KB	-rw-rw-r--
identify.c	57.07 KB	-rw-rw-r--
identify.h	971 B	-rw-rw-r--
image-private.h	2.89 KB	-rw-rw-r--
image-view.c	42.98 KB	-rw-rw-r--
image-view.h	2.72 KB	-rw-rw-r--
image.c	142.86 KB	-rw-rw-r--
image.h	13.87 KB	-rw-rw-r--
layer.c	75.49 KB	-rw-rw-r--
layer.h	2 KB	-rw-rw-r--
libMagickCore-7.Q16HDRI.la	1.32 KB	-rw-rw-r--
libMagickCore.map	46 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-acc...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-acc...	6.25 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ani...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ani...	245.7 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ann...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ann...	225.34 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-art...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-art...	57.34 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-att...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-att...	198.58 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-blo...	356 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-blo...	559.89 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cac...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cac...	130.77 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cac...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cac...	575.03 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cha...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cha...	132.27 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cip...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cip...	99.63 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cli...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cli...	11.99 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cod...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-cod...	48.66 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	187.05 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	64.29 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-col...	416.23 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	244.2 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	205.62 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-com...	116.91 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-con...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-con...	92.49 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-con...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-con...	134.21 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dec...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dec...	140.39 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-del...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-del...	181.88 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dep...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dep...	40.1 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	1001.06 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	257.94 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	392 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dis...	138.98 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dra...	356 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-dra...	629.21 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-eff...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-eff...	359.09 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-enh...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-enh...	435.72 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-exc...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-exc...	79.98 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fea...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fea...	231.75 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fou...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fou...	147.25 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fx....	350 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-fx....	285.02 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-gem...	353 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-gem...	222.46 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-geo...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-geo...	111.41 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-his...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-his...	103.51 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ide...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ide...	183.14 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ima...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ima...	103.35 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ima...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ima...	311.29 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lay...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lay...	140.62 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lin...	377 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lin...	41.23 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lis...	356 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-lis...	137.44 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-loc...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-loc...	93.1 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-log...	353 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-log...	109.05 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mag...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mag...	54.52 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mag...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mag...	123.44 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mat...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mat...	90.06 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mem...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mem...	64.4 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mim...	356 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mim...	69.73 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mod...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mod...	46.27 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mon...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mon...	37.7 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mon...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mon...	102.55 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mor...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-mor...	249.84 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ope...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ope...	14.32 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-opt...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-opt...	238.09 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pai...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pai...	158.05 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pix...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pix...	1.12 MB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pol...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pol...	84.46 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pre...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pre...	50.55 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pro...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pro...	178.05 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pro...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-pro...	375.58 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	308.11 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	386 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	886.72 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	386 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	690.47 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-qua...	93.22 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ran...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ran...	71.95 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-reg...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-reg...	58.8 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	101.68 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	484.14 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-res...	130.89 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-seg...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-seg...	137.09 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sem...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sem...	27.5 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-she...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-she...	209.97 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sig...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sig...	77.59 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-spl...	374 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-spl...	71.54 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sta...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sta...	42.69 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sta...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-sta...	361.96 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-str...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-str...	389.89 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-str...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-str...	145.78 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-thr...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-thr...	9.66 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-thr...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-thr...	223.15 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tim...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tim...	38.76 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tok...	359 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tok...	220.66 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tra...	371 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-tra...	228.2 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-typ...	356 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-typ...	88.52 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-uti...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-uti...	121.42 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ver...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-ver...	27.84 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-vis...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-vis...	161.29 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-vis...	386 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-vis...	490.88 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-wid...	362 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-wid...	450.54 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-xml...	368 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-xml...	166.75 KB	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-xwi...	365 B	-rw-rw-r--
libMagickCore_7_Q16HDRI_la-xwi...	641.91 KB	-rw-rw-r--
linked-list.c	33.55 KB	-rw-rw-r--
linked-list.h	1.92 KB	-rw-rw-r--
list.c	52.79 KB	-rw-rw-r--
list.h	2.3 KB	-rw-rw-r--
locale-private.h	1.35 KB	-rw-rw-r--
locale.c	58.89 KB	-rw-rw-r--
locale_.h	2.2 KB	-rw-rw-r--
log-private.h	1 KB	-rw-rw-r--
log.c	56.53 KB	-rw-rw-r--
log.h	2.73 KB	-rw-rw-r--
magic-private.h	999 B	-rw-rw-r--
magic.c	27.52 KB	-rw-rw-r--
magic.h	1.32 KB	-rw-rw-r--
magick-baseconfig.h	44.5 KB	-rw-rw-r--
magick-config.h	8.75 KB	-rw-rw-r--
magick-private.h	1.04 KB	-rw-rw-r--
magick-type.h	5.78 KB	-rw-rw-r--
magick.c	66.91 KB	-rw-rw-r--
magick.h	4.18 KB	-rw-rw-r--
matrix-private.h	1.1 KB	-rw-rw-r--
matrix.c	38.14 KB	-rw-rw-r--
matrix.h	1.53 KB	-rw-rw-r--
memory-private.h	1.49 KB	-rw-rw-r--
memory.c	51.43 KB	-rw-rw-r--
memory_.h	3.24 KB	-rw-rw-r--
method-attribute.h	4.03 KB	-rw-rw-r--
methods-private.h	0 B	-rw-rw-r--
methods.h	79.51 KB	-rw-rw-r--
mime-private.h	1.07 KB	-rw-rw-r--
mime.c	35.56 KB	-rw-rw-r--
mime.h	1.38 KB	-rw-rw-r--
module-private.h	1.05 KB	-rw-rw-r--
module.c	56.79 KB	-rw-rw-r--
module.h	1.99 KB	-rw-rw-r--
monitor-private.h	1023 B	-rw-rw-r--
monitor.c	10.83 KB	-rw-rw-r--
monitor.h	1.56 KB	-rw-rw-r--
montage.c	32.5 KB	-rw-rw-r--
montage.h	1.78 KB	-rw-rw-r--
morphology-private.h	1.17 KB	-rw-rw-r--
morphology.c	177.3 KB	-rw-rw-r--
morphology.h	4.45 KB	-rw-rw-r--
mutex.h	3.03 KB	-rw-rw-r--
nt-base-private.h	3.26 KB	-rw-rw-r--
nt-base.c	90.09 KB	-rw-rw-r--
nt-base.h	8.03 KB	-rw-rw-r--
nt-feature.c	13.72 KB	-rw-rw-r--
nt-feature.h	1.11 KB	-rw-rw-r--
opencl-private.h	14.79 KB	-rw-rw-r--
opencl.c	104.16 KB	-rw-rw-r--
opencl.h	1.98 KB	-rw-rw-r--
option-private.h	872 B	-rw-rw-r--
option.c	168.81 KB	-rw-rw-r--
option.h	6.26 KB	-rw-rw-r--
paint.c	42.91 KB	-rw-rw-r--
paint.h	1.62 KB	-rw-rw-r--
pixel-accessor.h	28.36 KB	-rw-rw-r--
pixel-private.h	869 B	-rw-rw-r--
pixel.c	202.86 KB	-rw-rw-r--
pixel.h	7.18 KB	-rw-rw-r--
policy-private.h	1.22 KB	-rw-rw-r--
policy.c	41.97 KB	-rw-rw-r--
policy.h	1.88 KB	-rw-rw-r--
prepress.c	6.08 KB	-rw-rw-r--
prepress.h	939 B	-rw-rw-r--
profile-private.h	984 B	-rw-rw-r--
profile.c	85.4 KB	-rw-rw-r--
profile.h	1.64 KB	-rw-rw-r--
property.c	148.71 KB	-rw-rw-r--
property.h	1.66 KB	-rw-rw-r--
quantize.c	133.36 KB	-rw-rw-r--
quantize.h	2.05 KB	-rw-rw-r--
quantum-export.c	124.46 KB	-rw-rw-r--
quantum-import.c	145.28 KB	-rw-rw-r--
quantum-private.h	19.37 KB	-rw-rw-r--
quantum.c	38.9 KB	-rw-rw-r--
quantum.h	5.1 KB	-rw-rw-r--
random-private.h	2.16 KB	-rw-rw-r--
random.c	33.01 KB	-rw-rw-r--
random_.h	1.49 KB	-rw-rw-r--
registry-private.h	1014 B	-rw-rw-r--
registry.c	18.63 KB	-rw-rw-r--
registry.h	1.41 KB	-rw-rw-r--
resample-private.h	2.21 KB	-rw-rw-r--
resample.c	56.74 KB	-rw-rw-r--
resample.h	2.72 KB	-rw-rw-r--
resize-private.h	2.02 KB	-rw-rw-r--
resize.c	149.98 KB	-rw-rw-r--
resize.h	1.71 KB	-rw-rw-r--
resource-private.h	1.11 KB	-rw-rw-r--
resource.c	47.74 KB	-rw-rw-r--
resource_.h	1.69 KB	-rw-rw-r--
segment.c	60.41 KB	-rw-rw-r--
segment.h	1.09 KB	-rw-rw-r--
semaphore-private.h	1009 B	-rw-rw-r--
semaphore.c	16.58 KB	-rw-rw-r--
semaphore.h	1.15 KB	-rw-rw-r--
shear.c	56.66 KB	-rw-rw-r--
shear.h	1.11 KB	-rw-rw-r--
signature-private.h	1.5 KB	-rw-rw-r--
signature.c	28.84 KB	-rw-rw-r--
signature.h	947 B	-rw-rw-r--
splay-tree.c	54.92 KB	-rw-rw-r--
splay-tree.h	1.98 KB	-rw-rw-r--
static.c	13.23 KB	-rw-rw-r--
static.h	10.11 KB	-rw-rw-r--
statistic.c	91.04 KB	-rw-rw-r--
statistic.h	4.25 KB	-rw-rw-r--
stream-private.h	1.04 KB	-rw-rw-r--
stream.c	97.33 KB	-rw-rw-r--
stream.h	1.57 KB	-rw-rw-r--
string-private.h	3.17 KB	-rw-rw-r--
string.c	90.27 KB	-rw-rw-r--
string_.h	3.61 KB	-rw-rw-r--
studio.h	9.23 KB	-rw-rw-r--
thread-private.h	3.87 KB	-rw-rw-r--
thread.c	9.62 KB	-rw-rw-r--
thread_.h	1.59 KB	-rw-rw-r--
threshold.c	81.92 KB	-rw-rw-r--
threshold.h	2.01 KB	-rw-rw-r--
timer-private.h	1.53 KB	-rw-rw-r--
timer.c	21.71 KB	-rw-rw-r--
timer.h	1.57 KB	-rw-rw-r--
token-private.h	4.27 KB	-rw-rw-r--
token.c	30.01 KB	-rw-rw-r--
token.h	1.48 KB	-rw-rw-r--
transform-private.h	997 B	-rw-rw-r--
transform.c	78.58 KB	-rw-rw-r--
transform.h	1.76 KB	-rw-rw-r--
type-private.h	1000 B	-rw-rw-r--
type.c	44.45 KB	-rw-rw-r--
type.h	1.94 KB	-rw-rw-r--
utility-private.h	7.37 KB	-rw-rw-r--
utility.c	60.19 KB	-rw-rw-r--
utility.h	1.62 KB	-rw-rw-r--
version-private.h	984 B	-rw-rw-r--
version.c	22.62 KB	-rw-rw-r--
version.h	3.02 KB	-rw-rw-r--
version.h.in	3.29 KB	-rw-rw-r--
vision.c	49.74 KB	-rw-rw-r--
vision.h	1.22 KB	-rw-rw-r--
visual-effects.c	122.12 KB	-rw-rw-r--
visual-effects.h	2.81 KB	-rw-rw-r--
widget-private.h	2.59 KB	-rw-rw-r--
widget.c	320.79 KB	-rw-rw-r--
widget.h	852 B	-rw-rw-r--
xml-tree-private.h	1.62 KB	-rw-rw-r--
xml-tree.c	93.09 KB	-rw-rw-r--
xml-tree.h	1.46 KB	-rw-rw-r--
xwindow-private.h	11.19 KB	-rw-rw-r--
xwindow.c	338.16 KB	-rw-rw-r--
xwindow.h	1.11 KB	-rw-rw-r--

Code Editor : gem.c

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%                              GGGG  EEEEE  M   M                             %
%                             G      E      MM MM                             %
%                             G GG   EEE    M M M                             %
%                             G   G  E      M   M                             %
%                              GGGG  EEEEE  M   M                             %
%                                                                             %
%                                                                             %
%                    Graphic Gems - Graphic Support Methods                   %
%                                                                             %
%                               Software Design                               %
%                                    Cristy                                   %
%                                 August 1996                                 %
%                                                                             %
%                                                                             %
%  Copyright 1999-2020 ImageMagick Studio LLC, a non-profit organization      %
%  dedicated to making software imaging solutions freely available.           %
%                                                                             %
%  You may not use this file except in compliance with the License.  You may  %
%  obtain a copy of the License at                                            %
%                                                                             %
%    https://imagemagick.org/script/license.php                               %
%                                                                             %
%  Unless required by applicable law or agreed to in writing, software        %
%  distributed under the License is distributed on an "AS IS" BASIS,          %
%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
%  See the License for the specific language governing permissions and        %
%  limitations under the License.                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
%
*/

/*
  Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/color-private.h"
#include "MagickCore/draw.h"
#include "MagickCore/gem.h"
#include "MagickCore/gem-private.h"
#include "MagickCore/image.h"
#include "MagickCore/image-private.h"
#include "MagickCore/log.h"
#include "MagickCore/memory_.h"
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/pixel-private.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/random_.h"
#include "MagickCore/resize.h"
#include "MagickCore/transform.h"
#include "MagickCore/signature-private.h"

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H C L T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHCLToRGB() transforms a (hue, chroma, luma) to a (red, green,
%  blue) triple.
%
%  The format of the ConvertHCLToRGBImage method is:
%
%      void ConvertHCLToRGB(const double hue,const double chroma,
%        const double luma,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, chroma, luma: A double value representing a component of the
%      HCL color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHCLToRGB(const double hue,const double chroma,
  const double luma,double *red,double *green,double *blue)
{
  double
    b,
    c,
    g,
    h,
    m,
    r,
    x;

/*
    Convert HCL to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  h=6.0*hue;
  c=chroma;
  x=c*(1.0-fabs(fmod(h,2.0)-1.0));
  r=0.0;
  g=0.0;
  b=0.0;
  if ((0.0 <= h) && (h < 1.0))
    {
      r=c;
      g=x;
    }
  else
    if ((1.0 <= h) && (h < 2.0))
      {
        r=x;
        g=c;
      }
    else
      if ((2.0 <= h) && (h < 3.0))
        {
          g=c;
          b=x;
        }
      else
        if ((3.0 <= h) && (h < 4.0))
          {
            g=x;
            b=c;
          }
        else
          if ((4.0 <= h) && (h < 5.0))
            {
              r=x;
              b=c;
            }
          else
            if ((5.0 <= h) && (h < 6.0))
              {
                r=c;
                b=x;
              }
  m=luma-(0.298839*r+0.586811*g+0.114350*b);
  *red=QuantumRange*(r+m);
  *green=QuantumRange*(g+m);
  *blue=QuantumRange*(b+m);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H C L p T o R G B                                           %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHCLpToRGB() transforms a (hue, chroma, luma) to a (red, green,
%  blue) triple.  Since HCL colorspace is wider than RGB, we instead choose a
%  saturation strategy to project it on the RGB cube.
%
%  The format of the ConvertHCLpToRGBImage method is:
%
%      void ConvertHCLpToRGB(const double hue,const double chroma,
%        const double luma,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, chroma, luma: A double value representing a componenet of the
%      HCLp color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHCLpToRGB(const double hue,const double chroma,
  const double luma,double *red,double *green,double *blue)
{
  double
    b,
    c,
    g,
    h,
    m,
    r,
    x,
    z;

/*
    Convert HCLp to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  h=6.0*hue;
  c=chroma;
  x=c*(1.0-fabs(fmod(h,2.0)-1.0));
  r=0.0;
  g=0.0;
  b=0.0;
  if ((0.0 <= h) && (h < 1.0))
    {
      r=c;
      g=x;
    }
  else
    if ((1.0 <= h) && (h < 2.0))
      {
        r=x;
        g=c;
      }
    else
      if ((2.0 <= h) && (h < 3.0))
        {
          g=c;
          b=x;
        }
      else
        if ((3.0 <= h) && (h < 4.0))
          {
            g=x;
            b=c;
          }
        else
          if ((4.0 <= h) && (h < 5.0))
            {
              r=x;
              b=c;
            }
          else
            if ((5.0 <= h) && (h < 6.0))
              {
                r=c;
                b=x;
              }
  m=luma-(0.298839*r+0.586811*g+0.114350*b);
  z=1.0;
  if (m < 0.0)
    {
      z=luma/(luma-m);
      m=0.0;
    }
  else
    if (m+c > 1.0)
      {
        z=(1.0-luma)/(m+c-luma);
        m=1.0-z*c;
      }
  *red=QuantumRange*(z*r+m);
  *green=QuantumRange*(z*g+m);
  *blue=QuantumRange*(z*b+m);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H S B T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHSBToRGB() transforms a (hue, saturation, brightness) to a (red,
%  green, blue) triple.
%
%  The format of the ConvertHSBToRGBImage method is:
%
%      void ConvertHSBToRGB(const double hue,const double saturation,
%        const double brightness,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, saturation, brightness: A double value representing a
%      component of the HSB color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHSBToRGB(const double hue,const double saturation,
  const double brightness,double *red,double *green,double *blue)
{
  double
    f,
    h,
    p,
    q,
    t;

/*
    Convert HSB to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  if (fabs(saturation) < MagickEpsilon)
    {
      *red=QuantumRange*brightness;
      *green=(*red);
      *blue=(*red);
      return;
    }
  h=6.0*(hue-floor(hue));
  f=h-floor((double) h);
  p=brightness*(1.0-saturation);
  q=brightness*(1.0-saturation*f);
  t=brightness*(1.0-(saturation*(1.0-f)));
  switch ((int) h)
  {
    case 0:
    default:
    {
      *red=QuantumRange*brightness;
      *green=QuantumRange*t;
      *blue=QuantumRange*p;
      break;
    }
    case 1:
    {
      *red=QuantumRange*q;
      *green=QuantumRange*brightness;
      *blue=QuantumRange*p;
      break;
    }
    case 2:
    {
      *red=QuantumRange*p;
      *green=QuantumRange*brightness;
      *blue=QuantumRange*t;
      break;
    }
    case 3:
    {
      *red=QuantumRange*p;
      *green=QuantumRange*q;
      *blue=QuantumRange*brightness;
      break;
    }
    case 4:
    {
      *red=QuantumRange*t;
      *green=QuantumRange*p;
      *blue=QuantumRange*brightness;
      break;
    }
    case 5:
    {
      *red=QuantumRange*brightness;
      *green=QuantumRange*p;
      *blue=QuantumRange*q;
      break;
    }
  }
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H S I T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHSIToRGB() transforms a (hue, saturation, intensity) to a (red,
%  green, blue) triple.
%
%  The format of the ConvertHSIToRGBImage method is:
%
%      void ConvertHSIToRGB(const double hue,const double saturation,
%        const double intensity,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, saturation, intensity: A double value representing a
%      component of the HSI color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHSIToRGB(const double hue,const double saturation,
  const double intensity,double *red,double *green,double *blue)
{
  double
    b,
    g,
    h,
    r;

/*
    Convert HSI to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  h=360.0*hue;
  h-=360.0*floor(h/360.0);
  if (h < 120.0)
    {
      b=intensity*(1.0-saturation);
      r=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
        (MagickPI/180.0)));
      g=3.0*intensity-r-b;
    }
  else
    if (h < 240.0)
      {
        h-=120.0;
        r=intensity*(1.0-saturation);
        g=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
          (MagickPI/180.0)));
        b=3.0*intensity-r-g;
      }
    else
      {
        h-=240.0;
        g=intensity*(1.0-saturation);
        b=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
          (MagickPI/180.0)));
        r=3.0*intensity-g-b;
      }
  *red=QuantumRange*r;
  *green=QuantumRange*g;
  *blue=QuantumRange*b;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H S L T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHSLToRGB() transforms a (hue, saturation, lightness) to a (red,
%  green, blue) triple.
%
%  The format of the ConvertHSLToRGBImage method is:
%
%      void ConvertHSLToRGB(const double hue,const double saturation,
%        const double lightness,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, saturation, lightness: A double value representing a
%      component of the HSL color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
  const double lightness,double *red,double *green,double *blue)
{
  double
    c,
    h,
    min,
    x;

/*
    Convert HSL to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  h=hue*360.0;
  if (lightness <= 0.5)
    c=2.0*lightness*saturation;
  else
    c=(2.0-2.0*lightness)*saturation;
  min=lightness-0.5*c;
  h-=360.0*floor(h/360.0);
  h/=60.0;
  x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
  switch ((int) floor(h))
  {
    case 0:
    {
      *red=QuantumRange*(min+c);
      *green=QuantumRange*(min+x);
      *blue=QuantumRange*min;
      break;
    }
    case 1:
    {
      *red=QuantumRange*(min+x);
      *green=QuantumRange*(min+c);
      *blue=QuantumRange*min;
      break;
    }
    case 2:
    {
      *red=QuantumRange*min;
      *green=QuantumRange*(min+c);
      *blue=QuantumRange*(min+x);
      break;
    }
    case 3:
    {
      *red=QuantumRange*min;
      *green=QuantumRange*(min+x);
      *blue=QuantumRange*(min+c);
      break;
    }
    case 4:
    {
      *red=QuantumRange*(min+x);
      *green=QuantumRange*min;
      *blue=QuantumRange*(min+c);
      break;
    }
    case 5:
    {
      *red=QuantumRange*(min+c);
      *green=QuantumRange*min;
      *blue=QuantumRange*(min+x);
      break;
    }
    default:
    {
      *red=0.0;
      *green=0.0;
      *blue=0.0;
    }
  }
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H S V T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHSVToRGB() transforms a (hue, saturation, value) to a (red,
%  green, blue) triple.
%
%  The format of the ConvertHSVToRGBImage method is:
%
%      void ConvertHSVToRGB(const double hue,const double saturation,
%        const double value,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, saturation, value: A double value representing a
%      component of the HSV color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHSVToRGB(const double hue,const double saturation,
  const double value,double *red,double *green,double *blue)
{
  double
    c,
    h,
    min,
    x;

/*
    Convert HSV to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  h=hue*360.0;
  c=value*saturation;
  min=value-c;
  h-=360.0*floor(h/360.0);
  h/=60.0;
  x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
  switch ((int) floor(h))
  {
    case 0:
    {
      *red=QuantumRange*(min+c);
      *green=QuantumRange*(min+x);
      *blue=QuantumRange*min;
      break;
    }
    case 1:
    {
      *red=QuantumRange*(min+x);
      *green=QuantumRange*(min+c);
      *blue=QuantumRange*min;
      break;
    }
    case 2:
    {
      *red=QuantumRange*min;
      *green=QuantumRange*(min+c);
      *blue=QuantumRange*(min+x);
      break;
    }
    case 3:
    {
      *red=QuantumRange*min;
      *green=QuantumRange*(min+x);
      *blue=QuantumRange*(min+c);
      break;
    }
    case 4:
    {
      *red=QuantumRange*(min+x);
      *green=QuantumRange*min;
      *blue=QuantumRange*(min+c);
      break;
    }
    case 5:
    {
      *red=QuantumRange*(min+c);
      *green=QuantumRange*min;
      *blue=QuantumRange*(min+x);
      break;
    }
    default:
    {
      *red=0.0;
      *green=0.0;
      *blue=0.0;
    }
  }
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t H W B T o R G B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertHWBToRGB() transforms a (hue, whiteness, blackness) to a (red, green,
%  blue) triple.
%
%  The format of the ConvertHWBToRGBImage method is:
%
%      void ConvertHWBToRGB(const double hue,const double whiteness,
%        const double blackness,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o hue, whiteness, blackness: A double value representing a
%      component of the HWB color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/
MagickPrivate void ConvertHWBToRGB(const double hue,const double whiteness,
  const double blackness,double *red,double *green,double *blue)
{
  double
    b,
    f,
    g,
    n,
    r,
    v;

/*
    Convert HWB to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  v=1.0-blackness;
  if (fabs(hue-(-1.0)) < MagickEpsilon)
    {
      *red=QuantumRange*v;
      *green=QuantumRange*v;
      *blue=QuantumRange*v;
      return;
    }
  i=(ssize_t) floor(6.0*hue);
  f=6.0*hue-i;
  if ((i & 0x01) != 0)
    f=1.0-f;
  n=whiteness+f*(v-whiteness);  /* linear interpolation */
  switch (i)
  {
    default:
    case 6:
    case 0: r=v; g=n; b=whiteness; break;
    case 1: r=n; g=v; b=whiteness; break;
    case 2: r=whiteness; g=v; b=n; break;
    case 3: r=whiteness; g=n; b=v; break;
    case 4: r=n; g=whiteness; b=v; break;
    case 5: r=v; g=whiteness; b=n; break;
  }
  *red=QuantumRange*r;
  *green=QuantumRange*g;
  *blue=QuantumRange*b;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t L C H a b T o R G B                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertLCHabToRGB() transforms a (luma, chroma, hue) to a (red, green,
%  blue) triple.
%
%  The format of the ConvertLCHabToRGBImage method is:
%
%      void ConvertLCHabToRGB(const double luma,const double chroma,
%        const double hue,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o luma, chroma, hue: A double value representing a component of the
%      LCHab color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/

static inline void ConvertLCHabToXYZ(const double luma,const double chroma,
  const double hue,double *X,double *Y,double *Z)
{
  ConvertLabToXYZ(luma,chroma*cos(hue*MagickPI/180.0),chroma*
    sin(hue*MagickPI/180.0),X,Y,Z);
}

MagickPrivate void ConvertLCHabToRGB(const double luma,const double chroma,
  const double hue,double *red,double *green,double *blue)
{
  double
    X,
    Y,
    Z;

/*
    Convert LCHab to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  ConvertLCHabToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,&X,&Y,&Z);
  ConvertXYZToRGB(X,Y,Z,red,green,blue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t L C H u v T o R G B                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertLCHuvToRGB() transforms a (luma, chroma, hue) to a (red, green,
%  blue) triple.
%
%  The format of the ConvertLCHuvToRGBImage method is:
%
%      void ConvertLCHuvToRGB(const double luma,const double chroma,
%        const double hue,double *red,double *green,double *blue)
%
%  A description of each parameter follows:
%
%    o luma, chroma, hue: A double value representing a component of the
%      LCHuv color space.
%
%    o red, green, blue: A pointer to a pixel component of type Quantum.
%
*/

static inline void ConvertLCHuvToXYZ(const double luma,const double chroma,
  const double hue,double *X,double *Y,double *Z)
{
  ConvertLuvToXYZ(luma,chroma*cos(hue*MagickPI/180.0),chroma*
    sin(hue*MagickPI/180.0),X,Y,Z);
}

MagickPrivate void ConvertLCHuvToRGB(const double luma,const double chroma,
  const double hue,double *red,double *green,double *blue)
{
  double
    X,
    Y,
    Z;

/*
    Convert LCHuv to RGB colorspace.
  */
  assert(red != (double *) NULL);
  assert(green != (double *) NULL);
  assert(blue != (double *) NULL);
  ConvertLCHuvToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,&X,&Y,&Z);
  ConvertXYZToRGB(X,Y,Z,red,green,blue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H C L                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHCL() transforms a (red, green, blue) to a (hue, chroma,
%  luma) triple.
%
%  The format of the ConvertRGBToHCL method is:
%
%      void ConvertRGBToHCL(const double red,const double green,
%        const double blue,double *hue,double *chroma,double *luma)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o hue, chroma, luma: A pointer to a double value representing a
%      component of the HCL color space.
%
*/
MagickPrivate void ConvertRGBToHCL(const double red,const double green,
  const double blue,double *hue,double *chroma,double *luma)
{
  double
    c,
    h,
    max;

/*
    Convert RGB to HCL colorspace.
  */
  assert(hue != (double *) NULL);
  assert(chroma != (double *) NULL);
  assert(luma != (double *) NULL);
  max=MagickMax(red,MagickMax(green,blue));
  c=max-(double) MagickMin(red,MagickMin(green,blue));
  h=0.0;
  if (fabs(c) < MagickEpsilon)
    h=0.0;
  else
    if (fabs(red-max) < MagickEpsilon)
      h=fmod((green-blue)/c+6.0,6.0);
    else
      if (fabs(green-max) < MagickEpsilon)
        h=((blue-red)/c)+2.0;
      else
        if (fabs(blue-max) < MagickEpsilon)
          h=((red-green)/c)+4.0;
  *hue=(h/6.0);
  *chroma=QuantumScale*c;
  *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H C L p                                           %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHCLp() transforms a (red, green, blue) to a (hue, chroma,
%  luma) triple.
%
%  The format of the ConvertRGBToHCLp method is:
%
%      void ConvertRGBToHCLp(const double red,const double green,
%        const double blue,double *hue,double *chroma,double *luma)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o hue, chroma, luma: A pointer to a double value representing a
%      component of the HCL color space.
%
*/
MagickPrivate void ConvertRGBToHCLp(const double red,const double green,
  const double blue,double *hue,double *chroma,double *luma)
{
  double
    c,
    h,
    max;

/*
    Convert RGB to HCL colorspace.
  */
  assert(hue != (double *) NULL);
  assert(chroma != (double *) NULL);
  assert(luma != (double *) NULL);
  max=MagickMax(red,MagickMax(green,blue));
  c=max-MagickMin(red,MagickMin(green,blue));
  h=0.0;
  if (fabs(c) < MagickEpsilon)
    h=0.0;
  else
    if (fabs(red-max) < MagickEpsilon)
      h=fmod((green-blue)/c+6.0,6.0);
    else
      if (fabs(green-max) < MagickEpsilon)
        h=((blue-red)/c)+2.0;
      else
        if (fabs(blue-max) < MagickEpsilon)
          h=((red-green)/c)+4.0;
  *hue=(h/6.0);
  *chroma=QuantumScale*c;
  *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H S B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHSB() transforms a (red, green, blue) to a (hue, saturation,
%  brightness) triple.
%
%  The format of the ConvertRGBToHSB method is:
%
%      void ConvertRGBToHSB(const double red,const double green,
%        const double blue,double *hue,double *saturation,double *brightness)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel..
%
%    o hue, saturation, brightness: A pointer to a double value representing a
%      component of the HSB color space.
%
*/
MagickPrivate void ConvertRGBToHSB(const double red,const double green,
  const double blue,double *hue,double *saturation,double *brightness)
{
  double
    delta,
    max,
    min;

/*
    Convert RGB to HSB colorspace.
  */
  assert(hue != (double *) NULL);
  assert(saturation != (double *) NULL);
  assert(brightness != (double *) NULL);
  *hue=0.0;
  *saturation=0.0;
  *brightness=0.0;
  min=red < green ? red : green;
  if (blue < min)
    min=blue;
  max=red > green ? red : green;
  if (blue > max)
    max=blue;
  if (fabs(max) < MagickEpsilon)
    return;
  delta=max-min;
  *saturation=delta/max;
  *brightness=QuantumScale*max;
  if (fabs(delta) < MagickEpsilon)
    return;
  if (fabs(red-max) < MagickEpsilon)
    *hue=(green-blue)/delta;
  else
    if (fabs(green-max) < MagickEpsilon)
      *hue=2.0+(blue-red)/delta;
    else
      *hue=4.0+(red-green)/delta;
  *hue/=6.0;
  if (*hue < 0.0)
    *hue+=1.0;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H S I                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHSI() transforms a (red, green, blue) to a (hue, saturation,
%  intensity) triple.
%
%  The format of the ConvertRGBToHSI method is:
%
%      void ConvertRGBToHSI(const double red,const double green,
%        const double blue,double *hue,double *saturation,double *intensity)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel..
%
%    o hue, saturation, intensity: A pointer to a double value representing a
%      component of the HSI color space.
%
*/
MagickPrivate void ConvertRGBToHSI(const double red,const double green,
  const double blue,double *hue,double *saturation,double *intensity)
{
  double
    alpha,
    beta;

/*
    Convert RGB to HSI colorspace.
  */
  assert(hue != (double *) NULL);
  assert(saturation != (double *) NULL);
  assert(intensity != (double *) NULL);
  *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
  if (*intensity <= 0.0)
    {
      *hue=0.0;
      *saturation=0.0;
      return;
    }
  *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
    QuantumScale*blue))/(*intensity);
  alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
  beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
  *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
  if (*hue < 0.0)
    *hue+=1.0;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H S L                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
%  lightness) triple.
%
%  The format of the ConvertRGBToHSL method is:
%
%      void ConvertRGBToHSL(const double red,const double green,
%        const double blue,double *hue,double *saturation,double *lightness)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel..
%
%    o hue, saturation, lightness: A pointer to a double value representing a
%      component of the HSL color space.
%
*/
MagickExport void ConvertRGBToHSL(const double red,const double green,
  const double blue,double *hue,double *saturation,double *lightness)
{
  double
    c,
    max,
    min;

/*
    Convert RGB to HSL colorspace.
  */
  assert(hue != (double *) NULL);
  assert(saturation != (double *) NULL);
  assert(lightness != (double *) NULL);
  max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
    QuantumScale*blue));
  min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
    QuantumScale*blue));
  c=max-min;
  *lightness=(max+min)/2.0;
  if (c <= 0.0)
    {
      *hue=0.0;
      *saturation=0.0;
      return;
    }
  if (fabs(max-QuantumScale*red) < MagickEpsilon)
    {
      *hue=(QuantumScale*green-QuantumScale*blue)/c;
      if ((QuantumScale*green) < (QuantumScale*blue))
        *hue+=6.0;
    }
  else
    if (fabs(max-QuantumScale*green) < MagickEpsilon)
      *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
    else
      *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
  *hue*=60.0/360.0;
  if (*lightness <= 0.5)
    *saturation=c/(2.0*(*lightness));
  else
    *saturation=c/(2.0-2.0*(*lightness));
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H S V                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHSV() transforms a (red, green, blue) to a (hue, saturation,
%  value) triple.
%
%  The format of the ConvertRGBToHSV method is:
%
%      void ConvertRGBToHSV(const double red,const double green,
%        const double blue,double *hue,double *saturation,double *value)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel..
%
%    o hue, saturation, value: A pointer to a double value representing a
%      component of the HSV color space.
%
*/
MagickPrivate void ConvertRGBToHSV(const double red,const double green,
  const double blue,double *hue,double *saturation,double *value)
{
  double
    c,
    max,
    min;

/*
    Convert RGB to HSV colorspace.
  */
  assert(hue != (double *) NULL);
  assert(saturation != (double *) NULL);
  assert(value != (double *) NULL);
  max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
    QuantumScale*blue));
  min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
    QuantumScale*blue));
  c=max-min;
  *value=max;
  if (c <= 0.0)
    {
      *hue=0.0;
      *saturation=0.0;
      return;
    }
  if (fabs(max-QuantumScale*red) < MagickEpsilon)
    {
      *hue=(QuantumScale*green-QuantumScale*blue)/c;
      if ((QuantumScale*green) < (QuantumScale*blue))
        *hue+=6.0;
    }
  else
    if (fabs(max-QuantumScale*green) < MagickEpsilon)
      *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
    else
      *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
  *hue*=60.0/360.0;
  *saturation=c/max;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o H W B                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToHWB() transforms a (red, green, blue) to a (hue, whiteness,
%  blackness) triple.
%
%  The format of the ConvertRGBToHWB method is:
%
%      void ConvertRGBToHWB(const double red,const double green,
%        const double blue,double *hue,double *whiteness,double *blackness)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o hue, whiteness, blackness: A pointer to a double value representing a
%      component of the HWB color space.
%
*/
MagickPrivate void ConvertRGBToHWB(const double red,const double green,
  const double blue,double *hue,double *whiteness,double *blackness)
{
  double
    f,
    p,
    v,
    w;

/*
    Convert RGB to HWB colorspace.
  */
  assert(hue != (double *) NULL);
  assert(whiteness != (double *) NULL);
  assert(blackness != (double *) NULL);
  w=MagickMin(red,MagickMin(green,blue));
  v=MagickMax(red,MagickMax(green,blue));
  *blackness=1.0-QuantumScale*v;
  *whiteness=QuantumScale*w;
  if (fabs(v-w) < MagickEpsilon)
    {
      *hue=(-1.0);
      return;
    }
  f=(fabs(red-w) < MagickEpsilon) ? green-blue :
    ((fabs(green-w) < MagickEpsilon) ? blue-red : red-green);
  p=(fabs(red-w) < MagickEpsilon) ? 3.0 :
    ((fabs(green-w) < MagickEpsilon) ? 5.0 : 1.0);
  *hue=(p-f/(v-1.0*w))/6.0;
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o L a b                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToLab() transforms a (red, green, blue) to a (L, a, b) triple.
%
%  The format of the ConvertRGBToLCHab method is:
%
%      void ConvertRGBToLCHab(const double red,const double green,
%        const double blue,double *L,double *a,double *b)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o L, a, b: A pointer to a double value representing a component of the
%      Lab color space.
%
*/
MagickPrivate void ConvertRGBToLab(const double red,const double green,
  const double blue,double *L,double *a,double *b)
{
  double
    X,
    Y,
    Z;

ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
  ConvertXYZToLab(X,Y,Z,L,a,b);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o L C H a b                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToLCHab() transforms a (red, green, blue) to a (luma, chroma,
%  hue) triple.
%
%  The format of the ConvertRGBToLCHab method is:
%
%      void ConvertRGBToLCHab(const double red,const double green,
%        const double blue,double *luma,double *chroma,double *hue)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o luma, chroma, hue: A pointer to a double value representing a
%      component of the LCH color space.
%
*/

static inline void ConvertXYZToLCHab(const double X,const double Y,
  const double Z,double *luma,double *chroma,double *hue)
{
  double
    a,
    b;

ConvertXYZToLab(X,Y,Z,luma,&a,&b);
  *chroma=hypot(255.0*(a-0.5),255.0*(b-0.5))/255.0+0.5;
  *hue=180.0*atan2(255.0*(b-0.5),255.0*(a-0.5))/MagickPI/360.0;
  if (*hue < 0.0)
    *hue+=1.0;
}

MagickPrivate void ConvertRGBToLCHab(const double red,const double green,
  const double blue,double *luma,double *chroma,double *hue)
{
  double
    X,
    Y,
    Z;

/*
    Convert RGB to LCHab colorspace.
  */
  assert(luma != (double *) NULL);
  assert(chroma != (double *) NULL);
  assert(hue != (double *) NULL);
  ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
  ConvertXYZToLCHab(X,Y,Z,luma,chroma,hue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o n v e r t R G B T o L C H u v                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ConvertRGBToLCHuv() transforms a (red, green, blue) to a (luma, chroma,
%  hue) triple.
%
%  The format of the ConvertRGBToLCHuv method is:
%
%      void ConvertRGBToLCHuv(const double red,const double green,
%        const double blue,double *luma,double *chroma,double *hue)
%
%  A description of each parameter follows:
%
%    o red, green, blue: A Quantum value representing the red, green, and
%      blue component of a pixel.
%
%    o luma, chroma, hue: A pointer to a double value representing a
%      component of the LCHuv color space.
%
*/

static inline void ConvertXYZToLCHuv(const double X,const double Y,
  const double Z,double *luma,double *chroma,double *hue)
{
  double
    u,
    v;

ConvertXYZToLuv(X,Y,Z,luma,&u,&v);
  *chroma=hypot(354.0*u-134.0,262.0*v-140.0)/255.0+0.5;
  *hue=180.0*atan2(262.0*v-140.0,354.0*u-134.0)/MagickPI/360.0;
  if (*hue < 0.0)
    *hue+=1.0;
}

MagickPrivate void ConvertRGBToLCHuv(const double red,const double green,
  const double blue,double *luma,double *chroma,double *hue)
{
  double
    X,
    Y,
    Z;

/*
    Convert RGB to LCHuv colorspace.
  */
  assert(luma != (double *) NULL);
  assert(chroma != (double *) NULL);
  assert(hue != (double *) NULL);
  ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
  ConvertXYZToLCHuv(X,Y,Z,luma,chroma,hue);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   E x p a n d A f f i n e                                                   %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ExpandAffine() computes the affine's expansion factor, i.e. the square root
%  of the factor by which the affine transform affects area. In an affine
%  transform composed of scaling, rotation, shearing, and translation, returns
%  the amount of scaling.
%
%  The format of the ExpandAffine method is:
%
%      double ExpandAffine(const AffineMatrix *affine)
%
%  A description of each parameter follows:
%
%    o expansion: ExpandAffine returns the affine's expansion factor.
%
%    o affine: A pointer the affine transform of type AffineMatrix.
%
*/
MagickExport double ExpandAffine(const AffineMatrix *affine)
{
  assert(affine != (const AffineMatrix *) NULL);
  return(sqrt(fabs(affine->sx*affine->sy-affine->rx*affine->ry)));
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   G e n e r a t e D i f f e r e n t i a l N o i s e                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  GenerateDifferentialNoise() generates differentual noise.
%
%  The format of the GenerateDifferentialNoise method is:
%
%      double GenerateDifferentialNoise(RandomInfo *random_info,
%        const Quantum pixel,const NoiseType noise_type,const double attenuate)
%
%  A description of each parameter follows:
%
%    o random_info: the random info.
%
%    o pixel: noise is relative to this pixel value.
%
%    o noise_type: the type of noise.
%
%    o attenuate:  attenuate the noise.
%
*/
MagickPrivate double GenerateDifferentialNoise(RandomInfo *random_info,
  const Quantum pixel,const NoiseType noise_type,const double attenuate)
{
#define SigmaUniform  (attenuate*0.015625)
#define SigmaGaussian  (attenuate*0.015625)
#define SigmaImpulse  (attenuate*0.1)
#define SigmaLaplacian (attenuate*0.0390625)
#define SigmaMultiplicativeGaussian  (attenuate*0.5)
#define SigmaPoisson  (attenuate*12.5)
#define SigmaRandom  (attenuate)
#define TauGaussian  (attenuate*0.078125)

double
    alpha,
    beta,
    noise,
    sigma;

alpha=GetPseudoRandomValue(random_info);
  switch (noise_type)
  {
    case UniformNoise:
    default:
    {
      noise=(double) (pixel+QuantumRange*SigmaUniform*(alpha-0.5));
      break;
    }
    case GaussianNoise:
    {
      double
        gamma,
        tau;

if (fabs(alpha) < MagickEpsilon)
        alpha=1.0;
      beta=GetPseudoRandomValue(random_info);
      gamma=sqrt(-2.0*log(alpha));
      sigma=gamma*cos((double) (2.0*MagickPI*beta));
      tau=gamma*sin((double) (2.0*MagickPI*beta));
      noise=(double) (pixel+sqrt((double) pixel)*SigmaGaussian*sigma+
        QuantumRange*TauGaussian*tau);
      break;
    }
    case ImpulseNoise:
    {
      if (alpha < (SigmaImpulse/2.0))
        noise=0.0;
      else
        if (alpha >= (1.0-(SigmaImpulse/2.0)))
          noise=(double) QuantumRange;
        else
          noise=(double) pixel;
      break;
    }
    case LaplacianNoise:
    {
      if (alpha <= 0.5)
        {
          if (alpha <= MagickEpsilon)
            noise=(double) (pixel-QuantumRange);
          else
            noise=(double) (pixel+QuantumRange*SigmaLaplacian*log(2.0*alpha)+
              0.5);
          break;
        }
      beta=1.0-alpha;
      if (beta <= (0.5*MagickEpsilon))
        noise=(double) (pixel+QuantumRange);
      else
        noise=(double) (pixel-QuantumRange*SigmaLaplacian*log(2.0*beta)+0.5);
      break;
    }
    case MultiplicativeGaussianNoise:
    {
      sigma=1.0;
      if (alpha > MagickEpsilon)
        sigma=sqrt(-2.0*log(alpha));
      beta=GetPseudoRandomValue(random_info);
      noise=(double) (pixel+pixel*SigmaMultiplicativeGaussian*sigma*
        cos((double) (2.0*MagickPI*beta))/2.0);
      break;
    }
    case PoissonNoise:
    {
      double
        poisson;

poisson=exp(-SigmaPoisson*QuantumScale*pixel);
      for (i=0; alpha > poisson; i++)
      {
        beta=GetPseudoRandomValue(random_info);
        alpha*=beta;
      }
      noise=(double) (QuantumRange*i/SigmaPoisson);
      break;
    }
    case RandomNoise:
    {
      noise=(double) (QuantumRange*SigmaRandom*alpha);
      break;
    }
  }
  return(noise);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   G e t O p t i m a l K e r n e l W i d t h                                 %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  GetOptimalKernelWidth() computes the optimal kernel radius for a convolution
%  filter.  Start with the minimum value of 3 pixels and walk out until we drop
%  below the threshold of one pixel numerical accuracy.
%
%  The format of the GetOptimalKernelWidth method is:
%
%      size_t GetOptimalKernelWidth(const double radius,
%        const double sigma)
%
%  A description of each parameter follows:
%
%    o width: GetOptimalKernelWidth returns the optimal width of a
%      convolution kernel.
%
%    o radius: the radius of the Gaussian, in pixels, not counting the center
%      pixel.
%
%    o sigma: the standard deviation of the Gaussian, in pixels.
%
*/
MagickPrivate size_t GetOptimalKernelWidth1D(const double radius,
  const double sigma)
{
  double
    alpha,
    beta,
    gamma,
    normalize,
    value;

size_t
    width;

ssize_t
    j;

(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
  if (radius > MagickEpsilon)
    return((size_t) (2.0*ceil(radius)+1.0));
  gamma=fabs(sigma);
  if (gamma <= MagickEpsilon)
    return(3UL);
  alpha=PerceptibleReciprocal(2.0*gamma*gamma);
  beta=(double) PerceptibleReciprocal((double) MagickSQ2PI*gamma);
  for (width=5; ; )
  {
    normalize=0.0;
    j=(ssize_t) (width-1)/2;
    for (i=(-j); i <= j; i++)
      normalize+=exp(-((double) (i*i))*alpha)*beta;
    value=exp(-((double) (j*j))*alpha)*beta/normalize;
    if ((value < QuantumScale) || (value < MagickEpsilon))
      break;
    width+=2;
  }
  return((size_t) (width-2));
}

MagickPrivate size_t GetOptimalKernelWidth2D(const double radius,
  const double sigma)
{
  double
    alpha,
    beta,
    gamma,
    normalize,
    value;

size_t
    width;

ssize_t
    j,
    u,
    v;

(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
  if (radius > MagickEpsilon)
    return((size_t) (2.0*ceil(radius)+1.0));
  gamma=fabs(sigma);
  if (gamma <= MagickEpsilon)
    return(3UL);
  alpha=PerceptibleReciprocal(2.0*gamma*gamma);
  beta=(double) PerceptibleReciprocal((double) Magick2PI*gamma*gamma);
  for (width=5; ; )
  {
    normalize=0.0;
    j=(ssize_t) (width-1)/2;
    for (v=(-j); v <= j; v++)
      for (u=(-j); u <= j; u++)
        normalize+=exp(-((double) (u*u+v*v))*alpha)*beta;
    value=exp(-((double) (j*j))*alpha)*beta/normalize;
    if ((value < QuantumScale) || (value < MagickEpsilon))
      break;
    width+=2;
  }
  return((size_t) (width-2));
}

MagickPrivate size_t  GetOptimalKernelWidth(const double radius,
  const double sigma)
{
  return(GetOptimalKernelWidth1D(radius,sigma));
}

${this.title}

Code Editor : gem.c