43 #include "magick/studio.h"
44 #if defined(MAGICKCORE_WINGDI32_DELEGATE)
45 # if defined(__CYGWIN__)
49 # include "magick/nt-base-private.h"
53 #include "magick/blob.h"
54 #include "magick/blob-private.h"
55 #include "magick/cache.h"
56 #include "magick/cache-view.h"
57 #include "magick/channel.h"
58 #include "magick/client.h"
59 #include "magick/color.h"
60 #include "magick/color-private.h"
61 #include "magick/colormap.h"
62 #include "magick/colormap-private.h"
63 #include "magick/colorspace.h"
64 #include "magick/colorspace-private.h"
65 #include "magick/composite.h"
66 #include "magick/composite-private.h"
67 #include "magick/constitute.h"
68 #include "magick/deprecate.h"
69 #include "magick/draw.h"
70 #include "magick/draw-private.h"
71 #include "magick/effect.h"
72 #include "magick/enhance.h"
73 #include "magick/exception.h"
74 #include "magick/exception-private.h"
75 #include "magick/fx.h"
76 #include "magick/geometry.h"
77 #include "magick/identify.h"
78 #include "magick/image.h"
79 #include "magick/image-private.h"
80 #include "magick/list.h"
81 #include "magick/log.h"
82 #include "magick/memory_.h"
83 #include "magick/magick.h"
84 #include "magick/monitor.h"
85 #include "magick/monitor-private.h"
86 #include "magick/morphology.h"
87 #include "magick/mutex.h"
88 #include "magick/nt-feature.h"
89 #include "magick/paint.h"
90 #include "magick/pixel.h"
91 #include "magick/pixel-accessor.h"
92 #include "magick/pixel-private.h"
93 #include "magick/property.h"
94 #include "magick/quantize.h"
95 #include "magick/random_.h"
96 #include "magick/resource_.h"
97 #include "magick/semaphore.h"
98 #include "magick/semaphore-private.h"
99 #include "magick/segment.h"
100 #include "magick/splay-tree.h"
101 #include "magick/statistic.h"
102 #include "magick/string_.h"
103 #include "magick/threshold.h"
104 #include "magick/thread_.h"
105 #include "magick/thread-private.h"
106 #include "magick/token.h"
107 #include "magick/transform.h"
108 #include "magick/utility.h"
110 #if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
114 static MonitorHandler
115 monitor_handler = (MonitorHandler) NULL;
144 MagickExport
const IndexPacket *AcquireCacheViewIndexes(
147 return(GetCacheViewVirtualIndexQueue(cache_view));
185 MagickExport
const PixelPacket *AcquireCacheViewPixels(
186 const CacheView *cache_view,
const ssize_t x,
const ssize_t y,
187 const size_t columns,
const size_t rows,
ExceptionInfo *exception)
189 return(GetCacheViewVirtualPixels(cache_view,x,y,columns,rows,exception));
245 const ssize_t x,
const ssize_t y,
const size_t columns,
248 return(GetVirtualPixels(image,x,y,columns,rows,exception));
283 MagickExport
const IndexPacket *AcquireIndexes(
const Image *image)
285 return(GetVirtualIndexQueue(image));
311 MagickExport
void *AcquireMemory(
const size_t size)
317 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
318 allocation=malloc(size);
358 MagickExport MagickBooleanType AcquireOneCacheViewPixel(
359 const CacheView *cache_view,
const ssize_t x,
const ssize_t y,
362 return(GetOneCacheViewVirtualPixel(cache_view,x,y,pixel,exception));
405 MagickExport MagickBooleanType AcquireOneCacheViewVirtualPixel(
406 const CacheView *cache_view,
const VirtualPixelMethod virtual_pixel_method,
412 status=GetOneCacheViewVirtualMethodPixel(cache_view,virtual_pixel_method,
413 x,y,pixel,exception);
457 (void) GetOneVirtualMagickPixel(image,x,y,&pixel,exception);
495 MagickExport
PixelPacket AcquireOnePixel(
const Image *image,
const ssize_t x,
501 (void) GetOneVirtualPixel(image,x,y,&pixel,exception);
544 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
550 (void) GetOneVirtualMethodPixel(image,virtual_pixel_method,x,y,&pixel,
584 return(GetVirtualPixelQueue(image));
609 MagickExport
void AcquireSemaphoreInfo(
SemaphoreInfo **semaphore_info)
614 InitializeMagickMutex();
617 *semaphore_info=AllocateSemaphoreInfo();
654 MagickExport MagickBooleanType AffinityImage(
const QuantizeInfo *quantize_info,
657 return(RemapImage(quantize_info,image,affinity_image));
692 MagickExport MagickBooleanType AffinityImages(
const QuantizeInfo *quantize_info,
695 return(RemapImages(quantize_info,images,affinity_image));
729 return(AcquireImage(image_info));
764 MagickExport MagickBooleanType AllocateImageColormap(
Image *image,
767 return(AcquireImageColormap(image,colors));
802 MagickExport
void AllocateNextImage(
const ImageInfo *image_info,
Image *image)
804 AcquireNextImage(image_info,image);
830 MagickExport
char *AllocateString(
const char *source)
838 assert(source != (
const char *) NULL);
839 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
840 length=strlen(source)+MaxTextExtent+1;
841 destination=(
char *) AcquireQuantumMemory(length,
sizeof(*destination));
842 if (destination == (
char *) NULL)
843 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
845 (void) CopyMagickString(destination,source,length);
883 return(EvaluateImages(images,MeanEvaluateOperator,exception));
917 MagickExport
unsigned int ChannelImage(
Image *image,
const ChannelType channel)
919 return(SeparateImageChannel(image,channel));
947 MagickExport
unsigned int ChannelThresholdImage(
Image *image,
const char *level)
959 assert(image != (
Image *) NULL);
960 assert(image->signature == MagickCoreSignature);
961 if (IsEventLogging() != MagickFalse)
963 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
964 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
967 if (level == (
char *) NULL)
969 flags=ParseGeometry(level,&geometry_info);
970 threshold.red=geometry_info.rho;
971 threshold.green=geometry_info.sigma;
972 if ((flags & SigmaValue) == 0)
973 threshold.green=threshold.red;
974 threshold.blue=geometry_info.xi;
975 if ((flags & XiValue) == 0)
976 threshold.blue=threshold.red;
977 status=BilevelImageChannel(image,RedChannel,threshold.red);
978 status&=BilevelImageChannel(image,GreenChannel,threshold.green);
979 status&=BilevelImageChannel(image,BlueChannel,threshold.blue);
1017 MagickExport MagickBooleanType ClipPathImage(
Image *image,
const char *pathname,
1018 const MagickBooleanType inside)
1020 return(ClipImagePath(image,pathname,inside));
1052 MagickExport MagickBooleanType CloneImageAttributes(
Image *image,
1053 const Image *clone_image)
1055 return(CloneImageProperties(image,clone_image));
1087 MagickExport
void *CloneMemory(
void *destination,
const void *source,
1099 assert(destination != (
void *) NULL);
1100 assert(source != (
const void *) NULL);
1101 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
1102 p=(
const unsigned char *) source;
1103 q=(
unsigned char *) destination;
1104 if ((p <= q) || ((p+size) >= q))
1105 return(memcpy(destination,source,size));
1111 for (i=(ssize_t) (size-1); i >= 0; i--)
1113 return(destination);
1145 return(DestroyCacheView(view_info));
1191 #define MaxStacksize (1UL << 15)
1192 #define PushSegmentStack(up,left,right,delta) \
1194 if (s >= (segment_stack+MaxStacksize)) \
1195 ThrowBinaryImageException(DrawError,"SegmentStackOverflow",image->filename) \
1198 if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
1200 s->x1=(double) (left); \
1201 s->y1=(double) (up); \
1202 s->x2=(double) (right); \
1203 s->y2=(double) (delta); \
1209 MagickExport MagickBooleanType ColorFloodfillImage(
Image *image,
1211 const ssize_t y_offset,
const PaintMethod method)
1239 assert(image != (
Image *) NULL);
1240 assert(image->signature == MagickCoreSignature);
1241 assert(draw_info != (
DrawInfo *) NULL);
1242 assert(draw_info->signature == MagickCoreSignature);
1243 if (IsEventLogging() != MagickFalse)
1244 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1245 if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
1246 return(MagickFalse);
1247 if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
1248 return(MagickFalse);
1249 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1250 return(MagickFalse);
1251 if (image->matte == MagickFalse)
1252 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
1253 floodplane_image=CloneImage(image,0,0,MagickTrue,&image->exception);
1254 if (floodplane_image == (
Image *) NULL)
1255 return(MagickFalse);
1256 (void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel);
1260 segment_stack=(
SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
1261 sizeof(*segment_stack));
1264 floodplane_image=DestroyImage(floodplane_image);
1265 ThrowBinaryImageException(ResourceLimitError,
"MemoryAllocationFailed",
1275 PushSegmentStack(y,x,x,1);
1276 PushSegmentStack(y+1,x,x,-1);
1277 while (s > segment_stack)
1294 offset=(ssize_t) s->y2;
1295 y=(ssize_t) s->y1+offset;
1299 p=GetVirtualPixels(image,0,y,(
size_t) (x1+1),1,&image->exception);
1300 q=GetAuthenticPixels(floodplane_image,0,y,(
size_t) (x1+1),1,
1306 for (x=x1; x >= 0; x--)
1308 if (q->opacity == (Quantum) TransparentOpacity)
1310 if (method == FloodfillMethod)
1312 if (IsColorSimilar(image,p,&target) == MagickFalse)
1316 if (IsColorSimilar(image,p,&target) != MagickFalse)
1318 q->opacity=(Quantum) TransparentOpacity;
1322 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
1324 skip=x >= x1 ? MagickTrue : MagickFalse;
1325 if (skip == MagickFalse)
1329 PushSegmentStack(y,start,x1-1,-offset);
1334 if (skip == MagickFalse)
1336 if (x < (ssize_t) image->columns)
1338 p=GetVirtualPixels(image,x,y,image->columns-x,1,
1340 q=GetAuthenticPixels(floodplane_image,x,y,image->columns-x,1,
1345 for ( ; x < (ssize_t) image->columns; x++)
1347 if (q->opacity == (Quantum) TransparentOpacity)
1349 if (method == FloodfillMethod)
1351 if (IsColorSimilar(image,p,&target) == MagickFalse)
1355 if (IsColorSimilar(image,p,&target) != MagickFalse)
1357 q->opacity=(Quantum) TransparentOpacity;
1361 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
1364 PushSegmentStack(y,start,x-1,offset);
1366 PushSegmentStack(y,x2+1,x-1,-offset);
1372 p=GetVirtualPixels(image,x,y,(
size_t) (x2-x+1),1,
1374 q=GetAuthenticPixels(floodplane_image,x,y,(
size_t) (x2-x+1),1,
1378 for ( ; x <= x2; x++)
1380 if (q->opacity == (Quantum) TransparentOpacity)
1382 if (method == FloodfillMethod)
1384 if (IsColorSimilar(image,p,&target) != MagickFalse)
1388 if (IsColorSimilar(image,p,&target) == MagickFalse)
1397 for (y=0; y < (ssize_t) image->rows; y++)
1411 p=GetVirtualPixels(floodplane_image,0,y,image->columns,1,
1413 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
1416 for (x=0; x < (ssize_t) image->columns; x++)
1418 if (GetPixelOpacity(p) != OpaqueOpacity)
1420 (void) GetFillColor(draw_info,x,y,&fill_color);
1421 MagickCompositeOver(&fill_color,(MagickRealType) fill_color.opacity,q,
1422 (MagickRealType) q->opacity,q);
1427 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
1430 segment_stack=(
SegmentInfo *) RelinquishMagickMemory(segment_stack);
1431 floodplane_image=DestroyImage(floodplane_image);
1432 return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
1453 MagickExport MagickBooleanType ConstituteComponentGenesis(
void)
1476 MagickExport
void ConstituteComponentTerminus(
void)
1480 #if defined(MAGICKCORE_WINGDI32_DELEGATE)
1512 MagickExport
void *CropImageToHBITMAP(
Image *image,
1515 #define CropImageTag "Crop/Image"
1547 assert(image != (
const Image *) NULL);
1548 assert(image->signature == MagickCoreSignature);
1551 assert(exception->signature == MagickCoreSignature);
1552 if (IsEventLogging() != MagickFalse)
1553 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1554 if (((geometry->x+(ssize_t) geometry->width) < 0) ||
1555 ((geometry->y+(ssize_t) geometry->height) < 0) ||
1556 (geometry->x >= (ssize_t) image->columns) ||
1557 (geometry->y >= (ssize_t) image->rows))
1558 ThrowImageException(OptionError,
"GeometryDoesNotContainImage");
1560 if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
1561 page.width=image->columns-page.x;
1562 if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
1563 page.height=image->rows-page.y;
1571 page.height+=page.y;
1575 if ((page.width == 0) || (page.height == 0))
1576 ThrowImageException(OptionError,
"GeometryDimensionsAreZero");
1581 bitmap.bmWidth = (LONG) page.width;
1582 bitmap.bmHeight = (LONG) page.height;
1583 bitmap.bmWidthBytes = bitmap.bmWidth * 4;
1584 bitmap.bmPlanes = 1;
1585 bitmap.bmBitsPixel = 32;
1586 bitmap.bmBits = NULL;
1588 bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,page.width*
1589 page.height*bitmap.bmBitsPixel);
1590 if (bitmap_bitsH == NULL)
1592 bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
1593 if ( bitmap.bmBits == NULL )
1594 bitmap.bmBits = bitmap_bits;
1595 if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
1596 SetImageColorspace(image,sRGBColorspace);
1601 for (y=0; y < (ssize_t) page.height; y++)
1606 p=GetVirtualPixels(image,page.x,page.y+y,page.width,1,exception);
1611 for( x=(ssize_t) page.width ; x> 0 ; x-- )
1613 q->rgbRed = ScaleQuantumToChar(GetPixelRed(p));
1614 q->rgbGreen = ScaleQuantumToChar(GetPixelGreen(p));
1615 q->rgbBlue = ScaleQuantumToChar(GetPixelBlue(p));
1620 proceed=SetImageProgress(image,CropImageTag,y,page.height);
1621 if (proceed == MagickFalse)
1624 if (y < (ssize_t) page.height)
1626 GlobalUnlock((HGLOBAL) bitmap_bitsH);
1627 GlobalFree((HGLOBAL) bitmap_bitsH);
1628 return((
void *) NULL);
1630 bitmap.bmBits=bitmap_bits;
1631 bitmapH=CreateBitmapIndirect(&bitmap);
1632 GlobalUnlock((HGLOBAL) bitmap_bitsH);
1633 GlobalFree((HGLOBAL) bitmap_bitsH);
1634 return((
void *) bitmapH);
1666 MagickExport MagickBooleanType DeleteImageAttribute(
Image *image,
1669 return(DeleteImageProperty(image,key));
1696 MagickExport
unsigned int DeleteImageList(
Image *images,
const ssize_t offset)
1701 if (images->debug != MagickFalse)
1702 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
1703 while (GetPreviousImageInList(images) != (
Image *) NULL)
1704 images=GetPreviousImageInList(images);
1705 for (i=0; i < offset; i++)
1707 if (GetNextImageInList(images) == (
Image *) NULL)
1708 return(MagickFalse);
1709 images=GetNextImageInList(images);
1711 DeleteImageFromList(&images);
1745 MagickExport MagickBooleanType DeleteMagickRegistry(
const ssize_t
id)
1750 (void) FormatLocaleString(key,MaxTextExtent,
"%.20g\n",(
double) id);
1751 return(DeleteImageRegistry(key));
1772 MagickExport
void DestroyConstitute(
void)
1798 MagickExport
void DestroyMagickRegistry(
void)
1800 RegistryComponentTerminus();
1836 MagickExport MagickBooleanType DescribeImage(
Image *image,FILE *file,
1837 const MagickBooleanType verbose)
1839 return(IdentifyImage(image,file,verbose));
1865 MagickExport
void DestroyImageAttributes(
Image *image)
1867 assert(image != (
Image *) NULL);
1868 assert(image->signature == MagickCoreSignature);
1869 if (IsEventLogging() != MagickFalse)
1870 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1871 if (image->attributes != (
void *) NULL)
1872 image->attributes=(
void *) DestroySplayTree((
SplayTreeInfo *)
1902 MagickExport
void DestroyImages(
Image *image)
1904 if (image == (
Image *) NULL)
1906 if (IsEventLogging() != MagickFalse)
1907 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.4.3");
1908 image=DestroyImageList(image);
1933 MagickExport
void DestroyMagick(
void)
1935 MagickCoreTerminus();
1995 MagickExport
unsigned int DispatchImage(
const Image *image,
const ssize_t x_offset,
1996 const ssize_t y_offset,
const size_t columns,
const size_t rows,
1997 const char *map,
const StorageType type,
void *pixels,
ExceptionInfo *exception)
2002 if (IsEventLogging() != MagickFalse)
2003 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.6");
2004 status=ExportImagePixels(image,x_offset,y_offset,columns,rows,map,type,pixels,
2038 static double GetSimilarityMetric(
const Image *image,
const Image *reference,
2039 const ssize_t x_offset,
const ssize_t y_offset,
2048 normalized_similarity,
2057 normalized_similarity=1.0;
2060 if ((image->matte != MagickFalse) && (reference->matte != MagickFalse))
2062 if ((image->colorspace == CMYKColorspace) &&
2063 (reference->colorspace == CMYKColorspace))
2065 image_view=AcquireVirtualCacheView(image,exception);
2066 reference_view=AcquireVirtualCacheView(reference,exception);
2067 for (y=0; y < (ssize_t) reference->rows; y++)
2080 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset+y,
2081 reference->columns,1,exception);
2082 q=GetCacheViewVirtualPixels(reference_view,0,y,reference->columns,1,
2086 indexes=GetCacheViewVirtualIndexQueue(image_view);
2087 reference_indexes=GetCacheViewVirtualIndexQueue(reference_view);
2088 for (x=0; x < (ssize_t) reference->columns; x++)
2093 pixel=QuantumScale*(GetPixelRed(p)-(double)
2095 similarity+=pixel*pixel;
2096 pixel=QuantumScale*(GetPixelGreen(p)-(double)
2098 similarity+=pixel*pixel;
2099 pixel=QuantumScale*(GetPixelBlue(p)-(double)
2101 similarity+=pixel*pixel;
2102 if ((image->matte != MagickFalse) && (reference->matte != MagickFalse))
2104 pixel=QuantumScale*(GetPixelOpacity(p)-(double)
2105 GetPixelOpacity(q));
2106 similarity+=pixel*pixel;
2108 if ((image->colorspace == CMYKColorspace) &&
2109 (reference->colorspace == CMYKColorspace))
2111 pixel=QuantumScale*(GetPixelIndex(indexes+x)-(double)
2112 GetPixelIndex(reference_indexes+x));
2113 similarity+=pixel*pixel;
2118 normalized_similarity=sqrt(similarity)/reference->columns/reference->rows/
2120 if (normalized_similarity > similarity_threshold)
2123 reference_view=DestroyCacheView(reference_view);
2124 image_view=DestroyCacheView(image_view);
2125 return(normalized_similarity);
2128 MagickExport
Image *ExtractSubimageFromImage(
Image *image,
2132 similarity_threshold;
2143 if ((reference->columns > image->columns) || (reference->rows > image->rows))
2144 return((
Image *) NULL);
2145 similarity_threshold=(double) image->columns*image->rows;
2146 SetGeometry(reference,&offset);
2147 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2148 #pragma omp parallel for schedule(static)
2150 for (y=0; y < (ssize_t) (image->rows-reference->rows); y++)
2158 for (x=0; x < (ssize_t) (image->columns-reference->columns); x++)
2160 similarity=GetSimilarityMetric(image,reference,x,y,similarity_threshold,
2162 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2163 #pragma omp critical (MagickCore_ExtractSubimageFromImage)
2165 if (similarity < similarity_threshold)
2167 similarity_threshold=similarity;
2173 if (similarity_threshold > (QuantumScale*reference->fuzz/100.0))
2174 return((
Image *) NULL);
2175 return(CropImage(image,&offset,exception));
2208 return(MergeImageLayers(image,FlattenLayer,exception));
2241 MagickExport MagickBooleanType FormatImageAttributeList(
Image *image,
2242 const char *key,
const char *format,va_list operands)
2245 value[MaxTextExtent];
2250 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
2251 n=vsnprintf(value,MaxTextExtent,format,operands);
2253 n=vsprintf(value,format,operands);
2256 value[MaxTextExtent-1]=
'\0';
2257 return(SetImageProperty(image,key,value));
2260 MagickExport MagickBooleanType FormatImagePropertyList(
Image *image,
2261 const char *property,
const char *format,va_list operands)
2264 value[MaxTextExtent];
2269 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
2270 n=vsnprintf(value,MaxTextExtent,format,operands);
2272 n=vsprintf(value,format,operands);
2275 value[MaxTextExtent-1]=
'\0';
2276 return(SetImageProperty(image,property,value));
2279 MagickExport MagickBooleanType FormatImageAttribute(
Image *image,
2280 const char *key,
const char *format,...)
2283 value[MaxTextExtent];
2291 va_start(operands,format);
2292 n=FormatLocaleStringList(value,MaxTextExtent,format,operands);
2295 return(SetImageProperty(image,key,value));
2328 MagickExport ssize_t FormatMagickStringList(
char *
string,
const size_t length,
2329 const char *format,va_list operands)
2334 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
2335 n=vsnprintf(
string,length,format,operands);
2337 n=vsprintf(
string,format,operands);
2340 string[length-1]=
'\0';
2341 return((ssize_t) n);
2344 MagickExport ssize_t FormatMagickString(
char *
string,
const size_t length,
2345 const char *format,...)
2353 va_start(operands,format);
2354 n=(ssize_t) FormatMagickStringList(
string,length,format,operands);
2386 MagickExport
void FormatStringList(
char *
string,
const char *format,
2392 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
2393 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
2394 n=vsnprintf(
string,MaxTextExtent,format,operands);
2396 n=vsprintf(
string,format,operands);
2399 string[MaxTextExtent-1]=
'\0';
2402 MagickExport
void FormatString(
char *
string,
const char *format,...)
2407 va_start(operands,format);
2408 (void) FormatLocaleStringList(
string,MaxTextExtent,format,operands);
2441 MagickExport
unsigned int FuzzyColorMatch(
const PixelPacket *p,
2450 if ((fuzz == 0.0) && (GetPixelRed(p) == GetPixelRed(q)) &&
2451 (GetPixelGreen(p) == GetPixelGreen(q)) &&
2452 (GetPixelBlue(p) == GetPixelBlue(q)))
2454 pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
2455 distance=pixel.red*pixel.red;
2456 if (distance > (fuzz*fuzz))
2457 return(MagickFalse);
2458 pixel.green=GetPixelGreen(p)-(MagickRealType)
2460 distance+=pixel.green*pixel.green;
2461 if (distance > (fuzz*fuzz))
2462 return(MagickFalse);
2463 pixel.blue=GetPixelBlue(p)-(MagickRealType) GetPixelBlue(q);
2464 distance+=pixel.blue*pixel.blue;
2465 if (distance > (fuzz*fuzz))
2466 return(MagickFalse);
2500 MagickExport MagickBooleanType FuzzyColorCompare(
const Image *image,
2503 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.2.5");
2504 return(IsColorSimilar(image,p,q));
2541 MagickExport MagickBooleanType FuzzyOpacityCompare(
const Image *image,
2544 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.2.5");
2545 return(IsOpacitySimilar(image,p,q));
2577 MagickExport
void *GetConfigureBlob(
const char *filename,
char *path,
2583 assert(filename != (
const char *) NULL);
2584 if (IsEventLogging() != MagickFalse)
2586 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",filename);
2587 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
2588 "last use: v5.5.7");
2590 assert(path != (
char *) NULL);
2591 assert(length != (
size_t *) NULL);
2594 (void) CopyMagickString(path,filename,MaxTextExtent);
2595 #if defined(MAGICKCORE_INSTALLED_SUPPORT)
2596 #if defined(MAGICKCORE_LIBRARY_PATH)
2597 if (blob == (
void *) NULL)
2602 (void) FormatLocaleString(path,MaxTextExtent,
"%s%s",
2603 MAGICKCORE_LIBRARY_PATH,filename);
2604 if (IsPathAccessible(path) != MagickFalse)
2605 blob=FileToBlob(path,~0UL,length,exception);
2608 #if defined(MAGICKCORE_WINDOWS_SUPPORT) && !(defined(MAGICKCORE_CONFIGURE_PATH) || defined(MAGICKCORE_SHARE_PATH))
2609 if (blob == (
void *) NULL)
2617 key_value=NTRegistryKeyLookup(
"ConfigurePath");
2618 if (key_value != (
unsigned char *) NULL)
2620 (void) FormatLocaleString(path,MaxTextExtent,
"%s%s%s",(
char *)
2621 key_value,DirectorySeparator,filename);
2622 if (IsPathAccessible(path) != MagickFalse)
2623 blob=FileToBlob(path,~0UL,length,exception);
2628 if (blob == (
void *) NULL)
2633 home=GetEnvironmentValue(
"MAGICK_HOME");
2634 if (home != (
char *) NULL)
2639 #if !defined(MAGICKCORE_POSIX_SUPPORT)
2640 (void) FormatLocaleString(path,MaxTextExtent,
"%s%s%s",home,
2641 DirectorySeparator,filename);
2643 (void) FormatLocaleString(path,MaxTextExtent,
"%s/lib/%s/%s",home,
2644 MAGICKCORE_LIBRARY_RELATIVE_PATH,filename);
2646 if (IsPathAccessible(path) != MagickFalse)
2647 blob=FileToBlob(path,~0UL,length,exception);
2648 home=DestroyString(home);
2650 home=GetEnvironmentValue(
"HOME");
2651 if (home == (
char *) NULL)
2652 home=GetEnvironmentValue(
"USERPROFILE");
2653 if (home != (
char *) NULL)
2658 (void) FormatLocaleString(path,MaxTextExtent,
"%s%s.magick%s%s",home,
2659 DirectorySeparator,DirectorySeparator,filename);
2660 if ((IsPathAccessible(path) != MagickFalse) && (blob == (
void *) NULL))
2661 blob=FileToBlob(path,~0UL,length,exception);
2662 home=DestroyString(home);
2665 if ((blob == (
void *) NULL) && (*GetClientPath() !=
'\0'))
2667 #if !defined(MAGICKCORE_POSIX_SUPPORT)
2668 (void) FormatLocaleString(path,MaxTextExtent,
"%s%s%s",GetClientPath(),
2669 DirectorySeparator,filename);
2672 prefix[MaxTextExtent];
2677 (void) CopyMagickString(prefix,GetClientPath(),
2679 ChopPathComponents(prefix,1);
2680 (void) FormatLocaleString(path,MaxTextExtent,
"%s/lib/%s/%s",prefix,
2681 MAGICKCORE_LIBRARY_RELATIVE_PATH,filename);
2683 if (IsPathAccessible(path) != MagickFalse)
2684 blob=FileToBlob(path,~0UL,length,exception);
2689 if ((blob == (
void *) NULL) && (IsPathAccessible(path) != MagickFalse))
2690 blob=FileToBlob(path,~0UL,length,exception);
2691 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
2695 if (blob == (
void *) NULL)
2696 blob=NTResourceToBlob(filename);
2699 if (blob == (
void *) NULL)
2700 (void) ThrowMagickException(exception,GetMagickModule(),ConfigureWarning,
2701 "UnableToOpenConfigureFile",
"`%s'",path);
2739 const ssize_t y,
const size_t columns,
const size_t rows)
2744 pixels=GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
2745 GetCacheViewException(cache_view));
2776 MagickExport IndexPacket *GetCacheViewIndexes(
CacheView *cache_view)
2778 return(GetCacheViewAuthenticIndexQueue(cache_view));
2815 const ssize_t y,
const size_t columns,
const size_t rows)
2820 pixels=GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
2821 GetCacheViewException(cache_view));
2847 MagickExport
void GetExceptionInfo(
ExceptionInfo *exception)
2850 (void) memset(exception,0,
sizeof(*exception));
2851 exception->severity=UndefinedException;
2852 exception->exceptions=(
void *) NewLinkedList(0);
2853 exception->semaphore=AllocateSemaphoreInfo();
2854 exception->signature=MagickCoreSignature;
2885 static void *DestroyAttribute(
void *attribute)
2891 if (p->value != (
char *) NULL)
2892 p->value=DestroyString(p->value);
2893 return(RelinquishMagickMemory(p));
2905 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.3.1");
2906 value=GetImageProperty(image,key);
2907 if (value == (
const char *) NULL)
2909 if (image->attributes == (
void *) NULL)
2910 ((
Image *) image)->attributes=NewSplayTree(CompareSplayTreeString,
2911 RelinquishMagickMemory,DestroyAttribute);
2918 image->attributes,key);
2922 attribute=(
ImageAttribute *) AcquireMagickMemory(
sizeof(*attribute));
2924 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
2925 (void) memset(attribute,0,
sizeof(*attribute));
2926 attribute->key=ConstantString(key);
2927 attribute->value=ConstantString(value);
2929 attribute->key,attribute);
2965 return(GetImageAttribute(image,
"8BIM:1999,2998"));
3000 MagickExport
Image *GetImageFromMagickRegistry(
const char *name,ssize_t *
id,
3004 return((
Image *) GetImageRegistry(ImageRegistryType,name,exception));
3037 MagickExport
void *GetMagickRegistry(
const ssize_t
id,RegistryType *type,
3046 *type=UndefinedRegistryType;
3048 (void) FormatLocaleString(key,MaxTextExtent,
"%.20g\n",(
double) id);
3049 blob=(
void *) GetImageRegistry(ImageRegistryType,key,exception);
3050 if (blob != (
void *) NULL)
3052 blob=(
void *) GetImageRegistry(ImageInfoRegistryType,key,exception);
3053 if (blob != (
void *) NULL)
3055 return((
void *) GetImageRegistry(UndefinedRegistryType,key,exception));
3088 MagickExport
void GetMagickToken(
const char *start,
const char **end,
char *token)
3090 (void) GetNextToken(start,end,~0UL,token);
3132 MagickExport
int GetImageGeometry(
Image *image,
const char *geometry,
3135 if (IsEventLogging() != MagickFalse)
3136 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.4");
3137 if (size_to_fit != MagickFalse)
3138 return((
int) ParseRegionGeometry(image,geometry,region_info,&image->exception));
3139 return((
int) ParsePageGeometry(image,geometry,region_info,&image->exception));
3174 MagickExport
Image *GetImageList(
const Image *images,
const ssize_t offset,
3180 if (images->debug != MagickFalse)
3181 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3182 image=CloneImage(GetImageFromList(images,(ssize_t) offset),0,0,MagickTrue,
3214 MagickExport ssize_t GetImageListIndex(
const Image *images)
3216 if (images->debug != MagickFalse)
3217 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3218 return(GetImageIndexInList(images));
3247 MagickExport
size_t GetImageListSize(
const Image *images)
3249 if (images->debug != MagickFalse)
3250 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3251 return(GetImageListLength(images));
3301 MagickExport
PixelPacket *GetImagePixels(
Image *image,
const ssize_t x,
const ssize_t y,
3302 const size_t columns,
const size_t rows)
3304 return(GetAuthenticPixels(image,x,y,columns,rows,&image->exception));
3338 MagickExport IndexPacket *GetIndexes(
const Image *image)
3340 return(GetAuthenticIndexQueue(image));
3379 MagickExport
unsigned int GetMagickGeometry(
const char *geometry,ssize_t *x,
3380 ssize_t *y,
size_t *width,
size_t *height)
3382 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.3");
3383 return(ParseMetaGeometry(geometry,x,y,width,height));
3412 MagickExport
Image *GetNextImage(
const Image *images)
3414 if (images->debug != MagickFalse)
3415 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3416 return(GetNextImageInList(images));
3453 property=GetNextImageProperty(image);
3454 if (property == (
const char *) NULL)
3456 return(GetImageAttribute(image,property));
3485 MagickExport
unsigned int GetNumberScenes(
const Image *image)
3487 if (IsEventLogging() != MagickFalse)
3488 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3489 return((
unsigned int) GetImageListLength(image));
3521 MagickExport
PixelPacket GetOnePixel(
Image *image,
const ssize_t x,
const ssize_t y)
3526 (void) GetOneAuthenticPixel(image,x,y,&pixel,&image->exception);
3562 return(GetAuthenticPixelQueue(image));
3591 MagickExport
Image *GetPreviousImage(
const Image *images)
3593 if (images->debug != MagickFalse)
3594 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
3595 return(GetPreviousImageInList(images));
3626 static inline MagickRealType HueToRGB(MagickRealType m1,MagickRealType m2,
3633 if ((6.0*hue) < 1.0)
3634 return(m1+6.0*(m2-m1)*hue);
3635 if ((2.0*hue) < 1.0)
3637 if ((3.0*hue) < 2.0)
3638 return(m1+6.0*(m2-m1)*(2.0/3.0-hue));
3642 MagickExport
void HSLTransform(
const double hue,
const double saturation,
3643 const double lightness,Quantum *red,Quantum *green,Quantum *blue)
3655 assert(red != (Quantum *) NULL);
3656 assert(green != (Quantum *) NULL);
3657 assert(blue != (Quantum *) NULL);
3658 if (lightness <= 0.5)
3659 m2=lightness*(saturation+1.0);
3661 m2=lightness+saturation-lightness*saturation;
3662 m1=2.0*lightness-m2;
3663 r=HueToRGB(m1,m2,hue+1.0/3.0);
3664 g=HueToRGB(m1,m2,hue);
3665 b=HueToRGB(m1,m2,hue-1.0/3.0);
3666 *red=ClampToQuantum((MagickRealType) QuantumRange*r);
3667 *green=ClampToQuantum((MagickRealType) QuantumRange*g);
3668 *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
3696 if (IsEventLogging() != MagickFalse)
3698 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
3699 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
3700 "last use: v5.5.7");
3707 #if defined(MAGICKCORE_WINGDI32_DELEGATE)
3759 (void) memset(&bitmap,0,
sizeof(bitmap));
3761 bitmap.bmWidth=(LONG) image->columns;
3762 bitmap.bmHeight=(LONG) image->rows;
3763 bitmap.bmWidthBytes=4*bitmap.bmWidth;
3765 bitmap.bmBitsPixel=32;
3767 length=bitmap.bmWidthBytes*bitmap.bmHeight;
3768 bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,length);
3769 if (bitmap_bitsH == NULL)
3774 message=GetExceptionMessage(errno);
3775 (void) ThrowMagickException(exception,GetMagickModule(),
3776 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",message);
3777 message=DestroyString(message);
3780 bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
3782 if (bitmap.bmBits == NULL)
3783 bitmap.bmBits=bitmap_bits;
3784 (void) SetImageColorspace(image,sRGBColorspace);
3785 for (y=0; y < (ssize_t) image->rows; y++)
3787 p=GetVirtualPixels(image,0,y,image->columns,1,exception);
3790 for (x=0; x < (ssize_t) image->columns; x++)
3792 q->rgbRed=ScaleQuantumToChar(GetPixelRed(p));
3793 q->rgbGreen=ScaleQuantumToChar(GetPixelGreen(p));
3794 q->rgbBlue=ScaleQuantumToChar(GetPixelBlue(p));
3800 bitmap.bmBits=bitmap_bits;
3801 bitmapH=CreateBitmapIndirect(&bitmap);
3802 if (bitmapH == NULL)
3807 message=GetExceptionMessage(errno);
3808 (void) ThrowMagickException(exception,GetMagickModule(),
3809 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",message);
3810 message=DestroyString(message);
3812 GlobalUnlock((HGLOBAL) bitmap_bitsH);
3813 GlobalFree((HGLOBAL) bitmap_bitsH);
3814 return((
void *) bitmapH);
3844 MagickExport
void InitializeMagick(
const char *path)
3846 MagickCoreGenesis(path,MagickFalse);
3894 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
3895 q=(pixels[0].red-pixels[1].red)-p;
3896 r=pixels[2].red-pixels[0].red;
3898 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3899 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
3900 q=(pixels[0].green-pixels[1].green)-p;
3901 r=pixels[2].green-pixels[0].green;
3903 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3904 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
3905 q=(pixels[0].blue-pixels[1].blue)-p;
3906 r=pixels[2].blue-pixels[0].blue;
3908 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3909 p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
3910 q=(pixels[0].opacity-pixels[1].opacity)-p;
3911 r=pixels[2].opacity-pixels[0].opacity;
3912 s=pixels[1].opacity;
3913 pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3914 if (pixel->colorspace == CMYKColorspace)
3916 p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
3917 q=(pixels[0].index-pixels[1].index)-p;
3918 r=pixels[2].index-pixels[0].index;
3920 pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3924 static inline MagickRealType CubicWeightingFunction(
const MagickRealType x)
3930 alpha=MagickMax(x+2.0,0.0);
3931 gamma=1.0*alpha*alpha*alpha;
3932 alpha=MagickMax(x+1.0,0.0);
3933 gamma-=4.0*alpha*alpha*alpha;
3934 alpha=MagickMax(x+0.0,0.0);
3935 gamma+=6.0*alpha*alpha*alpha;
3936 alpha=MagickMax(x-1.0,0.0);
3937 gamma-=4.0*alpha*alpha*alpha;
3941 static inline double MeshInterpolate(
const PointInfo *delta,
const double p,
3942 const double x,
const double y)
3944 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3947 static inline ssize_t NearestNeighbor(MagickRealType x)
3950 return((ssize_t) (x+0.5));
3951 return((ssize_t) (x-0.5));
3955 CacheView *image_view,
const InterpolatePixelMethod method,
const double x,
3970 assert(image != (
Image *) NULL);
3971 assert(image->signature == MagickCoreSignature);
3972 assert(image_view != (
CacheView *) NULL);
3973 GetMagickPixelPacket(image,&pixel);
3976 case AverageInterpolatePixel:
3987 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
3988 floor(y)-1,4,4,exception);
3991 indexes=GetCacheViewVirtualIndexQueue(image_view);
3992 for (i=0; i < 16L; i++)
3994 GetMagickPixelPacket(image,pixels+i);
3995 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
3997 if (image->matte != MagickFalse)
3999 alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
4000 pixels[i].red*=alpha[i];
4001 pixels[i].green*=alpha[i];
4002 pixels[i].blue*=alpha[i];
4003 if (image->colorspace == CMYKColorspace)
4004 pixels[i].index*=alpha[i];
4007 gamma=PerceptibleReciprocal(gamma);
4008 pixel.red+=gamma*0.0625*pixels[i].red;
4009 pixel.green+=gamma*0.0625*pixels[i].green;
4010 pixel.blue+=gamma*0.0625*pixels[i].blue;
4011 pixel.opacity+=0.0625*pixels[i].opacity;
4012 if (image->colorspace == CMYKColorspace)
4013 pixel.index+=gamma*0.0625*pixels[i].index;
4018 case BicubicInterpolatePixel:
4030 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
4031 floor(y)-1,4,4,exception);
4034 indexes=GetCacheViewVirtualIndexQueue(image_view);
4035 for (i=0; i < 4L; i++)
4036 GetMagickPixelPacket(image,u+i);
4037 for (i=0; i < 16L; i++)
4039 GetMagickPixelPacket(image,pixels+i);
4040 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
4042 if (image->matte != MagickFalse)
4044 alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
4045 pixels[i].red*=alpha[i];
4046 pixels[i].green*=alpha[i];
4047 pixels[i].blue*=alpha[i];
4048 if (image->colorspace == CMYKColorspace)
4049 pixels[i].index*=alpha[i];
4054 for (i=0; i < 4L; i++)
4056 GetMagickPixelPacket(image,pixels+4*i);
4057 BicubicInterpolate(pixels+4*i,delta.x,u+i);
4060 BicubicInterpolate(u,delta.y,&pixel);
4063 case BilinearInterpolatePixel:
4078 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
4079 floor(y),2,2,exception);
4082 indexes=GetCacheViewVirtualIndexQueue(image_view);
4083 for (i=0; i < 4L; i++)
4085 GetMagickPixelPacket(image,pixels+i);
4086 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
4088 if (image->matte != MagickFalse)
4090 alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
4091 pixels[i].red*=alpha[i];
4092 pixels[i].green*=alpha[i];
4093 pixels[i].blue*=alpha[i];
4094 if (image->colorspace == CMYKColorspace)
4095 pixels[i].index*=alpha[i];
4101 gamma=(((1.0-delta.y)*((1.0-delta.x)*alpha[0]+delta.x*alpha[1])+delta.y*
4102 ((1.0-delta.x)*alpha[2]+delta.x*alpha[3])));
4103 gamma=PerceptibleReciprocal(gamma);
4104 pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
4105 pixels[1].red)+delta.y*((1.0-delta.x)*pixels[2].red+delta.x*
4107 pixel.green=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].green+delta.x*
4108 pixels[1].green)+delta.y*((1.0-delta.x)*pixels[2].green+
4109 delta.x*pixels[3].green));
4110 pixel.blue=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].blue+delta.x*
4111 pixels[1].blue)+delta.y*((1.0-delta.x)*pixels[2].blue+delta.x*
4113 pixel.opacity=((1.0-delta.y)*((1.0-delta.x)*pixels[0].opacity+delta.x*
4114 pixels[1].opacity)+delta.y*((1.0-delta.x)*pixels[2].opacity+delta.x*
4115 pixels[3].opacity));
4116 if (image->colorspace == CMYKColorspace)
4117 pixel.index=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].index+delta.x*
4118 pixels[1].index)+delta.y*((1.0-delta.x)*pixels[2].index+delta.x*
4122 case FilterInterpolatePixel:
4136 geometry.x=(ssize_t) floor(x)-1L;
4137 geometry.y=(ssize_t) floor(y)-1L;
4138 excerpt_image=ExcerptImage(image,&geometry,exception);
4139 if (excerpt_image == (
Image *) NULL)
4141 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4143 excerpt_image=DestroyImage(excerpt_image);
4144 if (filter_image == (
Image *) NULL)
4146 p=GetVirtualPixels(filter_image,0,0,1,1,exception);
4149 filter_image=DestroyImage(filter_image);
4152 indexes=GetVirtualIndexQueue(filter_image);
4153 GetMagickPixelPacket(image,pixels);
4154 SetMagickPixelPacket(image,p,indexes,&pixel);
4155 filter_image=DestroyImage(filter_image);
4158 case IntegerInterpolatePixel:
4163 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
4164 floor(y),1,1,exception);
4167 indexes=GetCacheViewVirtualIndexQueue(image_view);
4168 GetMagickPixelPacket(image,pixels);
4169 SetMagickPixelPacket(image,p,indexes,&pixel);
4172 case MeshInterpolatePixel:
4187 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
4188 floor(y),2,2,exception);
4191 indexes=GetCacheViewVirtualIndexQueue(image_view);
4192 for (i=0; i < 4L; i++)
4194 GetMagickPixelPacket(image,pixels+i);
4195 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
4197 if (image->matte != MagickFalse)
4199 alpha[i]=QuantumScale*((MagickRealType) GetPixelAlpha(p));
4200 pixels[i].red*=alpha[i];
4201 pixels[i].green*=alpha[i];
4202 pixels[i].blue*=alpha[i];
4203 if (image->colorspace == CMYKColorspace)
4204 pixels[i].index*=alpha[i];
4210 luminance.x=MagickPixelLuma(pixels+0)-MagickPixelLuma(pixels+3);
4211 luminance.y=MagickPixelLuma(pixels+1)-MagickPixelLuma(pixels+2);
4212 if (fabs(luminance.x) < fabs(luminance.y))
4217 if (delta.x <= delta.y)
4222 delta.y=1.0-delta.y;
4223 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4224 gamma=PerceptibleReciprocal(gamma);
4225 pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
4226 pixels[3].red,pixels[0].red);
4227 pixel.green=gamma*MeshInterpolate(&delta,pixels[2].green,
4228 pixels[3].green,pixels[0].green);
4229 pixel.blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4230 pixels[3].blue,pixels[0].blue);
4231 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
4232 pixels[3].opacity,pixels[0].opacity);
4233 if (image->colorspace == CMYKColorspace)
4234 pixel.index=gamma*MeshInterpolate(&delta,pixels[2].index,
4235 pixels[3].index,pixels[0].index);
4242 delta.x=1.0-delta.x;
4243 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4244 gamma=PerceptibleReciprocal(gamma);
4245 pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
4246 pixels[0].red,pixels[3].red);
4247 pixel.green=gamma*MeshInterpolate(&delta,pixels[1].green,
4248 pixels[0].green,pixels[3].green);
4249 pixel.blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4250 pixels[0].blue,pixels[3].blue);
4251 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
4252 pixels[0].opacity,pixels[3].opacity);
4253 if (image->colorspace == CMYKColorspace)
4254 pixel.index=gamma*MeshInterpolate(&delta,pixels[1].index,
4255 pixels[0].index,pixels[3].index);
4263 if (delta.x <= (1.0-delta.y))
4268 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4269 gamma=PerceptibleReciprocal(gamma);
4270 pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
4271 pixels[1].red,pixels[2].red);
4272 pixel.green=gamma*MeshInterpolate(&delta,pixels[0].green,
4273 pixels[1].green,pixels[2].green);
4274 pixel.blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4275 pixels[1].blue,pixels[2].blue);
4276 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
4277 pixels[1].opacity,pixels[2].opacity);
4278 if (image->colorspace == CMYKColorspace)
4279 pixel.index=gamma*MeshInterpolate(&delta,pixels[0].index,
4280 pixels[1].index,pixels[2].index);
4287 delta.x=1.0-delta.x;
4288 delta.y=1.0-delta.y;
4289 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4290 gamma=PerceptibleReciprocal(gamma);
4291 pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
4292 pixels[2].red,pixels[1].red);
4293 pixel.green=gamma*MeshInterpolate(&delta,pixels[3].green,
4294 pixels[2].green,pixels[1].green);
4295 pixel.blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4296 pixels[2].blue,pixels[1].blue);
4297 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
4298 pixels[2].opacity,pixels[1].opacity);
4299 if (image->colorspace == CMYKColorspace)
4300 pixel.index=gamma*MeshInterpolate(&delta,pixels[3].index,
4301 pixels[2].index,pixels[1].index);
4306 case NearestNeighborInterpolatePixel:
4311 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
4312 NearestNeighbor(y),1,1,exception);
4315 indexes=GetCacheViewVirtualIndexQueue(image_view);
4316 GetMagickPixelPacket(image,pixels);
4317 SetMagickPixelPacket(image,p,indexes,&pixel);
4320 case SplineInterpolatePixel:
4340 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
4341 floor(y)-1,4,4,exception);
4344 indexes=GetCacheViewVirtualIndexQueue(image_view);
4348 for (i=(-1); i < 3L; i++)
4350 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
4351 for (j=(-1); j < 3L; j++)
4353 GetMagickPixelPacket(image,pixels+n);
4354 SetMagickPixelPacket(image,p,indexes+n,pixels+n);
4356 if (image->matte != MagickFalse)
4358 alpha[n]=QuantumScale*((MagickRealType)
4360 pixels[n].red*=alpha[n];
4361 pixels[n].green*=alpha[n];
4362 pixels[n].blue*=alpha[n];
4363 if (image->colorspace == CMYKColorspace)
4364 pixels[n].index*=alpha[n];
4366 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
4368 gamma=PerceptibleReciprocal(gamma);
4369 pixel.red+=gamma*dx*dy*pixels[n].red;
4370 pixel.green+=gamma*dx*dy*pixels[n].green;
4371 pixel.blue+=gamma*dx*dy*pixels[n].blue;
4372 if (image->matte != MagickFalse)
4373 pixel.opacity+=dx*dy*pixels[n].opacity;
4374 if (image->colorspace == CMYKColorspace)
4375 pixel.index+=gamma*dx*dy*pixels[n].index;
4419 MagickExport
char *InterpretImageAttributes(
const ImageInfo *image_info,
4420 Image *image,
const char *embed_text)
4422 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.3.1");
4423 return(InterpretImageProperties(image_info,image,embed_text));
4448 MagickExport MagickRealType InversesRGBCompandor(
const MagickRealType pixel)
4450 if (pixel <= (0.0404482362771076*QuantumRange))
4451 return(pixel/12.92);
4452 return(QuantumRange*pow((QuantumScale*pixel+0.055)/1.055,2.4));
4475 MagickExport MagickBooleanType IsMagickInstantiated(
void)
4477 return(IsMagickCoreInstantiated());
4506 MagickExport
unsigned int IsSubimage(
const char *geometry,
4507 const unsigned int pedantic)
4509 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
4510 if (geometry == (
const char *) NULL)
4511 return(MagickFalse);
4512 if ((strchr(geometry,
'x') != (
char *) NULL) ||
4513 (strchr(geometry,
'X') != (
char *) NULL))
4514 return(MagickFalse);
4515 if ((pedantic != MagickFalse) && (strchr(geometry,
',') != (
char *) NULL))
4516 return(MagickFalse);
4565 MagickBooleanType LevelImageColors(
Image *image,
const ChannelType channel,
4567 const MagickBooleanType invert)
4569 return(LevelColorsImageChannel(image,channel,black_color,white_color,invert));
4595 MagickExport
void LiberateMemory(
void **memory)
4597 assert(memory != (
void **) NULL);
4598 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
4599 if (*memory == (
void *) NULL)
4602 *memory=(
void *) NULL;
4631 MagickExport
void LiberateSemaphoreInfo(
SemaphoreInfo **semaphore_info)
4633 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
4634 UnlockSemaphoreInfo(*semaphore_info);
4664 MagickExport
void MagickIncarnate(
const char *path)
4666 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.1");
4667 MagickCoreGenesis(path,MagickFalse);
4702 MagickExport MagickBooleanType MagickMonitor(
const char *text,
4703 const MagickOffsetType offset,
const MagickSizeType span,
4704 void *magick_unused(client_data))
4712 magick_unreferenced(client_data);
4714 assert(text != (
const char *) NULL);
4715 if (IsEventLogging() != MagickFalse)
4716 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",text);
4717 ProcessPendingEvents(text);
4719 exception=AcquireExceptionInfo();
4720 if (monitor_handler != (MonitorHandler) NULL)
4721 status=(*monitor_handler)(text,offset,span,exception);
4722 exception=DestroyExceptionInfo(exception);
4763 MagickExport MagickBooleanType MapImage(
Image *image,
const Image *map_image,
4764 const MagickBooleanType dither)
4772 assert(image != (
Image *) NULL);
4773 assert(image->signature == MagickCoreSignature);
4774 assert(map_image != (
Image *) NULL);
4775 assert(map_image->signature == MagickCoreSignature);
4776 if (IsEventLogging() != MagickFalse)
4777 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4778 GetQuantizeInfo(&quantize_info);
4779 quantize_info.dither=dither;
4780 return(RemapImage(&quantize_info,image,map_image));
4820 MagickExport MagickBooleanType MapImages(
Image *images,
const Image *map_image,
4821 const MagickBooleanType dither)
4826 assert(images != (
Image *) NULL);
4827 assert(images->signature == MagickCoreSignature);
4828 if (IsEventLogging() != MagickFalse)
4829 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
4830 GetQuantizeInfo(&quantize_info);
4831 quantize_info.dither=dither;
4832 return(RemapImages(&quantize_info,images,map_image));
4878 MagickExport MagickBooleanType MatteFloodfillImage(
Image *image,
4879 const PixelPacket target,
const Quantum opacity,
const ssize_t x_offset,
4880 const ssize_t y_offset,
const PaintMethod method)
4905 assert(image != (
Image *) NULL);
4906 assert(image->signature == MagickCoreSignature);
4907 if (IsEventLogging() != MagickFalse)
4908 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4909 if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
4910 return(MagickFalse);
4911 if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
4912 return(MagickFalse);
4913 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
4914 return(MagickFalse);
4915 if (image->matte == MagickFalse)
4916 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
4917 floodplane_image=CloneImage(image,0,0,MagickTrue,&image->exception);
4918 if (floodplane_image == (
Image *) NULL)
4919 return(MagickFalse);
4920 (void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel);
4924 segment_stack=(
SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
4925 sizeof(*segment_stack));
4928 floodplane_image=DestroyImage(floodplane_image);
4929 ThrowBinaryImageException(ResourceLimitError,
"MemoryAllocationFailed",
4939 PushSegmentStack(y,x,x,1);
4940 PushSegmentStack(y+1,x,x,-1);
4941 while (s > segment_stack)
4958 offset=(ssize_t) s->y2;
4959 y=(ssize_t) s->y1+offset;
4963 p=GetVirtualPixels(image,0,y,(
size_t) (x1+1),1,&image->exception);
4964 q=GetAuthenticPixels(floodplane_image,0,y,(
size_t) (x1+1),1,
4970 for (x=x1; x >= 0; x--)
4972 if (q->opacity == (Quantum) TransparentOpacity)
4974 if (method == FloodfillMethod)
4976 if (IsColorSimilar(image,p,&target) == MagickFalse)
4980 if (IsColorSimilar(image,p,&target) != MagickFalse)
4982 q->opacity=(Quantum) TransparentOpacity;
4986 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
4988 skip=x >= x1 ? MagickTrue : MagickFalse;
4989 if (skip == MagickFalse)
4993 PushSegmentStack(y,start,x1-1,-offset);
4998 if (skip == MagickFalse)
5000 if (x < (ssize_t) image->columns)
5002 p=GetVirtualPixels(image,x,y,image->columns-x,1,
5004 q=GetAuthenticPixels(floodplane_image,x,y,image->columns-x,1,
5009 for ( ; x < (ssize_t) image->columns; x++)
5011 if (q->opacity == (Quantum) TransparentOpacity)
5013 if (method == FloodfillMethod)
5015 if (IsColorSimilar(image,p,&target) == MagickFalse)
5019 if (IsColorSimilar(image,p,&target) != MagickFalse)
5021 q->opacity=(Quantum) TransparentOpacity;
5025 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
5028 PushSegmentStack(y,start,x-1,offset);
5030 PushSegmentStack(y,x2+1,x-1,-offset);
5036 p=GetVirtualPixels(image,x,y,(
size_t) (x2-x+1),1,
5038 q=GetAuthenticPixels(floodplane_image,x,y,(
size_t) (x2-x+1),1,
5042 for ( ; x <= x2; x++)
5044 if (q->opacity == (Quantum) TransparentOpacity)
5046 if (method == FloodfillMethod)
5048 if (IsColorSimilar(image,p,&target) != MagickFalse)
5052 if (IsColorSimilar(image,p,&target) == MagickFalse)
5061 for (y=0; y < (ssize_t) image->rows; y++)
5075 p=GetVirtualPixels(floodplane_image,0,y,image->columns,1,
5077 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
5080 for (x=0; x < (ssize_t) image->columns; x++)
5082 if (GetPixelOpacity(p) != OpaqueOpacity)
5087 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
5090 segment_stack=(
SegmentInfo *) RelinquishMagickMemory(segment_stack);
5091 floodplane_image=DestroyImage(floodplane_image);
5092 return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
5125 return(EvaluateImages(images,MinEvaluateOperator,exception));
5158 return(EvaluateImages(images,MinEvaluateOperator,exception));
5195 MagickExport
Image *MedianFilterImage(
const Image *image,
const double radius,
5201 median_image=StatisticImage(image,MedianStatistic,(
size_t) radius,(
size_t)
5203 return(median_image);
5234 MagickExport
Image *ModeImage(
const Image *image,
const double radius,
5240 mode_image=StatisticImage(image,ModeStatistic,(
size_t) radius,(
size_t) radius,
5275 return(MergeImageLayers(image,MosaicLayer,exception));
5312 MagickExport MagickBooleanType OpaqueImage(
Image *image,
5315 #define OpaqueImageTag "Opaque/Image"
5329 assert(image != (
Image *) NULL);
5330 assert(image->signature == MagickCoreSignature);
5331 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.1.0");
5332 if (IsEventLogging() != MagickFalse)
5333 (
void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
5334 switch (image->storage_class)
5342 for (y=0; y < (ssize_t) image->rows; y++)
5350 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
5353 for (x=0; x < (ssize_t) image->columns; x++)
5355 if (IsColorSimilar(image,q,&target) != MagickFalse)
5359 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
5361 proceed=SetImageProgress(image,OpaqueImageTag,(MagickOffsetType) y,
5363 if (proceed == MagickFalse)
5373 for (i=0; i < (ssize_t) image->colors; i++)
5375 if (IsColorSimilar(image,&image->colormap[i],&target) != MagickFalse)
5376 image->colormap[i]=fill;
5378 if (fill.opacity != OpaqueOpacity)
5380 for (y=0; y < (ssize_t) image->rows; y++)
5388 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
5391 for (x=0; x < (ssize_t) image->columns; x++)
5393 if (IsColorSimilar(image,q,&target) != MagickFalse)
5394 q->opacity=fill.opacity;
5397 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
5401 (void) SyncImage(image);
5405 if (fill.opacity != OpaqueOpacity)
5406 image->matte=MagickTrue;
5439 return(AcquireVirtualCacheView(image,&((
Image *) image)->exception));
5468 #if defined(MAGICKCORE_HAVE__WFOPEN)
5469 static size_t UTF8ToUTF16(
const unsigned char *utf8,
wchar_t *utf16)
5474 if (utf16 != (
wchar_t *) NULL)
5486 for (p=utf8; *p !=
'\0'; p++)
5488 if ((*p & 0x80) == 0)
5491 if ((*p & 0xE0) == 0xC0)
5496 if ((*p & 0xC0) != 0x80)
5501 if ((*p & 0xF0) == 0xE0)
5506 if ((*p & 0xC0) != 0x80)
5509 *q|=(c & 0x3F) << 6;
5511 if ((*p & 0xC0) != 0x80)
5525 for (p=utf8; *p !=
'\0'; p++)
5527 if ((*p & 0x80) == 0)
5530 if ((*p & 0xE0) == 0xC0)
5533 if ((*p & 0xC0) != 0x80)
5537 if ((*p & 0xF0) == 0xE0)
5540 if ((*p & 0xC0) != 0x80)
5543 if ((*p & 0xC0) != 0x80)
5552 static wchar_t *ConvertUTF8ToUTF16(
const unsigned char *source)
5560 length=UTF8ToUTF16(source,(
wchar_t *) NULL);
5569 length=strlen((
const char *) source);
5570 utf16=(
wchar_t *) AcquireQuantumMemory(length+1,
sizeof(*utf16));
5571 if (utf16 == (
wchar_t *) NULL)
5572 return((
wchar_t *) NULL);
5573 for (i=0; i <= (ssize_t) length; i++)
5577 utf16=(
wchar_t *) AcquireQuantumMemory(length+1,
sizeof(*utf16));
5578 if (utf16 == (
wchar_t *) NULL)
5579 return((
wchar_t *) NULL);
5580 length=UTF8ToUTF16(source,utf16);
5585 MagickExport FILE *OpenMagickStream(
const char *path,
const char *mode)
5590 if ((path == (
const char *) NULL) || (mode == (
const char *) NULL))
5593 return((FILE *) NULL);
5596 #if defined(MAGICKCORE_HAVE__WFOPEN)
5602 unicode_path=ConvertUTF8ToUTF16((
const unsigned char *) path);
5603 if (unicode_path == (
wchar_t *) NULL)
5604 return((FILE *) NULL);
5605 unicode_mode=ConvertUTF8ToUTF16((
const unsigned char *) mode);
5606 if (unicode_mode == (
wchar_t *) NULL)
5608 unicode_path=(
wchar_t *) RelinquishMagickMemory(unicode_path);
5609 return((FILE *) NULL);
5611 file=_wfopen(unicode_path,unicode_mode);
5612 unicode_mode=(
wchar_t *) RelinquishMagickMemory(unicode_mode);
5613 unicode_path=(
wchar_t *) RelinquishMagickMemory(unicode_path);
5616 if (file == (FILE *) NULL)
5617 file=fopen(path,mode);
5671 MagickExport MagickBooleanType PaintFloodfillImage(
Image *image,
5673 const ssize_t y,
const DrawInfo *draw_info,
const PaintMethod method)
5678 status=FloodfillPaintImage(image,channel,draw_info,target,x,y,
5679 method == FloodfillMethod ? MagickFalse : MagickTrue);
5726 MagickExport MagickBooleanType PaintOpaqueImage(
Image *image,
5732 status=OpaquePaintImageChannel(image,DefaultChannels,target,fill,MagickFalse);
5736 MagickExport MagickBooleanType PaintOpaqueImageChannel(
Image *image,
5740 return(OpaquePaintImageChannel(image,channel,target,fill,MagickFalse));
5781 MagickExport MagickBooleanType PaintTransparentImage(
Image *image,
5784 return(TransparentPaintImage(image,target,opacity,MagickFalse));
5826 MagickExport
int ParseImageGeometry(
const char *geometry,ssize_t *x,ssize_t *y,
5827 size_t *width,
size_t *height)
5829 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.1");
5830 return((
int) ParseMetaGeometry(geometry,x,y,width,height));
5864 MagickExport MagickStatusType ParseSizeGeometry(
const Image *image,
5870 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.4.7");
5871 SetGeometry(image,region_info);
5872 flags=ParseMetaGeometry(geometry,®ion_info->x,®ion_info->y,
5873 ®ion_info->width,®ion_info->height);
5903 MagickExport
Image *PopImageList(
Image **images)
5905 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
5906 return(RemoveLastImageFromList(images));
5939 MagickExport
size_t PopImagePixels(
Image *image,
const QuantumType quantum,
5940 unsigned char *destination)
5948 quantum_info=AcquireQuantumInfo((
const ImageInfo *) NULL,image);
5951 length=ExportQuantumPixels(image,(
const CacheView *) NULL,quantum_info,
5952 quantum,destination,&image->exception);
5953 quantum_info=DestroyQuantumInfo(quantum_info);
5986 MagickExport
char *PostscriptGeometry(
const char *page)
5988 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.1");
5989 return(GetPageGeometry(page));
6023 MagickExport
unsigned int PushImageList(
Image **images,
const Image *image,
6026 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
6027 AppendImageToList(images,CloneImageList(image,exception));
6062 MagickExport
size_t PushImagePixels(
Image *image,
const QuantumType quantum,
6063 const unsigned char *source)
6071 quantum_info=AcquireQuantumInfo((
const ImageInfo *) NULL,image);
6074 length=ImportQuantumPixels(image,(
CacheView *) NULL,quantum_info,quantum,
6075 source,&image->exception);
6076 quantum_info=DestroyQuantumInfo(quantum_info);
6124 MagickExport
unsigned int QuantizationError(
Image *image)
6126 if (IsEventLogging() != MagickFalse)
6127 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.3");
6128 return(GetImageQuantizeError(image));
6165 MagickExport
Image *RadialBlurImage(
const Image *image,
const double angle,
6168 return(RotationalBlurImage(image,angle,exception));
6171 MagickExport
Image *RadialBlurImageChannel(
const Image *image,
6172 const ChannelType channel,
const double angle,
ExceptionInfo *exception)
6174 return(RotationalBlurImageChannel(image,channel,angle,exception));
6210 MagickExport
unsigned int RandomChannelThresholdImage(
Image *image,
6211 const char *channel,
const char *thresholds,
ExceptionInfo *exception)
6213 #define RandomChannelThresholdImageText " RandomChannelThreshold image... "
6226 static MagickRealType
6227 o2[4]={0.2f, 0.6f, 0.8f, 0.4f},
6228 o3[9]={0.1f, 0.6f, 0.3f, 0.7f, 0.5f, 0.8f, 0.4f, 0.9f, 0.2f},
6229 o4[16]={0.1f, 0.7f, 1.1f, 0.3f, 1.0f, 0.5f, 1.5f, 0.8f, 1.4f, 1.6f, 0.6f,
6230 1.2f, 0.4f, 0.9f, 1.3f, 0.2f},
6239 assert(image != (
Image *) NULL);
6240 assert(image->signature == MagickCoreSignature);
6241 if (IsEventLogging() != MagickFalse)
6242 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
6244 assert(exception->signature == MagickCoreSignature);
6245 if (IsEventLogging() != MagickFalse)
6246 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
6247 if (thresholds == (
const char *) NULL)
6251 if (LocaleCompare(thresholds,
"2x2") == 0)
6254 if (LocaleCompare(thresholds,
"3x3") == 0)
6257 if (LocaleCompare(thresholds,
"4x4") == 0)
6262 count=(ssize_t) sscanf(thresholds,
"%lf[/x%%]%lf",&lower_threshold,
6264 if (strchr(thresholds,
'%') != (
char *) NULL)
6266 upper_threshold*=(.01*QuantumRange);
6267 lower_threshold*=(.01*QuantumRange);
6270 upper_threshold=(MagickRealType) QuantumRange-lower_threshold;
6272 if (IsEventLogging() != MagickFalse)
6273 (
void) LogMagickEvent(TransformEvent,GetMagickModule(),
6274 " RandomChannelThresholdImage: channel type=%s",channel);
6275 if (IsEventLogging() != MagickFalse)
6276 (void) LogMagickEvent(TransformEvent,GetMagickModule(),
6277 " Thresholds: %s (%fx%f)",thresholds,lower_threshold,upper_threshold);
6278 if (LocaleCompare(channel,
"all") == 0 ||
6279 LocaleCompare(channel,
"intensity") == 0)
6280 if (AcquireImageColormap(image,2) == MagickFalse)
6281 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
6283 random_info=AcquireRandomInfo();
6284 for (y=0; y < (ssize_t) image->rows; y++)
6291 *magick_restrict indexes;
6296 q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
6299 if (LocaleCompare(channel,
"all") == 0 ||
6300 LocaleCompare(channel,
"intensity") == 0)
6302 indexes=GetAuthenticIndexQueue(image);
6303 for (x=0; x < (ssize_t) image->columns; x++)
6308 intensity=GetPixelIntensity(image,q);
6311 if (intensity < lower_threshold)
6312 threshold=lower_threshold;
6313 else if (intensity > upper_threshold)
6314 threshold=upper_threshold;
6316 threshold=(MagickRealType) (QuantumRange*
6317 GetPseudoRandomValue(random_info));
6319 else if (order == 2)
6320 threshold=(MagickRealType) QuantumRange*o2[(x%2)+2*(y%2)];
6321 else if (order == 3)
6322 threshold=(MagickRealType) QuantumRange*o3[(x%3)+3*(y%3)];
6323 else if (order == 4)
6324 threshold=(MagickRealType) QuantumRange*o4[(x%4)+4*(y%4)];
6325 index=(IndexPacket) (intensity <= threshold ? 0 : 1);
6326 SetPixelIndex(indexes+x,index);
6327 SetPixelRGBO(q,image->colormap+(ssize_t) index);
6331 if (LocaleCompare(channel,
"opacity") == 0 ||
6332 LocaleCompare(channel,
"all") == 0 ||
6333 LocaleCompare(channel,
"matte") == 0)
6335 if (image->matte != MagickFalse)
6336 for (x=0; x < (ssize_t) image->columns; x++)
6340 if ((MagickRealType) q->opacity < lower_threshold)
6341 threshold=lower_threshold;
6342 else if ((MagickRealType) q->opacity > upper_threshold)
6343 threshold=upper_threshold;
6345 threshold=(MagickRealType) (QuantumRange*
6346 GetPseudoRandomValue(random_info));
6348 else if (order == 2)
6349 threshold=(MagickRealType) QuantumRange*o2[(x%2)+2*(y%2)];
6350 else if (order == 3)
6351 threshold=(MagickRealType) QuantumRange*o3[(x%3)+3*(y%3)];
6352 else if (order == 4)
6353 threshold=(MagickRealType) QuantumRange*o4[(x%4)+4*(y%4)]/1.7;
6354 SetPixelOpacity(q,(MagickRealType) q->opacity <=
6355 threshold ? 0 : QuantumRange);
6362 if (LocaleCompare(channel,
"intensity") != 0)
6363 ThrowBinaryException(OptionError,
"UnrecognizedChannelType",
6366 if (SyncAuthenticPixels(image,exception) == MagickFalse)
6369 random_info=DestroyRandomInfo(random_info);
6400 MagickExport
void ReacquireMemory(
void **memory,
const size_t size)
6405 assert(memory != (
void **) NULL);
6406 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
6407 if (*memory == (
void *) NULL)
6409 *memory=AcquireMagickMemory(size);
6412 allocation=realloc(*memory,size);
6413 if (allocation == (
void *) NULL)
6414 *memory=RelinquishMagickMemory(*memory);
6453 MagickExport
Image *RecolorImage(
const Image *image,
const size_t order,
6462 kernel_info=AcquireKernelInfo(
"1");
6464 return((
Image *) NULL);
6465 kernel_info->width=order;
6466 kernel_info->height=order;
6467 kernel_info->values=(
double *) color_matrix;
6468 recolor_image=ColorMatrixImage(image,kernel_info,exception);
6469 kernel_info->values=(
double *) NULL;
6470 kernel_info=DestroyKernelInfo(kernel_info);
6471 return(recolor_image);
6504 MagickExport
Image *ReduceNoiseImage(
const Image *image,
const double radius,
6510 reduce_image=StatisticImage(image,NonpeakStatistic,(
size_t) radius,(
size_t)
6512 return(reduce_image);
6537 MagickExport
void RelinquishSemaphoreInfo(
SemaphoreInfo *semaphore_info)
6540 UnlockSemaphoreInfo(semaphore_info);
6571 MagickExport
void ResetImageAttributeIterator(
const Image *image)
6573 ResetImagePropertyIterator(image);
6610 const ssize_t y,
const size_t columns,
const size_t rows)
6615 pixels=QueueCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
6616 GetCacheViewException(cache_view));
6645 MagickExport
void SetCacheThreshold(
const size_t size)
6647 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.1");
6648 (void) SetMagickResourceLimit(MemoryResource,size*1024*1024);
6649 (void) SetMagickResourceLimit(MapResource,2*size*1024*1024);
6677 MagickExport MagickBooleanType SetExceptionInfo(
ExceptionInfo *exception,
6678 ExceptionType severity)
6681 ClearMagickException(exception);
6682 exception->severity=severity;
6713 MagickExport
void SetImage(
Image *image,
const Quantum opacity)
6721 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.2.0");
6722 assert(image != (
Image *) NULL);
6723 if (IsEventLogging() != MagickFalse)
6724 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
6725 assert(image->signature == MagickCoreSignature);
6726 background_color=image->background_color;
6727 if (opacity != OpaqueOpacity)
6728 background_color.opacity=opacity;
6729 if (background_color.opacity != OpaqueOpacity)
6731 (void) SetImageStorageClass(image,DirectClass);
6732 image->matte=MagickTrue;
6734 if ((image->storage_class == PseudoClass) ||
6735 (image->colorspace == CMYKColorspace))
6740 for (y=0; y < (ssize_t) image->rows; y++)
6743 *magick_restrict indexes;
6751 q=QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
6754 for (x=0; x < (ssize_t) image->columns; x++)
6756 SetPixelRGBO(q,&background_color);
6759 indexes=GetAuthenticIndexQueue(image);
6760 for (x=0; x < (ssize_t) image->columns; x++)
6761 SetPixelIndex(indexes+x,0);
6762 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
6770 for (y=0; y < (ssize_t) image->rows; y++)
6778 q=QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
6781 for (x=0; x < (ssize_t) image->columns; x++)
6783 SetPixelRGBO(q,&background_color);
6786 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
6824 MagickExport MagickBooleanType SetImageAttribute(
Image *image,
const char *key,
6827 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.3.1");
6828 return(SetImageProperty(image,key,value));
6860 MagickExport
unsigned int SetImageList(
Image **images,
const Image *image,
6869 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
6870 clone=CloneImageList(image,exception);
6871 while (GetPreviousImageInList(*images) != (
Image *) NULL)
6872 (*images)=GetPreviousImageInList(*images);
6873 for (i=0; i < offset; i++)
6875 if (GetNextImageInList(*images) == (
Image *) NULL)
6876 return(MagickFalse);
6877 (*images)=GetNextImageInList(*images);
6879 InsertImageInList(images,clone);
6943 MagickExport
PixelPacket *SetImagePixels(
Image *image,
const ssize_t x,
const ssize_t y,
6944 const size_t columns,
const size_t rows)
6946 return(QueueAuthenticPixels(image,x,y,columns,rows,&image->exception));
6980 MagickExport ssize_t SetMagickRegistry(
const RegistryType type,
const void *blob,
6981 const size_t magick_unused(length),
ExceptionInfo *exception)
6992 magick_unreferenced(length);
6994 (void) FormatLocaleString(key,MaxTextExtent,
"%.20g\n",(
double) id);
6995 status=SetImageRegistry(type,key,blob,exception);
6996 if (status == MagickFalse)
7025 MagickExport MonitorHandler GetMonitorHandler(
void)
7027 return(monitor_handler);
7030 MagickExport MonitorHandler SetMonitorHandler(MonitorHandler handler)
7035 previous_handler=monitor_handler;
7036 monitor_handler=handler;
7037 return(previous_handler);
7066 MagickExport
Image *ShiftImageList(
Image **images)
7068 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
7069 return(RemoveFirstImageFromList(images));
7101 MagickExport MagickOffsetType SizeBlob(
Image *image)
7103 if (IsEventLogging() != MagickFalse)
7104 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.4.3");
7105 return((MagickOffsetType) GetBlobSize(image));
7141 MagickExport
Image *SpliceImageList(
Image *images,
const ssize_t offset,
7150 if (images->debug != MagickFalse)
7151 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
7152 clone=CloneImageList(splices,exception);
7153 while (GetPreviousImageInList(images) != (
Image *) NULL)
7154 images=GetPreviousImageInList(images);
7155 for (i=0; i < offset; i++)
7157 if (GetNextImageInList(images) == (
Image *) NULL)
7158 return((
Image *) NULL);
7159 images=GetNextImageInList(images);
7161 (void) SpliceImageIntoList(&images,length,clone);
7187 MagickExport MagickRealType sRGBCompandor(
const MagickRealType pixel)
7189 if (pixel <= (0.0031306684425005883*QuantumRange))
7190 return(12.92*pixel);
7191 return(QuantumRange*(1.055*pow(QuantumScale*pixel,1.0/2.4)-0.055));
7217 MagickExport
void Strip(
char *message)
7223 assert(message != (
char *) NULL);
7224 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
7225 if (*message ==
'\0')
7227 if (strlen(message) == 1)
7230 while (isspace((
int) ((
unsigned char) *p)) != 0)
7232 if ((*p ==
'\'') || (*p ==
'"'))
7234 q=message+strlen(message)-1;
7235 while ((isspace((
int) ((
unsigned char) *q)) != 0) && (q > p))
7238 if ((*q ==
'\'') || (*q ==
'"'))
7240 (void) memcpy(message,p,(
size_t) (q-p+1));
7241 message[q-p+1]=
'\0';
7272 MagickExport MagickBooleanType SyncCacheView(
CacheView *cache_view)
7277 status=SyncCacheViewAuthenticPixels(cache_view,
7278 GetCacheViewException(cache_view));
7312 MagickExport MagickBooleanType SyncCacheViewPixels(
CacheView *cache_view)
7317 status=SyncCacheViewAuthenticPixels(cache_view,
7318 GetCacheViewException(cache_view));
7350 MagickExport MagickBooleanType SyncImagePixels(
Image *image)
7352 return(SyncAuthenticPixels(image,&image->exception));
7388 MagickExport
int SystemCommand(
const MagickBooleanType asynchronous,
7389 const MagickBooleanType verbose,
const char *command,
ExceptionInfo *exception)
7394 status=ExternalDelegateCommand(asynchronous,verbose,command,(
char *) NULL,
7422 MagickExport
void TemporaryFilename(
char *path)
7424 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.6");
7425 (void) AcquireUniqueFilename(path);
7426 (void) RelinquishUniqueFileResource(path);
7455 MagickExport
unsigned int ThresholdImage(
Image *image,
const double threshold)
7457 #define ThresholdImageTag "Threshold/Image"
7468 assert(image != (
Image *) NULL);
7469 assert(image->signature == MagickCoreSignature);
7470 if (IsEventLogging() != MagickFalse)
7471 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
7472 if (IsEventLogging() != MagickFalse)
7473 (
void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.7");
7474 if (!AcquireImageColormap(image,2))
7475 ThrowBinaryImageException(ResourceLimitError,
"MemoryAllocationFailed",
7476 "UnableToThresholdImage");
7477 for (y=0; y < (ssize_t) image->rows; y++)
7480 *magick_restrict indexes;
7488 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
7491 indexes=GetAuthenticIndexQueue(image);
7492 for (x=0; x < (ssize_t) image->columns; x++)
7494 index=(IndexPacket) (GetPixelIntensity(image,q) <=
7496 SetPixelIndex(indexes+x,index);
7497 SetPixelRGBO(q,image->colormap+(ssize_t) index);
7500 if (!SyncAuthenticPixels(image,&image->exception))
7531 MagickExport
unsigned int ThresholdImageChannel(
Image *image,
7532 const char *threshold)
7534 #define ThresholdImageTag "Threshold/Image"
7554 assert(image != (
Image *) NULL);
7555 assert(image->signature == MagickCoreSignature);
7556 if (IsEventLogging() != MagickFalse)
7557 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
7558 if (threshold == (
const char *) NULL)
7560 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
7561 return(MagickFalse);
7562 GetMagickPixelPacket(image,&pixel);
7563 flags=ParseGeometry(threshold,&geometry_info);
7564 pixel.red=geometry_info.rho;
7565 if (flags & SigmaValue)
7566 pixel.green=geometry_info.sigma;
7568 pixel.green=pixel.red;
7569 if (flags & XiValue)
7570 pixel.blue=geometry_info.xi;
7572 pixel.blue=pixel.red;
7573 if (flags & PsiValue)
7574 pixel.opacity=geometry_info.psi;
7576 pixel.opacity=(MagickRealType) OpaqueOpacity;
7577 if (flags & PercentValue)
7579 pixel.red*=QuantumRange/100.0f;
7580 pixel.green*=QuantumRange/100.0f;
7581 pixel.blue*=QuantumRange/100.0f;
7582 pixel.opacity*=QuantumRange/100.0f;
7584 if (!(flags & SigmaValue))
7586 if (!AcquireImageColormap(image,2))
7587 ThrowBinaryImageException(ResourceLimitError,
"MemoryAllocationFailed",
7588 "UnableToThresholdImage");
7590 (void) GetImageDynamicThreshold(image,2.0,2.0,&pixel,&image->exception);
7592 for (y=0; y < (ssize_t) image->rows; y++)
7595 *magick_restrict indexes;
7603 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
7606 indexes=GetAuthenticIndexQueue(image);
7607 if (IsMagickGray(&pixel) != MagickFalse)
7608 for (x=0; x < (ssize_t) image->columns; x++)
7610 index=(IndexPacket) (GetPixelIntensity(image,q) <= pixel.red ? 0 : 1);
7611 SetPixelIndex(indexes+x,index);
7612 SetPixelRed(q,image->colormap[(ssize_t) index].red);
7613 SetPixelGreen(q,image->colormap[(ssize_t) index].green);
7614 SetPixelBlue(q,image->colormap[(ssize_t) index].blue);
7618 for (x=0; x < (ssize_t) image->columns; x++)
7620 SetPixelRed(q,(MagickRealType) q->red <= pixel.red
7621 ? 0 : QuantumRange);
7622 SetPixelGreen(q,(MagickRealType) q->green <= pixel.green
7623 ? 0 : QuantumRange);
7624 SetPixelBlue(q,(MagickRealType) q->blue <= pixel.blue
7625 ? 0 : QuantumRange);
7626 SetPixelOpacity(q,(MagickRealType) q->opacity <= pixel.opacity
7627 ? 0 : QuantumRange);
7630 if (!SyncAuthenticPixels(image,&image->exception))
7670 MagickExport
unsigned int TransformColorspace(
Image *image,
7671 const ColorspaceType colorspace)
7673 assert(image != (
Image *) NULL);
7674 assert(image->signature == MagickCoreSignature);
7675 if (IsEventLogging() != MagickFalse)
7676 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.6");
7677 return(TransformImageColorspace(image,colorspace));
7708 MagickExport
void TransformHSL(
const Quantum red,
const Quantum green,
7709 const Quantum blue,
double *hue,
double *saturation,
double *lightness)
7722 assert(hue != (
double *) NULL);
7723 assert(saturation != (
double *) NULL);
7724 assert(lightness != (
double *) NULL);
7726 g=QuantumScale*green;
7727 b=QuantumScale*blue;
7728 max=MagickMax(r,MagickMax(g,b));
7729 min=MagickMin(r,MagickMin(g,b));
7732 *lightness=(double) ((min+max)/2.0);
7736 *saturation=(double) (delta/((*lightness < 0.5) ? (min+max) :
7739 *hue=(double) (g == min ? 5.0+(max-b)/delta : 1.0-(max-g)/delta);
7742 *hue=(double) (b == min ? 1.0+(max-r)/delta : 3.0-(max-b)/delta);
7744 *hue=(double) (r == min ? 3.0+(max-g)/delta : 5.0-(max-r)/delta);
7781 MagickExport
char *TranslateText(
const ImageInfo *image_info,
Image *image,
7782 const char *embed_text)
7784 assert(image != (
Image *) NULL);
7785 assert(image->signature == MagickCoreSignature);
7786 if (IsEventLogging() != MagickFalse)
7787 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.2.6");
7788 return(InterpretImageProperties(image_info,image,embed_text));
7825 MagickExport MagickBooleanType TransparentImage(
Image *image,
7828 #define TransparentImageTag "Transparent/Image"
7839 assert(image != (
Image *) NULL);
7840 assert(image->signature == MagickCoreSignature);
7841 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v6.1.0");
7842 if (IsEventLogging() != MagickFalse)
7843 (
void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
7844 if (image->matte == MagickFalse)
7845 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
7846 for (y=0; y < (ssize_t) image->rows; y++)
7854 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
7857 for (x=0; x < (ssize_t) image->columns; x++)
7859 if (IsColorSimilar(image,q,&target) != MagickFalse)
7863 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
7865 proceed=SetImageProgress(image,TransparentImageTag,(MagickOffsetType) y,
7867 if (proceed == MagickFalse)
7904 MagickExport
unsigned int UnshiftImageList(
Image **images,
const Image *image,
7907 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.5.2");
7908 PrependImageToList(images,CloneImageList(image,exception));
7945 MagickExport IndexPacket ValidateColormapIndex(
Image *image,
7948 if (IsEventLogging() != MagickFalse)
7949 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),
"last use: v5.4.4");
7950 return(ConstrainColormapIndex(image,index));
7992 MagickExport
Image *ZoomImage(
const Image *image,
const size_t columns,
7998 assert(image != (
const Image *) NULL);
7999 assert(image->signature == MagickCoreSignature);
8001 assert(exception->signature == MagickCoreSignature);
8002 if (IsEventLogging() != MagickFalse)
8003 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
8004 zoom_image=ResizeImage(image,columns,rows,image->filter,image->blur,