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 double MagickMax(const MagickRealType x,const MagickRealType y)
+static inline void AlphaBlendMagickPixelPacket(const Image *image,
+ const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel,
+ MagickRealType *alpha)
{
- if (x > y)
- return(x);
- return(y);
+ if (image->matte == MagickFalse)
+ {
+ *alpha=1.0;
+ 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)) &&
+ (indexes != (const IndexPacket *) NULL))
+ pixel->index=(MagickRealType) GetIndexPixelComponent(indexes);
+ return;
+ }
+ *alpha=QuantumScale*GetAlphaPixelComponent(color);
+ 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)) &&
+ (indexes != (const IndexPacket *) NULL))
+ pixel->index=(*alpha*GetIndexPixelComponent(indexes));
}
static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
}
}
+static inline double MagickMax(const MagickRealType x,const MagickRealType y)
+{
+ if (x > y)
+ return(x);
+ return(y);
+}
+
static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
{
MagickRealType
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;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
+ AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
+ 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);
+ AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
+ AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
+ AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
+ AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
+ AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
+ AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
+ AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
+ AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
+ AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
+ 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);
+ pixel->red=0.0;
+ pixel->green=0.0;
+ pixel->blue=0.0;
+ pixel->opacity=0.0;
+ pixel->index=0.0;
for (i=0; i < 16L; i++)
{
- SetMagickPixelPacket(image,p,indexes+i,pixels+i);
- alpha[i]=1.0;
- if (image->matte != MagickFalse)
- {
- alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
- pixels[i].red*=alpha[i];
- pixels[i].green*=alpha[i];
- pixels[i].blue*=alpha[i];
- if (image->colorspace == CMYKColorspace)
- pixels[i].index*=alpha[i];
- }
- gamma=alpha[i];
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
pixel->red+=gamma*0.0625*pixels[i].red;
pixel->green+=gamma*0.0625*pixels[i].green;
pixel->blue+=gamma*0.0625*pixels[i].blue;
pixel->opacity+=0.0625*pixels[i].opacity;
if (image->colorspace == CMYKColorspace)
pixel->index+=gamma*0.0625*pixels[i].index;
- p++;
}
break;
}
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;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
- for (i=0; i < 16L; i++)
- {
- SetMagickPixelPacket(image,p,indexes+i,pixels+i);
- alpha[i]=1.0;
- if (image->matte != MagickFalse)
- {
- alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
- pixels[i].red*=alpha[i];
- pixels[i].green*=alpha[i];
- pixels[i].blue*=alpha[i];
- if (image->colorspace == CMYKColorspace)
- pixels[i].index*=alpha[i];
- }
- p++;
- }
- delta.x=x-floor(x);
+ AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
+ 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);
+ AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
+ AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
+ AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
+ AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
+ AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
+ AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
+ AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
+ AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
+ AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
+ 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-x_offset;
+ delta.y=y-y_offset;
for (i=0; i < 4L; i++)
BicubicInterpolate(pixels+4*i,delta.x,u+i);
- delta.y=y-floor(y);
BicubicInterpolate(u,delta.y,pixel);
break;
}
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;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
- SetMagickPixelPacket(image,p+0,indexes+0,pixels+0);
- SetMagickPixelPacket(image,p+1,indexes+1,pixels+1);
- SetMagickPixelPacket(image,p+2,indexes+2,pixels+2);
- SetMagickPixelPacket(image,p+3,indexes+3,pixels+3);
- if (image->matte != MagickFalse)
- for (i=0; i < 4L; i++)
- {
- alpha[i]=QuantumScale*GetAlphaPixelComponent(p+i);
- pixels[i].red*=alpha[i];
- pixels[i].green*=alpha[i];
- pixels[i].blue*=alpha[i];
- if (image->colorspace == CMYKColorspace)
- pixels[i].index*=alpha[i];
- }
- gamma=1.0;
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
+ 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-x_offset;
+ delta.y=y-y_offset;
epsilon.x=1.0-delta.x;
epsilon.y=1.0-delta.y;
- if (image->matte != MagickFalse)
- {
- gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
- (epsilon.x*alpha[2]+delta.x*alpha[3])));
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
- }
+ gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
+ (epsilon.x*alpha[2]+delta.x*alpha[3])));
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
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] = { 1.0, 1.0, 1.0, 1.0 },
- gamma = 1.0;
-
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;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
- SetMagickPixelPacket(image,p+0,indexes+0,pixels+0);
- SetMagickPixelPacket(image,p+1,indexes+1,pixels+1);
- SetMagickPixelPacket(image,p+2,indexes+2,pixels+2);
- SetMagickPixelPacket(image,p+3,indexes+3,pixels+3);
- if (image->matte != MagickFalse)
- for (i=0; i < 4L; i++)
- {
- alpha[i]=QuantumScale*GetAlphaPixelComponent(p+i);
- pixels[i].red*=alpha[i];
- pixels[i].green*=alpha[i];
- pixels[i].blue*=alpha[i];
- if (image->colorspace == CMYKColorspace)
- pixels[i].index*=alpha[i];
- }
- delta.x=x-floor(x);
- delta.y=y-floor(y);
+ AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
+ 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-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;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
+ AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
+ 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);
+ AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
+ AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
+ AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
+ AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
+ AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
+ AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
+ AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
+ AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
+ AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
+ 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);
+ pixel->red=0.0;
+ pixel->green=0.0;
+ pixel->blue=0.0;
+ pixel->opacity=0.0;
+ pixel->index=0.0;
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
n=0;
- delta.x=x-floor(x);
- delta.y=y-floor(y);
for (i=(-1); i < 3L; i++)
{
dy=CubicWeightingFunction((MagickRealType) i-delta.y);
for (j=(-1); j < 3L; j++)
{
- SetMagickPixelPacket(image,p,indexes+n,pixels+n);
- alpha[n]=1.0;
- if (image->matte != MagickFalse)
- {
- alpha[n]=QuantumScale*((MagickRealType)
- GetAlphaPixelComponent(p));
- pixels[n].red*=alpha[n];
- pixels[n].green*=alpha[n];
- pixels[n].blue*=alpha[n];
- if (image->colorspace == CMYKColorspace)
- pixels[n].index*=alpha[n];
- }
dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
- gamma=alpha[n];
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
pixel->red+=gamma*dx*dy*pixels[n].red;
pixel->green+=gamma*dx*dy*pixels[n].green;
pixel->blue+=gamma*dx*dy*pixels[n].blue;
if (image->colorspace == CMYKColorspace)
pixel->index+=gamma*dx*dy*pixels[n].index;
n++;
- p++;
}
}
break;
projects / imagemagick / blobdiff