% %
% %
% %
-+ A c q u i r e P i x e l C o m p o n e n t M a p %
++ A c q u i r e P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% AcquirePixelComponentMap() acquires a pixel component map.
+% AcquirePixelChannelMap() acquires a pixel component map.
%
-% The format of the AcquirePixelComponentMap() method is:
+% The format of the AcquirePixelChannelMap() method is:
%
-% PixelComponentMap **AcquirePixelComponentMap(void)
+% PixelChannelMap **AcquirePixelChannelMap(void)
%
*/
-MagickExport PixelComponentMap **AcquirePixelComponentMap(void)
+MagickExport PixelChannelMap **AcquirePixelChannelMap(void)
{
- PixelComponentMap
- **component_map;
+ PixelChannelMap
+ **channel_map;
register ssize_t
i;
- component_map=(PixelComponentMap **) AcquireAlignedMemory(
- MaxPixelComponentMaps,sizeof(**component_map));
- if (component_map == (PixelComponentMap **) NULL)
+ channel_map=(PixelChannelMap **) AcquireAlignedMemory(MaxPixelChannelMaps,
+ sizeof(**channel_map));
+ if (channel_map == (PixelChannelMap **) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- for (i=0; i < MaxPixelComponentMaps; i++)
+ for (i=0; i < MaxPixelChannelMaps; i++)
{
register ssize_t
j;
- component_map[i]=(PixelComponentMap *) AcquireQuantumMemory(
- MaxPixelComponents,sizeof(*component_map[i]));
- if (component_map[i] == (PixelComponentMap *) NULL)
+ channel_map[i]=(PixelChannelMap *) AcquireQuantumMemory(MaxPixelChannels,
+ sizeof(*channel_map[i]));
+ if (channel_map[i] == (PixelChannelMap *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- (void) ResetMagickMemory(component_map[i],0,MaxPixelComponents*
- sizeof(*component_map[i]));
- for (j=0; j < MaxPixelComponents; j++)
- component_map[i][j].component=(PixelComponent) j;
+ (void) ResetMagickMemory(channel_map[i],0,MaxPixelChannels*
+ sizeof(*channel_map[i]));
+ for (j=0; j < MaxPixelChannels; j++)
+ channel_map[i][j].channel=(PixelChannel) j;
}
- return(component_map);
+ return(channel_map);
}
\f
/*
% %
% %
% %
-+ C l o n e P i x e l C o m p o n e n t M a p %
++ C l o n e P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% ClonePixelComponentMap() clones a pixel component map.
+% ClonePixelChannelMap() clones a pixel component map.
%
-% The format of the ClonePixelComponentMap() method is:
+% The format of the ClonePixelChannelMap() method is:
%
-% PixelComponentMap **ClonePixelComponentMap(
-% PixelComponentMap **component_map)
+% PixelChannelMap **ClonePixelChannelMap(
+% PixelChannelMap **channel_map)
%
% A description of each parameter follows:
%
-% o component_map: the pixel component map.
+% o channel_map: the pixel component map.
%
*/
-MagickExport PixelComponentMap **ClonePixelComponentMap(
- PixelComponentMap **component_map)
+MagickExport PixelChannelMap **ClonePixelChannelMap(
+ PixelChannelMap **channel_map)
{
- PixelComponentMap
+ PixelChannelMap
**clone_map;
register ssize_t
i;
- assert(component_map != (PixelComponentMap **) NULL);
- clone_map=AcquirePixelComponentMap();
- if (clone_map == (PixelComponentMap **) NULL)
- return((PixelComponentMap **) NULL);
- for (i=0; i < MaxPixelComponentMaps; i++)
- (void) CopyMagickMemory(clone_map[i],component_map[i],MaxPixelComponents*
- sizeof(*component_map[i]));
+ assert(channel_map != (PixelChannelMap **) NULL);
+ clone_map=AcquirePixelChannelMap();
+ if (clone_map == (PixelChannelMap **) NULL)
+ return((PixelChannelMap **) NULL);
+ for (i=0; i < MaxPixelChannelMaps; i++)
+ (void) CopyMagickMemory(clone_map[i],channel_map[i],MaxPixelChannels*
+ sizeof(*channel_map[i]));
return(clone_map);
}
\f
% %
% %
% %
-+ D e s t r o y P i x e l C o m p o n e n t M a p %
++ D e s t r o y P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DestroyPixelComponentMap() deallocates memory associated with the pixel
-% component map.
+% DestroyPixelChannelMap() deallocates memory associated with the pixel
+% channel map.
%
-% The format of the DestroyPixelComponentMap() method is:
+% The format of the DestroyPixelChannelMap() method is:
%
-% PixelComponentMap **DestroyPixelComponentMap(
-% PixelComponentMap **component_map)
+% PixelChannelMap **DestroyPixelChannelMap(PixelChannelMap **channel_map)
%
% A description of each parameter follows:
%
-% o component_map: the pixel component map.
+% o channel_map: the pixel component map.
%
*/
-MagickExport PixelComponentMap **DestroyPixelComponentMap(
- PixelComponentMap **component_map)
+MagickExport PixelChannelMap **DestroyPixelChannelMap(
+ PixelChannelMap **channel_map)
{
register ssize_t
i;
- assert(component_map != (PixelComponentMap **) NULL);
- for (i=0; i < MaxPixelComponentMaps; i++)
- component_map[i]=(PixelComponentMap *) RelinquishMagickMemory(
- component_map[i]);
- return((PixelComponentMap **) RelinquishMagickMemory(component_map));
+ assert(channel_map != (PixelChannelMap **) NULL);
+ for (i=0; i < MaxPixelChannelMaps; i++)
+ channel_map[i]=(PixelChannelMap *) RelinquishMagickMemory(channel_map[i]);
+ return((PixelChannelMap **) RelinquishMagickMemory(channel_map));
}
\f
/*
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=0.0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=(double) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=0.0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=0.0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=(float) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=0.0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=0U;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
{
*q++=(unsigned int) ScaleQuantumToLong(
GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=0U;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelBlue(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
*q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
*q++=(Quantum) 0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=GetPixelIntensity(image,p);
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelRed(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
*q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
*q++=(Quantum) 0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=0;
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
}
q++;
}
- p+=GetPixelComponents(image);
+ p+=GetPixelChannels(image);
}
}
break;
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(*p)),q);
p++;
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(*p)),q);
p++;
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,*p++,q);
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
SetPixelAlpha(image,*p++,q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,*p++,q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,*p++,q);
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
SetPixelAlpha(image,*p++,q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
p++;
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
% %
% %
% %
-% 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 %
+% I n t e r p o l a t e P i x e l C h a n n e l %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% InterpolatePixelInfo() 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.
+% InterpolatePixelChannel() applies a pixel interpolation method 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 InterpolatePixelChannel method is:
+%
+% MagickBooleanType InterpolatePixelChannel(const Image *image,
+% const PixelChannel channel,const CacheView *image_view,
+% const InterpolatePixelMethod method,const double x,const double y,
+% double *pixel,ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o image_view: the image view.
+%
+% o channel: the pixel channel to interpolate.
+%
+% 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 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 InterpolatePixelChannel(const Image *image,
+ const CacheView *image_view,const PixelChannel channel,
+ const InterpolatePixelMethod method,const double x,const double y,
+ double *pixel,ExceptionInfo *exception)
+{
+ MagickBooleanType
+ status;
+
+ MagickRealType
+ alpha[16],
+ gamma,
+ pixels[16];
+
+ PixelTrait
+ traits;
+
+ register const Quantum
+ *p;
+
+ register ssize_t
+ i;
+
+ ssize_t
+ x_offset,
+ y_offset;
+
+ assert(image != (Image *) NULL);
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ assert(image_view != (CacheView *) NULL);
+ status=MagickTrue;
+ *pixel=0.0;
+ traits=GetPixelChannelMapTraits(image,channel);
+ 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 Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if (((traits & BlendPixelTrait) == 0) ||
+ (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+ (image->matte == MagickFalse))
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ for (i=0; i < 16; i++)
+ {
+ gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
+ *pixel+=gamma*0.0625*pixels[i];
+ }
+ break;
+ }
+ case BicubicInterpolatePixel:
+ {
+ MagickRealType
+ u[4],
+ v[4];
+
+ PointInfo
+ delta;
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if (((traits & BlendPixelTrait) == 0) ||
+ (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+ (image->matte == MagickFalse))
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
+ for (i=0; i < 4; i++)
+ {
+ u[0]=(pixels[4*i+3]-pixels[4*i+2])-(pixels[4*i+0]-pixels[4*i+1]);
+ u[1]=(pixels[4*i+0]-pixels[4*i+1])-u[0];
+ u[2]=pixels[4*i+2]-pixels[4*i+0];
+ u[3]=pixels[4*i+1];
+ v[i]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
+ u[2])+u[3];
+ }
+ u[0]=(v[3]-v[2])-(v[0]-v[1]);
+ u[1]=(v[0]-v[1])-u[0];
+ u[2]=v[2]-v[0];
+ u[3]=v[1];
+ *pixel=(delta.y*delta.y*delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*
+ u[2])+u[3];
+ break;
+ }
+ case BilinearInterpolatePixel:
+ default:
+ {
+ PointInfo
+ delta,
+ epsilon;
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if (((traits & BlendPixelTrait) == 0) ||
+ (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+ (image->matte == MagickFalse))
+ for (i=0; i < 4; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 4; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ 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=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
+ (epsilon.x*pixels[2]+delta.x*pixels[3]));
+ 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 Quantum *) NULL)
+ status=MagickFalse;
+ else
+ *pixel=(double) p[channel];
+ 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 Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ *pixel=(double) p[channel];
+ break;
+ }
+ case NearestNeighborInterpolatePixel:
+ {
+ p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
+ NearestNeighbor(y),1,1,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ *pixel=(double) p[channel];
+ break;
+ }
+ case MeshInterpolatePixel:
+ {
+ PointInfo
+ delta,
+ luminance;
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if (((traits & BlendPixelTrait) == 0) ||
+ (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+ (image->matte == MagickFalse))
+ for (i=0; i < 4; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 4; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ delta.x=x-x_offset;
+ delta.y=y-y_offset;
+ luminance.x=GetPixelLuminance(image,p)-(double)
+ GetPixelLuminance(image,p+3*GetPixelChannels(image));
+ luminance.y=GetPixelLuminance(image,p+1*GetPixelChannels(image))-(double)
+ GetPixelLuminance(image,p+2*GetPixelChannels(image));
+ 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=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
+ pixels[0]);
+ }
+ 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=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
+ pixels[3]);
+ }
+ }
+ 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=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
+ pixels[2]);
+ }
+ 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=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
+ pixels[1]);
+ }
+ }
+ 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 Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if (((traits & BlendPixelTrait) == 0) ||
+ (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+ (image->matte == MagickFalse))
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ 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+=gamma*dx*dy*pixels[n];
+ n++;
+ }
+ }
+ break;
+ }
+ }
+ return(status);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% I n t e r p o l a t e P i x e l I n f o %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% InterpolatePixelInfo() applies a pixel interpolation method 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 InterpolatePixelInfo method is:
%
}
}
-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 InterpolatePixelInfo(const Image *image,
const CacheView *image_view,const InterpolatePixelMethod method,
const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
break;
}
AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+1*GetPixelComponents(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelComponents(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelComponents(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelComponents(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelComponents(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelComponents(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelComponents(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelComponents(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelComponents(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelComponents(image),pixels+10,alpha+
+ AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
+ AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
+ AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
+ AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
+ AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
+ AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
+ AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
+ AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
+ AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
+ AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
10);
- AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,alpha+
+ AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
11);
- AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,alpha+
+ AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
12);
- AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,alpha+
+ AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
13);
- AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,alpha+
+ AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
14);
- AlphaBlendPixelInfo(image,p+15*GetPixelComponents(image),pixels+15,alpha+
+ AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
15);
pixel->red=0.0;
pixel->green=0.0;
break;
}
AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+1*GetPixelComponents(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelComponents(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelComponents(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelComponents(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelComponents(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelComponents(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelComponents(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelComponents(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelComponents(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelComponents(image),pixels+10,alpha+
+ AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
+ AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
+ AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
+ AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
+ AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
+ AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
+ AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
+ AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
+ AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
+ AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
10);
- AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,alpha+
+ AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
11);
- AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,alpha+
+ AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
12);
- AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,alpha+
+ AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
13);
- AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,alpha+
+ AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
14);
- AlphaBlendPixelInfo(image,p+15*GetPixelComponents(image),pixels+15,alpha+
+ AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
15);
delta.x=x-x_offset;
delta.y=y-y_offset;
break;
}
AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+1*GetPixelComponents(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelComponents(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelComponents(image),pixels+3,alpha+3);
+ AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
+ AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
+ AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
delta.x=x-x_offset;
delta.y=y-y_offset;
epsilon.x=1.0-delta.x;
pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
pixels[3].black));
+ gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
pixels[3].alpha));
delta,
luminance;
- p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
- exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
- AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+1*GetPixelComponents(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelComponents(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelComponents(image),pixels+3,alpha+3);
delta.x=x-x_offset;
delta.y=y-y_offset;
- luminance.x=GetPixelInfoLuminance(pixels+0)-(double)
- GetPixelInfoLuminance(pixels+3);
- luminance.y=GetPixelInfoLuminance(pixels+1)-(double)
- GetPixelInfoLuminance(pixels+2);
+ luminance.x=GetPixelLuminance(image,p)-(double)
+ GetPixelLuminance(image,p+3*GetPixelChannels(image));
+ luminance.y=GetPixelLuminance(image,p+1*GetPixelChannels(image))-(double)
+ GetPixelLuminance(image,p+2*GetPixelChannels(image));
+ AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
+ AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
+ AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
+ AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
if (fabs(luminance.x) < fabs(luminance.y))
{
/*
if (delta.x <= delta.y)
{
/*
- Bottom-left triangle (pixel:2, diagonal: 0-3).
+ Bottom-left triangle (pixel: 2, diagonal: 0-3).
*/
delta.y=1.0-delta.y;
gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
if (image->colorspace == CMYKColorspace)
pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
pixels[3].black,pixels[0].black);
+ gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
pixels[3].alpha,pixels[0].alpha);
}
else
{
/*
- Top-right triangle (pixel:1, diagonal: 0-3).
+ Top-right triangle (pixel:1 , diagonal: 0-3).
*/
delta.x=1.0-delta.x;
gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
if (image->colorspace == CMYKColorspace)
pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
pixels[0].black,pixels[3].black);
+ gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
pixels[0].alpha,pixels[3].alpha);
}
if (delta.x <= (1.0-delta.y))
{
/*
- Top-left triangle (pixel 0, diagonal: 1-2).
+ 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);
if (image->colorspace == CMYKColorspace)
pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
pixels[1].black,pixels[2].black);
+ gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
pixels[1].alpha,pixels[2].alpha);
}
if (image->colorspace == CMYKColorspace)
pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
pixels[2].black,pixels[1].black);
+ gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
pixels[2].alpha,pixels[1].alpha);
}
break;
}
AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+1*GetPixelComponents(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelComponents(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelComponents(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelComponents(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelComponents(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelComponents(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelComponents(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelComponents(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelComponents(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelComponents(image),pixels+10,alpha+
+ AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
+ AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
+ AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
+ AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
+ AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
+ AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
+ AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
+ AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
+ AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
+ AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
10);
- AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,alpha+
+ AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
11);
- AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,alpha+
+ AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
12);
- AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,alpha+
+ AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
13);
- AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,alpha+
+ AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
14);
- AlphaBlendPixelInfo(image,p+15*GetPixelComponents(image),pixels+15,alpha+
+ AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
15);
pixel->red=0.0;
pixel->green=0.0;
% %
% %
% %
-% P o p P i x e l C o m p o n e n t M a p %
+% P o p P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% PopPixelComponentMap() pops the pixel component map.
+% PopPixelChannelMap() pops the pixel component map.
%
-% The format of the PopPixelComponentMap method is:
+% The format of the PopPixelChannelMap method is:
%
-% void PopPixelComponentMap(Image *image)
+% void PopPixelChannelMap(Image *image)
%
% A description of each parameter follows:
%
% o image: the image.
%
*/
-MagickExport void PopPixelComponentMap(Image *image)
+MagickExport void PopPixelChannelMap(Image *image)
{
image->map--;
if (image->map < 0)
- ThrowFatalException(ResourceLimitFatalError,"PixelComponentMapStack");
+ ThrowFatalException(ResourceLimitFatalError,"PixelChannelMapStack");
}
\f
/*
% %
% %
% %
-% P u s h P i x e l C o m p o n e n t M a p %
+% P u s h P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% PushPixelComponentMap() pushes the pixel component map from the specified
+% PushPixelChannelMap() pushes the pixel channel map from the specified
% channel mask.
%
-% The format of the PushPixelComponentMap method is:
+% The format of the PushPixelChannelMap method is:
%
-% void PushPixelComponentMap(Image *image,const ChannelType channel_mask)
+% void PushPixelChannelMap(Image *image,const ChannelType channel_mask)
%
% A description of each parameter follows:
%
% o channel_mask: the channel mask.
%
*/
-MagickExport void PushPixelComponentMap(Image *image,
+MagickExport void PushPixelChannelMap(Image *image,
const ChannelType channel_mask)
{
image->map++;
- if (image->map >= MaxPixelComponentMaps)
- ThrowFatalException(ResourceLimitFatalError,"PixelComponentMapStack");
- SetPixelComponentMap(image,channel_mask);
+ if (image->map >= MaxPixelChannelMaps)
+ ThrowFatalException(ResourceLimitFatalError,"PixelChannelMapStack");
+ SetPixelChannelMap(image,channel_mask);
}
\f
/*
% %
% %
% %
-% S e t P i x e l C o m p o n e n t M a p %
+% S e t P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetPixelComponentMap() sets the pixel component map from the specified
-% channel mask.
+% SetPixelChannelMap() sets the pixel channel map from the specified channel
+% mask.
%
-% The format of the SetPixelComponentMap method is:
+% The format of the SetPixelChannelMap method is:
%
-% void SetPixelComponentMap(Image *image,const ChannelType channel_mask)
+% void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
%
% A description of each parameter follows:
%
% o channel_mask: the channel mask.
%
*/
-MagickExport void SetPixelComponentMap(Image *image,
+MagickExport void SetPixelChannelMap(Image *image,
const ChannelType channel_mask)
{
+#define GetChannelBit(alpha,i) (((size_t) (alpha) >> (size_t) (i)) & 0x01)
+
register ssize_t
i;
- for (i=0; i < MaxPixelComponents; i++)
- SetPixelComponentTraits(image,(PixelComponent) i,UndefinedPixelTrait);
- image->sync=(channel_mask & SyncChannels) != 0 ? MagickTrue : MagickFalse;
- if ((channel_mask & RedChannel) != 0)
- SetPixelRedTraits(image,ActivePixelTrait);
- if ((channel_mask & GreenChannel) != 0)
- SetPixelGreenTraits(image,ActivePixelTrait);
- if ((channel_mask & BlueChannel) != 0)
- SetPixelBlueTraits(image,ActivePixelTrait);
- if ((channel_mask & BlackChannel) != 0)
- SetPixelBlackTraits(image,ActivePixelTrait);
- if ((channel_mask & AlphaChannel) != 0)
- SetPixelAlphaTraits(image,ActivePixelTrait);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ SetPixelChannelMapTraits(image,(PixelChannel) i,
+ GetChannelBit(channel_mask,i) ? UpdatePixelTrait : CopyPixelTrait);
+ for ( ; i < MaxPixelChannels; i++)
+ SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
}
\f
/*
% %
% %
% %
-+ S t a n d a r d P i x e l C o m p o n e n t M a p %
++ S t a n d a r d P i x e l C h a n n e l M a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% StandardPixelComponentMap() defines the standard pixel component map.
+% StandardPixelChannelMap() defines the standard pixel component map.
%
-% The format of the StandardPixelComponentMap() method is:
+% The format of the StandardPixelChannelMap() method is:
%
-% void StandardPixelComponentMap(Image *image)
+% void StandardPixelChannelMap(Image *image)
%
% A description of each parameter follows:
%
% o image: the image.
%
*/
-MagickExport void StandardPixelComponentMap(Image *image)
+MagickExport void StandardPixelChannelMap(Image *image)
{
- image->pixel_components=4;
- SetPixelComponent(image,RedPixelComponent,RedPixelComponent);
- SetPixelComponentTraits(image,RedPixelComponent,ActivePixelTrait);
- SetPixelComponent(image,GreenPixelComponent,GreenPixelComponent);
- SetPixelComponentTraits(image,GreenPixelComponent,ActivePixelTrait);
- SetPixelComponent(image,BluePixelComponent,BluePixelComponent);
- SetPixelComponentTraits(image,BluePixelComponent,ActivePixelTrait);
- SetPixelComponent(image,AlphaPixelComponent,AlphaPixelComponent);
- SetPixelComponentTraits(image,AlphaPixelComponent,ActivePixelTrait);
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
+ image->number_channels=4;
+ SetPixelChannelMapComponent(image,RedPixelChannel,RedPixelChannel);
+ SetPixelChannelMapTraits(image,RedPixelChannel,(PixelTrait)
+ (UpdatePixelTrait | BlendPixelTrait));
+ SetPixelChannelMapComponent(image,GreenPixelChannel,GreenPixelChannel);
+ SetPixelChannelMapTraits(image,GreenPixelChannel,(PixelTrait)
+ (UpdatePixelTrait | BlendPixelTrait));
+ SetPixelChannelMapComponent(image,BluePixelChannel,BluePixelChannel);
+ SetPixelChannelMapTraits(image,BluePixelChannel,(PixelTrait)
+ (UpdatePixelTrait | BlendPixelTrait));
+ SetPixelChannelMapComponent(image,AlphaPixelChannel,AlphaPixelChannel);
+ SetPixelChannelMapTraits(image,AlphaPixelChannel,UpdatePixelTrait);
+ if (0 && image->colorspace == GRAYColorspace)
+ {
+ image->number_channels=2;
+ SetPixelChannelMapComponent(image,GreenPixelChannel,RedPixelChannel);
+ SetPixelChannelMapComponent(image,BluePixelChannel,RedPixelChannel);
+ }
if (image->colorspace == CMYKColorspace)
{
- image->pixel_components++;
- SetPixelComponent(image,BlackPixelComponent,BlackPixelComponent);
- SetPixelComponentTraits(image,BlackPixelComponent,ActivePixelTrait);
+ image->number_channels++;
+ SetPixelChannelMapComponent(image,BlackPixelChannel,BlackPixelChannel);
+ SetPixelChannelMapTraits(image,BlackPixelChannel,(PixelTrait)
+ (UpdatePixelTrait | BlendPixelTrait));
}
if (image->storage_class == PseudoClass)
{
- image->pixel_components++;
- SetPixelComponent(image,IndexPixelComponent,IndexPixelComponent);
- SetPixelComponentTraits(image,IndexPixelComponent,ActivePixelTrait);
+ image->number_channels++;
+ SetPixelChannelMapComponent(image,IndexPixelChannel,IndexPixelChannel);
+ SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
}
+ image->number_channels+=image->number_meta_channels;
}
projects / imagemagick / blobdiff