// Set pixel value
Quantum *pixel = pixels.get(x_, y_, 1, 1 );
PixelInfo packet = color_;
- MagickCore::SetPixelPixelInfo(constImage(),&packet,pixel);
+ MagickCore::SetPixelInfoPixel(constImage(),&packet,pixel);
// Tell ImageMagick that pixels have been updated
pixels.sync();
image_view=DestroyCacheView(image_view);
return(bounds);
}
- SetPixelInfo(image,p,&target[0]);
+ GetPixelInfoPixel(image,p,&target[0]);
GetPixelInfo(image,&target[1]);
p=GetCacheViewVirtualPixels(image_view,(ssize_t) image->columns-1,0,1,1,
exception);
- SetPixelInfo(image,p,&target[1]);
+ GetPixelInfoPixel(image,p,&target[1]);
GetPixelInfo(image,&target[2]);
p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-1,1,1,
exception);
- SetPixelInfo(image,p,&target[2]);
+ GetPixelInfoPixel(image,p,&target[2]);
status=MagickTrue;
GetPixelInfo(image,&zero);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if ((x < bounding_box.x) &&
(IsFuzzyEquivalencePixelInfo(&pixel,&target[0]) == MagickFalse))
bounding_box.x=x;
GetPixelInfo(image,pixel);
if (p == (const Quantum *) NULL)
return(MagickFalse);
- SetPixelInfo(image,p,pixel);
+ GetPixelInfoPixel(image,p,pixel);
return(MagickTrue);
}
\f
{
if ((p == (const Quantum *) NULL) || (r == (const Quantum *) NULL))
break;
- SetPixelInfo(image,p,&alpha);
- SetPixelInfo(image,q,&beta);
+ GetPixelInfoPixel(image,p,&alpha);
+ GetPixelInfoPixel(image,q,&beta);
MagickPixelCompositeMask(&beta,(MagickRealType) GetPixelIntensity(image,r),
&alpha,alpha.alpha,&beta);
SetPixelRed(image,ClampToQuantum(beta.red),q);
for (i=0; i < (ssize_t) target_image->columns; i++)
{
p=GetCacheViewVirtualPixels(image_view,x+i,y+j,1,1,exception);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
q=GetCacheViewVirtualPixels(target_view,i,j,1,1,exception);
- SetPixelInfo(image,q,&target);
+ GetPixelInfoPixel(image,q,&target);
if (IsFuzzyEquivalencePixelInfo(&pixel,&target) == MagickFalse)
break;
}
if (index < 0)
index+=(ssize_t) image->colors;
SetPixelIndex(image,(Quantum) index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
{
index=(Quantum) pixels[(ssize_t) GetPixelIndex(image,q)];
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
ConvertRGBToCMYK(&pixel);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
ConvertCMYKToRGB(&pixel);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
difference=MagickTrue;
}
if (difference == MagickFalse)
- SetPixelPixelInfo(highlight_image,&lowlight,r);
+ SetPixelInfoPixel(highlight_image,&lowlight,r);
else
- SetPixelPixelInfo(highlight_image,&highlight,r);
+ SetPixelInfoPixel(highlight_image,&highlight,r);
p+=GetPixelChannels(image);
q+=GetPixelChannels(reconstruct_image);
r+=GetPixelChannels(highlight_image);
GetPixelGreen(composite_image,p));
(void) ResamplePixelColor(resample_filter,(double) x_offset+x,
(double) y_offset+y,&pixel);
- SetPixelPixelInfo(destination_image,&pixel,q);
+ SetPixelInfoPixel(destination_image,&pixel,q);
p+=GetPixelChannels(composite_image);
q+=GetPixelChannels(destination_image);
}
pixel.alpha=(MagickRealType) QuantumRange*(1.0-(1.0-QuantumScale*
pixel.alpha)*(1.0-QuantumScale*
GetPixelAlpha(composite_image,p)));
- SetPixelPixelInfo(destination_image,&pixel,q);
+ SetPixelInfoPixel(destination_image,&pixel,q);
p+=GetPixelChannels(composite_image);
q+=GetPixelChannels(destination_image);
}
{
index=(Quantum) (*p++);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
{
if (x < y)
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
else
- SetPixelPixelInfo(frame_image,&accentuate,q);
+ SetPixelInfoPixel(frame_image,&accentuate,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
width=image->columns+((size_t) frame_info->inner_bevel << 1)-
for (x=0; x < (ssize_t) width; x++)
{
if (x < y)
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
else
- SetPixelPixelInfo(frame_image,&trough,q);
+ SetPixelInfoPixel(frame_image,&trough,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(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);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
/*
(image->matte != MagickFalse)))
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(frame_image,&interior,q);
+ SetPixelInfoPixel(frame_image,&interior,q);
q+=GetPixelChannels(frame_image);
}
else
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(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);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < y; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
else
- SetPixelPixelInfo(frame_image,&accentuate,q);
+ SetPixelInfoPixel(frame_image,&accentuate,q);
q+=GetPixelChannels(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);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
+ SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
{
for (x=0; x < y; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
if (x >= (ssize_t) (frame_image->columns-y))
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelInfoPixel(frame_image,&shadow,q);
else
- SetPixelPixelInfo(frame_image,&trough,q);
+ SetPixelInfoPixel(frame_image,&trough,q);
q+=GetPixelChannels(frame_image);
}
}
break;
for (j=0; j < (int) width; j++)
{
- SetPixelPixelInfo(image,&pixel,s);
+ SetPixelInfoPixel(image,&pixel,s);
s+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
if ( validity <= 0.0 ) {
/* result of distortion is an invalid pixel - don't resample */
- SetPixelPixelInfo(distort_image,&invalid,q);
+ SetPixelInfoPixel(distort_image,&invalid,q);
}
else {
/* resample the source image to find its correct color */
CompositePixelInfoBlend(&pixel,validity,&invalid,(1.0-validity),
&pixel);
}
- SetPixelPixelInfo(distort_image,&pixel,q);
+ SetPixelInfoPixel(distort_image,&pixel,q);
}
q+=GetPixelChannels(distort_image);
}
GetPixelInfo(sparse_image,&pixel);
for (i=0; i < (ssize_t) image->columns; i++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
switch (sparse_method)
{
case BarycentricColorInterpolate:
if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
(image->matte != MagickFalse))
pixel.alpha*=QuantumRange;
- SetPixelPixelInfo(sparse_image,&pixel,q);
+ SetPixelInfoPixel(sparse_image,&pixel,q);
q+=GetPixelChannels(sparse_image);
}
sync=SyncCacheViewAuthenticPixels(sparse_view,exception);
inverse_affine.ty;
(void) InterpolatePixelInfo(source,source_view,UndefinedInterpolatePixel,
point.x,point.y,&pixel,exception);
- SetPixelInfo(image,q,&composite);
+ GetPixelInfoPixel(image,q,&composite);
CompositePixelInfoOver(&pixel,pixel.alpha,&composite,composite.alpha,
&composite);
- SetPixelPixelInfo(image,&composite,q);
+ SetPixelInfoPixel(image,&composite,q);
x_offset++;
q+=GetPixelChannels(image);
}
offset/=length;
for (x=bounding_box.x; x < (ssize_t) bounding_box.width; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
switch (gradient->spread)
{
case UndefinedSpread:
}
CompositePixelInfoOver(&composite,composite.alpha,&pixel,pixel.alpha,
&pixel);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
(y == (ssize_t) ceil(primitive_info->point.y-0.5)))
{
(void) GetStrokeColor(draw_info,x,y,&pixel,exception);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
}
q+=GetPixelChannels(image);
}
break;
GetPixelInfo(image,&pixel);
(void) GetFillColor(draw_info,x,y,&pixel,exception);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
(void) SyncCacheViewAuthenticPixels(image_view,exception);
break;
}
continue;
}
(void) GetFillColor(draw_info,x,y,&pixel,exception);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
for (x=0; x < (ssize_t) image->columns; x++)
{
(void) GetFillColor(draw_info,x,y,&pixel,exception);
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
q+=GetPixelChannels(image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
index=MaxTreeDepth-1;
for (level=1; level < MaxTreeDepth; level++)
{
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
id=ColorToNodeId(image,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
{
index=MaxTreeDepth-1;
for (level=1; level < MaxTreeDepth; level++)
{
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
id=ColorToNodeId(image,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
{
index=MaxTreeDepth-1;
for (level=1; level < MaxTreeDepth; level++)
{
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
id=ColorToNodeId(image,&pixel,index);
if (node_info->child[id] == (NodeInfo *) NULL)
{
pixel;
GetPixelInfo(image,&pixel);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
(void) QueryColorname(image,&pixel,SVGCompliance,tuple,
exception);
(void) FormatLocaleFile(file," Alpha: %s ",tuple);
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,background,q);
+ SetPixelInfoPixel(image,background,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
for (x=0; x < (ssize_t) image->columns; x++)
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
if (image->background_color.alpha != OpaqueAlpha)
image->matte=MagickTrue;
background=image->background_color;
- SetPacketPixelInfo(image,&background,&pixel);
+ SetPixelInfo(image,&background,&pixel);
/*
Set image background color.
*/
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,color,q);
+ SetPixelInfoPixel(image,color,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
{
index=PushColormapIndex(image,(size_t) GetPixelIndex(image,q),
&range_exception);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
for (y=0; y < (ssize_t) image1->rows; y++)
{
- SetPixelInfo(image1,p,&pixel1);
- SetPixelInfo(image2,q,&pixel2);
+ GetPixelInfoPixel(image1,p,&pixel1);
+ GetPixelInfoPixel(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
p+=GetPixelChannels(image1);
break;
for (y=0; y < (ssize_t) image1->rows; y++)
{
- SetPixelInfo(image1,p,&pixel1);
- SetPixelInfo(image2,q,&pixel2);
+ GetPixelInfoPixel(image1,p,&pixel1);
+ GetPixelInfoPixel(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
p+=GetPixelChannels(image1);
break;
for (x=0; x < (ssize_t) image1->columns; x++)
{
- SetPixelInfo(image1,p,&pixel1);
- SetPixelInfo(image2,q,&pixel2);
+ GetPixelInfoPixel(image1,p,&pixel1);
+ GetPixelInfoPixel(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
p+=GetPixelChannels(image1);
break;
for (x=0; x < (ssize_t) image1->columns; x++)
{
- SetPixelInfo(image1,p,&pixel1);
- SetPixelInfo(image2,q,&pixel2);
+ GetPixelInfoPixel(image1,p,&pixel1);
+ GetPixelInfoPixel(image2,q,&pixel2);
if (ComparePixels(method,&pixel1,&pixel2))
break;
p+=GetPixelChannels(image1);
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
-/* #undef BUILD_MODULES */
+#ifndef MAGICKCORE_BUILD_MODULES
+#define MAGICKCORE_BUILD_MODULES 1
+#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
#endif
/* Define if you have FFTW library */
-/* #undef FFTW_DELEGATE */
+#ifndef MAGICKCORE_FFTW_DELEGATE
+#define MAGICKCORE_FFTW_DELEGATE 1
+#endif
/* Location of filter modules */
#ifndef MAGICKCORE_FILTER_PATH
#endif
/* Define to 1 if you have the <CL/cl.h> header file. */
-/* #undef HAVE_CL_CL_H */
+#ifndef MAGICKCORE_HAVE_CL_CL_H
+#define MAGICKCORE_HAVE_CL_CL_H 1
+#endif
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#endif
/* Define if you have the <lcms2.h> header file. */
-#ifndef MAGICKCORE_HAVE_LCMS2_H
-#define MAGICKCORE_HAVE_LCMS2_H 1
-#endif
+/* #undef HAVE_LCMS2_H */
/* Define if you have the <lcms2/lcms2.h> header file. */
/* #undef HAVE_LCMS2_LCMS2_H */
/* Define if you have the <lcms.h> header file. */
-/* #undef HAVE_LCMS_H */
+#ifndef MAGICKCORE_HAVE_LCMS_H
+#define MAGICKCORE_HAVE_LCMS_H 1
+#endif
/* Define if you have the <lcms/lcms.h> header file. */
/* #undef HAVE_LCMS_LCMS_H */
#endif
/* Define if you have JBIG library */
-/* #undef JBIG_DELEGATE */
+#ifndef MAGICKCORE_JBIG_DELEGATE
+#define MAGICKCORE_JBIG_DELEGATE 1
+#endif
/* Define if you have JPEG version 2 "Jasper" library */
#ifndef MAGICKCORE_JP2_DELEGATE
#endif
/* Define if you have LQR library */
-/* #undef LQR_DELEGATE */
+#ifndef MAGICKCORE_LQR_DELEGATE
+#define MAGICKCORE_LQR_DELEGATE 1
+#endif
/* Define if using libltdl to support dynamically loadable modules */
#ifndef MAGICKCORE_LTDL_DELEGATE
/* Define to the system default library search path. */
#ifndef MAGICKCORE_LT_DLSEARCH_PATH
-#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/lib/llvm:/usr/lib64/llvm:/usr/lib64/mysql:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib64/tracker-0.12:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
+#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/R/lib:/usr/lib64/atlas:/opt/modules/pkg/intel/f77/10.0.025/lib:/opt/intel/lib/intel64:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/octave/3.4.2:/usr/lib64/qt-3.3/lib:/usr/lib64/tracker-0.12:/usr/lib64/xulrunner-2"
#endif
/* The archive extension */
/* #undef NO_MINUS_C_MINUS_O */
/* Define if you have OPENEXR library */
-/* #undef OPENEXR_DELEGATE */
+#ifndef MAGICKCORE_OPENEXR_DELEGATE
+#define MAGICKCORE_OPENEXR_DELEGATE 1
+#endif
/* Name of package */
#ifndef MAGICKCORE_PACKAGE
#endif
/* Define if you have RSVG library */
-/* #undef RSVG_DELEGATE */
+#ifndef MAGICKCORE_RSVG_DELEGATE
+#define MAGICKCORE_RSVG_DELEGATE 1
+#endif
/* Define to the type of arg 1 for `select'. */
#ifndef MAGICKCORE_SELECT_TYPE_ARG1
#endif
/* Define if you have WEBP library */
-/* #undef WEBP_DELEGATE */
+#ifndef MAGICKCORE_WEBP_DELEGATE
+#define MAGICKCORE_WEBP_DELEGATE 1
+#endif
/* Define to use the Windows GDI32 library */
/* #undef WINGDI32_DELEGATE */
/* #undef WITH_DMALLOC */
/* Define if you have WMF library */
-/* #undef WMF_DELEGATE */
+#ifndef MAGICKCORE_WMF_DELEGATE
+#define MAGICKCORE_WMF_DELEGATE 1
+#endif
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
/* #undef _MINIX */
/* Define this for the OpenCL Accelerator */
-/* #undef _OPENCL */
+#ifndef MAGICKCORE__OPENCL
+#define MAGICKCORE__OPENCL 1
+#endif
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
/* Starting Defaults */
GetPixelInfo(image,&result);
- SetPixelInfo(image,q,&result);
+ GetPixelInfoPixel(image,q,&result);
if ( method != VoronoiMorphology )
result.alpha = QuantumRange - result.alpha;
if ( IsNan(*k) ) continue;
if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ GetPixelInfoPixel(image,k_pixels+u*GetPixelChannels(image),
&result);
result.alpha += *k;
}
if ( IsNan(*k) ) continue;
if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ GetPixelInfoPixel(image,k_pixels+u*GetPixelChannels(image),
&result);
result.alpha += *k;
}
/* Assign the resulting pixel values - Clamping Result */
switch ( method ) {
case VoronoiMorphology:
- SetPixelPixelInfo(image,&result,q);
+ SetPixelInfoPixel(image,&result,q);
break;
default:
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
/* Default - previously modified pixel */
GetPixelInfo(image,&result);
- SetPixelInfo(image,q,&result);
+ GetPixelInfoPixel(image,q,&result);
if ( method != VoronoiMorphology )
result.alpha = QuantumRange - result.alpha;
if ( IsNan(*k) ) continue;
if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ GetPixelInfoPixel(image,k_pixels+u*GetPixelChannels(image),
&result);
result.alpha += *k;
}
if ( IsNan(*k) ) continue;
if( result.alpha > (*k)+GetPixelAlpha(image,k_pixels+u*GetPixelChannels(image)) )
{
- SetPixelInfo(image,k_pixels+u*GetPixelChannels(image),
+ GetPixelInfoPixel(image,k_pixels+u*GetPixelChannels(image),
&result);
result.alpha += *k;
}
/* Assign the resulting pixel values - Clamping Result */
switch ( method ) {
case VoronoiMorphology:
- SetPixelPixelInfo(image,&result,q);
+ SetPixelInfoPixel(image,&result,q);
break;
default:
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
break;
SetPixelAlpha(floodplane_image,TransparentAlpha,q);
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
break;
SetPixelAlpha(floodplane_image,TransparentAlpha,q);
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
break;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
break;
p+=GetPixelChannels(image);
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
{
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
SetPixelAlpha(image,opacity,q);
q+=GetPixelChannels(image);
GetPixelInfo(image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,q,&pixel);
+ GetPixelInfoPixel(image,q,&pixel);
match=((pixel.red >= low->red) && (pixel.red <= high->red) &&
(pixel.green >= low->green) && (pixel.green <= high->green) &&
(pixel.blue >= low->blue) && (pixel.blue <= high->blue)) ? MagickTrue :
#undef index
-static inline Quantum GetPixelAlpha(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelAlpha(const Image *restrict image,
+ const Quantum *restrict pixel)
{
+ if (image->channel_map[AlphaPixelChannel].traits == UndefinedPixelTrait)
+ return(OpaqueAlpha);
return(pixel[image->channel_map[AlphaPixelChannel].channel]);
}
-static inline PixelTrait GetPixelAlphaTraits(const Image *image)
+static inline PixelTrait GetPixelAlphaTraits(const Image *restrict image)
{
return(image->channel_map[AlphaPixelChannel].traits);
}
-static inline Quantum GetPixelBlack(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelBlack(const Image *restrict image,
+ const Quantum *restrict pixel)
{
+ if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
+ return(0);
return(pixel[image->channel_map[BlackPixelChannel].channel]);
}
-static inline PixelTrait GetPixelBlackTraits(const Image *image)
+static inline PixelTrait GetPixelBlackTraits(const Image *restrict image)
{
return(image->channel_map[BlackPixelChannel].traits);
}
-static inline Quantum GetPixelBlue(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelBlue(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[BluePixelChannel].channel]);
}
-static inline PixelTrait GetPixelBlueTraits(const Image *image)
+static inline PixelTrait GetPixelBlueTraits(const Image *restrict image)
{
return(image->channel_map[BluePixelChannel].traits);
}
-static inline Quantum GetPixelCb(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelCb(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[CbPixelChannel].channel]);
}
-static inline PixelTrait GetPixelCbTraits(const Image *image)
+static inline PixelTrait GetPixelCbTraits(const Image *restrict image)
{
return(image->channel_map[CbPixelChannel].traits);
}
-static inline Quantum GetPixelChannel(const Image *image,
- const PixelChannel channel,const Quantum *pixel)
+static inline Quantum GetPixelChannel(const Image *restrict image,
+ const PixelChannel channel,const Quantum *restrict pixel)
{
+ if (image->channel_map[channel].traits == UndefinedPixelTrait)
+ return(0);
return(pixel[image->channel_map[channel].channel]);
}
-static inline PixelChannel GetPixelChannelMapChannel(const Image *image,
- const PixelChannel channel)
+static inline PixelChannel GetPixelChannelMapChannel(
+ const Image *restrict image,const PixelChannel channel)
{
return(image->channel_map[channel].channel);
}
-static inline PixelTrait GetPixelChannelMapTraits(const Image *image,
+static inline PixelTrait GetPixelChannelMapTraits(const Image *restrict image,
const PixelChannel channel)
{
return(image->channel_map[channel].traits);
}
-static inline size_t GetPixelChannels(const Image *image)
+static inline size_t GetPixelChannels(const Image *restrict image)
{
return(image->number_channels);
}
-static inline Quantum GetPixelCr(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelCr(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[CrPixelChannel].channel]);
}
-static inline PixelTrait GetPixelCrTraits(const Image *image)
+static inline PixelTrait GetPixelCrTraits(const Image *restrict image)
{
return(image->channel_map[CrPixelChannel].traits);
}
-static inline Quantum GetPixelCyan(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelCyan(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[CyanPixelChannel].channel]);
}
-static inline PixelTrait GetPixelCyanTraits(const Image *image)
+static inline PixelTrait GetPixelCyanTraits(const Image *restrict image)
{
return(image->channel_map[CyanPixelChannel].traits);
}
-static inline Quantum GetPixelGray(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelGray(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[GrayPixelChannel].channel]);
}
-static inline PixelTrait GetPixelGrayTraits(const Image *image)
+static inline PixelTrait GetPixelGrayTraits(const Image *restrict image)
{
return(image->channel_map[GrayPixelChannel].traits);
}
-static inline Quantum GetPixelGreen(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelGreen(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[GreenPixelChannel].channel]);
}
-static inline PixelTrait GetPixelGreenTraits(const Image *image)
+static inline PixelTrait GetPixelGreenTraits(const Image *restrict image)
{
return(image->channel_map[GreenPixelChannel].traits);
}
-static inline Quantum GetPixelIndex(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelIndex(const Image *restrict image,
+ const Quantum *restrict pixel)
{
+ if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
+ return(0);
return(pixel[image->channel_map[IndexPixelChannel].channel]);
}
-static inline PixelTrait GetPixelIndexTraits(const Image *image)
+static inline PixelTrait GetPixelIndexTraits(const Image *restrict image)
{
return(image->channel_map[IndexPixelChannel].traits);
}
-static inline Quantum GetPixelInfoIntensity(const PixelInfo *pixel_info)
+static inline Quantum GetPixelInfoIntensity(
+ const PixelInfo *restrict pixel_info)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*
#endif
}
-static inline Quantum GetPixelInfoLuminance(const PixelInfo *pixel_info)
+static inline Quantum GetPixelInfoLuminance(
+ const PixelInfo *restrict pixel_info)
{
Quantum
luminance;
return((Quantum) luminance);
}
-static inline Quantum GetPixelMagenta(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelMagenta(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[MagentaPixelChannel].channel]);
}
-static inline PixelTrait GetPixelMagentaTraits(const Image *image)
+static inline PixelTrait GetPixelMagentaTraits(const Image *restrict image)
{
return(image->channel_map[MagentaPixelChannel].traits);
}
-static inline size_t GetPixelMetaChannels(const Image *image)
+static inline size_t GetPixelMetaChannels(const Image *restrict image)
{
return(image->number_meta_channels);
}
-static inline size_t GetPixelMetacontentExtent(const Image *image)
+static inline size_t GetPixelMetacontentExtent(const Image *restrict image)
{
return(image->metacontent_extent);
}
-static inline Quantum GetPixelRed(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelRed(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[RedPixelChannel].channel]);
}
-static inline PixelTrait GetPixelRedTraits(const Image *image)
+static inline PixelTrait GetPixelRedTraits(const Image *restrict image)
{
return(image->channel_map[RedPixelChannel].traits);
}
-static inline void GetPixelInfoPixel(const Image *image,const Quantum *pixel,
- PixelInfo *packet)
+static inline void GetPixelInfoPixel(const Image *restrict image,
+ const Quantum *restrict pixel,PixelInfo *restrict pixel_info)
{
- packet->red=(double) pixel[image->channel_map[RedPixelChannel].channel];
- packet->green=(double) pixel[image->channel_map[GreenPixelChannel].channel];
- packet->blue=(double) pixel[image->channel_map[BluePixelChannel].channel];
- packet->alpha=OpaqueAlpha;
+ pixel_info->red=(MagickRealType)
+ pixel[image->channel_map[RedPixelChannel].channel];
+ pixel_info->green=(MagickRealType)
+ pixel[image->channel_map[GreenPixelChannel].channel];
+ pixel_info->blue=(MagickRealType)
+ pixel[image->channel_map[BluePixelChannel].channel];
+ pixel_info->black=0;
+ if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+ pixel_info->black=(MagickRealType)
+ pixel[image->channel_map[BlackPixelChannel].channel];
+ pixel_info->alpha=OpaqueAlpha;
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- packet->alpha=(double) pixel[image->channel_map[AlphaPixelChannel].channel];
+ pixel_info->alpha=(MagickRealType)
+ pixel[image->channel_map[AlphaPixelChannel].channel];
+ pixel_info->index=0;
+ if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
+ pixel_info->index=(MagickRealType)
+ pixel[image->channel_map[IndexPixelChannel].channel];
}
-static inline PixelTrait GetPixelTraits(const Image *image,
+static inline PixelTrait GetPixelTraits(const Image *restrict image,
const PixelChannel channel)
{
return(image->channel_map[channel].traits);
}
-static inline Quantum GetPixelY(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelY(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[YPixelChannel].channel]);
}
-static inline PixelTrait GetPixelYTraits(const Image *image)
+static inline PixelTrait GetPixelYTraits(const Image *restrict image)
{
return(image->channel_map[YPixelChannel].traits);
}
-static inline Quantum GetPixelYellow(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelYellow(const Image *restrict image,
+ const Quantum *restrict pixel)
{
return(pixel[image->channel_map[YellowPixelChannel].channel]);
}
-static inline PixelTrait GetPixelYellowTraits(const Image *image)
+static inline PixelTrait GetPixelYellowTraits(const Image *restrict image)
{
return(image->channel_map[YellowPixelChannel].traits);
}
-static inline MagickBooleanType IsPixelEquivalent(const Image *image,
- const Quantum *p,const PixelInfo *q)
+static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
+ const Quantum *restrict p,const PixelInfo *restrict q)
{
if (((double) p[image->channel_map[RedPixelChannel].channel] == q->red) &&
((double) p[image->channel_map[GreenPixelChannel].channel] == q->green) &&
return(MagickFalse);
}
-static inline MagickBooleanType IsPixelGray(const Image *image,
- const Quantum *pixel)
+static inline MagickBooleanType IsPixelGray(const Image *restrict image,
+ const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
if ((pixel[image->channel_map[RedPixelChannel].channel] ==
return(MagickFalse);
}
-static inline MagickBooleanType IsPixelInfoEquivalent(const PixelInfo *p,
- const PixelInfo *q)
+static inline MagickBooleanType IsPixelInfoEquivalent(
+ const PixelInfo *restrict p,const PixelInfo *restrict q)
{
if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
(fabs(p->alpha-OpaqueAlpha) > 0.5))
return(MagickTrue);
}
-static inline MagickBooleanType IsPixelMonochrome(const Image *image,
- const Quantum *pixel)
+static inline MagickBooleanType IsPixelMonochrome(const Image *restrict image,
+ const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
if (((pixel[image->channel_map[RedPixelChannel].channel] == 0) ||
return(MagickFalse);
}
-static inline MagickBooleanType IsPixelInfoGray(const PixelInfo *pixel)
+static inline MagickBooleanType IsPixelInfoGray(
+ const PixelInfo *restrict pixel_info)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
+ if ((pixel_info->red == pixel_info->green) &&
+ (pixel_info->green == pixel_info->blue))
return(MagickTrue);
#else
{
alpha,
beta;
- alpha=pixel->red-(double) pixel->green;
- beta=pixel->green-(double) pixel->blue;
+ alpha=pixel_info->red-(double) pixel_info->green;
+ beta=pixel_info->green-(double) pixel_info->blue;
if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
return(MagickTrue);
}
}
static inline MagickBooleanType IsPixelInfoMonochrome(
- const PixelInfo *pixel)
+ const PixelInfo *restrict pixel_info)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
- if (((pixel->red == 0) || (pixel->red == (Quantum) QuantumRange)) &&
- (pixel->red == pixel->green) && (pixel->green == pixel->blue))
+ if (((pixel_info->red == 0) || (pixel_info->red == (Quantum) QuantumRange)) &&
+ (pixel_info->red == pixel_info->green) &&
+ (pixel_info->green == pixel_info->blue))
return(MagickTrue);
#else
{
alpha,
beta;
- alpha=pixel->red-(double) pixel->green;
- beta=pixel->green-(double) pixel->blue;
- if (((fabs(pixel->red) <= MagickEpsilon) ||
- (fabs(pixel->red-QuantumRange) <= MagickEpsilon)) &&
+ alpha=pixel_info->red-(double) pixel_info->green;
+ beta=pixel_info->green-(double) pixel_info->blue;
+ if (((fabs(pixel_info->red) <= MagickEpsilon) ||
+ (fabs(pixel_info->red-QuantumRange) <= MagickEpsilon)) &&
(fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
return(MagickTrue);
}
return(MagickFalse);
}
-static inline void SetPacketPixelInfo(const Image *image,
- const PixelInfo *pixel_info,PixelInfo *packet)
+static inline void SetPixelAlpha(const Image *restrict image,
+ const Quantum alpha,Quantum *restrict pixel)
{
- packet->red=pixel_info->red;
- packet->green=pixel_info->green;
- packet->blue=pixel_info->blue;
- packet->black=0;
- if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
- packet->black=pixel_info->black;
- packet->alpha=OpaqueAlpha;
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- packet->alpha=pixel_info->alpha;
- packet->index=0;
- if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
- packet->index=pixel_info->index;
-}
-
-static inline void SetPixelAlpha(const Image *image,const Quantum alpha,
- Quantum *pixel)
-{
- pixel[image->channel_map[AlphaPixelChannel].channel]=alpha;
+ pixel[image->channel_map[AlphaPixelChannel].channel]=alpha;
}
static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
image->channel_map[AlphaPixelChannel].traits=traits;
}
-static inline void SetPixelBlack(const Image *image,const Quantum black,
- Quantum *pixel)
+static inline void SetPixelBlack(const Image *restrict image,
+ const Quantum black,Quantum *restrict pixel)
{
- pixel[image->channel_map[BlackPixelChannel].channel]=black;
+ if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+ pixel[image->channel_map[BlackPixelChannel].channel]=black;
}
static inline void SetPixelBlackTraits(Image *image,const PixelTrait traits)
image->channel_map[BlackPixelChannel].traits=traits;
}
-static inline void SetPixelBlue(const Image *image,const Quantum blue,
- Quantum *pixel)
+static inline void SetPixelBlue(const Image *restrict image,const Quantum blue,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[BluePixelChannel].channel]=blue;
}
image->channel_map[BluePixelChannel].traits=traits;
}
-static inline void SetPixelCb(const Image *image,const Quantum cb,
- Quantum *pixel)
+static inline void SetPixelCb(const Image *restrict image,const Quantum cb,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[CbPixelChannel].channel]=cb;
}
image->channel_map[CbPixelChannel].traits=traits;
}
-static inline void SetPixelChannel(const Image *image,
- const PixelChannel channel,const Quantum quantum,Quantum *pixel)
+static inline void SetPixelChannel(const Image *restrict image,
+ const PixelChannel channel,const Quantum quantum,Quantum *restrict pixel)
{
- pixel[image->channel_map[channel].channel]=quantum;
+ if (image->channel_map[channel].traits != UndefinedPixelTrait)
+ pixel[image->channel_map[channel].channel]=quantum;
}
-static inline void SetPixelChannelMapChannel(const Image *image,
+static inline void SetPixelChannelMapChannel(const Image *restrict image,
const PixelChannel channel,const PixelChannel channels)
{
image->channel_map[channel].channel=channels;
image->channel_map[channel].traits=traits;
}
-static inline void SetPixelCr(const Image *image,const Quantum cr,
- Quantum *pixel)
+static inline void SetPixelCr(const Image *restrict image,const Quantum cr,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[CrPixelChannel].channel]=cr;
}
image->channel_map[CrPixelChannel].traits=traits;
}
-static inline void SetPixelCyan(const Image *image,const Quantum cyan,
- Quantum *pixel)
+static inline void SetPixelCyan(const Image *restrict image,const Quantum cyan,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[CyanPixelChannel].channel]=cyan;
}
-static inline void SetPixelGray(const Image *image,const Quantum gray,
- Quantum *pixel)
+static inline void SetPixelGray(const Image *restrict image,const Quantum gray,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[GrayPixelChannel].channel]=gray;
}
image->channel_map[GrayPixelChannel].traits=traits;
}
-static inline void SetPixelGreen(const Image *image,const Quantum green,
- Quantum *pixel)
+static inline void SetPixelGreen(const Image *restrict image,
+ const Quantum green,Quantum *restrict pixel)
{
pixel[image->channel_map[GreenPixelChannel].channel]=green;
}
image->channel_map[GreenPixelChannel].traits=traits;
}
-static inline void SetPixelIndex(const Image *image,const Quantum index,
- Quantum *pixel)
+static inline void SetPixelIndex(const Image *restrict image,
+ const Quantum index,Quantum *restrict pixel)
{
- pixel[image->channel_map[IndexPixelChannel].channel]=index;
+ if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
+ pixel[image->channel_map[IndexPixelChannel].channel]=index;
}
static inline void SetPixelIndexTraits(Image *image,const PixelTrait traits)
image->channel_map[IndexPixelChannel].traits=traits;
}
-static inline void SetPixelInfo(const Image *image,const Quantum *pixel,
- PixelInfo *pixel_info)
+static inline void SetPixelInfo(const Image *restrict image,
+ const PixelInfo *restrict p,PixelInfo *restrict q)
{
- pixel_info->red=(MagickRealType)
- pixel[image->channel_map[RedPixelChannel].channel];
- pixel_info->green=(MagickRealType)
- pixel[image->channel_map[GreenPixelChannel].channel];
- pixel_info->blue=(MagickRealType)
- pixel[image->channel_map[BluePixelChannel].channel];
- pixel_info->black=0;
+ q->red=p->red;
+ q->green=p->green;
+ q->blue=p->blue;
+ q->black=0;
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
- pixel_info->black=(MagickRealType)
- pixel[image->channel_map[BlackPixelChannel].channel];
- pixel_info->alpha=OpaqueAlpha;
+ q->black=p->black;
+ q->alpha=OpaqueAlpha;
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- pixel_info->alpha=(MagickRealType)
- pixel[image->channel_map[AlphaPixelChannel].channel];
- pixel_info->index=0;
+ q->alpha=p->alpha;
+ q->index=0;
if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
- pixel_info->index=(MagickRealType)
- pixel[image->channel_map[IndexPixelChannel].channel];
+ q->index=p->index;
}
-static inline void SetPixelMagenta(const Image *image,const Quantum magenta,
- Quantum *pixel)
+static inline void SetPixelInfoPixel(const Image *restrict image,
+ const PixelInfo *restrict pixel_info,Quantum *restrict pixel)
+{
+ pixel[image->channel_map[RedPixelChannel].channel]=
+ ClampToQuantum(pixel_info->red);
+ pixel[image->channel_map[GreenPixelChannel].channel]=
+ ClampToQuantum(pixel_info->green);
+ pixel[image->channel_map[BluePixelChannel].channel]=
+ ClampToQuantum(pixel_info->blue);
+ if (image->colorspace == CMYKColorspace)
+ pixel[image->channel_map[BlackPixelChannel].channel]=
+ ClampToQuantum(pixel_info->black);
+ if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+ pixel[image->channel_map[AlphaPixelChannel].channel]=
+ ClampToQuantum(pixel_info->alpha);
+}
+
+static inline void SetPixelMagenta(const Image *restrict image,
+ const Quantum magenta,Quantum *restrict pixel)
{
pixel[image->channel_map[MagentaPixelChannel].channel]=magenta;
}
image->metacontent_extent=extent;
}
-static inline void SetPixelRed(const Image *image,const Quantum red,
- Quantum *pixel)
+static inline void SetPixelRed(const Image *restrict image,const Quantum red,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[RedPixelChannel].channel]=red;
}
image->channel_map[RedPixelChannel].traits=traits;
}
-static inline void SetPixelPixelInfo(const Image *image,
- const PixelInfo *pixel_info,Quantum *pixel)
-{
- pixel[image->channel_map[RedPixelChannel].channel]=
- ClampToQuantum(pixel_info->red);
- pixel[image->channel_map[GreenPixelChannel].channel]=
- ClampToQuantum(pixel_info->green);
- pixel[image->channel_map[BluePixelChannel].channel]=
- ClampToQuantum(pixel_info->blue);
- if (image->colorspace == CMYKColorspace)
- pixel[image->channel_map[BlackPixelChannel].channel]=
- ClampToQuantum(pixel_info->black);
- if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
- pixel[image->channel_map[AlphaPixelChannel].channel]=
- ClampToQuantum(pixel_info->alpha);
-}
-
-static inline void SetPixelYellow(const Image *image,const Quantum yellow,
- Quantum *pixel)
+static inline void SetPixelYellow(const Image *restrict image,
+ const Quantum yellow,Quantum *restrict pixel)
{
pixel[image->channel_map[YellowPixelChannel].channel]=yellow;
}
image->channel_map[YellowPixelChannel].traits=traits;
}
-static inline void SetPixelY(const Image *image,const Quantum y,Quantum *pixel)
+static inline void SetPixelY(const Image *restrict image,const Quantum y,
+ Quantum *restrict pixel)
{
pixel[image->channel_map[YPixelChannel].channel]=y;
}
image->channel_map[YPixelChannel].traits=traits;
}
-static inline Quantum GetPixelIntensity(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelIntensity(const Image *restrict image,
+ const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
if ((pixel[image->channel_map[RedPixelChannel].channel] ==
#endif
}
-static inline Quantum GetPixelLuminance(const Image *image,const Quantum *pixel)
+static inline Quantum GetPixelLuminance(const Image *restrict image,
+ const Quantum *restrict pixel)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].channel]+
return(MagickFalse);
}
-static inline void SetPixelInfo(const Image *image,
+static inline void GetPixelInfo(const Image *image,
const MagickPixelInfo *pixel,PixelInfo *color,IndexPacket *index)
{
SetPixelRed(color,ClampToQuantum(pixel->red));
filter_view=AcquireCacheView(filter_image);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p != (const Quantum *) NULL)
- SetPixelInfo(image,p,pixel);
+ GetPixelInfoPixel(image,p,pixel);
filter_view=DestroyCacheView(filter_view);
filter_image=DestroyImage(filter_image);
break;
status=MagickFalse;
break;
}
- SetPixelInfo(image,p,pixel);
+ GetPixelInfoPixel(image,p,pixel);
break;
}
case MeshInterpolatePixel:
status=MagickFalse;
break;
}
- SetPixelInfo(image,p,pixel);
+ GetPixelInfoPixel(image,p,pixel);
break;
}
case SplineInterpolatePixel:
0x00 : 0x01);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=channels;
}
0x00 : 0x01);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=channels;
}
pixel=(unsigned char) ((*p >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=channels;
pixel=(unsigned char) ((*p) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p++;
q+=channels;
pixel=(unsigned char) ((*p++ >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=channels;
}
p=PushCharPixel(p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
(MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
p=PushShortPixel(endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
p=PushFloatPixel(&quantum_state,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,
ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
p=PushLongPixel(endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
p=PushDoublePixel(&quantum_state,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,
ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p+=quantum_info->pad;
q+=channels;
pixel=(unsigned char) ((*p >> 4) & 0xf);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
pixel=(unsigned char) ((*p) & 0xf);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
p=PushCharPixel(p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushCharPixel(p,&pixel);
SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
(MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushShortPixel(endian,p,&pixel);
SetPixelAlpha(image,ClampToQuantum((MagickRealType)
p=PushShortPixel(endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushShortPixel(endian,p,&pixel);
SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
p=PushFloatPixel(&quantum_state,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,
ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushFloatPixel(&quantum_state,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p=PushLongPixel(endian,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushLongPixel(endian,p,&pixel);
SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
p=PushDoublePixel(&quantum_state,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,
ClampToQuantum(pixel),&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushDoublePixel(&quantum_state,p,&pixel);
SetPixelAlpha(image,ClampToQuantum(pixel),q);
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
SetPixelIndex(image,PushColormapIndex(image,pixel,
&range_exception),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
*pixel=resample_filter->average_pixel; /* FAILED */
break;
}
- SetPixelInfo(resample_filter->image,pixels,
+ GetPixelInfoPixel(resample_filter->image,pixels,
&(resample_filter->average_pixel));
average_view=DestroyCacheView(average_view);
average_image=DestroyImage(average_image);
if ((x_offset+i) < step)
{
p+=GetPixelChannels(image);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
q+=GetPixelChannels(image);
continue;
}
- SetPixelInfo(image,p,&source);
+ GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&source,(MagickRealType) GetPixelAlpha(image,p),area,&destination);
- SetPixelPixelInfo(image,&destination,q);
- SetPixelInfo(image,p,&pixel);
+ SetPixelInfoPixel(image,&destination,q);
+ GetPixelInfoPixel(image,p,&pixel);
p+=GetPixelChannels(image);
q+=GetPixelChannels(image);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
- SetPixelPixelInfo(image,&destination,q);
+ SetPixelInfoPixel(image,&destination,q);
q+=GetPixelChannels(image);
for (i=0; i < (step-1); i++)
{
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
break;
q-=GetPixelChannels(image);
if ((size_t) (x_offset+width+step-i) >= image->columns)
continue;
- SetPixelInfo(image,p,&source);
+ GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&source,(MagickRealType) GetPixelAlpha(image,p),area,&destination);
- SetPixelPixelInfo(image,&destination,q);
- SetPixelInfo(image,p,&pixel);
+ SetPixelInfoPixel(image,&destination,q);
+ GetPixelInfoPixel(image,p,&pixel);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
q-=GetPixelChannels(image);
- SetPixelPixelInfo(image,&destination,q);
+ SetPixelInfoPixel(image,&destination,q);
for (i=0; i < (step-1); i++)
{
q-=GetPixelChannels(image);
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
}
break;
}
if ((y_offset+i) < step)
{
p+=GetPixelChannels(image);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
q+=GetPixelChannels(image);
continue;
}
- SetPixelInfo(image,p,&source);
+ GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&source,(MagickRealType) GetPixelAlpha(image,p),area,
&destination);
- SetPixelPixelInfo(image,&destination,q);
- SetPixelInfo(image,p,&pixel);
+ SetPixelInfoPixel(image,&destination,q);
+ GetPixelInfoPixel(image,p,&pixel);
p+=GetPixelChannels(image);
q+=GetPixelChannels(image);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
- SetPixelPixelInfo(image,&destination,q);
+ SetPixelInfoPixel(image,&destination,q);
q+=GetPixelChannels(image);
for (i=0; i < (step-1); i++)
{
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
break;
q-=GetPixelChannels(image);
if ((size_t) (y_offset+height+step-i) >= image->rows)
continue;
- SetPixelInfo(image,p,&source);
+ GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&source,(MagickRealType) GetPixelAlpha(image,p),area,
&destination);
- SetPixelPixelInfo(image,&destination,q);
- SetPixelInfo(image,p,&pixel);
+ SetPixelInfoPixel(image,&destination,q);
+ GetPixelInfoPixel(image,p,&pixel);
}
CompositePixelInfoAreaBlend(&pixel,(MagickRealType) pixel.alpha,
&background,(MagickRealType) background.alpha,area,&destination);
q-=GetPixelChannels(image);
- SetPixelPixelInfo(image,&destination,q);
+ SetPixelInfoPixel(image,&destination,q);
for (i=0; i < (step-1); i++)
{
q-=GetPixelChannels(image);
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
}
break;
}
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "Copyright (C) 1999-2011 ImageMagick Studio LLC"
-#define MagickSVNRevision "5982"
+#define MagickSVNRevision "exported"
#define MagickLibVersion 0x700
#define MagickLibVersionText "7.0.0"
#define MagickLibVersionNumber 7,0,0
/*
Set this pixel to the background color.
*/
- SetPixelPixelInfo(draw_image,&draw_image->background_color,q);
+ SetPixelInfoPixel(draw_image,&draw_image->background_color,q);
SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
OpaqueStencil ? TransparentAlpha : OpaqueAlpha),q);
}
{
index=(Quantum) XGetPixel(ximage,x,y);
SetPixelIndex(composite_image,index,q);
- SetPixelPixelInfo(composite_image,
+ SetPixelInfoPixel(composite_image,
composite_image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(composite_image);
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% PixelSetPixelInfo() sets the color of the pixel wand.
+% PixelGetPixelInfoPixel() sets the color of the pixel wand.
%
% The format of the PixelSetPixelInfo method is:
%
-% PixelSetPixelInfo(PixelWand *wand,const PixelInfo *color)
+% PixelGetPixelInfoPixel(PixelWand *wand,const PixelInfo *color)
%
% A description of each parameter follows:
%
% o color: the pixel wand color.
%
*/
-WandExport void PixelSetPixelInfo(PixelWand *wand,
+WandExport void PixelGetPixelInfoPixel(PixelWand *wand,
const PixelInfo *color)
{
assert(wand != (const PixelWand *) NULL);
PixelSetIndex(PixelWand *,const Quantum),
PixelSetMagenta(PixelWand *,const double),
PixelSetMagentaQuantum(PixelWand *,const Quantum),
- PixelSetPixelInfo(PixelWand *,const PixelInfo *),
+ PixelGetPixelInfoPixel(PixelWand *,const PixelInfo *),
PixelSetAlpha(PixelWand *,const double),
PixelSetAlphaQuantum(PixelWand *,const Quantum),
PixelSetQuantumPacket(PixelWand *,const PixelInfo *),
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g,%.20g: ",(double)
x,(double) y);
(void) WriteBlobString(image,buffer);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
(void) FormatLocaleString(tuple,MaxTextExtent,"%.20g,%.20g,%.20g ",
(double) pixel.red,(double) pixel.green,(double) pixel.blue);
if (pixel.colorspace == CMYKColorspace)
break;
index=ConstrainColormapIndex(image,(size_t) c,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
SetPixelAlpha(image,(ssize_t) index == opacity ? TransparentAlpha :
OpaqueAlpha,q);
x++;
if (bit == 8)
bit=0;
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
pixel=(size_t) ((GETJSAMPLE(*p) ^ 0x80) << 4);
index=ConstrainColormapIndex(image,pixel,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
{
index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p),exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
p++;
}
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
case RLECompression:
{
length=0;
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
p+=GetPixelChannels(image);
for (x=1; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,p,&target);
+ GetPixelInfoPixel(image,p,&target);
if ((length < 255) &&
(IsPixelInfoEquivalent(&pixel,&target) != MagickFalse))
length++;
q=PopRunlengthPacket(image,q,length,&pixel,exception);
length=0;
}
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
p+=GetPixelChannels(image);
}
q=PopRunlengthPacket(image,q,length,&pixel,exception);
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,&background,q);
+ SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
ThrowReaderException(CorruptImageError,"CorruptImage");
index=(Quantum) (mask-(((*ptr) & (mask << bit)) >> bit));
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
if (bit)
bit-=bits_per_pixel;
else
{
if (GetPixelAlpha(image,r) < OpaqueAlpha/2)
{
- SetPixelPixelInfo(image,&image->background_color,r);
+ SetPixelInfoPixel(image,&image->background_color,r);
SetPixelAlpha(image,TransparentAlpha,r);
}
else
SetPixelIndex(image,ScaleQuantumToChar(pixel),q);
else
SetPixelIndex(image,ScaleQuantumToShort(pixel),q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
if (image->depth == 1)
{
{
SetPixelIndex(image,(((unsigned char) pixel) &
(0x01 << (7-bit))) != 0 ? 0 : 255,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t)
+ SetPixelInfoPixel(image,image->colormap+(ssize_t)
GetPixelIndex(image,q),q);
q+=GetPixelChannels(image);
x++;
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
(void) QueryColorname(image,&pixel,SVGCompliance,tuple,exception);
(void) FormatLocaleString(message,MaxTextExtent,
" <circle cx=\"%.20g\" cy=\"%.20g\" r=\"1\" fill=\"%s\"/>\n",
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,&background_color,q);
+ SetPixelInfoPixel(image,&background_color,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g,%.20g: ",(double)
x,(double) y);
(void) WriteBlobString(image,buffer);
- SetPixelInfo(image,p,&pixel);
+ GetPixelInfoPixel(image,p,&pixel);
(void) CopyMagickString(tuple,"(",MaxTextExtent);
ConcatenateColorComponent(&pixel,RedPixelChannel,X11Compliance,
tuple);
{
index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
p++;
{
index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
p++;
{
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
index=ConstrainColormapIndex(image,(*p) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
{
index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 1)
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 2)
index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,
exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
}
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
index=ConstrainColormapIndex(image,(*p) & 0x0f,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
{
index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
{
index=ConstrainColormapIndex(image,*p,exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
image->colorspace=color.colorspace;
image->matte=color.matte;
pixel.black=0;
- SetPacketPixelInfo(image,&color,&pixel);
+ SetPixelInfo(image,&color,&pixel);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelPixelInfo(image,&pixel,q);
+ SetPixelInfoPixel(image,&pixel,q);
if (image->colorspace == CMYKColorspace)
SetPixelBlack(image,pixel.black,q);
q+=GetPixelChannels(image);
j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
if (image->storage_class == PseudoClass)
SetPixelIndex(image,j,r);
- SetPixelPixelInfo(image,image->colormap+j,r);
+ SetPixelInfoPixel(image,image->colormap+j,r);
p+=width;
r+=GetPixelChannels(image);
}
index=ConstrainColormapIndex(image,XGetPixel(ximage,(int) x,
(int) y),exception);
SetPixelIndex(image,index,q);
- SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
projects / imagemagick / commitdiff