case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToChar(indexes[x]);
+ *q=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(double) (QuantumScale*indexes[x]);
+ *q=(double) (QuantumScale*GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(float) (QuantumScale*indexes[x]);
+ *q=(float) (QuantumScale*GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
+ *q=(unsigned int) ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToLong(indexes[x]);
+ *q=ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=indexes[x];
+ *q=GetIndexPixelComponent(indexes+x);
break;
}
case IndexQuantum:
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToShort(indexes[x]);
+ *q=ScaleQuantumToShort(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
- q->opacity=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
- q->opacity=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleCharToQuantum(*p);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleCharToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleCharToQuantum(*p);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleCharToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleCharToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleCharToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
p++;
q++;
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ClampToQuantum(
- (MagickRealType) QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case OpacityQuantum:
{
- q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlackQuantum:
{
- indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*(*p)));
break;
}
case IndexQuantum:
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
p++;
q++;
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ClampToQuantum(
- (MagickRealType) QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case OpacityQuantum:
{
- q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlackQuantum:
{
- indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*(*p)));
break;
}
case IndexQuantum:
{
- q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleLongToQuantum(*p);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleLongToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleLongToQuantum(*p);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleLongToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleLongToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleLongToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleLongToQuantum(*p);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleLongToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleLongToQuantum(*p);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleLongToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleLongToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleLongToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
- q->opacity=(Quantum) QuantumRange-(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
+ SetAlphaPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
- q->opacity=(Quantum) QuantumRange-(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
+ SetAlphaPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=(*p);
+ SetRedPixelComponent(q,*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=(*p);
+ SetGreenPixelComponent(q,*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=(*p);
+ SetBluePixelComponent(q,*p);
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-(*p);
+ SetAlphaPixelComponent(q,*p);
break;
}
case OpacityQuantum:
{
- q->opacity=(*p);
+ SetOpacityPixelComponent(q,*p);
break;
}
case BlackQuantum:
{
- indexes[x]=(*p);
+ SetIndexPixelComponent(indexes+x,*p);
break;
}
case IndexQuantum:
{
- q->red=(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,*p);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->red=ScaleShortToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->red=ScaleShortToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->red=ScaleShortToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
p++;
q++;
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->blue=ScaleShortToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->blue=ScaleShortToQuantum(*p++);
- q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->blue=ScaleShortToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
p++;
q++;
}
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleShortToQuantum(*p);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleShortToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleShortToQuantum(*p);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleShortToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleShortToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleShortToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
*/
static inline void AlphaBlendMagickPixelPacket(const Image *image,
- const PixelPacket *color,const IndexPacket *index,MagickPixelPacket *pixel,
+ const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel,
MagickRealType *alpha)
{
if (image->matte == MagickFalse)
{
*alpha=1.0;
- pixel->red=(MagickRealType) color->red;
- pixel->green=(MagickRealType) color->green;
- pixel->blue=(MagickRealType) color->blue;
- pixel->opacity=(MagickRealType) color->opacity;
+ pixel->red=(MagickRealType) GetRedPixelComponent(color);
+ pixel->green=(MagickRealType) GetGreenPixelComponent(color);
+ pixel->blue=(MagickRealType) GetBluePixelComponent(color);
+ pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
+ pixel->index=0.0;
if (((image->colorspace == CMYKColorspace) ||
(image->storage_class == PseudoClass)) &&
- (index != (const IndexPacket *) NULL))
- pixel->index=(MagickRealType) *index;
+ (indexes != (const IndexPacket *) NULL))
+ pixel->index=(MagickRealType) GetIndexPixelComponent(indexes);
return;
}
*alpha=QuantumScale*GetAlphaPixelComponent(color);
- pixel->red=(MagickRealType) (*alpha*color->red);
- pixel->green=(MagickRealType) (*alpha*color->green);
- pixel->blue=(MagickRealType) (*alpha*color->blue);
- pixel->opacity=(MagickRealType) (*alpha*color->opacity);
+ pixel->red=(*alpha*GetRedPixelComponent(color));
+ pixel->green=(*alpha*GetGreenPixelComponent(color));
+ pixel->blue=(*alpha*GetBluePixelComponent(color));
+ pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
+ pixel->index=0.0;
if (((image->colorspace == CMYKColorspace) ||
(image->storage_class == PseudoClass)) &&
- (index != (const IndexPacket *) NULL))
- pixel->index=(MagickRealType) (*alpha*(*index));
+ (indexes != (const IndexPacket *) NULL))
+ pixel->index=(*alpha*GetIndexPixelComponent(indexes));
}
static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
MagickBooleanType
status;
+ MagickPixelPacket
+ pixels[16];
+
+ MagickRealType
+ alpha[16],
+ gamma;
+
register const IndexPacket
*indexes;
register ssize_t
i;
+ ssize_t
+ x_offset,
+ y_offset;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
assert(image_view != (CacheView *) NULL);
status=MagickTrue;
+ x_offset=(ssize_t) floor(x);
+ y_offset=(ssize_t) floor(y);
switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
{
case AverageInterpolatePixel:
{
- MagickPixelPacket
- pixels[16];
-
- MagickRealType
- alpha[16],
- gamma;
-
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,
- (ssize_t) floor(y)-1,4,4,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
case BicubicInterpolatePixel:
{
MagickPixelPacket
- pixels[16],
u[4];
- MagickRealType
- alpha[16];
-
PointInfo
delta;
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
- floor(y)-1,4,4,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
for (i=0; i < 4L; i++)
BicubicInterpolate(pixels+4*i,delta.x,u+i);
BicubicInterpolate(u,delta.y,pixel);
case BilinearInterpolatePixel:
default:
{
- MagickPixelPacket
- pixels[4];
-
- MagickRealType
- alpha[4],
- gamma;
-
PointInfo
delta,
epsilon;
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
- floor(y),2,2,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
epsilon.x=1.0-delta.x;
epsilon.y=1.0-delta.y;
gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
geometry.width=4L;
geometry.height=4L;
- geometry.x=(ssize_t) floor(x)-1L;
- geometry.y=(ssize_t) floor(y)-1L;
+ geometry.x=x_offset-1;
+ geometry.y=y_offset-1;
excerpt_image=ExcerptImage(image,&geometry,exception);
if (excerpt_image == (Image *) NULL)
{
}
case IntegerInterpolatePixel:
{
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
- floor(y),1,1,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
}
case MeshInterpolatePixel:
{
- MagickPixelPacket
- pixels[4];
-
- MagickRealType
- alpha[4],
- gamma;
-
PointInfo
delta,
luminance;
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
- floor(y),2,2,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
+ exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
if (fabs(luminance.x) < fabs(luminance.y))
}
case SplineInterpolatePixel:
{
- MagickPixelPacket
- pixels[16];
-
MagickRealType
- alpha[16],
dx,
- dy,
- gamma;
+ dy;
PointInfo
delta;
j,
n;
- p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
- floor(y)-1,4,4,exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
pixel->blue=0.0;
pixel->opacity=0.0;
pixel->index=0.0;
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
n=0;
for (i=(-1); i < 3L; i++)
{