mirror of
https://github.com/imagemagick/imagemagick
synced 2024-10-18 17:02:34 +00:00
This commit is contained in:
cristy
parent
a24b245fac
commit
0a39a5c567
|
|
@ -303,7 +303,7 @@ Magick::ColorHSL::ColorHSL ( double hue_,
|
|||
{
|
||||
double red, green, blue;
|
||||
|
||||
ConvertHSLTosRGB ( hue_,
|
||||
ConvertHSLToRGB ( hue_,
|
||||
saturation_,
|
||||
luminosity_,
|
||||
&red,
|
||||
|
|
@ -337,7 +337,7 @@ Magick::ColorHSL::~ColorHSL ( )
|
|||
void Magick::ColorHSL::hue ( double hue_ )
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
@ -347,7 +347,7 @@ void Magick::ColorHSL::hue ( double hue_ )
|
|||
hue_val = hue_;
|
||||
|
||||
double red, green, blue;
|
||||
ConvertHSLTosRGB ( hue_val,
|
||||
ConvertHSLToRGB ( hue_val,
|
||||
saturation_val,
|
||||
luminosity_val,
|
||||
&red,
|
||||
|
|
@ -363,7 +363,7 @@ void Magick::ColorHSL::hue ( double hue_ )
|
|||
double Magick::ColorHSL::hue ( void ) const
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
@ -375,7 +375,7 @@ double Magick::ColorHSL::hue ( void ) const
|
|||
void Magick::ColorHSL::saturation ( double saturation_ )
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
@ -385,7 +385,7 @@ void Magick::ColorHSL::saturation ( double saturation_ )
|
|||
saturation_val = saturation_;
|
||||
|
||||
double red, green, blue;
|
||||
ConvertHSLTosRGB ( hue_val,
|
||||
ConvertHSLToRGB ( hue_val,
|
||||
saturation_val,
|
||||
luminosity_val,
|
||||
&red,
|
||||
|
|
@ -401,7 +401,7 @@ void Magick::ColorHSL::saturation ( double saturation_ )
|
|||
double Magick::ColorHSL::saturation ( void ) const
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
@ -413,7 +413,7 @@ double Magick::ColorHSL::saturation ( void ) const
|
|||
void Magick::ColorHSL::luminosity ( double luminosity_ )
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
@ -423,7 +423,7 @@ void Magick::ColorHSL::luminosity ( double luminosity_ )
|
|||
luminosity_val = luminosity_;
|
||||
|
||||
double red, green, blue;
|
||||
ConvertHSLTosRGB ( hue_val,
|
||||
ConvertHSLToRGB ( hue_val,
|
||||
saturation_val,
|
||||
luminosity_val,
|
||||
&red,
|
||||
|
|
@ -439,7 +439,7 @@ void Magick::ColorHSL::luminosity ( double luminosity_ )
|
|||
double Magick::ColorHSL::luminosity ( void ) const
|
||||
{
|
||||
double hue_val, saturation_val, luminosity_val;
|
||||
ConvertsRGBToHSL ( redQuantum(),
|
||||
ConvertRGBToHSL ( redQuantum(),
|
||||
greenQuantum(),
|
||||
blueQuantum(),
|
||||
&hue_val,
|
||||
|
|
|
|||
|
|
@ -606,8 +606,8 @@ namespace Magick
|
|||
using MagickCore::ConfigureWarning;
|
||||
using MagickCore::ConstituteImage;
|
||||
using MagickCore::ContrastImage;
|
||||
using MagickCore::ConvertHSLTosRGB;
|
||||
using MagickCore::ConvertsRGBToHSL;
|
||||
using MagickCore::ConvertHSLToRGB;
|
||||
using MagickCore::ConvertRGBToHSL;
|
||||
using MagickCore::ConvolveImage;
|
||||
using MagickCore::CopyMagickString;
|
||||
using MagickCore::CorruptImageError;
|
||||
|
|
|
|||
|
|
@ -2370,16 +2370,16 @@ MagickExport MagickBooleanType QueryColorCompliance(const char *name,
|
|||
geometry_info.sigma*=scale;
|
||||
geometry_info.xi*=scale;
|
||||
if (LocaleCompare(colorspace,"HSB") == 0)
|
||||
ConvertHSBTosRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
ConvertHSBToRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
|
||||
&pixel.green,&pixel.blue);
|
||||
else
|
||||
if (LocaleCompare(colorspace,"HSL") == 0)
|
||||
ConvertHSLTosRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
ConvertHSLToRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
|
||||
&pixel.green,&pixel.blue);
|
||||
else
|
||||
ConvertHWBTosRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
ConvertHWBToRGB(fmod(fmod(geometry_info.rho,360.0)+360.0,360.0)/
|
||||
360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
|
||||
&pixel.green,&pixel.blue);
|
||||
color->colorspace=sRGBColorspace;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ extern "C" {
|
|||
#include <MagickCore/pixel.h>
|
||||
#include <MagickCore/pixel-accessor.h>
|
||||
|
||||
static inline void ConvertsRGBToCMYK(PixelInfo *pixel)
|
||||
static inline void ConvertRGBToCMYK(PixelInfo *pixel)
|
||||
{
|
||||
MagickRealType
|
||||
black,
|
||||
|
|
@ -38,9 +38,9 @@ static inline void ConvertsRGBToCMYK(PixelInfo *pixel)
|
|||
red,
|
||||
yellow;
|
||||
|
||||
red=DecompandsRGB(QuantumScale*pixel->red);
|
||||
green=DecompandsRGB(QuantumScale*pixel->green);
|
||||
blue=DecompandsRGB(QuantumScale*pixel->blue);
|
||||
red=QuantumScale*pixel->red;
|
||||
green=QuantumScale*pixel->green;
|
||||
blue=QuantumScale*pixel->blue;
|
||||
if ((fabs(red) < MagickEpsilon) && (fabs(green) < MagickEpsilon) &&
|
||||
(fabs(blue) < MagickEpsilon))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ static MagickBooleanType
|
|||
%
|
||||
*/
|
||||
|
||||
static inline void ConvertsRGBToXYZ(const Quantum red,const Quantum green,
|
||||
static inline void ConvertRGBToXYZ(const Quantum red,const Quantum green,
|
||||
const Quantum blue,double *X,double *Y,double *Z)
|
||||
{
|
||||
double
|
||||
|
|
@ -126,9 +126,9 @@ static inline void ConvertsRGBToXYZ(const Quantum red,const Quantum green,
|
|||
assert(X != (double *) NULL);
|
||||
assert(Y != (double *) NULL);
|
||||
assert(Z != (double *) NULL);
|
||||
r=DecompandsRGB(QuantumScale*red);
|
||||
g=DecompandsRGB(QuantumScale*green);
|
||||
b=DecompandsRGB(QuantumScale*blue);
|
||||
r=QuantumScale*red;
|
||||
g=QuantumScale*green;
|
||||
b=QuantumScale*blue;
|
||||
*X=0.4360747*r+0.3850649*g+0.1430804*b;
|
||||
*Y=0.2225045*r+0.7168786*g+0.0606169*b;
|
||||
*Z=0.0139322*r+0.0971045*g+0.7141733*b;
|
||||
|
|
@ -332,7 +332,10 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
GetPixelInfoPixel(image,q,&pixel);
|
||||
ConvertsRGBToCMYK(&pixel);
|
||||
pixel.red=QuantumRange*DecompandsRGB(QuantumScale*pixel.red);
|
||||
pixel.green=QuantumRange*DecompandsRGB(QuantumScale*pixel.green);
|
||||
pixel.blue=QuantumRange*DecompandsRGB(QuantumScale*pixel.blue);
|
||||
ConvertRGBToCMYK(&pixel);
|
||||
SetPixelInfoPixel(image,&pixel,q);
|
||||
q+=GetPixelChannels(image);
|
||||
}
|
||||
|
|
@ -457,9 +460,15 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
brightness=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToHSB((double) GetPixelRed(image,q),
|
||||
(double) GetPixelGreen(image,q),(double) GetPixelBlue(image,q),
|
||||
&hue,&saturation,&brightness);
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
red=QuantumRange*DecompandsRGB(QuantumScale*GetPixelRed(image,q));
|
||||
green=QuantumRange*DecompandsRGB(QuantumScale*GetPixelGreen(image,q));
|
||||
blue=QuantumRange*DecompandsRGB(QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertRGBToHSB(red,green,blue,&hue,&saturation,&brightness);
|
||||
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
hue),q);
|
||||
SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
|
|
@ -524,9 +533,15 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
lightness=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToHSL((double) GetPixelRed(image,q),(double)
|
||||
GetPixelGreen(image,q),(double) GetPixelBlue(image,q),
|
||||
&hue,&saturation,&lightness);
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
red=QuantumRange*DecompandsRGB(QuantumScale*GetPixelRed(image,q));
|
||||
green=QuantumRange*DecompandsRGB(QuantumScale*GetPixelGreen(image,q));
|
||||
blue=QuantumRange*DecompandsRGB(QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertRGBToHSL(red,green,blue,&hue,&saturation,&lightness);
|
||||
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
hue),q);
|
||||
SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
|
|
@ -591,9 +606,15 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
blackness=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToHWB((double) GetPixelRed(image,q),(double)
|
||||
GetPixelGreen(image,q),(double) GetPixelBlue(image,q),
|
||||
&hue,&whiteness,&blackness);
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
red=QuantumRange*DecompandsRGB(QuantumScale*GetPixelRed(image,q));
|
||||
green=QuantumRange*DecompandsRGB(QuantumScale*GetPixelGreen(image,q));
|
||||
blue=QuantumRange*DecompandsRGB(QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertRGBToHWB(red,green,blue,&hue,&whiteness,&blackness);
|
||||
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
hue),q);
|
||||
SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
|
|
@ -664,8 +685,15 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
Z=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToXYZ(GetPixelRed(image,q),GetPixelGreen(image,q),
|
||||
GetPixelBlue(image,q),&X,&Y,&Z);
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
red=QuantumRange*DecompandsRGB(QuantumScale*GetPixelRed(image,q));
|
||||
green=QuantumRange*DecompandsRGB(QuantumScale*GetPixelGreen(image,q));
|
||||
blue=QuantumRange*DecompandsRGB(QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
|
||||
ConvertXYZToLab(X,Y,Z,&L,&a,&b);
|
||||
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
|
||||
L),q);
|
||||
|
|
@ -963,8 +991,15 @@ static MagickBooleanType sRGBTransformImage(Image *image,
|
|||
Z=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToXYZ(GetPixelRed(image,q),GetPixelGreen(image,q),
|
||||
GetPixelBlue(image,q),&X,&Y,&Z);
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
red=QuantumRange*DecompandsRGB(QuantumScale*GetPixelRed(image,q));
|
||||
green=QuantumRange*DecompandsRGB(QuantumScale*GetPixelGreen(image,q));
|
||||
blue=QuantumRange*DecompandsRGB(QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
|
||||
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*X),q);
|
||||
SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*Y),
|
||||
q);
|
||||
|
|
@ -1574,8 +1609,8 @@ static inline ssize_t RoundToYCC(const MagickRealType value)
|
|||
return((ssize_t) (value+0.5));
|
||||
}
|
||||
|
||||
static inline void ConvertXYZTosRGB(const double x,const double y,
|
||||
const double z,Quantum *red,Quantum *green,Quantum *blue)
|
||||
static inline void ConvertXYZToRGB(const double x,const double y,
|
||||
const double z,double *red,double *green,double *blue)
|
||||
{
|
||||
double
|
||||
b,
|
||||
|
|
@ -1585,25 +1620,25 @@ static inline void ConvertXYZTosRGB(const double x,const double y,
|
|||
/*
|
||||
Convert XYZ to sRGB colorspace.
|
||||
*/
|
||||
assert(red != (Quantum *) NULL);
|
||||
assert(green != (Quantum *) NULL);
|
||||
assert(blue != (Quantum *) NULL);
|
||||
assert(red != (double *) NULL);
|
||||
assert(green != (double *) NULL);
|
||||
assert(blue != (double *) NULL);
|
||||
r=3.1338561*x-1.6168667*y-0.4906146*z;
|
||||
g=(-0.9787684*x+1.9161415*y+0.0334540*z);
|
||||
b=0.0719453*x-0.2289914*y+1.4052427*z;
|
||||
*red=ClampToQuantum((MagickRealType) QuantumRange*CompandsRGB(r));
|
||||
*green=ClampToQuantum((MagickRealType) QuantumRange*CompandsRGB(g));
|
||||
*blue=ClampToQuantum((MagickRealType) QuantumRange*CompandsRGB(b));
|
||||
*red=QuantumRange*r;
|
||||
*green=QuantumRange*g;
|
||||
*blue=QuantumRange*b;
|
||||
}
|
||||
|
||||
static inline void ConvertCMYKTosRGB(PixelInfo *pixel)
|
||||
static inline void ConvertCMYKToRGB(PixelInfo *pixel)
|
||||
{
|
||||
pixel->red=QuantumRange*CompandsRGB(QuantumScale*(QuantumRange-
|
||||
(QuantumScale*pixel->red*(QuantumRange-pixel->black)+pixel->black)));
|
||||
pixel->green=QuantumRange*CompandsRGB(QuantumScale*(QuantumRange-
|
||||
(QuantumScale*pixel->green*(QuantumRange-pixel->black)+pixel->black)));
|
||||
pixel->blue=QuantumRange*CompandsRGB(QuantumScale*(QuantumRange-
|
||||
(QuantumScale*pixel->blue*(QuantumRange-pixel->black)+pixel->black)));
|
||||
pixel->red=((QuantumRange-(QuantumScale*pixel->red*
|
||||
(QuantumRange-pixel->black)+pixel->black)));
|
||||
pixel->green=((QuantumRange-(QuantumScale*pixel->green*
|
||||
(QuantumRange-pixel->black)+pixel->black)));
|
||||
pixel->blue=((QuantumRange-(QuantumScale*pixel->blue*
|
||||
(QuantumRange-pixel->black)+pixel->black)));
|
||||
}
|
||||
|
||||
static MagickBooleanType TransformsRGBImage(Image *image,
|
||||
|
|
@ -1990,7 +2025,10 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
GetPixelInfoPixel(image,q,&pixel);
|
||||
ConvertCMYKTosRGB(&pixel);
|
||||
ConvertCMYKToRGB(&pixel);
|
||||
pixel.red=QuantumRange*CompandsRGB(QuantumScale*pixel.red);
|
||||
pixel.green=QuantumRange*CompandsRGB(QuantumScale*pixel.green);
|
||||
pixel.blue=QuantumRange*CompandsRGB(QuantumScale*pixel.blue);
|
||||
SetPixelInfoPixel(image,&pixel,q);
|
||||
q+=GetPixelChannels(image);
|
||||
}
|
||||
|
|
@ -2084,9 +2122,9 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
brightness,
|
||||
hue,
|
||||
saturation;
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
MagickBooleanType
|
||||
sync;
|
||||
|
|
@ -2106,17 +2144,23 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
status=MagickFalse;
|
||||
continue;
|
||||
}
|
||||
red=0.0;
|
||||
green=0.0;
|
||||
blue=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
brightness,
|
||||
hue,
|
||||
saturation;
|
||||
|
||||
hue=(double) (QuantumScale*GetPixelRed(image,q));
|
||||
saturation=(double) (QuantumScale*GetPixelGreen(image,q));
|
||||
brightness=(double) (QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertHSBTosRGB(hue,saturation,brightness,&red,&green,&blue);
|
||||
ConvertHSBToRGB(hue,saturation,brightness,&red,&green,&blue);
|
||||
red=QuantumRange*CompandsRGB(QuantumScale*red);
|
||||
green=QuantumRange*CompandsRGB(QuantumScale*green);
|
||||
blue=QuantumRange*CompandsRGB(QuantumScale*blue);
|
||||
SetPixelRed(image,ClampToQuantum(red),q);
|
||||
SetPixelGreen(image,ClampToQuantum(green),q);
|
||||
SetPixelBlue(image,ClampToQuantum(blue),q);
|
||||
|
|
@ -2151,9 +2195,9 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
hue,
|
||||
lightness,
|
||||
saturation;
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
MagickBooleanType
|
||||
sync;
|
||||
|
|
@ -2173,17 +2217,23 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
status=MagickFalse;
|
||||
continue;
|
||||
}
|
||||
red=0.0;
|
||||
green=0.0;
|
||||
blue=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
hue,
|
||||
lightness,
|
||||
saturation;
|
||||
|
||||
hue=(double) (QuantumScale*GetPixelRed(image,q));
|
||||
saturation=(double) (QuantumScale*GetPixelGreen(image,q));
|
||||
lightness=(double) (QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertHSLTosRGB(hue,saturation,lightness,&red,&green,&blue);
|
||||
ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
|
||||
red=QuantumRange*CompandsRGB(QuantumScale*red);
|
||||
green=QuantumRange*CompandsRGB(QuantumScale*green);
|
||||
blue=QuantumRange*CompandsRGB(QuantumScale*blue);
|
||||
SetPixelRed(image,ClampToQuantum(red),q);
|
||||
SetPixelGreen(image,ClampToQuantum(green),q);
|
||||
SetPixelBlue(image,ClampToQuantum(blue),q);
|
||||
|
|
@ -2218,9 +2268,9 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
blackness,
|
||||
hue,
|
||||
whiteness;
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
MagickBooleanType
|
||||
sync;
|
||||
|
|
@ -2240,17 +2290,23 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
status=MagickFalse;
|
||||
continue;
|
||||
}
|
||||
red=0.0;
|
||||
green=0.0;
|
||||
blue=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
blackness,
|
||||
hue,
|
||||
whiteness;
|
||||
|
||||
hue=(double) (QuantumScale*GetPixelRed(image,q));
|
||||
whiteness=(double) (QuantumScale*GetPixelGreen(image,q));
|
||||
blackness=(double) (QuantumScale*GetPixelBlue(image,q));
|
||||
ConvertHWBTosRGB(hue,whiteness,blackness,&red,&green,&blue);
|
||||
ConvertHWBToRGB(hue,whiteness,blackness,&red,&green,&blue);
|
||||
red=QuantumRange*CompandsRGB(QuantumScale*red);
|
||||
green=QuantumRange*CompandsRGB(QuantumScale*green);
|
||||
blue=QuantumRange*CompandsRGB(QuantumScale*blue);
|
||||
SetPixelRed(image,ClampToQuantum(red),q);
|
||||
SetPixelGreen(image,ClampToQuantum(green),q);
|
||||
SetPixelBlue(image,ClampToQuantum(blue),q);
|
||||
|
|
@ -2285,13 +2341,16 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
a,
|
||||
b,
|
||||
L,
|
||||
X,
|
||||
Y,
|
||||
Z;
|
||||
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
|
||||
MagickBooleanType
|
||||
sync;
|
||||
|
||||
|
|
@ -2313,18 +2372,24 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
X=0.0;
|
||||
Y=0.0;
|
||||
Z=0.0;
|
||||
red=0.0;
|
||||
green=0.0;
|
||||
blue=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
Quantum
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
double
|
||||
a,
|
||||
b,
|
||||
L;
|
||||
|
||||
L=QuantumScale*GetPixelRed(image,q);
|
||||
a=QuantumScale*GetPixelGreen(image,q);
|
||||
b=QuantumScale*GetPixelBlue(image,q);
|
||||
ConvertLabToXYZ(L,a,b,&X,&Y,&Z);
|
||||
ConvertXYZTosRGB(X,Y,Z,&red,&green,&blue);
|
||||
ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
|
||||
red=QuantumRange*CompandsRGB(QuantumScale*red);
|
||||
green=QuantumRange*CompandsRGB(QuantumScale*green);
|
||||
blue=QuantumRange*CompandsRGB(QuantumScale*blue);
|
||||
SetPixelRed(image,red,q);
|
||||
SetPixelGreen(image,green,q);
|
||||
SetPixelBlue(image,blue,q);
|
||||
|
|
@ -2530,6 +2595,11 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
#endif
|
||||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
MagickBooleanType
|
||||
sync;
|
||||
|
||||
|
|
@ -2548,6 +2618,9 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
status=MagickFalse;
|
||||
continue;
|
||||
}
|
||||
red=0.0;
|
||||
green=0.0;
|
||||
blue=0.0;
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
double
|
||||
|
|
@ -2555,15 +2628,13 @@ static MagickBooleanType TransformsRGBImage(Image *image,
|
|||
Y,
|
||||
Z;
|
||||
|
||||
Quantum
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
X=QuantumScale*GetPixelRed(image,q);
|
||||
Y=QuantumScale*GetPixelGreen(image,q);
|
||||
Z=QuantumScale*GetPixelBlue(image,q);
|
||||
ConvertXYZTosRGB(X,Y,Z,&red,&green,&blue);
|
||||
ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
|
||||
red=QuantumRange*CompandsRGB(QuantumScale*red);
|
||||
green=QuantumRange*CompandsRGB(QuantumScale*green);
|
||||
blue=QuantumRange*CompandsRGB(QuantumScale*blue);
|
||||
SetPixelRed(image,red,q);
|
||||
SetPixelGreen(image,green,q);
|
||||
SetPixelBlue(image,blue,q);
|
||||
|
|
|
|||
|
|
@ -2376,7 +2376,7 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
|
|||
|
||||
invalid=distort_image->matte_color;
|
||||
if (distort_image->colorspace == CMYKColorspace)
|
||||
ConvertsRGBToCMYK(&invalid); /* what about other color spaces? */
|
||||
ConvertRGBToCMYK(&invalid); /* what about other color spaces? */
|
||||
for (i=0; i < (ssize_t) distort_image->columns; i++)
|
||||
{
|
||||
/* map pixel coordinate to distortion space coordinate */
|
||||
|
|
|
|||
|
|
@ -856,7 +856,7 @@ static void Contrast(const int sign,double *red,double *green,double *blue)
|
|||
hue=0.0;
|
||||
saturation=0.0;
|
||||
brightness=0.0;
|
||||
ConvertsRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
|
||||
ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
|
||||
brightness+=0.5*sign*(0.5*(sin((double) (MagickPI*(brightness-0.5)))+1.0)-
|
||||
brightness);
|
||||
if (brightness > 1.0)
|
||||
|
|
@ -864,7 +864,7 @@ static void Contrast(const int sign,double *red,double *green,double *blue)
|
|||
else
|
||||
if (brightness < 0.0)
|
||||
brightness=0.0;
|
||||
ConvertHSBTosRGB(hue,saturation,brightness,red,green,blue);
|
||||
ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
|
||||
}
|
||||
|
||||
MagickExport MagickBooleanType ContrastImage(Image *image,
|
||||
|
|
@ -2777,7 +2777,7 @@ static void ModulateHSB(const double percent_hue,
|
|||
assert(red != (double *) NULL);
|
||||
assert(green != (double *) NULL);
|
||||
assert(blue != (double *) NULL);
|
||||
ConvertsRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
|
||||
ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
|
||||
hue+=0.5*(0.01*percent_hue-1.0);
|
||||
while (hue < 0.0)
|
||||
hue+=1.0;
|
||||
|
|
@ -2785,7 +2785,7 @@ static void ModulateHSB(const double percent_hue,
|
|||
hue-=1.0;
|
||||
saturation*=0.01*percent_saturation;
|
||||
brightness*=0.01*percent_brightness;
|
||||
ConvertHSBTosRGB(hue,saturation,brightness,red,green,blue);
|
||||
ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
|
||||
}
|
||||
|
||||
static void ModulateHSL(const double percent_hue,
|
||||
|
|
@ -2803,7 +2803,7 @@ static void ModulateHSL(const double percent_hue,
|
|||
assert(red != (double *) NULL);
|
||||
assert(green != (double *) NULL);
|
||||
assert(blue != (double *) NULL);
|
||||
ConvertsRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
|
||||
ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
|
||||
hue+=0.5*(0.01*percent_hue-1.0);
|
||||
while (hue < 0.0)
|
||||
hue+=1.0;
|
||||
|
|
@ -2811,7 +2811,7 @@ static void ModulateHSL(const double percent_hue,
|
|||
hue-=1.0;
|
||||
saturation*=0.01*percent_saturation;
|
||||
lightness*=0.01*percent_lightness;
|
||||
ConvertHSLTosRGB(hue,saturation,lightness,red,green,blue);
|
||||
ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
|
||||
}
|
||||
|
||||
static void ModulateHWB(const double percent_hue,const double percent_whiteness, const double percent_blackness,double *red,double *green,double *blue)
|
||||
|
|
@ -2827,7 +2827,7 @@ static void ModulateHWB(const double percent_hue,const double percent_whiteness,
|
|||
assert(red != (double *) NULL);
|
||||
assert(green != (double *) NULL);
|
||||
assert(blue != (double *) NULL);
|
||||
ConvertsRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
|
||||
ConvertRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
|
||||
hue+=0.5*(0.01*percent_hue-1.0);
|
||||
while (hue < 0.0)
|
||||
hue+=1.0;
|
||||
|
|
@ -2835,7 +2835,7 @@ static void ModulateHWB(const double percent_hue,const double percent_whiteness,
|
|||
hue-=1.0;
|
||||
blackness*=0.01*percent_blackness;
|
||||
whiteness*=0.01*percent_whiteness;
|
||||
ConvertHWBTosRGB(hue,whiteness,blackness,red,green,blue);
|
||||
ConvertHWBToRGB(hue,whiteness,blackness,red,green,blue);
|
||||
}
|
||||
|
||||
MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
|
||||
|
|
@ -2853,9 +2853,12 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
|
|||
*artifact;
|
||||
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
percent_brightness,
|
||||
percent_hue,
|
||||
percent_saturation;
|
||||
percent_saturation,
|
||||
red;
|
||||
|
||||
GeometryInfo
|
||||
geometry_info;
|
||||
|
|
@ -2884,7 +2887,7 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
|
|||
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
|
||||
if (modulate == (char *) NULL)
|
||||
return(MagickFalse);
|
||||
if (IssRGBColorspace(image->colorspace) == MagickFalse)
|
||||
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
|
||||
(void) TransformImageColorspace(image,sRGBColorspace,exception);
|
||||
flags=ParseGeometry(modulate,&geometry_info);
|
||||
percent_brightness=geometry_info.rho;
|
||||
|
|
@ -2909,31 +2912,33 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
|
|||
dynamic_number_threads(image,image->columns,1,1)
|
||||
#endif
|
||||
for (i=0; i < (ssize_t) image->colors; i++)
|
||||
{
|
||||
red=image->colormap[i].red;
|
||||
green=image->colormap[i].green;
|
||||
blue=image->colormap[i].blue;
|
||||
switch (colorspace)
|
||||
{
|
||||
case HSBColorspace:
|
||||
{
|
||||
ModulateHSB(percent_hue,percent_saturation,percent_brightness,
|
||||
&image->colormap[i].red,&image->colormap[i].green,
|
||||
&image->colormap[i].blue);
|
||||
&red,&green,&blue);
|
||||
break;
|
||||
}
|
||||
case HSLColorspace:
|
||||
default:
|
||||
{
|
||||
ModulateHSL(percent_hue,percent_saturation,percent_brightness,
|
||||
&image->colormap[i].red,&image->colormap[i].green,
|
||||
&image->colormap[i].blue);
|
||||
&red,&green,&blue);
|
||||
break;
|
||||
}
|
||||
case HWBColorspace:
|
||||
{
|
||||
ModulateHWB(percent_hue,percent_saturation,percent_brightness,
|
||||
&image->colormap[i].red,&image->colormap[i].green,
|
||||
&image->colormap[i].blue);
|
||||
&red,&green,&blue);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
Modulate image.
|
||||
|
|
@ -2947,11 +2952,6 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
|
|||
#endif
|
||||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
double
|
||||
blue,
|
||||
green,
|
||||
red;
|
||||
|
||||
register Quantum
|
||||
*restrict q;
|
||||
|
||||
|
|
|
|||
|
|
@ -1651,7 +1651,7 @@ static MagickRealType FxGetSymbol(FxInfo *fx_info,const PixelChannel channel,
|
|||
lightness,
|
||||
saturation;
|
||||
|
||||
ConvertsRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
ConvertRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
&lightness);
|
||||
return(hue);
|
||||
}
|
||||
|
|
@ -1695,7 +1695,7 @@ static MagickRealType FxGetSymbol(FxInfo *fx_info,const PixelChannel channel,
|
|||
lightness,
|
||||
saturation;
|
||||
|
||||
ConvertsRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
ConvertRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
&lightness);
|
||||
return(lightness);
|
||||
}
|
||||
|
|
@ -1770,7 +1770,7 @@ static MagickRealType FxGetSymbol(FxInfo *fx_info,const PixelChannel channel,
|
|||
lightness,
|
||||
saturation;
|
||||
|
||||
ConvertsRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
ConvertRGBToHSL(pixel.red,pixel.green,pixel.blue,&hue,&saturation,
|
||||
&lightness);
|
||||
return(saturation);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,13 +32,13 @@ extern MagickPrivate size_t
|
|||
GetOptimalKernelWidth2D(const double,const double);
|
||||
|
||||
extern MagickPrivate void
|
||||
ConvertHSBTosRGB(const double,const double,const double,double *,double *,
|
||||
ConvertHSBToRGB(const double,const double,const double,double *,double *,
|
||||
double *),
|
||||
ConvertHWBTosRGB(const double,const double,const double,double *,double *,
|
||||
ConvertHWBToRGB(const double,const double,const double,double *,double *,
|
||||
double *),
|
||||
ConvertsRGBToHSB(const double,const double,const double,double *,double *,
|
||||
ConvertRGBToHSB(const double,const double,const double,double *,double *,
|
||||
double *),
|
||||
ConvertsRGBToHWB(const double,const double,const double,double *,double *,
|
||||
ConvertRGBToHWB(const double,const double,const double,double *,double *,
|
||||
double *);
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
|
|
|
|||
140
MagickCore/gem.c
140
MagickCore/gem.c
|
|
@ -63,18 +63,18 @@
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t H S B T o s R G B %
|
||||
% C o n v e r t H S B T o R G B %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertHSBTosRGB() transforms a (hue, saturation, brightness) to a (red,
|
||||
% ConvertHSBToRGB() transforms a (hue, saturation, brightness) to a (red,
|
||||
% green, blue) triple.
|
||||
%
|
||||
% The format of the ConvertHSBTosRGBImage method is:
|
||||
% The format of the ConvertHSBToRGBImage method is:
|
||||
%
|
||||
% void ConvertHSBTosRGB(const double hue,const double saturation,
|
||||
% void ConvertHSBToRGB(const double hue,const double saturation,
|
||||
% const double brightness,double *red,double *green,double *blue)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -85,7 +85,7 @@
|
|||
% o red, green, blue: A pointer to a pixel component of type Quantum.
|
||||
%
|
||||
*/
|
||||
MagickPrivate void ConvertHSBTosRGB(const double hue,const double saturation,
|
||||
MagickPrivate void ConvertHSBToRGB(const double hue,const double saturation,
|
||||
const double brightness,double *red,double *green,double *blue)
|
||||
{
|
||||
double
|
||||
|
|
@ -118,44 +118,44 @@ MagickPrivate void ConvertHSBTosRGB(const double hue,const double saturation,
|
|||
case 0:
|
||||
default:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(brightness);
|
||||
*green=QuantumRange*CompandsRGB(t);
|
||||
*blue=QuantumRange*CompandsRGB(p);
|
||||
*red=QuantumRange*brightness;
|
||||
*green=QuantumRange*t;
|
||||
*blue=QuantumRange*p;
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(q);
|
||||
*green=QuantumRange*CompandsRGB(brightness);
|
||||
*blue=QuantumRange*CompandsRGB(p);
|
||||
*red=QuantumRange*q;
|
||||
*green=QuantumRange*brightness;
|
||||
*blue=QuantumRange*p;
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(p);
|
||||
*green=QuantumRange*CompandsRGB(brightness);
|
||||
*blue=QuantumRange*CompandsRGB(t);
|
||||
*red=QuantumRange*p;
|
||||
*green=QuantumRange*brightness;
|
||||
*blue=QuantumRange*t;
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(p);
|
||||
*green=QuantumRange*CompandsRGB(q);
|
||||
*blue=QuantumRange*CompandsRGB(brightness);
|
||||
*red=QuantumRange*p;
|
||||
*green=QuantumRange*q;
|
||||
*blue=QuantumRange*brightness;
|
||||
break;
|
||||
}
|
||||
case 4:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(t);
|
||||
*green=QuantumRange*CompandsRGB(p);
|
||||
*blue=QuantumRange*CompandsRGB(brightness);
|
||||
*red=QuantumRange*t;
|
||||
*green=QuantumRange*p;
|
||||
*blue=QuantumRange*brightness;
|
||||
break;
|
||||
}
|
||||
case 5:
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(brightness);
|
||||
*green=QuantumRange*CompandsRGB(p);
|
||||
*blue=QuantumRange*CompandsRGB(q);
|
||||
*red=QuantumRange*brightness;
|
||||
*green=QuantumRange*p;
|
||||
*blue=QuantumRange*q;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -166,18 +166,18 @@ MagickPrivate void ConvertHSBTosRGB(const double hue,const double saturation,
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t H S L T o s R G B %
|
||||
% C o n v e r t H S L T o R G B %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertHSLTosRGB() transforms a (hue, saturation, lightness) to a (red,
|
||||
% ConvertHSLToRGB() transforms a (hue, saturation, lightness) to a (red,
|
||||
% green, blue) triple.
|
||||
%
|
||||
% The format of the ConvertHSLTosRGBImage method is:
|
||||
% The format of the ConvertHSLToRGBImage method is:
|
||||
%
|
||||
% void ConvertHSLTosRGB(const double hue,const double saturation,
|
||||
% void ConvertHSLToRGB(const double hue,const double saturation,
|
||||
% const double lightness,double *red,double *green,double *blue)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -189,7 +189,7 @@ MagickPrivate void ConvertHSBTosRGB(const double hue,const double saturation,
|
|||
%
|
||||
*/
|
||||
|
||||
static inline double ConvertHueTosRGB(double m1,double m2,double hue)
|
||||
static inline double ConvertHueToRGB(double m1,double m2,double hue)
|
||||
{
|
||||
if (hue < 0.0)
|
||||
hue+=1.0;
|
||||
|
|
@ -204,7 +204,7 @@ static inline double ConvertHueTosRGB(double m1,double m2,double hue)
|
|||
return(m1);
|
||||
}
|
||||
|
||||
MagickExport void ConvertHSLTosRGB(const double hue,const double saturation,
|
||||
MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
|
||||
const double lightness,double *red,double *green,double *blue)
|
||||
{
|
||||
double
|
||||
|
|
@ -232,12 +232,12 @@ MagickExport void ConvertHSLTosRGB(const double hue,const double saturation,
|
|||
else
|
||||
m2=(lightness+saturation)-(lightness*saturation);
|
||||
m1=2.0*lightness-m2;
|
||||
r=ConvertHueTosRGB(m1,m2,hue+1.0/3.0);
|
||||
g=ConvertHueTosRGB(m1,m2,hue);
|
||||
b=ConvertHueTosRGB(m1,m2,hue-1.0/3.0);
|
||||
*red=QuantumRange*CompandsRGB(r);
|
||||
*green=QuantumRange*CompandsRGB(g);
|
||||
*blue=QuantumRange*CompandsRGB(b);
|
||||
r=ConvertHueToRGB(m1,m2,hue+1.0/3.0);
|
||||
g=ConvertHueToRGB(m1,m2,hue);
|
||||
b=ConvertHueToRGB(m1,m2,hue-1.0/3.0);
|
||||
*red=QuantumRange*r;
|
||||
*green=QuantumRange*g;
|
||||
*blue=QuantumRange*b;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -245,18 +245,18 @@ MagickExport void ConvertHSLTosRGB(const double hue,const double saturation,
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t H W B T o s R G B %
|
||||
% C o n v e r t H W B T o R G B %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertHWBTosRGB() transforms a (hue, whiteness, blackness) to a (red, green,
|
||||
% ConvertHWBToRGB() transforms a (hue, whiteness, blackness) to a (red, green,
|
||||
% blue) triple.
|
||||
%
|
||||
% The format of the ConvertHWBTosRGBImage method is:
|
||||
% The format of the ConvertHWBToRGBImage method is:
|
||||
%
|
||||
% void ConvertHWBTosRGB(const double hue,const double whiteness,
|
||||
% void ConvertHWBToRGB(const double hue,const double whiteness,
|
||||
% const double blackness,double *red,double *green,double *blue)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -267,7 +267,7 @@ MagickExport void ConvertHSLTosRGB(const double hue,const double saturation,
|
|||
% o red, green, blue: A pointer to a pixel component of type Quantum.
|
||||
%
|
||||
*/
|
||||
MagickPrivate void ConvertHWBTosRGB(const double hue,const double whiteness,
|
||||
MagickPrivate void ConvertHWBToRGB(const double hue,const double whiteness,
|
||||
const double blackness,double *red,double *green,double *blue)
|
||||
{
|
||||
double
|
||||
|
|
@ -290,9 +290,9 @@ MagickPrivate void ConvertHWBTosRGB(const double hue,const double whiteness,
|
|||
v=1.0-blackness;
|
||||
if (hue == -1.0)
|
||||
{
|
||||
*red=QuantumRange*CompandsRGB(v);
|
||||
*green=QuantumRange*CompandsRGB(v);
|
||||
*blue=QuantumRange*CompandsRGB(v);
|
||||
*red=QuantumRange*v;
|
||||
*green=QuantumRange*v;
|
||||
*blue=QuantumRange*v;
|
||||
return;
|
||||
}
|
||||
i=(ssize_t) floor(6.0*hue);
|
||||
|
|
@ -311,9 +311,9 @@ MagickPrivate void ConvertHWBTosRGB(const double hue,const double whiteness,
|
|||
case 4: r=n; g=whiteness; b=v; break;
|
||||
case 5: r=v; g=whiteness; b=n; break;
|
||||
}
|
||||
*red=QuantumRange*CompandsRGB(r);
|
||||
*green=QuantumRange*CompandsRGB(g);
|
||||
*blue=QuantumRange*CompandsRGB(b);
|
||||
*red=QuantumRange*r;
|
||||
*green=QuantumRange*g;
|
||||
*blue=QuantumRange*b;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -321,18 +321,18 @@ MagickPrivate void ConvertHWBTosRGB(const double hue,const double whiteness,
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t s R G B T o H S B %
|
||||
% C o n v e r t R G B T o H S B %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertsRGBToHSB() transforms a (red, green, blue) to a (hue, saturation,
|
||||
% ConvertRGBToHSB() transforms a (red, green, blue) to a (hue, saturation,
|
||||
% brightness) triple.
|
||||
%
|
||||
% The format of the ConvertsRGBToHSB method is:
|
||||
% The format of the ConvertRGBToHSB method is:
|
||||
%
|
||||
% void ConvertsRGBToHSB(const double red,const double green,
|
||||
% void ConvertRGBToHSB(const double red,const double green,
|
||||
% const double blue,double *hue,double *saturation,double *brightness)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -344,7 +344,7 @@ MagickPrivate void ConvertHWBTosRGB(const double hue,const double whiteness,
|
|||
% component of the HSB color space.
|
||||
%
|
||||
*/
|
||||
MagickPrivate void ConvertsRGBToHSB(const double red,const double green,
|
||||
MagickPrivate void ConvertRGBToHSB(const double red,const double green,
|
||||
const double blue,double *hue,double *saturation,double *brightness)
|
||||
{
|
||||
double
|
||||
|
|
@ -364,9 +364,9 @@ MagickPrivate void ConvertsRGBToHSB(const double red,const double green,
|
|||
*hue=0.0;
|
||||
*saturation=0.0;
|
||||
*brightness=0.0;
|
||||
r=QuantumRange*DecompandsRGB(QuantumScale*red);
|
||||
g=QuantumRange*DecompandsRGB(QuantumScale*green);
|
||||
b=QuantumRange*DecompandsRGB(QuantumScale*blue);
|
||||
r=red;
|
||||
g=green;
|
||||
b=blue;
|
||||
min=r < g ? r : g;
|
||||
if (b < min)
|
||||
min=b;
|
||||
|
|
@ -397,18 +397,18 @@ MagickPrivate void ConvertsRGBToHSB(const double red,const double green,
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t s R G B T o H S L %
|
||||
% C o n v e r t R G B T o H S L %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertsRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
|
||||
% ConvertRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
|
||||
% lightness) triple.
|
||||
%
|
||||
% The format of the ConvertsRGBToHSL method is:
|
||||
% The format of the ConvertRGBToHSL method is:
|
||||
%
|
||||
% void ConvertsRGBToHSL(const double red,const double green,
|
||||
% void ConvertRGBToHSL(const double red,const double green,
|
||||
% const double blue,double *hue,double *saturation,double *lightness)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -435,7 +435,7 @@ static inline double MagickMin(const double x,const double y)
|
|||
return(y);
|
||||
}
|
||||
|
||||
MagickExport void ConvertsRGBToHSL(const double red,const double green,
|
||||
MagickExport void ConvertRGBToHSL(const double red,const double green,
|
||||
const double blue,double *hue,double *saturation,double *lightness)
|
||||
{
|
||||
double
|
||||
|
|
@ -452,9 +452,9 @@ MagickExport void ConvertsRGBToHSL(const double red,const double green,
|
|||
assert(hue != (double *) NULL);
|
||||
assert(saturation != (double *) NULL);
|
||||
assert(lightness != (double *) NULL);
|
||||
r=DecompandsRGB(QuantumScale*red);
|
||||
g=DecompandsRGB(QuantumScale*green);
|
||||
b=DecompandsRGB(QuantumScale*blue);
|
||||
r=QuantumScale*red;
|
||||
g=QuantumScale*green;
|
||||
b=QuantumScale*blue;
|
||||
max=MagickMax(r,MagickMax(g,b));
|
||||
min=MagickMin(r,MagickMin(g,b));
|
||||
*lightness=(double) ((min+max)/2.0);
|
||||
|
|
@ -490,18 +490,18 @@ MagickExport void ConvertsRGBToHSL(const double red,const double green,
|
|||
% %
|
||||
% %
|
||||
% %
|
||||
% C o n v e r t s R G B T o H W B %
|
||||
% C o n v e r t R G B T o H W B %
|
||||
% %
|
||||
% %
|
||||
% %
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%
|
||||
% ConvertsRGBToHWB() transforms a (red, green, blue) to a (hue, whiteness,
|
||||
% ConvertRGBToHWB() transforms a (red, green, blue) to a (hue, whiteness,
|
||||
% blackness) triple.
|
||||
%
|
||||
% The format of the ConvertsRGBToHWB method is:
|
||||
% The format of the ConvertRGBToHWB method is:
|
||||
%
|
||||
% void ConvertsRGBToHWB(const double red,const double green,
|
||||
% void ConvertRGBToHWB(const double red,const double green,
|
||||
% const double blue,double *hue,double *whiteness,double *blackness)
|
||||
%
|
||||
% A description of each parameter follows:
|
||||
|
|
@ -513,7 +513,7 @@ MagickExport void ConvertsRGBToHSL(const double red,const double green,
|
|||
% component of the HWB color space.
|
||||
%
|
||||
*/
|
||||
MagickPrivate void ConvertsRGBToHWB(const double red,const double green,
|
||||
MagickPrivate void ConvertRGBToHWB(const double red,const double green,
|
||||
const double blue,double *hue,double *whiteness,double *blackness)
|
||||
{
|
||||
double
|
||||
|
|
@ -531,9 +531,9 @@ MagickPrivate void ConvertsRGBToHWB(const double red,const double green,
|
|||
assert(hue != (double *) NULL);
|
||||
assert(whiteness != (double *) NULL);
|
||||
assert(blackness != (double *) NULL);
|
||||
r=QuantumRange*DecompandsRGB(QuantumScale*red);
|
||||
g=QuantumRange*DecompandsRGB(QuantumScale*green);
|
||||
b=QuantumRange*DecompandsRGB(QuantumScale*blue);
|
||||
r=red;
|
||||
g=green;
|
||||
b=blue;
|
||||
w=MagickMin(r,MagickMin(g,b));
|
||||
v=MagickMax(r,MagickMax(g,b));
|
||||
*blackness=1.0-QuantumScale*v;
|
||||
|
|
|
|||
|
|
@ -29,9 +29,9 @@ extern MagickExport double
|
|||
ExpandAffine(const AffineMatrix *);
|
||||
|
||||
extern MagickExport void
|
||||
ConvertHSLTosRGB(const double,const double,const double,double *,double *,
|
||||
ConvertHSLToRGB(const double,const double,const double,double *,double *,
|
||||
double *),
|
||||
ConvertsRGBToHSL(const double,const double,const double,double *,double *,
|
||||
ConvertRGBToHSL(const double,const double,const double,double *,double *,
|
||||
double *);
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
|
|
|
|||
|
|
@ -12,7 +12,9 @@
|
|||
/* #undef AUTOTRACE_DELEGATE */
|
||||
|
||||
/* Define if coders and filters are to be built as modules. */
|
||||
/* #undef BUILD_MODULES */
|
||||
#ifndef MAGICKCORE_BUILD_MODULES
|
||||
#define MAGICKCORE_BUILD_MODULES 1
|
||||
#endif
|
||||
|
||||
/* Define if you have the bzip2 library */
|
||||
#ifndef MAGICKCORE_BZLIB_DELEGATE
|
||||
|
|
@ -106,9 +108,7 @@
|
|||
/* #undef GS_DELEGATE */
|
||||
|
||||
/* Define if you have GVC library */
|
||||
#ifndef MAGICKCORE_GVC_DELEGATE
|
||||
#define MAGICKCORE_GVC_DELEGATE 1
|
||||
#endif
|
||||
/* #undef GVC_DELEGATE */
|
||||
|
||||
/* Define to 1 if you have the `acosh' function. */
|
||||
#ifndef MAGICKCORE_HAVE_ACOSH
|
||||
|
|
@ -219,7 +219,9 @@
|
|||
#endif
|
||||
|
||||
/* Define to 1 if you have the <CL/cl.h> header file. */
|
||||
/* #undef HAVE_CL_CL_H */
|
||||
#ifndef MAGICKCORE_HAVE_CL_CL_H
|
||||
#define MAGICKCORE_HAVE_CL_CL_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <complex.h> header file. */
|
||||
#ifndef MAGICKCORE_HAVE_COMPLEX_H
|
||||
|
|
@ -1188,7 +1190,9 @@
|
|||
#endif
|
||||
|
||||
/* Define if you have JBIG library */
|
||||
/* #undef JBIG_DELEGATE */
|
||||
#ifndef MAGICKCORE_JBIG_DELEGATE
|
||||
#define MAGICKCORE_JBIG_DELEGATE 1
|
||||
#endif
|
||||
|
||||
/* Define if you have JPEG version 2 "Jasper" library */
|
||||
#ifndef MAGICKCORE_JP2_DELEGATE
|
||||
|
|
@ -1229,7 +1233,7 @@
|
|||
|
||||
/* Define to the system default library search path. */
|
||||
#ifndef MAGICKCORE_LT_DLSEARCH_PATH
|
||||
#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/lib64/freetype-freeworld:/usr/lib/llvm:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib64/tracker-0.14:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
|
||||
#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/R/lib:/usr/lib64/atlas:/usr/local/cuda/lib64:/usr/local/cuda/lib:/usr/lib/llvm:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/openmotif:/usr/lib64/qt-3.3/lib:/usr/lib64/tracker-0.14:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
|
||||
#endif
|
||||
|
||||
/* The archive extension */
|
||||
|
|
@ -1263,9 +1267,7 @@
|
|||
/* #undef LT_SHARED_EXT */
|
||||
|
||||
/* Define if you have LZMA library */
|
||||
#ifndef MAGICKCORE_LZMA_DELEGATE
|
||||
#define MAGICKCORE_LZMA_DELEGATE 1
|
||||
#endif
|
||||
/* #undef LZMA_DELEGATE */
|
||||
|
||||
/* Define to prepend to default font search path. */
|
||||
/* #undef MAGICK_FONT_PATH */
|
||||
|
|
@ -1355,7 +1357,9 @@
|
|||
#endif
|
||||
|
||||
/* Define if you have RSVG library */
|
||||
/* #undef RSVG_DELEGATE */
|
||||
#ifndef MAGICKCORE_RSVG_DELEGATE
|
||||
#define MAGICKCORE_RSVG_DELEGATE 1
|
||||
#endif
|
||||
|
||||
/* Define to the type of arg 1 for `select'. */
|
||||
#ifndef MAGICKCORE_SELECT_TYPE_ARG1
|
||||
|
|
@ -1513,7 +1517,9 @@
|
|||
#endif
|
||||
|
||||
/* Define if you have WEBP library */
|
||||
/* #undef WEBP_DELEGATE */
|
||||
#ifndef MAGICKCORE_WEBP_DELEGATE
|
||||
#define MAGICKCORE_WEBP_DELEGATE 1
|
||||
#endif
|
||||
|
||||
/* Define to use the Windows GDI32 library */
|
||||
/* #undef WINGDI32_DELEGATE */
|
||||
|
|
@ -1586,7 +1592,9 @@
|
|||
/* #undef _MINIX */
|
||||
|
||||
/* Define this for the OpenCL Accelerator */
|
||||
/* #undef _OPENCL */
|
||||
#ifndef MAGICKCORE__OPENCL
|
||||
#define MAGICKCORE__OPENCL 1
|
||||
#endif
|
||||
|
||||
/* Define to 2 if the system does not provide POSIX.1 features except with
|
||||
this defined. */
|
||||
|
|
|
|||
|
|
@ -209,12 +209,12 @@ extern "C" {
|
|||
#define ContrastImage PrependMagickMethod(ContrastImage)
|
||||
#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage)
|
||||
#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage)
|
||||
#define ConvertHSBTosRGB PrependMagickMethod(ConvertHSBTosRGB)
|
||||
#define ConvertHSLTosRGB PrependMagickMethod(ConvertHSLTosRGB)
|
||||
#define ConvertHWBTosRGB PrependMagickMethod(ConvertHWBTosRGB)
|
||||
#define ConvertsRGBToHSB PrependMagickMethod(ConvertsRGBToHSB)
|
||||
#define ConvertsRGBToHSL PrependMagickMethod(ConvertsRGBToHSL)
|
||||
#define ConvertsRGBToHWB PrependMagickMethod(ConvertsRGBToHWB)
|
||||
#define ConvertHSBToRGB PrependMagickMethod(ConvertHSBToRGB)
|
||||
#define ConvertHSLToRGB PrependMagickMethod(ConvertHSLToRGB)
|
||||
#define ConvertHWBToRGB PrependMagickMethod(ConvertHWBToRGB)
|
||||
#define ConvertRGBToHSB PrependMagickMethod(ConvertRGBToHSB)
|
||||
#define ConvertRGBToHSL PrependMagickMethod(ConvertRGBToHSL)
|
||||
#define ConvertRGBToHWB PrependMagickMethod(ConvertRGBToHWB)
|
||||
#define ConvolveImage PrependMagickMethod(ConvolveImage)
|
||||
#define ConvolveImage PrependMagickMethod(ConvolveImage)
|
||||
#define CopyMagickMemory PrependMagickMethod(CopyMagickMemory)
|
||||
|
|
|
|||
|
|
@ -27,14 +27,14 @@ extern "C" {
|
|||
*/
|
||||
#define MagickPackageName "ImageMagick"
|
||||
#define MagickCopyright "Copyright (C) 1999-2012 ImageMagick Studio LLC"
|
||||
#define MagickSVNRevision "8354"
|
||||
#define MagickSVNRevision ""
|
||||
#define MagickLibVersion 0x700
|
||||
#define MagickLibVersionText "7.0.0"
|
||||
#define MagickLibVersionNumber 7,0,0
|
||||
#define MagickLibAddendum "-0"
|
||||
#define MagickLibInterface 7
|
||||
#define MagickLibMinInterface 7
|
||||
#define MagickReleaseDate "2012-06-20"
|
||||
#define MagickReleaseDate "2012-06-27"
|
||||
#define MagickChangeDate "20110801"
|
||||
#define MagickAuthoritativeURL "http://www.imagemagick.org"
|
||||
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
||||
|
|
|
|||
|
|
@ -1067,7 +1067,7 @@ WandExport void PixelGetHSL(const PixelWand *wand,double *hue,
|
|||
assert(wand->signature == WandSignature);
|
||||
if (wand->debug != MagickFalse)
|
||||
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
|
||||
ConvertsRGBToHSL((double) ClampToQuantum(wand->pixel.red),(double)
|
||||
ConvertRGBToHSL((double) ClampToQuantum(wand->pixel.red),(double)
|
||||
ClampToQuantum(wand->pixel.green),(double) ClampToQuantum(wand->pixel.blue),
|
||||
hue,saturation,lightness);
|
||||
}
|
||||
|
|
@ -1976,7 +1976,7 @@ WandExport void PixelSetHSL(PixelWand *wand,const double hue,
|
|||
assert(wand->signature == WandSignature);
|
||||
if (wand->debug != MagickFalse)
|
||||
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
|
||||
ConvertHSLTosRGB(hue,saturation,lightness,&red,&green,&blue);
|
||||
ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
|
||||
wand->pixel.red=(MagickRealType) red;
|
||||
wand->pixel.green=(MagickRealType) green;
|
||||
wand->pixel.blue=(MagickRealType) blue;
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ static Image *ReadNULLImage(const ImageInfo *image_info,
|
|||
GetPixelInfo(image,&background);
|
||||
background.alpha=(MagickRealType) TransparentAlpha;
|
||||
if (image->colorspace == CMYKColorspace)
|
||||
ConvertsRGBToCMYK(&background);
|
||||
ConvertRGBToCMYK(&background);
|
||||
for (y=0; y < (ssize_t) image->rows; y++)
|
||||
{
|
||||
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
|
||||
|
|
|
|||
|
|
@ -293,7 +293,9 @@ static MagickBooleanType IsPDFRendered(const char *path)
|
|||
|
||||
static Image *ReadPDFImage(const ImageInfo *image_info,ExceptionInfo *exception)
|
||||
{
|
||||
#define CMYKProcessColor "CMYKProcessColor"
|
||||
#define CropBox "CropBox"
|
||||
#define DefaultCMYK "DefaultCMYK"
|
||||
#define DeviceCMYK "DeviceCMYK"
|
||||
#define MediaBox "MediaBox"
|
||||
#define RenderPostscriptText "Rendering Postscript... "
|
||||
|
|
@ -453,8 +455,12 @@ static Image *ReadPDFImage(const ImageInfo *image_info,ExceptionInfo *exception)
|
|||
/*
|
||||
Is this a CMYK document?
|
||||
*/
|
||||
if (LocaleNCompare(DefaultCMYK,command,strlen(DefaultCMYK)) == 0)
|
||||
cmyk=MagickTrue;
|
||||
if (LocaleNCompare(DeviceCMYK,command,strlen(DeviceCMYK)) == 0)
|
||||
cmyk=MagickTrue;
|
||||
if (LocaleNCompare(CMYKProcessColor,command,strlen(CMYKProcessColor)) == 0)
|
||||
cmyk=MagickTrue;
|
||||
if (LocaleNCompare(SpotColor,command,strlen(SpotColor)) == 0)
|
||||
{
|
||||
char
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ ModuleExport size_t analyzeImage(Image **images,const int argc,
|
|||
}
|
||||
for (x=0; x < (ssize_t) image->columns; x++)
|
||||
{
|
||||
ConvertsRGBToHSL(GetPixelRed(image,p),GetPixelGreen(image,p),
|
||||
ConvertRGBToHSL(GetPixelRed(image,p),GetPixelGreen(image,p),
|
||||
GetPixelBlue(image,p),&hue,&saturation,&brightness);
|
||||
brightness*=QuantumRange;
|
||||
brightness_sum_x+=brightness;
|
||||
|
|
|
|||
Loading…
Reference in a new issue