211 #if !defined(__APPLE__) && !defined(TARGET_OS_IPHONE) 216 #define ErrorQueueLength 16 217 #define ErrorRelativeWeight PerceptibleReciprocal(16) 218 #define MaxNodes 266817 219 #define MaxTreeDepth 8 220 #define NodesInAList 1920 392 if (option != (
const char *) NULL)
397 return(quantize_info);
471 alpha_pixel->
red=(double) pixel->
red;
473 alpha_pixel->
blue=(double) pixel->
blue;
478 alpha_pixel->
red=alpha*pixel->
red;
480 alpha_pixel->
blue=alpha*pixel->
blue;
490 id=(size_t) (((ScaleQuantumToChar(
ClampPixel(pixel->
red)) >> index) & 0x01) |
491 ((ScaleQuantumToChar(
ClampPixel(pixel->
green)) >> index) & 0x01) << 1 |
492 ((ScaleQuantumToChar(
ClampPixel(pixel->
blue)) >> index) & 0x01) << 2);
494 id|=((ScaleQuantumToChar(
ClampPixel(pixel->
alpha)) >> index) & 0x1) << 3;
501 #define AssignImageTag "Assign/Image" 535 #if defined(MAGICKCORE_OPENMP_SUPPORT) 536 #pragma omp parallel for schedule(static) shared(status) \ 537 magick_number_threads(image,image,image->rows,1) 539 for (y=0; y < (ssize_t) image->
rows; y++)
561 for (x=0; x < (ssize_t) image->
columns; x+=count)
579 for (count=1; (x+count) < (ssize_t) image->
columns; count++)
590 for (index=
MaxTreeDepth-1; (ssize_t) index > 0; index--)
595 node_info=node_info->
child[id];
605 for (i=0; i < (ssize_t) count; i++)
754 #define ClassifyImageTag "Classify/Image" 804 for (y=0; y < (ssize_t) image->
rows; y++)
813 if (p == (
const Quantum *) NULL)
823 for (x=0; x < (ssize_t) image->
columns; x+=(ssize_t) count)
828 for (count=1; (x+(ssize_t) count) < (ssize_t) image->
columns; count++)
841 node_info=cube_info->
root;
849 mid.
red+=(
id & 1) != 0 ? bisect : -bisect;
850 mid.
green+=(
id & 2) != 0 ? bisect : -bisect;
851 mid.
blue+=(
id & 4) != 0 ? bisect : -bisect;
852 mid.
alpha+=(
id & 8) != 0 ? bisect : -bisect;
872 node_info=node_info->
child[id];
880 if (
IsNaN(distance) != 0)
911 for (y++; y < (ssize_t) image->
rows; y++)
920 if (p == (
const Quantum *) NULL)
930 for (x=0; x < (ssize_t) image->
columns; x+=(ssize_t) count)
935 for (count=1; (x+(ssize_t) count) < (ssize_t) image->
columns; count++)
948 node_info=cube_info->
root;
949 for (level=1; level <= cube_info->
depth; level++)
956 mid.
red+=(
id & 1) != 0 ? bisect : -bisect;
957 mid.
green+=(
id & 2) != 0 ? bisect : -bisect;
958 mid.
blue+=(
id & 4) != 0 ? bisect : -bisect;
959 mid.
alpha+=(
id & 8) != 0 ? bisect : -bisect;
973 if (level == cube_info->
depth)
979 node_info=node_info->
child[id];
987 if (
IsNaN(distance) != 0)
1106 for (i=0; i < (ssize_t) number_children; i++)
1135 pixel=alpha*p->red-beta*q->red;
1136 distance=pixel*pixel;
1137 if (distance <= cube_info->distance)
1139 pixel=alpha*p->green-beta*q->green;
1140 distance+=pixel*pixel;
1141 if (distance <= cube_info->distance)
1143 pixel=alpha*p->blue-beta*q->blue;
1144 distance+=pixel*pixel;
1145 if (distance <= cube_info->distance)
1149 pixel=p->alpha-q->alpha;
1150 distance+=pixel*pixel;
1152 if (distance <= cube_info->distance)
1195 assert(image != (
Image *) NULL);
1250 for (i=0; i < (ssize_t) number_children; i++)
1393 return(quantize_info);
1456 (void) memset(pixels,0,number_threads*
sizeof(*pixels));
1457 for (i=0; i < (ssize_t) number_threads; i++)
1470 #define RedShift(pixel) (((pixel) >> CacheShift) << (0*(8-CacheShift))) 1471 #define GreenShift(pixel) (((pixel) >> CacheShift) << (1*(8-CacheShift))) 1472 #define BlueShift(pixel) (((pixel) >> CacheShift) << (2*(8-CacheShift))) 1473 #define AlphaShift(pixel) (((pixel) >> CacheShift) << (3*(8-CacheShift))) 1489 #define DitherImageTag "Dither/Image" 1511 for (y=0; y < (ssize_t) image->
rows; y++)
1542 current=pixels[id]+(y & 0x01)*image->
columns;
1543 previous=pixels[
id]+((y+1) & 0x01)*image->
columns;
1544 v=(ssize_t) ((y & 0x01) != 0 ? -1 : 1);
1545 for (x=0; x < (ssize_t) image->
columns; x++)
1557 u=(y & 0x01) != 0 ? (ssize_t) image->
columns-1-x : x;
1569 if (x < (ssize_t) (image->
columns-1))
1597 if (cube.
cache[i] < 0)
1608 node_info=cube.
root;
1609 for (index=
MaxTreeDepth-1; (ssize_t) index > 0; index--)
1614 node_info=node_info->
child[node_id];
1628 index=(size_t) cube.
cache[i];
1674 #define DitherImageTag "Dither/Image" 1690 if ((p->
x >= 0) && (p->
x < (ssize_t) image->
columns) &&
1691 (p->
y >= 0) && (p->
y < (ssize_t) image->
rows))
1724 if (p->
cache[i] < 0)
1736 for (index=
MaxTreeDepth-1; (ssize_t) index > 0; index--)
1741 node_info=node_info->
child[id];
1755 index=(size_t) p->
cache[i];
1772 sizeof(p->
error[0]));
1795 CubeInfo *cube_info,
const size_t level,
const unsigned int direction,
1978 if (artifact != (
const char *) NULL)
1989 level=(size_t) log2((
double) extent);
1990 if (((
size_t) 1UL << level) < extent)
2039 const size_t depth,
const size_t maximum_colors)
2057 if (cube_info == (
CubeInfo *) NULL)
2059 (void) memset(cube_info,0,
sizeof(*cube_info));
2060 cube_info->
depth=depth;
2063 if (cube_info->
depth < 2)
2087 (void) memset(cube_info->
cache,(-1),
sizeof(*cube_info->
cache)*length);
2130 const size_t level,
NodeInfo *parent)
2144 if (nodes == (
Nodes *) NULL)
2147 sizeof(*nodes->
nodes));
2158 (void) memset(node_info,0,
sizeof(*node_info));
2159 node_info->
parent=parent;
2161 node_info->
level=level;
2220 mean_error_per_pixel;
2226 assert(image != (
Image *) NULL);
2231 (void) memset(&image->
error,0,
sizeof(image->
error));
2238 mean_error_per_pixel=0.0;
2241 for (y=0; y < (ssize_t) image->
rows; y++)
2250 if (p == (
const Quantum *) NULL)
2252 for (x=0; x < (ssize_t) image->
columns; x++)
2260 distance=fabs((
double) (alpha*
GetPixelRed(image,p)-beta*
2262 mean_error_per_pixel+=distance;
2263 mean_error+=distance*distance;
2264 if (distance > maximum_error)
2265 maximum_error=distance;
2268 mean_error_per_pixel+=distance;
2269 mean_error+=distance*distance;
2270 if (distance > maximum_error)
2271 maximum_error=distance;
2272 distance=fabs((
double) (alpha*
GetPixelBlue(image,p)-beta*
2274 mean_error_per_pixel+=distance;
2275 mean_error+=distance*distance;
2276 if (distance > maximum_error)
2277 maximum_error=distance;
2316 (void) memset(quantize_info,0,
sizeof(*quantize_info));
2380 return(kmeans_info);
2396 sizeof(*kmeans_info));
2399 (void) memset(kmeans_info,0,number_threads*
sizeof(*kmeans_info));
2400 for (i=0; i < (ssize_t) number_threads; i++)
2403 sizeof(**kmeans_info));
2407 return(kmeans_info);
2425 metric+=pixel*pixel;
2434 metric+=gamma*pixel*pixel;
2442 if (fabs((
double) pixel) > 0.5)
2446 metric+=gamma*pixel*pixel;
2448 metric+=gamma*pixel*pixel;
2450 metric+=gamma*pixel*pixel;
2455 const size_t number_colors,
const size_t max_iterations,
const double tolerance,
2458 #define KmeansImageTag "Kmeans/Image" 2459 #define RandomColorComponent(info) (QuantumRange*GetPseudoRandomValue(info)) 2481 assert(image != (
Image *) NULL);
2487 if (max_iterations == 0)
2490 if (colors == (
const char *) NULL)
2509 for (depth=1; n != 0; depth++)
2511 cube_info=
GetCubeInfo(quantize_info,depth,number_colors);
2512 if (cube_info == (
CubeInfo *) NULL)
2544 for (n=0, p=colors; n < image->
colors; n++)
2549 for (q=p; *q !=
'\0'; q++)
2563 if (n < image->colors)
2572 for ( ; n < image->
colors; n++)
2594 previous_tolerance=0.0;
2598 for (n=0; n < max_iterations; n++)
2607 for (j=0; j < (ssize_t) number_threads; j++)
2608 (
void) memset(kmeans_pixels[j],0,image->
colors*
sizeof(*kmeans_pixels[j]));
2609 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2610 #pragma omp parallel for schedule(dynamic) shared(status) \ 2611 magick_number_threads(image,image,image->rows,1) 2613 for (y=0; y < (ssize_t) image->
rows; y++)
2632 for (x=0; x < (ssize_t) image->
columns; x++)
2646 for (i=1; i < (ssize_t) image->
colors; i++)
2654 if (distance < min_distance)
2656 min_distance=distance;
2667 kmeans_pixels[id][k].
count++;
2668 kmeans_pixels[id][k].
distortion+=min_distance;
2680 for (j=1; j < (ssize_t) number_threads; j++)
2685 for (k=0; k < (ssize_t) image->
colors; k++)
2687 kmeans_pixels[0][k].
red+=kmeans_pixels[j][k].
red;
2688 kmeans_pixels[0][k].
green+=kmeans_pixels[j][k].
green;
2689 kmeans_pixels[0][k].
blue+=kmeans_pixels[j][k].
blue;
2691 kmeans_pixels[0][k].
alpha+=kmeans_pixels[j][k].
alpha;
2693 kmeans_pixels[0][k].
black+=kmeans_pixels[j][k].
black;
2694 kmeans_pixels[0][k].
count+=kmeans_pixels[j][k].
count;
2702 for (j=0; j < (ssize_t) image->
colors; j++)
2720 fabs(distortion-previous_tolerance));
2721 if (fabs(distortion-previous_tolerance) <= tolerance)
2723 previous_tolerance=distortion;
2739 max_iterations-1,max_iterations);
2783 if ((x-floor(x)) < (ceil(x)-x))
2791 #define PosterizeImageTag "Posterize/Image" 2792 #define PosterizePixel(pixel) ClampToQuantum((MagickRealType) QuantumRange*( \ 2793 MagickRound(QuantumScale*pixel*(levels-1)))/MagickMax((ssize_t) levels-1,1)) 2813 assert(image != (
Image *) NULL);
2820 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2821 #pragma omp parallel for schedule(static) shared(progress,status) \ 2822 magick_number_threads(image,image,image->colors,1) 2824 for (i=0; i < (ssize_t) image->
colors; i++)
2848 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2849 #pragma omp parallel for schedule(static) shared(progress,status) \ 2850 magick_number_threads(image,image,image->rows,1) 2852 for (y=0; y < (ssize_t) image->
rows; y++)
2868 for (x=0; x < (ssize_t) image->
columns; x++)
2891 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2951 for (i=0; i < (ssize_t) number_children; i++)
2959 parent=node_info->
parent;
3007 for (i=0; i < (ssize_t) number_children; i++)
3052 for (i=0; i < (ssize_t) number_children; i++)
3107 assert(image != (
Image *) NULL);
3114 if (maximum_colors == 0)
3130 colors=maximum_colors;
3131 for (depth=1; colors != 0; depth++)
3143 cube_info=
GetCubeInfo(quantize_info,depth,maximum_colors);
3144 if (cube_info == (
CubeInfo *) NULL)
3217 assert(images != (
Image *) NULL);
3233 if (maximum_colors == 0)
3246 colors=maximum_colors;
3247 for (depth=1; colors != 0; depth++)
3255 cube_info=
GetCubeInfo(quantize_info,depth,maximum_colors);
3256 if (cube_info == (
CubeInfo *) NULL)
3264 for (i=0; image != (
Image *) NULL; i++)
3285 for (i=0; image != (
Image *) NULL; i++)
3339 const NodeInfo *node_info,
const ssize_t offset,
double *quantize_error)
3348 if (offset >= (ssize_t) cube_info->
nodes)
3353 for (i=0; i < (ssize_t) number_children ; i++)
3397 for (i=0; i < (ssize_t) number_children; i++)
3475 p=(
double *) error_p;
3476 q=(
double *) error_q;
3486 #define ReduceImageTag "Reduce/Image" 3507 sizeof(*quantize_error));
3508 if (quantize_error != (
double *) NULL)
3512 qsort(quantize_error,cube_info->
nodes,
sizeof(
double),
3576 assert(image != (
Image *) NULL);
3578 assert(remap_image != (
Image *) NULL);
3586 if (cube_info == (
CubeInfo *) NULL)
3644 assert(images != (
Image *) NULL);
3651 if (remap_image == (
Image *) NULL)
3664 if (cube_info == (
CubeInfo *) NULL)
3712 #if defined(__cplusplus) || defined(c_plusplus) 3729 if (intensity < (
double) INT_MIN)
3730 intensity=(double) INT_MIN;
3731 if (intensity > (
double) INT_MAX)
3732 intensity=(
double) INT_MAX;
3733 return((
int) intensity);
3736 #if defined(__cplusplus) || defined(c_plusplus) 3761 assert(image != (
Image *) NULL);
3767 sizeof(*colormap_index));
3768 if (colormap_index == (ssize_t *) NULL)
3773 (void) memset(colormap_index,(-1),extent*
sizeof(*colormap_index));
3783 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3784 #pragma omp parallel for schedule(static) shared(status) \ 3785 magick_number_threads(image,image,image->rows,1) 3787 for (y=0; y < (ssize_t) image->
rows; y++)
3804 for (x=0; x < (ssize_t) image->
columns; x++)
3809 intensity=ScaleQuantumToMap(
GetPixelRed(image,q));
3810 if (colormap_index[intensity] < 0)
3812 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3813 #pragma omp critical (MagickCore_SetGrayscaleImage) 3815 if (colormap_index[intensity] < 0)
3817 colormap_index[intensity]=(ssize_t) image->
colors;
3835 (void) memset(colormap_index,0,extent*
sizeof(*colormap_index));
3836 for (i=0; i < (ssize_t) image->
colors; i++)
3849 for (i=0; i < (ssize_t) image->
colors; i++)
3858 image->
colors=(size_t) (j+1);
3863 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3864 #pragma omp parallel for schedule(static) shared(status) \ 3865 magick_number_threads(image,image,image->rows,1) 3867 for (y=0; y < (ssize_t) image->
rows; y++)
3883 for (x=0; x < (ssize_t) image->
columns; x++)
3942 if (image->
colors != number_colors)
MagickExport MagickBooleanType CompressImageColormap(Image *image, ExceptionInfo *exception)
MagickBooleanType associate_alpha
MagickDoubleType MagickRealType
MagickExport CacheView * DestroyCacheView(CacheView *cache_view)
MagickExport MemoryInfo * RelinquishVirtualMemory(MemoryInfo *memory_info)
MagickProgressMonitor progress_monitor
static PixelTrait GetPixelBlackTraits(const Image *magick_restrict image)
MagickExport MagickBooleanType SyncImage(Image *image, ExceptionInfo *exception)
static Quantum GetPixelAlpha(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
static PixelTrait GetPixelRedTraits(const Image *magick_restrict image)
MagickExport MagickBooleanType TransformImageColorspace(Image *image, const ColorspaceType colorspace, ExceptionInfo *exception)
static PixelTrait GetPixelAlphaTraits(const Image *magick_restrict image)
MagickExport MagickBooleanType PosterizeImage(Image *image, const size_t levels, const DitherMethod dither_method, ExceptionInfo *exception)
static Quantum GetPixelRed(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
ColorspaceType colorspace
#define RandomColorComponent(info)
MagickExport ssize_t ParseCommandOption(const CommandOption option, const MagickBooleanType list, const char *options)
static size_t QuantizeErrorFlatten(const CubeInfo *cube_info, const NodeInfo *node_info, const ssize_t offset, double *quantize_error)
#define ErrorRelativeWeight
MagickExport MemoryInfo * AcquireVirtualMemory(const size_t count, const size_t quantum)
static DoublePixelPacket ** AcquirePixelTLS(const size_t count)
MagickExport ImageType IdentifyImageGray(const Image *image, ExceptionInfo *exception)
static void DestroyCubeInfo(CubeInfo *)
static MagickBooleanType DitherImage(Image *, CubeInfo *, ExceptionInfo *)
MagickExport QuantizeInfo * DestroyQuantizeInfo(QuantizeInfo *quantize_info)
MagickExport const char * GetImageArtifact(const Image *image, const char *artifact)
QuantizeInfo * quantize_info
double mean_error_per_pixel
struct _CubeInfo CubeInfo
static MagickBooleanType IsGrayColorspace(const ColorspaceType colorspace)
MagickExport size_t CopyMagickString(char *magick_restrict destination, const char *magick_restrict source, const size_t length)
MagickExport const Quantum * GetCacheViewVirtualPixels(const CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
static void Reduce(CubeInfo *cube_info, const NodeInfo *node_info)
MagickBooleanType verbose
MagickExport const char * GetImageOption(const ImageInfo *image_info, const char *option)
#define PosterizeImageTag
MagickExport void * ResizeQuantumMemory(void *memory, const size_t count, const size_t quantum)
static MagickBooleanType IsGrayImageType(const ImageType type)
static NodeInfo * GetNodeInfo(CubeInfo *, const size_t, const size_t, NodeInfo *)
#define ThrowBinaryException(severity, tag, context)
static Quantum ClampToQuantum(const MagickRealType quantum)
static MagickBooleanType IsPixelInfoEquivalent(const PixelInfo *magick_restrict p, const PixelInfo *magick_restrict q)
MagickExport RandomInfo * DestroyRandomInfo(RandomInfo *random_info)
static MagickBooleanType IsPixelEquivalent(const Image *magick_restrict image, const Quantum *magick_restrict p, const PixelInfo *magick_restrict q)
#define MagickCoreSignature
double normalized_mean_error
MagickExport Quantum * GetCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
static Quantum ClampPixel(const MagickRealType pixel)
#define AlphaShift(pixel)
static MagickBooleanType IsHueCompatibleColorspace(const ColorspaceType colorspace)
MagickExport MagickBooleanType RemapImages(const QuantizeInfo *quantize_info, Image *images, const Image *remap_image, ExceptionInfo *exception)
static MagickBooleanType FloydSteinbergDither(Image *image, CubeInfo *cube_info, ExceptionInfo *exception)
MagickExport ssize_t FormatLocaleFile(FILE *file, const char *magick_restrict format,...)
static double PerceptibleReciprocal(const double x)
double weights[ErrorQueueLength]
DoublePixelPacket total_color
struct _KmeansInfo KmeansInfo
static void PruneChild(CubeInfo *cube_info, const NodeInfo *node_info)
MagickExport void * AcquireCriticalMemory(const size_t size)
static MagickBooleanType RiemersmaDither(Image *image, CacheView *image_view, CubeInfo *cube_info, const unsigned int direction, ExceptionInfo *exception)
static MagickBooleanType IssRGBCompatibleColorspace(const ColorspaceType colorspace)
static KmeansInfo ** AcquireKmeansTLS(const size_t number_colors)
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
MagickExport MagickBooleanType QuantizeImages(const QuantizeInfo *quantize_info, Image *images, ExceptionInfo *exception)
static int GetOpenMPThreadId(void)
static CubeInfo * GetCubeInfo(const QuantizeInfo *, const size_t, const size_t)
static Quantum GetPixelGreen(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport MagickBooleanType IsStringTrue(const char *value)
MagickExport MagickBooleanType IsEventLogging(void)
static void GetPixelInfoPixel(const Image *magick_restrict image, const Quantum *magick_restrict pixel, PixelInfo *magick_restrict pixel_info)
MagickExport int GetMagickPrecision(void)
MagickExport void GetQuantizeInfo(QuantizeInfo *quantize_info)
static Quantum GetPixelIndex(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickSizeType transparent_pixels
static double MagickRound(double x)
static Quantum GetPixelBlack(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
struct _NodeInfo * child[16]
MagickExport MagickRealType GetPixelInfoIntensity(const Image *magick_restrict image, const PixelInfo *magick_restrict pixel)
MagickExport MagickBooleanType RemapImage(const QuantizeInfo *quantize_info, Image *image, const Image *remap_image, ExceptionInfo *exception)
MagickExport MagickBooleanType ThrowMagickException(ExceptionInfo *exception, const char *module, const char *function, const size_t line, const ExceptionType severity, const char *tag, const char *format,...)
static void AssociateAlphaPixelInfo(const CubeInfo *cube_info, const PixelInfo *pixel, DoublePixelPacket *alpha_pixel)
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info, Image *image, ExceptionInfo *exception)
MagickExport MagickBooleanType GetImageQuantizeError(Image *image, ExceptionInfo *exception)
ssize_t transparent_index
static void PruneLevel(CubeInfo *, const NodeInfo *)
MagickExport RandomInfo * AcquireRandomInfo(void)
MagickExport MagickSizeType GetMagickResourceLimit(const ResourceType type)
MagickBooleanType(* MagickProgressMonitor)(const char *, const MagickOffsetType, const MagickSizeType, void *)
struct _NodeInfo * parent
static PixelTrait GetPixelGreenTraits(const Image *magick_restrict image)
MagickExport MagickBooleanType QueryColorCompliance(const char *name, const ComplianceType compliance, PixelInfo *color, ExceptionInfo *exception)
static void SetPixelBlue(const Image *magick_restrict image, const Quantum blue, Quantum *magick_restrict pixel)
MagickExport MagickProgressMonitor SetImageProgressMonitor(Image *image, const MagickProgressMonitor progress_monitor, void *client_data)
static MagickBooleanType Riemersma(Image *image, CacheView *image_view, CubeInfo *cube_info, const size_t level, const unsigned int direction, ExceptionInfo *exception)
MagickSizeType number_unique
static size_t GetPixelChannels(const Image *magick_restrict image)
MagickExport MagickBooleanType AcquireImageColormap(Image *image, const size_t colors, ExceptionInfo *exception)
MagickExport MagickBooleanType IsPaletteImage(const Image *image)
MagickExport QuantizeInfo * AcquireQuantizeInfo(const ImageInfo *image_info)
static MagickBooleanType AssignImageColors(Image *, CubeInfo *, ExceptionInfo *)
char filename[MagickPathExtent]
#define GetMagickModule()
NodeInfo nodes[NodesInAList]
MagickExport size_t GetNumberColors(const Image *image, FILE *file, ExceptionInfo *exception)
MagickExport CacheView * AcquireVirtualCacheView(const Image *image, ExceptionInfo *exception)
static double StringToDoubleInterval(const char *string, const double interval)
static int IntensityCompare(const void *x, const void *y)
DitherMethod dither_method
double normalized_maximum_error
struct _NodeInfo NodeInfo
DoublePixelPacket error[ErrorQueueLength]
static size_t ColorToNodeId(const CubeInfo *cube_info, const DoublePixelPacket *pixel, size_t index)
MagickExport Image * GetNextImageInList(const Image *images)
MagickExport void * AcquireMagickMemory(const size_t size)
static DoublePixelPacket ** DestroyPixelTLS(DoublePixelPacket **pixels)
MagickExport QuantizeInfo * CloneQuantizeInfo(const QuantizeInfo *quantize_info)
static void SetPixelIndex(const Image *magick_restrict image, const Quantum index, Quantum *magick_restrict pixel)
static MagickBooleanType SetGrayscaleImage(Image *, ExceptionInfo *)
static MagickBooleanType ClassifyImageColors(CubeInfo *, const Image *, ExceptionInfo *)
MagickBooleanType measure_error
static int QuantizeErrorCompare(const void *error_p, const void *error_q)
static void SetPixelAlpha(const Image *magick_restrict image, const Quantum alpha, Quantum *magick_restrict pixel)
static KmeansInfo ** DestroyKmeansTLS(KmeansInfo **kmeans_info)
static void DefineImageColormap(Image *, CubeInfo *, NodeInfo *)
static RandomInfo * random_info
MagickExport void * RelinquishMagickMemory(void *memory)
MagickExport MagickBooleanType KmeansImage(Image *image, const size_t number_colors, const size_t max_iterations, const double tolerance, ExceptionInfo *exception)
static void AssociateAlphaPixel(const Image *image, const CubeInfo *cube_info, const Quantum *pixel, DoublePixelPacket *alpha_pixel)
static void SetPixelRed(const Image *magick_restrict image, const Quantum red, Quantum *magick_restrict pixel)
static ssize_t CacheOffset(CubeInfo *cube_info, const DoublePixelPacket *pixel)
static void ReduceImageColors(const Image *, CubeInfo *)
static MagickRealType GetPixelInfoLuma(const PixelInfo *magick_restrict pixel)
MagickExport MagickBooleanType SyncCacheViewAuthenticPixels(CacheView *magick_restrict cache_view, ExceptionInfo *exception)
MagickExport CacheView * AcquireAuthenticCacheView(const Image *image, ExceptionInfo *exception)
MagickExport MagickBooleanType SetImageMonochrome(Image *image, ExceptionInfo *exception)
static void PruneToCubeDepth(CubeInfo *, const NodeInfo *)
static void SetPixelBlack(const Image *magick_restrict image, const Quantum black, Quantum *magick_restrict pixel)
static Quantum GetPixelBlue(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
static MagickBooleanType SetImageColormap(Image *, CubeInfo *, ExceptionInfo *)
MagickExport void * GetVirtualMemoryBlob(const MemoryInfo *memory_info)
#define PosterizePixel(pixel)
MagickExport size_t GetImageListLength(const Image *images)
struct _DoublePixelPacket DoublePixelPacket
static void SetAssociatedAlpha(const Image *image, CubeInfo *cube_info)
static double KmeansMetric(const Image *magick_restrict image, const Quantum *magick_restrict p, const PixelInfo *magick_restrict q)
ColorspaceType colorspace
MagickExport MagickBooleanType SetImageProgress(const Image *image, const char *tag, const MagickOffsetType offset, const MagickSizeType extent)
static void ClosestColor(const Image *, CubeInfo *, const NodeInfo *)
#define GreenShift(pixel)
static void SetPixelGreen(const Image *magick_restrict image, const Quantum green, Quantum *magick_restrict pixel)
static PixelTrait GetPixelBlueTraits(const Image *magick_restrict image)