(x_offset >= (ssize_t) image->columns))
{
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
fill_opacity=(MagickRealType) (*p)/(bitmap->bitmap.num_grays-1);
if (q == (const Quantum *) NULL)
{
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
(void) GetFillColor(draw_info,x_offset,y_offset,&fill_color);
status=MagickFalse;
}
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(annotate_image,fill_color.red,q);
SetPixelGreen(annotate_image,fill_color.green,q);
SetPixelBlue(annotate_image,fill_color.blue,q);
- q+=GetPixelChannels(annotate_image);
+ q+=GetPixelComponents(annotate_image);
}
sync=SyncCacheViewAuthenticPixels(annotate_view,exception);
if (sync == MagickFalse)
if ((y > (ssize_t) bounding_box.height) &&
(IsFuzzyEquivalencePixelInfo(&pixel,&target[2]) == MagickFalse))
bounding_box.height=(size_t) y;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
# pragma omp critical (MagickCore_GetImageBoundingBox)
break;
current_depth[id]++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (current_depth[id] == MAGICKCORE_QUANTUM_DEPTH)
status=MagickFalse;
if ((type == BilevelType) &&
(IsPixelMonochrome(image,p) == MagickFalse))
type=GrayscaleType;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (type == UndefinedType)
break;
type=UndefinedType;
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (type == UndefinedType)
break;
{
if (GetPixelAlpha(image,p) != OpaqueAlpha)
break;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
break;
(image->matte != MagickFalse))
SetPixelAlpha(image,ScaleAnyToQuantum(ScaleQuantumToAny(
GetPixelAlpha(image,q),range),range),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
{
size_t
metacontent_extent,
- pixel_channels;
+ pixel_components;
CacheType
type;
SetPixelBlack(image,GetPixelBlack(image,p),q);
SetPixelAlpha(image,GetPixelAlpha(image,p),q);
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
- r+=GetPixelChannels(image->clip_mask);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(image);
+ r+=GetPixelComponents(image->clip_mask);
}
clip_nexus=DestroyPixelCacheNexus(clip_nexus,1);
image_nexus=DestroyPixelCacheNexus(image_nexus,1);
else
(void) LogMagickEvent(CacheEvent,GetMagickModule(),"disk => disk");
}
- length=(size_t) MagickMax(MagickMax(cache_info->pixel_channels,
- clone_info->pixel_channels)*sizeof(Quantum),MagickMax(
+ length=(size_t) MagickMax(MagickMax(cache_info->pixel_components,
+ clone_info->pixel_components)*sizeof(Quantum),MagickMax(
cache_info->metacontent_extent,clone_info->metacontent_extent));
blob=(unsigned char *) AcquireQuantumMemory(length,sizeof(*blob));
if (blob == (unsigned char *) NULL)
/*
Read a set of pixel channels.
*/
- length=cache_info->pixel_channels*sizeof(Quantum);
+ length=cache_info->pixel_components*sizeof(Quantum);
if (cache_info->type != DiskCache)
(void) memcpy(blob,(unsigned char *) cache_info->pixels+cache_offset,
length);
/*
Write a set of pixel channels.
*/
- length=clone_info->pixel_channels*sizeof(Quantum);
+ length=clone_info->pixel_components*sizeof(Quantum);
if (clone_info->type != DiskCache)
(void) memcpy((unsigned char *) clone_info->pixels+clone_offset,
blob,length);
clone_offset+=length;
}
}
- length=clone_info->pixel_channels*sizeof(Quantum);
+ length=clone_info->pixel_components*sizeof(Quantum);
(void) ResetMagickMemory(blob,0,length*sizeof(*blob));
for ( ; x < (ssize_t) clone_info->columns; x++)
{
clone_offset+=length;
}
}
- length=clone_info->pixel_channels*sizeof(Quantum);
+ length=clone_info->pixel_components*sizeof(Quantum);
(void) ResetMagickMemory(blob,0,length*sizeof(*blob));
for ( ; y < (ssize_t) clone_info->rows; y++)
{
return(MagickTrue);
if ((cache_info->columns == clone_info->columns) &&
(cache_info->rows == clone_info->rows) &&
- (cache_info->pixel_channels == clone_info->pixel_channels) &&
+ (cache_info->pixel_components == clone_info->pixel_components) &&
(cache_info->metacontent_extent == clone_info->metacontent_extent))
return(OptimizedPixelCacheClone(clone_info,cache_info,exception));
return(UnoptimizedPixelCacheClone(clone_info,cache_info,exception));
offset=(MagickOffsetType) nexus_info->region.y*cache_info->columns+
nexus_info->region.x;
status=nexus_info->pixels == (cache_info->pixels+offset*
- cache_info->pixel_channels) ? MagickTrue : MagickFalse;
+ cache_info->pixel_components) ? MagickTrue : MagickFalse;
return(status);
}
(image->colorspace != cache_info->colorspace) ||
(image->columns != cache_info->columns) ||
(image->rows != cache_info->rows) ||
- (image->pixel_channels != cache_info->pixel_channels) ||
+ (image->pixel_components != cache_info->pixel_components) ||
(image->metacontent_extent != cache_info->metacontent_extent) ||
(cache_info->nexus_info == (NexusInfo **) NULL) ||
(cache_info->number_threads < GetOpenMPMaximumThreads()))
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
cache_info=(CacheInfo *) image->cache;
assert(cache_info->signature == MagickSignature);
- *width=2048UL/(cache_info->pixel_channels*sizeof(Quantum));
+ *width=2048UL/(cache_info->pixel_components*sizeof(Quantum));
if (GetPixelCacheType(image) == DiskCache)
- *width=8192UL/(cache_info->pixel_channels*sizeof(Quantum));
+ *width=8192UL/(cache_info->pixel_components*sizeof(Quantum));
*height=(*width);
}
\f
Acquire virtual pixel and associated channels.
*/
virtual_pixel=(Quantum *) AcquireQuantumMemory(
- cache_info->pixel_channels,sizeof(*virtual_pixel));
+ cache_info->pixel_components,sizeof(*virtual_pixel));
if (virtual_pixel == (Quantum *) NULL)
{
virtual_nexus=DestroyPixelCacheNexus(virtual_nexus,1);
"UnableToGetCacheNexus","`%s'",image->filename);
return((const Quantum *) NULL);
}
- (void) ResetMagickMemory(virtual_pixel,0,cache_info->pixel_channels*
+ (void) ResetMagickMemory(virtual_pixel,0,cache_info->pixel_components*
sizeof(*virtual_pixel));
if (cache_info->metacontent_extent != 0)
{
}
if (p == (const Quantum *) NULL)
break;
- (void) memcpy(q,p,(size_t) length*cache_info->pixel_channels*
+ (void) memcpy(q,p,(size_t) length*cache_info->pixel_components*
sizeof(*p));
- q+=cache_info->pixel_channels;
+ q+=cache_info->pixel_components;
if ((s != (void *) NULL) &&
(r != (const void *) NULL))
{
if (p == (const Quantum *) NULL)
break;
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
- (void) memcpy(q,p,(size_t) length*cache_info->pixel_channels*sizeof(*p));
- q+=length*cache_info->pixel_channels;
+ (void) memcpy(q,p,(size_t) length*cache_info->pixel_components*sizeof(*p));
+ q+=length*cache_info->pixel_components;
if ((s != (void *) NULL) && (r != (const void *) NULL))
{
(void) memcpy(s,r,(size_t) length);
cache_info->mode=mode;
cache_info->rows=image->rows;
cache_info->columns=image->columns;
- cache_info->pixel_channels=GetPixelChannels(image);
+ cache_info->pixel_components=GetPixelComponents(image);
cache_info->metacontent_extent=image->metacontent_extent;
if (image->ping != MagickFalse)
{
return(MagickTrue);
}
number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
- packet_size=cache_info->pixel_channels*sizeof(Quantum);
+ packet_size=cache_info->pixel_components*sizeof(Quantum);
if (image->metacontent_extent != 0)
packet_size+=cache_info->metacontent_extent;
length=number_pixels*packet_size;
if ((cache_info->type != UndefinedCache) &&
(cache_info->columns <= source_info.columns) &&
(cache_info->rows <= source_info.rows) &&
- (cache_info->pixel_channels <= source_info.pixel_channels) &&
+ (cache_info->pixel_components <= source_info.pixel_components) &&
(cache_info->metacontent_extent <= source_info.metacontent_extent))
{
/*
*/
if ((cache_info->columns == source_info.columns) &&
(cache_info->rows == source_info.rows) &&
- (cache_info->pixel_channels == source_info.pixel_channels) &&
+ (cache_info->pixel_components == source_info.pixel_components) &&
(cache_info->metacontent_extent == source_info.metacontent_extent))
return(MagickTrue);
return(ClonePixelCachePixels(cache_info,&source_info,exception));
}
status=AcquireMagickResource(AreaResource,cache_info->length);
- length=number_pixels*(cache_info->pixel_channels*sizeof(Quantum)+
+ length=number_pixels*(cache_info->pixel_components*sizeof(Quantum)+
cache_info->metacontent_extent);
if ((status != MagickFalse) && (length == (MagickSizeType) ((size_t) length)))
{
"open %s (%s memory, %.20gx%.20gx%.20g %s)",
cache_info->filename,cache_info->mapped != MagickFalse ?
"anonymous" : "heap",(double) cache_info->columns,(double)
- cache_info->rows,(double) cache_info->pixel_channels,
+ cache_info->rows,(double) cache_info->pixel_components,
format);
(void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
message);
cache_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
cache_info->metacontent=(void *) (cache_info->pixels+
- number_pixels*cache_info->pixel_channels);
+ number_pixels*cache_info->pixel_components);
if (source_info.storage_class != UndefinedClass)
{
status=ClonePixelCachePixels(cache_info,&source_info,
image->filename);
return(MagickFalse);
}
- length=number_pixels*(cache_info->pixel_channels*sizeof(Quantum)+
+ length=number_pixels*(cache_info->pixel_components*sizeof(Quantum)+
cache_info->metacontent_extent);
status=AcquireMagickResource(AreaResource,cache_info->length);
if ((status == MagickFalse) || (length != (MagickSizeType) ((size_t) length)))
cache_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
cache_info->metacontent=(void *) (cache_info->pixels+
- number_pixels*cache_info->pixel_channels);
+ number_pixels*cache_info->pixel_components);
if (source_info.storage_class != UndefinedClass)
{
status=ClonePixelCachePixels(cache_info,&source_info,
"open %s (%s[%d], memory-mapped, %.20gx%.20gx%.20g %s)",
cache_info->filename,cache_info->cache_filename,
cache_info->file,(double) cache_info->columns,(double)
- cache_info->rows,(double) cache_info->pixel_channels,
+ cache_info->rows,(double) cache_info->pixel_components,
format);
(void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
message);
"open %s (%s[%d], disk, %.20gx%.20gx%.20g %s)",cache_info->filename,
cache_info->cache_filename,cache_info->file,(double)
cache_info->columns,(double) cache_info->rows,(double)
- cache_info->pixel_channels,format);
+ cache_info->pixel_components,format);
(void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);
}
return(status);
for (y=0; y < (ssize_t) rows; y++)
{
count=ReadPixelCacheRegion(cache_info,cache_info->offset+extent*
- cache_info->pixel_channels*sizeof(Quantum)+offset*
+ cache_info->pixel_components*sizeof(Quantum)+offset*
cache_info->metacontent_extent,length,(unsigned char *) q);
if ((MagickSizeType) count != length)
break;
return(MagickTrue);
offset=(MagickOffsetType) nexus_info->region.y*cache_info->columns+
nexus_info->region.x;
- length=(MagickSizeType) nexus_info->region.width*cache_info->pixel_channels*
+ length=(MagickSizeType) nexus_info->region.width*cache_info->pixel_components*
sizeof(Quantum);
rows=nexus_info->region.height;
extent=length*rows;
length=extent;
rows=1UL;
}
- p=cache_info->pixels+offset*cache_info->pixel_channels;
+ p=cache_info->pixels+offset*cache_info->pixel_components;
for (y=0; y < (ssize_t) rows; y++)
{
(void) memcpy(q,p,(size_t) length);
- p+=cache_info->pixel_channels*cache_info->columns;
- q+=cache_info->pixel_channels*nexus_info->region.width;
+ p+=cache_info->pixel_components*cache_info->columns;
+ q+=cache_info->pixel_components*nexus_info->region.width;
}
break;
}
for (y=0; y < (ssize_t) rows; y++)
{
count=ReadPixelCacheRegion(cache_info,cache_info->offset+offset*
- cache_info->pixel_channels*sizeof(*q),length,(unsigned char *) q);
+ cache_info->pixel_components*sizeof(*q),length,(unsigned char *) q);
if ((MagickSizeType) count != length)
break;
offset+=cache_info->columns;
- q+=cache_info->pixel_channels*nexus_info->region.width;
+ q+=cache_info->pixel_components*nexus_info->region.width;
}
if (y < (ssize_t) rows)
{
*/
offset=(MagickOffsetType) nexus_info->region.y*cache_info->columns+
nexus_info->region.x;
- nexus_info->pixels=cache_info->pixels+cache_info->pixel_channels*
+ nexus_info->pixels=cache_info->pixels+cache_info->pixel_components*
offset;
nexus_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
*/
number_pixels=(MagickSizeType) nexus_info->region.width*
nexus_info->region.height;
- length=number_pixels*cache_info->pixel_channels*sizeof(Quantum);
+ length=number_pixels*cache_info->pixel_components*sizeof(Quantum);
if (cache_info->metacontent_extent != 0)
length+=number_pixels*cache_info->metacontent_extent;
if (nexus_info->cache == (Quantum *) NULL)
nexus_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
nexus_info->metacontent=(void *) (nexus_info->pixels+number_pixels*
- cache_info->pixel_channels);
+ cache_info->pixel_components);
return(nexus_info->pixels);
}
\f
for (y=0; y < (ssize_t) rows; y++)
{
count=WritePixelCacheRegion(cache_info,cache_info->offset+extent*
- cache_info->pixel_channels*sizeof(Quantum)+offset*
+ cache_info->pixel_components*sizeof(Quantum)+offset*
cache_info->metacontent_extent,length,(const unsigned char *) p);
if ((MagickSizeType) count != length)
break;
return(MagickTrue);
offset=(MagickOffsetType) nexus_info->region.y*cache_info->columns+
nexus_info->region.x;
- length=(MagickSizeType) nexus_info->region.width*cache_info->pixel_channels*
+ length=(MagickSizeType) nexus_info->region.width*cache_info->pixel_components*
sizeof(Quantum);
rows=nexus_info->region.height;
extent=length*rows;
length=extent;
rows=1UL;
}
- q=cache_info->pixels+offset*cache_info->pixel_channels;
+ q=cache_info->pixels+offset*cache_info->pixel_components;
for (y=0; y < (ssize_t) rows; y++)
{
(void) memcpy(q,p,(size_t) length);
- p+=nexus_info->region.width*cache_info->pixel_channels;
- q+=cache_info->columns*cache_info->pixel_channels;
+ p+=nexus_info->region.width*cache_info->pixel_components;
+ q+=cache_info->columns*cache_info->pixel_components;
}
break;
}
for (y=0; y < (ssize_t) rows; y++)
{
count=WritePixelCacheRegion(cache_info,cache_info->offset+offset*
- cache_info->pixel_channels*sizeof(*p),length,(const unsigned char *)
+ cache_info->pixel_components*sizeof(*p),length,(const unsigned char *)
p);
if ((MagickSizeType) count != length)
break;
- p+=nexus_info->region.width*cache_info->pixel_channels;
+ p+=nexus_info->region.width*cache_info->pixel_components;
offset+=cache_info->columns;
}
if (y < (ssize_t) rows)
index+=(ssize_t) image->colors;
SetPixelIndex(image,(Quantum) index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
index=(Quantum) pixels[(ssize_t) GetPixelIndex(image,q)];
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
GetPixelGreen(image,q))),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) (QuantumRange-
GetPixelBlue(image,q))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelInfo(image,q,&pixel);
ConvertRGBToCMYK(&pixel);
SetPixelPixelInfo(image,&pixel,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
saturation),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
brightness),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
saturation),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
lightness),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
whiteness),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
blackness),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
a),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
b),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
GetPixelGreen(image,q))],q);
SetPixelBlue(image,logmap[ScaleQuantumToMap(
GetPixelBlue(image,q))],q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(image,ScaleMapToQuantum(pixel.red),q);
SetPixelGreen(image,ScaleMapToQuantum(pixel.green),q);
SetPixelBlue(image,ScaleMapToQuantum(pixel.blue),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
GetPixelGreen(image,q))),q);
SetPixelBlue(image,ClampToQuantum((MagickRealType) (QuantumRange-
GetPixelBlue(image,q))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelInfo(image,q,&pixel);
ConvertCMYKToRGB(&pixel);
SetPixelPixelInfo(image,&pixel,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
GetPixelGreen(image,q))],q);
SetPixelBlue(image,logmap[ScaleQuantumToMap(
GetPixelBlue(image,q))],q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
QuantumScale*pixel.green),q);
SetPixelBlue(image,ScaleMapToQuantum((MagickRealType) MaxMap*
QuantumScale*pixel.blue),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelPixelInfo(highlight_image,&highlight,r);
else
SetPixelPixelInfo(highlight_image,&lowlight,r);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
- r+=GetPixelChannels(highlight_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
+ r+=GetPixelComponents(highlight_image);
}
sync=SyncCacheViewAuthenticPixels(highlight_view,exception);
if (sync == MagickFalse)
channel_distortion[BlackChannel]++;
channel_distortion[CompositeChannels]++;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_GetAbsoluteError)
channel_distortion[BlackChannel]+=distance*distance;
channel_distortion[CompositeChannels]+=distance*distance;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_GetMeanSquaredError)
channel_distortion[OpacityChannel]+=distance;
channel_distortion[CompositeChannels]+=distance;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_GetMeanAbsoluteError)
maximum_error=distance;
area++;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
}
reconstruct_view=DestroyCacheView(reconstruct_view);
channel_distortion[OpacityChannel]+=distance*distance;
channel_distortion[CompositeChannels]+=distance*distance;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_GetMeanSquaredError)
image_statistics[OpacityChannel].mean)*
(GetPixelAlpha(reconstruct_image,q)-
reconstruct_statistics[OpacityChannel].mean);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(image);
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
if (distance > channel_distortion[CompositeChannels])
channel_distortion[CompositeChannels]=distance;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(image);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_GetPeakAbsoluteError)
maximum_error=distance;
area++;
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
}
reconstruct_view=DestroyCacheView(reconstruct_view);
image_statistics[OpacityChannel].mean)*(
GetPixelAlpha(reconstruct_image,q)-
reconstruct_statistics[OpacityChannel].mean);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(reconstruct_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(reconstruct_image);
}
}
reconstruct_view=DestroyCacheView(reconstruct_view);
QuantumRange*similarity),q);
SetPixelGreen(similarity_image,GetPixelRed(image,q),q);
SetPixelBlue(similarity_image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(similarity_image);
+ q+=GetPixelComponents(similarity_image);
}
if (SyncCacheViewAuthenticPixels(similarity_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(image,GetPixelAlpha(composite_image,p),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,GetPixelBlack(composite_image,p),q);
- p+=GetPixelChannels(composite_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(composite_image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
{
if (((x_offset+x) < 0) || ((x_offset+x) >= (ssize_t) image->columns))
{
- p+=GetPixelChannels(composite_image);
+ p+=GetPixelComponents(composite_image);
continue;
}
if (fabs(angle_range) > MagickEpsilon)
(void) ResamplePixelColor(resample_filter,(double) x_offset+x,
(double) y_offset+y,&pixel);
SetPixelPixelInfo(destination_image,&pixel,q);
- p+=GetPixelChannels(composite_image);
- q+=GetPixelChannels(destination_image);
+ p+=GetPixelComponents(composite_image);
+ q+=GetPixelComponents(destination_image);
}
sync=SyncCacheViewAuthenticPixels(destination_view,exception);
if (sync == MagickFalse)
{
if (((x_offset+x) < 0) || ((x_offset+x) >= (ssize_t) image->columns))
{
- p+=GetPixelChannels(composite_image);
+ p+=GetPixelComponents(composite_image);
continue;
}
/*
pixel.alpha)*(1.0-QuantumScale*
GetPixelAlpha(composite_image,p)));
SetPixelPixelInfo(destination_image,&pixel,q);
- p+=GetPixelChannels(composite_image);
- q+=GetPixelChannels(destination_image);
+ p+=GetPixelComponents(composite_image);
+ q+=GetPixelComponents(destination_image);
}
sync=SyncCacheViewAuthenticPixels(destination_view,exception);
if (sync == MagickFalse)
}
pixels=p;
if (x_offset < 0)
- p-=x_offset*GetPixelChannels(composite_image);
+ p-=x_offset*GetPixelComponents(composite_image);
}
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (const Quantum *) NULL)
{
if (x < x_offset)
{
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
if ((x-x_offset) >= (ssize_t) composite_image->columns)
SetPixelAlpha(image,ClampToQuantum(composite.alpha),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,ClampToQuantum(composite.black),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
/*
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,ClampToQuantum(composite.black),q);
SetPixelAlpha(image,ClampToQuantum(composite.alpha),q);
- p+=GetPixelChannels(composite_image);
- if (p >= (pixels+composite_image->columns*GetPixelChannels(composite_image)))
+ p+=GetPixelComponents(composite_image);
+ if (p >= (pixels+composite_image->columns*GetPixelComponents(composite_image)))
p=pixels;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if ((image->colorspace == CMYKColorspace) &&
(texture->colorspace == CMYKColorspace))
SetPixelBlack(image,GetPixelBlack(texture,p),q);
- p+=GetPixelChannels(texture);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(texture);
+ q+=GetPixelComponents(image);
}
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
index=(Quantum) (*p++);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
{
*q++=(unsigned char) (GetPixelIntensity(huffman_image,p) >=
((MagickRealType) QuantumRange/2.0) ? 0 : 1);
- p+=GetPixelChannels(huffman_image);
+ p+=GetPixelComponents(huffman_image);
}
/*
Huffman encode scanline.
SetPixelPixelInfo(frame_image,&highlight,q);
else
SetPixelPixelInfo(frame_image,&accentuate,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=image->columns+((size_t) frame_info->inner_bevel << 1)-
y;
SetPixelPixelInfo(frame_image,&shadow,q);
else
SetPixelPixelInfo(frame_image,&trough,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
/*
Set frame interior to interior color.
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPixelInfo(frame_image,&interior,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
else
{
if (image->colorspace == CMYKColorspace)
SetPixelBlack(frame_image,GetPixelBlack(image,p),q);
SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(frame_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(frame_image);
}
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < y; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
else
SetPixelPixelInfo(frame_image,&accentuate,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
height=frame_info->height-frame_info->y-image->rows-bevel_width;
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
for (y=frame_info->outer_bevel-1; y >= 0; y--)
for (x=0; x < y; x++)
{
SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
SetPixelPixelInfo(frame_image,&shadow,q);
else
SetPixelPixelInfo(frame_image,&trough,q);
- q+=GetPixelChannels(frame_image);
+ q+=GetPixelComponents(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
(QuantumRange-HighlightFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) (image->columns-y); x++)
{
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*AccentuateFactor+(MagickRealType) foreground*
(QuantumRange-AccentuateFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
(QuantumRange-ShadowFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
(QuantumRange-HighlightFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) (image->columns-raise_info->width); x++)
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
for ( ; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
(QuantumRange-ShadowFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
(QuantumRange-HighlightFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) (image->columns-(image->rows-y)); x++)
{
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*TroughFactor+(MagickRealType) background*
(QuantumRange-TroughFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
(QuantumRange-ShadowFactor))),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlue(*image,ScaleShortToQuantum(
color.blue),q);
}
- q+=GetPixelChannels(*image);
+ q+=GetPixelComponents(*image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
SetPixelRed(*image,ScaleShortToQuantum(color.red),q);
SetPixelGreen(*image,ScaleShortToQuantum(color.green),q);
SetPixelBlue(*image,ScaleShortToQuantum(color.blue),q);
- q+=GetPixelChannels(*image);
+ q+=GetPixelComponents(*image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
for (x=0; x < (int) image->columns; x++)
{
SetPixelAlpha(image,opacity,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
for (x=0; x < (int) crop_info.width; x++)
{
SetPixelAlpha(image,TransparentAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
GetPixelPacket(*image,q,&pixel);
if (IsFuzzyEquivalencePixelPacket(*image,&pixel,&target))
SetPixelAlpha(*image,(Quantum) StringToLong(matte),q);
- q+=GetPixelChannels(*image);
+ q+=GetPixelComponents(*image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
for (x=0; x < (int) (*image)->columns; x++)
{
SetPixelAlpha(*image,(Quantum) StringToLong(matte),q);
- q+=GetPixelChannels(*image);
+ q+=GetPixelComponents(*image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
for (j=0; j < (int) width; j++)
{
SetPixelPacket(image,&pixel,s);
- s+=GetPixelChannels(image);
+ s+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
}
SetPixelPixelInfo(distort_image,&pixel,q);
}
- q+=GetPixelChannels(distort_image);
+ q+=GetPixelComponents(distort_image);
}
sync=SyncCacheViewAuthenticPixels(distort_view,exception);
if (sync == MagickFalse)
if ( channel & BlackChannel ) pixel.black *= QuantumRange;
if ( channel & AlphaChannel ) pixel.alpha *= QuantumRange;
SetPixelPixelInfo(sparse_image,&pixel,q);
- q+=GetPixelChannels(sparse_image);
+ q+=GetPixelComponents(sparse_image);
}
sync=SyncCacheViewAuthenticPixels(sparse_view,exception);
if (sync == MagickFalse)
&composite);
SetPixelPixelInfo(image,&composite,q);
x_offset++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
CompositePixelInfoOver(&composite,composite.alpha,&pixel,pixel.alpha,
&pixel);
SetPixelPixelInfo(image,&pixel,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
(void) GetStrokeColor(draw_info,x,y,&pixel);
SetPixelPacket(image,&pixel,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
stroke_opacity=stroke_opacity*stroke_color.alpha;
CompositePixelOver(image,&stroke_color,stroke_opacity,q,(MagickRealType)
GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
GetPixelPacket(image,q,&pixel);
if (IsFuzzyEquivalencePixelPacket(image,&pixel,&target) == MagickFalse)
{
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
(void) GetFillColor(draw_info,x,y,&pixel);
SetPixelPacket(image,&pixel,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
{
(void) GetFillColor(draw_info,x,y,&pixel);
SetPixelPacket(image,&pixel,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
GetPixelPacket(image,q,&pixel);
if (IsFuzzyEquivalencePixelPacket(image,&pixel,&target) == MagickFalse)
{
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
(void) GetFillColor(draw_info,x,y,&pixel);
SetPixelAlpha(image,pixel.alpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
{
(void) GetFillColor(draw_info,x,y,&pixel);
SetPixelAlpha(image,pixel.alpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
pixel.alpha+=(*k)*GetPixelAlpha(image,p);
gamma+=(*k)*alpha;
k++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
SetPixelBlack(blur_image,ClampToQuantum(gamma*pixel.black),q);
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
- q+=GetPixelChannels(blur_image);
- r+=GetPixelChannels(edge_image);
+ q+=GetPixelComponents(blur_image);
+ r+=GetPixelComponents(edge_image);
}
if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
status=MagickFalse;
pixel.alpha+=(*k)*GetPixelAlpha(image,p);
gamma+=(*k)*alpha;
k++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
SetPixelBlack(sharp_image,ClampToQuantum(gamma*pixel.black),q);
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(sharp_image,ClampToQuantum(pixel.alpha),q);
- q+=GetPixelChannels(sharp_image);
- r+=GetPixelChannels(edge_image);
+ q+=GetPixelComponents(sharp_image);
+ r+=GetPixelComponents(edge_image);
}
if (SyncCacheViewAuthenticPixels(sharp_view,exception) == MagickFalse)
status=MagickFalse;
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(image);
+ kernel_pixels+=GetPixelComponents(image);
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelRed(blur_image,ClampToQuantum(pixel.red),q);
{
pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(image);
+ kernel_pixels+=GetPixelComponents(image);
}
SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
}
pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels);
gamma+=(*k)*alpha;
k++;
- kernel_pixels+=GetPixelChannels(image);
+ kernel_pixels+=GetPixelComponents(image);
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
{
pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(image);
+ kernel_pixels+=GetPixelComponents(image);
}
SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
}
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(blur_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(blur_image);
}
if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
status=MagickFalse;
if (blur_image->colorspace == CMYKColorspace)
pixel.black+=(*k)*GetPixelBlack(blur_image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(blur_image);
+ kernel_pixels+=GetPixelComponents(blur_image);
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelRed(blur_image,ClampToQuantum(pixel.red),q);
{
pixel.alpha+=(*k)*GetPixelAlpha(blur_image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(blur_image);
+ kernel_pixels+=GetPixelComponents(blur_image);
}
SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
}
pixel.black+=(*k)*alpha*GetPixelBlack(blur_image,kernel_pixels);
gamma+=(*k)*alpha;
k++;
- kernel_pixels+=GetPixelChannels(blur_image);
+ kernel_pixels+=GetPixelComponents(blur_image);
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
{
pixel.alpha+=(*k)*GetPixelAlpha(blur_image,kernel_pixels);
k++;
- kernel_pixels+=GetPixelChannels(blur_image);
+ kernel_pixels+=GetPixelComponents(blur_image);
}
SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
}
}
- p+=GetPixelChannels(blur_image);
- q+=GetPixelChannels(blur_image);
+ p+=GetPixelComponents(blur_image);
+ q+=GetPixelComponents(blur_image);
}
if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
status=MagickFalse;
for (u=0; u < (ssize_t) width; u++)
{
pixel.red+=(*k)*GetPixelRed(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=(*k)*GetPixelGreen(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=(*k)*GetPixelBlue(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
k++;
}
- kernel_pixels+=(image->columns+width)*GetPixelChannels(image);
+ kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelRed(convolve_image,ClampToQuantum(pixel.red),q);
for (u=0; u < (ssize_t) width; u++)
{
pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
k++;
}
kernel_pixels+=(image->columns+width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
SetPixelAlpha(convolve_image,ClampToQuantum(pixel.alpha),q);
}
for (u=0; u < (ssize_t) width; u++)
{
alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
- kernel_pixels+u*GetPixelChannels(image)));
+ kernel_pixels+u*GetPixelComponents(image)));
pixel.red+=(*k)*alpha*GetPixelRed(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=(*k)*alpha*GetPixelGreen(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=(*k)*alpha*GetPixelBlue(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
gamma+=(*k)*alpha;
k++;
}
- kernel_pixels+=(image->columns+width)*GetPixelChannels(image);
+ kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
k++;
}
kernel_pixels+=(image->columns+width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
SetPixelAlpha(convolve_image,ClampToQuantum(pixel.alpha),q);
}
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(convolve_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(convolve_image);
}
sync=SyncCacheViewAuthenticPixels(convolve_view,exception);
if (sync == MagickFalse)
case 4: pixel[j]=GetPixelBlack(image,p); break;
default: break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
j++;
}
j++;
case 4: SetPixelBlack(despeckle_image,pixel[j],q); break;
default: break;
}
- q+=GetPixelChannels(despeckle_image);
+ q+=GetPixelComponents(despeckle_image);
j++;
}
sync=SyncCacheViewAuthenticPixels(despeckle_view,exception);
for (u=0; u < (ssize_t) kernel->height; u++)
{
pixel.red+=(*k)*GetPixelRed(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=(*k)*GetPixelGreen(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=(*k)*GetPixelBlue(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
k++;
}
kernel_pixels+=(image->columns+kernel->width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelRed(filter_image,ClampToQuantum(pixel.red),q);
for (u=0; u < (ssize_t) kernel->height; u++)
{
pixel.alpha+=(*k)*GetPixelRed(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
k++;
}
kernel_pixels+=(image->columns+kernel->width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
SetPixelAlpha(filter_image,ClampToQuantum(pixel.alpha),q);
}
for (u=0; u < (ssize_t) kernel->height; u++)
{
alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
- kernel_pixels+u*GetPixelChannels(image)));
+ kernel_pixels+u*GetPixelComponents(image)));
pixel.red+=(*k)*alpha*GetPixelRed(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=(*k)*alpha*GetPixelGreen(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=(*k)*alpha*GetPixelBlue(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
gamma+=(*k)*alpha;
k++;
}
kernel_pixels+=(image->columns+kernel->width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
for (u=0; u < (ssize_t) kernel->height; u++)
{
pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels+u*
- GetPixelChannels(image));
+ GetPixelComponents(image));
k++;
}
kernel_pixels+=(image->columns+kernel->width)*
- GetPixelChannels(image);
+ GetPixelComponents(image);
}
SetPixelAlpha(filter_image,ClampToQuantum(pixel.alpha),q);
}
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(filter_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(filter_image);
}
sync=SyncCacheViewAuthenticPixels(filter_view,exception);
if (sync == MagickFalse)
SetPixelAlpha(blur_image,
ClampToQuantum(qixel.alpha),q);
}
- q+=GetPixelChannels(blur_image);
+ q+=GetPixelComponents(blur_image);
}
if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(blur_image,
ClampToQuantum(normalize*qixel.alpha),q);
}
- q+=GetPixelChannels(blur_image);
+ q+=GetPixelComponents(blur_image);
}
if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
status=MagickFalse;
{
for (u=0; u < (ssize_t) width; u++)
{
- contrast=GetPixelIntensity(image,p+(u+j)*GetPixelChannels(image))-
+ contrast=GetPixelIntensity(image,p+(u+j)*GetPixelComponents(image))-
(double) GetPixelIntensity(blur_image,q);
if (fabs(contrast) < threshold)
{
pixel.red+=(*k)*
- GetPixelRed(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelRed(image,p+(u+j)*GetPixelComponents(image));
pixel.green+=(*k)*
- GetPixelGreen(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelGreen(image,p+(u+j)*GetPixelComponents(image));
pixel.blue+=(*k)*
- GetPixelBlue(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelBlue(image,p+(u+j)*GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*
- GetPixelBlack(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelBlack(image,p+(u+j)*GetPixelComponents(image));
gamma+=(*k);
k++;
}
for (u=0; u < (ssize_t) width; u++)
{
contrast=GetPixelIntensity(image,p+(u+j)*
- GetPixelChannels(image))-(double)
+ GetPixelComponents(image))-(double)
GetPixelIntensity(blur_image,q);
if (fabs(contrast) < threshold)
{
pixel.alpha+=(*k)*
- GetPixelAlpha(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelAlpha(image,p+(u+j)*GetPixelComponents(image));
gamma+=(*k);
k++;
}
for (u=0; u < (ssize_t) width; u++)
{
contrast=GetPixelIntensity(image,p+(u+j)*
- GetPixelChannels(image))-(double)
+ GetPixelComponents(image))-(double)
GetPixelIntensity(blur_image,q);
if (fabs(contrast) < threshold)
{
alpha=(MagickRealType) (QuantumScale*
- GetPixelAlpha(image,p+(u+j)*GetPixelChannels(image)));
+ GetPixelAlpha(image,p+(u+j)*GetPixelComponents(image)));
pixel.red+=(*k)*alpha*
- GetPixelRed(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelRed(image,p+(u+j)*GetPixelComponents(image));
pixel.green+=(*k)*alpha*GetPixelGreen(image,p+(u+j)*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=(*k)*alpha*GetPixelBlue(image,p+(u+j)*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.alpha+=(*k)*GetPixelAlpha(image,p+(u+j)*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
pixel.black+=(*k)*GetPixelBlack(image,p+(u+j)*
- GetPixelChannels(image));
+ GetPixelComponents(image));
gamma+=(*k)*alpha;
k++;
}
for (u=0; u < (ssize_t) width; u++)
{
contrast=GetPixelIntensity(image,p+(u+j)*
- GetPixelChannels(image))-(double)
+ GetPixelComponents(image))-(double)
GetPixelIntensity(blur_image,q);
if (fabs(contrast) < threshold)
{
pixel.alpha+=(*k)*
- GetPixelAlpha(image,p+(u+j)*GetPixelChannels(image));
+ GetPixelAlpha(image,p+(u+j)*GetPixelComponents(image));
gamma+=(*k);
k++;
}
}
}
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(blur_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(blur_image);
}
sync=SyncCacheViewAuthenticPixels(blur_view,exception);
if (sync == MagickFalse)
Shade this row of pixels.
*/
normal.z=2.0*(double) QuantumRange; /* constant Z of surface normal */
- s0=p+GetPixelChannels(image);
- s1=s0+(image->columns+2)*GetPixelChannels(image);
- s2=s1+(image->columns+2)*GetPixelChannels(image);
+ s0=p+GetPixelComponents(image);
+ s1=s0+(image->columns+2)*GetPixelComponents(image);
+ s2=s1+(image->columns+2)*GetPixelComponents(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
/*
Determine the surface normal and compute shading.
*/
- normal.x=(double) (GetPixelIntensity(image,s0-GetPixelChannels(image))+
- GetPixelIntensity(image,s1-GetPixelChannels(image))+
- GetPixelIntensity(image,s2-GetPixelChannels(image))-
- GetPixelIntensity(image,s0+GetPixelChannels(image))-
- GetPixelIntensity(image,s1+GetPixelChannels(image))-
- GetPixelIntensity(image,s2+GetPixelChannels(image)));
- normal.y=(double) (GetPixelIntensity(image,s2-GetPixelChannels(image))+
+ normal.x=(double) (GetPixelIntensity(image,s0-GetPixelComponents(image))+
+ GetPixelIntensity(image,s1-GetPixelComponents(image))+
+ GetPixelIntensity(image,s2-GetPixelComponents(image))-
+ GetPixelIntensity(image,s0+GetPixelComponents(image))-
+ GetPixelIntensity(image,s1+GetPixelComponents(image))-
+ GetPixelIntensity(image,s2+GetPixelComponents(image)));
+ normal.y=(double) (GetPixelIntensity(image,s2-GetPixelComponents(image))+
GetPixelIntensity(image,s2)+
- GetPixelIntensity(image,s2+GetPixelChannels(image))-
- GetPixelIntensity(image,s0-GetPixelChannels(image))-
+ GetPixelIntensity(image,s2+GetPixelComponents(image))-
+ GetPixelIntensity(image,s0-GetPixelComponents(image))-
GetPixelIntensity(image,s0)-
- GetPixelIntensity(image,s0+GetPixelChannels(image)));
+ GetPixelIntensity(image,s0+GetPixelComponents(image)));
if ((normal.x == 0.0) && (normal.y == 0.0))
shade=light.z;
else
GetPixelBlue(image,s1)),q);
}
SetPixelAlpha(shade_image,GetPixelAlpha(image,s1),q);
- s0+=GetPixelChannels(image);
- s1+=GetPixelChannels(image);
- s2+=GetPixelChannels(image);
- q+=GetPixelChannels(shade_image);
+ s0+=GetPixelComponents(image);
+ s1+=GetPixelComponents(image);
+ s2+=GetPixelComponents(image);
+ q+=GetPixelComponents(shade_image);
}
if (SyncCacheViewAuthenticPixels(shade_view,exception) == MagickFalse)
status=MagickFalse;
random_info[id])-0.5),(double) y+width*(GetPseudoRandomValue(
random_info[id])-0.5),&pixel,exception);
SetPixelPixelInfo(spread_image,&pixel,q);
- q+=GetPixelChannels(spread_image);
+ q+=GetPixelComponents(spread_image);
}
if (SyncCacheViewAuthenticPixels(spread_view,exception) == MagickFalse)
status=MagickFalse;
for (v=0; v < (ssize_t) StatisticHeight; v++)
{
for (u=0; u < (ssize_t) StatisticWidth; u++)
- InsertPixelList(image,r+u*GetPixelChannels(image),pixel_list[id]);
- r+=(image->columns+StatisticWidth)*GetPixelChannels(image);
+ InsertPixelList(image,r+u*GetPixelComponents(image),pixel_list[id]);
+ r+=(image->columns+StatisticWidth)*GetPixelComponents(image);
}
GetPixelInfo(image,&pixel);
SetPixelInfo(image,p+(StatisticWidth*StatisticHeight/2)*
- GetPixelChannels(image),&pixel);
+ GetPixelComponents(image),&pixel);
switch (type)
{
case GradientStatistic:
if (((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0) &&
(image->matte != MagickFalse))
SetPixelAlpha(statistic_image,ClampToQuantum(pixel.alpha),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(statistic_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(statistic_image);
}
if (SyncCacheViewAuthenticPixels(statistic_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(unsharp_image,
ClampToQuantum(pixel.alpha),q);
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(unsharp_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(unsharp_image);
}
if (SyncCacheViewAuthenticPixels(unsharp_view,exception) == MagickFalse)
status=MagickFalse;
(cdl_map[ScaleQuantumToMap(GetPixelGreen(image,q))].green-luma)),q);
SetPixelBlue(image,ClampToQuantum(luma+color_correction.saturation*
(cdl_map[ScaleQuantumToMap(GetPixelBlue(image,q))].blue-luma)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(image,ClampAlphaPixelComponent(clut_map+
ScaleQuantumToMap(GetPixelAlpha(image,q))),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
histogram[ScaleQuantumToMap(intensity)].green++;
histogram[ScaleQuantumToMap(intensity)].blue++;
histogram[ScaleQuantumToMap(intensity)].black++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
histogram[ScaleQuantumToMap(GetPixelBlack(image,p))].black++;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
histogram[ScaleQuantumToMap(GetPixelAlpha(image,p))].alpha++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
/*
SetPixelAlpha(image,ClampToQuantum(stretch_map[ScaleQuantumToMap(
GetPixelAlpha(image,q))].alpha),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
(total_weight/2)-1)/total_weight),q);
SetPixelAlpha(enhance_image,(Quantum) ((aggregate.alpha+
(total_weight/2)-1)/total_weight),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(enhance_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(enhance_image);
}
if (SyncCacheViewAuthenticPixels(enhance_view,exception) == MagickFalse)
status=MagickFalse;
histogram[ScaleQuantumToMap(GetPixelBlack(image,p))].black++;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
histogram[ScaleQuantumToMap(GetPixelAlpha(image,p))].alpha++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
/*
(white.alpha != black.alpha))
SetPixelAlpha(image,ClampToQuantum(equalize_map[
ScaleQuantumToMap(GetPixelAlpha(image,q))].alpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
ScaleQuantumToMap(GetPixelAlpha(image,q))],q);
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (((GetPixelBlackTraits(image) & ActivePixelTrait) != 0) &&
(image->colorspace == CMYKColorspace))
if (((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0) && (image->matte != MagickFalse))
SetPixelAlpha(image,
ClampToQuantum(pixel.alpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
(image->colorspace == CMYKColorspace))
SetPixelBlack(image,
LevelQuantum(GetPixelBlack(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if (((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0) &&
(image->matte == MagickTrue))
SetPixelAlpha(image,LevelizeValue(GetPixelAlpha(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
for (x=(ssize_t) image->columns-1; x >= 0; x--)
{
histogram[ScaleQuantumToMap(GetPixelIntensity(image,p))]++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
/*
SetPixelRed(image,red,q);
SetPixelGreen(image,green,q);
SetPixelBlue(image,blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if ((GetPixelRed(image,q) != GetPixelGreen(image,q)) ||
(GetPixelGreen(image,q) != GetPixelBlue(image,q)))
{
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelBlack(image,QuantumRange-GetPixelBlack(image,q),q);
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,QuantumRange-GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
SetPixelBlack(image,QuantumRange-GetPixelBlack(image,q),q);
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,QuantumRange-GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,ClampToQuantum(sigmoidal_map[ScaleQuantumToMap(
GetPixelAlpha(image,q))]),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if (image->matte != MagickFalse)
grays[ScaleQuantumToMap(GetPixelAlpha(image,p))].alpha=
ScaleQuantumToMap(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
status=MagickFalse;
continue;
}
- p+=distance*GetPixelChannels(image);;
+ p+=distance*GetPixelComponents(image);;
for (x=0; x < (ssize_t) image->columns; x++)
{
for (i=0; i < 4; i++)
v=0;
while (grays[u].red != ScaleQuantumToMap(GetPixelRed(image,p)))
u++;
- while (grays[v].red != ScaleQuantumToMap(GetPixelRed(image,p+offset*GetPixelChannels(image))))
+ while (grays[v].red != ScaleQuantumToMap(GetPixelRed(image,p+offset*GetPixelComponents(image))))
v++;
cooccurrence[u][v].direction[i].red++;
cooccurrence[v][u].direction[i].red++;
v=0;
while (grays[u].green != ScaleQuantumToMap(GetPixelGreen(image,p)))
u++;
- while (grays[v].green != ScaleQuantumToMap(GetPixelGreen(image,p+offset*GetPixelChannels(image))))
+ while (grays[v].green != ScaleQuantumToMap(GetPixelGreen(image,p+offset*GetPixelComponents(image))))
v++;
cooccurrence[u][v].direction[i].green++;
cooccurrence[v][u].direction[i].green++;
v=0;
while (grays[u].blue != ScaleQuantumToMap(GetPixelBlue(image,p)))
u++;
- while (grays[v].blue != ScaleQuantumToMap(GetPixelBlue(image,p+offset*GetPixelChannels(image))))
+ while (grays[v].blue != ScaleQuantumToMap(GetPixelBlue(image,p+offset*GetPixelComponents(image))))
v++;
cooccurrence[u][v].direction[i].blue++;
cooccurrence[v][u].direction[i].blue++;
v=0;
while (grays[u].black != ScaleQuantumToMap(GetPixelBlack(image,p)))
u++;
- while (grays[v].black != ScaleQuantumToMap(GetPixelBlack(image,p+offset*GetPixelChannels(image))))
+ while (grays[v].black != ScaleQuantumToMap(GetPixelBlack(image,p+offset*GetPixelComponents(image))))
v++;
cooccurrence[u][v].direction[i].black++;
cooccurrence[v][u].direction[i].black++;
v=0;
while (grays[u].alpha != ScaleQuantumToMap(GetPixelAlpha(image,p)))
u++;
- while (grays[v].alpha != ScaleQuantumToMap(GetPixelAlpha(image,p+offset*GetPixelChannels(image))))
+ while (grays[v].alpha != ScaleQuantumToMap(GetPixelAlpha(image,p+offset*GetPixelComponents(image))))
v++;
cooccurrence[u][v].direction[i].alpha++;
cooccurrence[v][u].direction[i].alpha++;
}
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
grays=(LongPixelPacket *) RelinquishMagickMemory(grays);
}
}
i++;
- q+=GetPixelChannels(magnitude_image);
+ q+=GetPixelComponents(magnitude_image);
}
status=SyncCacheViewAuthenticPixels(magnitude_view,exception);
if (status == MagickFalse)
}
}
i++;
- q+=GetPixelChannels(phase_image);
+ q+=GetPixelComponents(phase_image);
}
status=SyncCacheViewAuthenticPixels(phase_view,exception);
if (status == MagickFalse)
}
}
i++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
}
}
i++;
- p+=GetPixelChannels(magnitude_image);
+ p+=GetPixelComponents(magnitude_image);
}
}
i=0L;
}
}
i++;
- p+=GetPixelChannels(phase_image);
+ p+=GetPixelComponents(phase_image);
}
}
if (fourier_info->modulus != MagickFalse)
}
}
i++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(noise_image,ClampToQuantum(GenerateDifferentialNoise(
random_info[id],GetPixelAlpha(image,p),noise_type,attenuate)),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(noise_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(noise_image);
}
sync=SyncCacheViewAuthenticPixels(noise_view,exception);
if (sync == MagickFalse)
SetPixelRed(shift_image,ClampToQuantum(pixel.red),q);
SetPixelGreen(shift_image,ClampToQuantum(pixel.green),q);
SetPixelBlue(shift_image,ClampToQuantum(pixel.blue),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(shift_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(shift_image);
}
sync=SyncCacheViewAuthenticPixels(shift_view,exception);
if (sync == MagickFalse)
(100.0-pixel.blue)+colorize.blue*pixel.blue)/100.0),q);
SetPixelAlpha(colorize_image,ClampToQuantum((GetPixelAlpha(image,p)*
(100.0-pixel.alpha)+colorize.alpha*pixel.alpha)/100.0),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(colorize_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(colorize_image);
}
sync=SyncCacheViewAuthenticPixels(colorize_view,exception);
if (sync == MagickFalse)
}
}
}
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(color_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(color_image);
}
if (SyncCacheViewAuthenticPixels(color_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(fx_image,ClampToQuantum((MagickRealType) QuantumRange*
alpha),q);
}
- q+=GetPixelChannels(fx_image);
+ q+=GetPixelComponents(fx_image);
}
if (SyncCacheViewAuthenticPixels(fx_view,exception) == MagickFalse)
status=MagickFalse;
exception);
SetPixelPixelInfo(implode_image,&pixel,q);
}
- q+=GetPixelChannels(implode_image);
+ q+=GetPixelComponents(implode_image);
}
if (SyncCacheViewAuthenticPixels(implode_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlack(morph_images,ClampToQuantum(alpha*
GetPixelBlack(morph_images,q)+beta*GetPixelBlack(morph_image,p)),
q);
- p+=GetPixelChannels(morph_image);
- q+=GetPixelChannels(morph_images);
+ p+=GetPixelComponents(morph_image);
+ q+=GetPixelComponents(morph_images);
}
sync=SyncCacheViewAuthenticPixels(morph_view,exception);
if (sync == MagickFalse)
SetPixelGreen(sepia_image,ClampToQuantum(tone),q);
if ((MagickRealType) GetPixelBlue(image,q) < tone)
SetPixelBlue(sepia_image,ClampToQuantum(tone),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(sepia_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(sepia_image);
}
if (SyncCacheViewAuthenticPixels(sepia_view,exception) == MagickFalse)
status=MagickFalse;
else
SetPixelAlpha(border_image,ClampToQuantum((MagickRealType)
(GetPixelAlpha(border_image,q)*opacity/100.0)),q);
- q+=GetPixelChannels(border_image);
+ q+=GetPixelComponents(border_image);
}
if (SyncCacheViewAuthenticPixels(border_view,exception) == MagickFalse)
status=MagickFalse;
if (image->colorspace == CMYKColorspace)
pixel.black=pixel.red;
SetPixelPixelInfo(random_image,&pixel,q);
- q+=GetPixelChannels(random_image);
+ q+=GetPixelComponents(random_image);
}
if (SyncCacheViewAuthenticPixels(random_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelGreen(image,QuantumRange-GetPixelGreen(image,q),q);
if ((MagickRealType) GetPixelBlue(image,q) > threshold)
SetPixelBlue(image,QuantumRange-GetPixelBlue(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlue(image,GetPixelBlue(left_image,q),r);
SetPixelAlpha(image,(GetPixelAlpha(left_image,p)+
GetPixelAlpha(left_image,q))/2,r);
- p+=GetPixelChannels(left_image);
+ p+=GetPixelComponents(left_image);
q++;
r++;
}
center.y),&pixel,exception);
SetPixelPixelInfo(swirl_image,&pixel,q);
}
- q+=GetPixelChannels(swirl_image);
+ q+=GetPixelComponents(swirl_image);
}
if (SyncCacheViewAuthenticPixels(swirl_view,exception) == MagickFalse)
status=MagickFalse;
(1.0-(4.0*(weight*weight)));
SetPixelBlue(tint_image,ClampToQuantum(pixel.blue),q);
SetPixelAlpha(tint_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(tint_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(tint_image);
}
if (SyncCacheViewAuthenticPixels(tint_view,exception) == MagickFalse)
status=MagickFalse;
UndefinedInterpolatePixel,(double) x,(double) (y-sine_map[x]),&pixel,
exception);
SetPixelPixelInfo(wave_image,&pixel,q);
- q+=GetPixelChannels(wave_image);
+ q+=GetPixelComponents(wave_image);
}
if (SyncCacheViewAuthenticPixels(wave_view,exception) == MagickFalse)
status=MagickFalse;
node_info->number_unique++;
cube_info->colors++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
proceed=SetImageProgress(image,EvaluateImageTag,(MagickOffsetType) y,
image->rows);
if (cube_info->colors > MaximumUniqueColors)
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
break;
if (cube_info->colors > 256)
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
break;
{
if (GetPixelAlpha(image,p) == (Quantum) TransparentAlpha)
break;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
break;
SetPixelAlpha(append_image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(append_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(append_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(append_image);
}
sync=SyncCacheViewAuthenticPixels(append_view,exception);
if (sync == MagickFalse)
(void) ResetMagickMemory(clone_image,0,sizeof(*clone_image));
clone_image->signature=MagickSignature;
clone_image->storage_class=image->storage_class;
- clone_image->pixel_channels=image->pixel_channels;
+ clone_image->pixel_components=image->pixel_components;
clone_image->metacontent_extent=image->metacontent_extent;
clone_image->colorspace=image->colorspace;
clone_image->matte=image->matte;
for (x=0; x < (ssize_t) combine_image->columns; x++)
{
SetPixelRed(image,GetPixelIntensity(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
image_view=DestroyCacheView(image_view);
for (x=0; x < (ssize_t) combine_image->columns; x++)
{
SetPixelGreen(image,GetPixelIntensity(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
image_view=DestroyCacheView(image_view);
for (x=0; x < (ssize_t) combine_image->columns; x++)
{
SetPixelBlue(image,GetPixelIntensity(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
image_view=DestroyCacheView(image_view);
for (x=0; x < (ssize_t) combine_image->columns; x++)
{
SetPixelBlack(image,GetPixelIntensity(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
image_view=DestroyCacheView(image_view);
for (x=0; x < (ssize_t) combine_image->columns; x++)
{
SetPixelAlpha(image,GetPixelIntensity(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
image_view=DestroyCacheView(image_view);
(pixel.alpha != (QuantumAny) pixel.alpha))
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
status=MagickFalse;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPixelInfo(image,background,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
{
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
{
SetPixelRed(image,GetPixelGreen(image,q),q);
SetPixelBlue(image,GetPixelGreen(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
{
SetPixelRed(image,GetPixelBlue(image,q),q);
SetPixelGreen(image,GetPixelBlue(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
SetPixelRed(image,GetPixelAlpha(image,q),q);
SetPixelGreen(image,GetPixelAlpha(image,q),q);
SetPixelBlue(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
SetPixelRed(image,GetPixelBlack(image,q),q);
SetPixelGreen(image,GetPixelBlack(image,q),q);
SetPixelBlue(image,GetPixelBlack(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
SetPixelRed(image,GetPixelAlpha(image,q),q);
SetPixelGreen(image,GetPixelAlpha(image,q),q);
SetPixelBlue(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelIntensity(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,pixel.black,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelPacket(image,&pixel,q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,pixel.black,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPixelInfo(image,color,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,opacity,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
index=PushColormapIndex(image,(size_t) GetPixelIndex(image,q),
&range_exception);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
ping;
size_t
- pixel_channels,
+ pixel_components,
metacontent_extent;
MagickBooleanType
for (x=0; x < (ssize_t) bounds->width; x++)
{
SetPixelAlpha(image,TransparentAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if ((GetPixelAlpha(image1,p) <= (Quantum) (QuantumRange/2)) &&
(GetPixelAlpha(image1,q) > (Quantum) (QuantumRange/2)))
break;
- p+=GetPixelChannels(image1);
+ p+=GetPixelComponents(image1);
q++;
}
if (x < (ssize_t) bounds->width)
SetPixelInfo(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
- p+=GetPixelChannels(image1);
+ p+=GetPixelComponents(image1);
q++;
}
if (y < (ssize_t) image1->rows)
SetPixelInfo(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
- p+=GetPixelChannels(image1);
+ p+=GetPixelComponents(image1);
q++;
}
if (y < (ssize_t) image1->rows)
SetPixelInfo(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
- p+=GetPixelChannels(image1);
+ p+=GetPixelComponents(image1);
q++;
}
if (x < (ssize_t) image1->columns)
SetPixelInfo(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
- p+=GetPixelChannels(image1);
+ p+=GetPixelComponents(image1);
q++;
}
if (x < (ssize_t) image1->columns)
SetPixelBlue(image,ScaleCharToQuantum(Pixel.blue & 0xff),q);
if (image->storage_class == PseudoClass)
SetPixelIndex(image,Color2Index(&Pixel),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
* This removes need for 'cloning' a new image every iteration
*/
SetPixelRed(morphology_image,GetPixelRed(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelGreen(morphology_image,GetPixelGreen(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelBlue(morphology_image,GetPixelBlue(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(morphology_image,GetPixelBlack(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
/* Set the bias of the weighted average output */
result.red =
|| ((image->colorspace == CMYKColorspace) &&
(GetPixelBlack(image,p+r) != GetPixelBlack(morphology_image,q))))
changed++; /* The pixel was changed in some way! */
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(morphology_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(morphology_image);
} /* y */
if ( SyncCacheViewAuthenticPixels(morphology_view,exception) == MagickFalse)
status=MagickFalse;
* This removes need for 'cloning' a new image every iteration
*/
SetPixelRed(morphology_image,GetPixelRed(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelGreen(morphology_image,GetPixelGreen(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelBlue(morphology_image,GetPixelBlue(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(morphology_image,GetPixelBlack(image,p+r*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
/* Defaults */
min.red =
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
result.red += (*k)*
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image));
result.green += (*k)*
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image));
result.blue += (*k)*
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
result.black += (*k)*
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image));
result.alpha += (*k)*
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
SetPixelRed(morphology_image,ClampToQuantum(result.red),
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
alpha=(*k)*(QuantumScale*
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
gamma += alpha;
result.red += alpha*
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image));
result.green += alpha*
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image));
result.blue += alpha*
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
result.black+=alpha*
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image));
result.alpha += (*k)*
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* Sync'ed channels, all channels are modified */
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
for (u=0; u < (ssize_t) kernel->width; u++, k++) {
if ( IsNan(*k) || (*k) < 0.5 ) continue;
Minimize(min.red, (double)
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.green, (double)
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.blue, (double)
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if (image->colorspace == CMYKColorspace)
Minimize(min.black,(double)
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.alpha,(double)
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
break;
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) || (*k) < 0.5 ) continue;
Maximize(max.red, (double)
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.green, (double)
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.blue, (double)
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if (image->colorspace == CMYKColorspace)
Maximize(max.black, (double)
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.alpha,(double)
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
break;
if ( (*k) > 0.7 )
{ /* minimim of foreground pixels */
Minimize(min.red, (double)
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.green, (double)
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.blue, (double)
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if ( image->colorspace == CMYKColorspace)
Minimize(min.black,(double)
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Minimize(min.alpha,(double)
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
else if ( (*k) < 0.3 )
{ /* maximum of background pixels */
Maximize(max.red, (double)
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.green, (double)
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.blue, (double)
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if (image->colorspace == CMYKColorspace)
Maximize(max.black, (double)
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Maximize(max.alpha,(double)
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* Pattern Match if difference is positive */
min.red -= max.red; Maximize( min.red, 0.0 );
result.red = 1.0;
}
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
break;
result.red = 1.0;
}
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
break;
#if 0
if ( image->colorspace == CMYKColorspace)
Minimize(result.black,(*k)+GetPixelBlack(p_image,k_indexes+u));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
break;
#endif
((image->colorspace == CMYKColorspace) &&
(GetPixelBlack(image,p+r) != GetPixelBlack(morphology_image,q))))
changed++; /* The pixel was changed in some way! */
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(morphology_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(morphology_image);
} /* x */
if ( SyncCacheViewAuthenticPixels(morphology_view,exception) == MagickFalse)
status=MagickFalse;
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
Minimize(result.red, (*k)+
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.green, (*k)+
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.blue, (*k)+
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if (image->colorspace == CMYKColorspace)
Minimize(result.black,(*k)+
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.alpha, (*k)+
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* repeat with the just processed pixels of this row */
k = &kernel->values[ kernel->width*(kernel->y+1)-1 ];
if ( x+u-offx < 0 ) continue; /* off the edge! */
if ( IsNan(*k) ) continue;
Minimize(result.red, (*k)+
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.green, (*k)+
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.blue, (*k)+
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if (image->colorspace == CMYKColorspace)
Minimize(result.black,(*k)+
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.alpha,(*k)+
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
break;
case VoronoiMorphology:
for (v=0; v <= (ssize_t) offy; v++) {
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
- if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
+ if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ SetPixelInfo(image,k_pixels+u*GetPixelComponents(image),
&result);
result.alpha += *k;
}
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* repeat with the just processed pixels of this row */
k = &kernel->values[ kernel->width*(kernel->y+1)-1 ];
for (u=0; u < (ssize_t) offx; u++, k--) {
if ( x+u-offx < 0 ) continue; /* off the edge! */
if ( IsNan(*k) ) continue;
- if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
+ if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ SetPixelInfo(image,k_pixels+u*GetPixelComponents(image),
&result);
result.alpha += *k;
}
(GetPixelBlack(image,p+r) != GetPixelBlack(image,q))))
changed++; /* The pixel was changed in some way! */
- p+=GetPixelChannels(image); /* increment pixel buffers */
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(image); /* increment pixel buffers */
+ q+=GetPixelComponents(image);
} /* x */
if ( SyncCacheViewAuthenticPixels(auth_view,exception) == MagickFalse)
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
Minimize(result.red, (*k)+
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.green, (*k)+
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.blue, (*k)+
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if ( image->colorspace == CMYKColorspace)
Minimize(result.black,(*k)+
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.alpha, (*k)+
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* repeat with the just processed pixels of this row */
k = &kernel->values[ kernel->width*(kernel->y)+kernel->x-1 ];
if ( (x+u-offx) >= (ssize_t)image->columns ) continue;
if ( IsNan(*k) ) continue;
Minimize(result.red, (*k)+
- GetPixelRed(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelRed(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.green, (*k)+
- GetPixelGreen(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelGreen(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.blue, (*k)+
- GetPixelBlue(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlue(image,k_pixels+u*GetPixelComponents(image)));
if ( image->colorspace == CMYKColorspace)
Minimize(result.black, (*k)+
- GetPixelBlack(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelBlack(image,k_pixels+u*GetPixelComponents(image)));
Minimize(result.alpha, (*k)+
- GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)));
+ GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)));
}
break;
case VoronoiMorphology:
for (v=offy; v < (ssize_t) kernel->height; v++) {
for (u=0; u < (ssize_t) kernel->width; u++, k--) {
if ( IsNan(*k) ) continue;
- if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
+ if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ SetPixelInfo(image,k_pixels+u*GetPixelComponents(image),
&result);
result.alpha += *k;
}
}
- k_pixels += virt_width*GetPixelChannels(image);
+ k_pixels += virt_width*GetPixelComponents(image);
}
/* repeat with the just processed pixels of this row */
k = &kernel->values[ kernel->width*(kernel->y)+kernel->x-1 ];
for (u=offx+1; u < (ssize_t) kernel->width; u++, k--) {
if ( (x+u-offx) >= (ssize_t)image->columns ) continue;
if ( IsNan(*k) ) continue;
- if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
+ if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelComponents(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ SetPixelInfo(image,k_pixels+u*GetPixelComponents(image),
&result);
result.alpha += *k;
}
q->rgbGreen=ScaleQuantumToChar(GetPixelGreen(image,p));
q->rgbBlue=ScaleQuantumToChar(GetPixelBlue(image,p));
q->rgbReserved=0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
}
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
break;
- p+=x1*GetPixelChannels(image);
- q+=x1*GetPixelChannels(floodplane_image);
+ p+=x1*GetPixelComponents(image);
+ q+=x1*GetPixelComponents(floodplane_image);
for (x=x1; x >= 0; x--)
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
break;
SetPixelAlpha(floodplane_image,TransparentAlpha,q);
- p-=GetPixelChannels(image);
- q-=GetPixelChannels(floodplane_image);
+ p-=GetPixelComponents(image);
+ q-=GetPixelComponents(floodplane_image);
}
if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
break;
break;
SetPixelAlpha(floodplane_image,
TransparentAlpha,q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(floodplane_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(floodplane_image);
}
if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
break;
SetPixelInfo(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
break;
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(floodplane_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(floodplane_image);
}
}
start=x;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,ClampToQuantum(fill.alpha),q);
}
- p+=GetPixelChannels(floodplane_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(floodplane_image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
i+=(ssize_t) (image->columns+width);
}
SetPixelRed(paint_image,GetPixelRed(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelGreen(paint_image,GetPixelGreen(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelBlue(paint_image,GetPixelBlue(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(paint_image,GetPixelBlack(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->matte != MagickFalse)
SetPixelAlpha(paint_image,GetPixelAlpha(image,p+j*
- GetPixelChannels(image)),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(paint_image);
+ GetPixelComponents(image)),q);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(paint_image);
}
if (SyncCacheViewAuthenticPixels(paint_view,exception) == MagickFalse)
status=MagickFalse;
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,ClampToQuantum(fill->alpha),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelInfo(image,q,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
SetPixelAlpha(image,opacity,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
MagickTrue : MagickFalse;
if (match != invert)
SetPixelAlpha(image,opacity,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
return(image->component_map[image->map][CbPixelComponent].traits);
}
-static inline size_t GetPixelChannels(const Image *image)
-{
- return(image->pixel_channels);
-}
-
static inline Quantum GetPixelComponent(const Image *image,
const PixelComponent component)
{
return(image->component_map[image->map][component].component);
}
+static inline size_t GetPixelComponents(const Image *image)
+{
+ return(image->pixel_components);
+}
+
static inline Quantum GetPixelCr(const Image *image,const Quantum *pixel)
{
return(pixel[image->component_map[image->map][CrPixelComponent].component]);
image->component_map[image->map][CbPixelComponent].traits=traits;
}
-static inline void SetPixelChannels(Image *image,const size_t channels)
-{
- image->pixel_channels=channels;
-}
-
static inline void SetPixelComponent(const Image *image,
const PixelComponent component,const PixelComponent components)
{
image->component_map[image->map][component].component=components;
}
+static inline void SetPixelComponents(Image *image,const size_t channels)
+{
+ image->pixel_components=channels;
+}
+
static inline void SetPixelComponentTraits(Image *image,
const PixelComponent component,const PixelTrait traits)
{
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar((Quantum) 0);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=0.0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=(double) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelRed(image,p));
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=(double) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(double) (QuantumScale*GetPixelGreen(image,p));
*q++=(double) (QuantumScale*GetPixelBlue(image,p));
*q++=0.0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=0.0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=(float) (QuantumScale*GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelRed(image,p));
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=(float) (QuantumScale*GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(float) (QuantumScale*GetPixelGreen(image,p));
*q++=(float) (QuantumScale*GetPixelBlue(image,p));
*q++=0.0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=0U;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
{
*q++=(unsigned int) ScaleQuantumToLong(
GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=0U;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelRed(image,p));
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToLong(GetPixelGreen(image,p));
*q++=ScaleQuantumToLong(GetPixelBlue(image,p));
*q++=0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelBlue(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
*q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelRed(image,p);
*q++=(Quantum) 0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=GetPixelIntensity(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelRed(image,p);
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
*q++=(Quantum) (GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=GetPixelGreen(image,p);
*q++=GetPixelBlue(image,p);
*q++=(Quantum) 0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelRed(image,p));
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=0;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
}
q++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
break;
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(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+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(*p)),q);
p++;
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(*p)),q);
p++;
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(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+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(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+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleLongToQuantum(*p++),q);
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,*p++,q);
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
SetPixelAlpha(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelRed(image,*p++,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,*p++,q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,*p++,q);
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
SetPixelAlpha(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,*p++,q);
SetPixelBlue(image,*p++,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(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+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleShortToQuantum(*p++),q);
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
break;
}
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);
- 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,
+ 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+10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,
+ AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,
alpha+11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,
+ AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,
alpha+12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,
+ AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,
alpha+13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,
+ AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,
alpha+14);
AlphaBlendPixelInfo(image,p+15,pixels+15,alpha+15);
pixel->red=0.0;
break;
}
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);
- 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,
+ 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+10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,
+ AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,
alpha+11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,
+ AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,
alpha+12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,
+ AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,
alpha+13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,
+ AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,
alpha+14);
- AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,
+ AlphaBlendPixelInfo(image,p+15*GetPixelComponents(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*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+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;
epsilon.x=1.0-delta.x;
break;
}
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);
+ 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)
break;
}
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);
- 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,
+ 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+10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,
+ AlphaBlendPixelInfo(image,p+11*GetPixelComponents(image),pixels+11,
alpha+11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,
+ AlphaBlendPixelInfo(image,p+12*GetPixelComponents(image),pixels+12,
alpha+12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,
+ AlphaBlendPixelInfo(image,p+13*GetPixelComponents(image),pixels+13,
alpha+13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,
+ AlphaBlendPixelInfo(image,p+14*GetPixelComponents(image),pixels+14,
alpha+14);
- AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,
+ AlphaBlendPixelInfo(image,p+15*GetPixelComponents(image),pixels+15,
alpha+15);
pixel->red=0.0;
pixel->green=0.0;
*/
MagickExport void StandardPixelComponentMap(Image *image)
{
- image->pixel_channels=4;
+ image->pixel_components=4;
SetPixelComponent(image,RedPixelComponent,RedPixelComponent);
SetPixelComponentTraits(image,RedPixelComponent,ActivePixelTrait);
SetPixelComponent(image,GreenPixelComponent,GreenPixelComponent);
SetPixelComponentTraits(image,AlphaPixelComponent,ActivePixelTrait);
if (image->colorspace == CMYKColorspace)
{
- image->pixel_channels++;
+ image->pixel_components++;
SetPixelComponent(image,BlackPixelComponent,BlackPixelComponent);
SetPixelComponentTraits(image,BlackPixelComponent,ActivePixelTrait);
}
if (image->storage_class == PseudoClass)
{
- image->pixel_channels++;
+ image->pixel_components++;
SetPixelComponent(image,IndexPixelComponent,IndexPixelComponent);
SetPixelComponentTraits(image,IndexPixelComponent,ActivePixelTrait);
}
if (density > total_ink_density)
total_ink_density=density;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
}
if (source_channels > 3)
*p++=ScaleQuantumToShort(GetPixelBlack(image,q));
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
cmsDoTransform(transform[id],source_pixels[id],target_pixels[id],
(unsigned int) image->columns);
p=target_pixels[id];
- q-=image->columns*GetPixelChannels(image);
+ q-=image->columns*GetPixelComponents(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,ScaleShortToQuantum(*p),q);
SetPixelBlack(image,ScaleShortToQuantum(*p),q);
p++;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
PixelPacket
packet;
- GetPixelPacket(image,q+count*GetPixelChannels(image),&packet);
+ GetPixelPacket(image,q+count*GetPixelComponents(image),&packet);
if (IsPixelEquivalent(image,q,&packet) == MagickFalse)
break;
}
if (cube.associate_alpha != MagickFalse)
SetPixelAlpha(image,image->colormap[index].alpha,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
PixelPacket
packet;
- GetPixelPacket(image,p+count*GetPixelChannels(image),&packet);
+ GetPixelPacket(image,p+count*GetPixelComponents(image),&packet);
if (IsPixelEquivalent(image,p,&packet) == MagickFalse)
break;
}
node_info->total_color.blue+=count*QuantumScale*pixel.blue;
if (cube_info->associate_alpha != MagickFalse)
node_info->total_color.alpha+=count*QuantumScale*pixel.alpha;
- p+=count*GetPixelChannels(image);
+ p+=count*GetPixelComponents(image);
}
if (cube_info->colors > cube_info->maximum_colors)
{
PixelPacket
packet;
- GetPixelPacket(image,p+count*GetPixelChannels(image),&packet);
+ GetPixelPacket(image,p+count*GetPixelComponents(image),&packet);
if (IsPixelEquivalent(image,p,&packet) == MagickFalse)
break;
}
node_info->total_color.blue+=count*QuantumScale*pixel.blue;
if (cube_info->associate_alpha != MagickFalse)
node_info->total_color.alpha+=count*QuantumScale*pixel.alpha;
- p+=count*GetPixelChannels(image);
+ p+=count*GetPixelComponents(image);
}
proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
image->rows);
status=MagickFalse;
continue;
}
- q+=(y & 0x01)*image->columns*GetPixelChannels(image);
+ q+=(y & 0x01)*image->columns*GetPixelComponents(image);
cube=(*cube_info);
current=pixels[id]+(y & 0x01)*image->columns;
previous=pixels[id]+((y+1) & 0x01)*image->columns;
ssize_t
u;
- q-=(y & 0x01)*GetPixelChannels(image);
+ q-=(y & 0x01)*GetPixelComponents(image);
u=(y & 0x01) != 0 ? (ssize_t) image->columns-1-x : x;
AssociateAlphaPixel(image,&cube,q,&pixel);
if (x > 0)
if (proceed == MagickFalse)
status=MagickFalse;
}
- q+=((y+1) & 0x01)*GetPixelChannels(image);
+ q+=((y+1) & 0x01)*GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
mean_error+=distance*distance;
if (distance > maximum_error)
maximum_error=distance;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
if (((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0) &&
(image->matte == MagickTrue))
SetPixelAlpha(image,PosterizePixel(GetPixelAlpha(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
SetPixelIndex(image,(Quantum)
colormap_index[intensity],q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
{
SetPixelIndex(image,(Quantum) colormap_index[ScaleQuantumToMap(
GetPixelIndex(image,q))],q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
{
number_pixels=GetImageExtent(image);
p=GetVirtualPixelQueue(image);
- channels=GetPixelChannels(image);
+ channels=GetPixelComponents(image);
}
else
{
number_pixels=GetCacheViewExtent(image_view);
p=GetCacheViewVirtualPixelQueue(image_view);
- channels=GetPixelChannels(image);
+ channels=GetPixelComponents(image);
}
if (quantum_info->alpha_type == AssociatedQuantumAlpha)
{
{
number_pixels=GetImageExtent(image);
q=GetAuthenticPixelQueue(image);
- channels=GetPixelChannels(image);
+ channels=GetPixelComponents(image);
}
else
{
number_pixels=GetCacheViewExtent(image_view);
q=GetCacheViewAuthenticPixelQueue(image_view);
- channels=GetPixelChannels(image);
+ channels=GetPixelComponents(image);
}
InitializeQuantumState(quantum_info,image->endian,&quantum_state);
extent=GetQuantumExtent(image,quantum_info,quantum_type);
#else
}
#endif
- pixels+=GetPixelChannels(resample_filter->image);
+ pixels+=GetPixelComponents(resample_filter->image);
Q += DQ;
DQ += DDQ;
}
(void) InterpolatePixelInfo(image,image_view,
MeshInterpolatePixel,offset.x-0.5,offset.y-0.5,&pixel,exception);
SetPixelPixelInfo(resize_image,&pixel,q);
- q+=GetPixelChannels(resize_image);
+ q+=GetPixelComponents(resize_image);
}
if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
continue;
(contribution[i].pixel-contribution[0].pixel);
alpha=contribution[i].weight;
pixel.red+=alpha*GetPixelRed(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=alpha*GetPixelGreen(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=alpha*GetPixelBlue(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
pixel.black+=alpha*GetPixelBlue(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.alpha+=alpha*GetPixelAlpha(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
}
SetPixelRed(resize_image,ClampToQuantum(pixel.red),q);
SetPixelGreen(resize_image,ClampToQuantum(pixel.green),q);
j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
(contribution[i].pixel-contribution[0].pixel);
alpha=contribution[i].weight*QuantumScale*
- GetPixelAlpha(image,p+j*GetPixelChannels(image));
+ GetPixelAlpha(image,p+j*GetPixelComponents(image));
pixel.red+=alpha*GetPixelRed(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=alpha*GetPixelGreen(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=alpha*GetPixelBlue(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
pixel.black+=alpha*GetPixelBlack(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.alpha+=contribution[i].weight*
- GetPixelAlpha(image,p+j*GetPixelChannels(image));
+ GetPixelAlpha(image,p+j*GetPixelComponents(image));
gamma+=alpha;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
(contribution[i-start].pixel-contribution[0].pixel);
SetPixelIndex(resize_image,GetPixelIndex(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
}
- q+=GetPixelChannels(resize_image);
+ q+=GetPixelComponents(resize_image);
}
if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
status=MagickFalse;
image->columns+x);
alpha=contribution[i].weight;
pixel.red+=alpha*GetPixelRed(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=alpha*GetPixelGreen(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=alpha*GetPixelBlue(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
pixel.black+=alpha*GetPixelBlack(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.alpha+=alpha*GetPixelAlpha(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
}
SetPixelRed(resize_image,ClampToQuantum(pixel.red),q);
SetPixelGreen(resize_image,ClampToQuantum(pixel.green),q);
j=(ssize_t) ((contribution[i].pixel-contribution[0].pixel)*
image->columns+x);
alpha=contribution[i].weight*QuantumScale*
- GetPixelAlpha(image,p+j*GetPixelChannels(image));
+ GetPixelAlpha(image,p+j*GetPixelComponents(image));
pixel.red+=alpha*GetPixelRed(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.green+=alpha*GetPixelGreen(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.blue+=alpha*GetPixelBlue(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
if ((image->colorspace == CMYKColorspace) &&
(resize_image->colorspace == CMYKColorspace))
pixel.black+=alpha*GetPixelBlack(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
pixel.alpha+=contribution[i].weight*GetPixelAlpha(image,p+j*
- GetPixelChannels(image));
+ GetPixelComponents(image));
gamma+=alpha;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
j=(ssize_t) ((contribution[i-start].pixel-contribution[0].pixel)*
image->columns+x);
SetPixelIndex(resize_image,GetPixelIndex(image,p+j*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
}
- q+=GetPixelChannels(resize_image);
+ q+=GetPixelComponents(resize_image);
}
if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) sample_image->columns; x++)
{
SetPixelRed(sample_image,GetPixelRed(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelGreen(sample_image,GetPixelGreen(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
SetPixelBlue(sample_image,GetPixelBlue(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(sample_image,GetPixelBlack(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->matte != MagickFalse)
SetPixelAlpha(sample_image,GetPixelAlpha(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
+ GetPixelComponents(image)),q);
if (image->storage_class == PseudoClass)
SetPixelIndex(sample_image,GetPixelIndex(image,p+x_offset[x]*
- GetPixelChannels(image)),q);
- q+=GetPixelChannels(sample_image);
+ GetPixelComponents(image)),q);
+ q+=GetPixelComponents(sample_image);
}
if (SyncCacheViewAuthenticPixels(sample_view,exception) == MagickFalse)
status=MagickFalse;
x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
if (image->colorspace == CMYKColorspace)
x_vector[x].black=(MagickRealType) (alpha*GetPixelBlack(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
else
if (image->matte != MagickFalse)
x_vector[x].alpha=(MagickRealType)
GetPixelAlpha(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
number_rows++;
}
GetPixelBlack(image,p));
if (image->matte != MagickFalse)
x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
number_rows++;
next_row=MagickFalse;
SetPixelBlack(scale_image,ClampToQuantum(alpha*s->black),q);
if (scale_image->matte != MagickFalse)
SetPixelAlpha(scale_image,ClampToQuantum(s->alpha),q);
- q+=GetPixelChannels(scale_image);
+ q+=GetPixelComponents(scale_image);
s++;
}
}
if (scale_image->matte != MagickFalse)
SetPixelAlpha(scale_image,ClampToQuantum(t->alpha),q);
t++;
- q+=GetPixelChannels(scale_image);
+ q+=GetPixelComponents(scale_image);
}
}
if (SyncCacheViewAuthenticPixels(scale_view,exception) == MagickFalse)
cluster->count++;
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
}
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
cluster->count++;
break;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
proceed=SetImageProgress(image,SegmentImageTag,(MagickOffsetType) y,
2*image->rows);
histogram[Red][(ssize_t) ScaleQuantumToChar(GetPixelRed(image,p))]++;
histogram[Green][(ssize_t) ScaleQuantumToChar(GetPixelGreen(image,p))]++;
histogram[Blue][(ssize_t) ScaleQuantumToChar(GetPixelBlue(image,p))]++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
}
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
background.blue+=QuantumScale*GetPixelBlue(image,p);
background.alpha+=QuantumScale*GetPixelAlpha(image,p);
count++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
status=MagickFalse;
break;
}
- tile_pixels=p+((height-1)*width+y)*GetPixelChannels(image);
+ tile_pixels=p+((height-1)*width+y)*GetPixelComponents(image);
for (x=0; x < (ssize_t) height; x++)
{
SetPixelRed(rotate_image,GetPixelRed(image,tile_pixels),q);
SetPixelGreen(rotate_image,GetPixelGreen(image,tile_pixels),q);
SetPixelBlue(rotate_image,GetPixelBlue(image,tile_pixels),q);
SetPixelAlpha(rotate_image,GetPixelAlpha(image,tile_pixels),q);
- tile_pixels-=width*GetPixelChannels(image);
- q+=GetPixelChannels(rotate_image);
+ tile_pixels-=width*GetPixelComponents(image);
+ q+=GetPixelComponents(rotate_image);
}
sync=SyncCacheViewAuthenticPixels(rotate_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
continue;
}
- q+=GetPixelChannels(rotate_image)*image->columns;
+ q+=GetPixelComponents(rotate_image)*image->columns;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q-=GetPixelChannels(rotate_image);
+ q-=GetPixelComponents(rotate_image);
SetPixelRed(rotate_image,GetPixelRed(image,p),q);
SetPixelGreen(rotate_image,GetPixelGreen(image,p),q);
SetPixelBlue(rotate_image,GetPixelBlue(image,p),q);
SetPixelAlpha(rotate_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(rotate_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
break;
}
- tile_pixels=p+((width-1)-y)*GetPixelChannels(image);
+ tile_pixels=p+((width-1)-y)*GetPixelComponents(image);
for (x=0; x < (ssize_t) height; x++)
{
SetPixelRed(rotate_image,GetPixelRed(image,tile_pixels),q);
SetPixelGreen(rotate_image,GetPixelGreen(image,tile_pixels),q);
SetPixelBlue(rotate_image,GetPixelBlue(image,tile_pixels),q);
SetPixelAlpha(rotate_image,GetPixelAlpha(image,tile_pixels),q);
- tile_pixels+=width*GetPixelChannels(image);
- q+=GetPixelChannels(rotate_image);
+ tile_pixels+=width*GetPixelComponents(image);
+ q+=GetPixelComponents(rotate_image);
}
sync=SyncCacheViewAuthenticPixels(rotate_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
continue;
}
- p+=x_offset*GetPixelChannels(image);
+ p+=x_offset*GetPixelComponents(image);
displacement=degrees*(MagickRealType) (y-height/2.0);
if (displacement == 0.0)
continue;
*/
if (step > x_offset)
break;
- q=p-step*GetPixelChannels(image);
+ q=p-step*GetPixelComponents(image);
for (i=0; i < (ssize_t) width; i++)
{
if ((x_offset+i) < step)
{
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
SetPixelInfo(image,p,&pixel);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
SetPixelInfo(image,p,&source);
&destination);
SetPixelPixelInfo(image,&destination,q);
SetPixelInfo(image,p,&pixel);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(image);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
SetPixelPixelInfo(image,&destination,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
for (i=0; i < (step-1); i++)
{
SetPixelPixelInfo(image,&background,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
/*
Transfer pixels right-to-left.
*/
- p+=width*GetPixelChannels(image);
- q=p+step*GetPixelChannels(image);
+ p+=width*GetPixelComponents(image);
+ q=p+step*GetPixelComponents(image);
for (i=0; i < (ssize_t) width; i++)
{
- p-=GetPixelChannels(image);
- q-=GetPixelChannels(image);
+ p-=GetPixelComponents(image);
+ q-=GetPixelComponents(image);
if ((size_t) (x_offset+width+step-i) >= image->columns)
continue;
SetPixelInfo(image,p,&source);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
- q-=GetPixelChannels(image);
+ q-=GetPixelComponents(image);
SetPixelPixelInfo(image,&destination,q);
for (i=0; i < (step-1); i++)
{
- q-=GetPixelChannels(image);
+ q-=GetPixelComponents(image);
SetPixelPixelInfo(image,&background,q);
}
break;
status=MagickFalse;
continue;
}
- p+=y_offset*GetPixelChannels(image);
+ p+=y_offset*GetPixelComponents(image);
displacement=degrees*(MagickRealType) (x-width/2.0);
if (displacement == 0.0)
continue;
*/
if (step > y_offset)
break;
- q=p-step*GetPixelChannels(image);
+ q=p-step*GetPixelComponents(image);
for (i=0; i < (ssize_t) height; i++)
{
if ((y_offset+i) < step)
{
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
SetPixelInfo(image,p,&pixel);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
continue;
}
SetPixelInfo(image,p,&source);
&destination);
SetPixelPixelInfo(image,&destination,q);
SetPixelInfo(image,p,&pixel);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(image);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
SetPixelPixelInfo(image,&destination,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
for (i=0; i < (step-1); i++)
{
SetPixelPixelInfo(image,&background,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
/*
Transfer pixels bottom-to-top.
*/
- p+=height*GetPixelChannels(image);
- q=p+step*GetPixelChannels(image);
+ p+=height*GetPixelComponents(image);
+ q=p+step*GetPixelComponents(image);
for (i=0; i < (ssize_t) height; i++)
{
- p-=GetPixelChannels(image);
- q-=GetPixelChannels(image);
+ p-=GetPixelComponents(image);
+ q-=GetPixelComponents(image);
if ((size_t) (y_offset+height+step-i) >= image->rows)
continue;
SetPixelInfo(image,p,&source);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
- q-=GetPixelChannels(image);
+ q-=GetPixelComponents(image);
SetPixelPixelInfo(image,&destination,q);
for (i=0; i < (step-1); i++)
{
- q-=GetPixelChannels(image);
+ q-=GetPixelComponents(image);
SetPixelPixelInfo(image,&background,q);
}
break;
else
SetPixelAlpha(evaluate_image,
ClampToQuantum(evaluate_pixel[i/2].alpha),q);
- q+=GetPixelChannels(evaluate_image);
+ q+=GetPixelComponents(evaluate_image);
}
if (SyncCacheViewAuthenticPixels(evaluate_view,exception) == MagickFalse)
status=MagickFalse;
evaluate_pixel[x].alpha=ApplyEvaluateOperator(random_info[id],
GetPixelAlpha(next,p),i == 0 ? AddEvaluateOperator : op,
evaluate_pixel[x].alpha);
- p+=GetPixelChannels(next);
+ p+=GetPixelComponents(next);
}
image_view=DestroyCacheView(image_view);
next=GetNextImageInList(next);
else
SetPixelAlpha(evaluate_image,ClampToQuantum(evaluate_pixel[x].alpha),
q);
- q+=GetPixelChannels(evaluate_image);
+ q+=GetPixelComponents(evaluate_image);
}
if (SyncCacheViewAuthenticPixels(evaluate_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(image,ClampToQuantum(ApplyEvaluateOperator(
random_info[id],GetPixelAlpha(image,q),op,value)),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelAlpha(image,ApplyFunction(GetPixelAlpha(image,q),function,
number_parameters,parameters,exception),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
GetPixelAlpha(image,p);
area++;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
if (y < (ssize_t) image->rows)
if (pixel.alpha > *maxima)
*maxima=(double) pixel.alpha;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
GetPixelAlpha(image,p)*GetPixelAlpha(image,p);
}
x++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
area=(double) image->columns*image->rows;
Pixels are stored in a temporary buffer until they are synced to the cache.
*/
number_pixels=(MagickSizeType) columns*rows;
- length=(size_t) number_pixels*cache_info->pixel_channels*sizeof(Quantum);
+ length=(size_t) number_pixels*cache_info->pixel_components*sizeof(Quantum);
if (cache_info->metacontent_extent != 0)
length+=number_pixels*cache_info->metacontent_extent;
if (cache_info->pixels == (Quantum *) NULL)
cache_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
cache_info->metacontent=(void *) (cache_info->pixels+number_pixels*
- cache_info->pixel_channels);
+ cache_info->pixel_components);
return(cache_info->pixels);
}
\f
cache_info->columns=columns;
cache_info->rows=rows;
number_pixels=(MagickSizeType) columns*rows;
- length=(size_t) number_pixels*cache_info->pixel_channels*sizeof(Quantum);
+ length=(size_t) number_pixels*cache_info->pixel_components*sizeof(Quantum);
if (cache_info->metacontent_extent != 0)
length+=number_pixels*cache_info->metacontent_extent;
if (cache_info->pixels == (Quantum *) NULL)
cache_info->metacontent=(void *) NULL;
if (cache_info->metacontent_extent != 0)
cache_info->metacontent=(void *) (cache_info->pixels+number_pixels*
- cache_info->pixel_channels);
+ cache_info->pixel_components);
return(cache_info->pixels);
}
\f
{
for (u=0; u < (ssize_t) width; u++)
{
- pixel.red+=GetPixelAlpha(image,r+u*GetPixelChannels(image));
- pixel.green+=GetPixelGreen(image,r+u*GetPixelChannels(image));
- pixel.blue+=GetPixelBlue(image,r+u*GetPixelChannels(image));
+ pixel.red+=GetPixelAlpha(image,r+u*GetPixelComponents(image));
+ pixel.green+=GetPixelGreen(image,r+u*GetPixelComponents(image));
+ pixel.blue+=GetPixelBlue(image,r+u*GetPixelComponents(image));
if (image->colorspace == CMYKColorspace)
- pixel.black+=GetPixelBlack(image,r+u*GetPixelChannels(image));
- pixel.alpha+=GetPixelAlpha(image,r+u*GetPixelChannels(image));
+ pixel.black+=GetPixelBlack(image,r+u*GetPixelComponents(image));
+ pixel.alpha+=GetPixelAlpha(image,r+u*GetPixelComponents(image));
}
- r+=(image->columns+width)*GetPixelChannels(image);
+ r+=(image->columns+width)*GetPixelComponents(image);
}
mean.red=(MagickRealType) (pixel.red/number_pixels+offset);
mean.green=(MagickRealType) (pixel.green/number_pixels+offset);
q);
SetPixelAlpha(threshold_image,(Quantum) (((MagickRealType)
GetPixelAlpha(threshold_image,q) <= mean.alpha) ? 0 : QuantumRange),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(threshold_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(threshold_image);
}
sync=SyncCacheViewAuthenticPixels(threshold_view,exception);
if (sync == MagickFalse)
GetPixelIntensity(image,q) <= threshold ? 0 : QuantumRange),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
GetPixelAlpha(image,q) >= threshold ? OpaqueAlpha :
TransparentAlpha),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
((MagickRealType) GetPixelAlpha(image,q) < threshold.alpha))
SetPixelAlpha(image,0,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlack(image,ClampToUnsignedQuantum(GetPixelBlack(image,q)),q);
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,ClampToUnsignedQuantum(GetPixelAlpha(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlack(image,RoundToQuantum((MagickRealType)
((l+(t>=threshold))*(MagickRealType) QuantumRange/levels.black)),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
index=(Quantum) (intensity <= threshold.black ? 0 : 1);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
SetPixelAlpha(image,(Quantum) ((MagickRealType)
GetPixelAlpha(image,q) <= threshold.alpha ? 0 : QuantumRange),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
((MagickRealType) GetPixelAlpha(image,q) > threshold.alpha))
SetPixelAlpha(image,QuantumRange,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlue(chop_image,GetPixelBlue(image,p),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(chop_image,GetPixelBlack(image,p),q);
- q+=GetPixelChannels(chop_image);
+ q+=GetPixelComponents(chop_image);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelRed(chop_image,GetPixelRed(image,p),q);
SetPixelGreen(chop_image,GetPixelGreen(image,p),q);
SetPixelBlue(chop_image,GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(chop_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(chop_image);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) images->columns; x++)
{
SetPixelRed(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
+ p+=GetPixelComponents(images);
+ q+=GetPixelComponents(cmyk_image);
}
if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) images->columns; x++)
{
SetPixelGreen(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
+ p+=GetPixelComponents(images);
+ q+=GetPixelComponents(cmyk_image);
}
if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) images->columns; x++)
{
SetPixelBlue(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
+ p+=GetPixelComponents(images);
+ q+=GetPixelComponents(cmyk_image);
}
if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) images->columns; x++)
{
SetPixelBlack(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
+ p+=GetPixelComponents(images);
+ q+=GetPixelComponents(cmyk_image);
}
if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
break;
SetPixelAlpha(crop_image,GetPixelAlpha(image,p),q);
if (image->storage_class == PseudoClass)
SetPixelIndex(crop_image,GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(crop_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(crop_image);
}
if (SyncCacheViewAuthenticPixels(crop_view,exception) == MagickFalse)
status=MagickFalse;
if (image->storage_class == PseudoClass)
SetPixelIndex(excerpt_image,GetPixelIndex(image,p),q);
SetPixelAlpha(excerpt_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(excerpt_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(excerpt_image);
}
if (SyncCacheViewAuthenticPixels(excerpt_view,exception) == MagickFalse)
status=MagickFalse;
if (image->storage_class == PseudoClass)
SetPixelIndex(flip_image,GetPixelIndex(image,p),q);
SetPixelAlpha(flip_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(flip_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(flip_image);
}
if (SyncCacheViewAuthenticPixels(flip_view,exception) == MagickFalse)
status=MagickFalse;
status=MagickFalse;
continue;
}
- q+=GetPixelChannels(flop_image)*flop_image->columns;
+ q+=GetPixelComponents(flop_image)*flop_image->columns;
for (x=0; x < (ssize_t) flop_image->columns; x++)
{
- q-=GetPixelChannels(flop_image);
+ q-=GetPixelComponents(flop_image);
SetPixelRed(flop_image,GetPixelRed(image,p),q);
SetPixelGreen(flop_image,GetPixelGreen(image,p),q);
SetPixelBlue(flop_image,GetPixelBlue(image,p),q);
SetPixelAlpha(flop_image,GetPixelAlpha(image,p),q);
if (image->storage_class == PseudoClass)
SetPixelIndex(flop_image,GetPixelIndex(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (SyncCacheViewAuthenticPixels(flop_view,exception) == MagickFalse)
status=MagickFalse;
if (destination->colorspace == CMYKColorspace)
SetPixelBlack(destination,GetPixelBlack(source,p),q);
SetPixelAlpha(destination,GetPixelAlpha(source,p),q);
- p+=GetPixelChannels(source);
- q+=GetPixelChannels(destination);
+ p+=GetPixelComponents(source);
+ q+=GetPixelComponents(destination);
}
sync=SyncCacheViewAuthenticPixels(destination_view,exception);
if (sync == MagickFalse)
SetPixelAlpha(splice_image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(splice_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(splice_image);
}
for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
- q+=GetPixelChannels(splice_image);
+ q+=GetPixelComponents(splice_image);
for ( ; x < (ssize_t) splice_image->columns; x++)
{
SetPixelRed(splice_image,GetPixelRed(image,p),q);
SetPixelAlpha(splice_image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(splice_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(splice_image);
}
if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
status=MagickFalse;
SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
if (image->matte != MagickFalse)
SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(splice_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(splice_image);
}
for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
- q+=GetPixelChannels(splice_image);
+ q+=GetPixelComponents(splice_image);
for ( ; x < (ssize_t) splice_image->columns; x++)
{
SetPixelRed(splice_image,GetPixelRed(image,p),q);
SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
if (image->matte != MagickFalse)
SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(splice_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(splice_image);
}
if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
status=MagickFalse;
if (image->colorspace == CMYKColorspace)
SetPixelBlack(transpose_image,GetPixelBlack(image,p),q);
SetPixelAlpha(transpose_image,GetPixelAlpha(image,p),q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(transpose_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(transpose_image);
}
if (SyncCacheViewAuthenticPixels(transpose_view,exception) == MagickFalse)
status=MagickFalse;
status=MagickFalse;
continue;
}
- q+=GetPixelChannels(transverse_image)*image->columns;
+ q+=GetPixelComponents(transverse_image)*image->columns;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q-=GetPixelChannels(transverse_image);
+ q-=GetPixelComponents(transverse_image);
SetPixelRed(transverse_image,GetPixelRed(image,p),q);
SetPixelGreen(transverse_image,GetPixelGreen(image,p),q);
SetPixelBlue(transverse_image,GetPixelBlue(image,p),q);
SetPixelAlpha(transverse_image,GetPixelAlpha(image,p),q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(transverse_image,GetPixelBlack(image,p),q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
if (sync == MagickFalse)
if (annotate_info->stencil == BackgroundStencil)
SetPixelAlpha(annotate_image,TransparentAlpha,q);
}
- q+=GetPixelChannels(annotate_image);
+ q+=GetPixelComponents(annotate_image);
}
if (SyncCacheViewAuthenticPixels(annotate_view,exception) == MagickFalse)
break;
(((size_t) color.green & 0xe0) >> 3) |
(((size_t) color.blue & 0xc0) >> 6));
*q++=(char) pixel;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
j++;
if (j == 16)
j=0;
SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
OpaqueStencil ? OpaqueAlpha : TransparentAlpha),q);
}
- q+=GetPixelChannels(draw_image);
+ q+=GetPixelComponents(draw_image);
}
if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
{
if (GetPixelAlpha(image,q) != TransparentAlpha)
SetPixelAlpha(draw_image,OpaqueAlpha,q);
- q+=GetPixelChannels(draw_image);
+ q+=GetPixelComponents(draw_image);
}
if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
index=(pixel >> blue_shift) & blue_mask;
SetPixelBlue(composite_image,
ScaleShortToQuantum(colors[index].blue),q);
- q+=GetPixelChannels(composite_image);
+ q+=GetPixelComponents(composite_image);
}
if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
color=(65535UL*color)/blue_mask;
SetPixelBlue(composite_image,
ScaleShortToQuantum((unsigned short) color),q);
- q+=GetPixelChannels(composite_image);
+ q+=GetPixelComponents(composite_image);
}
if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
SetPixelIndex(composite_image,index,q);
SetPixelPacket(composite_image,
composite_image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(composite_image);
+ q+=GetPixelComponents(composite_image);
}
if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
if (bit != 0)
*q=byte >> (8-bit);
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)];
*q++=(unsigned char) pixel;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
{
pixel=XGammaPixel(canvas,map_info,p);
*q++=(unsigned char) pixel;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
*q++=0;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
continue;
}
*q++=ScaleQuantumToChar((Quantum)
GetPixelRed(canvas,p));
*q++=0;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
}
}
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
*q++=0;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
continue;
}
*q++=ScaleQuantumToChar((Quantum)
GetPixelBlue(canvas,p));
*q++=0;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
}
}
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
bit=0;
byte=0;
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
if (bit != 0)
*q=byte >> (8-bit);
bit=0;
byte=0;
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
if (bit != 0)
*q=byte << (8-bit);
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
pixel=pixels[(ssize_t)
GetPixelIndex(canvas,p)];
*q++=(unsigned char) pixel;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
break;
}
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
{
pixel=XGammaPixel(canvas,map_info,p);
*q++=(unsigned char) pixel;
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
continue;
}
GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum)
GetPixelBlue(canvas,p));
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
}
}
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
continue;
}
GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum)
GetPixelRed(canvas,p));
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
}
}
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
q+=scanline_pad;
}
bit=0;
byte=0;
}
- p+=GetPixelChannels(canvas);
+ p+=GetPixelComponents(canvas);
}
if (bit != 0)
*q=byte << (8-bit);
map_info->blue_max),q);
SetPixelAlpha(affinity_image,
TransparentAlpha,q);
- q+=GetPixelChannels(affinity_image);
+ q+=GetPixelComponents(affinity_image);
}
(void) SyncAuthenticPixels(affinity_image,exception);
(void) RemapImage(resource_info->quantize_info,image,
for (x=(int) image->columns-1; x >= 0; x--)
{
diversity[(ssize_t) GetPixelIndex(image,p)].count++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
SetPixelRed(mask_image,GetPixelAlpha(mask_image,q),q);
SetPixelGreen(mask_image,GetPixelAlpha(mask_image,q),q);
SetPixelBlue(mask_image,GetPixelAlpha(mask_image,q),q);
- q+=GetPixelChannels(mask_image);
+ q+=GetPixelComponents(mask_image);
}
if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) iterator->region.width; x++)
{
PixelSetQuantumPixel(iterator->image,pixels,iterator->pixel_wands[x]);
- pixels+=GetPixelChannels(iterator->image);
+ pixels+=GetPixelComponents(iterator->image);
}
*number_wands=iterator->region.width;
return(iterator->pixel_wands);
for (x=0; x < (ssize_t) iterator->region.width; x++)
{
PixelSetQuantumPixel(iterator->image,pixels,iterator->pixel_wands[x]);
- pixels+=GetPixelChannels(iterator->image);
+ pixels+=GetPixelComponents(iterator->image);
}
*number_wands=iterator->region.width;
return(iterator->pixel_wands);
for (x=0; x < (ssize_t) iterator->region.width; x++)
{
PixelSetQuantumPixel(iterator->image,pixels,iterator->pixel_wands[x]);
- pixels+=GetPixelChannels(iterator->image);
+ pixels+=GetPixelComponents(iterator->image);
}
*number_wands=iterator->region.width;
return(iterator->pixel_wands);
for (x=0; x < (ssize_t) iterator->region.width; x++)
{
PixelGetQuantumPixel(iterator->image,iterator->pixel_wands[x],pixels);
- pixels+=GetPixelChannels(iterator->image);
+ pixels+=GetPixelComponents(iterator->image);
}
if (SyncCacheViewAuthenticPixels(iterator->view,exception) == MagickFalse)
{
for (x=0; x < (ssize_t) source->extent.width; x++)
{
PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
- pixels+=GetPixelChannels(source->image);
+ pixels+=GetPixelComponents(source->image);
}
duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->extent.x,y,
duplex->extent.width,1,duplex->exception);
{
PixelSetQuantumPixel(duplex->image,duplex_pixels,
duplex->pixel_wands[id][x]);
- duplex_pixels+=GetPixelChannels(duplex->image);
+ duplex_pixels+=GetPixelComponents(duplex->image);
}
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
destination->extent.x,y,destination->extent.width,1,exception);
{
PixelSetQuantumPixel(destination->image,destination_pixels,
destination->pixel_wands[id][x]);
- destination_pixels+=GetPixelChannels(destination->image);
+ destination_pixels+=GetPixelComponents(destination->image);
}
if (transfer(source,duplex,destination,y,id,context) == MagickFalse)
status=MagickFalse;
{
PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
destination_pixels);
- destination_pixels+=GetPixelChannels(destination->image);
+ destination_pixels+=GetPixelComponents(destination->image);
}
sync=SyncCacheViewAuthenticPixels(destination->view,exception);
if (sync == MagickFalse)
for (x=0; x < (ssize_t) source->extent.width; x++)
{
PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
- pixels+=GetPixelChannels(source->image);
+ pixels+=GetPixelComponents(source->image);
}
if (get(source,y,id,context) == MagickFalse)
status=MagickFalse;
{
PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
pixels);
- pixels+=GetPixelChannels(destination->image);
+ pixels+=GetPixelComponents(destination->image);
}
sync=SyncCacheViewAuthenticPixels(destination->view,exception);
if (sync == MagickFalse)
for (x=0; x < (ssize_t) source->extent.width; x++)
{
PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
- pixels+=GetPixelChannels(source->image);
+ pixels+=GetPixelComponents(source->image);
}
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
destination->extent.x,y,destination->extent.width,1,exception);
{
PixelSetQuantumPixel(destination->image,destination_pixels,
destination->pixel_wands[id][x]);
- destination_pixels+=GetPixelChannels(destination->image);
+ destination_pixels+=GetPixelComponents(destination->image);
}
if (transfer(source,destination,y,id,context) == MagickFalse)
status=MagickFalse;
{
PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
destination_pixels);
- destination_pixels+=GetPixelChannels(destination->image);
+ destination_pixels+=GetPixelComponents(destination->image);
}
sync=SyncCacheViewAuthenticPixels(destination->view,exception);
if (sync == MagickFalse)
for (x=0; x < (ssize_t) source->extent.width; x++)
{
PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
- pixels+=GetPixelChannels(source->image);
+ pixels+=GetPixelComponents(source->image);
}
if (update(source,y,id,context) == MagickFalse)
status=MagickFalse;
for (x=0; x < (ssize_t) source->extent.width; x++)
{
PixelGetQuantumPixel(source->image,source->pixel_wands[id][x],pixels);
- pixels+=GetPixelChannels(source->image);
+ pixels+=GetPixelComponents(source->image);
}
if (SyncCacheViewAuthenticPixels(source->view,exception) == MagickFalse)
{
{
if (GetPixelAlpha(image,q) == OpaqueAlpha)
SetPixelAlpha(composite_image,ClampToQuantum(opacity),q);
- q+=GetPixelChannels(composite_image);
+ q+=GetPixelComponents(composite_image);
}
sync=SyncCacheViewAuthenticPixels(composite_view,exception);
if (sync == MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
image->matte=MagickTrue;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
GetPixelAlpha(image,p) : OpaqueAlpha));
if (*q == 255)
*q=254;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
image->matte=MagickTrue;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
if (count != (ssize_t) (q-pixels))
SetPixelAlpha(image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
default:
break;
}
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,*p & 0x0f);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if ((image->columns % 2) != 0)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
{
index=ConstrainColormapIndex(image,*p++);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->matte != MagickFalse)
SetPixelAlpha(image,
ScaleShortToQuantum((unsigned short) opacity),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->matte != MagickFalse)
SetPixelAlpha(image,
ScaleShortToQuantum((unsigned short) opacity),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
nibble=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (nibble != 0)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for (x=3L*(ssize_t) image->columns; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
SetPixelBlue(image,ScaleCharToQuantum(pBits->rgbBlue),q);
SetPixelAlpha(image,OpaqueAlpha,q);
pBits++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
default:
break;
}
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlack(image,GetPixelBlack(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlack(image,GetPixelBlack(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if ((image->columns % 4) != 0)
{
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
if ((image->columns % 4) >= 1)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
if ((image->columns % 4) >= 2)
{
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
p++;
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if ((image->columns % 2) != 0)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
index=ConstrainColormapIndex(image,*p);
SetPixelIndex(image,index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
intensity=GetPixelRed(image,q);
if (intensity >= scale_intensity)
return(255);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if (intensity < ScaleCharToQuantum(2))
SetPixelGreen(image,QuantumRange,q);
SetPixelBlue(image,QuantumRange,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse) goto Finish;
}
default:
break;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,pixel.red,q);
SetPixelGreen(image,pixel.green,q);
SetPixelBlue(image,pixel.blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(((size_t) pixel.green) << 8)),q);
SetPixelBlue(image,(((size_t) GetPixelBlue(image,q)) |
(((size_t) pixel.blue) << 8)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ScaleCharToQuantum(colors.a[code]),q);
if (colors.a[code] && (image->matte == MagickFalse))
image->matte=MagickTrue; /* Correct matte */
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
}
else
alpha = 17U * (unsigned char) ((a1 >> (4*(4*(j-2)+i))) & 0xf);
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) alpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
}
else
alpha = (((6-alpha_code) * a0 + (alpha_code-1) * a1) / 5);
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) alpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
}
ReadBlobByte(image)),q);
if (dds_info->pixelformat.rgb_bitcount == 32)
(void) ReadBlobByte(image);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
ReadBlobByte(image)),q);
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
ReadBlobByte(image)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
(void) WriteBlobString(image,tuple);
(void) WriteBlobString(image,"\n");
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
{
index=(Quantum) ((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=(Quantum) ((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,*p & 0xf);
SetPixelIndex(image,index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 2) != 0)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
p++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
index=ConstrainColormapIndex(image,*p);
SetPixelIndex(image,index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleCharToQuantum(ScaleColor5to8(
(unsigned char) (word & 0x1f))),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for ( ; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
GetPixelBlue(image,p)) << 0)));
*q++=(unsigned char)(word & 0xff);
*q++=(unsigned char)(word >> 8);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for (x=(ssize_t) (2*image->columns); x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
if (image->matte != MagickFalse)
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (dib_info.bits_per_pixel == 24)
for (x=(ssize_t) (3*image->columns); x < (ssize_t) bytes_per_line; x++)
if (bit == 8)
bit=0;
byte>>=1;
- o+=GetPixelChannels(image);
+ o+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*s++),r);
SetPixelGreen(image,ScaleCharToQuantum(*s++),r);
SetPixelBlue(image,ScaleCharToQuantum(*s++),r);
- r+=GetPixelChannels(image);
+ r+=GetPixelComponents(image);
}
SyncAuthenticPixels(image,&image->exception);
SetPixelGreen(image,ScaleShortToQuantum(colors[index].green),q);
index=(pixel >> blue_shift) & blue_mask;
SetPixelBlue(image,ScaleShortToQuantum(colors[index].blue),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
color=(pixel >> blue_shift) & blue_mask;
color=(color*65535L)/blue_mask;
SetPixelBlue(image,ScaleShortToQuantum((unsigned short) color),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,(unsigned short) XGetPixel(dps_image,x,y),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,OpaqueAlpha,q);
if (XGetPixel(matte_image,x,y) == 0)
SetPixelAlpha(image,TransparentAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleCharToQuantum(pBits->rgbBlue),q);
SetPixelAlpha(image,OpaqueAlpha,q);
pBits++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
ImfHalfToFloat(scanline[x].b)),q);
SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
ImfHalfToFloat(scanline[x].a)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
else
ImfFloatToHalf(QuantumScale*GetPixelAlpha(image,p),&half_quantum);
scanline[x].a=half_quantum;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
ImfOutputSetFrameBuffer(file,scanline-(y*image->columns),1,image->columns);
ImfOutputWritePixels(file,1);
(pixel-fits_info.min_data)+fits_info.zero)),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*a),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
r+=red_component->columnStride;
g+=green_component->columnStride;
b+=blue_component->columnStride;
SetPixelAlpha(image,(ssize_t) index == opacity ? TransparentAlpha :
OpaqueAlpha,q);
x++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (x < (ssize_t) image->columns)
break;
if (y == 0)
{
waiting_code=(short) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for (x=(ssize_t) (y == 0 ? 1 : 0); x < (ssize_t) image->columns; x++)
{
Probe hash table.
*/
index=(Quantum) ((size_t) GetPixelIndex(image,p) & 0xff);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
k=(ssize_t) (((size_t) index << (MaxGIFBits-8))+waiting_code);
if (k >= MaxHashTable)
k-=MaxHashTable;
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(cube_size-1.0)),q);
SetPixelBlue(image,ClampToQuantum(QuantumRange*blue/(cube_size-1.0)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
SetPixelGreen(image,ClampToQuantum(QuantumRange*gamma*pixel[1]),q);
SetPixelBlue(image,ClampToQuantum(QuantumRange*gamma*pixel[2]),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
pixels[i++]=pixel[2];
pixels[i++]=pixel[3];
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if ((image->columns >= 8) && (image->columns <= 0x7ffff))
{
histogram[ScaleQuantumToChar(GetPixelGreen(image,p))].green++;
if ((GetPixelBlueTraits(image) & ActivePixelTrait) != 0)
histogram[ScaleQuantumToChar(GetPixelBlue(image,p))].blue++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
maximum=histogram[0].red;
SetPixelGreen(image,4*ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,4*ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
*q++=ScaleQuantumToChar(GetPixelRed(hrz_image,p))/4;
*q++=ScaleQuantumToChar(GetPixelGreen(hrz_image,p))/4;
*q++=ScaleQuantumToChar(GetPixelBlue(hrz_image,p))/4;
- p+=GetPixelChannels(hrz_image);
+ p+=GetPixelComponents(hrz_image);
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
if (count != (ssize_t) (q-pixels))
{
SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
0x00),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if ((image->columns % 8) != 0)
{
SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
0x00),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
for (x=0; x < (ssize_t) scanline_pad; x++)
{
byte=(size_t) ReadBlobByte(image);
SetPixelIndex(image,((byte >> 4) & 0xf),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
SetPixelIndex(image,((byte) & 0xf),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 2) != 0)
{
byte=(size_t) ReadBlobByte(image);
SetPixelIndex(image,((byte >> 4) & 0xf),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for (x=0; x < (ssize_t) scanline_pad; x++)
(void) ReadBlobByte(image);
{
byte=(size_t) ReadBlobByte(image);
SetPixelIndex(image,byte,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for (x=0; x < (ssize_t) scanline_pad; x++)
(void) ReadBlobByte(image);
byte=(size_t) ReadBlobByte(image);
byte|=(size_t) (ReadBlobByte(image) << 8);
SetPixelIndex(image,byte,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
for (x=0; x < (ssize_t) scanline_pad; x++)
(void) ReadBlobByte(image);
if (icon_info.bits_per_pixel == 32)
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
ReadBlobByte(image)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (icon_info.bits_per_pixel == 24)
for (x=0; x < (ssize_t) scanline_pad; x++)
{
SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
TransparentAlpha : OpaqueAlpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if ((image->columns % 8) != 0)
{
SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
TransparentAlpha : OpaqueAlpha),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if ((image->columns % 32) != 0)
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
*q++=(unsigned char) (byte << (8-bit));
nibble=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (nibble != 0)
*q++=(unsigned char) (byte << 4);
for (x=0; x < (ssize_t) next->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(next,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (next->previous == (Image *) NULL)
{
*q++=ScaleQuantumToChar(QuantumRange);
else
*q++=ScaleQuantumToChar(GetPixelAlpha(next,p));
- p+=GetPixelChannels(next);
+ p+=GetPixelComponents(next);
}
if (icon_info.bits_per_pixel == 24)
for (x=3L*(ssize_t) next->columns; x < (ssize_t) bytes_per_line; x++)
bit=0;
byte=0;
}
- p+=GetPixelChannels(next);
+ p+=GetPixelComponents(next);
}
if (bit != 0)
(void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
bit=0;
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
*q++=byte << (8-bit);
SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
SetPixelAlpha(image,ScaleAnyToQuantum((QuantumAny) pixel,range[3]),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny(
GetPixelAlpha(image,p),range));
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
if (image->colorspace != CMYKColorspace)
SetPixelBlue(image,ScaleShortToQuantum((unsigned char)
(GETJSAMPLE(*p++) << 4)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
SetPixelBlack(image,QuantumRange-ScaleShortToQuantum(
(unsigned char) (GETJSAMPLE(*p++) << 4)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
if (image->colorspace != CMYKColorspace)
SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
GETJSAMPLE(*p++)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
SetPixelBlack(image,QuantumRange-ScaleCharToQuantum(
(unsigned char) GETJSAMPLE(*p++)),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
*q++=(JSAMPLE) ScaleQuantumToChar(GetPixelRed(image,p));
*q++=(JSAMPLE) ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=(JSAMPLE) ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(JSAMPLE) ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
GetPixelBlue(image,p))));
*q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
GetPixelBlack(image,p))));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
{
*q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelIntensity(image,p)) >>
4);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
*q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelRed(image,p)) >> 4);
*q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelGreen(image,p)) >> 4);
*q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelBlue(image,p)) >> 4);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
GetPixelBlue(image,p)) >> 4));
*q++=(JSAMPLE) (4095-(ScaleQuantumToShort(
GetPixelBlack(image,p)) >> 4));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
byte<<=1;
if (bit == 8)
bit=0;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
byte<<=1;
if (bit == 8)
bit=0;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->colors > 256)
*q++=(unsigned char) ((size_t) GetPixelIndex(image,p) >> 8);
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
}
}
}
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (!SyncAuthenticPixels(image,exception))
return;
SetPixelGreen(matte_image,GetPixelAlpha(image,p),q);
SetPixelBlue(matte_image,GetPixelAlpha(image,p),q);
SetPixelAlpha(matte_image,OpaqueAlpha,q);
- p+=GetPixelChannels(image);
- q+=GetPixelChannels(matte_image);
+ p+=GetPixelComponents(image);
+ q+=GetPixelComponents(matte_image);
}
if (SyncAuthenticPixels(matte_image,exception) == MagickFalse)
break;
}
if (image->matte != MagickFalse)
SetPixelAlpha(image,pixel.alpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
break;
}
{
length=0;
SetPixelInfo(image,p,&pixel);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
for (x=1; x < (ssize_t) image->columns; x++)
{
SetPixelInfo(image,p,&target);
length=0;
}
SetPixelInfo(image,p,&pixel);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
q=PopRunlengthPacket(image,q,length,&pixel);
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
if (bit == 8)
bit=0;
byte>>=1;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
(void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
if (GetPixelAlpha(composite_image,q) == OpaqueAlpha)
SetPixelAlpha(composite_image,
ClampToQuantum(opacity),q);
- q+=GetPixelChannels(composite_image);
+ q+=GetPixelComponents(composite_image);
}
if (SyncCacheViewAuthenticPixels(composite_view,&exception) == MagickFalse)
break;
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
if (image->previous == (Image *) NULL)
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPixelInfo(image,&background,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit++;
if (bit == 8)
bit=0;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
(void) WriteBlobByte(image,byte);
SetPixelGreen(image,(QuantumRange*((color16 >> 5) & 0x3f))/0x3f,q);
SetPixelBlue(image,(QuantumRange*((color16 >> 0) & 0x1f))/0x1f,q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
ptr++;
bit=8-bits_per_pixel;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelIndex(image,FindColor(image,&image->colormap[(ssize_t)
GetPixelIndex(image,q)]),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
affinity_image=DestroyImage(affinity_image);
}
*ptr++=(unsigned char) ((color16 >> 8) & 0xff);
*ptr++=(unsigned char) (color16 & 0xff);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
else
byte=0x00;
bit=(unsigned char) (8-bits_per_pixel);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if ((image->columns % (8/bits_per_pixel)) != 0)
*ptr++=byte;
SetPixelRed(image,ScaleCharToQuantum(*yy++),q);
SetPixelGreen(image,ScaleCharToQuantum(*c1++),q);
SetPixelBlue(image,ScaleCharToQuantum(*c2++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*yy++),q);
SetPixelGreen(image,ScaleCharToQuantum(*c1++),q);
SetPixelBlue(image,ScaleCharToQuantum(*c2++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) (tile_image->columns << 1); x++)
{
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(tile_image,p)));
- p+=GetPixelChannels(tile_image);
+ p+=GetPixelComponents(tile_image);
}
q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
1,&downsample_image->exception);
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
*q++=byte << (8-bit);
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
if (image->matte != MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*r++),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
{
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
for (x=(ssize_t) pcx_info.bytes_per_line; x != 0; x--)
{
*q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (PCXWritePixels(&pcx_info,pcx_pixels,image) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
*q++=byte << (8-bit);
{
index=(Quantum) (*p & (0x80 >> bit) ? 0x00 : 0x01);
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
{
index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03));
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03));
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03));
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,3UL-((*p) & 0x03));
SetPixelIndex(image,index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f));
SetPixelIndex(image,index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f));
SetPixelIndex(image,index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
{
Ascii85Encode(image,ScaleQuantumToChar(
GetPixelIntensity(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(GetPixelBlack(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
if (image->colorspace == CMYKColorspace)
Ascii85Encode(image,ScaleQuantumToChar(
GetPixelBlack(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
Ascii85Encode(image,(unsigned char) GetPixelIndex(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (x=0; x < (ssize_t) tile_image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(tile_image,p));
- p+=GetPixelChannels(tile_image);
+ p+=GetPixelComponents(tile_image);
}
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
{
Ascii85Encode(image,
ScaleQuantumToChar(GetPixelIntensity(tile_image,p)));
- p+=GetPixelChannels(tile_image);
+ p+=GetPixelComponents(tile_image);
}
}
Ascii85Flush(image);
*q++=ScaleQuantumToChar(GetPixelBlue(tile_image,p));
if (image->colorspace == CMYKColorspace)
*q++=ScaleQuantumToChar(GetPixelBlack(tile_image,p));
- p+=GetPixelChannels(tile_image);
+ p+=GetPixelComponents(tile_image);
}
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
if (image->colorspace == CMYKColorspace)
Ascii85Encode(image,ScaleQuantumToChar(
GetPixelBlack(tile_image,p)));
- p+=GetPixelChannels(tile_image);
+ p+=GetPixelComponents(tile_image);
}
}
Ascii85Flush(image);
for (x=0; x < (ssize_t) tile_image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(tile_image,p);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
{
Ascii85Encode(image,(unsigned char)
GetPixelIndex(tile_image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
Ascii85Flush(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
#if defined(MAGICKCORE_ZLIB_DELEGATE)
for (x=0; x < (ssize_t) image->columns; x++)
{
Ascii85Encode(image,ScaleQuantumToChar(GetPixelAlpha(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
Ascii85Flush(image);
*/
for (y=0; y < (ssize_t) image->rows; y++)
{
- q=pixels+y*width*GetPixelChannels(image);;
+ q=pixels+y*width*GetPixelComponents(image);;
number_pixels=bytes_per_line;
count=ReadBlob(blob,(size_t) number_pixels,scanline);
(void) count;
}
}
p++;
- q+=GetPixelChannels(tile_image);
+ q+=GetPixelComponents(tile_image);
}
if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
scanline[x]=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
packed_scanline);
*blue++=ScaleQuantumToChar(GetPixelBlue(image,p));
if (image->matte != MagickFalse)
*opacity++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
count+=EncodeImage(image,scanline,bytes_per_line & 0x7FFF,
packed_scanline);
SetPixelGreen(image,green,q);
SetPixelRed(image,red,q);
length--;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,QuantumRange/2,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (ok_to_reduce == MagickFalse)
break;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (x >= 0)
break;
{
if (IsPixelGray(image,p) == MagickFalse)
return(MagickFalse);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
return(MagickTrue);
found_transparent_pixel = MagickTrue;
break;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) *p++),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
found_transparent_pixel = MagickTrue;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
SetPixelAlpha(image,ScaleShortToQuantum(quantum),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
found_transparent_pixel = MagickTrue;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
#else /* MAGICKCORE_QUANTUM_DEPTH == 8 */
if (GetPixelAlpha(image,q) != OpaqueAlpha)
found_transparent_pixel = MagickTrue;
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
#endif
}
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,*r++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
#endif
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
SetPixelRed(image,GetPixelRed(jng_image,s),q);
SetPixelGreen(image,GetPixelGreen(jng_image,s),q);
SetPixelBlue(image,GetPixelBlue(jng_image,s),q);
- q+=GetPixelChannels(image);
- s+=GetPixelChannels(jng_image);
+ q+=GetPixelComponents(image);
+ s+=GetPixelComponents(jng_image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (x=(ssize_t) image->columns; x != 0; x--)
{
SetPixelAlpha(image,GetPixelRed(jng_image,s),q);
- q+=GetPixelChannels(image);
- s+=GetPixelChannels(jng_image);
+ q+=GetPixelComponents(image);
+ s+=GetPixelComponents(jng_image);
}
else
SetPixelAlpha(image,GetPixelRed(jng_image,s),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
image->matte=MagickTrue;
- q+=GetPixelChannels(image);
- s+=GetPixelChannels(jng_image);
+ q+=GetPixelComponents(image);
+ s+=GetPixelComponents(jng_image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
GetPixelBlue(image,q)),q);
SetPixelAlpha(image,ScaleQuantumToShort(
GetPixelAlpha(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
+GetPixelAlpha(image,pixels)),q);
}
}
- n+=GetPixelChannels(image);
- q+=GetPixelChannels(large_image);
- pixels+=GetPixelChannels(image);
+ n+=GetPixelComponents(image);
+ q+=GetPixelComponents(large_image);
+ pixels+=GetPixelComponents(image);
} /* x */
if (SyncAuthenticPixels(large_image,exception) == 0)
*pixels;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- pixels=q+(image->columns-length)*GetPixelChannels(image);
- n=pixels+GetPixelChannels(image);
+ pixels=q+(image->columns-length)*GetPixelComponents(image);
+ n=pixels+GetPixelComponents(image);
for (x=(ssize_t) (image->columns-length);
x < (ssize_t) image->columns; x++)
+GetPixelAlpha(image,pixels)),q);
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
- n+=GetPixelChannels(image);
- p+=GetPixelChannels(image);
+ n+=GetPixelComponents(image);
+ p+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
GetPixelBlue(image,q)),q);
SetPixelAlpha(image,ScaleShortToQuantum(
GetPixelAlpha(image,q)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
ping_have_non_bw=MagickTrue;
break;
}
- s+=GetPixelChannels(image);
+ s+=GetPixelComponents(image);
}
}
{
ping_have_non_bw=MagickTrue;
}
- s+=GetPixelChannels(image);
+ s+=GetPixelComponents(image);
}
}
}
break;
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
else
SetPixelAlpha(image,OpaqueAlpha,r);
- r+=GetPixelChannels(image);
+ r+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
{
SetPixelRed(image,ScaleCharToQuantum(0x24),r);
}
- r+=GetPixelChannels(image);
+ r+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (ping_have_cheap_transparency == MagickFalse)
SetPixelRed(image,PNMInteger(image,2) == 0 ? QuantumRange : 0,q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
max_value)],q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,pixel.red,q);
SetPixelGreen(image,pixel.green,q);
SetPixelBlue(image,pixel.blue,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
sync=SyncAuthenticPixels(image,exception);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
if (image->depth == 16)
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
p=PushCharPixel(p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if ((type == BilevelType) || (type == GrayscaleType))
type=UndefinedType;
if ((type != BilevelType) && (type != GrayscaleType))
break;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
sync=SyncAuthenticPixels(image,exception);
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
break;
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
break;
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
p=PushShortPixel(MSBEndian,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
break;
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
pixel=ScaleQuantumToAny(GetPixelRed(image,p),range);
}
q=PopCharPixel((unsigned char) pixel,q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
pixel=ScaleQuantumToAny(GetPixelRed(image,p),range);
}
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
extent=(size_t) (q-pixels);
}
q=PopCharPixel((unsigned char) pixel,q);
pixel=ScaleQuantumToAny(GetPixelBlue(image,p),range);
q=PopCharPixel((unsigned char) pixel,q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
pixel=ScaleQuantumToAny(GetPixelBlue(image,p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
extent=(size_t) (q-pixels);
}
GetPixelAlpha(image,p),range);
q=PopCharPixel((unsigned char) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
GetPixelAlpha(image,p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
q=PopCharPixel((unsigned char) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
q=PopCharPixel((unsigned char) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
break;
}
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
length=0;
}
GetPixelPacket(image,p,&pixel);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
WriteRunlengthPacket(image,pixel,length,p);
if ((q-pixels+10) >= 80)
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
pixel.green=GetPixelGreen(image,p);
pixel.blue=GetPixelBlue(image,p);
pixel.alpha=GetPixelAlpha(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
q=PopHexPixel(hex_digits,(size_t) index,q);
q=PopHexPixel(hex_digits,(size_t)
(void) WriteBlob(image,q-pixels,pixels);
q=pixels;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
{
Ascii85Encode(image,ScaleQuantumToChar(
GetPixelIntensity(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
y,image->rows);
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelBlack(image,p));
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
y,image->rows);
Ascii85Encode(image,ScaleQuantumToChar(
GetPixelBlack(image,p)));
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
y,image->rows);
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
y,image->rows);
for (x=0; x < (ssize_t) image->columns; x++)
{
Ascii85Encode(image,(unsigned char) GetPixelIndex(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
y,image->rows);
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelBlack(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
{
*q++=code;
code='\0';
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
(0x01 << (7-bit))) != 0 ? 0 : 255,q);
SetPixelPacket(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
x++;
}
q--;
default:
break;
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(layer_info[i].image,(Quantum)
(QuantumScale*(GetPixelAlpha(layer_info[i].image,q))*
layer_info[i].opacity),q);
- q+=GetPixelChannels(layer_info[i].image);
+ q+=GetPixelComponents(layer_info[i].image);
}
if (SyncAuthenticPixels(layer_info[i].image,exception) == MagickFalse)
break;
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,OpaqueAlpha,q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
default:
break;
}
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelGreen(image,
GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelBlue(image,
GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelAlpha(image,
GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelGreen(image,
GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelBlue(image,
GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelAlpha(image,
GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelGreen(image,image->colormap[*p++].green,q);
SetPixelBlue(image,image->colormap[*p++].blue,q);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
break;
}
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
((*(p+6) << 8) | (*(p+7)))),q);
p+=8;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->matte != MagickFalse)
SetPixelAlpha(image,ScaleCharToQuantum(*(p+3)),q);
p+=4;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
quantum|=(*(p+1));
SetPixelIndex(image,quantum,q);
p+=8;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
{
SetPixelIndex(image,*p,q);
p+=4;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
*q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
else
for (x=0; x < (ssize_t) image->columns; x++)
*q++=ScaleQuantumToShort(GetPixelGreen(image,p));
*q++=ScaleQuantumToShort(GetPixelBlue(image,p));
*q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
for (bit=7; bit >= 0; bit--)
{
SetPixelIndex(image,((*p) & (0x01 << bit) ? 0x00 : 0x01),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
{
SetPixelIndex(image,(*p) & (0x01 << bit) ? 0x00 : 0x01,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 2) != 0)
p++;
SetPixelBlue(image,image->colormap[(ssize_t)
GetPixelBlue(image,q)].blue,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (((bytes_per_pixel*image->columns) % 2) != 0)
p++;
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (((bytes_per_pixel*image->columns) & 0x01) != 0)
*q++='\0'; /* pad scanline */
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
(void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
{
(void) WriteBlobByte(image,(unsigned char)
GetPixelIndex(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->columns & 0x01)
(void) WriteBlobByte(image,0); /* pad scanline */
#endif
CompositePixelOver(image,&fill_color,fill_color.alpha,q,
(MagickRealType) GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
trace->bitmap[i++]=GetPixelGreen(image,p);
trace->bitmap[i++]=GetPixelBlue(image,p);
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
splines=at_splines_new_full(trace,fitting_options,NULL,NULL,NULL,NULL,NULL,
" <circle cx=\"%.20g\" cy=\"%.20g\" r=\"1\" fill=\"%s\"/>\n",
(double) x,(double) y,tuple);
(void) WriteBlobString(image,message);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
(void) WriteBlobString(image,"</svg>\n");
SetPixelBlue(image,pixel.blue,q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,pixel.alpha,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (((unsigned char) (tga_info.attributes & 0xc0) >> 6) == 4)
offset+=4;
if (image->matte != MagickFalse)
*q++=(unsigned char) ScaleQuantumToChar(GetPixelAlpha(image,p));
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) WriteBlob(image,(size_t) (q-targa_pixels),targa_pixels);
if (image->previous == (Image *) NULL)
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
(TIFFGetA(*p))),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
TIFFGetA(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
else
for (column=columns_remaining; column > 0; column--)
SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
TIFFGetB(*p)),q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p+=columns-columns_remaining;
- q-=GetPixelChannels(image)*(image->columns+columns_remaining);
+ q-=GetPixelComponents(image)*(image->columns+columns_remaining);
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (const Quantum *) NULL)
break;
- q+=GetPixelChannels(image)*(image->columns-1);
+ q+=GetPixelComponents(image)*(image->columns-1);
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,ScaleCharToQuantum((unsigned char)
SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
TIFFGetA(*p)),q);
p--;
- q-=GetPixelChannels(image);;
+ q-=GetPixelComponents(image);;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
SetPixelIndex(image,(*p) & 0x0f,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
SetPixelIndex(image,(*p >> 4) & 0x0f,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 2) != 0)
{
SetPixelIndex(image,(*p >> 4) & 0x0f,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(1UL*word >> 5) & 0x1f)),q);
SetPixelRed(image,ScaleCharToQuantum(ScaleColor5to8(
(1UL*word >> 0) & 0x1f)),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPacket(image,&background_color,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
&image->exception);
(void) WriteBlobString(image,tuple);
(void) WriteBlobString(image,"\n");
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
if (matte_image[i] != 0)
transparent=MagickTrue;
i++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
}
if (matte_image[i] != 0)
SetPixelIndex(image,image->colors,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
}
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
(y == (ssize_t) (image->rows-1) ? ");" : ","));
SetPixelRed(image,ScaleCharToQuantum(y1),q);
SetPixelGreen(image,ScaleCharToQuantum(u),q);
SetPixelBlue(image,ScaleCharToQuantum(v),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
SetPixelRed(image,ScaleCharToQuantum(y2),q);
SetPixelGreen(image,ScaleCharToQuantum(u),q);
SetPixelBlue(image,ScaleCharToQuantum(v),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
pixel.green=(double) GetPixelGreen(uyvy_image,p);
pixel.blue=(double) GetPixelBlue(uyvy_image,p);
full=full == MagickFalse ? MagickTrue : MagickFalse;
- p+=GetPixelChannels(uyvy_image);
+ p+=GetPixelComponents(uyvy_image);
}
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
quantum|=0x01;
SetPixelIndex(image,quantum,q);
}
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
quantum=(size_t) GetPixelIndex(image,q);
quantum|=0x01;
SetPixelIndex(image,quantum,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,*p++,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(image,image->matte != MagickFalse ?
ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueAlpha,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->matte != MagickFalse)
*(q+number_pixels*3)=ScaleQuantumToChar((Quantum)
(GetPixelAlpha(image,p)));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
q++;
}
if (image->previous == (Image *) NULL)
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
*q++=byte >> (8-bit);
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIntensity(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (image->previous == (Image *) NULL)
{
bit++;
if (bit == 8)
bit=0;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
(void) WriteBlobByte(image,byte);
SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
if (GetPixelAlpha(image,q) != OpaqueAlpha)
image->matte=MagickTrue;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->matte != MagickFalse)
*q++=ScaleQuantumToChar((Quantum) (image->matte != MagickFalse ?
GetPixelAlpha(image,p) : OpaqueAlpha));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
p++;
}
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 4) != 0)
{
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
if ((image->columns % 4) >= 1)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
if ((image->columns % 4) >= 2)
{
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
p++;
index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
index=ConstrainColormapIndex(image,(*p) & 0x0f);
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if ((image->columns % 2) != 0)
{
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
p++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelRed(image,ScaleCharToQuantum(*p++),q);
SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (!SyncAuthenticPixels(image,exception))
break;
byte>>=1;
if (bit == 8)
bit=0;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
bit=0;
byte=0;
}
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
if (bit != 0)
{
SetPixelPacket(image,&pixel,q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,pixel.black,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
SetPixelAlpha(tile_image,ScaleCharToQuantum((unsigned char)
inLayerInfo->alpha),q);
graydata++;
- q+=GetPixelChannels(tile_image);
+ q+=GetPixelComponents(tile_image);
}
}
else
SetPixelAlpha(tile_image,xcfdata->alpha == 0U ? OpaqueAlpha :
ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);
xcfdata++;
- q+=GetPixelChannels(tile_image);
+ q+=GetPixelComponents(tile_image);
}
}
if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
break;
}
}
- q+=GetPixelChannels(tile_image);
+ q+=GetPixelComponents(tile_image);
}
}
else
break;
}
}
- q+=GetPixelChannels(tile_image);
+ q+=GetPixelComponents(tile_image);
}
}
}
SetPixelIndex(image,j,r);
SetPixelPacket(image,image->colormap+j,r);
p+=width;
- r+=GetPixelChannels(image);
+ r+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
transparent=MagickTrue;
else
SetPixelAlpha(picon,OpaqueAlpha,q);
- q+=GetPixelChannels(picon);
+ q+=GetPixelComponents(picon);
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
{
if (GetPixelAlpha(image,q) == (Quantum) TransparentAlpha)
SetPixelIndex(picon,picon->colors,q);
- q+=GetPixelChannels(picon);
+ q+=GetPixelComponents(picon);
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
y == (ssize_t) (picon->rows-1) ? "" : ",");
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
(y == (ssize_t) (image->rows-1) ? "" : ","));
index=(Quantum) ((pixel >> blue_shift) & blue_mask);
SetPixelBlue(image,ScaleShortToQuantum(
colors[(ssize_t) index].blue),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
color=(color*65535UL)/blue_mask;
SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
color),q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
(int) y));
SetPixelIndex(image,index,q);
SetPixelPacket(image,image->colormap+(ssize_t) index,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=(unsigned char) GetPixelIndex(image,p);
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
else
*q++=ScaleQuantumToChar(GetPixelRed(image,p));
*q++=ScaleQuantumToChar(GetPixelGreen(image,p));
*q++=ScaleQuantumToChar(GetPixelBlue(image,p));
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
for (x=0; x < (ssize_t) scanline_pad; x++)
*q++='\0';
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
if (image->matte != MagickFalse)
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
default:
break;
}
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(image,GetPixelRed(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
- p+=GetPixelChannels(canvas_image);
- q+=GetPixelChannels(image);
+ p+=GetPixelComponents(canvas_image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
SetPixelGreen(image,0,q);
SetPixelBlue(image,0,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
SetPixelGreen(image,0,q);
SetPixelBlue(image,0,q);
if (quantum == 1)
p+=2;
}
chroma_pixels++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
else
}
SetPixelGreen(image,0,q);
SetPixelBlue(image,0,q);
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
p+=2;
}
SetPixelBlue(chroma_image,0,q);
- q+=GetPixelChannels(chroma_image);
+ q+=GetPixelComponents(chroma_image);
}
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
break;
*(p+1)),q);
p+=2;
}
- q+=GetPixelChannels(chroma_image);
+ q+=GetPixelComponents(chroma_image);
}
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
break;
SetPixelGreen(image,GetPixelGreen(image,chroma_pixels),q);
SetPixelBlue(image,GetPixelBlue(image,chroma_pixels),q);
chroma_pixels++;
- q+=GetPixelChannels(image);
+ q+=GetPixelComponents(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
GetPixelGreen(yuv_image,s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelRed(yuv_image,p)));
- p+=GetPixelChannels(yuv_image);
+ p+=GetPixelComponents(yuv_image);
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelBlue(yuv_image,s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelGreen(yuv_image,s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelRed(yuv_image,p)));
- p+=GetPixelChannels(yuv_image);
+ p+=GetPixelComponents(yuv_image);
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelBlue(yuv_image,s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelRed(yuv_image,p)));
}
- p+=GetPixelChannels(yuv_image);
+ p+=GetPixelComponents(yuv_image);
s++;
x++;
}
else
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelRed(yuv_image,p)));
- p+=GetPixelChannels(yuv_image);
+ p+=GetPixelComponents(yuv_image);
}
if (image->previous == (Image *) NULL)
{
else
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelGreen(chroma_image,p)));
- p+=GetPixelChannels(chroma_image);
+ p+=GetPixelComponents(chroma_image);
}
}
if (image->previous == (Image *) NULL)
else
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelBlue(chroma_image,p)));
- p+=GetPixelChannels(chroma_image);
+ p+=GetPixelComponents(chroma_image);
}
}
if (image->previous == (Image *) NULL)
saturation_sum_x3+=saturation*saturation*saturation;
saturation_sum_x4+=saturation*saturation*saturation*saturation;
area++;
- p+=GetPixelChannels(image);
+ p+=GetPixelComponents(image);
}
}
image_view=DestroyCacheView(image_view);
projects / imagemagick / commitdiff