diff --git a/coders/avs.c b/coders/avs.c
index 6a8031d..c544d77 100644
--- a/coders/avs.c
+++ b/coders/avs.c
@@ -377,9 +377,9 @@
{
*q++=ScaleQuantumToChar((Quantum) (QuantumRange-
(image->matte != MagickFalse ? p->opacity : OpaqueOpacity)));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
diff --git a/coders/bmp.c b/coders/bmp.c
index 86bd1fa..7b33d50 100644
--- a/coders/bmp.c
+++ b/coders/bmp.c
@@ -1143,7 +1143,7 @@
q->red=ScaleShortToQuantum((unsigned short) red);
q->green=ScaleShortToQuantum((unsigned short) green);
q->blue=ScaleShortToQuantum((unsigned short) blue);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
q->opacity=ScaleShortToQuantum((unsigned short) opacity);
q++;
@@ -1231,7 +1231,7 @@
q->red=ScaleShortToQuantum((unsigned short) red);
q->green=ScaleShortToQuantum((unsigned short) green);
q->blue=ScaleShortToQuantum((unsigned short) blue);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
q->opacity=ScaleShortToQuantum((unsigned short) opacity);
q++;
@@ -1732,9 +1732,9 @@
q=pixels+(image->rows-y-1)*bytes_per_line;
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
for (x=3L*(long) image->columns; x < (long) bytes_per_line; x++)
@@ -1761,10 +1761,10 @@
q=pixels+(image->rows-y-1)*bytes_per_line;
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetOpacitySample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetOpacityPixelComponent(p));
p++;
}
if (image->previous == (Image *) NULL)
diff --git a/coders/clipboard.c b/coders/clipboard.c
index af0d5b5..d55fe89 100644
--- a/coders/clipboard.c
+++ b/coders/clipboard.c
@@ -211,7 +211,7 @@
q->red=ScaleCharToQuantum(pBits->rgbRed);
q->green=ScaleCharToQuantum(pBits->rgbGreen);
q->blue=ScaleCharToQuantum(pBits->rgbBlue);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
pBits++;
q++;
}
diff --git a/coders/cmyk.c b/coders/cmyk.c
index f8ac795..91ad393 100644
--- a/coders/cmyk.c
+++ b/coders/cmyk.c
@@ -260,13 +260,13 @@
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
indexes[x]=canvas_indexes[image->extract_info.x+x];
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -353,12 +353,12 @@
{
switch (quantum_type)
{
- case CyanQuantum: SetRedSample(q,GetRedSample(p)); break;
- case MagentaQuantum: SetGreenSample(q,GetGreenSample(p)); break;
- case YellowQuantum: SetBlueSample(q,GetBlueSample(p)); break;
+ case CyanQuantum: SetRedPixelComponent(q,GetRedPixelComponent(p)); break;
+ case MagentaQuantum: SetGreenPixelComponent(q,GetGreenPixelComponent(p)); break;
+ case YellowQuantum: SetBluePixelComponent(q,GetBluePixelComponent(p)); break;
case BlackQuantum: indexes[x]=
canvas_indexes[image->extract_info.x+x];; break;
- case OpacityQuantum: SetOpacitySample(q,GetOpacitySample(p)); break;
+ case OpacityQuantum: SetOpacityPixelComponent(q,GetOpacityPixelComponent(p)); break;
default: break;
}
p++;
@@ -425,7 +425,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
@@ -477,7 +477,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetGreenSample(q,GetGreenSample(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
@@ -529,7 +529,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetBlueSample(q,GetBlueSample(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
@@ -644,7 +644,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -735,7 +735,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
@@ -806,7 +806,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetGreenSample(q,GetGreenSample(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
@@ -877,7 +877,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetBlueSample(q,GetBlueSample(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
@@ -1029,7 +1029,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
diff --git a/coders/cut.c b/coders/cut.c
index 63d842e..18ba8e2 100644
--- a/coders/cut.c
+++ b/coders/cut.c
@@ -483,20 +483,20 @@
image->colormap[i].red=(Quantum) ReadBlobLSBShort(palette);
if (QuantumRange != (Quantum) PalHeader.MaxRed)
{
- image->colormap[i].red=RoundToQuantum(((double)
+ image->colormap[i].red=ClampToQuantum(((double)
image->colormap[i].red*QuantumRange+(PalHeader.MaxRed>>1))/
PalHeader.MaxRed);
}
image->colormap[i].green=(Quantum) ReadBlobLSBShort(palette);
if (QuantumRange != (Quantum) PalHeader.MaxGreen)
{
- image->colormap[i].green=RoundToQuantum
+ image->colormap[i].green=ClampToQuantum
(((double) image->colormap[i].green*QuantumRange+(PalHeader.MaxGreen>>1))/PalHeader.MaxGreen);
}
image->colormap[i].blue=(Quantum) ReadBlobLSBShort(palette);
if (QuantumRange != (Quantum) PalHeader.MaxBlue)
{
- image->colormap[i].blue=RoundToQuantum
+ image->colormap[i].blue=ClampToQuantum
(((double)image->colormap[i].blue*QuantumRange+(PalHeader.MaxBlue>>1))/PalHeader.MaxBlue);
}
diff --git a/coders/dib.c b/coders/dib.c
index 8539541..afe6634 100644
--- a/coders/dib.c
+++ b/coders/dib.c
@@ -1150,9 +1150,9 @@
for (x=0; x < (long) image->columns; x++)
{
word=(unsigned short) ((ScaleColor8to5((unsigned char)
- ScaleQuantumToChar(GetRedSample(p))) << 11) | (ScaleColor8to6((unsigned char)
- ScaleQuantumToChar(GetGreenSample(p))) << 5) | (ScaleColor8to5(
- (unsigned char) ScaleQuantumToChar((unsigned char) GetBlueSample(p)) << 0)));
+ ScaleQuantumToChar(GetRedPixelComponent(p))) << 11) | (ScaleColor8to6((unsigned char)
+ ScaleQuantumToChar(GetGreenPixelComponent(p))) << 5) | (ScaleColor8to5(
+ (unsigned char) ScaleQuantumToChar((unsigned char) GetBluePixelComponent(p)) << 0)));
*q++=(unsigned char)(word & 0xff);
*q++=(unsigned char)(word >> 8);
p++;
@@ -1179,11 +1179,11 @@
q=pixels+(image->rows-y-1)*bytes_per_line;
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
if (image->matte != MagickFalse)
- *q++=ScaleQuantumToChar(GetOpacitySample(p));
+ *q++=ScaleQuantumToChar(GetOpacityPixelComponent(p));
p++;
}
if (dib_info.bits_per_pixel == 24)
diff --git a/coders/dps.c b/coders/dps.c
index c754a13..446cbe4 100644
--- a/coders/dps.c
+++ b/coders/dps.c
@@ -497,7 +497,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (XGetPixel(matte_image,x,y) == 0)
q->opacity=TransparentOpacity;
q++;
diff --git a/coders/emf.c b/coders/emf.c
index 837d4de..86072fa 100644
--- a/coders/emf.c
+++ b/coders/emf.c
@@ -617,7 +617,7 @@
q->red=ScaleCharToQuantum(pBits->rgbRed);
q->green=ScaleCharToQuantum(pBits->rgbGreen);
q->blue=ScaleCharToQuantum(pBits->rgbBlue);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
pBits++;
q++;
}
diff --git a/coders/exr.c b/coders/exr.c
index b785377..0726020 100644
--- a/coders/exr.c
+++ b/coders/exr.c
@@ -224,13 +224,13 @@
ImfInputReadPixels(file,min_y+y,min_y+y);
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
scanline[x].r));
- q->green=RoundToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
scanline[x].g));
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*ImfHalfToFloat(
scanline[x].b));
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange-QuantumRange*
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange-QuantumRange*
ImfHalfToFloat(scanline[x].a));
q++;
}
diff --git a/coders/fits.c b/coders/fits.c
index 6f32bfa..9f6703b 100644
--- a/coders/fits.c
+++ b/coders/fits.c
@@ -445,7 +445,7 @@
for (x=0; x < (long) image->columns; x++)
{
pixel=GetFITSPixel(image,fits_info.bits_per_pixel);
- q->red=(Quantum) RoundToQuantum(scale*(fits_info.scale*(pixel-
+ q->red=(Quantum) ClampToQuantum(scale*(fits_info.scale*(pixel-
fits_info.min_data)+fits_info.zero));
q->green=q->red;
q->blue=q->red;
diff --git a/coders/fpx.c b/coders/fpx.c
index 82d1506..ace1a4f 100644
--- a/coders/fpx.c
+++ b/coders/fpx.c
@@ -471,7 +471,7 @@
q->green=index;
q->blue=index;
}
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
q->opacity=ScaleCharToQuantum(255-*a);
q++;
diff --git a/coders/gray.c b/coders/gray.c
index 9b6a222..bbf5c4e 100644
--- a/coders/gray.c
+++ b/coders/gray.c
@@ -232,9 +232,9 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
diff --git a/coders/hald.c b/coders/hald.c
index 0d1ecda..7408982 100644
--- a/coders/hald.c
+++ b/coders/hald.c
@@ -153,10 +153,10 @@
{
for (red=0; red < (long) cube_size; red++)
{
- q->red=RoundToQuantum(QuantumRange*red/(cube_size-1.0));
- q->green=RoundToQuantum(QuantumRange*green/(cube_size-1.0));
- q->blue=RoundToQuantum(QuantumRange*blue/(cube_size-1.0));
- SetOpacitySample(q,OpaqueOpacity);
+ q->red=ClampToQuantum(QuantumRange*red/(cube_size-1.0));
+ q->green=ClampToQuantum(QuantumRange*green/(cube_size-1.0));
+ q->blue=ClampToQuantum(QuantumRange*blue/(cube_size-1.0));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
diff --git a/coders/histogram.c b/coders/histogram.c
index d6e1597..7c86c3a 100644
--- a/coders/histogram.c
+++ b/coders/histogram.c
@@ -272,11 +272,11 @@
for (x=0; x < (long) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- histogram[ScaleQuantumToChar(GetRedSample(p))].red++;
+ histogram[ScaleQuantumToChar(GetRedPixelComponent(p))].red++;
if ((channel & GreenChannel) != 0)
- histogram[ScaleQuantumToChar(GetGreenSample(p))].green++;
+ histogram[ScaleQuantumToChar(GetGreenPixelComponent(p))].green++;
if ((channel & BlueChannel) != 0)
- histogram[ScaleQuantumToChar(GetBlueSample(p))].blue++;
+ histogram[ScaleQuantumToChar(GetBluePixelComponent(p))].blue++;
p++;
}
}
diff --git a/coders/hrz.c b/coders/hrz.c
index efa1b6c..0be965f 100644
--- a/coders/hrz.c
+++ b/coders/hrz.c
@@ -161,7 +161,7 @@
q->red=4*ScaleCharToQuantum(*p++);
q->green=4*ScaleCharToQuantum(*p++);
q->blue=4*ScaleCharToQuantum(*p++);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -325,9 +325,9 @@
q=pixels;
for (x=0; x < (long) hrz_image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p))/4;
- *q++=ScaleQuantumToChar(GetGreenSample(p))/4;
- *q++=ScaleQuantumToChar(GetBlueSample(p))/4;
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p))/4;
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p))/4;
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p))/4;
p++;
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
diff --git a/coders/icon.c b/coders/icon.c
index 147bd4f..52239bb 100644
--- a/coders/icon.c
+++ b/coders/icon.c
@@ -1079,13 +1079,13 @@
q=pixels+(next->rows-y-1)*bytes_per_line;
for (x=0; x < (long) next->columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
if (next->matte == MagickFalse)
*q++=ScaleQuantumToChar(QuantumRange);
else
- *q++=ScaleQuantumToChar(QuantumRange-GetOpacitySample(p));
+ *q++=ScaleQuantumToChar(QuantumRange-GetOpacityPixelComponent(p));
p++;
}
if (icon_info.bits_per_pixel == 24)
diff --git a/coders/jp2.c b/coders/jp2.c
index 98505a6..91f19ec 100644
--- a/coders/jp2.c
+++ b/coders/jp2.c
@@ -939,7 +939,7 @@
ScaleQuantumToAny(p->blue,range));
if (number_components > 3)
jas_matrix_setv(pixels[3],x,(jas_seqent_t)
- ScaleQuantumToAny((Quantum) (QuantumRange-GetOpacitySample(p)),range));
+ ScaleQuantumToAny((Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range));
}
p++;
}
diff --git a/coders/jpeg.c b/coders/jpeg.c
index 408b7bd..dff4ce5 100644
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -1201,7 +1201,7 @@
(GETJSAMPLE(*p++) << 4));
q->blue=ScaleShortToQuantum((unsigned char)
(GETJSAMPLE(*p++) << 4));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
else
@@ -1213,7 +1213,7 @@
(unsigned char) (GETJSAMPLE(*p++) << 4));
q->blue=(Quantum) QuantumRange-ScaleShortToQuantum((unsigned char)
(GETJSAMPLE(*p++) << 4));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
indexes[x]=(IndexPacket) QuantumRange-ScaleShortToQuantum(
(unsigned char) (GETJSAMPLE(*p++) << 4));
q++;
@@ -1235,7 +1235,7 @@
q->red=ScaleCharToQuantum((unsigned char) GETJSAMPLE(*p++));
q->green=ScaleCharToQuantum((unsigned char) GETJSAMPLE(*p++));
q->blue=ScaleCharToQuantum((unsigned char) GETJSAMPLE(*p++));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
else
@@ -1247,7 +1247,7 @@
GETJSAMPLE(*p++));
q->blue=(Quantum) QuantumRange-ScaleCharToQuantum((unsigned char)
GETJSAMPLE(*p++));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
indexes[x]=(IndexPacket) QuantumRange-ScaleCharToQuantum(
(unsigned char) GETJSAMPLE(*p++));
q++;
@@ -2178,9 +2178,9 @@
q=jpeg_pixels;
for (x=0; x < (long) image->columns; x++)
{
- *q++=(JSAMPLE) (ScaleQuantumToShort(GetRedSample(p)) >> 4);
- *q++=(JSAMPLE) (ScaleQuantumToShort(GetGreenSample(p)) >> 4);
- *q++=(JSAMPLE) (ScaleQuantumToShort(GetBlueSample(p)) >> 4);
+ *q++=(JSAMPLE) (ScaleQuantumToShort(GetRedPixelComponent(p)) >> 4);
+ *q++=(JSAMPLE) (ScaleQuantumToShort(GetGreenPixelComponent(p)) >> 4);
+ *q++=(JSAMPLE) (ScaleQuantumToShort(GetBluePixelComponent(p)) >> 4);
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
@@ -2210,9 +2210,9 @@
/*
Convert DirectClass packets to contiguous CMYK scanlines.
*/
- *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetRedSample(p)) >> 4));
- *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetGreenSample(p)) >> 4));
- *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetBlueSample(p)) >> 4));
+ *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetRedPixelComponent(p)) >> 4));
+ *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetGreenPixelComponent(p)) >> 4));
+ *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(GetBluePixelComponent(p)) >> 4));
*q++=(JSAMPLE) (4095-(ScaleQuantumToShort(indexes[x]) >> 4));
p++;
}
@@ -2262,9 +2262,9 @@
q=jpeg_pixels;
for (x=0; x < (long) image->columns; x++)
{
- *q++=(JSAMPLE) ScaleQuantumToChar(GetRedSample(p));
- *q++=(JSAMPLE) ScaleQuantumToChar(GetGreenSample(p));
- *q++=(JSAMPLE) ScaleQuantumToChar(GetBlueSample(p));
+ *q++=(JSAMPLE) ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=(JSAMPLE) ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=(JSAMPLE) ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
@@ -2294,11 +2294,11 @@
Convert DirectClass packets to contiguous CMYK scanlines.
*/
*q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
- GetRedSample(p))));
+ GetRedPixelComponent(p))));
*q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
- GetGreenSample(p))));
+ GetGreenPixelComponent(p))));
*q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
- GetBlueSample(p))));
+ GetBluePixelComponent(p))));
*q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
indexes[x])));
p++;
diff --git a/coders/matte.c b/coders/matte.c
index e63fa44..1c1983b 100644
--- a/coders/matte.c
+++ b/coders/matte.c
@@ -194,10 +194,10 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- q->red=GetOpacitySample(p);
- q->green=GetOpacitySample(p);
- q->blue=GetOpacitySample(p);
- SetOpacitySample(q,OpaqueOpacity);
+ q->red=GetOpacityPixelComponent(p);
+ q->green=GetOpacityPixelComponent(p);
+ q->blue=GetOpacityPixelComponent(p);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p++;
q++;
}
diff --git a/coders/msl.c b/coders/msl.c
index 1bb30dc..ad5bd67 100644
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -1934,7 +1934,7 @@
for (x=0; x < (long) composite_image->columns; x++)
{
if (q->opacity == OpaqueOpacity)
- q->opacity=RoundToQuantum(opacity);
+ q->opacity=ClampToQuantum(opacity);
q++;
}
if (SyncCacheViewAuthenticPixels(composite_view,&exception) == MagickFalse)
@@ -3746,7 +3746,7 @@
}
draw_info=CloneDrawInfo(msl_info->image_info[n],
msl_info->draw_info[n]);
- draw_info->fill.opacity=RoundToQuantum(opacity);
+ draw_info->fill.opacity=ClampToQuantum(opacity);
(void) FloodfillPaintImage(msl_info->image[n],OpacityChannel,
draw_info,&target,geometry.x,geometry.y,
paint_method == FloodfillMethod ? MagickFalse : MagickTrue);
diff --git a/coders/mtv.c b/coders/mtv.c
index df3115e..f445aa5 100644
--- a/coders/mtv.c
+++ b/coders/mtv.c
@@ -179,7 +179,7 @@
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=ScaleCharToQuantum(*p++);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -379,9 +379,9 @@
q=pixels;
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
diff --git a/coders/palm.c b/coders/palm.c
index 9a26d2a..b77af07 100644
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -471,7 +471,7 @@
q->red=(Quantum) ((QuantumRange*((color16 >> 11) & 0x1f))/0x1f);
q->green=(Quantum) ((QuantumRange*((color16 >> 5) & 0x3f))/0x3f);
q->blue=(Quantum) ((QuantumRange*((color16 >> 0) & 0x1f))/0x1f);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
@@ -844,16 +844,16 @@
{
for (x=0; x < (int) image->columns; x++)
{
- color16=(unsigned short) ((((31*(unsigned long) GetRedSample(p))/
+ color16=(unsigned short) ((((31*(unsigned long) GetRedPixelComponent(p))/
(unsigned long) QuantumRange) << 11) |
- (((63*(unsigned long) GetGreenSample(p))/(unsigned long) QuantumRange) << 5) |
- ((31*(unsigned long) GetBlueSample(p))/(unsigned long) QuantumRange));
+ (((63*(unsigned long) GetGreenPixelComponent(p))/(unsigned long) QuantumRange) << 5) |
+ ((31*(unsigned long) GetBluePixelComponent(p))/(unsigned long) QuantumRange));
if (p->opacity == (Quantum) TransparentOpacity)
{
- transpix.red=GetRedSample(p);
- transpix.green=GetGreenSample(p);
- transpix.blue=GetBlueSample(p);
- transpix.opacity=GetOpacitySample(p);
+ transpix.red=GetRedPixelComponent(p);
+ transpix.green=GetGreenPixelComponent(p);
+ transpix.blue=GetBluePixelComponent(p);
+ transpix.opacity=GetOpacityPixelComponent(p);
flags|=PALM_HAS_TRANSPARENCY_FLAG;
}
*ptr++=(unsigned char) ((color16 >> 8) & 0xff);
diff --git a/coders/pcd.c b/coders/pcd.c
index 444d944..e70eaf2 100644
--- a/coders/pcd.c
+++ b/coders/pcd.c
@@ -1030,7 +1030,7 @@
break;
for (x=0; x < (long) (tile_image->columns << 1); x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
p++;
}
q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
diff --git a/coders/pcl.c b/coders/pcl.c
index 22a9140..6f0948b 100644
--- a/coders/pcl.c
+++ b/coders/pcl.c
@@ -898,9 +898,9 @@
*/
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
break;
diff --git a/coders/pcx.c b/coders/pcx.c
index 932ae06..e8d9851 100644
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -1001,7 +1001,7 @@
{
for (x=0; x < (long) pcx_info.bytes_per_line; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
break;
@@ -1010,7 +1010,7 @@
{
for (x=0; x < (long) pcx_info.bytes_per_line; x++)
{
- *q++=ScaleQuantumToChar(GetGreenSample(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
p++;
}
break;
@@ -1019,7 +1019,7 @@
{
for (x=0; x < (long) pcx_info.bytes_per_line; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
break;
@@ -1029,7 +1029,7 @@
{
for (x=(long) pcx_info.bytes_per_line; x != 0; x--)
{
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
diff --git a/coders/pdf.c b/coders/pdf.c
index 42785d2..74e9c60 100644
--- a/coders/pdf.c
+++ b/coders/pdf.c
@@ -1661,9 +1661,9 @@
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(indexes[x]);
p++;
@@ -1707,9 +1707,9 @@
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- Ascii85Encode(image,ScaleQuantumToChar(GetRedSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetGreenSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetBlueSample(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
if (image->colorspace == CMYKColorspace)
Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
p++;
@@ -2093,9 +2093,9 @@
indexes=GetVirtualIndexQueue(tile_image);
for (x=0; x < (long) tile_image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(indexes[x]);
p++;
@@ -2133,9 +2133,9 @@
indexes=GetVirtualIndexQueue(tile_image);
for (x=0; x < (long) tile_image->columns; x++)
{
- Ascii85Encode(image,ScaleQuantumToChar(GetRedSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetGreenSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetBlueSample(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
if (image->colorspace == CMYKColorspace)
Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
p++;
@@ -2375,7 +2375,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -2411,7 +2411,7 @@
for (x=0; x < (long) image->columns; x++)
{
Ascii85Encode(image,ScaleQuantumToChar((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
p++;
}
}
diff --git a/coders/pict.c b/coders/pict.c
index 5393a89..a2c611d 100644
--- a/coders/pict.c
+++ b/coders/pict.c
@@ -1930,12 +1930,12 @@
}
for (x=0; x < (long) image->columns; x++)
{
- *red++=ScaleQuantumToChar(GetRedSample(p));
- *green++=ScaleQuantumToChar(GetGreenSample(p));
- *blue++=ScaleQuantumToChar(GetBlueSample(p));
+ *red++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *green++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *blue++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->matte != MagickFalse)
*opacity++=ScaleQuantumToChar((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
count+=EncodeImage(image,scanline,bytes_per_line & 0x7FFF,
diff --git a/coders/png.c b/coders/png.c
index fccb26b..9735605 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -613,7 +613,7 @@
for (x=0; x < (long) image->columns; x++)
{
marker[(int) indices[x]]=MagickTrue;
- opacity[(int) indices[x]]=GetOpacitySample(p);
+ opacity[(int) indices[x]]=GetOpacityPixelComponent(p);
if (indices[x] > top_used)
top_used=indices[x];
p++;
@@ -2719,7 +2719,7 @@
q->opacity=ScaleCharToQuantum((unsigned char)
(255-ping_info->trans_alpha[(long) indexpacket]));
else
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
@@ -2732,7 +2732,7 @@
if (q->red == transparent_color.opacity)
q->opacity=(Quantum) TransparentOpacity;
else
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
}
@@ -2744,7 +2744,7 @@
ScaleQuantumToChar(q->blue) == transparent_color.blue)
q->opacity=(Quantum) TransparentOpacity;
else
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -6610,7 +6610,7 @@
{
indices[x]=(IndexPacket) (number_colors-1);
ping_info->trans_alpha[(long) indices[x]]=(png_byte) (255-
- ScaleQuantumToChar(GetOpacitySample(p)));
+ ScaleQuantumToChar(GetOpacityPixelComponent(p)));
}
p++;
}
@@ -6827,15 +6827,15 @@
mask=0x0001;
ping_info->valid|=PNG_INFO_tRNS;
ping_info->trans_color.red=(png_uint_16)
- (ScaleQuantumToShort(GetRedSample(p)) & mask);
+ (ScaleQuantumToShort(GetRedPixelComponent(p)) & mask);
ping_info->trans_color.green=(png_uint_16)
- (ScaleQuantumToShort(GetGreenSample(p)) & mask);
+ (ScaleQuantumToShort(GetGreenPixelComponent(p)) & mask);
ping_info->trans_color.blue=(png_uint_16)
- (ScaleQuantumToShort(GetBlueSample(p)) & mask);
+ (ScaleQuantumToShort(GetBluePixelComponent(p)) & mask);
ping_info->trans_color.gray=(png_uint_16)
(ScaleQuantumToShort(PixelIntensityToQuantum(p)) & mask);
ping_info->trans_color.index=(png_byte)
- (ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p))));
+ (ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p))));
}
if (ping_info->valid & PNG_INFO_tRNS)
{
@@ -7067,7 +7067,7 @@
if (trans[(long) packet_index] != 256)
{
if (trans[(long) packet_index] != (png_byte) (255-
- ScaleQuantumToChar(GetOpacitySample(p))))
+ ScaleQuantumToChar(GetOpacityPixelComponent(p))))
{
ping_info->color_type=(png_byte)
PNG_COLOR_TYPE_RGB_ALPHA;
@@ -7075,7 +7075,7 @@
}
}
trans[(long) packet_index]=(png_byte) (255-
- ScaleQuantumToChar(GetOpacitySample(p)));
+ ScaleQuantumToChar(GetOpacityPixelComponent(p)));
}
p++;
}
diff --git a/coders/pnm.c b/coders/pnm.c
index 9c31fa1..cc0cc5c 100644
--- a/coders/pnm.c
+++ b/coders/pnm.c
@@ -744,7 +744,7 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
q++;
@@ -758,7 +758,7 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
q++;
@@ -1042,14 +1042,14 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushCharPixel(p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1062,14 +1062,14 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1087,18 +1087,18 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
indexes[x]=ScaleAnyToQuantum(pixel,range);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushCharPixel(p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1111,18 +1111,18 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
indexes[x]=ScaleAnyToQuantum(pixel,range);
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1139,16 +1139,16 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
- SetOpacitySample(q,OpaqueOpacity);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushCharPixel(p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1161,16 +1161,16 @@
for (x=0; x < (long) image->columns; x++)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushShortPixel(MSBEndian,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
- SetOpacitySample(q,OpaqueOpacity);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
{
p=PushShortPixel(MSBEndian,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
}
q++;
}
@@ -1797,12 +1797,12 @@
{
if (image->depth <= 8)
count=(ssize_t) FormatMagickString(buffer,MaxTextExtent,
- "%u %u %u ",ScaleQuantumToChar(GetRedSample(p)),
- ScaleQuantumToChar(GetGreenSample(p)),ScaleQuantumToChar(GetBlueSample(p)));
+ "%u %u %u ",ScaleQuantumToChar(GetRedPixelComponent(p)),
+ ScaleQuantumToChar(GetGreenPixelComponent(p)),ScaleQuantumToChar(GetBluePixelComponent(p)));
else
count=(ssize_t) FormatMagickString(buffer,MaxTextExtent,
- "%u %u %u ",ScaleQuantumToShort(GetRedSample(p)),
- ScaleQuantumToShort(GetGreenSample(p)),ScaleQuantumToShort(GetBlueSample(p)));
+ "%u %u %u ",ScaleQuantumToShort(GetRedPixelComponent(p)),
+ ScaleQuantumToShort(GetGreenPixelComponent(p)),ScaleQuantumToShort(GetBluePixelComponent(p)));
extent=(size_t) count;
(void) strncpy((char *) q,buffer,extent);
q+=extent;
@@ -1907,7 +1907,7 @@
else
{
if (image->depth == 8)
- pixel=ScaleQuantumToChar(GetRedSample(p));
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
else
pixel=ScaleQuantumToAny(p->red,range);
}
@@ -1922,7 +1922,7 @@
else
{
if (image->depth == 16)
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
else
pixel=ScaleQuantumToAny(p->red,range);
}
@@ -1992,7 +1992,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopCharPixel((unsigned char) pixel,q);
}
p++;
@@ -2009,7 +2009,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
p++;
@@ -2113,7 +2113,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopCharPixel((unsigned char) pixel,q);
}
p++;
@@ -2132,7 +2132,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
p++;
@@ -2153,7 +2153,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopCharPixel((unsigned char) pixel,q);
}
p++;
@@ -2170,7 +2170,7 @@
if (image->matte != MagickFalse)
{
pixel=ScaleQuantumToAny((Quantum) (QuantumRange-
- GetOpacitySample(p)),range);
+ GetOpacityPixelComponent(p)),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
p++;
diff --git a/coders/ps.c b/coders/ps.c
index 17f1884..74bff38 100644
--- a/coders/ps.c
+++ b/coders/ps.c
@@ -1909,9 +1909,9 @@
}
else
{
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetRedSample(p)),q);
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetGreenSample(p)),q);
- q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetBlueSample(p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetRedPixelComponent(p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
+ q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetBluePixelComponent(p)),q);
}
if ((q-pixels+6) >= 80)
{
diff --git a/coders/ps2.c b/coders/ps2.c
index 09ce4bd..f8c223e 100644
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -893,15 +893,15 @@
else
if (image->colorspace != CMYKColorspace)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
}
else
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar(indexes[x]);
}
p++;
@@ -951,15 +951,15 @@
else
if (image->colorspace != CMYKColorspace)
{
- Ascii85Encode(image,ScaleQuantumToChar(GetRedSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetGreenSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetBlueSample(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
}
else
{
- Ascii85Encode(image,ScaleQuantumToChar(GetRedSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetGreenSample(p)));
- Ascii85Encode(image,ScaleQuantumToChar(GetBlueSample(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
+ Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
}
p++;
diff --git a/coders/ps3.c b/coders/ps3.c
index 12b9115..16b907e 100644
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -270,17 +270,17 @@
if (image->colorspace != CMYKColorspace)
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
else
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar(indexes[x]);
p++;
}
diff --git a/coders/raw.c b/coders/raw.c
index 08954c9..c84d3ea 100644
--- a/coders/raw.c
+++ b/coders/raw.c
@@ -230,9 +230,9 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
diff --git a/coders/rgb.c b/coders/rgb.c
index b8c9b77..861856b 100644
--- a/coders/rgb.c
+++ b/coders/rgb.c
@@ -287,9 +287,9 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- qx[0]=GetRedSample(p);
- qx[1]=GetGreenSample(p);
- qx[2]=GetBlueSample(p);
+ qx[0]=GetRedPixelComponent(p);
+ qx[1]=GetGreenPixelComponent(p);
+ qx[2]=GetBluePixelComponent(p);
for (i=0; i < 3; i++)
switch(quantum_types[i])
{
@@ -298,9 +298,9 @@
case BlueQuantum: q->blue=qx[i]; break;
default: break;
}
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -367,10 +367,10 @@
if (i == (channels - 1))
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,GetOpacitySample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -439,11 +439,11 @@
{
switch(quantum_types[i])
{
- case RedQuantum: SetRedSample(q,GetRedSample(p)); break;
- case GreenQuantum: SetGreenSample(q,GetGreenSample(p)); break;
- case BlueQuantum: SetBlueSample(q,GetBlueSample(p)); break;
+ case RedQuantum: SetRedPixelComponent(q,GetRedPixelComponent(p)); break;
+ case GreenQuantum: SetGreenPixelComponent(q,GetGreenPixelComponent(p)); break;
+ case BlueQuantum: SetBluePixelComponent(q,GetBluePixelComponent(p)); break;
case OpacityQuantum:
- case AlphaQuantum: SetOpacitySample(q,GetOpacitySample(p)); break;
+ case AlphaQuantum: SetOpacityPixelComponent(q,GetOpacityPixelComponent(p)); break;
default: break;
}
p++;
@@ -542,11 +542,11 @@
{
switch(quantum_types[i])
{
- case RedQuantum: SetRedSample(q,GetRedSample(p)); break;
- case GreenQuantum: SetGreenSample(q,GetGreenSample(p)); break;
- case BlueQuantum: SetBlueSample(q,GetBlueSample(p)); break;
+ case RedQuantum: SetRedPixelComponent(q,GetRedPixelComponent(p)); break;
+ case GreenQuantum: SetGreenPixelComponent(q,GetGreenPixelComponent(p)); break;
+ case BlueQuantum: SetBluePixelComponent(q,GetBluePixelComponent(p)); break;
case OpacityQuantum:
- case AlphaQuantum: SetOpacitySample(q,GetOpacitySample(p)); break;
+ case AlphaQuantum: SetOpacityPixelComponent(q,GetOpacityPixelComponent(p)); break;
default: break;
}
p++;
diff --git a/coders/sgi.c b/coders/sgi.c
index 1713999..2348034 100644
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -560,7 +560,7 @@
((*(p+2) << 8) | (*(p+3))));
q->blue=ScaleShortToQuantum((unsigned short)
((*(p+4) << 8) | (*(p+5))));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
(unsigned short) ((*(p+6) << 8) | (*(p+7)))));
@@ -589,7 +589,7 @@
q->red=ScaleCharToQuantum(*p);
q->green=ScaleCharToQuantum(*(p+1));
q->blue=ScaleCharToQuantum(*(p+2));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*(p+3)));
p+=4;
@@ -983,10 +983,10 @@
q=(unsigned char *) iris_pixels;
q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
else
@@ -997,10 +997,10 @@
q=(unsigned short *) iris_pixels;
q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
if (image->previous == (Image *) NULL)
diff --git a/coders/sun.c b/coders/sun.c
index 8a49473..08b2dd2 100644
--- a/coders/sun.c
+++ b/coders/sun.c
@@ -843,10 +843,10 @@
for (x=0; x < (long) image->columns; x++)
{
if (image->matte != MagickFalse)
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
if (((bytes_per_pixel*image->columns) & 0x01) != 0)
diff --git a/coders/svg.c b/coders/svg.c
index 305900a..e45b54c 100644
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -3283,11 +3283,11 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- trace->bitmap[i++]=GetRedSample(p);
+ trace->bitmap[i++]=GetRedPixelComponent(p);
if (number_planes == 3)
{
- trace->bitmap[i++]=GetGreenSample(p);
- trace->bitmap[i++]=GetBlueSample(p);
+ trace->bitmap[i++]=GetGreenPixelComponent(p);
+ trace->bitmap[i++]=GetBluePixelComponent(p);
}
p++;
}
diff --git a/coders/tga.c b/coders/tga.c
index 198f08f..a1e349d 100644
--- a/coders/tga.c
+++ b/coders/tga.c
@@ -834,12 +834,12 @@
*q++=(unsigned char) ScaleQuantumToChar(PixelIntensityToQuantum(p));
else
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
if (image->matte != MagickFalse)
*q++=(unsigned char) ScaleQuantumToChar((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (QuantumRange-GetOpacityPixelComponent(p)));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(indexes[x]);
}
diff --git a/coders/tiff.c b/coders/tiff.c
index 5f7e3f7..dfe1af9 100644
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1181,11 +1181,11 @@
}
for (i=0; i < (long) image->colors; i++)
{
- image->colormap[i].red=RoundToQuantum(((double) QuantumRange*
+ image->colormap[i].red=ClampToQuantum(((double) QuantumRange*
red_colormap[i])/range);
- image->colormap[i].green=RoundToQuantum(((double) QuantumRange*
+ image->colormap[i].green=ClampToQuantum(((double) QuantumRange*
green_colormap[i])/range);
- image->colormap[i].blue=RoundToQuantum(((double) QuantumRange*
+ image->colormap[i].blue=ClampToQuantum(((double) QuantumRange*
blue_colormap[i])/range);
}
}
diff --git a/coders/uyvy.c b/coders/uyvy.c
index 9628df8..aacfc67 100644
--- a/coders/uyvy.c
+++ b/coders/uyvy.c
@@ -345,16 +345,16 @@
{
if (full != MagickFalse)
{
- pixel.green=(pixel.green+GetGreenSample(p))/2;
- pixel.blue=(pixel.blue+GetBlueSample(p))/2;
+ pixel.green=(pixel.green+GetGreenPixelComponent(p))/2;
+ pixel.blue=(pixel.blue+GetBluePixelComponent(p))/2;
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.green));
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
(void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.blue));
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
}
- pixel.red=(double) GetRedSample(p);
- pixel.green=(double) GetGreenSample(p);
- pixel.blue=(double) GetBlueSample(p);
+ pixel.red=(double) GetRedPixelComponent(p);
+ pixel.green=(double) GetGreenPixelComponent(p);
+ pixel.blue=(double) GetBluePixelComponent(p);
full=full == MagickFalse ? MagickTrue : MagickFalse;
p++;
}
diff --git a/coders/viff.c b/coders/viff.c
index a898f77..62749d8 100644
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -1092,12 +1092,12 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- *q=ScaleQuantumToChar(GetRedSample(p));
- *(q+number_pixels)=ScaleQuantumToChar(GetGreenSample(p));
- *(q+number_pixels*2)=ScaleQuantumToChar(GetBlueSample(p));
+ *q=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *(q+number_pixels)=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *(q+number_pixels*2)=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->matte != MagickFalse)
*(q+number_pixels*3)=ScaleQuantumToChar((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (QuantumRange-GetOpacityPixelComponent(p)));
p++;
q++;
}
diff --git a/coders/xpm.c b/coders/xpm.c
index 4067ae1..df5a30e 100644
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -685,7 +685,7 @@
if (q->opacity == (Quantum) TransparentOpacity)
transparent=MagickTrue;
else
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
diff --git a/coders/xwd.c b/coders/xwd.c
index a52aee0..cc93064 100644
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -769,9 +769,9 @@
else
for (x=0; x < (long) image->columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
for (x=0; x < (long) scanline_pad; x++)
diff --git a/coders/ycbcr.c b/coders/ycbcr.c
index 480f25e..12f21df 100644
--- a/coders/ycbcr.c
+++ b/coders/ycbcr.c
@@ -250,11 +250,11 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -323,10 +323,10 @@
{
switch (quantum_type)
{
- case RedQuantum: SetRedSample(q,GetRedSample(p)); break;
- case GreenQuantum: SetGreenSample(q,GetGreenSample(p)); break;
- case BlueQuantum: SetBlueSample(q,GetBlueSample(p)); break;
- case OpacityQuantum: SetOpacitySample(q,GetOpacitySample(p)); break;
+ case RedQuantum: SetRedPixelComponent(q,GetRedPixelComponent(p)); break;
+ case GreenQuantum: SetGreenPixelComponent(q,GetGreenPixelComponent(p)); break;
+ case BlueQuantum: SetBluePixelComponent(q,GetBluePixelComponent(p)); break;
+ case OpacityQuantum: SetOpacityPixelComponent(q,GetOpacityPixelComponent(p)); break;
default: break;
}
p++;
@@ -384,7 +384,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
@@ -427,7 +427,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetGreenSample(q,GetGreenSample(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
@@ -470,7 +470,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetBlueSample(q,GetBlueSample(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
@@ -516,7 +516,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -598,7 +598,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
@@ -660,7 +660,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetGreenSample(q,GetGreenSample(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
@@ -722,7 +722,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetBlueSample(q,GetBlueSample(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
@@ -787,7 +787,7 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
diff --git a/coders/yuv.c b/coders/yuv.c
index 276403e..fe524d6 100644
--- a/coders/yuv.c
+++ b/coders/yuv.c
@@ -626,10 +626,10 @@
for (x=0; x < (long) yuv_image->columns; x++)
{
(void) WriteBlobByte(image,ScaleQuantumToChar(s->green));
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
p++;
(void) WriteBlobByte(image,ScaleQuantumToChar(s->blue));
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
p++;
s++;
x++;
@@ -656,7 +656,7 @@
break;
for (x=0; x < (long) yuv_image->columns; x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
p++;
}
if (image->previous == (Image *) NULL)
@@ -693,7 +693,7 @@
break;
for (x=0; x < (long) chroma_image->columns; x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetGreenSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
p++;
}
}
@@ -723,7 +723,7 @@
break;
for (x=0; x < (long) chroma_image->columns; x++)
{
- (void) WriteBlobByte(image,ScaleQuantumToChar(GetBlueSample(p)));
+ (void) WriteBlobByte(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
p++;
}
}
diff --git a/filters/convolve.c b/filters/convolve.c
index 8f21713..81a8f82 100644
--- a/filters/convolve.c
+++ b/filters/convolve.c
@@ -139,7 +139,7 @@
static char
*convolve_program =
- "static long AuthenticPixel(const long offset,const ulong range)\n"
+ "static long ClampToCanvas(const long offset,const ulong range)\n"
"{\n"
" if (offset < 0)\n"
" return(0);\n"
@@ -148,7 +148,7 @@
" return(offset);\n"
"}\n"
"\n"
- "static CLQuantumType AuthenticQuantum(const double value)\n"
+ "static CLQuantumType ClampToQuantum(const double value)\n"
"{\n"
"#if !defined(MAGICKCORE_HDRI_SUPPORT)\n"
" if (value < 0)\n"
@@ -198,8 +198,8 @@
" {\n"
" for (long u=(-mid_width); u <= mid_width; u++)\n"
" {\n"
- " index=AuthenticPixel(y+v,rows)*columns+\n"
- " AuthenticPixel(x+u,columns);\n"
+ " index=ClampToCanvas(y+v,rows)*columns+\n"
+ " ClampToCanvas(x+u,columns);\n"
" sum.x+=filter[i]*input[index].x;\n"
" sum.y+=filter[i]*input[index].y;\n"
" sum.z+=filter[i]*input[index].z;\n"
@@ -215,8 +215,8 @@
" {\n"
" for (long u=(-mid_width); u <= mid_width; u++)\n"
" {\n"
- " index=AuthenticPixel(y+v,rows)*columns+\n"
- " AuthenticPixel(x+u,columns);\n"
+ " index=ClampToCanvas(y+v,rows)*columns+\n"
+ " ClampToCanvas(x+u,columns);\n"
" alpha=scale*(QuantumRange-input[index].w);\n"
" sum.x+=alpha*filter[i]*input[index].x;\n"
" sum.y+=alpha*filter[i]*input[index].y;\n"
@@ -265,13 +265,13 @@
" }\n"
" gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);\n"
" index=y*columns+x;\n"
- " output[index].x=AuthenticQuantum(gamma*sum.x);\n"
- " output[index].y=AuthenticQuantum(gamma*sum.y);\n"
- " output[index].z=AuthenticQuantum(gamma*sum.z);\n"
+ " output[index].x=ClampToQuantum(gamma*sum.x);\n"
+ " output[index].y=ClampToQuantum(gamma*sum.y);\n"
+ " output[index].z=ClampToQuantum(gamma*sum.z);\n"
" if (matte == false)\n"
" output[index].w=input[index].w;\n"
" else\n"
- " output[index].w=AuthenticQuantum(sum.w);\n"
+ " output[index].w=ClampToQuantum(sum.w);\n"
"}\n";
static void OpenCLNotify(const char *message,const void *data,size_t length,
diff --git a/magick/annotate.c b/magick/annotate.c
index 1dad37c..b614e97 100644
--- a/magick/annotate.c
+++ b/magick/annotate.c
@@ -1695,7 +1695,7 @@
for (x=0; x < (long) annotate_image->columns; x++)
{
(void) GetFillColor(draw_info,x,y,&fill_color);
- q->opacity=RoundToQuantum(QuantumRange-(((QuantumRange-
+ q->opacity=ClampToQuantum(QuantumRange-(((QuantumRange-
(MagickRealType) PixelIntensityToQuantum(q))*(QuantumRange-
fill_color.opacity))/QuantumRange));
q->red=fill_color.red;
diff --git a/magick/cache.c b/magick/cache.c
index a1c67cf..a23e7e2 100644
--- a/magick/cache.c
+++ b/magick/cache.c
@@ -407,10 +407,10 @@
break;
if (PixelIntensityToQuantum(r) > ((Quantum) QuantumRange/2))
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,GetOpacitySample(p));
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (cache_info->active_index_channel != MagickFalse)
nexus_indexes[i]=indexes[i];
}
@@ -3862,10 +3862,10 @@
SetMagickPixelPacket(image,q,nexus_indexes+i,&beta);
MagickPixelCompositeMask(&beta,(MagickRealType) PixelIntensityToQuantum(r),
&alpha,alpha.opacity,&beta);
- q->red=RoundToQuantum(beta.red);
- q->green=RoundToQuantum(beta.green);
- q->blue=RoundToQuantum(beta.blue);
- q->opacity=RoundToQuantum(beta.opacity);
+ q->red=ClampToQuantum(beta.red);
+ q->green=ClampToQuantum(beta.green);
+ q->blue=ClampToQuantum(beta.blue);
+ q->opacity=ClampToQuantum(beta.opacity);
if (cache_info->active_index_channel != MagickFalse)
nexus_indexes[i]=indexes[i];
p++;
diff --git a/magick/color.c b/magick/color.c
index b549904..c4dc632 100644
--- a/magick/color.c
+++ b/magick/color.c
@@ -1026,19 +1026,19 @@
if (pixel->depth > 16)
{
(void) FormatMagickString(component,MaxTextExtent,"%10lu",
- (unsigned long) ScaleQuantumToLong(RoundToQuantum(color)));
+ (unsigned long) ScaleQuantumToLong(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
if (pixel->depth > 8)
{
(void) FormatMagickString(component,MaxTextExtent,"%5d",
- ScaleQuantumToShort(RoundToQuantum(color)));
+ ScaleQuantumToShort(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
(void) FormatMagickString(component,MaxTextExtent,"%3d",
- ScaleQuantumToChar(RoundToQuantum(color)));
+ ScaleQuantumToChar(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
@@ -1065,7 +1065,7 @@
return;
}
(void) FormatMagickString(component,MaxTextExtent,"%d",
- ScaleQuantumToChar(RoundToQuantum(color)));
+ ScaleQuantumToChar(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
}
@@ -1329,26 +1329,26 @@
if (pixel->depth > 32)
{
(void) FormatMagickString(component,MaxTextExtent,"%08lX",
- ScaleQuantumToLong(RoundToQuantum(color)));
+ ScaleQuantumToLong(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
if (pixel->depth > 16)
{
(void) FormatMagickString(component,MaxTextExtent,"%08X",
- (unsigned int) ScaleQuantumToLong(RoundToQuantum(color)));
+ (unsigned int) ScaleQuantumToLong(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
if (pixel->depth > 8)
{
(void) FormatMagickString(component,MaxTextExtent,"%04X",
- ScaleQuantumToShort(RoundToQuantum(color)));
+ ScaleQuantumToShort(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
(void) FormatMagickString(component,MaxTextExtent,"%02X",
- ScaleQuantumToChar(RoundToQuantum(color)));
+ ScaleQuantumToChar(ClampToQuantum(color)));
(void) ConcatenateMagickString(tuple,component,MaxTextExtent);
return;
}
@@ -1385,7 +1385,7 @@
if (color.depth > 8)
{
#define SVGCompliant(component) ((MagickRealType) \
- ScaleCharToQuantum(ScaleQuantumToChar(RoundToQuantum(component))));
+ ScaleCharToQuantum(ScaleQuantumToChar(ClampToQuantum(component))));
MagickStatusType
status;
@@ -1527,7 +1527,7 @@
beta=1.0;
if (image->matte != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacityPixelComponent(p)));
beta=(MagickRealType) (QuantumScale*(QuantumRange-q->opacity));
}
pixel=alpha*p->red-beta*q->red;
@@ -1719,7 +1719,7 @@
fuzz=3.0*MagickMax(p->fuzz,MagickSQ1_2)*MagickMax(q->fuzz,MagickSQ1_2);
alpha=1.0;
if (p->matte != MagickFalse)
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacityPixelComponent(p)));
beta=1.0;
if (q->matte != MagickFalse)
beta=(MagickRealType) (QuantumScale*(QuantumRange-q->opacity));
@@ -2194,9 +2194,9 @@
color_info->path=(char *) "[built-in]";
color_info->name=(char *) p->name;
GetMagickPixelPacket((Image *) NULL,&color_info->color);
- color_info->color.red=scale*GetRedSample(p);
- color_info->color.green=scale*GetGreenSample(p);
- color_info->color.blue=scale*GetBlueSample(p);
+ color_info->color.red=scale*GetRedPixelComponent(p);
+ color_info->color.green=scale*GetGreenPixelComponent(p);
+ color_info->color.blue=scale*GetBluePixelComponent(p);
color_info->color.opacity=(MagickRealType) (QuantumRange-QuantumRange*
p->alpha);
color_info->compliance=(ComplianceType) p->compliance;
@@ -2269,23 +2269,23 @@
pixel;
status=QueryMagickColor(name,&pixel,exception);
- color->opacity=RoundToQuantum(pixel.opacity);
+ color->opacity=ClampToQuantum(pixel.opacity);
if (pixel.colorspace == CMYKColorspace)
{
- color->red=RoundToQuantum((MagickRealType) (QuantumRange-MagickMin(
+ color->red=ClampToQuantum((MagickRealType) (QuantumRange-MagickMin(
QuantumRange,(MagickRealType) (QuantumScale*pixel.red*(QuantumRange-
pixel.index)+pixel.index))));
- color->green=RoundToQuantum((MagickRealType) (QuantumRange-MagickMin(
+ color->green=ClampToQuantum((MagickRealType) (QuantumRange-MagickMin(
QuantumRange,(MagickRealType) (QuantumScale*pixel.green*(QuantumRange-
pixel.index)+pixel.index))));
- color->blue=RoundToQuantum((MagickRealType) (QuantumRange-MagickMin(
+ color->blue=ClampToQuantum((MagickRealType) (QuantumRange-MagickMin(
QuantumRange,(MagickRealType) (QuantumScale*pixel.blue*(QuantumRange-
pixel.index)+pixel.index))));
return(status);
}
- color->red=RoundToQuantum(pixel.red);
- color->green=RoundToQuantum(pixel.green);
- color->blue=RoundToQuantum(pixel.blue);
+ color->red=ClampToQuantum(pixel.red);
+ color->green=ClampToQuantum(pixel.green);
+ color->blue=ClampToQuantum(pixel.blue);
return(status);
}
@@ -2523,31 +2523,31 @@
if ((flags & PercentValue) != 0)
scale=(MagickRealType) (QuantumRange/100.0);
if ((flags & RhoValue) != 0)
- color->red=(MagickRealType) RoundToQuantum(scale*geometry_info.rho);
+ color->red=(MagickRealType) ClampToQuantum(scale*geometry_info.rho);
if ((flags & SigmaValue) != 0)
- color->green=(MagickRealType) RoundToQuantum(scale*geometry_info.sigma);
+ color->green=(MagickRealType) ClampToQuantum(scale*geometry_info.sigma);
if ((flags & XiValue) != 0)
- color->blue=(MagickRealType) RoundToQuantum(scale*geometry_info.xi);
+ color->blue=(MagickRealType) ClampToQuantum(scale*geometry_info.xi);
color->opacity=(MagickRealType) OpaqueOpacity;
if ((flags & PsiValue) != 0)
{
if (color->colorspace == CMYKColorspace)
- color->index=(MagickRealType) RoundToQuantum(scale*
+ color->index=(MagickRealType) ClampToQuantum(scale*
geometry_info.psi);
else
if (color->matte != MagickFalse)
- color->opacity=(MagickRealType) RoundToQuantum((MagickRealType)
+ color->opacity=(MagickRealType) ClampToQuantum((MagickRealType)
(QuantumRange-QuantumRange*geometry_info.psi));
}
if (((flags & ChiValue) != 0) && (color->matte != MagickFalse))
- color->opacity=(MagickRealType) RoundToQuantum((MagickRealType)
+ color->opacity=(MagickRealType) ClampToQuantum((MagickRealType)
(QuantumRange-QuantumRange*geometry_info.chi));
if (LocaleCompare(colorspace,"gray") == 0)
{
color->green=color->red;
color->blue=color->red;
if (((flags & SigmaValue) != 0) && (color->matte != MagickFalse))
- color->opacity=(MagickRealType) RoundToQuantum((MagickRealType)
+ color->opacity=(MagickRealType) ClampToQuantum((MagickRealType)
(QuantumRange-QuantumRange*geometry_info.sigma));
}
if ((LocaleCompare(colorspace,"HSB") == 0) ||
diff --git a/magick/colorspace.c b/magick/colorspace.c
index 393ee21..719714d 100644
--- a/magick/colorspace.c
+++ b/magick/colorspace.c
@@ -246,9 +246,9 @@
}
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) (QuantumRange-q->red));
- q->green=RoundToQuantum((MagickRealType) (QuantumRange-q->green));
- q->blue=RoundToQuantum((MagickRealType) (QuantumRange-q->blue));
+ q->red=ClampToQuantum((MagickRealType) (QuantumRange-q->red));
+ q->green=ClampToQuantum((MagickRealType) (QuantumRange-q->green));
+ q->blue=ClampToQuantum((MagickRealType) (QuantumRange-q->blue));
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -365,9 +365,9 @@
for (x=0; x < (long) image->columns; x++)
{
ConvertRGBToHSB(q->red,q->green,q->blue,&hue,&saturation,&brightness);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*saturation);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*hue);
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*saturation);
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -421,9 +421,9 @@
for (x=0; x < (long) image->columns; x++)
{
ConvertRGBToHSL(q->red,q->green,q->blue,&hue,&saturation,&lightness);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*saturation);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*lightness);
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*hue);
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*saturation);
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*lightness);
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -477,9 +477,9 @@
for (x=0; x < (long) image->columns; x++)
{
ConvertRGBToHWB(q->red,q->green,q->blue,&hue,&whiteness,&blackness);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*whiteness);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*blackness);
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*hue);
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*whiteness);
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*blackness);
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -540,9 +540,9 @@
{
ConvertRGBToXYZ(q->red,q->green,q->blue,&X,&Y,&Z);
ConvertXYZToLab(X,Y,Z,&L,&a,&b);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*L);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*a);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*L);
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*a);
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*b);
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -1293,9 +1293,9 @@
r=3.2407100*x-1.5372600*y-0.4985710*z;
g=(-0.9692580*x+1.8759900*y+0.0415557*z);
b=0.0556352*x-0.2039960*y+1.0570700*z;
- *red=RoundToQuantum((MagickRealType) QuantumRange*r);
- *green=RoundToQuantum((MagickRealType) QuantumRange*g);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
}
static inline void ConvertCMYKToRGB(MagickPixelPacket *pixel)
@@ -1429,9 +1429,9 @@
}
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) (QuantumRange-q->red));
- q->green=RoundToQuantum((MagickRealType) (QuantumRange-q->green));
- q->blue=RoundToQuantum((MagickRealType) (QuantumRange-q->blue));
+ q->red=ClampToQuantum((MagickRealType) (QuantumRange-q->red));
+ q->green=ClampToQuantum((MagickRealType) (QuantumRange-q->green));
+ q->blue=ClampToQuantum((MagickRealType) (QuantumRange-q->blue));
q++;
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -1787,7 +1787,7 @@
for (i=0; i <= (long) (reference_black*MaxMap/1024.0); i++)
logmap[i]=(Quantum) 0;
for ( ; i < (long) (reference_white*MaxMap/1024.0); i++)
- logmap[i]=RoundToQuantum((MagickRealType) QuantumRange/(1.0-black)*
+ logmap[i]=ClampToQuantum((MagickRealType) QuantumRange/(1.0-black)*
(pow(10.0,(1024.0*i/MaxMap-reference_white)*
(gamma/density)*0.002/0.6)-black));
for ( ; i <= (long) MaxMap; i++)
diff --git a/magick/compare.c b/magick/compare.c
index 52cfad3..aa9cbb3 100644
--- a/magick/compare.c
+++ b/magick/compare.c
@@ -633,7 +633,7 @@
if ((channel & OpacityChannel) != 0)
{
if (image->matte != MagickFalse)
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacityPixelComponent(p)));
if (reconstruct_image->matte != MagickFalse)
beta=(MagickRealType) (QuantumScale*(QuantumRange-q->opacity));
}
@@ -1558,7 +1558,7 @@
offset->x=x;
offset->y=y;
}
- q->red=RoundToQuantum(QuantumRange-QuantumRange*similarity);
+ q->red=ClampToQuantum(QuantumRange-QuantumRange*similarity);
q->green=q->red;
q->blue=q->red;
q++;
diff --git a/magick/composite.c b/magick/composite.c
index 6ebfd96..987234e 100644
--- a/magick/composite.c
+++ b/magick/composite.c
@@ -236,7 +236,7 @@
composite->red=QuantumScale*intensity*q->red;
composite->green=QuantumScale*intensity*q->green;
composite->blue=QuantumScale*intensity*q->blue;
- composite->opacity=(MagickRealType) QuantumScale*intensity*GetOpacitySample(p);
+ composite->opacity=(MagickRealType) QuantumScale*intensity*GetOpacityPixelComponent(p);
if (q->colorspace == CMYKColorspace)
composite->index=QuantumScale*intensity*q->index;
}
@@ -764,7 +764,7 @@
gamma,
Sa;
- Sa=1.0-QuantumScale*GetOpacitySample(p);
+ Sa=1.0-QuantumScale*GetOpacityPixelComponent(p);
Da=1.0-QuantumScale*q->opacity;
gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
@@ -1551,7 +1551,7 @@
MagickRealType
angle;
- angle = angle_start + angle_range*QuantumScale*GetBlueSample(p);
+ angle = angle_start + angle_range*QuantumScale*GetBluePixelComponent(p);
blur_xu = w*cos(angle);
blur_xv = w*sin(angle);
blur_yu = (-h*sin(angle));
@@ -1559,7 +1559,7 @@
}
ScaleResampleFilter(resample_filter,blur_xu*QuantumScale*p->red,
blur_yu*QuantumScale*p->green,blur_xv*QuantumScale*p->red,
- blur_yv*QuantumScale*GetGreenSample(p));
+ blur_yv*QuantumScale*GetGreenPixelComponent(p));
(void) ResamplePixelColor(resample_filter,(double) x_offset+x,
(double) y_offset+y,&pixel);
SetPixelPacket(destination_image,&pixel,r,destination_indexes+x);
@@ -1735,7 +1735,7 @@
Mask with 'invalid pixel mask' in alpha channel.
*/
pixel.opacity = (MagickRealType) QuantumRange*(1.0-(1.0-QuantumScale*
- pixel.opacity)*(1.0-QuantumScale*GetOpacitySample(p)));
+ pixel.opacity)*(1.0-QuantumScale*GetOpacityPixelComponent(p)));
SetPixelPacket(destination_image,&pixel,r,destination_indexes+x);
p++;
r++;
@@ -2007,24 +2007,24 @@
composite.blue=(MagickRealType) QuantumRange-composite.blue;
composite.index=(MagickRealType) QuantumRange-composite.index;
}
- q->red=RoundToQuantum(composite.red);
- q->green=RoundToQuantum(composite.green);
- q->blue=RoundToQuantum(composite.blue);
+ q->red=ClampToQuantum(composite.red);
+ q->green=ClampToQuantum(composite.green);
+ q->blue=ClampToQuantum(composite.blue);
if (image->matte != MagickFalse)
- q->opacity=RoundToQuantum(composite.opacity);
+ q->opacity=ClampToQuantum(composite.opacity);
if (image->colorspace == CMYKColorspace)
- indexes[x]=RoundToQuantum(composite.index);
+ indexes[x]=ClampToQuantum(composite.index);
q++;
continue;
}
/*
Handle normal overlay of source onto destination.
*/
- source.red=(MagickRealType) GetRedSample(p);
- source.green=(MagickRealType) GetGreenSample(p);
- source.blue=(MagickRealType) GetBlueSample(p);
+ source.red=(MagickRealType) GetRedPixelComponent(p);
+ source.green=(MagickRealType) GetGreenPixelComponent(p);
+ source.blue=(MagickRealType) GetBluePixelComponent(p);
if (composite_image->matte != MagickFalse)
- source.opacity=(MagickRealType) GetOpacitySample(p);
+ source.opacity=(MagickRealType) GetOpacityPixelComponent(p);
if (composite_image->colorspace == CMYKColorspace)
{
source.red=(MagickRealType) QuantumRange-source.red;
@@ -2430,12 +2430,12 @@
composite.blue=(MagickRealType) QuantumRange-composite.blue;
composite.index=(MagickRealType) QuantumRange-composite.index;
}
- q->red=RoundToQuantum(composite.red);
- q->green=RoundToQuantum(composite.green);
- q->blue=RoundToQuantum(composite.blue);
- q->opacity=RoundToQuantum(composite.opacity);
+ q->red=ClampToQuantum(composite.red);
+ q->green=ClampToQuantum(composite.green);
+ q->blue=ClampToQuantum(composite.blue);
+ q->opacity=ClampToQuantum(composite.opacity);
if (image->colorspace == CMYKColorspace)
- indexes[x]=RoundToQuantum(composite.index);
+ indexes[x]=ClampToQuantum(composite.index);
p++;
if (p >= (pixels+composite_image->columns))
p=pixels;
diff --git a/magick/decorate.c b/magick/decorate.c
index 3956486..f80f077 100644
--- a/magick/decorate.c
+++ b/magick/decorate.c
@@ -742,37 +742,37 @@
}
for (x=0; x < y; x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
q++;
}
for ( ; x < (long) (image->columns-y); x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*
AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
AccentuateFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
AccentuateFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
AccentuateFactor)));
q++;
}
for ( ; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
q++;
}
@@ -809,13 +809,13 @@
}
for (x=0; x < (long) raise_info->width; x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
q++;
@@ -824,11 +824,11 @@
q++;
for ( ; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
q++;
}
@@ -865,34 +865,34 @@
}
for (x=0; x < (long) (image->rows-y); x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
HighlightFactor+(MagickRealType) foreground*(QuantumRange-
HighlightFactor)));
q++;
}
for ( ; x < (long) (image->columns-(image->rows-y)); x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*TroughFactor+
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*TroughFactor+
(MagickRealType) background*(QuantumRange-TroughFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
TroughFactor+(MagickRealType) background*(QuantumRange-TroughFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
TroughFactor+(MagickRealType) background*(QuantumRange-TroughFactor)));
q++;
}
for ( ; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
+ q->red=ClampToQuantum(QuantumScale*((MagickRealType) q->red*ShadowFactor+
(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->green=RoundToQuantum(QuantumScale*((MagickRealType) q->green*
+ q->green=ClampToQuantum(QuantumScale*((MagickRealType) q->green*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
- q->blue=RoundToQuantum(QuantumScale*((MagickRealType) q->blue*
+ q->blue=ClampToQuantum(QuantumScale*((MagickRealType) q->blue*
ShadowFactor+(MagickRealType) background*(QuantumRange-ShadowFactor)));
q++;
}
diff --git a/magick/deprecate.c b/magick/deprecate.c
index 14817f8..f01f154 100644
--- a/magick/deprecate.c
+++ b/magick/deprecate.c
@@ -2982,9 +2982,9 @@
r=HueToRGB(m1,m2,hue+1.0/3.0);
g=HueToRGB(m1,m2,hue);
b=HueToRGB(m1,m2,hue-1.0/3.0);
- *red=RoundToQuantum((MagickRealType) QuantumRange*r);
- *green=RoundToQuantum((MagickRealType) QuantumRange*g);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
}
/*
@@ -3201,7 +3201,7 @@
alpha[i]=1.0;
if (image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -3244,7 +3244,7 @@
alpha[i]=1.0;
if (image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -3285,7 +3285,7 @@
alpha[i]=1.0;
if (image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -3392,7 +3392,7 @@
alpha[i]=1.0;
if (image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -3549,7 +3549,7 @@
alpha[n]=1.0;
if (image->matte != MagickFalse)
{
- alpha[n]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[n]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[n].red*=alpha[n];
pixels[n].green*=alpha[n];
pixels[n].blue*=alpha[n];
diff --git a/magick/display.c b/magick/display.c
index 0e4f7ac..3fa81bb 100644
--- a/magick/display.c
+++ b/magick/display.c
@@ -10006,7 +10006,7 @@
}
draw_info=CloneDrawInfo(resource_info->image_info,
(DrawInfo *) NULL);
- draw_info->fill.opacity=RoundToQuantum(StringToDouble(matte));
+ draw_info->fill.opacity=ClampToQuantum(StringToDouble(matte));
(void) FloodfillPaintImage(*image,OpacityChannel,draw_info,&target,
x_offset,y_offset,method == FloodfillMethod ? MagickFalse :
MagickTrue);
diff --git a/magick/draw.c b/magick/draw.c
index 2b833ec..1a2bbfe 100644
--- a/magick/draw.c
+++ b/magick/draw.c
@@ -2017,7 +2017,7 @@
{
GetMagickToken(q,&q,token);
factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
- graphic_context[n]->fill.opacity=RoundToQuantum((MagickRealType)
+ graphic_context[n]->fill.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-factor*StringToDouble(token)));
break;
}
@@ -2215,7 +2215,7 @@
{
GetMagickToken(q,&q,token);
factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
- graphic_context[n]->opacity=RoundToQuantum((MagickRealType)
+ graphic_context[n]->opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-((1.0-QuantumScale*graphic_context[n]->opacity)*
factor*StringToDouble(token))));
graphic_context[n]->fill.opacity=graphic_context[n]->opacity;
@@ -2641,7 +2641,7 @@
{
GetMagickToken(q,&q,token);
factor=strchr(token,'%') != (char *) NULL ? 0.01 : 1.0;
- graphic_context[n]->stroke.opacity=RoundToQuantum((MagickRealType)
+ graphic_context[n]->stroke.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-factor*StringToDouble(token)));
break;
}
diff --git a/magick/effect.c b/magick/effect.c
index 2a7b6b6..b357fec 100644
--- a/magick/effect.c
+++ b/magick/effect.c
@@ -338,15 +338,15 @@
if (((channel & OpacityChannel) != 0) &&
(image->matte != MagickFalse))
alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
if ((channel & RedChannel) != 0)
- pixel.red+=(*k)*alpha*GetRedSample(p);
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(p);
if ((channel & GreenChannel) != 0)
- pixel.green+=(*k)*alpha*GetGreenSample(p);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(p);
if ((channel & BlueChannel) != 0)
- pixel.blue+=(*k)*alpha*GetBlueSample(p);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(p);
if ((channel & OpacityChannel) != 0)
- pixel.opacity+=(*k)*GetOpacitySample(p);
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
pixel.index+=(*k)*alpha*indexes[x+(width-i)*v+u];
@@ -357,16 +357,16 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ blur_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
q++;
r++;
}
@@ -653,15 +653,16 @@
alpha=1.0;
if (((channel & OpacityChannel) != 0) &&
(image->matte != MagickFalse))
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
if ((channel & RedChannel) != 0)
- pixel.red+=(*k)*alpha*GetRedSample(p);
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(p);
if ((channel & GreenChannel) != 0)
- pixel.green+=(*k)*alpha*GetGreenSample(p);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(p);
if ((channel & BlueChannel) != 0)
- pixel.blue+=(*k)*alpha*GetBlueSample(p);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(p);
if ((channel & OpacityChannel) != 0)
- pixel.opacity+=(*k)*GetOpacitySample(p);
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
pixel.index+=(*k)*alpha*indexes[x+(width-i)*v+u];
@@ -672,16 +673,16 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- sharp_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ sharp_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
q++;
r++;
}
@@ -955,11 +956,11 @@
kernel_pixels++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
@@ -970,7 +971,7 @@
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -986,7 +987,7 @@
k++;
kernel_indexes++;
}
- blur_indexes[x]=RoundToQuantum(pixel.index);
+ blur_indexes[x]=ClampToQuantum(pixel.index);
}
}
else
@@ -1009,11 +1010,11 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
@@ -1024,7 +1025,7 @@
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -1044,7 +1045,7 @@
kernel_pixels++;
kernel_indexes++;
}
- blur_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ blur_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
p++;
@@ -1133,11 +1134,11 @@
kernel_pixels++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
@@ -1148,7 +1149,7 @@
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -1164,7 +1165,7 @@
k++;
kernel_indexes++;
}
- blur_indexes[y]=RoundToQuantum(pixel.index);
+ blur_indexes[y]=ClampToQuantum(pixel.index);
}
}
else
@@ -1187,11 +1188,11 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
@@ -1202,7 +1203,7 @@
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -1222,7 +1223,7 @@
kernel_pixels++;
kernel_indexes++;
}
- blur_indexes[y]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ blur_indexes[y]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
p++;
@@ -1481,11 +1482,11 @@
kernel_pixels+=image->columns+width;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=normal_kernel;
@@ -1499,7 +1500,7 @@
}
kernel_pixels+=image->columns+width;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -1518,7 +1519,7 @@
}
kernel_indexes+=image->columns+width;
}
- convolve_indexes[x]=RoundToQuantum(pixel.index);
+ convolve_indexes[x]=ClampToQuantum(pixel.index);
}
}
else
@@ -1544,11 +1545,11 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=normal_kernel;
@@ -1562,7 +1563,7 @@
}
kernel_pixels+=image->columns+width;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -1585,7 +1586,7 @@
kernel_pixels+=image->columns+width;
kernel_indexes+=image->columns+width;
}
- convolve_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ convolve_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
p++;
@@ -1886,10 +1887,10 @@
{
switch (channel)
{
- case 0: pixel[j]=GetRedSample(p); break;
- case 1: pixel[j]=GetGreenSample(p); break;
- case 2: pixel[j]=GetBlueSample(p); break;
- case 3: pixel[j]=GetOpacitySample(p); break;
+ case 0: pixel[j]=GetRedPixelComponent(p); break;
+ case 1: pixel[j]=GetGreenPixelComponent(p); break;
+ case 2: pixel[j]=GetBluePixelComponent(p); break;
+ case 3: pixel[j]=GetOpacityPixelComponent(p); break;
default: break;
}
p++;
@@ -2332,11 +2333,11 @@
kernel_pixels+=image->columns+kernel->width;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=normal_kernel;
@@ -2350,7 +2351,7 @@
}
kernel_pixels+=image->columns+kernel->width;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -2369,7 +2370,7 @@
}
kernel_indexes+=image->columns+kernel->width;
}
- filter_indexes[x]=RoundToQuantum(pixel.index);
+ filter_indexes[x]=ClampToQuantum(pixel.index);
}
}
else
@@ -2395,11 +2396,11 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
k=normal_kernel;
@@ -2413,7 +2414,7 @@
}
kernel_pixels+=image->columns+kernel->width;
}
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -2436,7 +2437,7 @@
kernel_pixels+=image->columns+kernel->width;
kernel_indexes+=image->columns+kernel->width;
}
- filter_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ filter_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
p++;
@@ -3265,16 +3266,16 @@
k++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(qixel.red);
+ q->red=ClampToQuantum(qixel.red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(qixel.green);
+ q->green=ClampToQuantum(qixel.green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(qixel.blue);
+ q->blue=ClampToQuantum(qixel.blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(qixel.opacity);
+ q->opacity=ClampToQuantum(qixel.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(qixel.index);
+ blur_indexes[x]=(IndexPacket) ClampToQuantum(qixel.index);
}
else
{
@@ -3303,16 +3304,16 @@
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*qixel.red);
+ q->red=ClampToQuantum(gamma*qixel.red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*qixel.green);
+ q->green=ClampToQuantum(gamma*qixel.green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*qixel.blue);
+ q->blue=ClampToQuantum(gamma*qixel.blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(qixel.opacity);
+ q->opacity=ClampToQuantum(qixel.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(gamma*qixel.index);
+ blur_indexes[x]=(IndexPacket) ClampToQuantum(gamma*qixel.index);
}
q++;
}
@@ -4067,16 +4068,16 @@
normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 :
normalize);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(normalize*qixel.red);
+ q->red=ClampToQuantum(normalize*qixel.red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(normalize*qixel.green);
+ q->green=ClampToQuantum(normalize*qixel.green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(normalize*qixel.blue);
+ q->blue=ClampToQuantum(normalize*qixel.blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(normalize*qixel.opacity);
+ q->opacity=ClampToQuantum(normalize*qixel.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(normalize*qixel.index);
+ blur_indexes[x]=(IndexPacket) ClampToQuantum(normalize*qixel.index);
}
else
{
@@ -4109,16 +4110,16 @@
normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 :
normalize);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*qixel.red);
+ q->red=ClampToQuantum(gamma*qixel.red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*qixel.green);
+ q->green=ClampToQuantum(gamma*qixel.green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*qixel.blue);
+ q->blue=ClampToQuantum(gamma*qixel.blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(normalize*qixel.opacity);
+ q->opacity=ClampToQuantum(normalize*qixel.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(gamma*qixel.index);
+ blur_indexes[x]=(IndexPacket) ClampToQuantum(gamma*qixel.index);
}
q++;
}
@@ -4623,11 +4624,11 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
}
if ((channel & OpacityChannel) != 0)
{
@@ -4650,7 +4651,8 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- q->opacity=RoundToQuantum(gamma*GetOpacitySample(&pixel));
+ SetOpacityPixelComponent(q,ClampToQuantum(gamma*
+ GetOpacityPixelComponent(&pixel)));
}
}
if (((channel & IndexChannel) != 0) &&
@@ -4675,7 +4677,7 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- blur_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ blur_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
}
@@ -4706,11 +4708,11 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
}
if ((channel & OpacityChannel) != 0)
{
@@ -4733,7 +4735,7 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
}
if (((channel & IndexChannel) != 0) &&
@@ -4760,7 +4762,7 @@
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- blur_indexes[x]=RoundToQuantum(gamma*GetIndexSample(&pixel));
+ blur_indexes[x]=ClampToQuantum(gamma*GetIndexPixelComponent(&pixel));
}
}
}
@@ -4955,9 +4957,9 @@
}
else
{
- q->red=RoundToQuantum(QuantumScale*shade*s1->red);
- q->green=RoundToQuantum(QuantumScale*shade*s1->green);
- q->blue=RoundToQuantum(QuantumScale*shade*s1->blue);
+ q->red=ClampToQuantum(QuantumScale*shade*s1->red);
+ q->green=ClampToQuantum(QuantumScale*shade*s1->green);
+ q->blue=ClampToQuantum(QuantumScale*shade*s1->blue);
}
q->opacity=s1->opacity;
s0++;
@@ -5379,37 +5381,37 @@
{
pixel.red=p->red-(MagickRealType) q->red;
if (fabs(2.0*pixel.red) < quantum_threshold)
- pixel.red=(MagickRealType) GetRedSample(p);
+ pixel.red=(MagickRealType) GetRedPixelComponent(p);
else
pixel.red=(MagickRealType) p->red+(pixel.red*amount);
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
}
if ((channel & GreenChannel) != 0)
{
pixel.green=p->green-(MagickRealType) q->green;
if (fabs(2.0*pixel.green) < quantum_threshold)
- pixel.green=(MagickRealType) GetGreenSample(p);
+ pixel.green=(MagickRealType) GetGreenPixelComponent(p);
else
pixel.green=(MagickRealType) p->green+(pixel.green*amount);
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
}
if ((channel & BlueChannel) != 0)
{
pixel.blue=p->blue-(MagickRealType) q->blue;
if (fabs(2.0*pixel.blue) < quantum_threshold)
- pixel.blue=(MagickRealType) GetBlueSample(p);
+ pixel.blue=(MagickRealType) GetBluePixelComponent(p);
else
pixel.blue=(MagickRealType) p->blue+(pixel.blue*amount);
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
}
if ((channel & OpacityChannel) != 0)
{
pixel.opacity=p->opacity-(MagickRealType) q->opacity;
if (fabs(2.0*pixel.opacity) < quantum_threshold)
- pixel.opacity=(MagickRealType) GetOpacitySample(p);
+ pixel.opacity=(MagickRealType) GetOpacityPixelComponent(p);
else
pixel.opacity=p->opacity+(pixel.opacity*amount);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -5420,7 +5422,7 @@
else
pixel.index=(MagickRealType) unsharp_indexes[x]+(pixel.index*
amount);
- unsharp_indexes[x]=RoundToQuantum(pixel.index);
+ unsharp_indexes[x]=ClampToQuantum(pixel.index);
}
p++;
q++;
diff --git a/magick/enhance.c b/magick/enhance.c
index a411261..ada79a0 100644
--- a/magick/enhance.c
+++ b/magick/enhance.c
@@ -465,13 +465,13 @@
#endif
for (i=0; i <= (long) MaxMap; i++)
{
- cdl_map[i].red=RoundToQuantum((MagickRealType) ScaleMapToQuantum((
+ cdl_map[i].red=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
MagickRealType) (MaxMap*(pow(color_correction.red.slope*i/MaxMap+
color_correction.red.offset,color_correction.red.power)))));
- cdl_map[i].green=RoundToQuantum((MagickRealType) ScaleMapToQuantum((
+ cdl_map[i].green=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
MagickRealType) (MaxMap*(pow(color_correction.green.slope*i/MaxMap+
color_correction.green.offset,color_correction.green.power)))));
- cdl_map[i].blue=RoundToQuantum((MagickRealType) ScaleMapToQuantum((
+ cdl_map[i].blue=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
MagickRealType) (MaxMap*(pow(color_correction.blue.slope*i/MaxMap+
color_correction.blue.offset,color_correction.blue.power)))));
}
@@ -490,12 +490,12 @@
luma=0.2126*image->colormap[i].red+0.7152*image->colormap[i].green+
0.0722*image->colormap[i].blue;
- image->colormap[i].red=RoundToQuantum(luma+color_correction.saturation*
+ image->colormap[i].red=ClampToQuantum(luma+color_correction.saturation*
cdl_map[ScaleQuantumToMap(image->colormap[i].red)].red-luma);
- image->colormap[i].green=RoundToQuantum(luma+
+ image->colormap[i].green=ClampToQuantum(luma+
color_correction.saturation*cdl_map[ScaleQuantumToMap(
image->colormap[i].green)].green-luma);
- image->colormap[i].blue=RoundToQuantum(luma+color_correction.saturation*
+ image->colormap[i].blue=ClampToQuantum(luma+color_correction.saturation*
cdl_map[ScaleQuantumToMap(image->colormap[i].blue)].blue-luma);
}
}
@@ -531,11 +531,11 @@
for (x=0; x < (long) image->columns; x++)
{
luma=0.2126*q->red+0.7152*q->green+0.0722*q->blue;
- q->red=RoundToQuantum(luma+color_correction.saturation*
+ q->red=ClampToQuantum(luma+color_correction.saturation*
(cdl_map[ScaleQuantumToMap(q->red)].red-luma));
- q->green=RoundToQuantum(luma+color_correction.saturation*
+ q->green=ClampToQuantum(luma+color_correction.saturation*
(cdl_map[ScaleQuantumToMap(q->green)].green-luma));
- q->blue=RoundToQuantum(luma+color_correction.saturation*
+ q->blue=ClampToQuantum(luma+color_correction.saturation*
(cdl_map[ScaleQuantumToMap(q->blue)].blue-luma));
q++;
}
@@ -719,7 +719,7 @@
(void) ResamplePixelColor(resample_filter[id],QuantumScale*
PixelIntensity(q)*(clut_image->columns-adjust),QuantumScale*
PixelIntensity(q)*(clut_image->rows-adjust),&pixel);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
else
{
@@ -729,7 +729,7 @@
(void) ResamplePixelColor(resample_filter[id],QuantumScale*
q->opacity*(clut_image->columns-adjust),QuantumScale*
q->opacity* (clut_image->rows-adjust),&pixel);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
}
if ((channel & RedChannel) != 0)
@@ -737,21 +737,21 @@
(void) ResamplePixelColor(resample_filter[id],QuantumScale*q->red*
(clut_image->columns-adjust),QuantumScale*q->red*
(clut_image->rows-adjust),&pixel);
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
}
if ((channel & GreenChannel) != 0)
{
(void) ResamplePixelColor(resample_filter[id],QuantumScale*q->green*
(clut_image->columns-adjust),QuantumScale*q->green*
(clut_image->rows-adjust),&pixel);
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
}
if ((channel & BlueChannel) != 0)
{
(void) ResamplePixelColor(resample_filter[id],QuantumScale*q->blue*
(clut_image->columns-adjust),QuantumScale*q->blue*
(clut_image->rows-adjust),&pixel);
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
@@ -759,7 +759,7 @@
(void) ResamplePixelColor(resample_filter[id],QuantumScale*indexes[x]*
(clut_image->columns-adjust),QuantumScale*indexes[x]*
(clut_image->rows-adjust),&pixel);
- indexes[x]=RoundToQuantum(pixel.index);
+ indexes[x]=ClampToQuantum(pixel.index);
}
q++;
}
@@ -1099,13 +1099,13 @@
for (x=0; x < (long) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- histogram[ScaleQuantumToMap(GetRedSample(p))].red++;
+ histogram[ScaleQuantumToMap(GetRedPixelComponent(p))].red++;
if ((channel & GreenChannel) != 0)
- histogram[ScaleQuantumToMap(GetGreenSample(p))].green++;
+ histogram[ScaleQuantumToMap(GetGreenPixelComponent(p))].green++;
if ((channel & BlueChannel) != 0)
- histogram[ScaleQuantumToMap(GetBlueSample(p))].blue++;
+ histogram[ScaleQuantumToMap(GetBluePixelComponent(p))].blue++;
if ((channel & OpacityChannel) != 0)
- histogram[ScaleQuantumToMap(GetOpacitySample(p))].opacity++;
+ histogram[ScaleQuantumToMap(GetOpacityPixelComponent(p))].opacity++;
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
histogram[ScaleQuantumToMap(indexes[x])].index++;
@@ -1315,25 +1315,25 @@
if ((channel & RedChannel) != 0)
{
if (black.red != white.red)
- image->colormap[i].red=RoundToQuantum(stretch_map[
+ image->colormap[i].red=ClampToQuantum(stretch_map[
ScaleQuantumToMap(image->colormap[i].red)].red);
}
if ((channel & GreenChannel) != 0)
{
if (black.green != white.green)
- image->colormap[i].green=RoundToQuantum(stretch_map[
+ image->colormap[i].green=ClampToQuantum(stretch_map[
ScaleQuantumToMap(image->colormap[i].green)].green);
}
if ((channel & BlueChannel) != 0)
{
if (black.blue != white.blue)
- image->colormap[i].blue=RoundToQuantum(stretch_map[
+ image->colormap[i].blue=ClampToQuantum(stretch_map[
ScaleQuantumToMap(image->colormap[i].blue)].blue);
}
if ((channel & OpacityChannel) != 0)
{
if (black.opacity != white.opacity)
- image->colormap[i].opacity=RoundToQuantum(stretch_map[
+ image->colormap[i].opacity=ClampToQuantum(stretch_map[
ScaleQuantumToMap(image->colormap[i].opacity)].opacity);
}
}
@@ -1371,31 +1371,31 @@
if ((channel & RedChannel) != 0)
{
if (black.red != white.red)
- q->red=RoundToQuantum(stretch_map[ScaleQuantumToMap(q->red)].red);
+ q->red=ClampToQuantum(stretch_map[ScaleQuantumToMap(q->red)].red);
}
if ((channel & GreenChannel) != 0)
{
if (black.green != white.green)
- q->green=RoundToQuantum(stretch_map[ScaleQuantumToMap(
+ q->green=ClampToQuantum(stretch_map[ScaleQuantumToMap(
q->green)].green);
}
if ((channel & BlueChannel) != 0)
{
if (black.blue != white.blue)
- q->blue=RoundToQuantum(stretch_map[ScaleQuantumToMap(
+ q->blue=ClampToQuantum(stretch_map[ScaleQuantumToMap(
q->blue)].blue);
}
if ((channel & OpacityChannel) != 0)
{
if (black.opacity != white.opacity)
- q->opacity=RoundToQuantum(stretch_map[ScaleQuantumToMap(
+ q->opacity=ClampToQuantum(stretch_map[ScaleQuantumToMap(
q->opacity)].opacity);
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
if (black.index != white.index)
- indexes[x]=(IndexPacket) RoundToQuantum(stretch_map[
+ indexes[x]=(IndexPacket) ClampToQuantum(stretch_map[
ScaleQuantumToMap(indexes[x])].index);
}
q++;
@@ -1720,13 +1720,13 @@
for (x=0; x < (long) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- histogram[ScaleQuantumToMap(GetRedSample(p))].red++;
+ histogram[ScaleQuantumToMap(GetRedPixelComponent(p))].red++;
if ((channel & GreenChannel) != 0)
- histogram[ScaleQuantumToMap(GetGreenSample(p))].green++;
+ histogram[ScaleQuantumToMap(GetGreenPixelComponent(p))].green++;
if ((channel & BlueChannel) != 0)
- histogram[ScaleQuantumToMap(GetBlueSample(p))].blue++;
+ histogram[ScaleQuantumToMap(GetBluePixelComponent(p))].blue++;
if ((channel & OpacityChannel) != 0)
- histogram[ScaleQuantumToMap(GetOpacitySample(p))].opacity++;
+ histogram[ScaleQuantumToMap(GetOpacityPixelComponent(p))].opacity++;
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
histogram[ScaleQuantumToMap(indexes[x])].index++;
@@ -1792,17 +1792,17 @@
for (i=0; i < (long) image->colors; i++)
{
if (((channel & RedChannel) != 0) && (white.red != black.red))
- image->colormap[i].red=RoundToQuantum(equalize_map[
+ image->colormap[i].red=ClampToQuantum(equalize_map[
ScaleQuantumToMap(image->colormap[i].red)].red);
if (((channel & GreenChannel) != 0) && (white.green != black.green))
- image->colormap[i].green=RoundToQuantum(equalize_map[
+ image->colormap[i].green=ClampToQuantum(equalize_map[
ScaleQuantumToMap(image->colormap[i].green)].green);
if (((channel & BlueChannel) != 0) && (white.blue != black.blue))
- image->colormap[i].blue=RoundToQuantum(equalize_map[
+ image->colormap[i].blue=ClampToQuantum(equalize_map[
ScaleQuantumToMap(image->colormap[i].blue)].blue);
if (((channel & OpacityChannel) != 0) &&
(white.opacity != black.opacity))
- image->colormap[i].opacity=RoundToQuantum(equalize_map[
+ image->colormap[i].opacity=ClampToQuantum(equalize_map[
ScaleQuantumToMap(image->colormap[i].opacity)].opacity);
}
}
@@ -1839,19 +1839,19 @@
for (x=0; x < (long) image->columns; x++)
{
if (((channel & RedChannel) != 0) && (white.red != black.red))
- q->red=RoundToQuantum(equalize_map[ScaleQuantumToMap(q->red)].red);
+ q->red=ClampToQuantum(equalize_map[ScaleQuantumToMap(q->red)].red);
if (((channel & GreenChannel) != 0) && (white.green != black.green))
- q->green=RoundToQuantum(equalize_map[ScaleQuantumToMap(
+ q->green=ClampToQuantum(equalize_map[ScaleQuantumToMap(
q->green)].green);
if (((channel & BlueChannel) != 0) && (white.blue != black.blue))
- q->blue=RoundToQuantum(equalize_map[ScaleQuantumToMap(q->blue)].blue);
+ q->blue=ClampToQuantum(equalize_map[ScaleQuantumToMap(q->blue)].blue);
if (((channel & OpacityChannel) != 0) && (white.opacity != black.opacity))
- q->opacity=RoundToQuantum(equalize_map[ScaleQuantumToMap(
+ q->opacity=ClampToQuantum(equalize_map[ScaleQuantumToMap(
q->opacity)].opacity);
if ((((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace)) &&
(white.index != black.index))
- indexes[x]=RoundToQuantum(equalize_map[ScaleQuantumToMap(
+ indexes[x]=ClampToQuantum(equalize_map[ScaleQuantumToMap(
indexes[x])].index);
q++;
}
@@ -1993,7 +1993,7 @@
#pragma omp parallel for schedule(dynamic,4)
#endif
for (i=0; i <= (long) MaxMap; i++)
- gamma_map[i]=RoundToQuantum((MagickRealType) ScaleMapToQuantum((
+ gamma_map[i]=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
MagickRealType) (MaxMap*pow((double) i/MaxMap,1.0/gamma))));
if (image->storage_class == PseudoClass)
{
@@ -2289,16 +2289,16 @@
MagickPixelCompositeAreaBlend(&pixel3,pixel3.opacity,&pixel4,
pixel4.opacity,point.z,&pixel);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue);
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- indexes[x]=RoundToQuantum(pixel.index);
+ indexes[x]=ClampToQuantum(pixel.index);
q++;
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -2465,7 +2465,7 @@
const double gamma)
{
#define LevelImageTag "Level/Image"
-#define LevelValue(x) (RoundToQuantum((MagickRealType) QuantumRange* \
+#define LevelValue(x) (ClampToQuantum((MagickRealType) QuantumRange* \
pow(((double) (x)-black_point)/(white_point-black_point),1.0/gamma)))
CacheView
@@ -2621,7 +2621,7 @@
const double gamma)
{
#define LevelizeImageTag "Levelize/Image"
-#define LevelizeValue(x) (RoundToQuantum(((MagickRealType) \
+#define LevelizeValue(x) (ClampToQuantum(((MagickRealType) \
pow((double)(QuantumScale*(x)),1.0/gamma))*(white_point-black_point)+ \
black_point))
@@ -3638,16 +3638,16 @@
for (i=0; i < (long) image->colors; i++)
{
if ((channel & RedChannel) != 0)
- image->colormap[i].red=RoundToQuantum(sigmoidal_map[
+ image->colormap[i].red=ClampToQuantum(sigmoidal_map[
ScaleQuantumToMap(image->colormap[i].red)]);
if ((channel & GreenChannel) != 0)
- image->colormap[i].green=RoundToQuantum(sigmoidal_map[
+ image->colormap[i].green=ClampToQuantum(sigmoidal_map[
ScaleQuantumToMap(image->colormap[i].green)]);
if ((channel & BlueChannel) != 0)
- image->colormap[i].blue=RoundToQuantum(sigmoidal_map[
+ image->colormap[i].blue=ClampToQuantum(sigmoidal_map[
ScaleQuantumToMap(image->colormap[i].blue)]);
if ((channel & OpacityChannel) != 0)
- image->colormap[i].opacity=RoundToQuantum(sigmoidal_map[
+ image->colormap[i].opacity=ClampToQuantum(sigmoidal_map[
ScaleQuantumToMap(image->colormap[i].opacity)]);
}
}
@@ -3684,16 +3684,16 @@
for (x=0; x < (long) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(sigmoidal_map[ScaleQuantumToMap(q->red)]);
+ q->red=ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(q->red)]);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(sigmoidal_map[ScaleQuantumToMap(q->green)]);
+ q->green=ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(q->green)]);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(sigmoidal_map[ScaleQuantumToMap(q->blue)]);
+ q->blue=ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(q->blue)]);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(sigmoidal_map[ScaleQuantumToMap(q->opacity)]);
+ q->opacity=ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(q->opacity)]);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- indexes[x]=(IndexPacket) RoundToQuantum(sigmoidal_map[
+ indexes[x]=(IndexPacket) ClampToQuantum(sigmoidal_map[
ScaleQuantumToMap(indexes[x])]);
q++;
}
diff --git a/magick/fourier.c b/magick/fourier.c
index 7a82c24..2c19962 100644
--- a/magick/fourier.c
+++ b/magick/fourier.c
@@ -291,32 +291,32 @@
case RedChannel:
default:
{
- q->red=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ q->red=ClampToQuantum(QuantumRange*magnitude_source[i]);
break;
}
case GreenChannel:
{
- q->green=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ q->green=ClampToQuantum(QuantumRange*magnitude_source[i]);
break;
}
case BlueChannel:
{
- q->blue=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ q->blue=ClampToQuantum(QuantumRange*magnitude_source[i]);
break;
}
case OpacityChannel:
{
- q->opacity=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ q->opacity=ClampToQuantum(QuantumRange*magnitude_source[i]);
break;
}
case IndexChannel:
{
- indexes[x]=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ indexes[x]=ClampToQuantum(QuantumRange*magnitude_source[i]);
break;
}
case GrayChannels:
{
- q->red=RoundToQuantum(QuantumRange*magnitude_source[i]);
+ q->red=ClampToQuantum(QuantumRange*magnitude_source[i]);
q->green=q->red;
q->blue=q->red;
break;
@@ -344,32 +344,32 @@
case RedChannel:
default:
{
- q->red=RoundToQuantum(QuantumRange*phase_source[i]);
+ q->red=ClampToQuantum(QuantumRange*phase_source[i]);
break;
}
case GreenChannel:
{
- q->green=RoundToQuantum(QuantumRange*phase_source[i]);
+ q->green=ClampToQuantum(QuantumRange*phase_source[i]);
break;
}
case BlueChannel:
{
- q->blue=RoundToQuantum(QuantumRange*phase_source[i]);
+ q->blue=ClampToQuantum(QuantumRange*phase_source[i]);
break;
}
case OpacityChannel:
{
- q->opacity=RoundToQuantum(QuantumRange*phase_source[i]);
+ q->opacity=ClampToQuantum(QuantumRange*phase_source[i]);
break;
}
case IndexChannel:
{
- indexes[x]=RoundToQuantum(QuantumRange*phase_source[i]);
+ indexes[x]=ClampToQuantum(QuantumRange*phase_source[i]);
break;
}
case GrayChannels:
{
- q->red=RoundToQuantum(QuantumRange*phase_source[i]);
+ q->red=ClampToQuantum(QuantumRange*phase_source[i]);
q->green=q->red;
q->blue=q->red;
break;
@@ -447,22 +447,22 @@
case RedChannel:
default:
{
- source[i]=QuantumScale*GetRedSample(p);
+ source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
case GreenChannel:
{
- source[i]=QuantumScale*GetGreenSample(p);
+ source[i]=QuantumScale*GetGreenPixelComponent(p);
break;
}
case BlueChannel:
{
- source[i]=QuantumScale*GetBlueSample(p);
+ source[i]=QuantumScale*GetBluePixelComponent(p);
break;
}
case OpacityChannel:
{
- source[i]=QuantumScale*GetOpacitySample(p);
+ source[i]=QuantumScale*GetOpacityPixelComponent(p);
break;
}
case IndexChannel:
@@ -472,7 +472,7 @@
}
case GrayChannels:
{
- source[i]=QuantumScale*GetRedSample(p);
+ source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
}
@@ -845,22 +845,22 @@
case RedChannel:
default:
{
- magnitude_source[i]=QuantumScale*GetRedSample(p);
+ magnitude_source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
case GreenChannel:
{
- magnitude_source[i]=QuantumScale*GetGreenSample(p);
+ magnitude_source[i]=QuantumScale*GetGreenPixelComponent(p);
break;
}
case BlueChannel:
{
- magnitude_source[i]=QuantumScale*GetBlueSample(p);
+ magnitude_source[i]=QuantumScale*GetBluePixelComponent(p);
break;
}
case OpacityChannel:
{
- magnitude_source[i]=QuantumScale*GetOpacitySample(p);
+ magnitude_source[i]=QuantumScale*GetOpacityPixelComponent(p);
break;
}
case IndexChannel:
@@ -870,7 +870,7 @@
}
case GrayChannels:
{
- magnitude_source[i]=QuantumScale*GetRedSample(p);
+ magnitude_source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
}
@@ -894,22 +894,22 @@
case RedChannel:
default:
{
- phase_source[i]=QuantumScale*GetRedSample(p);
+ phase_source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
case GreenChannel:
{
- phase_source[i]=QuantumScale*GetGreenSample(p);
+ phase_source[i]=QuantumScale*GetGreenPixelComponent(p);
break;
}
case BlueChannel:
{
- phase_source[i]=QuantumScale*GetBlueSample(p);
+ phase_source[i]=QuantumScale*GetBluePixelComponent(p);
break;
}
case OpacityChannel:
{
- phase_source[i]=QuantumScale*GetOpacitySample(p);
+ phase_source[i]=QuantumScale*GetOpacityPixelComponent(p);
break;
}
case IndexChannel:
@@ -919,7 +919,7 @@
}
case GrayChannels:
{
- phase_source[i]=QuantumScale*GetRedSample(p);
+ phase_source[i]=QuantumScale*GetRedPixelComponent(p);
break;
}
}
@@ -1048,32 +1048,32 @@
case RedChannel:
default:
{
- q->red=RoundToQuantum(QuantumRange*source[i]);
+ q->red=ClampToQuantum(QuantumRange*source[i]);
break;
}
case GreenChannel:
{
- q->green=RoundToQuantum(QuantumRange*source[i]);
+ q->green=ClampToQuantum(QuantumRange*source[i]);
break;
}
case BlueChannel:
{
- q->blue=RoundToQuantum(QuantumRange*source[i]);
+ q->blue=ClampToQuantum(QuantumRange*source[i]);
break;
}
case OpacityChannel:
{
- q->opacity=RoundToQuantum(QuantumRange*source[i]);
+ q->opacity=ClampToQuantum(QuantumRange*source[i]);
break;
}
case IndexChannel:
{
- indexes[x]=RoundToQuantum(QuantumRange*source[i]);
+ indexes[x]=ClampToQuantum(QuantumRange*source[i]);
break;
}
case GrayChannels:
{
- q->red=RoundToQuantum(QuantumRange*source[i]);
+ q->red=ClampToQuantum(QuantumRange*source[i]);
q->green=q->red;
q->blue=q->red;
break;
diff --git a/magick/fx.c b/magick/fx.c
index 8400d40..1a832ac 100644
--- a/magick/fx.c
+++ b/magick/fx.c
@@ -71,6 +71,7 @@
#include "magick/pixel-private.h"
#include "magick/property.h"
#include "magick/quantum.h"
+#include "magick/quantum-private.h"
#include "magick/random_.h"
#include "magick/random-private.h"
#include "magick/resample.h"
@@ -374,20 +375,20 @@
for (x=0; x < (long) image->columns; x++)
{
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(GenerateDifferentialNoise(random_info[id],
+ q->red=ClampToQuantum(GenerateDifferentialNoise(random_info[id],
p->red,noise_type,attenuate));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(GenerateDifferentialNoise(random_info[id],
+ q->green=ClampToQuantum(GenerateDifferentialNoise(random_info[id],
p->green,noise_type,attenuate));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(GenerateDifferentialNoise(random_info[id],
+ q->blue=ClampToQuantum(GenerateDifferentialNoise(random_info[id],
p->blue,noise_type,attenuate));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(GenerateDifferentialNoise(random_info[id],
+ q->opacity=ClampToQuantum(GenerateDifferentialNoise(random_info[id],
p->opacity,noise_type,attenuate));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- noise_indexes[x]=(IndexPacket) RoundToQuantum(GenerateDifferentialNoise(
+ noise_indexes[x]=(IndexPacket) ClampToQuantum(GenerateDifferentialNoise(
random_info[id],indexes[x],noise_type,attenuate));
p++;
q++;
@@ -525,25 +526,25 @@
}
for (x=0; x < (long) image->columns; x++)
{
- quantum=GetRedSample(p);
+ quantum=GetRedPixelComponent(p);
if (p->green < quantum)
- quantum=GetGreenSample(p);
+ quantum=GetGreenPixelComponent(p);
if (p->blue < quantum)
- quantum=GetBlueSample(p);
+ quantum=GetBluePixelComponent(p);
pixel.red=0.5*(p->red+factor*quantum);
pixel.green=0.5*(p->green+factor*quantum);
pixel.blue=0.5*(p->blue+factor*quantum);
- quantum=GetRedSample(p);
+ quantum=GetRedPixelComponent(p);
if (p->green > quantum)
- quantum=GetGreenSample(p);
+ quantum=GetGreenPixelComponent(p);
if (p->blue > quantum)
- quantum=GetBlueSample(p);
+ quantum=GetBluePixelComponent(p);
pixel.red=0.5*(pixel.red+factor*quantum);
pixel.green=0.5*(pixel.green+factor*quantum);
pixel.blue=0.5*(pixel.blue+factor*quantum);
- q->red=RoundToQuantum(pixel.red);
- q->green=RoundToQuantum(pixel.green);
- q->blue=RoundToQuantum(pixel.blue);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
p++;
q++;
}
@@ -1062,7 +1063,7 @@
break;
}
}
- return(RoundToQuantum(result));
+ return(ClampToQuantum(result));
}
MagickExport MagickBooleanType EvaluateImage(Image *image,
@@ -1295,7 +1296,7 @@
case UndefinedFunction:
break;
}
- return(RoundToQuantum(result));
+ return(ClampToQuantum(result));
}
MagickExport MagickBooleanType FunctionImage(Image *image,
@@ -1979,8 +1980,8 @@
lightness,
saturation;
- ConvertRGBToHSL(RoundToQuantum(pixel.red),RoundToQuantum(pixel.green),
- RoundToQuantum(pixel.blue),&hue,&saturation,&lightness);
+ ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
+ ClampToQuantum(pixel.blue),&hue,&saturation,&lightness);
return(hue);
}
break;
@@ -2023,8 +2024,8 @@
lightness,
saturation;
- ConvertRGBToHSL(RoundToQuantum(pixel.red),RoundToQuantum(pixel.green),
- RoundToQuantum(pixel.blue),&hue,&saturation,&lightness);
+ ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
+ ClampToQuantum(pixel.blue),&hue,&saturation,&lightness);
return(lightness);
}
if (LocaleCompare(symbol,"luminance") == 0)
@@ -2098,8 +2099,8 @@
lightness,
saturation;
- ConvertRGBToHSL(RoundToQuantum(pixel.red),RoundToQuantum(pixel.green),
- RoundToQuantum(pixel.blue),&hue,&saturation,&lightness);
+ ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
+ ClampToQuantum(pixel.blue),&hue,&saturation,&lightness);
return(saturation);
}
if (LocaleNCompare(symbol,"skewness",8) == 0)
@@ -3213,28 +3214,28 @@
{
(void) FxEvaluateChannelExpression(fx_info[id],RedChannel,x,y,
&alpha,exception);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*alpha);
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*alpha);
}
if ((channel & GreenChannel) != 0)
{
(void) FxEvaluateChannelExpression(fx_info[id],GreenChannel,x,y,
&alpha,exception);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*alpha);
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*alpha);
}
if ((channel & BlueChannel) != 0)
{
(void) FxEvaluateChannelExpression(fx_info[id],BlueChannel,x,y,
&alpha,exception);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*alpha);
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*alpha);
}
if ((channel & OpacityChannel) != 0)
{
(void) FxEvaluateChannelExpression(fx_info[id],OpacityChannel,x,y,
&alpha,exception);
if (image->matte == MagickFalse)
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange*alpha);
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange*alpha);
else
- q->opacity=RoundToQuantum((MagickRealType) (QuantumRange-
+ q->opacity=ClampToQuantum((MagickRealType) (QuantumRange-
QuantumRange*alpha));
}
if (((channel & IndexChannel) != 0) &&
@@ -3242,7 +3243,7 @@
{
(void) FxEvaluateChannelExpression(fx_info[id],IndexChannel,x,y,
&alpha,exception);
- fx_indexes[x]=(IndexPacket) RoundToQuantum((MagickRealType)
+ fx_indexes[x]=(IndexPacket) ClampToQuantum((MagickRealType)
QuantumRange*alpha);
}
q++;
@@ -3633,10 +3634,10 @@
}
for (x=0; x < (long) morph_images->columns; x++)
{
- q->red=RoundToQuantum(alpha*q->red+beta*GetRedSample(p));
- q->green=RoundToQuantum(alpha*q->green+beta*GetGreenSample(p));
- q->blue=RoundToQuantum(alpha*q->blue+beta*GetBlueSample(p));
- q->opacity=RoundToQuantum(alpha*q->opacity+beta*GetOpacitySample(p));
+ q->red=ClampToQuantum(alpha*q->red+beta*GetRedPixelComponent(p));
+ q->green=ClampToQuantum(alpha*q->green+beta*GetGreenPixelComponent(p));
+ q->blue=ClampToQuantum(alpha*q->blue+beta*GetBluePixelComponent(p));
+ q->opacity=ClampToQuantum(alpha*q->opacity+beta*GetOpacityPixelComponent(p));
p++;
q++;
}
@@ -3722,7 +3723,7 @@
Quantum
plasma;
- plasma=RoundToQuantum(pixel+noise*GetPseudoRandomValue(random_info)-
+ plasma=ClampToQuantum(pixel+noise*GetPseudoRandomValue(random_info)-
noise/2.0);
return(plasma);
}
@@ -4268,7 +4269,7 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*GetRedSample(p));
+ q->red=ClampToQuantum(k[0]*GetRedPixelComponent(p));
p++;
q++;
}
@@ -4278,8 +4279,8 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*p->red+k[1]*GetGreenSample(p));
- q->green=RoundToQuantum(k[2]*p->red+k[3]*GetGreenSample(p));
+ q->red=ClampToQuantum(k[0]*p->red+k[1]*GetGreenPixelComponent(p));
+ q->green=ClampToQuantum(k[2]*p->red+k[3]*GetGreenPixelComponent(p));
p++;
q++;
}
@@ -4289,9 +4290,9 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*p->red+k[1]*p->green+k[2]*GetBlueSample(p));
- q->green=RoundToQuantum(k[3]*p->red+k[4]*p->green+k[5]*GetBlueSample(p));
- q->blue=RoundToQuantum(k[6]*p->red+k[7]*p->green+k[8]*GetBlueSample(p));
+ q->red=ClampToQuantum(k[0]*p->red+k[1]*p->green+k[2]*GetBluePixelComponent(p));
+ q->green=ClampToQuantum(k[3]*p->red+k[4]*p->green+k[5]*GetBluePixelComponent(p));
+ q->blue=ClampToQuantum(k[6]*p->red+k[7]*p->green+k[8]*GetBluePixelComponent(p));
p++;
q++;
}
@@ -4301,11 +4302,11 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
+ q->red=ClampToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
k[12]*QuantumRange);
- q->green=RoundToQuantum(k[4]*p->red+k[5]*p->green+k[6]*p->blue+
+ q->green=ClampToQuantum(k[4]*p->red+k[5]*p->green+k[6]*p->blue+
k[13]*QuantumRange);
- q->blue=RoundToQuantum(k[8]*p->red+k[9]*p->green+k[10]*p->blue+
+ q->blue=ClampToQuantum(k[8]*p->red+k[9]*p->green+k[10]*p->blue+
k[14]*QuantumRange);
p++;
q++;
@@ -4316,16 +4317,16 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
- k[3]*(QuantumRange-GetOpacitySample(p))+k[20]*QuantumRange);
- q->green=RoundToQuantum(k[5]*p->red+k[6]*p->green+k[7]*p->blue+
- k[8]*(QuantumRange-GetOpacitySample(p))+k[21]*QuantumRange);
- q->blue=RoundToQuantum(k[10]*p->red+k[11]*p->green+k[12]*p->blue+
- k[13]*(QuantumRange-GetOpacitySample(p))+k[22]*QuantumRange);
+ q->red=ClampToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
+ k[3]*(QuantumRange-GetOpacityPixelComponent(p))+k[20]*QuantumRange);
+ q->green=ClampToQuantum(k[5]*p->red+k[6]*p->green+k[7]*p->blue+
+ k[8]*(QuantumRange-GetOpacityPixelComponent(p))+k[21]*QuantumRange);
+ q->blue=ClampToQuantum(k[10]*p->red+k[11]*p->green+k[12]*p->blue+
+ k[13]*(QuantumRange-GetOpacityPixelComponent(p))+k[22]*QuantumRange);
if (image->matte != MagickFalse)
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange-(k[15]*
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange-(k[15]*
p->red+k[16]*p->green+k[17]*p->blue+k[18]*(QuantumRange-
- GetOpacitySample(p))+k[23]*QuantumRange));
+ GetOpacityPixelComponent(p))+k[23]*QuantumRange));
p++;
q++;
}
@@ -4335,23 +4336,23 @@
{
for (x=0; x < (long) image->columns; x++)
{
- q->red=RoundToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
- k[3]*indexes[x]+k[4]*((Quantum) QuantumRange-GetOpacitySample(p))+
+ q->red=ClampToQuantum(k[0]*p->red+k[1]*p->green+k[2]*p->blue+
+ k[3]*indexes[x]+k[4]*((Quantum) QuantumRange-GetOpacityPixelComponent(p))+
k[30]*QuantumRange);
- q->green=RoundToQuantum(k[6]*p->red+k[7]*p->green+k[8]*p->blue+
- k[9]*indexes[x]+k[10]*((Quantum) QuantumRange-GetOpacitySample(p))+
+ q->green=ClampToQuantum(k[6]*p->red+k[7]*p->green+k[8]*p->blue+
+ k[9]*indexes[x]+k[10]*((Quantum) QuantumRange-GetOpacityPixelComponent(p))+
k[31]*QuantumRange);
- q->blue=RoundToQuantum(k[12]*p->red+k[13]*p->green+k[14]*p->blue+
- k[15]*indexes[x]+k[16]*((Quantum) QuantumRange-GetOpacitySample(p))+
+ q->blue=ClampToQuantum(k[12]*p->red+k[13]*p->green+k[14]*p->blue+
+ k[15]*indexes[x]+k[16]*((Quantum) QuantumRange-GetOpacityPixelComponent(p))+
k[32]*QuantumRange);
if (image->matte != MagickFalse)
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange-(k[24]*
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange-(k[24]*
p->red+k[25]*p->green+k[26]*p->blue+k[27]*indexes[x]+
- k[28]*(QuantumRange-GetOpacitySample(p))+k[34]*QuantumRange));
+ k[28]*(QuantumRange-GetOpacityPixelComponent(p))+k[34]*QuantumRange));
if (image->colorspace == CMYKColorspace)
- recolor_indexes[x]=RoundToQuantum(k[18]*p->red+k[19]*p->green+k[20]*
+ recolor_indexes[x]=ClampToQuantum(k[18]*p->red+k[19]*p->green+k[20]*
p->blue+k[21]*indexes[x]+k[22]*((Quantum) QuantumRange-
- GetOpacitySample(p))+k[33]*QuantumRange);
+ GetOpacityPixelComponent(p))+k[33]*QuantumRange);
p++;
q++;
}
@@ -4487,17 +4488,17 @@
intensity=(MagickRealType) PixelIntensityToQuantum(p);
tone=intensity > threshold ? (MagickRealType) QuantumRange : intensity+
(MagickRealType) QuantumRange-threshold;
- q->red=RoundToQuantum(tone);
+ q->red=ClampToQuantum(tone);
tone=intensity > (7.0*threshold/6.0) ? (MagickRealType) QuantumRange :
intensity+(MagickRealType) QuantumRange-7.0*threshold/6.0;
- q->green=RoundToQuantum(tone);
+ q->green=ClampToQuantum(tone);
tone=intensity < (threshold/6.0) ? 0 : intensity-threshold/6.0;
- q->blue=RoundToQuantum(tone);
+ q->blue=ClampToQuantum(tone);
tone=threshold/7.0;
if ((MagickRealType) q->green < tone)
- q->green=RoundToQuantum(tone);
+ q->green=ClampToQuantum(tone);
if ((MagickRealType) q->blue < tone)
- q->blue=RoundToQuantum(tone);
+ q->blue=ClampToQuantum(tone);
p++;
q++;
}
@@ -4640,7 +4641,7 @@
if (border_image->matte == MagickFalse)
q->opacity=border_image->background_color.opacity;
else
- q->opacity=RoundToQuantum((MagickRealType) (QuantumRange-(QuantumRange-
+ q->opacity=ClampToQuantum((MagickRealType) (QuantumRange-(QuantumRange-
q->opacity)*opacity/100.0));
q++;
}
@@ -5221,7 +5222,7 @@
break;
for (x=0; x < (long) stereo_image->columns; x++)
{
- r->red=GetRedSample(p);
+ r->red=GetRedPixelComponent(p);
r->green=q->green;
r->blue=q->blue;
r->opacity=(Quantum) ((p->opacity+q->opacity)/2);
@@ -5579,16 +5580,16 @@
weight=QuantumScale*p->red-0.5;
pixel.red=(MagickRealType) p->red+color_vector.red*(1.0-(4.0*
(weight*weight)));
- q->red=RoundToQuantum(pixel.red);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
weight=QuantumScale*p->green-0.5;
pixel.green=(MagickRealType) p->green+color_vector.green*(1.0-(4.0*
(weight*weight)));
- q->green=RoundToQuantum(pixel.green);
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
weight=QuantumScale*p->blue-0.5;
pixel.blue=(MagickRealType) p->blue+color_vector.blue*(1.0-(4.0*
(weight*weight)));
- q->blue=RoundToQuantum(pixel.blue);
- SetOpacitySample(q,GetOpacitySample(p));
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
diff --git a/magick/gem.c b/magick/gem.c
index 60b0a2c..a3ff4e7 100644
--- a/magick/gem.c
+++ b/magick/gem.c
@@ -100,7 +100,7 @@
assert(blue != (Quantum *) NULL);
if (saturation == 0.0)
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
*green=(*red);
*blue=(*red);
return;
@@ -115,44 +115,44 @@
case 0:
default:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
- *green=RoundToQuantum((MagickRealType) QuantumRange*t);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*p);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*t);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
break;
}
case 1:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*q);
- *green=RoundToQuantum((MagickRealType) QuantumRange*brightness);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*p);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*q);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
break;
}
case 2:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*p);
- *green=RoundToQuantum((MagickRealType) QuantumRange*brightness);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*t);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*t);
break;
}
case 3:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*p);
- *green=RoundToQuantum((MagickRealType) QuantumRange*q);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*q);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
break;
}
case 4:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*t);
- *green=RoundToQuantum((MagickRealType) QuantumRange*p);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*t);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
break;
}
case 5:
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
- *green=RoundToQuantum((MagickRealType) QuantumRange*p);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*q);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*q);
break;
}
}
@@ -220,7 +220,7 @@
assert(blue != (Quantum *) NULL);
if (saturation == 0)
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*lightness);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*lightness);
*green=(*red);
*blue=(*red);
return;
@@ -233,9 +233,9 @@
r=ConvertHueToRGB(m1,m2,hue+1.0/3.0);
g=ConvertHueToRGB(m1,m2,hue);
b=ConvertHueToRGB(m1,m2,hue-1.0/3.0);
- *red=RoundToQuantum((MagickRealType) QuantumRange*r);
- *green=RoundToQuantum((MagickRealType) QuantumRange*g);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
}
/*
@@ -288,9 +288,9 @@
v=1.0-blackness;
if (hue == 0.0)
{
- *red=RoundToQuantum((MagickRealType) QuantumRange*v);
- *green=RoundToQuantum((MagickRealType) QuantumRange*v);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*v);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*v);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*v);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*v);
return;
}
i=(long) floor(6.0*hue);
@@ -309,9 +309,9 @@
case 4: r=n; g=whiteness; b=v; break;
case 5: r=v; g=whiteness; b=n; break;
}
- *red=RoundToQuantum((MagickRealType) QuantumRange*r);
- *green=RoundToQuantum((MagickRealType) QuantumRange*g);
- *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+ *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+ *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+ *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
}
/*
diff --git a/magick/histogram.c b/magick/histogram.c
index 5ef6caa..9d02236 100644
--- a/magick/histogram.c
+++ b/magick/histogram.c
@@ -161,11 +161,11 @@
id;
id=(unsigned long) (
- ((ScaleQuantumToChar(RoundToQuantum(pixel->red)) >> index) & 0x01) |
- ((ScaleQuantumToChar(RoundToQuantum(pixel->green)) >> index) & 0x01) << 1 |
- ((ScaleQuantumToChar(RoundToQuantum(pixel->blue)) >> index) & 0x01) << 2);
+ ((ScaleQuantumToChar(ClampToQuantum(pixel->red)) >> index) & 0x01) |
+ ((ScaleQuantumToChar(ClampToQuantum(pixel->green)) >> index) & 0x01) << 1 |
+ ((ScaleQuantumToChar(ClampToQuantum(pixel->blue)) >> index) & 0x01) << 2);
if (image->matte != MagickFalse)
- id|=((ScaleQuantumToChar(RoundToQuantum(pixel->opacity)) >> index) &
+ id|=((ScaleQuantumToChar(ClampToQuantum(pixel->opacity)) >> index) &
0x01) << 3;
return(id);
}
diff --git a/magick/image.c b/magick/image.c
index 7145121..4557bda 100644
--- a/magick/image.c
+++ b/magick/image.c
@@ -589,12 +589,12 @@
append_indexes=GetCacheViewAuthenticIndexQueue(append_view);
for (x=0; x < (long) image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
append_indexes[x]=indexes[x];
p++;
@@ -1135,7 +1135,7 @@
q=pixels;
for (x=0; x < (long) combine_image->columns; x++)
{
- q->red=PixelIntensityToQuantum(p);
+ SetRedPixelComponent(q,PixelIntensityToQuantum(p));
p++;
q++;
}
@@ -1151,7 +1151,7 @@
q=pixels;
for (x=0; x < (long) combine_image->columns; x++)
{
- q->green=PixelIntensityToQuantum(p);
+ SetGreenPixelComponent(q,PixelIntensityToQuantum(p));
p++;
q++;
}
@@ -1167,7 +1167,7 @@
q=pixels;
for (x=0; x < (long) combine_image->columns; x++)
{
- q->blue=PixelIntensityToQuantum(p);
+ SetBluePixelComponent(q,PixelIntensityToQuantum(p));
p++;
q++;
}
@@ -1183,7 +1183,7 @@
q=pixels;
for (x=0; x < (long) combine_image->columns; x++)
{
- q->opacity=PixelIntensityToQuantum(p);
+ SetOpacityPixelComponent(q,PixelIntensityToQuantum(p));
p++;
q++;
}
diff --git a/magick/morphology.c b/magick/morphology.c
index cd48b76..680406a 100644
--- a/magick/morphology.c
+++ b/magick/morphology.c
@@ -1126,11 +1126,11 @@
/* incr change if the value being assigned changed */
#define Assign(channel,value) \
- { q->channel = RoundToQuantum(value); \
+ { q->channel = ClampToQuantum(value); \
if ( p[r].channel != q->channel ) changed++; \
}
#define AssignIndex(value) \
- { q_indexes[x] = RoundToQuantum(value); \
+ { q_indexes[x] = ClampToQuantum(value); \
if ( p_indexes[r] != q_indexes[x] ) changed++; \
}
@@ -1522,24 +1522,24 @@
** which may have a distance that reachs a maximum gradient.
*/
if ((channel & RedChannel) != 0)
- { q->red = RoundToQuantum(result.red);
+ { q->red = ClampToQuantum(result.red);
if ( q->red == QuantumRange ) changed++; /* more to do */
}
if ((channel & GreenChannel) != 0)
- { q->green = RoundToQuantum(result.green);
+ { q->green = ClampToQuantum(result.green);
if ( q->green == QuantumRange ) changed++; /* more to do */
}
if ((channel & BlueChannel) != 0)
- { q->blue = RoundToQuantum(result.blue);
+ { q->blue = ClampToQuantum(result.blue);
if ( q->blue == QuantumRange ) changed++; /* more to do */
}
if ((channel & OpacityChannel) != 0)
- { q->opacity = RoundToQuantum(QuantumRange-result.opacity);
+ { q->opacity = ClampToQuantum(QuantumRange-result.opacity);
if ( q->opacity == 0 ) changed++; /* more to do */
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- { q_indexes[x] = RoundToQuantum(result.index);
+ { q_indexes[x] = ClampToQuantum(result.index);
if ( q_indexes[x] == QuantumRange ) changed++;
}
#endif
diff --git a/magick/nt-feature.c b/magick/nt-feature.c
index 51fe204..aad7f80 100644
--- a/magick/nt-feature.c
+++ b/magick/nt-feature.c
@@ -200,9 +200,9 @@
/* Transfer pixels, scaling to Quantum */
for( x=page.width ; x> 0 ; x-- )
{
- q->rgbRed = ScaleQuantumToChar(GetRedSample(p));
- q->rgbGreen = ScaleQuantumToChar(GetGreenSample(p));
- q->rgbBlue = ScaleQuantumToChar(GetBlueSample(p));
+ q->rgbRed = ScaleQuantumToChar(GetRedPixelComponent(p));
+ q->rgbGreen = ScaleQuantumToChar(GetGreenPixelComponent(p));
+ q->rgbBlue = ScaleQuantumToChar(GetBluePixelComponent(p));
q->rgbReserved = 0;
++q;
++p;
@@ -644,9 +644,9 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- q->rgbRed=ScaleQuantumToChar(GetRedSample(p));
- q->rgbGreen=ScaleQuantumToChar(GetGreenSample(p));
- q->rgbBlue=ScaleQuantumToChar(GetBlueSample(p));
+ q->rgbRed=ScaleQuantumToChar(GetRedPixelComponent(p));
+ q->rgbGreen=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ q->rgbBlue=ScaleQuantumToChar(GetBluePixelComponent(p));
q->rgbReserved=0;
p++;
q++;
diff --git a/magick/paint.c b/magick/paint.c
index eeab38c..a8e0f22 100644
--- a/magick/paint.c
+++ b/magick/paint.c
@@ -343,16 +343,16 @@
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&fill);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(fill.red);
+ q->red=ClampToQuantum(fill.red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(fill.green);
+ q->green=ClampToQuantum(fill.green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(fill.blue);
+ q->blue=ClampToQuantum(fill.blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(fill.opacity);
+ q->opacity=ClampToQuantum(fill.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- indexes[x]=RoundToQuantum(fill.index);
+ indexes[x]=ClampToQuantum(fill.index);
}
p++;
q++;
@@ -822,16 +822,16 @@
if (IsMagickColorSimilar(&pixel,target) != invert)
{
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(fill->red);
+ q->red=ClampToQuantum(fill->red);
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(fill->green);
+ q->green=ClampToQuantum(fill->green);
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(fill->blue);
+ q->blue=ClampToQuantum(fill->blue);
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(fill->opacity);
+ q->opacity=ClampToQuantum(fill->opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- indexes[x]=RoundToQuantum(fill->index);
+ indexes[x]=ClampToQuantum(fill->index);
}
q++;
}
diff --git a/magick/pixel-private.h b/magick/pixel-private.h
index 80431e6..9fda194 100644
--- a/magick/pixel-private.h
+++ b/magick/pixel-private.h
@@ -97,14 +97,14 @@
static inline void SetPixelPacket(const Image *image,
const MagickPixelPacket *pixel,PixelPacket *color,IndexPacket *index)
{
- color->red=RoundToQuantum(pixel->red);
- color->green=RoundToQuantum(pixel->green);
- color->blue=RoundToQuantum(pixel->blue);
- color->opacity=RoundToQuantum(pixel->opacity);
+ color->red=ClampToQuantum(pixel->red);
+ color->green=ClampToQuantum(pixel->green);
+ color->blue=ClampToQuantum(pixel->blue);
+ color->opacity=ClampToQuantum(pixel->opacity);
if (((image->colorspace == CMYKColorspace) ||
(image->storage_class == PseudoClass)) &&
(index != (const IndexPacket *) NULL))
- *index=RoundToQuantum(pixel->index);
+ *index=ClampToQuantum(pixel->index);
}
#if defined(__cplusplus) || defined(c_plusplus)
diff --git a/magick/pixel.c b/magick/pixel.c
index e29745c..3a403ff 100644
--- a/magick/pixel.c
+++ b/magick/pixel.c
@@ -269,9 +269,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
}
@@ -286,10 +286,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -304,9 +304,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
@@ -337,9 +337,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
}
@@ -354,10 +354,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -372,9 +372,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
@@ -397,29 +397,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToChar(GetRedSample(p));
+ *q=ScaleQuantumToChar(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToChar(GetGreenSample(p));
+ *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToChar(GetBlueSample(p));
+ *q=ScaleQuantumToChar(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToChar(GetOpacitySample(p));
+ *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -458,9 +458,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
p++;
}
}
@@ -475,11 +475,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
*q++=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
p++;
}
}
@@ -494,9 +494,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
*q++=0.0;
p++;
}
@@ -527,9 +527,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
p++;
}
}
@@ -544,11 +544,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
*q++=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
p++;
}
}
@@ -563,9 +563,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
*q++=0.0;
p++;
}
@@ -588,30 +588,30 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(double) (QuantumScale*GetRedSample(p));
+ *q=(double) (QuantumScale*GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(double) (QuantumScale*GetGreenSample(p));
+ *q=(double) (QuantumScale*GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(double) (QuantumScale*GetBlueSample(p));
+ *q=(double) (QuantumScale*GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
break;
}
case OpacityQuantum:
{
- *q=(double) (QuantumScale*GetOpacitySample(p));
+ *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -650,9 +650,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
p++;
}
}
@@ -667,10 +667,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*(Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*(Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -685,9 +685,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
*q++=0.0;
p++;
}
@@ -718,9 +718,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
p++;
}
}
@@ -735,10 +735,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacityPixelComponent(p))));
p++;
}
}
@@ -753,9 +753,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
*q++=0.0;
p++;
}
@@ -778,29 +778,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(float) (QuantumScale*GetRedSample(p));
+ *q=(float) (QuantumScale*GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(float) (QuantumScale*GetGreenSample(p));
+ *q=(float) (QuantumScale*GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(float) (QuantumScale*GetBlueSample(p));
+ *q=(float) (QuantumScale*GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))));
+ *q=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacityPixelComponent(p))));
break;
}
case OpacityQuantum:
{
- *q=(float) (QuantumScale*GetOpacitySample(p));
+ *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -839,9 +839,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
}
@@ -856,11 +856,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
p++;
}
}
@@ -875,9 +875,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0U;
p++;
}
@@ -909,9 +909,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
}
@@ -926,11 +926,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -945,9 +945,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0U;
p++;
}
@@ -970,30 +970,30 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetOpacitySample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -1033,9 +1033,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
}
@@ -1050,10 +1050,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -1068,9 +1068,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0;
p++;
}
@@ -1101,9 +1101,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
}
@@ -1118,10 +1118,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -1136,9 +1136,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0;
p++;
}
@@ -1161,29 +1161,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToLong(GetRedSample(p));
+ *q=ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToLong(GetGreenSample(p));
+ *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToLong(GetBlueSample(p));
+ *q=ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToLong(GetOpacitySample(p));
+ *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -1222,9 +1222,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
p++;
}
}
@@ -1239,10 +1239,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
p++;
}
}
@@ -1257,9 +1257,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
*q++=(Quantum) 0;
p++;
}
@@ -1290,9 +1290,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
p++;
}
}
@@ -1307,10 +1307,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
p++;
}
}
@@ -1325,9 +1325,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
*q++=(Quantum) 0;
p++;
}
@@ -1350,29 +1350,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=GetRedSample(p);
+ *q=GetRedPixelComponent(p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=GetGreenSample(p);
+ *q=GetGreenPixelComponent(p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=GetBlueSample(p);
+ *q=GetBluePixelComponent(p);
break;
}
case AlphaQuantum:
{
- *q=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
break;
}
case OpacityQuantum:
{
- *q=GetOpacitySample(p);
+ *q=GetOpacityPixelComponent(p);
break;
}
case BlackQuantum:
@@ -1411,9 +1411,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
p++;
}
}
@@ -1428,10 +1428,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -1446,9 +1446,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
*q++=0;
p++;
}
@@ -1479,9 +1479,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
p++;
}
}
@@ -1496,10 +1496,10 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
}
@@ -1514,9 +1514,9 @@
break;
for (x=0; x < (long) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
*q++=0;
p++;
}
@@ -1539,29 +1539,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToShort(GetRedSample(p));
+ *q=ScaleQuantumToShort(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToShort(GetGreenSample(p));
+ *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToShort(GetBlueSample(p));
+ *q=ScaleQuantumToShort(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToShort(GetOpacitySample(p));
+ *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -2088,11 +2088,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2110,13 +2110,13 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
p++;
q++;
@@ -2135,11 +2135,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
p++;
q++;
@@ -2158,7 +2158,7 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
p++;
@@ -2178,11 +2178,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2200,13 +2200,13 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
p++;
q++;
@@ -2225,11 +2225,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2253,40 +2253,40 @@
case RedQuantum:
case CyanQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case IndexQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
break;
@@ -2318,11 +2318,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2340,13 +2340,13 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
p++;
q++;
@@ -2365,11 +2365,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
p++;
q++;
@@ -2388,7 +2388,7 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
p++;
@@ -2408,11 +2408,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2430,13 +2430,13 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
p++;
q++;
@@ -2455,11 +2455,11 @@
break;
for (x=0; x < (long) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q++;
}
@@ -2483,40 +2483,40 @@
case RedQuantum:
case CyanQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case IndexQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
break;
diff --git a/magick/pixel.h b/magick/pixel.h
index 74ad0dc..ce4a543 100644
--- a/magick/pixel.h
+++ b/magick/pixel.h
@@ -25,38 +25,44 @@
#include <magick/colorspace.h>
#include <magick/constitute.h>
-#define GetRedSample(p) ((p)->red)
-#define GetGreenSample(p) ((p)->green)
-#define GetBlueSample(p) ((p)->blue)
-#define GetOpacitySample(p) ((p)->opacity)
-#define GetIndexSample(p) ((p)->index)
+#define ClampRedPixelComponent(p) ClampToQuantum((p)->red)
+#define ClampGreenPixelComponent(p) ClampToQuantum((p)->green)
+#define ClampBluePixelComponent(p) ClampToQuantum((p)->blue)
+#define ClampOpacityPixelComponent(p) ClampToQuantum((p)->opacity)
+#define ClampIndexPixelComponent(p) ClampToQuantum((p)->index)
-#define SetRedSample(q,sample) ((q)->red=(sample))
-#define SetGreenSample(q,sample) ((q)->green=(sample))
-#define SetBlueSample(q,sample) ((q)->blue=(sample))
-#define SetOpacitySample(q,sample) ((q)->opacity=(sample))
-#define SetIndexSample(q,sample) ((q)->index=(sample))
+#define GetRedPixelComponent(p) ((p)->red)
+#define GetGreenPixelComponent(p) ((p)->green)
+#define GetBluePixelComponent(p) ((p)->blue)
+#define GetOpacityPixelComponent(p) ((p)->opacity)
+#define GetIndexPixelComponent(p) ((p)->index)
-#define GetGraySample(p) ((p)->red)
-#define SetGraySample(q,sample) ((q)->red=(q)->green=(q)->blue=(sample))
+#define SetRedPixelComponent(q,component) ((q)->red=(component))
+#define SetGreenPixelComponent(q,component) ((q)->green=(component))
+#define SetBluePixelComponent(q,component) ((q)->blue=(component))
+#define SetOpacityPixelComponent(q,component) ((q)->opacity=(component))
+#define SetIndexPixelComponent(q,component) ((q)->index=(component))
-#define GetYSample(p) ((p)->red)
-#define GetCbSample(p) ((p)->green)
-#define GetCrSample(p) ((p)->blue)
+#define GetGrayPixelComponent(p) ((p)->red)
+#define SetGrayPixelComponent(q,component) ((q)->red=(q)->green=(q)->blue=(component))
-#define SetYSample(q,sample) ((q)->red=(sample))
-#define SetCbSample(q,sample) ((q)->green=(sample))
-#define SetCrSample(q,sample) ((q)->blue=(sample))
+#define GetYPixelComponent(p) ((p)->red)
+#define GetCbPixelComponent(p) ((p)->green)
+#define GetCrPixelComponent(p) ((p)->blue)
-#define GetCyanSample(p) ((p)->red)
-#define GetMagentaSample(p) ((p)->green)
-#define GetYellowSample(p) ((p)->blue)
-#define GetBlackSample(p) ((p)->opacity)
+#define SetYPixelComponent(q,component) ((q)->red=(component))
+#define SetCbPixelComponent(q,component) ((q)->green=(component))
+#define SetCrPixelComponent(q,component) ((q)->blue=(component))
-#define SetCyanSample(q,sample) ((q)->red=(sample))
-#define SetMagentaSample(q,sample) ((q)->green=(sample))
-#define SetYellowSample(q,sample) ((q)->blue=(sample))
-#define SetBlackSample(q,sample) ((q)->opacity=(sample))
+#define GetCyanPixelComponent(p) ((p)->red)
+#define GetMagentaPixelComponent(p) ((p)->green)
+#define GetYellowPixelComponent(p) ((p)->blue)
+#define GetBlackPixelComponent(p) ((p)->opacity)
+
+#define SetCyanPixelComponent(q,component) ((q)->red=(component))
+#define SetMagentaPixelComponent(q,component) ((q)->green=(component))
+#define SetYellowPixelComponent(q,component) ((q)->blue=(component))
+#define SetBlackPixelComponent(q,component) ((q)->opacity=(component))
typedef struct _LongPixelPacket
{
diff --git a/magick/quantize.c b/magick/quantize.c
index eec7569..cf3f588 100644
--- a/magick/quantize.c
+++ b/magick/quantize.c
@@ -442,7 +442,7 @@
alpha_pixel->opacity=(MagickRealType) pixel->opacity;
}
-static inline Quantum ClipToQuantum(const MagickRealType value)
+static inline Quantum ClampPixel(const MagickRealType value)
{
if (value <= 0.0)
return((Quantum) 0);
@@ -458,11 +458,11 @@
id;
id=(unsigned long) (
- ((ScaleQuantumToChar(ClipToQuantum(pixel->red)) >> index) & 0x1) |
- ((ScaleQuantumToChar(ClipToQuantum(pixel->green)) >> index) & 0x1) << 1 |
- ((ScaleQuantumToChar(ClipToQuantum(pixel->blue)) >> index) & 0x1) << 2);
+ ((ScaleQuantumToChar(ClampPixel(pixel->red)) >> index) & 0x1) |
+ ((ScaleQuantumToChar(ClampPixel(pixel->green)) >> index) & 0x1) << 1 |
+ ((ScaleQuantumToChar(ClampPixel(pixel->blue)) >> index) & 0x1) << 2);
if (cube_info->associate_alpha != MagickFalse)
- id|=((ScaleQuantumToChar(ClipToQuantum(pixel->opacity)) >> index) & 0x1)
+ id|=((ScaleQuantumToChar(ClampPixel(pixel->opacity)) >> index) & 0x1)
<< 3;
return(id);
}
@@ -1054,7 +1054,7 @@
beta=1.0;
if (cube_info->associate_alpha == MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacityPixelComponent(p)));
beta=(MagickRealType) (QuantumScale*(QuantumRange-q->opacity));
}
pixel=alpha*p->red-beta*q->red;
@@ -1185,13 +1185,13 @@
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
if (cube_info->associate_alpha == MagickFalse)
{
- q->red=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.blue));
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
}
else
{
@@ -1200,14 +1200,14 @@
opacity=(MagickRealType) (alpha*QuantumRange*
node_info->total_color.opacity);
- q->opacity=RoundToQuantum(opacity);
+ q->opacity=ClampToQuantum(opacity);
if (q->opacity == OpaqueOpacity)
{
- q->red=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (alpha*QuantumRange*
node_info->total_color.blue));
}
else
@@ -1218,11 +1218,11 @@
gamma=(MagickRealType) (QuantumScale*(QuantumRange-
(MagickRealType) q->opacity));
gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=RoundToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
node_info->total_color.red));
- q->green=RoundToQuantum((MagickRealType) (alpha*gamma*
+ q->green=ClampToQuantum((MagickRealType) (alpha*gamma*
QuantumRange*node_info->total_color.green));
- q->blue=RoundToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) (alpha*gamma*QuantumRange*
node_info->total_color.blue));
if (node_info->number_unique > cube_info->transparent_pixels)
{
@@ -1438,16 +1438,16 @@
pixel.opacity+=3*previous[u-v].opacity/16;
}
}
- pixel.red=(MagickRealType) ClipToQuantum(pixel.red);
- pixel.green=(MagickRealType) ClipToQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClipToQuantum(pixel.blue);
+ pixel.red=(MagickRealType) ClampPixel(pixel.red);
+ pixel.green=(MagickRealType) ClampPixel(pixel.green);
+ pixel.blue=(MagickRealType) ClampPixel(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- pixel.opacity=(MagickRealType) ClipToQuantum(pixel.opacity);
- i=(long) ((ScaleQuantumToChar(ClipToQuantum(pixel.red)) >> CacheShift) |
- (ScaleQuantumToChar(ClipToQuantum(pixel.green)) >> CacheShift) << 6 |
- (ScaleQuantumToChar(ClipToQuantum(pixel.blue)) >> CacheShift) << 12);
+ pixel.opacity=(MagickRealType) ClampPixel(pixel.opacity);
+ i=(long) ((ScaleQuantumToChar(ClampPixel(pixel.red)) >> CacheShift) |
+ (ScaleQuantumToChar(ClampPixel(pixel.green)) >> CacheShift) << 6 |
+ (ScaleQuantumToChar(ClampPixel(pixel.blue)) >> CacheShift) << 12);
if (cube_info->associate_alpha != MagickFalse)
- i|=((ScaleQuantumToChar(ClipToQuantum(pixel.opacity)) >> CacheShift)
+ i|=((ScaleQuantumToChar(ClampPixel(pixel.opacity)) >> CacheShift)
<< 18);
if (p->cache[i] < 0)
{
@@ -1656,16 +1656,16 @@
if (cube_info->associate_alpha != MagickFalse)
pixel.opacity+=p->weights[i]*p->error[i].opacity;
}
- pixel.red=(MagickRealType) ClipToQuantum(pixel.red);
- pixel.green=(MagickRealType) ClipToQuantum(pixel.green);
- pixel.blue=(MagickRealType) ClipToQuantum(pixel.blue);
+ pixel.red=(MagickRealType) ClampPixel(pixel.red);
+ pixel.green=(MagickRealType) ClampPixel(pixel.green);
+ pixel.blue=(MagickRealType) ClampPixel(pixel.blue);
if (cube_info->associate_alpha != MagickFalse)
- pixel.opacity=(MagickRealType) ClipToQuantum(pixel.opacity);
- i=(long) ((ScaleQuantumToChar(ClipToQuantum(pixel.red)) >> CacheShift) |
- (ScaleQuantumToChar(ClipToQuantum(pixel.green)) >> CacheShift) << 6 |
- (ScaleQuantumToChar(ClipToQuantum(pixel.blue)) >> CacheShift) << 12);
+ pixel.opacity=(MagickRealType) ClampPixel(pixel.opacity);
+ i=(long) ((ScaleQuantumToChar(ClampPixel(pixel.red)) >> CacheShift) |
+ (ScaleQuantumToChar(ClampPixel(pixel.green)) >> CacheShift) << 6 |
+ (ScaleQuantumToChar(ClampPixel(pixel.blue)) >> CacheShift) << 12);
if (cube_info->associate_alpha != MagickFalse)
- i|=((ScaleQuantumToChar(ClipToQuantum(pixel.opacity)) >> CacheShift)
+ i|=((ScaleQuantumToChar(ClampPixel(pixel.opacity)) >> CacheShift)
<< 18);
if (p->cache[i] < 0)
{
@@ -2062,7 +2062,7 @@
index=1UL*indexes[x];
if (image->matte != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-GetOpacityPixelComponent(p)));
beta=(MagickRealType) (QuantumScale*(QuantumRange-
image->colormap[index].opacity));
}
diff --git a/magick/quantum-export.c b/magick/quantum-export.c
index 0738258..b8e845a 100644
--- a/magick/quantum-export.c
+++ b/magick/quantum-export.c
@@ -300,9 +300,9 @@
for (x=0; x < (long) image->columns; x++)
{
alpha=QuantumScale*((double) QuantumRange-q->opacity);
- q->red=RoundToQuantum(alpha*q->red);
- q->green=RoundToQuantum(alpha*q->green);
- q->blue=RoundToQuantum(alpha*q->blue);
+ q->red=ClampToQuantum(alpha*q->red);
+ q->green=ClampToQuantum(alpha*q->green);
+ q->blue=ClampToQuantum(alpha*q->blue);
q++;
}
}
@@ -556,7 +556,7 @@
pixel=(unsigned char) *indexes++;
*q=((pixel & 0xf) << 4);
pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p)))+0.5);
+ GetOpacityPixelComponent(p)))+0.5);
*q|=((pixel & 0xf) << 0);
p++;
q++;
@@ -571,7 +571,8 @@
for (x=0; x < (long) number_pixels; x++)
{
q=PopCharPixel((unsigned char) indexes[x],q);
- pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -588,7 +589,8 @@
for (x=0; x < (long) number_pixels; x++)
{
q=PopShortPixel(endian,(unsigned short) indexes[x],q);
- pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -598,7 +600,8 @@
for (x=0; x < (long) number_pixels; x++)
{
q=PopShortPixel(endian,(unsigned short) indexes[x],q);
- pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -618,7 +621,7 @@
pixel;
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
- pixel=(float) (QuantumRange-GetOpacitySample(p));
+ pixel=(float) (QuantumRange-GetOpacityPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -628,7 +631,8 @@
for (x=0; x < (long) number_pixels; x++)
{
q=PopLongPixel(endian,(unsigned long) indexes[x],q);
- pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -645,7 +649,7 @@
pixel;
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
- pixel=(double) (QuantumRange-GetOpacitySample(p));
+ pixel=(double) (QuantumRange-GetOpacityPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -660,7 +664,7 @@
{
q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (QuantumRange-GetOpacitySample(p)),range),q);
+ (Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
@@ -970,7 +974,7 @@
pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
*q=(((pixel >> 4) & 0xf) << 4);
pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p)))+0.5);
+ GetOpacityPixelComponent(p)))+0.5);
*q|=pixel & 0xf;
p++;
q++;
@@ -986,7 +990,8 @@
{
pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1004,7 +1009,8 @@
{
pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1015,7 +1021,8 @@
{
pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1036,7 +1043,7 @@
pixel=(float) PixelIntensityToQuantum(p);
q=PopFloatPixel(&quantum_state,pixel,q);
- pixel=(float) (QuantumRange-GetOpacitySample(p));
+ pixel=(float) (QuantumRange-GetOpacityPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1047,7 +1054,8 @@
{
pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1065,7 +1073,7 @@
pixel=(double) PixelIntensityToQuantum(p);
q=PopDoublePixel(&quantum_state,pixel,q);
- pixel=(double) (QuantumRange-GetOpacitySample(p));
+ pixel=(double) (QuantumRange-GetOpacityPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1081,7 +1089,7 @@
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
PixelIntensityToQuantum(p),range),q);
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (QuantumRange-GetOpacitySample(p)),range),q);
+ (Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
@@ -1102,7 +1110,7 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetRedSample(p));
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1118,7 +1126,7 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetRedSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1127,7 +1135,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1151,7 +1159,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetRedSample(p));
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1198,7 +1206,7 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetGreenSample(p));
+ pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1214,7 +1222,7 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetGreenSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1223,7 +1231,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetGreenSample(p));
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1247,7 +1255,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetGreenSample(p));
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1294,7 +1302,7 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetBlueSample(p));
+ pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1310,7 +1318,7 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetBlueSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1319,7 +1327,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetBlueSample(p));
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1343,7 +1351,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetBlueSample(p));
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1389,7 +1397,8 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1405,7 +1414,8 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1414,7 +1424,8 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1433,7 +1444,7 @@
float
pixel;
- pixel=(float) (QuantumRange-GetOpacitySample(p));
+ pixel=(float) (QuantumRange-GetOpacityPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1442,7 +1453,8 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1458,7 +1470,7 @@
double
pixel;
- pixel=(double) (QuantumRange-GetOpacitySample(p));
+ pixel=(double) (QuantumRange-GetOpacityPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1472,7 +1484,7 @@
for (x=0; x < (long) number_pixels; x++)
{
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (QuantumRange-GetOpacitySample(p)),range),q);
+ (Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
@@ -1492,7 +1504,7 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetOpacitySample(p));
+ pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1508,7 +1520,7 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetOpacitySample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetOpacityPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1517,7 +1529,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetOpacitySample(p));
+ pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1541,7 +1553,7 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetOpacitySample(p));
+ pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1686,9 +1698,9 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- q=PopCharPixel(ScaleQuantumToChar(GetRedSample(p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetGreenSample(p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetBlueSample(p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
p++;
q+=quantum_info->pad;
}
@@ -1861,11 +1873,11 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetRedSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetGreenSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetBlueSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1874,11 +1886,11 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetGreenSample(p));
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetBlueSample(p));
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1904,11 +1916,11 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetRedSample(p));
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetGreenSample(p));
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetBlueSample(p));
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1962,13 +1974,14 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetRedSample(p));
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetGreenSample(p));
+ pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetBlueSample(p));
+ pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -1984,13 +1997,14 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetRedSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetGreenSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetBlueSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -1999,13 +2013,14 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetGreenSample(p));
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetBlueSample(p));
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2027,7 +2042,7 @@
q=PopFloatPixel(&quantum_state,(float) p->red,q);
q=PopFloatPixel(&quantum_state,(float) p->green,q);
q=PopFloatPixel(&quantum_state,(float) p->blue,q);
- pixel=(float) (QuantumRange-GetOpacitySample(p));
+ pixel=(float) (QuantumRange-GetOpacityPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2036,13 +2051,14 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetRedSample(p));
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetGreenSample(p));
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetBlueSample(p));
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2061,7 +2077,7 @@
q=PopDoublePixel(&quantum_state,(double) p->red,q);
q=PopDoublePixel(&quantum_state,(double) p->green,q);
q=PopDoublePixel(&quantum_state,(double) p->blue,q);
- pixel=(double) (QuantumRange-GetOpacitySample(p));
+ pixel=(double) (QuantumRange-GetOpacityPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2081,7 +2097,7 @@
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
p->blue,range),q);
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- (Quantum) (QuantumRange-GetOpacitySample(p)),range),q);
+ (Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range),q);
p++;
q+=quantum_info->pad;
}
@@ -2107,11 +2123,11 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetRedSample(p));
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetGreenSample(p));
+ pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetBlueSample(p));
+ pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
pixel=ScaleQuantumToChar(indexes[x]);
q=PopCharPixel(pixel,q);
@@ -2129,11 +2145,11 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetRedSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetGreenSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetBlueSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
q=PopShortPixel(endian,pixel,q);
@@ -2144,11 +2160,11 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetGreenSample(p));
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetBlueSample(p));
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
pixel=ScaleQuantumToShort(indexes[x]);
q=PopShortPixel(endian,pixel,q);
@@ -2177,11 +2193,11 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetRedSample(p));
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetGreenSample(p));
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetBlueSample(p));
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
pixel=ScaleQuantumToLong(indexes[x]);
q=PopLongPixel(endian,pixel,q);
@@ -2245,15 +2261,16 @@
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetRedSample(p));
+ pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetGreenSample(p));
+ pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetBlueSample(p));
+ pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
pixel=ScaleQuantumToChar(indexes[x]);
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
@@ -2269,15 +2286,16 @@
{
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleFloatToHalf(QuantumScale*GetRedSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetGreenSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*GetBlueSample(p));
+ pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2286,15 +2304,16 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetRedSample(p));
+ pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetGreenSample(p));
+ pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetBlueSample(p));
+ pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
pixel=ScaleQuantumToShort(indexes[x]);
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2317,7 +2336,7 @@
q=PopFloatPixel(&quantum_state,(float) p->green,q);
q=PopFloatPixel(&quantum_state,(float) p->blue,q);
q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
- pixel=(float) (QuantumRange-GetOpacitySample(p));
+ pixel=(float) (QuantumRange-GetOpacityPixelComponent(p));
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2326,15 +2345,16 @@
}
for (x=0; x < (long) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetRedSample(p));
+ pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetGreenSample(p));
+ pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetBlueSample(p));
+ pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
pixel=ScaleQuantumToLong(indexes[x]);
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
+ GetOpacityPixelComponent(p)));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2354,7 +2374,7 @@
q=PopDoublePixel(&quantum_state,(double) p->green,q);
q=PopDoublePixel(&quantum_state,(double) p->blue,q);
q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
- pixel=(double) (QuantumRange-GetOpacitySample(p));
+ pixel=(double) (QuantumRange-GetOpacityPixelComponent(p));
q=PopDoublePixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
@@ -2419,17 +2439,17 @@
{
case 0:
{
- quantum=GetRedSample(p);
+ quantum=GetRedPixelComponent(p);
break;
}
case 1:
{
- quantum=GetGreenSample(p);
+ quantum=GetGreenPixelComponent(p);
break;
}
case 2:
{
- quantum=GetBlueSample(p);
+ quantum=GetBluePixelComponent(p);
break;
}
}
@@ -2462,17 +2482,17 @@
{
case 0:
{
- quantum=GetRedSample(p);
+ quantum=GetRedPixelComponent(p);
break;
}
case 1:
{
- quantum=GetGreenSample(p);
+ quantum=GetGreenPixelComponent(p);
break;
}
case 2:
{
- quantum=GetBlueSample(p);
+ quantum=GetBluePixelComponent(p);
break;
}
}
diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index 6dc131b..872cded 100644
--- a/magick/quantum-import.c
+++ b/magick/quantum-import.c
@@ -411,7 +411,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)),
&range_exception);
*q=image->colormap[(long) indexes[x]];
@@ -443,7 +443,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception);
*q=image->colormap[(long) indexes[x]];
p+=quantum_info->pad;
@@ -471,7 +471,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception);
*q=image->colormap[(long) indexes[x]];
p+=quantum_info->pad;
@@ -599,12 +599,12 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)),
&range_exception);
*q=image->colormap[(long) indexes[x]];
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
p+=quantum_info->pad;
q++;
@@ -636,11 +636,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception);
*q=image->colormap[(long) indexes[x]];
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -668,11 +668,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
+ indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
&range_exception);
*q=image->colormap[(long) indexes[x]];
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -748,12 +748,12 @@
for (x=0; x < ((long) number_pixels-1); x+=2)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
q++;
pixel=(unsigned char) ((*p) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p++;
@@ -762,7 +762,7 @@
for (bit=0; bit < (long) (number_pixels % 2); bit++)
{
pixel=(unsigned char) (*p++ >> 4);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
q++;
@@ -782,7 +782,7 @@
q->red=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
@@ -791,10 +791,10 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
@@ -848,7 +848,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -894,7 +894,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -925,7 +925,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
q->green=q->red;
q->blue=q->red;
@@ -937,7 +937,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -958,7 +958,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -969,7 +969,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -987,7 +987,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -1002,7 +1002,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p+=quantum_info->pad;
@@ -1060,7 +1060,7 @@
for (x=0; x < (long) number_pixels; x++)
{
pixel=(unsigned char) ((*p >> 4) & 0xf);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
pixel=(unsigned char) ((*p) & 0xf);
@@ -1078,7 +1078,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
p=PushCharPixel(p,&pixel);
@@ -1094,11 +1094,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
@@ -1110,11 +1110,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->opacity=ScaleAnyToQuantum(pixel,range);
+ SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
@@ -1130,12 +1130,12 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
q->green=q->red;
q->blue=q->red;
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
p+=quantum_info->pad;
q++;
@@ -1145,7 +1145,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
p=PushShortPixel(endian,p,&pixel);
@@ -1168,11 +1168,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
q->green=q->red;
q->blue=q->red;
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1181,7 +1181,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
q->green=q->red;
q->blue=q->red;
p=PushLongPixel(endian,p,&pixel);
@@ -1201,11 +1201,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
q->green=q->red;
q->blue=q->red;
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1218,7 +1218,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q->green=q->red;
q->blue=q->red;
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
@@ -1244,7 +1244,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1260,7 +1260,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
q++;
@@ -1270,7 +1270,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1289,7 +1289,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1298,7 +1298,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1314,7 +1314,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1327,7 +1327,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
@@ -1349,7 +1349,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1365,7 +1365,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
q++;
@@ -1375,7 +1375,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1394,7 +1394,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1403,7 +1403,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1419,7 +1419,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1432,7 +1432,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
@@ -1454,7 +1454,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1470,7 +1470,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
q++;
@@ -1480,7 +1480,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1499,7 +1499,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1508,7 +1508,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1524,7 +1524,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1537,7 +1537,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p+=quantum_info->pad;
q++;
}
@@ -1574,7 +1574,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel)));
p+=quantum_info->pad;
@@ -1604,7 +1604,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1629,7 +1629,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1684,7 +1684,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
+ indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
}
@@ -1711,7 +1711,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=RoundToQuantum(pixel);
+ indexes[x]=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1736,7 +1736,7 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=RoundToQuantum(pixel);
+ indexes[x]=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1771,12 +1771,12 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
- SetOpacitySample(q,OpaqueOpacity);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
p+=quantum_info->pad;
q++;
}
@@ -1803,11 +1803,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -1815,11 +1815,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -1912,11 +1912,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -1924,11 +1924,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -1943,13 +1943,13 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
q++;
@@ -1959,11 +1959,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -1982,11 +1982,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -1995,11 +1995,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -2015,11 +2015,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -2032,11 +2032,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -2058,11 +2058,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
p+=quantum_info->pad;
@@ -2151,16 +2151,16 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
p+=quantum_info->pad;
q++;
@@ -2170,11 +2170,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
p+=quantum_info->pad;
@@ -2195,13 +2195,13 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -2210,11 +2210,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
p+=quantum_info->pad;
@@ -2232,13 +2232,13 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -2251,11 +2251,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
q++;
@@ -2283,11 +2283,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
indexes[x]=ScaleCharToQuantum(pixel);
p+=quantum_info->pad;
@@ -2305,16 +2305,16 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
+ indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p+=quantum_info->pad;
q++;
@@ -2324,11 +2324,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
indexes[x]=ScaleShortToQuantum(pixel);
p+=quantum_info->pad;
@@ -2349,13 +2349,13 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ indexes[x]=(IndexPacket) ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -2364,11 +2364,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
indexes[x]=ScaleLongToQuantum(pixel);
p+=quantum_info->pad;
@@ -2386,13 +2386,13 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ indexes[x]=(IndexPacket) ClampToQuantum(pixel);
p+=quantum_info->pad;
q++;
}
@@ -2405,11 +2405,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
indexes[x]=ScaleAnyToQuantum(pixel,range);
q++;
@@ -2438,11 +2438,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushCharPixel(p,&pixel);
- q->red=ScaleCharToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->green=ScaleCharToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
- q->blue=ScaleCharToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
p=PushCharPixel(p,&pixel);
indexes[x]=ScaleCharToQuantum(pixel);
p=PushCharPixel(p,&pixel);
@@ -2462,19 +2462,19 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=RoundToQuantum((MagickRealType) QuantumRange*
+ q->red=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=RoundToQuantum((MagickRealType) QuantumRange*
+ q->green=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*
+ q->blue=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
+ indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
ScaleHalfToFloat(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*ScaleHalfToFloat(pixel)));
p+=quantum_info->pad;
q++;
@@ -2484,11 +2484,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushShortPixel(endian,p,&pixel);
- q->red=ScaleShortToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->green=ScaleShortToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
- q->blue=ScaleShortToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
p=PushShortPixel(endian,p,&pixel);
indexes[x]=ScaleShortToQuantum(pixel);
p=PushShortPixel(endian,p,&pixel);
@@ -2511,15 +2511,15 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ indexes[x]=(IndexPacket) ClampToQuantum(pixel);
p=PushFloatPixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p+=quantum_info->pad;
q++;
}
@@ -2528,11 +2528,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushLongPixel(endian,p,&pixel);
- q->red=ScaleLongToQuantum(pixel);
+ SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->green=ScaleLongToQuantum(pixel);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
- q->blue=ScaleLongToQuantum(pixel);
+ SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
p=PushLongPixel(endian,p,&pixel);
indexes[x]=ScaleLongToQuantum(pixel);
p=PushLongPixel(endian,p,&pixel);
@@ -2552,15 +2552,15 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->red=RoundToQuantum(pixel);
+ q->red=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->green=RoundToQuantum(pixel);
+ q->green=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->blue=RoundToQuantum(pixel);
+ q->blue=ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+ indexes[x]=(IndexPacket) ClampToQuantum(pixel);
p=PushDoublePixel(&quantum_state,p,&pixel);
- q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+ q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
p=PushDoublePixel(&quantum_state,p,&pixel);
p+=quantum_info->pad;
q++;
@@ -2574,11 +2574,11 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->blue=ScaleAnyToQuantum(pixel,range);
+ SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
indexes[x]=ScaleAnyToQuantum(pixel,range);
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
@@ -2661,9 +2661,9 @@
for (x=0; x < (long) number_pixels; x++)
{
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->red=ScaleAnyToQuantum(pixel,range);
+ SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
- q->green=ScaleAnyToQuantum(pixel,range);
+ SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
q++;
}
break;
@@ -2725,9 +2725,9 @@
{
alpha=QuantumScale*((MagickRealType) QuantumRange-q->opacity);
alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
- q->red=RoundToQuantum(alpha*q->red);
- q->green=RoundToQuantum(alpha*q->green);
- q->blue=RoundToQuantum(alpha*q->blue);
+ q->red=ClampToQuantum(alpha*q->red);
+ q->green=ClampToQuantum(alpha*q->green);
+ q->blue=ClampToQuantum(alpha*q->blue);
q++;
}
}
diff --git a/magick/quantum.h b/magick/quantum.h
index 8727bf0..88ca2de 100644
--- a/magick/quantum.h
+++ b/magick/quantum.h
@@ -24,6 +24,8 @@
#include "magick/semaphore.h"
+#define RoundToQuantum(quantum) ClampToQuantum(quantum)
+
typedef enum
{
UndefinedEndian,
@@ -79,7 +81,7 @@
typedef struct _QuantumInfo
QuantumInfo;
-static inline Quantum RoundToQuantum(const MagickRealType value)
+static inline Quantum ClampToQuantum(const MagickRealType value)
{
#if defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) value);
diff --git a/magick/resample.c b/magick/resample.c
index 5583ae8..32612bf 100644
--- a/magick/resample.c
+++ b/magick/resample.c
@@ -404,7 +404,7 @@
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -450,7 +450,7 @@
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -624,7 +624,7 @@
alpha[i]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[i]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[i].red*=alpha[i];
pixels[i].green*=alpha[i];
pixels[i].blue*=alpha[i];
@@ -787,7 +787,7 @@
alpha[n]=1.0;
if (resample_filter->image->matte != MagickFalse)
{
- alpha[n]=QuantumScale*((MagickRealType) QuantumRange-GetOpacitySample(p));
+ alpha[n]=QuantumScale*((MagickRealType) QuantumRange-GetOpacityPixelComponent(p));
pixels[n].red*=alpha[n];
pixels[n].green*=alpha[n];
pixels[n].blue*=alpha[n];
@@ -1132,13 +1132,13 @@
Finialize results of resampling
*/
divisor_m = 1.0/divisor_m;
- pixel->opacity = (MagickRealType) RoundToQuantum(divisor_m*pixel->opacity);
+ pixel->opacity = (MagickRealType) ClampToQuantum(divisor_m*pixel->opacity);
divisor_c = 1.0/divisor_c;
- pixel->red = (MagickRealType) RoundToQuantum(divisor_c*pixel->red);
- pixel->green = (MagickRealType) RoundToQuantum(divisor_c*pixel->green);
- pixel->blue = (MagickRealType) RoundToQuantum(divisor_c*pixel->blue);
+ pixel->red = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
+ pixel->green = (MagickRealType) ClampToQuantum(divisor_c*pixel->green);
+ pixel->blue = (MagickRealType) ClampToQuantum(divisor_c*pixel->blue);
if (resample_filter->image->colorspace == CMYKColorspace)
- pixel->index = (MagickRealType) RoundToQuantum(divisor_c*pixel->index);
+ pixel->index = (MagickRealType) ClampToQuantum(divisor_c*pixel->index);
return(MagickTrue);
}
diff --git a/magick/resize.c b/magick/resize.c
index da93e33..e7cc96e 100644
--- a/magick/resize.c
+++ b/magick/resize.c
@@ -146,7 +146,7 @@
}
static MagickRealType Blackman(const MagickRealType x,
- const ResizeFilter *magick_unused(resize_filter))
+ const ResizeFilter *magick_unused(resize_filter))
{
/*
Blackman: 2rd Order cosine windowing function.
@@ -155,7 +155,7 @@
}
static MagickRealType Bohman(const MagickRealType x,
- const ResizeFilter *magick_unused(resize_filter))
+ const ResizeFilter *magick_unused(resize_filter))
{
/*
Bohman: 2rd Order cosine windowing function.
@@ -1819,10 +1819,10 @@
pixel.blue+=alpha*(p+j)->blue;
pixel.opacity+=alpha*(p+j)->opacity;
}
- q->red=RoundToQuantum(pixel.red);
- q->green=RoundToQuantum(pixel.green);
- q->blue=RoundToQuantum(pixel.blue);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
{
@@ -1833,7 +1833,7 @@
alpha=contribution[i].weight;
pixel.index+=alpha*indexes[j];
}
- resize_indexes[y]=(IndexPacket) RoundToQuantum(pixel.index);
+ resize_indexes[y]=(IndexPacket) ClampToQuantum(pixel.index);
}
}
else
@@ -1855,10 +1855,10 @@
gamma+=alpha;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
- q->opacity=RoundToQuantum(pixel.opacity);
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
{
@@ -1870,7 +1870,8 @@
QuantumRange-(p+j)->opacity);
pixel.index+=alpha*indexes[j];
}
- resize_indexes[y]=(IndexPacket) RoundToQuantum(gamma*GetIndexSample(&pixel));
+ resize_indexes[y]=(IndexPacket) ClampToQuantum(gamma*
+ GetIndexPixelComponent(&pixel));
}
}
if ((resize_image->storage_class == PseudoClass) &&
@@ -2060,10 +2061,10 @@
pixel.blue+=alpha*(p+j)->blue;
pixel.opacity+=alpha*(p+j)->opacity;
}
- q->red=RoundToQuantum(pixel.red);
- q->green=RoundToQuantum(pixel.green);
- q->blue=RoundToQuantum(pixel.blue);
- q->opacity=RoundToQuantum(pixel.opacity);
+ SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
+ SetGreenPixelComponent(q,ClampGreenPixelComponent(&pixel));
+ SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
{
@@ -2074,7 +2075,7 @@
alpha=contribution[i].weight;
pixel.index+=alpha*indexes[j];
}
- resize_indexes[x]=(IndexPacket) RoundToQuantum(pixel.index);
+ resize_indexes[x]=(IndexPacket) ClampToQuantum(pixel.index);
}
}
else
@@ -2096,10 +2097,10 @@
gamma+=alpha;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
- q->red=RoundToQuantum(gamma*GetRedSample(&pixel));
- q->green=RoundToQuantum(gamma*GetGreenSample(&pixel));
- q->blue=RoundToQuantum(gamma*GetBlueSample(&pixel));
- q->opacity=RoundToQuantum(pixel.opacity);
+ q->red=ClampToQuantum(gamma*GetRedPixelComponent(&pixel));
+ q->green=ClampToQuantum(gamma*GetGreenPixelComponent(&pixel));
+ q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
+ SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
{
@@ -2111,7 +2112,8 @@
QuantumRange-(p+j)->opacity);
pixel.index+=alpha*indexes[j];
}
- resize_indexes[x]=(IndexPacket) RoundToQuantum(gamma*GetIndexSample(&pixel));
+ resize_indexes[x]=(IndexPacket) ClampToQuantum(gamma*
+ GetIndexPixelComponent(&pixel));
}
}
if ((resize_image->storage_class == PseudoClass) &&
@@ -2556,11 +2558,11 @@
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- x_vector[x].red=(MagickRealType) GetRedSample(p);
- x_vector[x].green=(MagickRealType) GetGreenSample(p);
- x_vector[x].blue=(MagickRealType) GetBlueSample(p);
+ x_vector[x].red=(MagickRealType) GetRedPixelComponent(p);
+ x_vector[x].green=(MagickRealType) GetGreenPixelComponent(p);
+ x_vector[x].blue=(MagickRealType) GetBluePixelComponent(p);
if (image->matte != MagickFalse)
- x_vector[x].opacity=(MagickRealType) GetOpacitySample(p);
+ x_vector[x].opacity=(MagickRealType) GetOpacityPixelComponent(p);
if (indexes != (IndexPacket *) NULL)
x_vector[x].index=(MagickRealType) indexes[x];
p++;
@@ -2584,11 +2586,11 @@
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- x_vector[x].red=(MagickRealType) GetRedSample(p);
- x_vector[x].green=(MagickRealType) GetGreenSample(p);
- x_vector[x].blue=(MagickRealType) GetBlueSample(p);
+ x_vector[x].red=(MagickRealType) GetRedPixelComponent(p);
+ x_vector[x].green=(MagickRealType) GetGreenPixelComponent(p);
+ x_vector[x].blue=(MagickRealType) GetBluePixelComponent(p);
if (image->matte != MagickFalse)
- x_vector[x].opacity=(MagickRealType) GetOpacitySample(p);
+ x_vector[x].opacity=(MagickRealType) GetOpacityPixelComponent(p);
if (indexes != (IndexPacket *) NULL)
x_vector[x].index=(MagickRealType) indexes[x];
p++;
@@ -2620,11 +2622,11 @@
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (long) image->columns; x++)
{
- x_vector[x].red=(MagickRealType) GetRedSample(p);
- x_vector[x].green=(MagickRealType) GetGreenSample(p);
- x_vector[x].blue=(MagickRealType) GetBlueSample(p);
+ x_vector[x].red=(MagickRealType) GetRedPixelComponent(p);
+ x_vector[x].green=(MagickRealType) GetGreenPixelComponent(p);
+ x_vector[x].blue=(MagickRealType) GetBluePixelComponent(p);
if (image->matte != MagickFalse)
- x_vector[x].opacity=(MagickRealType) GetOpacitySample(p);
+ x_vector[x].opacity=(MagickRealType) GetOpacityPixelComponent(p);
if (indexes != (IndexPacket *) NULL)
x_vector[x].index=(MagickRealType) indexes[x];
p++;
@@ -2668,13 +2670,13 @@
s=scanline;
for (x=0; x < (long) scale_image->columns; x++)
{
- q->red=RoundToQuantum(s->red);
- q->green=RoundToQuantum(s->green);
- q->blue=RoundToQuantum(s->blue);
+ q->red=ClampToQuantum(s->red);
+ q->green=ClampToQuantum(s->green);
+ q->blue=ClampToQuantum(s->blue);
if (scale_image->matte != MagickFalse)
- q->opacity=RoundToQuantum(s->opacity);
+ q->opacity=ClampToQuantum(s->opacity);
if (scale_indexes != (IndexPacket *) NULL)
- scale_indexes[x]=(IndexPacket) RoundToQuantum(s->index);
+ scale_indexes[x]=(IndexPacket) ClampToQuantum(s->index);
q++;
s++;
}
@@ -2764,13 +2766,13 @@
t=scale_scanline;
for (x=0; x < (long) scale_image->columns; x++)
{
- q->red=RoundToQuantum(t->red);
- q->green=RoundToQuantum(t->green);
- q->blue=RoundToQuantum(t->blue);
+ q->red=ClampToQuantum(t->red);
+ q->green=ClampToQuantum(t->green);
+ q->blue=ClampToQuantum(t->blue);
if (scale_image->matte != MagickFalse)
- q->opacity=RoundToQuantum(t->opacity);
+ q->opacity=ClampToQuantum(t->opacity);
if (scale_indexes != (IndexPacket *) NULL)
- scale_indexes[x]=(IndexPacket) RoundToQuantum(t->index);
+ scale_indexes[x]=(IndexPacket) ClampToQuantum(t->index);
t++;
q++;
}
diff --git a/magick/segment.c b/magick/segment.c
index a4b15a7..25b9482 100644
--- a/magick/segment.c
+++ b/magick/segment.c
@@ -363,27 +363,27 @@
for (x=0; x < (long) image->columns; x++)
{
for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
- if (((long) ScaleQuantumToChar(GetRedSample(p)) >=
+ if (((long) ScaleQuantumToChar(GetRedPixelComponent(p)) >=
(cluster->red.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetRedSample(p)) <=
+ ((long) ScaleQuantumToChar(GetRedPixelComponent(p)) <=
(cluster->red.right+SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetGreenSample(p)) >=
+ ((long) ScaleQuantumToChar(GetGreenPixelComponent(p)) >=
(cluster->green.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetGreenSample(p)) <=
+ ((long) ScaleQuantumToChar(GetGreenPixelComponent(p)) <=
(cluster->green.right+SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetBlueSample(p)) >=
+ ((long) ScaleQuantumToChar(GetBluePixelComponent(p)) >=
(cluster->blue.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetBlueSample(p)) <=
+ ((long) ScaleQuantumToChar(GetBluePixelComponent(p)) <=
(cluster->blue.right+SafeMargin)))
{
/*
Count this pixel.
*/
count++;
- cluster->red.center+=(MagickRealType) ScaleQuantumToChar(GetRedSample(p));
+ cluster->red.center+=(MagickRealType) ScaleQuantumToChar(GetRedPixelComponent(p));
cluster->green.center+=(MagickRealType)
- ScaleQuantumToChar(GetGreenSample(p));
- cluster->blue.center+=(MagickRealType) ScaleQuantumToChar(GetBlueSample(p));
+ ScaleQuantumToChar(GetGreenPixelComponent(p));
+ cluster->blue.center+=(MagickRealType) ScaleQuantumToChar(GetBluePixelComponent(p));
cluster->count++;
break;
}
@@ -596,21 +596,21 @@
sum=0.0;
p=image->colormap+j;
distance_squared=squares[(long) ScaleQuantumToChar(q->red)-
- (long) ScaleQuantumToChar(GetRedSample(p))]+
+ (long) ScaleQuantumToChar(GetRedPixelComponent(p))]+
squares[(long) ScaleQuantumToChar(q->green)-
- (long) ScaleQuantumToChar(GetGreenSample(p))]+
+ (long) ScaleQuantumToChar(GetGreenPixelComponent(p))]+
squares[(long) ScaleQuantumToChar(q->blue)-
- (long) ScaleQuantumToChar(GetBlueSample(p))];
+ (long) ScaleQuantumToChar(GetBluePixelComponent(p))];
numerator=distance_squared;
for (k=0; k < (long) image->colors; k++)
{
p=image->colormap+k;
distance_squared=squares[(long) ScaleQuantumToChar(q->red)-
- (long) ScaleQuantumToChar(GetRedSample(p))]+
+ (long) ScaleQuantumToChar(GetRedPixelComponent(p))]+
squares[(long) ScaleQuantumToChar(q->green)-
- (long) ScaleQuantumToChar(GetGreenSample(p))]+
+ (long) ScaleQuantumToChar(GetGreenPixelComponent(p))]+
squares[(long) ScaleQuantumToChar(q->blue)-
- (long) ScaleQuantumToChar(GetBlueSample(p))];
+ (long) ScaleQuantumToChar(GetBluePixelComponent(p))];
ratio=numerator/distance_squared;
sum+=SegmentPower(ratio);
}
@@ -1091,17 +1091,17 @@
for (x=0; x < (long) image->columns; x++)
{
for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
- if (((long) ScaleQuantumToChar(GetRedSample(p)) >=
+ if (((long) ScaleQuantumToChar(GetRedPixelComponent(p)) >=
(cluster->red.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetRedSample(p)) <=
+ ((long) ScaleQuantumToChar(GetRedPixelComponent(p)) <=
(cluster->red.right+SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetGreenSample(p)) >=
+ ((long) ScaleQuantumToChar(GetGreenPixelComponent(p)) >=
(cluster->green.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetGreenSample(p)) <=
+ ((long) ScaleQuantumToChar(GetGreenPixelComponent(p)) <=
(cluster->green.right+SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetBlueSample(p)) >=
+ ((long) ScaleQuantumToChar(GetBluePixelComponent(p)) >=
(cluster->blue.left-SafeMargin)) &&
- ((long) ScaleQuantumToChar(GetBlueSample(p)) <=
+ ((long) ScaleQuantumToChar(GetBluePixelComponent(p)) <=
(cluster->blue.right+SafeMargin)))
{
/*
@@ -1109,11 +1109,11 @@
*/
count++;
cluster->red.center+=(MagickRealType)
- ScaleQuantumToChar(GetRedSample(p));
+ ScaleQuantumToChar(GetRedPixelComponent(p));
cluster->green.center+=(MagickRealType)
- ScaleQuantumToChar(GetGreenSample(p));
+ ScaleQuantumToChar(GetGreenPixelComponent(p));
cluster->blue.center+=(MagickRealType)
- ScaleQuantumToChar(GetBlueSample(p));
+ ScaleQuantumToChar(GetBluePixelComponent(p));
cluster->count++;
break;
}
@@ -1254,9 +1254,9 @@
break;
for (x=0; x < (long) image->columns; x++)
{
- histogram[Red][(long) ScaleQuantumToChar(GetRedSample(p))]++;
- histogram[Green][(long) ScaleQuantumToChar(GetGreenSample(p))]++;
- histogram[Blue][(long) ScaleQuantumToChar(GetBlueSample(p))]++;
+ histogram[Red][(long) ScaleQuantumToChar(GetRedPixelComponent(p))]++;
+ histogram[Green][(long) ScaleQuantumToChar(GetGreenPixelComponent(p))]++;
+ histogram[Blue][(long) ScaleQuantumToChar(GetBluePixelComponent(p))]++;
p++;
}
}
diff --git a/magick/shear.c b/magick/shear.c
index 8fb36bb..4cdbbe3 100644
--- a/magick/shear.c
+++ b/magick/shear.c
@@ -855,22 +855,22 @@
{
if ((x >= offset) && (x < ((long) image->columns-offset)))
continue;
- background.red+=QuantumScale*GetRedSample(p);
- background.green+=QuantumScale*GetGreenSample(p);
- background.blue+=QuantumScale*GetBlueSample(p);
- background.opacity+=QuantumScale*GetOpacitySample(p);
+ background.red+=QuantumScale*GetRedPixelComponent(p);
+ background.green+=QuantumScale*GetGreenPixelComponent(p);
+ background.blue+=QuantumScale*GetBluePixelComponent(p);
+ background.opacity+=QuantumScale*GetOpacityPixelComponent(p);
count++;
p++;
}
}
image_view=DestroyCacheView(image_view);
- image->background_color.red=RoundToQuantum((MagickRealType) QuantumRange*
+ image->background_color.red=ClampToQuantum((MagickRealType) QuantumRange*
background.red/count);
- image->background_color.green=RoundToQuantum((MagickRealType) QuantumRange*
+ image->background_color.green=ClampToQuantum((MagickRealType) QuantumRange*
background.green/count);
- image->background_color.blue=RoundToQuantum((MagickRealType) QuantumRange*
+ image->background_color.blue=ClampToQuantum((MagickRealType) QuantumRange*
background.blue/count);
- image->background_color.opacity=RoundToQuantum((MagickRealType) QuantumRange*
+ image->background_color.opacity=ClampToQuantum((MagickRealType) QuantumRange*
background.opacity/count);
}
diff --git a/magick/statistic.c b/magick/statistic.c
index 94595d3..e91514e 100644
--- a/magick/statistic.c
+++ b/magick/statistic.c
@@ -481,26 +481,26 @@
{
if ((channel & RedChannel) != 0)
{
- *mean+=GetRedSample(p);
- *standard_deviation+=(double) p->red*GetRedSample(p);
+ *mean+=GetRedPixelComponent(p);
+ *standard_deviation+=(double) p->red*GetRedPixelComponent(p);
area++;
}
if ((channel & GreenChannel) != 0)
{
- *mean+=GetGreenSample(p);
- *standard_deviation+=(double) p->green*GetGreenSample(p);
+ *mean+=GetGreenPixelComponent(p);
+ *standard_deviation+=(double) p->green*GetGreenPixelComponent(p);
area++;
}
if ((channel & BlueChannel) != 0)
{
- *mean+=GetBlueSample(p);
- *standard_deviation+=(double) p->blue*GetBlueSample(p);
+ *mean+=GetBluePixelComponent(p);
+ *standard_deviation+=(double) p->blue*GetBluePixelComponent(p);
area++;
}
if ((channel & OpacityChannel) != 0)
{
- *mean+=GetOpacitySample(p);
- *standard_deviation+=(double) p->opacity*GetOpacitySample(p);
+ *mean+=GetOpacityPixelComponent(p);
+ *standard_deviation+=(double) p->opacity*GetOpacityPixelComponent(p);
area++;
}
if (((channel & IndexChannel) != 0) &&
@@ -615,35 +615,35 @@
{
if ((channel & RedChannel) != 0)
{
- mean+=GetRedSample(p);
- sum_squares+=(double) p->red*GetRedSample(p);
- sum_cubes+=(double) p->red*p->red*GetRedSample(p);
- sum_fourth_power+=(double) p->red*p->red*p->red*GetRedSample(p);
+ mean+=GetRedPixelComponent(p);
+ sum_squares+=(double) p->red*GetRedPixelComponent(p);
+ sum_cubes+=(double) p->red*p->red*GetRedPixelComponent(p);
+ sum_fourth_power+=(double) p->red*p->red*p->red*GetRedPixelComponent(p);
area++;
}
if ((channel & GreenChannel) != 0)
{
- mean+=GetGreenSample(p);
- sum_squares+=(double) p->green*GetGreenSample(p);
- sum_cubes+=(double) p->green*p->green*GetGreenSample(p);
- sum_fourth_power+=(double) p->green*p->green*p->green*GetGreenSample(p);
+ mean+=GetGreenPixelComponent(p);
+ sum_squares+=(double) p->green*GetGreenPixelComponent(p);
+ sum_cubes+=(double) p->green*p->green*GetGreenPixelComponent(p);
+ sum_fourth_power+=(double) p->green*p->green*p->green*GetGreenPixelComponent(p);
area++;
}
if ((channel & BlueChannel) != 0)
{
- mean+=GetBlueSample(p);
- sum_squares+=(double) p->blue*GetBlueSample(p);
- sum_cubes+=(double) p->blue*p->blue*GetBlueSample(p);
- sum_fourth_power+=(double) p->blue*p->blue*p->blue*GetBlueSample(p);
+ mean+=GetBluePixelComponent(p);
+ sum_squares+=(double) p->blue*GetBluePixelComponent(p);
+ sum_cubes+=(double) p->blue*p->blue*GetBluePixelComponent(p);
+ sum_fourth_power+=(double) p->blue*p->blue*p->blue*GetBluePixelComponent(p);
area++;
}
if ((channel & OpacityChannel) != 0)
{
- mean+=GetOpacitySample(p);
- sum_squares+=(double) p->opacity*GetOpacitySample(p);
- sum_cubes+=(double) p->opacity*p->opacity*GetOpacitySample(p);
+ mean+=GetOpacityPixelComponent(p);
+ sum_squares+=(double) p->opacity*GetOpacityPixelComponent(p);
+ sum_cubes+=(double) p->opacity*p->opacity*GetOpacityPixelComponent(p);
sum_fourth_power+=(double) p->opacity*p->opacity*p->opacity*
- GetOpacitySample(p);
+ GetOpacityPixelComponent(p);
area++;
}
if (((channel & IndexChannel) != 0) &&
@@ -981,49 +981,49 @@
}
}
if ((double) p->red < channel_statistics[RedChannel].minima)
- channel_statistics[RedChannel].minima=(double) GetRedSample(p);
+ channel_statistics[RedChannel].minima=(double) GetRedPixelComponent(p);
if ((double) p->red > channel_statistics[RedChannel].maxima)
- channel_statistics[RedChannel].maxima=(double) GetRedSample(p);
- channel_statistics[RedChannel].mean+=GetRedSample(p);
- channel_statistics[RedChannel].standard_deviation+=(double) p->red*GetRedSample(p);
+ channel_statistics[RedChannel].maxima=(double) GetRedPixelComponent(p);
+ channel_statistics[RedChannel].mean+=GetRedPixelComponent(p);
+ channel_statistics[RedChannel].standard_deviation+=(double) p->red*GetRedPixelComponent(p);
channel_statistics[RedChannel].kurtosis+=(double) p->red*p->red*
- p->red*GetRedSample(p);
- channel_statistics[RedChannel].skewness+=(double) p->red*p->red*GetRedSample(p);
+ p->red*GetRedPixelComponent(p);
+ channel_statistics[RedChannel].skewness+=(double) p->red*p->red*GetRedPixelComponent(p);
if ((double) p->green < channel_statistics[GreenChannel].minima)
- channel_statistics[GreenChannel].minima=(double) GetGreenSample(p);
+ channel_statistics[GreenChannel].minima=(double) GetGreenPixelComponent(p);
if ((double) p->green > channel_statistics[GreenChannel].maxima)
- channel_statistics[GreenChannel].maxima=(double) GetGreenSample(p);
- channel_statistics[GreenChannel].mean+=GetGreenSample(p);
+ channel_statistics[GreenChannel].maxima=(double) GetGreenPixelComponent(p);
+ channel_statistics[GreenChannel].mean+=GetGreenPixelComponent(p);
channel_statistics[GreenChannel].standard_deviation+=(double) p->green*
- GetGreenSample(p);
+ GetGreenPixelComponent(p);
channel_statistics[GreenChannel].kurtosis+=(double) p->green*p->green*
- p->green*GetGreenSample(p);
+ p->green*GetGreenPixelComponent(p);
channel_statistics[GreenChannel].skewness+=(double) p->green*p->green*
- GetGreenSample(p);
+ GetGreenPixelComponent(p);
if ((double) p->blue < channel_statistics[BlueChannel].minima)
- channel_statistics[BlueChannel].minima=(double) GetBlueSample(p);
+ channel_statistics[BlueChannel].minima=(double) GetBluePixelComponent(p);
if ((double) p->blue > channel_statistics[BlueChannel].maxima)
- channel_statistics[BlueChannel].maxima=(double) GetBlueSample(p);
- channel_statistics[BlueChannel].mean+=GetBlueSample(p);
+ channel_statistics[BlueChannel].maxima=(double) GetBluePixelComponent(p);
+ channel_statistics[BlueChannel].mean+=GetBluePixelComponent(p);
channel_statistics[BlueChannel].standard_deviation+=(double) p->blue*
- GetBlueSample(p);
+ GetBluePixelComponent(p);
channel_statistics[BlueChannel].kurtosis+=(double) p->blue*p->blue*
- p->blue*GetBlueSample(p);
+ p->blue*GetBluePixelComponent(p);
channel_statistics[BlueChannel].skewness+=(double) p->blue*p->blue*
- GetBlueSample(p);
+ GetBluePixelComponent(p);
if (image->matte != MagickFalse)
{
if ((double) p->opacity < channel_statistics[OpacityChannel].minima)
- channel_statistics[OpacityChannel].minima=(double) GetOpacitySample(p);
+ channel_statistics[OpacityChannel].minima=(double) GetOpacityPixelComponent(p);
if ((double) p->opacity > channel_statistics[OpacityChannel].maxima)
- channel_statistics[OpacityChannel].maxima=(double) GetOpacitySample(p);
- channel_statistics[OpacityChannel].mean+=GetOpacitySample(p);
+ channel_statistics[OpacityChannel].maxima=(double) GetOpacityPixelComponent(p);
+ channel_statistics[OpacityChannel].mean+=GetOpacityPixelComponent(p);
channel_statistics[OpacityChannel].standard_deviation+=(double)
- p->opacity*GetOpacitySample(p);
+ p->opacity*GetOpacityPixelComponent(p);
channel_statistics[OpacityChannel].kurtosis+=(double) p->opacity*
- p->opacity*p->opacity*GetOpacitySample(p);
+ p->opacity*p->opacity*GetOpacityPixelComponent(p);
channel_statistics[OpacityChannel].skewness+=(double) p->opacity*
- p->opacity*GetOpacitySample(p);
+ p->opacity*GetOpacityPixelComponent(p);
}
if (image->colorspace == CMYKColorspace)
{
diff --git a/magick/stream.c b/magick/stream.c
index f7767fe..3e9dd4a 100644
--- a/magick/stream.c
+++ b/magick/stream.c
@@ -1373,9 +1373,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
break;
@@ -1387,10 +1387,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -1402,9 +1402,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
@@ -1429,9 +1429,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
break;
@@ -1443,10 +1443,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -1458,9 +1458,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
@@ -1480,29 +1480,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToChar(GetRedSample(p));
+ *q=ScaleQuantumToChar(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToChar(GetGreenSample(p));
+ *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToChar(GetBlueSample(p));
+ *q=ScaleQuantumToChar(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToChar(GetOpacitySample(p));
+ *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -1538,11 +1538,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
p++;
}
@@ -1555,13 +1555,13 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))))*
+ *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-GetOpacityPixelComponent(p))))*
quantum_info->scale+quantum_info->minimum);
p++;
}
@@ -1574,11 +1574,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
*q++=0.0;
p++;
@@ -1605,11 +1605,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
p++;
}
@@ -1622,13 +1622,13 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))))*
+ *q++=(double) ((QuantumScale*((Quantum) (QuantumRange-GetOpacityPixelComponent(p))))*
quantum_info->scale+quantum_info->minimum);
p++;
}
@@ -1641,11 +1641,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
*q++=0.0;
p++;
@@ -1666,33 +1666,33 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(double) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q=(double) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(double) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q=(double) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(double) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q=(double) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case AlphaQuantum:
{
*q=(double) ((QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))))*quantum_info->scale+quantum_info->minimum);
+ GetOpacityPixelComponent(p))))*quantum_info->scale+quantum_info->minimum);
break;
}
case OpacityQuantum:
{
- *q=(double) ((QuantumScale*GetOpacitySample(p))*quantum_info->scale+
+ *q=(double) ((QuantumScale*GetOpacityPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
@@ -1731,11 +1731,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
p++;
}
@@ -1748,13 +1748,13 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*(Quantum) (QuantumRange-GetOpacitySample(p)))*
+ *q++=(float) ((QuantumScale*(Quantum) (QuantumRange-GetOpacityPixelComponent(p)))*
quantum_info->scale+quantum_info->minimum);
p++;
}
@@ -1767,11 +1767,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
*q++=0.0;
p++;
@@ -1798,11 +1798,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
p++;
}
@@ -1815,13 +1815,13 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))))*
+ *q++=(float) ((QuantumScale*((Quantum) (QuantumRange-GetOpacityPixelComponent(p))))*
quantum_info->scale+quantum_info->minimum);
p++;
}
@@ -1834,11 +1834,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
- *q++=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q++=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
*q++=0.0;
p++;
@@ -1859,33 +1859,33 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(float) ((QuantumScale*GetRedSample(p))*quantum_info->scale+
+ *q=(float) ((QuantumScale*GetRedPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(float) ((QuantumScale*GetGreenSample(p))*quantum_info->scale+
+ *q=(float) ((QuantumScale*GetGreenPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(float) ((QuantumScale*GetBlueSample(p))*quantum_info->scale+
+ *q=(float) ((QuantumScale*GetBluePixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
case AlphaQuantum:
{
*q=(float) ((QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))))*quantum_info->scale+quantum_info->minimum);
+ GetOpacityPixelComponent(p))))*quantum_info->scale+quantum_info->minimum);
break;
}
case OpacityQuantum:
{
- *q=(float) ((QuantumScale*GetOpacitySample(p))*quantum_info->scale+
+ *q=(float) ((QuantumScale*GetOpacityPixelComponent(p))*quantum_info->scale+
quantum_info->minimum);
break;
}
@@ -1924,9 +1924,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
break;
@@ -1938,11 +1938,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -1954,9 +1954,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0U;
p++;
}
@@ -1982,9 +1982,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
break;
@@ -1996,11 +1996,11 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -2012,9 +2012,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0U;
p++;
}
@@ -2034,30 +2034,30 @@
case RedQuantum:
case CyanQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetOpacitySample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -2094,9 +2094,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
break;
@@ -2108,10 +2108,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -2123,9 +2123,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0;
p++;
}
@@ -2150,9 +2150,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
break;
@@ -2164,10 +2164,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -2179,9 +2179,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0;
p++;
}
@@ -2201,29 +2201,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToLong(GetRedSample(p));
+ *q=ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToLong(GetGreenSample(p));
+ *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToLong(GetBlueSample(p));
+ *q=ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToLong(GetOpacitySample(p));
+ *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
@@ -2259,9 +2259,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
p++;
}
break;
@@ -2273,10 +2273,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
p++;
}
break;
@@ -2288,9 +2288,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
*q++=0;
p++;
}
@@ -2315,9 +2315,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
p++;
}
break;
@@ -2329,10 +2329,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
p++;
}
break;
@@ -2344,9 +2344,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
*q++=0U;
p++;
}
@@ -2366,29 +2366,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=GetRedSample(p);
+ *q=GetRedPixelComponent(p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=GetGreenSample(p);
+ *q=GetGreenPixelComponent(p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=GetBlueSample(p);
+ *q=GetBluePixelComponent(p);
break;
}
case AlphaQuantum:
{
- *q=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q=(Quantum) (QuantumRange-GetOpacityPixelComponent(p));
break;
}
case OpacityQuantum:
{
- *q=GetOpacitySample(p);
+ *q=GetOpacityPixelComponent(p);
break;
}
case BlackQuantum:
@@ -2424,9 +2424,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
p++;
}
break;
@@ -2438,10 +2438,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -2453,9 +2453,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
*q++=0;
p++;
}
@@ -2480,9 +2480,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
p++;
}
break;
@@ -2494,10 +2494,10 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
p++;
}
break;
@@ -2509,9 +2509,9 @@
break;
for (x=0; x < (long) GetImageExtent(image); x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
*q++=0;
p++;
}
@@ -2531,29 +2531,29 @@
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToShort(GetRedSample(p));
+ *q=ScaleQuantumToShort(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToShort(GetGreenSample(p));
+ *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToShort(GetBlueSample(p));
+ *q=ScaleQuantumToShort(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToShort(GetOpacitySample(p));
+ *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
diff --git a/magick/transform.c b/magick/transform.c
index 2c388a8..545b37f 100644
--- a/magick/transform.c
+++ b/magick/transform.c
@@ -1470,12 +1470,12 @@
splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
for (x=0; x < splice_geometry.x; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
@@ -1485,12 +1485,12 @@
q++;
for ( ; x < (long) splice_image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
@@ -1547,12 +1547,12 @@
splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
for (x=0; x < splice_geometry.x; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
@@ -1562,12 +1562,12 @@
q++;
for ( ; x < (long) splice_image->columns; x++)
{
- SetRedSample(q,GetRedSample(p));
- SetGreenSample(q,GetGreenSample(p));
- SetBlueSample(q,GetBlueSample(p));
- SetOpacitySample(q,OpaqueOpacity);
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- SetOpacitySample(q,GetOpacitySample(p));
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
diff --git a/magick/xwindow.c b/magick/xwindow.c
index 0c20fad..b4ac089 100644
--- a/magick/xwindow.c
+++ b/magick/xwindow.c
@@ -102,7 +102,7 @@
/*
X defines.
*/
-#define XBlueGamma(color) RoundToQuantum(blue_gamma == 1.0 ? (double) \
+#define XBlueGamma(color) ClampToQuantum(blue_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) blue_gamma)* \
QuantumRange)))
#define XGammaPixel(map,color) (unsigned long) (map->base_pixel+ \
@@ -112,10 +112,10 @@
map->green_mult)+ \
((ScaleQuantumToShort(XBlueGamma((color)->blue))*map->blue_max/65535L)* \
map->blue_mult))
-#define XGreenGamma(color) RoundToQuantum(green_gamma == 1.0 ? (double) \
+#define XGreenGamma(color) ClampToQuantum(green_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) green_gamma)* \
QuantumRange)))
-#define XRedGamma(color) RoundToQuantum(red_gamma == 1.0 ? (double) \
+#define XRedGamma(color) ClampToQuantum(red_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) red_gamma)* \
QuantumRange)))
#define XStandardPixel(map,color) (unsigned long) (map->base_pixel+ \
@@ -556,7 +556,7 @@
break;
for (x=0; x < (long) annotate_image->columns; x++)
{
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (XGetPixel(annotate_ximage,x,y) == 0)
{
/*
@@ -2222,12 +2222,12 @@
break;
for (x=0; x < (int) image->columns; x++)
{
- color.red=RoundToQuantum((MagickRealType) (red_map[i][j][(int)
- ScaleQuantumToChar(GetRedSample(p))] << 8));
- color.green=RoundToQuantum((MagickRealType) (green_map[i][j][(int)
- ScaleQuantumToChar(GetGreenSample(p))] << 8));
- color.blue=RoundToQuantum((MagickRealType) (blue_map[i][j][(int)
- ScaleQuantumToChar(GetBlueSample(p))] << 8));
+ color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
+ ScaleQuantumToChar(GetRedPixelComponent(p))] << 8));
+ color.green=ClampToQuantum((MagickRealType) (green_map[i][j][(int)
+ ScaleQuantumToChar(GetGreenPixelComponent(p))] << 8));
+ color.blue=ClampToQuantum((MagickRealType) (blue_map[i][j][(int)
+ ScaleQuantumToChar(GetBluePixelComponent(p))] << 8));
pixel=(unsigned long) (((unsigned long) color.red & 0xe0) |
(((unsigned long) color.green & 0xe0) >> 3) |
(((unsigned long) color.blue & 0xc0) >> 6));
@@ -2596,7 +2596,7 @@
for (x=0; x < (long) draw_image->columns; x++)
{
if (q->opacity != (Quantum) TransparentOpacity)
- SetOpacitySample(q,OpaqueOpacity);
+ SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(draw_image,exception) == MagickFalse)
@@ -6240,9 +6240,9 @@
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
- *q++=ScaleQuantumToChar(XBlueGamma(GetBlueSample(p)));
- *q++=ScaleQuantumToChar(XGreenGamma(GetGreenSample(p)));
- *q++=ScaleQuantumToChar(XRedGamma(GetRedSample(p)));
+ *q++=ScaleQuantumToChar(XBlueGamma(GetBluePixelComponent(p)));
+ *q++=ScaleQuantumToChar(XGreenGamma(GetGreenPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XRedGamma(GetRedPixelComponent(p)));
*q++=0;
p++;
}
@@ -6250,9 +6250,9 @@
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
- *q++=ScaleQuantumToChar((Quantum) GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetGreenSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetRedSample(p));
+ *q++=ScaleQuantumToChar((Quantum) GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetRedPixelComponent(p));
*q++=0;
p++;
}
@@ -6281,9 +6281,9 @@
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
- *q++=ScaleQuantumToChar(XRedGamma(GetRedSample(p)));
- *q++=ScaleQuantumToChar(XGreenGamma(GetGreenSample(p)));
- *q++=ScaleQuantumToChar(XBlueGamma(GetBlueSample(p)));
+ *q++=ScaleQuantumToChar(XRedGamma(GetRedPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XGreenGamma(GetGreenPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XBlueGamma(GetBluePixelComponent(p)));
*q++=0;
p++;
}
@@ -6291,9 +6291,9 @@
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
- *q++=ScaleQuantumToChar((Quantum) GetRedSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetGreenSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetBlueSample(p));
+ *q++=ScaleQuantumToChar((Quantum) GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetBluePixelComponent(p));
*q++=0;
p++;
}
@@ -6845,9 +6845,9 @@
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
- *q++=ScaleQuantumToChar(XRedGamma(GetRedSample(p)));
- *q++=ScaleQuantumToChar(XGreenGamma(GetGreenSample(p)));
- *q++=ScaleQuantumToChar(XBlueGamma(GetBlueSample(p)));
+ *q++=ScaleQuantumToChar(XRedGamma(GetRedPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XGreenGamma(GetGreenPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XBlueGamma(GetBluePixelComponent(p)));
p++;
}
continue;
@@ -6855,9 +6855,9 @@
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
- *q++=ScaleQuantumToChar((Quantum) GetRedSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetGreenSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetBlueSample(p));
+ *q++=ScaleQuantumToChar((Quantum) GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetBluePixelComponent(p));
p++;
}
}
@@ -6886,9 +6886,9 @@
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
- *q++=ScaleQuantumToChar(XBlueGamma(GetBlueSample(p)));
- *q++=ScaleQuantumToChar(XGreenGamma(GetGreenSample(p)));
- *q++=ScaleQuantumToChar(XRedGamma(GetRedSample(p)));
+ *q++=ScaleQuantumToChar(XBlueGamma(GetBluePixelComponent(p)));
+ *q++=ScaleQuantumToChar(XGreenGamma(GetGreenPixelComponent(p)));
+ *q++=ScaleQuantumToChar(XRedGamma(GetRedPixelComponent(p)));
p++;
}
continue;
@@ -6896,9 +6896,9 @@
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
- *q++=ScaleQuantumToChar((Quantum) GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetGreenSample(p));
- *q++=ScaleQuantumToChar((Quantum) GetRedSample(p));
+ *q++=ScaleQuantumToChar((Quantum) GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) GetRedPixelComponent(p));
p++;
}
}
diff --git a/wand/deprecate.c b/wand/deprecate.c
index 660c6a6..7f43fb5 100644
--- a/wand/deprecate.c
+++ b/wand/deprecate.c
@@ -857,7 +857,7 @@
if (bordercolor != (PixelWand *) NULL)
PixelGetQuantumColor(bordercolor,&target);
wand->images->fuzz=fuzz;
- status=MatteFloodfillImage(wand->images,target,RoundToQuantum(
+ status=MatteFloodfillImage(wand->images,target,ClampToQuantum(
(MagickRealType) QuantumRange-QuantumRange*alpha),x,y,bordercolor !=
(PixelWand *) NULL ? FillToBorderMethod : FloodfillMethod);
if (status == MagickFalse)
diff --git a/wand/drawing-wand.c b/wand/drawing-wand.c
index 4011054..ac3b7cb 100644
--- a/wand/drawing-wand.c
+++ b/wand/drawing-wand.c
@@ -4723,7 +4723,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=RoundToQuantum((double) QuantumRange*(1.0-fill_opacity));
+ opacity=ClampToQuantum((double) QuantumRange*(1.0-fill_opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->fill.opacity != opacity))
{
@@ -4766,7 +4766,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- quantum_opacity=RoundToQuantum((double) QuantumRange*(1.0-opacity));
+ quantum_opacity=ClampToQuantum((double) QuantumRange*(1.0-opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->opacity != quantum_opacity))
{
@@ -5647,7 +5647,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=RoundToQuantum((double) QuantumRange*(1.0-stroke_opacity));
+ opacity=ClampToQuantum((double) QuantumRange*(1.0-stroke_opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->stroke.opacity != opacity))
{
@@ -6132,7 +6132,7 @@
{
value=GetXMLTreeContent(child);
if (value != (const char *) NULL)
- CurrentContext->fill.opacity=RoundToQuantum((MagickRealType)
+ CurrentContext->fill.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-StringToDouble(value)));
}
child=GetXMLTreeChild(xml_info,"fill-rule");
@@ -6295,7 +6295,7 @@
{
value=GetXMLTreeContent(child);
if (value != (const char *) NULL)
- CurrentContext->stroke.opacity=RoundToQuantum((MagickRealType)
+ CurrentContext->stroke.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-StringToDouble(value)));
}
child=GetXMLTreeChild(xml_info,"stroke-width");
diff --git a/wand/magick-image.c b/wand/magick-image.c
index 3d5ca0e..f370fad 100644
--- a/wand/magick-image.c
+++ b/wand/magick-image.c
@@ -10308,7 +10308,7 @@
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=SetImageOpacity(wand->images,RoundToQuantum((MagickRealType)
+ status=SetImageOpacity(wand->images,ClampToQuantum((MagickRealType)
QuantumRange-QuantumRange*alpha));
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
@@ -12069,7 +12069,7 @@
ThrowWandException(WandError,"ContainsNoImages",wand->name);
PixelGetMagickColor(target,&target_pixel);
wand->images->fuzz=fuzz;
- status=TransparentPaintImage(wand->images,&target_pixel,RoundToQuantum(
+ status=TransparentPaintImage(wand->images,&target_pixel,ClampToQuantum(
(MagickRealType) QuantumRange-QuantumRange*alpha),invert);
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
diff --git a/wand/pixel-wand.c b/wand/pixel-wand.c
index a6eaf8b..21f2c16 100644
--- a/wand/pixel-wand.c
+++ b/wand/pixel-wand.c
@@ -548,7 +548,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return((Quantum) QuantumRange-RoundToQuantum(wand->pixel.opacity));
+ return((Quantum) QuantumRange-ClampToQuantum(wand->pixel.opacity));
}
/*
@@ -610,7 +610,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.index));
+ return(ClampToQuantum(wand->pixel.index));
}
/*
@@ -672,7 +672,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.blue));
+ return(ClampToQuantum(wand->pixel.blue));
}
/*
@@ -850,7 +850,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.red));
+ return(ClampToQuantum(wand->pixel.red));
}
/*
@@ -1031,7 +1031,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.green));
+ return(ClampToQuantum(wand->pixel.green));
}
/*
@@ -1067,8 +1067,8 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- ConvertRGBToHSL(RoundToQuantum(wand->pixel.red),RoundToQuantum(
- wand->pixel.green),RoundToQuantum(wand->pixel.blue),hue,saturation,
+ ConvertRGBToHSL(ClampToQuantum(wand->pixel.red),ClampToQuantum(
+ wand->pixel.green),ClampToQuantum(wand->pixel.blue),hue,saturation,
lightness);
}
@@ -1162,7 +1162,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.green));
+ return(ClampToQuantum(wand->pixel.green));
}
/*
@@ -1259,7 +1259,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.opacity));
+ return(ClampToQuantum(wand->pixel.opacity));
}
/*
@@ -1293,20 +1293,20 @@
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
assert(color != (PixelPacket *) NULL);
- color->opacity=RoundToQuantum(wand->pixel.opacity);
+ color->opacity=ClampToQuantum(wand->pixel.opacity);
if (wand->pixel.colorspace == CMYKColorspace)
{
- color->red=RoundToQuantum((MagickRealType) QuantumRange-
+ color->red=ClampToQuantum((MagickRealType) QuantumRange-
(wand->pixel.red*(QuantumRange-wand->pixel.index)+wand->pixel.index));
- color->green=RoundToQuantum((MagickRealType) QuantumRange-
+ color->green=ClampToQuantum((MagickRealType) QuantumRange-
(wand->pixel.green*(QuantumRange-wand->pixel.index)+wand->pixel.index));
- color->blue=RoundToQuantum((MagickRealType) QuantumRange-
+ color->blue=ClampToQuantum((MagickRealType) QuantumRange-
(wand->pixel.blue*(QuantumRange-wand->pixel.index)+wand->pixel.index));
return;
}
- color->red=RoundToQuantum(wand->pixel.red);
- color->green=RoundToQuantum(wand->pixel.green);
- color->blue=RoundToQuantum(wand->pixel.blue);
+ color->red=ClampToQuantum(wand->pixel.red);
+ color->green=ClampToQuantum(wand->pixel.green);
+ color->blue=ClampToQuantum(wand->pixel.blue);
}
/*
@@ -1368,7 +1368,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.red));
+ return(ClampToQuantum(wand->pixel.red));
}
/*
@@ -1430,7 +1430,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(RoundToQuantum(wand->pixel.blue));
+ return(ClampToQuantum(wand->pixel.blue));
}
/*
@@ -1465,7 +1465,7 @@
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
wand->pixel.opacity=(MagickRealType) (QuantumRange-
- RoundToQuantum((MagickRealType) QuantumRange*alpha));
+ ClampToQuantum((MagickRealType) QuantumRange*alpha));
}
/*
@@ -1532,7 +1532,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.index=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.index=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*black);
}
@@ -1599,7 +1599,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.blue=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.blue=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*blue);
}
@@ -1776,7 +1776,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.red=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.red=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*cyan);
}
@@ -1876,7 +1876,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.green=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.green=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*green);
}
@@ -2020,7 +2020,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.green=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.green=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*magenta);
}
@@ -2124,7 +2124,7 @@
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
wand->pixel.matte=MagickTrue;
- wand->pixel.opacity=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.opacity=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*opacity);
}
@@ -2230,7 +2230,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.red=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.red=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*red);
}
@@ -2297,7 +2297,7 @@
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.blue=(MagickRealType) RoundToQuantum((MagickRealType)
+ wand->pixel.blue=(MagickRealType) ClampToQuantum((MagickRealType)
QuantumRange*yellow);
}