#include "magick/blob.h"
#include "magick/blob-private.h"
#include "magick/color-private.h"
+#include "magick/draw.h"
#include "magick/exception.h"
#include "magick/exception-private.h"
#include "magick/cache.h"
#include "magick/statistic.h"
#include "magick/stream.h"
#include "magick/string_.h"
+#include "magick/transform.h"
#include "magick/utility.h"
\f
/*
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:
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
return(MagickTrue);
}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% I n t e r p o l a t e M a g i c k P i x e l P a c k e t %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation
+% between a floating point coordinate and the pixels surrounding that
+% coordinate. No pixel area resampling, or scaling of the result is
+% performed.
+%
+% The format of the InterpolateMagickPixelPacket method is:
+%
+% MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
+% const CacheView *image_view,const InterpolatePixelMethod method,
+% const double x,const double y,MagickPixelPacket *pixel,
+% ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o image_view: the image view.
+%
+% o method: the pixel color interpolation method.
+%
+% o x,y: A double representing the current (x,y) position of the pixel.
+%
+% o pixel: return the interpolated pixel here.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+
+static inline void AlphaBlendMagickPixelPacket(const Image *image,
+ const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel,
+ MagickRealType *alpha)
+{
+ 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,
+ MagickPixelPacket *pixel)
+{
+ MagickRealType
+ dx2,
+ p,
+ q,
+ r,
+ s;
+
+ dx2=dx*dx;
+ p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
+ q=(pixels[0].red-pixels[1].red)-p;
+ r=pixels[2].red-pixels[0].red;
+ s=pixels[1].red;
+ pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
+ p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
+ q=(pixels[0].green-pixels[1].green)-p;
+ r=pixels[2].green-pixels[0].green;
+ s=pixels[1].green;
+ pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
+ p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
+ q=(pixels[0].blue-pixels[1].blue)-p;
+ r=pixels[2].blue-pixels[0].blue;
+ s=pixels[1].blue;
+ pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
+ p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
+ q=(pixels[0].opacity-pixels[1].opacity)-p;
+ r=pixels[2].opacity-pixels[0].opacity;
+ s=pixels[1].opacity;
+ pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
+ if (pixel->colorspace == CMYKColorspace)
+ {
+ p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
+ q=(pixels[0].index-pixels[1].index)-p;
+ r=pixels[2].index-pixels[0].index;
+ s=pixels[1].index;
+ pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
+ }
+}
+
+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
+ alpha,
+ gamma;
+
+ alpha=MagickMax(x+2.0,0.0);
+ gamma=1.0*alpha*alpha*alpha;
+ alpha=MagickMax(x+1.0,0.0);
+ gamma-=4.0*alpha*alpha*alpha;
+ alpha=MagickMax(x+0.0,0.0);
+ gamma+=6.0*alpha*alpha*alpha;
+ alpha=MagickMax(x-1.0,0.0);
+ gamma-=4.0*alpha*alpha*alpha;
+ return(gamma/6.0);
+}
+
+static inline double MeshInterpolate(const PointInfo *delta,const double p,
+ const double x,const double y)
+{
+ return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
+}
+
+static inline ssize_t NearestNeighbor(const MagickRealType x)
+{
+ if (x >= 0.0)
+ return((ssize_t) (x+0.5));
+ return((ssize_t) (x-0.5));
+}
+
+MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
+ const CacheView *image_view,const InterpolatePixelMethod method,
+ const double x,const double y,MagickPixelPacket *pixel,
+ ExceptionInfo *exception)
+{
+ MagickBooleanType
+ status;
+
+ MagickPixelPacket
+ pixels[16];
+
+ MagickRealType
+ alpha[16],
+ gamma;
+
+ register const IndexPacket
+ *indexes;
+
+ register const PixelPacket
+ *p;
+
+ 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:
+ {
+ 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++)
+ {
+ 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;
+ }
+ break;
+ }
+ case BicubicInterpolatePixel:
+ {
+ MagickPixelPacket
+ u[4];
+
+ PointInfo
+ delta;
+
+ 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);
+ 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);
+ break;
+ }
+ case BilinearInterpolatePixel:
+ default:
+ {
+ PointInfo
+ delta,
+ epsilon;
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,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);
+ 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*
+ (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*
+ pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
+ pixels[3].green));
+ pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
+ pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
+ pixels[3].blue));
+ pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
+ pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
+ pixels[3].opacity));
+ if (image->colorspace == CMYKColorspace)
+ pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
+ pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
+ pixels[3].index));
+ break;
+ }
+ case FilterInterpolatePixel:
+ {
+ CacheView
+ *filter_view;
+
+ Image
+ *excerpt_image,
+ *filter_image;
+
+ RectangleInfo
+ geometry;
+
+ geometry.width=4L;
+ geometry.height=4L;
+ geometry.x=x_offset-1;
+ geometry.y=y_offset-1;
+ excerpt_image=ExcerptImage(image,&geometry,exception);
+ if (excerpt_image == (Image *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
+ exception);
+ excerpt_image=DestroyImage(excerpt_image);
+ if (filter_image == (Image *) NULL)
+ break;
+ filter_view=AcquireCacheView(filter_image);
+ p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
+ if (p != (const PixelPacket *) NULL)
+ {
+ indexes=GetVirtualIndexQueue(filter_image);
+ SetMagickPixelPacket(image,p,indexes,pixel);
+ }
+ filter_view=DestroyCacheView(filter_view);
+ filter_image=DestroyImage(filter_image);
+ break;
+ }
+ case IntegerInterpolatePixel:
+ {
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
+ if (p == (const PixelPacket *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ SetMagickPixelPacket(image,p,indexes,pixel);
+ break;
+ }
+ case MeshInterpolatePixel:
+ {
+ PointInfo
+ delta,
+ luminance;
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
+ 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);
+ 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))
+ {
+ /*
+ Diagonal 0-3 NW-SE.
+ */
+ if (delta.x <= delta.y)
+ {
+ /*
+ Bottom-left triangle (pixel:2, diagonal: 0-3).
+ */
+ delta.y=1.0-delta.y;
+ gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
+ pixels[3].red,pixels[0].red);
+ pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
+ pixels[3].green,pixels[0].green);
+ pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
+ pixels[3].blue,pixels[0].blue);
+ pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
+ pixels[3].opacity,pixels[0].opacity);
+ if (image->colorspace == CMYKColorspace)
+ pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
+ pixels[3].index,pixels[0].index);
+ }
+ else
+ {
+ /*
+ Top-right triangle (pixel:1, diagonal: 0-3).
+ */
+ delta.x=1.0-delta.x;
+ gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
+ pixels[0].red,pixels[3].red);
+ pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
+ pixels[0].green,pixels[3].green);
+ pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
+ pixels[0].blue,pixels[3].blue);
+ pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
+ pixels[0].opacity,pixels[3].opacity);
+ if (image->colorspace == CMYKColorspace)
+ pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
+ pixels[0].index,pixels[3].index);
+ }
+ }
+ else
+ {
+ /*
+ Diagonal 1-2 NE-SW.
+ */
+ if (delta.x <= (1.0-delta.y))
+ {
+ /*
+ Top-left triangle (pixel 0, diagonal: 1-2).
+ */
+ gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
+ pixels[1].red,pixels[2].red);
+ pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
+ pixels[1].green,pixels[2].green);
+ pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
+ pixels[1].blue,pixels[2].blue);
+ pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
+ pixels[1].opacity,pixels[2].opacity);
+ if (image->colorspace == CMYKColorspace)
+ pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
+ pixels[1].index,pixels[2].index);
+ }
+ else
+ {
+ /*
+ Bottom-right triangle (pixel: 3, diagonal: 1-2).
+ */
+ delta.x=1.0-delta.x;
+ delta.y=1.0-delta.y;
+ gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
+ pixels[2].red,pixels[1].red);
+ pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
+ pixels[2].green,pixels[1].green);
+ pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
+ pixels[2].blue,pixels[1].blue);
+ pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
+ pixels[2].opacity,pixels[1].opacity);
+ if (image->colorspace == CMYKColorspace)
+ pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
+ pixels[2].index,pixels[1].index);
+ }
+ }
+ break;
+ }
+ case NearestNeighborInterpolatePixel:
+ {
+ p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
+ NearestNeighbor(y),1,1,exception);
+ if (p == (const PixelPacket *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ SetMagickPixelPacket(image,p,indexes,pixel);
+ break;
+ }
+ case SplineInterpolatePixel:
+ {
+ MagickRealType
+ dx,
+ dy;
+
+ PointInfo
+ delta;
+
+ ssize_t
+ j,
+ n;
+
+ 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;
+ for (i=(-1); i < 3L; i++)
+ {
+ dy=CubicWeightingFunction((MagickRealType) i-delta.y);
+ for (j=(-1); j < 3L; j++)
+ {
+ dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
+ 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;
+ pixel->opacity+=dx*dy*pixels[n].opacity;
+ if (image->colorspace == CMYKColorspace)
+ pixel->index+=gamma*dx*dy*pixels[n].index;
+ n++;
+ }
+ }
+ break;
+ }
+ }
+ return(status);
+}
projects / imagemagick / blobdiff