MagickCore  7.0.3
threshold.c
Go to the documentation of this file.
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % TTTTT H H RRRR EEEEE SSSSS H H OOO L DDDD %
7 % T H H R R E SS H H O O L D D %
8 % T HHHHH RRRR EEE SSS HHHHH O O L D D %
9 % T H H R R E SS H H O O L D D %
10 % T H H R R EEEEE SSSSS H H OOO LLLLL DDDD %
11 % %
12 % %
13 % MagickCore Image Threshold Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % October 1996 %
18 % %
19 % %
20 % Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % https://imagemagick.org/script/license.php %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 %
38 */
39 
40 /*
41  Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/property.h"
45 #include "MagickCore/blob.h"
46 #include "MagickCore/cache-view.h"
47 #include "MagickCore/color.h"
48 #include "MagickCore/color-private.h"
49 #include "MagickCore/colormap.h"
50 #include "MagickCore/colorspace.h"
51 #include "MagickCore/colorspace-private.h"
52 #include "MagickCore/configure.h"
53 #include "MagickCore/constitute.h"
54 #include "MagickCore/decorate.h"
55 #include "MagickCore/draw.h"
56 #include "MagickCore/enhance.h"
57 #include "MagickCore/exception.h"
58 #include "MagickCore/exception-private.h"
59 #include "MagickCore/effect.h"
60 #include "MagickCore/fx.h"
61 #include "MagickCore/gem.h"
62 #include "MagickCore/geometry.h"
63 #include "MagickCore/image-private.h"
64 #include "MagickCore/list.h"
65 #include "MagickCore/log.h"
66 #include "MagickCore/memory_.h"
67 #include "MagickCore/memory-private.h"
68 #include "MagickCore/monitor.h"
69 #include "MagickCore/monitor-private.h"
70 #include "MagickCore/montage.h"
71 #include "MagickCore/option.h"
72 #include "MagickCore/pixel-accessor.h"
73 #include "MagickCore/pixel-private.h"
74 #include "MagickCore/quantize.h"
75 #include "MagickCore/quantum.h"
76 #include "MagickCore/quantum-private.h"
77 #include "MagickCore/random_.h"
78 #include "MagickCore/random-private.h"
79 #include "MagickCore/resize.h"
80 #include "MagickCore/resource_.h"
81 #include "MagickCore/segment.h"
82 #include "MagickCore/shear.h"
83 #include "MagickCore/signature-private.h"
84 #include "MagickCore/string_.h"
85 #include "MagickCore/string-private.h"
86 #include "MagickCore/thread-private.h"
87 #include "MagickCore/threshold.h"
88 #include "MagickCore/token.h"
89 #include "MagickCore/transform.h"
90 #include "MagickCore/xml-tree.h"
91 #include "MagickCore/xml-tree-private.h"
92 
93 /*
94  Define declarations.
95 */
96 #define ThresholdsFilename "thresholds.xml"
97 
98 /*
99  Typedef declarations.
100 */
101 struct _ThresholdMap
102 {
103  char
104  *map_id,
105  *description;
106 
107  size_t
108  width,
109  height;
110 
111  ssize_t
112  divisor,
113  *levels;
114 };
115 
116 /*
117  Static declarations.
118 */
119 static const char
120  *MinimalThresholdMap =
121  "<?xml version=\"1.0\"?>"
122  "<thresholds>"
123  " <threshold map=\"threshold\" alias=\"1x1\">"
124  " <description>Threshold 1x1 (non-dither)</description>"
125  " <levels width=\"1\" height=\"1\" divisor=\"2\">"
126  " 1"
127  " </levels>"
128  " </threshold>"
129  " <threshold map=\"checks\" alias=\"2x1\">"
130  " <description>Checkerboard 2x1 (dither)</description>"
131  " <levels width=\"2\" height=\"2\" divisor=\"3\">"
132  " 1 2"
133  " 2 1"
134  " </levels>"
135  " </threshold>"
136  "</thresholds>";
137 
138 /*
139  Forward declarations.
140 */
141 static ThresholdMap
142  *GetThresholdMapFile(const char *,const char *,const char *,ExceptionInfo *);
143 
144 /*
145 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
146 % %
147 % %
148 % %
149 % A d a p t i v e T h r e s h o l d I m a g e %
150 % %
151 % %
152 % %
153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
154 %
155 % AdaptiveThresholdImage() selects an individual threshold for each pixel
156 % based on the range of intensity values in its local neighborhood. This
157 % allows for thresholding of an image whose global intensity histogram
158 % doesn't contain distinctive peaks.
159 %
160 % The format of the AdaptiveThresholdImage method is:
161 %
162 % Image *AdaptiveThresholdImage(const Image *image,const size_t width,
163 % const size_t height,const double bias,ExceptionInfo *exception)
164 %
165 % A description of each parameter follows:
166 %
167 % o image: the image.
168 %
169 % o width: the width of the local neighborhood.
170 %
171 % o height: the height of the local neighborhood.
172 %
173 % o bias: the mean bias.
174 %
175 % o exception: return any errors or warnings in this structure.
176 %
177 */
178 MagickExport Image *AdaptiveThresholdImage(const Image *image,
179  const size_t width,const size_t height,const double bias,
180  ExceptionInfo *exception)
181 {
182 #define AdaptiveThresholdImageTag "AdaptiveThreshold/Image"
183 
184  CacheView
185  *image_view,
186  *threshold_view;
187 
188  Image
189  *threshold_image;
190 
191  MagickBooleanType
192  status;
193 
194  MagickOffsetType
195  progress;
196 
197  MagickSizeType
198  number_pixels;
199 
200  ssize_t
201  y;
202 
203  /*
204  Initialize threshold image attributes.
205  */
206  assert(image != (Image *) NULL);
207  assert(image->signature == MagickCoreSignature);
208  if (image->debug != MagickFalse)
209  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
210  assert(exception != (ExceptionInfo *) NULL);
211  assert(exception->signature == MagickCoreSignature);
212  threshold_image=CloneImage(image,0,0,MagickTrue,exception);
213  if (threshold_image == (Image *) NULL)
214  return((Image *) NULL);
215  status=SetImageStorageClass(threshold_image,DirectClass,exception);
216  if (status == MagickFalse)
217  {
218  threshold_image=DestroyImage(threshold_image);
219  return((Image *) NULL);
220  }
221  /*
222  Threshold image.
223  */
224  status=MagickTrue;
225  progress=0;
226  number_pixels=(MagickSizeType) width*height;
227  image_view=AcquireVirtualCacheView(image,exception);
228  threshold_view=AcquireAuthenticCacheView(threshold_image,exception);
229 #if defined(MAGICKCORE_OPENMP_SUPPORT)
230  #pragma omp parallel for schedule(static) shared(progress,status) \
231  magick_number_threads(image,threshold_image,image->rows,1)
232 #endif
233  for (y=0; y < (ssize_t) image->rows; y++)
234  {
235  double
236  channel_bias[MaxPixelChannels],
237  channel_sum[MaxPixelChannels];
238 
239  register const Quantum
240  *magick_restrict p,
241  *magick_restrict pixels;
242 
243  register Quantum
244  *magick_restrict q;
245 
246  register ssize_t
247  i,
248  x;
249 
250  ssize_t
251  center,
252  u,
253  v;
254 
255  if (status == MagickFalse)
256  continue;
257  p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
258  (height/2L),image->columns+width,height,exception);
259  q=QueueCacheViewAuthenticPixels(threshold_view,0,y,threshold_image->columns,
260  1,exception);
261  if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
262  {
263  status=MagickFalse;
264  continue;
265  }
266  center=(ssize_t) GetPixelChannels(image)*(image->columns+width)*(height/2L)+
267  GetPixelChannels(image)*(width/2);
268  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
269  {
270  PixelChannel channel = GetPixelChannelChannel(image,i);
271  PixelTrait traits = GetPixelChannelTraits(image,channel);
272  PixelTrait threshold_traits=GetPixelChannelTraits(threshold_image,
273  channel);
274  if ((traits == UndefinedPixelTrait) ||
275  (threshold_traits == UndefinedPixelTrait))
276  continue;
277  if ((threshold_traits & CopyPixelTrait) != 0)
278  {
279  SetPixelChannel(threshold_image,channel,p[center+i],q);
280  continue;
281  }
282  pixels=p;
283  channel_bias[channel]=0.0;
284  channel_sum[channel]=0.0;
285  for (v=0; v < (ssize_t) height; v++)
286  {
287  for (u=0; u < (ssize_t) width; u++)
288  {
289  if (u == (ssize_t) (width-1))
290  channel_bias[channel]+=pixels[i];
291  channel_sum[channel]+=pixels[i];
292  pixels+=GetPixelChannels(image);
293  }
294  pixels+=GetPixelChannels(image)*image->columns;
295  }
296  }
297  for (x=0; x < (ssize_t) image->columns; x++)
298  {
299  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
300  {
301  double
302  mean;
303 
304  PixelChannel channel = GetPixelChannelChannel(image,i);
305  PixelTrait traits = GetPixelChannelTraits(image,channel);
306  PixelTrait threshold_traits=GetPixelChannelTraits(threshold_image,
307  channel);
308  if ((traits == UndefinedPixelTrait) ||
309  (threshold_traits == UndefinedPixelTrait))
310  continue;
311  if ((threshold_traits & CopyPixelTrait) != 0)
312  {
313  SetPixelChannel(threshold_image,channel,p[center+i],q);
314  continue;
315  }
316  channel_sum[channel]-=channel_bias[channel];
317  channel_bias[channel]=0.0;
318  pixels=p;
319  for (v=0; v < (ssize_t) height; v++)
320  {
321  channel_bias[channel]+=pixels[i];
322  pixels+=(width-1)*GetPixelChannels(image);
323  channel_sum[channel]+=pixels[i];
324  pixels+=GetPixelChannels(image)*(image->columns+1);
325  }
326  mean=(double) (channel_sum[channel]/number_pixels+bias);
327  SetPixelChannel(threshold_image,channel,(Quantum) ((double)
328  p[center+i] <= mean ? 0 : QuantumRange),q);
329  }
330  p+=GetPixelChannels(image);
331  q+=GetPixelChannels(threshold_image);
332  }
333  if (SyncCacheViewAuthenticPixels(threshold_view,exception) == MagickFalse)
334  status=MagickFalse;
335  if (image->progress_monitor != (MagickProgressMonitor) NULL)
336  {
337  MagickBooleanType
338  proceed;
339 
340 #if defined(MAGICKCORE_OPENMP_SUPPORT)
341  #pragma omp atomic
342 #endif
343  progress++;
344  proceed=SetImageProgress(image,AdaptiveThresholdImageTag,progress,
345  image->rows);
346  if (proceed == MagickFalse)
347  status=MagickFalse;
348  }
349  }
350  threshold_image->type=image->type;
351  threshold_view=DestroyCacheView(threshold_view);
352  image_view=DestroyCacheView(image_view);
353  if (status == MagickFalse)
354  threshold_image=DestroyImage(threshold_image);
355  return(threshold_image);
356 }
357 
358 /*
359 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
360 % %
361 % %
362 % %
363 % A u t o T h r e s h o l d I m a g e %
364 % %
365 % %
366 % %
367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
368 %
369 % AutoThresholdImage() automatically performs image thresholding
370 % dependent on which method you specify.
371 %
372 % The format of the AutoThresholdImage method is:
373 %
374 % MagickBooleanType AutoThresholdImage(Image *image,
375 % const AutoThresholdMethod method,ExceptionInfo *exception)
376 %
377 % A description of each parameter follows:
378 %
379 % o image: The image to auto-threshold.
380 %
381 % o method: choose from Kapur, OTSU, or Triangle.
382 %
383 % o exception: return any errors or warnings in this structure.
384 %
385 */
386 
387 static double KapurThreshold(const Image *image,const double *histogram,
388  ExceptionInfo *exception)
389 {
390 #define MaxIntensity 255
391 
392  double
393  *black_entropy,
394  *cumulative_histogram,
395  entropy,
396  epsilon,
397  maximum_entropy,
398  *white_entropy;
399 
400  register ssize_t
401  i,
402  j;
403 
404  size_t
405  threshold;
406 
407  /*
408  Compute optimal threshold from the entopy of the histogram.
409  */
410  cumulative_histogram=(double *) AcquireQuantumMemory(MaxIntensity+1UL,
411  sizeof(*cumulative_histogram));
412  black_entropy=(double *) AcquireQuantumMemory(MaxIntensity+1UL,
413  sizeof(*black_entropy));
414  white_entropy=(double *) AcquireQuantumMemory(MaxIntensity+1UL,
415  sizeof(*white_entropy));
416  if ((cumulative_histogram == (double *) NULL) ||
417  (black_entropy == (double *) NULL) || (white_entropy == (double *) NULL))
418  {
419  if (white_entropy != (double *) NULL)
420  white_entropy=(double *) RelinquishMagickMemory(white_entropy);
421  if (black_entropy != (double *) NULL)
422  black_entropy=(double *) RelinquishMagickMemory(black_entropy);
423  if (cumulative_histogram != (double *) NULL)
424  cumulative_histogram=(double *)
425  RelinquishMagickMemory(cumulative_histogram);
426  (void) ThrowMagickException(exception,GetMagickModule(),
427  ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
428  return(-1.0);
429  }
430  /*
431  Entropy for black and white parts of the histogram.
432  */
433  cumulative_histogram[0]=histogram[0];
434  for (i=1; i <= MaxIntensity; i++)
435  cumulative_histogram[i]=cumulative_histogram[i-1]+histogram[i];
436  epsilon=MagickMinimumValue;
437  for (j=0; j <= MaxIntensity; j++)
438  {
439  /*
440  Black entropy.
441  */
442  black_entropy[j]=0.0;
443  if (cumulative_histogram[j] > epsilon)
444  {
445  entropy=0.0;
446  for (i=0; i <= j; i++)
447  if (histogram[i] > epsilon)
448  entropy-=histogram[i]/cumulative_histogram[j]*
449  log(histogram[i]/cumulative_histogram[j]);
450  black_entropy[j]=entropy;
451  }
452  /*
453  White entropy.
454  */
455  white_entropy[j]=0.0;
456  if ((1.0-cumulative_histogram[j]) > epsilon)
457  {
458  entropy=0.0;
459  for (i=j+1; i <= MaxIntensity; i++)
460  if (histogram[i] > epsilon)
461  entropy-=histogram[i]/(1.0-cumulative_histogram[j])*
462  log(histogram[i]/(1.0-cumulative_histogram[j]));
463  white_entropy[j]=entropy;
464  }
465  }
466  /*
467  Find histogram bin with maximum entropy.
468  */
469  maximum_entropy=black_entropy[0]+white_entropy[0];
470  threshold=0;
471  for (j=1; j <= MaxIntensity; j++)
472  if ((black_entropy[j]+white_entropy[j]) > maximum_entropy)
473  {
474  maximum_entropy=black_entropy[j]+white_entropy[j];
475  threshold=(size_t) j;
476  }
477  /*
478  Free resources.
479  */
480  white_entropy=(double *) RelinquishMagickMemory(white_entropy);
481  black_entropy=(double *) RelinquishMagickMemory(black_entropy);
482  cumulative_histogram=(double *) RelinquishMagickMemory(cumulative_histogram);
483  return(100.0*threshold/MaxIntensity);
484 }
485 
486 static double OTSUThreshold(const Image *image,const double *histogram,
487  ExceptionInfo *exception)
488 {
489  double
490  max_sigma,
491  *myu,
492  *omega,
493  *probability,
494  *sigma,
495  threshold;
496 
497  register ssize_t
498  i;
499 
500  /*
501  Compute optimal threshold from maximization of inter-class variance.
502  */
503  myu=(double *) AcquireQuantumMemory(MaxIntensity+1UL,sizeof(*myu));
504  omega=(double *) AcquireQuantumMemory(MaxIntensity+1UL,sizeof(*omega));
505  probability=(double *) AcquireQuantumMemory(MaxIntensity+1UL,
506  sizeof(*probability));
507  sigma=(double *) AcquireQuantumMemory(MaxIntensity+1UL,sizeof(*sigma));
508  if ((myu == (double *) NULL) || (omega == (double *) NULL) ||
509  (probability == (double *) NULL) || (sigma == (double *) NULL))
510  {
511  if (sigma != (double *) NULL)
512  sigma=(double *) RelinquishMagickMemory(sigma);
513  if (probability != (double *) NULL)
514  probability=(double *) RelinquishMagickMemory(probability);
515  if (omega != (double *) NULL)
516  omega=(double *) RelinquishMagickMemory(omega);
517  if (myu != (double *) NULL)
518  myu=(double *) RelinquishMagickMemory(myu);
519  (void) ThrowMagickException(exception,GetMagickModule(),
520  ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
521  return(-1.0);
522  }
523  /*
524  Calculate probability density.
525  */
526  for (i=0; i <= (ssize_t) MaxIntensity; i++)
527  probability[i]=histogram[i];
528  /*
529  Generate probability of graylevels and mean value for separation.
530  */
531  omega[0]=probability[0];
532  myu[0]=0.0;
533  for (i=1; i <= (ssize_t) MaxIntensity; i++)
534  {
535  omega[i]=omega[i-1]+probability[i];
536  myu[i]=myu[i-1]+i*probability[i];
537  }
538  /*
539  Sigma maximization: inter-class variance and compute optimal threshold.
540  */
541  threshold=0;
542  max_sigma=0.0;
543  for (i=0; i < (ssize_t) MaxIntensity; i++)
544  {
545  sigma[i]=0.0;
546  if ((omega[i] != 0.0) && (omega[i] != 1.0))
547  sigma[i]=pow(myu[MaxIntensity]*omega[i]-myu[i],2.0)/(omega[i]*(1.0-
548  omega[i]));
549  if (sigma[i] > max_sigma)
550  {
551  max_sigma=sigma[i];
552  threshold=(double) i;
553  }
554  }
555  /*
556  Free resources.
557  */
558  myu=(double *) RelinquishMagickMemory(myu);
559  omega=(double *) RelinquishMagickMemory(omega);
560  probability=(double *) RelinquishMagickMemory(probability);
561  sigma=(double *) RelinquishMagickMemory(sigma);
562  return(100.0*threshold/MaxIntensity);
563 }
564 
565 static double TriangleThreshold(const double *histogram)
566 {
567  double
568  a,
569  b,
570  c,
571  count,
572  distance,
573  inverse_ratio,
574  max_distance,
575  segment,
576  x1,
577  x2,
578  y1,
579  y2;
580 
581  register ssize_t
582  i;
583 
584  ssize_t
585  end,
586  max,
587  start,
588  threshold;
589 
590  /*
591  Compute optimal threshold with triangle algorithm.
592  */
593  start=0; /* find start bin, first bin not zero count */
594  for (i=0; i <= (ssize_t) MaxIntensity; i++)
595  if (histogram[i] > 0.0)
596  {
597  start=i;
598  break;
599  }
600  end=0; /* find end bin, last bin not zero count */
601  for (i=(ssize_t) MaxIntensity; i >= 0; i--)
602  if (histogram[i] > 0.0)
603  {
604  end=i;
605  break;
606  }
607  max=0; /* find max bin, bin with largest count */
608  count=0.0;
609  for (i=0; i <= (ssize_t) MaxIntensity; i++)
610  if (histogram[i] > count)
611  {
612  max=i;
613  count=histogram[i];
614  }
615  /*
616  Compute threshold at split point.
617  */
618  x1=(double) max;
619  y1=histogram[max];
620  x2=(double) end;
621  if ((max-start) >= (end-max))
622  x2=(double) start;
623  y2=0.0;
624  a=y1-y2;
625  b=x2-x1;
626  c=(-1.0)*(a*x1+b*y1);
627  inverse_ratio=1.0/sqrt(a*a+b*b+c*c);
628  threshold=0;
629  max_distance=0.0;
630  if (x2 == (double) start)
631  for (i=start; i < max; i++)
632  {
633  segment=inverse_ratio*(a*i+b*histogram[i]+c);
634  distance=sqrt(segment*segment);
635  if ((distance > max_distance) && (segment > 0.0))
636  {
637  threshold=i;
638  max_distance=distance;
639  }
640  }
641  else
642  for (i=end; i > max; i--)
643  {
644  segment=inverse_ratio*(a*i+b*histogram[i]+c);
645  distance=sqrt(segment*segment);
646  if ((distance > max_distance) && (segment < 0.0))
647  {
648  threshold=i;
649  max_distance=distance;
650  }
651  }
652  return(100.0*threshold/MaxIntensity);
653 }
654 
655 MagickExport MagickBooleanType AutoThresholdImage(Image *image,
656  const AutoThresholdMethod method,ExceptionInfo *exception)
657 {
658  CacheView
659  *image_view;
660 
661  char
662  property[MagickPathExtent];
663 
664  double
665  gamma,
666  *histogram,
667  sum,
668  threshold;
669 
670  MagickBooleanType
671  status;
672 
673  register ssize_t
674  i;
675 
676  ssize_t
677  y;
678 
679  /*
680  Form histogram.
681  */
682  assert(image != (Image *) NULL);
683  assert(image->signature == MagickCoreSignature);
684  if (image->debug != MagickFalse)
685  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
686  histogram=(double *) AcquireQuantumMemory(MaxIntensity+1UL,
687  sizeof(*histogram));
688  if (histogram == (double *) NULL)
689  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
690  image->filename);
691  status=MagickTrue;
692  (void) memset(histogram,0,(MaxIntensity+1UL)*sizeof(*histogram));
693  image_view=AcquireVirtualCacheView(image,exception);
694  for (y=0; y < (ssize_t) image->rows; y++)
695  {
696  register const Quantum
697  *magick_restrict p;
698 
699  register ssize_t
700  x;
701 
702  p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
703  if (p == (const Quantum *) NULL)
704  break;
705  for (x=0; x < (ssize_t) image->columns; x++)
706  {
707  double intensity = GetPixelIntensity(image,p);
708  histogram[ScaleQuantumToChar(ClampToQuantum(intensity))]++;
709  p+=GetPixelChannels(image);
710  }
711  }
712  image_view=DestroyCacheView(image_view);
713  /*
714  Normalize histogram.
715  */
716  sum=0.0;
717  for (i=0; i <= (ssize_t) MaxIntensity; i++)
718  sum+=histogram[i];
719  gamma=PerceptibleReciprocal(sum);
720  for (i=0; i <= (ssize_t) MaxIntensity; i++)
721  histogram[i]=gamma*histogram[i];
722  /*
723  Discover threshold from histogram.
724  */
725  switch (method)
726  {
727  case KapurThresholdMethod:
728  {
729  threshold=KapurThreshold(image,histogram,exception);
730  break;
731  }
732  case OTSUThresholdMethod:
733  default:
734  {
735  threshold=OTSUThreshold(image,histogram,exception);
736  break;
737  }
738  case TriangleThresholdMethod:
739  {
740  threshold=TriangleThreshold(histogram);
741  break;
742  }
743  }
744  histogram=(double *) RelinquishMagickMemory(histogram);
745  if (threshold < 0.0)
746  status=MagickFalse;
747  if (status == MagickFalse)
748  return(MagickFalse);
749  /*
750  Threshold image.
751  */
752  (void) FormatLocaleString(property,MagickPathExtent,"%g%%",threshold);
753  (void) SetImageProperty(image,"auto-threshold:threshold",property,exception);
754  return(BilevelImage(image,QuantumRange*threshold/100.0,exception));
755 }
756 
757 /*
758 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
759 % %
760 % %
761 % %
762 % B i l e v e l I m a g e %
763 % %
764 % %
765 % %
766 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
767 %
768 % BilevelImage() changes the value of individual pixels based on the
769 % intensity of each pixel channel. The result is a high-contrast image.
770 %
771 % More precisely each channel value of the image is 'thresholded' so that if
772 % it is equal to or less than the given value it is set to zero, while any
773 % value greater than that give is set to it maximum or QuantumRange.
774 %
775 % This function is what is used to implement the "-threshold" operator for
776 % the command line API.
777 %
778 % If the default channel setting is given the image is thresholded using just
779 % the gray 'intensity' of the image, rather than the individual channels.
780 %
781 % The format of the BilevelImage method is:
782 %
783 % MagickBooleanType BilevelImage(Image *image,const double threshold,
784 % ExceptionInfo *exception)
785 %
786 % A description of each parameter follows:
787 %
788 % o image: the image.
789 %
790 % o threshold: define the threshold values.
791 %
792 % o exception: return any errors or warnings in this structure.
793 %
794 % Aside: You can get the same results as operator using LevelImages()
795 % with the 'threshold' value for both the black_point and the white_point.
796 %
797 */
798 MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
799  ExceptionInfo *exception)
800 {
801 #define ThresholdImageTag "Threshold/Image"
802 
803  CacheView
804  *image_view;
805 
806  MagickBooleanType
807  status;
808 
809  MagickOffsetType
810  progress;
811 
812  ssize_t
813  y;
814 
815  assert(image != (Image *) NULL);
816  assert(image->signature == MagickCoreSignature);
817  if (image->debug != MagickFalse)
818  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
819  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
820  return(MagickFalse);
821  if (IsGrayColorspace(image->colorspace) != MagickFalse)
822  (void) SetImageColorspace(image,sRGBColorspace,exception);
823  /*
824  Bilevel threshold image.
825  */
826  status=MagickTrue;
827  progress=0;
828  image_view=AcquireAuthenticCacheView(image,exception);
829 #if defined(MAGICKCORE_OPENMP_SUPPORT)
830  #pragma omp parallel for schedule(static) shared(progress,status) \
831  magick_number_threads(image,image,image->rows,1)
832 #endif
833  for (y=0; y < (ssize_t) image->rows; y++)
834  {
835  register ssize_t
836  x;
837 
838  register Quantum
839  *magick_restrict q;
840 
841  if (status == MagickFalse)
842  continue;
843  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
844  if (q == (Quantum *) NULL)
845  {
846  status=MagickFalse;
847  continue;
848  }
849  for (x=0; x < (ssize_t) image->columns; x++)
850  {
851  double
852  pixel;
853 
854  register ssize_t
855  i;
856 
857  pixel=GetPixelIntensity(image,q);
858  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
859  {
860  PixelChannel channel = GetPixelChannelChannel(image,i);
861  PixelTrait traits = GetPixelChannelTraits(image,channel);
862  if ((traits & UpdatePixelTrait) == 0)
863  continue;
864  if (image->channel_mask != DefaultChannels)
865  pixel=(double) q[i];
866  q[i]=(Quantum) (pixel <= threshold ? 0 : QuantumRange);
867  }
868  q+=GetPixelChannels(image);
869  }
870  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
871  status=MagickFalse;
872  if (image->progress_monitor != (MagickProgressMonitor) NULL)
873  {
874  MagickBooleanType
875  proceed;
876 
877 #if defined(MAGICKCORE_OPENMP_SUPPORT)
878  #pragma omp atomic
879 #endif
880  progress++;
881  proceed=SetImageProgress(image,ThresholdImageTag,progress++,
882  image->rows);
883  if (proceed == MagickFalse)
884  status=MagickFalse;
885  }
886  }
887  image_view=DestroyCacheView(image_view);
888  return(status);
889 }
890 
891 /*
892 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
893 % %
894 % %
895 % %
896 % B l a c k T h r e s h o l d I m a g e %
897 % %
898 % %
899 % %
900 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
901 %
902 % BlackThresholdImage() is like ThresholdImage() but forces all pixels below
903 % the threshold into black while leaving all pixels at or above the threshold
904 % unchanged.
905 %
906 % The format of the BlackThresholdImage method is:
907 %
908 % MagickBooleanType BlackThresholdImage(Image *image,
909 % const char *threshold,ExceptionInfo *exception)
910 %
911 % A description of each parameter follows:
912 %
913 % o image: the image.
914 %
915 % o threshold: define the threshold value.
916 %
917 % o exception: return any errors or warnings in this structure.
918 %
919 */
920 MagickExport MagickBooleanType BlackThresholdImage(Image *image,
921  const char *thresholds,ExceptionInfo *exception)
922 {
923 #define ThresholdImageTag "Threshold/Image"
924 
925  CacheView
926  *image_view;
927 
928  GeometryInfo
929  geometry_info;
930 
931  MagickBooleanType
932  status;
933 
934  MagickOffsetType
935  progress;
936 
937  PixelInfo
938  threshold;
939 
940  MagickStatusType
941  flags;
942 
943  ssize_t
944  y;
945 
946  assert(image != (Image *) NULL);
947  assert(image->signature == MagickCoreSignature);
948  if (image->debug != MagickFalse)
949  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
950  if (thresholds == (const char *) NULL)
951  return(MagickTrue);
952  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
953  return(MagickFalse);
954  if (IsGrayColorspace(image->colorspace) != MagickFalse)
955  (void) SetImageColorspace(image,sRGBColorspace,exception);
956  GetPixelInfo(image,&threshold);
957  flags=ParseGeometry(thresholds,&geometry_info);
958  threshold.red=geometry_info.rho;
959  threshold.green=geometry_info.rho;
960  threshold.blue=geometry_info.rho;
961  threshold.black=geometry_info.rho;
962  threshold.alpha=100.0;
963  if ((flags & SigmaValue) != 0)
964  threshold.green=geometry_info.sigma;
965  if ((flags & XiValue) != 0)
966  threshold.blue=geometry_info.xi;
967  if ((flags & PsiValue) != 0)
968  threshold.alpha=geometry_info.psi;
969  if (threshold.colorspace == CMYKColorspace)
970  {
971  if ((flags & PsiValue) != 0)
972  threshold.black=geometry_info.psi;
973  if ((flags & ChiValue) != 0)
974  threshold.alpha=geometry_info.chi;
975  }
976  if ((flags & PercentValue) != 0)
977  {
978  threshold.red*=(MagickRealType) (QuantumRange/100.0);
979  threshold.green*=(MagickRealType) (QuantumRange/100.0);
980  threshold.blue*=(MagickRealType) (QuantumRange/100.0);
981  threshold.black*=(MagickRealType) (QuantumRange/100.0);
982  threshold.alpha*=(MagickRealType) (QuantumRange/100.0);
983  }
984  /*
985  White threshold image.
986  */
987  status=MagickTrue;
988  progress=0;
989  image_view=AcquireAuthenticCacheView(image,exception);
990 #if defined(MAGICKCORE_OPENMP_SUPPORT)
991  #pragma omp parallel for schedule(static) shared(progress,status) \
992  magick_number_threads(image,image,image->rows,1)
993 #endif
994  for (y=0; y < (ssize_t) image->rows; y++)
995  {
996  register ssize_t
997  x;
998 
999  register Quantum
1000  *magick_restrict q;
1001 
1002  if (status == MagickFalse)
1003  continue;
1004  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1005  if (q == (Quantum *) NULL)
1006  {
1007  status=MagickFalse;
1008  continue;
1009  }
1010  for (x=0; x < (ssize_t) image->columns; x++)
1011  {
1012  double
1013  pixel;
1014 
1015  register ssize_t
1016  i;
1017 
1018  pixel=GetPixelIntensity(image,q);
1019  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1020  {
1021  PixelChannel channel = GetPixelChannelChannel(image,i);
1022  PixelTrait traits = GetPixelChannelTraits(image,channel);
1023  if ((traits & UpdatePixelTrait) == 0)
1024  continue;
1025  if (image->channel_mask != DefaultChannels)
1026  pixel=(double) q[i];
1027  if (pixel < GetPixelInfoChannel(&threshold,channel))
1028  q[i]=(Quantum) 0;
1029  }
1030  q+=GetPixelChannels(image);
1031  }
1032  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1033  status=MagickFalse;
1034  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1035  {
1036  MagickBooleanType
1037  proceed;
1038 
1039 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1040  #pragma omp atomic
1041 #endif
1042  progress++;
1043  proceed=SetImageProgress(image,ThresholdImageTag,progress,
1044  image->rows);
1045  if (proceed == MagickFalse)
1046  status=MagickFalse;
1047  }
1048  }
1049  image_view=DestroyCacheView(image_view);
1050  return(status);
1051 }
1052 
1053 /*
1054 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1055 % %
1056 % %
1057 % %
1058 % C l a m p I m a g e %
1059 % %
1060 % %
1061 % %
1062 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1063 %
1064 % ClampImage() set each pixel whose value is below zero to zero and any the
1065 % pixel whose value is above the quantum range to the quantum range (e.g.
1066 % 65535) otherwise the pixel value remains unchanged.
1067 %
1068 % The format of the ClampImage method is:
1069 %
1070 % MagickBooleanType ClampImage(Image *image,ExceptionInfo *exception)
1071 %
1072 % A description of each parameter follows:
1073 %
1074 % o image: the image.
1075 %
1076 % o exception: return any errors or warnings in this structure.
1077 %
1078 */
1079 
1080 MagickExport MagickBooleanType ClampImage(Image *image,ExceptionInfo *exception)
1081 {
1082 #define ClampImageTag "Clamp/Image"
1083 
1084  CacheView
1085  *image_view;
1086 
1087  MagickBooleanType
1088  status;
1089 
1090  MagickOffsetType
1091  progress;
1092 
1093  ssize_t
1094  y;
1095 
1096  assert(image != (Image *) NULL);
1097  assert(image->signature == MagickCoreSignature);
1098  if (image->debug != MagickFalse)
1099  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1100  if (image->storage_class == PseudoClass)
1101  {
1102  register ssize_t
1103  i;
1104 
1105  register PixelInfo
1106  *magick_restrict q;
1107 
1108  q=image->colormap;
1109  for (i=0; i < (ssize_t) image->colors; i++)
1110  {
1111  q->red=(double) ClampPixel(q->red);
1112  q->green=(double) ClampPixel(q->green);
1113  q->blue=(double) ClampPixel(q->blue);
1114  q->alpha=(double) ClampPixel(q->alpha);
1115  q++;
1116  }
1117  return(SyncImage(image,exception));
1118  }
1119  /*
1120  Clamp image.
1121  */
1122  status=MagickTrue;
1123  progress=0;
1124  image_view=AcquireAuthenticCacheView(image,exception);
1125 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1126  #pragma omp parallel for schedule(static) shared(progress,status) \
1127  magick_number_threads(image,image,image->rows,1)
1128 #endif
1129  for (y=0; y < (ssize_t) image->rows; y++)
1130  {
1131  register ssize_t
1132  x;
1133 
1134  register Quantum
1135  *magick_restrict q;
1136 
1137  if (status == MagickFalse)
1138  continue;
1139  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1140  if (q == (Quantum *) NULL)
1141  {
1142  status=MagickFalse;
1143  continue;
1144  }
1145  for (x=0; x < (ssize_t) image->columns; x++)
1146  {
1147  register ssize_t
1148  i;
1149 
1150  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1151  {
1152  PixelChannel channel = GetPixelChannelChannel(image,i);
1153  PixelTrait traits = GetPixelChannelTraits(image,channel);
1154  if ((traits & UpdatePixelTrait) == 0)
1155  continue;
1156  q[i]=ClampPixel((MagickRealType) q[i]);
1157  }
1158  q+=GetPixelChannels(image);
1159  }
1160  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1161  status=MagickFalse;
1162  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1163  {
1164  MagickBooleanType
1165  proceed;
1166 
1167 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1168  #pragma omp atomic
1169 #endif
1170  progress++;
1171  proceed=SetImageProgress(image,ClampImageTag,progress,image->rows);
1172  if (proceed == MagickFalse)
1173  status=MagickFalse;
1174  }
1175  }
1176  image_view=DestroyCacheView(image_view);
1177  return(status);
1178 }
1179 
1180 /*
1181 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1182 % %
1183 % %
1184 % %
1185 % D e s t r o y T h r e s h o l d M a p %
1186 % %
1187 % %
1188 % %
1189 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1190 %
1191 % DestroyThresholdMap() de-allocate the given ThresholdMap
1192 %
1193 % The format of the ListThresholdMaps method is:
1194 %
1195 % ThresholdMap *DestroyThresholdMap(Threshold *map)
1196 %
1197 % A description of each parameter follows.
1198 %
1199 % o map: Pointer to the Threshold map to destroy
1200 %
1201 */
1202 MagickExport ThresholdMap *DestroyThresholdMap(ThresholdMap *map)
1203 {
1204  assert(map != (ThresholdMap *) NULL);
1205  if (map->map_id != (char *) NULL)
1206  map->map_id=DestroyString(map->map_id);
1207  if (map->description != (char *) NULL)
1208  map->description=DestroyString(map->description);
1209  if (map->levels != (ssize_t *) NULL)
1210  map->levels=(ssize_t *) RelinquishMagickMemory(map->levels);
1211  map=(ThresholdMap *) RelinquishMagickMemory(map);
1212  return(map);
1213 }
1214 
1215 /*
1216 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1217 % %
1218 % %
1219 % %
1220 % G e t T h r e s h o l d M a p %
1221 % %
1222 % %
1223 % %
1224 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1225 %
1226 % GetThresholdMap() loads and searches one or more threshold map files for the
1227 % map matching the given name or alias.
1228 %
1229 % The format of the GetThresholdMap method is:
1230 %
1231 % ThresholdMap *GetThresholdMap(const char *map_id,
1232 % ExceptionInfo *exception)
1233 %
1234 % A description of each parameter follows.
1235 %
1236 % o map_id: ID of the map to look for.
1237 %
1238 % o exception: return any errors or warnings in this structure.
1239 %
1240 */
1241 MagickExport ThresholdMap *GetThresholdMap(const char *map_id,
1242  ExceptionInfo *exception)
1243 {
1244  ThresholdMap
1245  *map;
1246 
1247  map=GetThresholdMapFile(MinimalThresholdMap,"built-in",map_id,exception);
1248  if (map != (ThresholdMap *) NULL)
1249  return(map);
1250 #if !defined(MAGICKCORE_ZERO_CONFIGURATION_SUPPORT)
1251  {
1252  const StringInfo
1253  *option;
1254 
1255  LinkedListInfo
1256  *options;
1257 
1258  options=GetConfigureOptions(ThresholdsFilename,exception);
1259  option=(const StringInfo *) GetNextValueInLinkedList(options);
1260  while (option != (const StringInfo *) NULL)
1261  {
1262  map=GetThresholdMapFile((const char *) GetStringInfoDatum(option),
1263  GetStringInfoPath(option),map_id,exception);
1264  if (map != (ThresholdMap *) NULL)
1265  break;
1266  option=(const StringInfo *) GetNextValueInLinkedList(options);
1267  }
1268  options=DestroyConfigureOptions(options);
1269  }
1270 #endif
1271  return(map);
1272 }
1273 
1274 /*
1275 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1276 % %
1277 % %
1278 % %
1279 + G e t T h r e s h o l d M a p F i l e %
1280 % %
1281 % %
1282 % %
1283 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1284 %
1285 % GetThresholdMapFile() look for a given threshold map name or alias in the
1286 % given XML file data, and return the allocated the map when found.
1287 %
1288 % The format of the ListThresholdMaps method is:
1289 %
1290 % ThresholdMap *GetThresholdMap(const char *xml,const char *filename,
1291 % const char *map_id,ExceptionInfo *exception)
1292 %
1293 % A description of each parameter follows.
1294 %
1295 % o xml: The threshold map list in XML format.
1296 %
1297 % o filename: The threshold map XML filename.
1298 %
1299 % o map_id: ID of the map to look for in XML list.
1300 %
1301 % o exception: return any errors or warnings in this structure.
1302 %
1303 */
1304 static ThresholdMap *GetThresholdMapFile(const char *xml,const char *filename,
1305  const char *map_id,ExceptionInfo *exception)
1306 {
1307  char
1308  *p;
1309 
1310  const char
1311  *attribute,
1312  *content;
1313 
1314  double
1315  value;
1316 
1317  register ssize_t
1318  i;
1319 
1320  ThresholdMap
1321  *map;
1322 
1323  XMLTreeInfo
1324  *description,
1325  *levels,
1326  *threshold,
1327  *thresholds;
1328 
1329  (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
1330  "Loading threshold map file \"%s\" ...",filename);
1331  map=(ThresholdMap *) NULL;
1332  thresholds=NewXMLTree(xml,exception);
1333  if (thresholds == (XMLTreeInfo *) NULL)
1334  return(map);
1335  for (threshold=GetXMLTreeChild(thresholds,"threshold");
1336  threshold != (XMLTreeInfo *) NULL;
1337  threshold=GetNextXMLTreeTag(threshold))
1338  {
1339  attribute=GetXMLTreeAttribute(threshold,"map");
1340  if ((attribute != (char *) NULL) && (LocaleCompare(map_id,attribute) == 0))
1341  break;
1342  attribute=GetXMLTreeAttribute(threshold,"alias");
1343  if ((attribute != (char *) NULL) && (LocaleCompare(map_id,attribute) == 0))
1344  break;
1345  }
1346  if (threshold == (XMLTreeInfo *) NULL)
1347  {
1348  thresholds=DestroyXMLTree(thresholds);
1349  return(map);
1350  }
1351  description=GetXMLTreeChild(threshold,"description");
1352  if (description == (XMLTreeInfo *) NULL)
1353  {
1354  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1355  "XmlMissingElement", "<description>, map \"%s\"",map_id);
1356  thresholds=DestroyXMLTree(thresholds);
1357  return(map);
1358  }
1359  levels=GetXMLTreeChild(threshold,"levels");
1360  if (levels == (XMLTreeInfo *) NULL)
1361  {
1362  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1363  "XmlMissingElement", "<levels>, map \"%s\"", map_id);
1364  thresholds=DestroyXMLTree(thresholds);
1365  return(map);
1366  }
1367  map=(ThresholdMap *) AcquireCriticalMemory(sizeof(*map));
1368  map->map_id=(char *) NULL;
1369  map->description=(char *) NULL;
1370  map->levels=(ssize_t *) NULL;
1371  attribute=GetXMLTreeAttribute(threshold,"map");
1372  if (attribute != (char *) NULL)
1373  map->map_id=ConstantString(attribute);
1374  content=GetXMLTreeContent(description);
1375  if (content != (char *) NULL)
1376  map->description=ConstantString(content);
1377  attribute=GetXMLTreeAttribute(levels,"width");
1378  if (attribute == (char *) NULL)
1379  {
1380  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1381  "XmlMissingAttribute", "<levels width>, map \"%s\"",map_id);
1382  thresholds=DestroyXMLTree(thresholds);
1383  map=DestroyThresholdMap(map);
1384  return(map);
1385  }
1386  map->width=StringToUnsignedLong(attribute);
1387  if (map->width == 0)
1388  {
1389  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1390  "XmlInvalidAttribute", "<levels width>, map \"%s\"",map_id);
1391  thresholds=DestroyXMLTree(thresholds);
1392  map=DestroyThresholdMap(map);
1393  return(map);
1394  }
1395  attribute=GetXMLTreeAttribute(levels,"height");
1396  if (attribute == (char *) NULL)
1397  {
1398  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1399  "XmlMissingAttribute", "<levels height>, map \"%s\"",map_id);
1400  thresholds=DestroyXMLTree(thresholds);
1401  map=DestroyThresholdMap(map);
1402  return(map);
1403  }
1404  map->height=StringToUnsignedLong(attribute);
1405  if (map->height == 0)
1406  {
1407  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1408  "XmlInvalidAttribute", "<levels height>, map \"%s\"",map_id);
1409  thresholds=DestroyXMLTree(thresholds);
1410  map=DestroyThresholdMap(map);
1411  return(map);
1412  }
1413  attribute=GetXMLTreeAttribute(levels,"divisor");
1414  if (attribute == (char *) NULL)
1415  {
1416  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1417  "XmlMissingAttribute", "<levels divisor>, map \"%s\"",map_id);
1418  thresholds=DestroyXMLTree(thresholds);
1419  map=DestroyThresholdMap(map);
1420  return(map);
1421  }
1422  map->divisor=(ssize_t) StringToLong(attribute);
1423  if (map->divisor < 2)
1424  {
1425  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1426  "XmlInvalidAttribute", "<levels divisor>, map \"%s\"",map_id);
1427  thresholds=DestroyXMLTree(thresholds);
1428  map=DestroyThresholdMap(map);
1429  return(map);
1430  }
1431  content=GetXMLTreeContent(levels);
1432  if (content == (char *) NULL)
1433  {
1434  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1435  "XmlMissingContent", "<levels>, map \"%s\"",map_id);
1436  thresholds=DestroyXMLTree(thresholds);
1437  map=DestroyThresholdMap(map);
1438  return(map);
1439  }
1440  map->levels=(ssize_t *) AcquireQuantumMemory((size_t) map->width,map->height*
1441  sizeof(*map->levels));
1442  if (map->levels == (ssize_t *) NULL)
1443  ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireThresholdMap");
1444  for (i=0; i < (ssize_t) (map->width*map->height); i++)
1445  {
1446  map->levels[i]=(ssize_t) strtol(content,&p,10);
1447  if (p == content)
1448  {
1449  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1450  "XmlInvalidContent", "<level> too few values, map \"%s\"",map_id);
1451  thresholds=DestroyXMLTree(thresholds);
1452  map=DestroyThresholdMap(map);
1453  return(map);
1454  }
1455  if ((map->levels[i] < 0) || (map->levels[i] > map->divisor))
1456  {
1457  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1458  "XmlInvalidContent", "<level> %.20g out of range, map \"%s\"",
1459  (double) map->levels[i],map_id);
1460  thresholds=DestroyXMLTree(thresholds);
1461  map=DestroyThresholdMap(map);
1462  return(map);
1463  }
1464  content=p;
1465  }
1466  value=(double) strtol(content,&p,10);
1467  (void) value;
1468  if (p != content)
1469  {
1470  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1471  "XmlInvalidContent", "<level> too many values, map \"%s\"",map_id);
1472  thresholds=DestroyXMLTree(thresholds);
1473  map=DestroyThresholdMap(map);
1474  return(map);
1475  }
1476  thresholds=DestroyXMLTree(thresholds);
1477  return(map);
1478 }
1479 
1480 /*
1481 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1482 % %
1483 % %
1484 % %
1485 + L i s t T h r e s h o l d M a p F i l e %
1486 % %
1487 % %
1488 % %
1489 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1490 %
1491 % ListThresholdMapFile() lists the threshold maps and their descriptions
1492 % in the given XML file data.
1493 %
1494 % The format of the ListThresholdMaps method is:
1495 %
1496 % MagickBooleanType ListThresholdMaps(FILE *file,const char*xml,
1497 % const char *filename,ExceptionInfo *exception)
1498 %
1499 % A description of each parameter follows.
1500 %
1501 % o file: An pointer to the output FILE.
1502 %
1503 % o xml: The threshold map list in XML format.
1504 %
1505 % o filename: The threshold map XML filename.
1506 %
1507 % o exception: return any errors or warnings in this structure.
1508 %
1509 */
1510 MagickBooleanType ListThresholdMapFile(FILE *file,const char *xml,
1511  const char *filename,ExceptionInfo *exception)
1512 {
1513  const char
1514  *alias,
1515  *content,
1516  *map;
1517 
1518  XMLTreeInfo
1519  *description,
1520  *threshold,
1521  *thresholds;
1522 
1523  assert( xml != (char *) NULL );
1524  assert( file != (FILE *) NULL );
1525  (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
1526  "Loading threshold map file \"%s\" ...",filename);
1527  thresholds=NewXMLTree(xml,exception);
1528  if ( thresholds == (XMLTreeInfo *) NULL )
1529  return(MagickFalse);
1530  (void) FormatLocaleFile(file,"%-16s %-12s %s\n","Map","Alias","Description");
1531  (void) FormatLocaleFile(file,
1532  "----------------------------------------------------\n");
1533  threshold=GetXMLTreeChild(thresholds,"threshold");
1534  for ( ; threshold != (XMLTreeInfo *) NULL;
1535  threshold=GetNextXMLTreeTag(threshold))
1536  {
1537  map=GetXMLTreeAttribute(threshold,"map");
1538  if (map == (char *) NULL)
1539  {
1540  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1541  "XmlMissingAttribute", "<map>");
1542  thresholds=DestroyXMLTree(thresholds);
1543  return(MagickFalse);
1544  }
1545  alias=GetXMLTreeAttribute(threshold,"alias");
1546  description=GetXMLTreeChild(threshold,"description");
1547  if (description == (XMLTreeInfo *) NULL)
1548  {
1549  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1550  "XmlMissingElement", "<description>, map \"%s\"",map);
1551  thresholds=DestroyXMLTree(thresholds);
1552  return(MagickFalse);
1553  }
1554  content=GetXMLTreeContent(description);
1555  if (content == (char *) NULL)
1556  {
1557  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1558  "XmlMissingContent", "<description>, map \"%s\"", map);
1559  thresholds=DestroyXMLTree(thresholds);
1560  return(MagickFalse);
1561  }
1562  (void) FormatLocaleFile(file,"%-16s %-12s %s\n",map,alias ? alias : "",
1563  content);
1564  }
1565  thresholds=DestroyXMLTree(thresholds);
1566  return(MagickTrue);
1567 }
1568 
1569 /*
1570 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1571 % %
1572 % %
1573 % %
1574 % L i s t T h r e s h o l d M a p s %
1575 % %
1576 % %
1577 % %
1578 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1579 %
1580 % ListThresholdMaps() lists the threshold maps and their descriptions
1581 % as defined by "threshold.xml" to a file.
1582 %
1583 % The format of the ListThresholdMaps method is:
1584 %
1585 % MagickBooleanType ListThresholdMaps(FILE *file,ExceptionInfo *exception)
1586 %
1587 % A description of each parameter follows.
1588 %
1589 % o file: An pointer to the output FILE.
1590 %
1591 % o exception: return any errors or warnings in this structure.
1592 %
1593 */
1594 MagickExport MagickBooleanType ListThresholdMaps(FILE *file,
1595  ExceptionInfo *exception)
1596 {
1597  const StringInfo
1598  *option;
1599 
1600  LinkedListInfo
1601  *options;
1602 
1603  MagickStatusType
1604  status;
1605 
1606  status=MagickTrue;
1607  if (file == (FILE *) NULL)
1608  file=stdout;
1609  options=GetConfigureOptions(ThresholdsFilename,exception);
1610  (void) FormatLocaleFile(file,
1611  "\n Threshold Maps for Ordered Dither Operations\n");
1612  option=(const StringInfo *) GetNextValueInLinkedList(options);
1613  while (option != (const StringInfo *) NULL)
1614  {
1615  (void) FormatLocaleFile(file,"\nPath: %s\n\n",GetStringInfoPath(option));
1616  status&=ListThresholdMapFile(file,(const char *) GetStringInfoDatum(option),
1617  GetStringInfoPath(option),exception);
1618  option=(const StringInfo *) GetNextValueInLinkedList(options);
1619  }
1620  options=DestroyConfigureOptions(options);
1621  return(status != 0 ? MagickTrue : MagickFalse);
1622 }
1623 
1624 /*
1625 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1626 % %
1627 % %
1628 % %
1629 % O r d e r e d D i t h e r I m a g e %
1630 % %
1631 % %
1632 % %
1633 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1634 %
1635 % OrderedDitherImage() will perform a ordered dither based on a number
1636 % of pre-defined dithering threshold maps, but over multiple intensity
1637 % levels, which can be different for different channels, according to the
1638 % input argument.
1639 %
1640 % The format of the OrderedDitherImage method is:
1641 %
1642 % MagickBooleanType OrderedDitherImage(Image *image,
1643 % const char *threshold_map,ExceptionInfo *exception)
1644 %
1645 % A description of each parameter follows:
1646 %
1647 % o image: the image.
1648 %
1649 % o threshold_map: A string containing the name of the threshold dither
1650 % map to use, followed by zero or more numbers representing the number
1651 % of color levels tho dither between.
1652 %
1653 % Any level number less than 2 will be equivalent to 2, and means only
1654 % binary dithering will be applied to each color channel.
1655 %
1656 % No numbers also means a 2 level (bitmap) dither will be applied to all
1657 % channels, while a single number is the number of levels applied to each
1658 % channel in sequence. More numbers will be applied in turn to each of
1659 % the color channels.
1660 %
1661 % For example: "o3x3,6" will generate a 6 level posterization of the
1662 % image with a ordered 3x3 diffused pixel dither being applied between
1663 % each level. While checker,8,8,4 will produce a 332 colormaped image
1664 % with only a single checkerboard hash pattern (50% grey) between each
1665 % color level, to basically double the number of color levels with
1666 % a bare minimim of dithering.
1667 %
1668 % o exception: return any errors or warnings in this structure.
1669 %
1670 */
1671 MagickExport MagickBooleanType OrderedDitherImage(Image *image,
1672  const char *threshold_map,ExceptionInfo *exception)
1673 {
1674 #define DitherImageTag "Dither/Image"
1675 
1676  CacheView
1677  *image_view;
1678 
1679  char
1680  token[MagickPathExtent];
1681 
1682  const char
1683  *p;
1684 
1685  double
1686  levels[CompositePixelChannel];
1687 
1688  MagickBooleanType
1689  status;
1690 
1691  MagickOffsetType
1692  progress;
1693 
1694  register ssize_t
1695  i;
1696 
1697  ssize_t
1698  y;
1699 
1700  ThresholdMap
1701  *map;
1702 
1703  assert(image != (Image *) NULL);
1704  assert(image->signature == MagickCoreSignature);
1705  if (image->debug != MagickFalse)
1706  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1707  assert(exception != (ExceptionInfo *) NULL);
1708  assert(exception->signature == MagickCoreSignature);
1709  if (threshold_map == (const char *) NULL)
1710  return(MagickTrue);
1711  p=(char *) threshold_map;
1712  while (((isspace((int) ((unsigned char) *p)) != 0) || (*p == ',')) &&
1713  (*p != '\0'))
1714  p++;
1715  threshold_map=p;
1716  while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != ',')) &&
1717  (*p != '\0'))
1718  {
1719  if ((p-threshold_map) >= (MagickPathExtent-1))
1720  break;
1721  token[p-threshold_map]=(*p);
1722  p++;
1723  }
1724  token[p-threshold_map]='\0';
1725  map=GetThresholdMap(token,exception);
1726  if (map == (ThresholdMap *) NULL)
1727  {
1728  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1729  "InvalidArgument","%s : '%s'","ordered-dither",threshold_map);
1730  return(MagickFalse);
1731  }
1732  for (i=0; i < MaxPixelChannels; i++)
1733  levels[i]=2.0;
1734  p=strchr((char *) threshold_map,',');
1735  if ((p != (char *) NULL) && (isdigit((int) ((unsigned char) *(++p))) != 0))
1736  {
1737  GetNextToken(p,&p,MagickPathExtent,token);
1738  for (i=0; (i < MaxPixelChannels); i++)
1739  levels[i]=StringToDouble(token,(char **) NULL);
1740  for (i=0; (*p != '\0') && (i < MaxPixelChannels); i++)
1741  {
1742  GetNextToken(p,&p,MagickPathExtent,token);
1743  if (*token == ',')
1744  GetNextToken(p,&p,MagickPathExtent,token);
1745  levels[i]=StringToDouble(token,(char **) NULL);
1746  }
1747  }
1748  for (i=0; i < MaxPixelChannels; i++)
1749  if (fabs(levels[i]) >= 1)
1750  levels[i]-=1.0;
1751  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1752  return(MagickFalse);
1753  status=MagickTrue;
1754  progress=0;
1755  image_view=AcquireAuthenticCacheView(image,exception);
1756 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1757  #pragma omp parallel for schedule(static) shared(progress,status) \
1758  magick_number_threads(image,image,image->rows,1)
1759 #endif
1760  for (y=0; y < (ssize_t) image->rows; y++)
1761  {
1762  register ssize_t
1763  x;
1764 
1765  register Quantum
1766  *magick_restrict q;
1767 
1768  if (status == MagickFalse)
1769  continue;
1770  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1771  if (q == (Quantum *) NULL)
1772  {
1773  status=MagickFalse;
1774  continue;
1775  }
1776  for (x=0; x < (ssize_t) image->columns; x++)
1777  {
1778  register ssize_t
1779  i;
1780 
1781  ssize_t
1782  n;
1783 
1784  n=0;
1785  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1786  {
1787  ssize_t
1788  level,
1789  threshold;
1790 
1791  PixelChannel channel = GetPixelChannelChannel(image,i);
1792  PixelTrait traits = GetPixelChannelTraits(image,channel);
1793  if ((traits & UpdatePixelTrait) == 0)
1794  continue;
1795  if (fabs(levels[n]) < MagickEpsilon)
1796  {
1797  n++;
1798  continue;
1799  }
1800  threshold=(ssize_t) (QuantumScale*q[i]*(levels[n]*(map->divisor-1)+1));
1801  level=threshold/(map->divisor-1);
1802  threshold-=level*(map->divisor-1);
1803  q[i]=ClampToQuantum((double) (level+(threshold >=
1804  map->levels[(x % map->width)+map->width*(y % map->height)]))*
1805  QuantumRange/levels[n]);
1806  n++;
1807  }
1808  q+=GetPixelChannels(image);
1809  }
1810  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1811  status=MagickFalse;
1812  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1813  {
1814  MagickBooleanType
1815  proceed;
1816 
1817 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1818  #pragma omp atomic
1819 #endif
1820  progress++;
1821  proceed=SetImageProgress(image,DitherImageTag,progress,image->rows);
1822  if (proceed == MagickFalse)
1823  status=MagickFalse;
1824  }
1825  }
1826  image_view=DestroyCacheView(image_view);
1827  map=DestroyThresholdMap(map);
1828  return(MagickTrue);
1829 }
1830 
1831 /*
1832 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1833 % %
1834 % %
1835 % %
1836 % P e r c e p t i b l e I m a g e %
1837 % %
1838 % %
1839 % %
1840 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1841 %
1842 % PerceptibleImage() set each pixel whose value is less than |epsilon| to
1843 % epsilon or -epsilon (whichever is closer) otherwise the pixel value remains
1844 % unchanged.
1845 %
1846 % The format of the PerceptibleImage method is:
1847 %
1848 % MagickBooleanType PerceptibleImage(Image *image,const double epsilon,
1849 % ExceptionInfo *exception)
1850 %
1851 % A description of each parameter follows:
1852 %
1853 % o image: the image.
1854 %
1855 % o epsilon: the epsilon threshold (e.g. 1.0e-9).
1856 %
1857 % o exception: return any errors or warnings in this structure.
1858 %
1859 */
1860 
1861 static inline Quantum PerceptibleThreshold(const Quantum quantum,
1862  const double epsilon)
1863 {
1864  double
1865  sign;
1866 
1867  sign=(double) quantum < 0.0 ? -1.0 : 1.0;
1868  if ((sign*quantum) >= epsilon)
1869  return(quantum);
1870  return((Quantum) (sign*epsilon));
1871 }
1872 
1873 MagickExport MagickBooleanType PerceptibleImage(Image *image,
1874  const double epsilon,ExceptionInfo *exception)
1875 {
1876 #define PerceptibleImageTag "Perceptible/Image"
1877 
1878  CacheView
1879  *image_view;
1880 
1881  MagickBooleanType
1882  status;
1883 
1884  MagickOffsetType
1885  progress;
1886 
1887  ssize_t
1888  y;
1889 
1890  assert(image != (Image *) NULL);
1891  assert(image->signature == MagickCoreSignature);
1892  if (image->debug != MagickFalse)
1893  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1894  if (image->storage_class == PseudoClass)
1895  {
1896  register ssize_t
1897  i;
1898 
1899  register PixelInfo
1900  *magick_restrict q;
1901 
1902  q=image->colormap;
1903  for (i=0; i < (ssize_t) image->colors; i++)
1904  {
1905  q->red=(double) PerceptibleThreshold(ClampToQuantum(q->red),
1906  epsilon);
1907  q->green=(double) PerceptibleThreshold(ClampToQuantum(q->green),
1908  epsilon);
1909  q->blue=(double) PerceptibleThreshold(ClampToQuantum(q->blue),
1910  epsilon);
1911  q->alpha=(double) PerceptibleThreshold(ClampToQuantum(q->alpha),
1912  epsilon);
1913  q++;
1914  }
1915  return(SyncImage(image,exception));
1916  }
1917  /*
1918  Perceptible image.
1919  */
1920  status=MagickTrue;
1921  progress=0;
1922  image_view=AcquireAuthenticCacheView(image,exception);
1923 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1924  #pragma omp parallel for schedule(static) shared(progress,status) \
1925  magick_number_threads(image,image,image->rows,1)
1926 #endif
1927  for (y=0; y < (ssize_t) image->rows; y++)
1928  {
1929  register ssize_t
1930  x;
1931 
1932  register Quantum
1933  *magick_restrict q;
1934 
1935  if (status == MagickFalse)
1936  continue;
1937  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1938  if (q == (Quantum *) NULL)
1939  {
1940  status=MagickFalse;
1941  continue;
1942  }
1943  for (x=0; x < (ssize_t) image->columns; x++)
1944  {
1945  register ssize_t
1946  i;
1947 
1948  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1949  {
1950  PixelChannel channel = GetPixelChannelChannel(image,i);
1951  PixelTrait traits = GetPixelChannelTraits(image,channel);
1952  if (traits == UndefinedPixelTrait)
1953  continue;
1954  q[i]=PerceptibleThreshold(q[i],epsilon);
1955  }
1956  q+=GetPixelChannels(image);
1957  }
1958  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1959  status=MagickFalse;
1960  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1961  {
1962  MagickBooleanType
1963  proceed;
1964 
1965 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1966  #pragma omp atomic
1967 #endif
1968  progress++;
1969  proceed=SetImageProgress(image,PerceptibleImageTag,progress,
1970  image->rows);
1971  if (proceed == MagickFalse)
1972  status=MagickFalse;
1973  }
1974  }
1975  image_view=DestroyCacheView(image_view);
1976  return(status);
1977 }
1978 
1979 /*
1980 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1981 % %
1982 % %
1983 % %
1984 % R a n d o m T h r e s h o l d I m a g e %
1985 % %
1986 % %
1987 % %
1988 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1989 %
1990 % RandomThresholdImage() changes the value of individual pixels based on the
1991 % intensity of each pixel compared to a random threshold. The result is a
1992 % low-contrast, two color image.
1993 %
1994 % The format of the RandomThresholdImage method is:
1995 %
1996 % MagickBooleanType RandomThresholdImage(Image *image,
1997 % const char *thresholds,ExceptionInfo *exception)
1998 %
1999 % A description of each parameter follows:
2000 %
2001 % o image: the image.
2002 %
2003 % o low,high: Specify the high and low thresholds. These values range from
2004 % 0 to QuantumRange.
2005 %
2006 % o exception: return any errors or warnings in this structure.
2007 %
2008 */
2009 MagickExport MagickBooleanType RandomThresholdImage(Image *image,
2010  const double min_threshold, const double max_threshold,ExceptionInfo *exception)
2011 {
2012 #define ThresholdImageTag "Threshold/Image"
2013 
2014  CacheView
2015  *image_view;
2016 
2017  MagickBooleanType
2018  status;
2019 
2020  MagickOffsetType
2021  progress;
2022 
2023  PixelInfo
2024  threshold;
2025 
2026  RandomInfo
2027  **magick_restrict random_info;
2028 
2029  ssize_t
2030  y;
2031 
2032 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2033  unsigned long
2034  key;
2035 #endif
2036 
2037  assert(image != (Image *) NULL);
2038  assert(image->signature == MagickCoreSignature);
2039  if (image->debug != MagickFalse)
2040  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2041  assert(exception != (ExceptionInfo *) NULL);
2042  assert(exception->signature == MagickCoreSignature);
2043  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2044  return(MagickFalse);
2045  GetPixelInfo(image,&threshold);
2046  /*
2047  Random threshold image.
2048  */
2049  status=MagickTrue;
2050  progress=0;
2051  random_info=AcquireRandomInfoThreadSet();
2052  image_view=AcquireAuthenticCacheView(image,exception);
2053 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2054  key=GetRandomSecretKey(random_info[0]);
2055  #pragma omp parallel for schedule(static) shared(progress,status) \
2056  magick_number_threads(image,image,image->rows,key == ~0UL)
2057 #endif
2058  for (y=0; y < (ssize_t) image->rows; y++)
2059  {
2060  const int
2061  id = GetOpenMPThreadId();
2062 
2063  register Quantum
2064  *magick_restrict q;
2065 
2066  register ssize_t
2067  x;
2068 
2069  if (status == MagickFalse)
2070  continue;
2071  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2072  if (q == (Quantum *) NULL)
2073  {
2074  status=MagickFalse;
2075  continue;
2076  }
2077  for (x=0; x < (ssize_t) image->columns; x++)
2078  {
2079  register ssize_t
2080  i;
2081 
2082  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2083  {
2084  double
2085  threshold;
2086 
2087  PixelChannel channel = GetPixelChannelChannel(image,i);
2088  PixelTrait traits = GetPixelChannelTraits(image,channel);
2089  if ((traits & UpdatePixelTrait) == 0)
2090  continue;
2091  if ((double) q[i] < min_threshold)
2092  threshold=min_threshold;
2093  else
2094  if ((double) q[i] > max_threshold)
2095  threshold=max_threshold;
2096  else
2097  threshold=(double) (QuantumRange*
2098  GetPseudoRandomValue(random_info[id]));
2099  q[i]=(double) q[i] <= threshold ? 0 : QuantumRange;
2100  }
2101  q+=GetPixelChannels(image);
2102  }
2103  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2104  status=MagickFalse;
2105  if (image->progress_monitor != (MagickProgressMonitor) NULL)
2106  {
2107  MagickBooleanType
2108  proceed;
2109 
2110 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2111  #pragma omp atomic
2112 #endif
2113  progress++;
2114  proceed=SetImageProgress(image,ThresholdImageTag,progress,
2115  image->rows);
2116  if (proceed == MagickFalse)
2117  status=MagickFalse;
2118  }
2119  }
2120  image_view=DestroyCacheView(image_view);
2121  random_info=DestroyRandomInfoThreadSet(random_info);
2122  return(status);
2123 }
2124 
2125 /*
2126 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2127 % %
2128 % %
2129 % %
2130 % R a n g e T h r e s h o l d I m a g e %
2131 % %
2132 % %
2133 % %
2134 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2135 %
2136 % RangeThresholdImage() applies soft and hard thresholding.
2137 %
2138 % The format of the RangeThresholdImage method is:
2139 %
2140 % MagickBooleanType RangeThresholdImage(Image *image,
2141 % const double low_black,const double low_white,const double high_white,
2142 % const double high_black,ExceptionInfo *exception)
2143 %
2144 % A description of each parameter follows:
2145 %
2146 % o image: the image.
2147 %
2148 % o low_black: Define the minimum black threshold value.
2149 %
2150 % o low_white: Define the minimum white threshold value.
2151 %
2152 % o high_white: Define the maximum white threshold value.
2153 %
2154 % o high_black: Define the maximum black threshold value.
2155 %
2156 % o exception: return any errors or warnings in this structure.
2157 %
2158 */
2159 MagickExport MagickBooleanType RangeThresholdImage(Image *image,
2160  const double low_black,const double low_white,const double high_white,
2161  const double high_black,ExceptionInfo *exception)
2162 {
2163 #define ThresholdImageTag "Threshold/Image"
2164 
2165  CacheView
2166  *image_view;
2167 
2168  MagickBooleanType
2169  status;
2170 
2171  MagickOffsetType
2172  progress;
2173 
2174  ssize_t
2175  y;
2176 
2177  assert(image != (Image *) NULL);
2178  assert(image->signature == MagickCoreSignature);
2179  if (image->debug != MagickFalse)
2180  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2181  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2182  return(MagickFalse);
2183  if (IsGrayColorspace(image->colorspace) != MagickFalse)
2184  (void) TransformImageColorspace(image,sRGBColorspace,exception);
2185  /*
2186  Range threshold image.
2187  */
2188  status=MagickTrue;
2189  progress=0;
2190  image_view=AcquireAuthenticCacheView(image,exception);
2191 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2192  #pragma omp parallel for schedule(static) shared(progress,status) \
2193  magick_number_threads(image,image,image->rows,1)
2194 #endif
2195  for (y=0; y < (ssize_t) image->rows; y++)
2196  {
2197  register ssize_t
2198  x;
2199 
2200  register Quantum
2201  *magick_restrict q;
2202 
2203  if (status == MagickFalse)
2204  continue;
2205  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2206  if (q == (Quantum *) NULL)
2207  {
2208  status=MagickFalse;
2209  continue;
2210  }
2211  for (x=0; x < (ssize_t) image->columns; x++)
2212  {
2213  double
2214  pixel;
2215 
2216  register ssize_t
2217  i;
2218 
2219  pixel=GetPixelIntensity(image,q);
2220  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2221  {
2222  PixelChannel channel = GetPixelChannelChannel(image,i);
2223  PixelTrait traits = GetPixelChannelTraits(image,channel);
2224  if ((traits & UpdatePixelTrait) == 0)
2225  continue;
2226  if (image->channel_mask != DefaultChannels)
2227  pixel=(double) q[i];
2228  if (pixel < low_black)
2229  q[i]=0;
2230  else
2231  if ((pixel >= low_black) && (pixel < low_white))
2232  q[i]=ClampToQuantum(QuantumRange*
2233  PerceptibleReciprocal(low_white-low_black)*(pixel-low_black));
2234  else
2235  if ((pixel >= low_white) && (pixel <= high_white))
2236  q[i]=QuantumRange;
2237  else
2238  if ((pixel > high_white) && (pixel <= high_black))
2239  q[i]=ClampToQuantum(QuantumRange*PerceptibleReciprocal(
2240  high_black-high_white)*(high_black-pixel));
2241  else
2242  if (pixel > high_black)
2243  q[i]=0;
2244  else
2245  q[i]=0;
2246  }
2247  q+=GetPixelChannels(image);
2248  }
2249  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2250  status=MagickFalse;
2251  if (image->progress_monitor != (MagickProgressMonitor) NULL)
2252  {
2253  MagickBooleanType
2254  proceed;
2255 
2256 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2257  #pragma omp atomic
2258 #endif
2259  progress++;
2260  proceed=SetImageProgress(image,ThresholdImageTag,progress,
2261  image->rows);
2262  if (proceed == MagickFalse)
2263  status=MagickFalse;
2264  }
2265  }
2266  image_view=DestroyCacheView(image_view);
2267  return(status);
2268 }
2269 
2270 /*
2271 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2272 % %
2273 % %
2274 % %
2275 % W h i t e T h r e s h o l d I m a g e %
2276 % %
2277 % %
2278 % %
2279 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2280 %
2281 % WhiteThresholdImage() is like ThresholdImage() but forces all pixels above
2282 % the threshold into white while leaving all pixels at or below the threshold
2283 % unchanged.
2284 %
2285 % The format of the WhiteThresholdImage method is:
2286 %
2287 % MagickBooleanType WhiteThresholdImage(Image *image,
2288 % const char *threshold,ExceptionInfo *exception)
2289 %
2290 % A description of each parameter follows:
2291 %
2292 % o image: the image.
2293 %
2294 % o threshold: Define the threshold value.
2295 %
2296 % o exception: return any errors or warnings in this structure.
2297 %
2298 */
2299 MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
2300  const char *thresholds,ExceptionInfo *exception)
2301 {
2302 #define ThresholdImageTag "Threshold/Image"
2303 
2304  CacheView
2305  *image_view;
2306 
2307  GeometryInfo
2308  geometry_info;
2309 
2310  MagickBooleanType
2311  status;
2312 
2313  MagickOffsetType
2314  progress;
2315 
2316  PixelInfo
2317  threshold;
2318 
2319  MagickStatusType
2320  flags;
2321 
2322  ssize_t
2323  y;
2324 
2325  assert(image != (Image *) NULL);
2326  assert(image->signature == MagickCoreSignature);
2327  if (image->debug != MagickFalse)
2328  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2329  if (thresholds == (const char *) NULL)
2330  return(MagickTrue);
2331  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2332  return(MagickFalse);
2333  if (IsGrayColorspace(image->colorspace) != MagickFalse)
2334  (void) TransformImageColorspace(image,sRGBColorspace,exception);
2335  GetPixelInfo(image,&threshold);
2336  flags=ParseGeometry(thresholds,&geometry_info);
2337  threshold.red=geometry_info.rho;
2338  threshold.green=geometry_info.rho;
2339  threshold.blue=geometry_info.rho;
2340  threshold.black=geometry_info.rho;
2341  threshold.alpha=100.0;
2342  if ((flags & SigmaValue) != 0)
2343  threshold.green=geometry_info.sigma;
2344  if ((flags & XiValue) != 0)
2345  threshold.blue=geometry_info.xi;
2346  if ((flags & PsiValue) != 0)
2347  threshold.alpha=geometry_info.psi;
2348  if (threshold.colorspace == CMYKColorspace)
2349  {
2350  if ((flags & PsiValue) != 0)
2351  threshold.black=geometry_info.psi;
2352  if ((flags & ChiValue) != 0)
2353  threshold.alpha=geometry_info.chi;
2354  }
2355  if ((flags & PercentValue) != 0)
2356  {
2357  threshold.red*=(MagickRealType) (QuantumRange/100.0);
2358  threshold.green*=(MagickRealType) (QuantumRange/100.0);
2359  threshold.blue*=(MagickRealType) (QuantumRange/100.0);
2360  threshold.black*=(MagickRealType) (QuantumRange/100.0);
2361  threshold.alpha*=(MagickRealType) (QuantumRange/100.0);
2362  }
2363  /*
2364  White threshold image.
2365  */
2366  status=MagickTrue;
2367  progress=0;
2368  image_view=AcquireAuthenticCacheView(image,exception);
2369 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2370  #pragma omp parallel for schedule(static) shared(progress,status) \
2371  magick_number_threads(image,image,image->rows,1)
2372 #endif
2373  for (y=0; y < (ssize_t) image->rows; y++)
2374  {
2375  register ssize_t
2376  x;
2377 
2378  register Quantum
2379  *magick_restrict q;
2380 
2381  if (status == MagickFalse)
2382  continue;
2383  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2384  if (q == (Quantum *) NULL)
2385  {
2386  status=MagickFalse;
2387  continue;
2388  }
2389  for (x=0; x < (ssize_t) image->columns; x++)
2390  {
2391  double
2392  pixel;
2393 
2394  register ssize_t
2395  i;
2396 
2397  pixel=GetPixelIntensity(image,q);
2398  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2399  {
2400  PixelChannel channel = GetPixelChannelChannel(image,i);
2401  PixelTrait traits = GetPixelChannelTraits(image,channel);
2402  if ((traits & UpdatePixelTrait) == 0)
2403  continue;
2404  if (image->channel_mask != DefaultChannels)
2405  pixel=(double) q[i];
2406  if (pixel > GetPixelInfoChannel(&threshold,channel))
2407  q[i]=QuantumRange;
2408  }
2409  q+=GetPixelChannels(image);
2410  }
2411  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2412  status=MagickFalse;
2413  if (image->progress_monitor != (MagickProgressMonitor) NULL)
2414  {
2415  MagickBooleanType
2416  proceed;
2417 
2418 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2419  #pragma omp atomic
2420 #endif
2421  progress++;
2422  proceed=SetImageProgress(image,ThresholdImageTag,progress,image->rows);
2423  if (proceed == MagickFalse)
2424  status=MagickFalse;
2425  }
2426  }
2427  image_view=DestroyCacheView(image_view);
2428  return(status);
2429 }
DitherImageTag
#define DitherImageTag
_GeometryInfo::psi
double psi
Definition: geometry.h:106
_Image::rows
size_t rows
Definition: image.h:172
magick_restrict
#define magick_restrict
Definition: MagickCore.h:41
BlackThresholdImage
MagickExport MagickBooleanType BlackThresholdImage(Image *image, const char *thresholds, ExceptionInfo *exception)
Definition: threshold.c:920
RangeThresholdImage
MagickExport MagickBooleanType RangeThresholdImage(Image *image, const double low_black, const double low_white, const double high_white, const double high_black, ExceptionInfo *exception)
Definition: threshold.c:2159
MagickRealType
MagickDoubleType MagickRealType
Definition: magick-type.h:120
DestroyCacheView
MagickExport CacheView * DestroyCacheView(CacheView *cache_view)
Definition: cache-view.c:252
_Image::colormap
PixelInfo * colormap
Definition: image.h:179
_XMLTreeInfo
Definition: xml-tree.c:77
DestroyXMLTree
MagickExport XMLTreeInfo * DestroyXMLTree(XMLTreeInfo *xml_info)
Definition: xml-tree.c:558
_Image::progress_monitor
MagickProgressMonitor progress_monitor
Definition: image.h:303
_Image::type
ImageType type
Definition: image.h:264
SyncImage
MagickExport MagickBooleanType SyncImage(Image *image, ExceptionInfo *exception)
Definition: image.c:3883
TransformImageColorspace
MagickExport MagickBooleanType TransformImageColorspace(Image *image, const ColorspaceType colorspace, ExceptionInfo *exception)
Definition: colorspace.c:1326
StringToUnsignedLong
static unsigned long StringToUnsignedLong(const char *magick_restrict value)
Definition: string-private.h:97
resource_.h
ThrowFatalException
#define ThrowFatalException(severity, tag)
Definition: exception-private.h:35
GetNextXMLTreeTag
MagickExport XMLTreeInfo * GetNextXMLTreeTag(XMLTreeInfo *xml_info)
Definition: xml-tree.c:744
_ExceptionInfo::signature
size_t signature
Definition: exception.h:123
_ThresholdMap::width
size_t width
Definition: threshold.c:108
_GeometryInfo::rho
double rho
Definition: geometry.h:106
_ExceptionInfo
Definition: exception.h:101
ListThresholdMaps
MagickExport MagickBooleanType ListThresholdMaps(FILE *file, ExceptionInfo *exception)
Definition: threshold.c:1594
_PixelInfo::red
MagickRealType red
Definition: pixel.h:191
DestroyRandomInfoThreadSet
static RandomInfo ** DestroyRandomInfoThreadSet(RandomInfo **random_info)
Definition: random-private.h:39
StringToDouble
static double StringToDouble(const char *magick_restrict string, char **magick_restrict sentinal)
Definition: string-private.h:42
GetPixelChannelTraits
static PixelTrait GetPixelChannelTraits(const Image *magick_restrict image, const PixelChannel channel)
Definition: pixel-accessor.h:131
MinimalThresholdMap
static const char * MinimalThresholdMap
Definition: threshold.c:120
AdaptiveThresholdImage
MagickExport Image * AdaptiveThresholdImage(const Image *image, const size_t width, const size_t height, const double bias, ExceptionInfo *exception)
Definition: threshold.c:178
ThresholdsFilename
#define ThresholdsFilename
Definition: threshold.c:96
FormatLocaleString
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
Definition: locale.c:499
AcquireCriticalMemory
static void * AcquireCriticalMemory(const size_t size)
Definition: memory-private.h:56
IsGrayColorspace
static MagickBooleanType IsGrayColorspace(const ColorspaceType colorspace)
Definition: colorspace-private.h:96
_CacheView
Definition: cache-view.c:65
_ThresholdMap::map_id
char * map_id
Definition: threshold.c:104
GetCacheViewVirtualPixels
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)
Definition: cache-view.c:651
AcquireRandomInfoThreadSet
static RandomInfo ** AcquireRandomInfoThreadSet(void)
Definition: random-private.h:52
StringToLong
static long StringToLong(const char *magick_restrict value)
Definition: string-private.h:68
_PixelInfo::alpha
MagickRealType alpha
Definition: pixel.h:191
_RandomInfo
Definition: random.c:79
_LinkedListInfo
Definition: linked-list.c:68
MagickEpsilon
#define MagickEpsilon
Definition: magick-type.h:110
GetXMLTreeChild
MagickExport XMLTreeInfo * GetXMLTreeChild(XMLTreeInfo *xml_info, const char *tag)
Definition: xml-tree.c:896
_GeometryInfo::sigma
double sigma
Definition: geometry.h:106
PerceptibleImage
MagickExport MagickBooleanType PerceptibleImage(Image *image, const double epsilon, ExceptionInfo *exception)
Definition: threshold.c:1873
_Image::storage_class
ClassType storage_class
Definition: image.h:154
ThrowBinaryException
#define ThrowBinaryException(severity, tag, context)
Definition: exception-private.h:29
TraceEvent
Definition: log.h:52
MagickOffsetType
ssize_t MagickOffsetType
Definition: magick-type.h:129
GetRandomSecretKey
MagickExport unsigned long GetRandomSecretKey(const RandomInfo *random_info)
Definition: random.c:743
GetPixelInfo
MagickExport void GetPixelInfo(const Image *image, PixelInfo *pixel)
Definition: pixel.c:2170
ListThresholdMapFile
MagickBooleanType ListThresholdMapFile(FILE *file, const char *xml, const char *filename, ExceptionInfo *exception)
Definition: threshold.c:1510
PerceptibleImageTag
#define PerceptibleImageTag
_Image
Definition: image.h:151
_ThresholdMap::description
char * description
Definition: threshold.c:104
GetNextValueInLinkedList
MagickExport void * GetNextValueInLinkedList(LinkedListInfo *list_info)
Definition: linked-list.c:305
MagickMinimumValue
#define MagickMinimumValue
Definition: magick-type.h:112
_StringInfo
Definition: string_.h:27
string_.h
MagickCoreSignature
#define MagickCoreSignature
Definition: method-attribute.h:86
GetCacheViewAuthenticPixels
MagickExport Quantum * GetCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: cache-view.c:299
ClampPixel
static Quantum ClampPixel(const MagickRealType pixel)
Definition: pixel-accessor.h:36
GetStringInfoDatum
MagickExport unsigned char * GetStringInfoDatum(const StringInfo *string_info)
Definition: string.c:1215
GetConfigureOptions
MagickExport LinkedListInfo * GetConfigureOptions(const char *filename, ExceptionInfo *exception)
Definition: configure.c:639
FormatLocaleFile
MagickExport ssize_t FormatLocaleFile(FILE *file, const char *magick_restrict format,...)
Definition: locale.c:404
MagickBooleanType
MagickBooleanType
Definition: magick-type.h:158
MagickStatusType
unsigned int MagickStatusType
Definition: magick-type.h:121
PerceptibleReciprocal
static double PerceptibleReciprocal(const double x)
Definition: pixel-accessor.h:224
ThresholdImageTag
#define ThresholdImageTag
AcquireQuantumMemory
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:543
MaxIntensity
#define MaxIntensity
GetOpenMPThreadId
static int GetOpenMPThreadId(void)
Definition: thread-private.h:123
_ThresholdMap::height
size_t height
Definition: threshold.c:108
_Image::channel_mask
ChannelType channel_mask
Definition: image.h:288
SetImageProperty
MagickExport MagickBooleanType SetImageProperty(Image *image, const char *property, const char *value, ExceptionInfo *exception)
Definition: property.c:4114
GetXMLTreeContent
MagickExport const char * GetXMLTreeContent(XMLTreeInfo *xml_info)
Definition: xml-tree.c:936
_ThresholdMap::divisor
ssize_t divisor
Definition: threshold.c:112
MagickSizeType
size_t MagickSizeType
Definition: magick-type.h:130
MagickPathExtent
#define MagickPathExtent
Definition: method-attribute.h:88
OTSUThreshold
static double OTSUThreshold(const Image *image, const double *histogram, ExceptionInfo *exception)
Definition: threshold.c:486
GetThresholdMap
MagickExport ThresholdMap * GetThresholdMap(const char *map_id, ExceptionInfo *exception)
Definition: threshold.c:1241
ClampImageTag
#define ClampImageTag
_PixelInfo::blue
MagickRealType blue
Definition: pixel.h:191
memory_.h
QueueCacheViewAuthenticPixels
MagickExport Quantum * QueueCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: cache-view.c:977
ThrowMagickException
MagickExport MagickBooleanType ThrowMagickException(ExceptionInfo *exception, const char *module, const char *function, const size_t line, const ExceptionType severity, const char *tag, const char *format,...)
Definition: exception.c:1145
LogMagickEvent
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
Definition: log.c:1403
_Image::signature
size_t signature
Definition: image.h:354
QuantumScale
#define QuantumScale
Definition: magick-type.h:115
_Image::columns
size_t columns
Definition: image.h:172
GetPseudoRandomValue
MagickExport double GetPseudoRandomValue(RandomInfo *random_info)
Definition: random.c:610
AdaptiveThresholdImageTag
#define AdaptiveThresholdImageTag
SetImageStorageClass
MagickExport MagickBooleanType SetImageStorageClass(Image *image, const ClassType storage_class, ExceptionInfo *exception)
Definition: image.c:2617
PixelChannel
PixelChannel
Definition: pixel.h:67
_Image::colors
size_t colors
Definition: image.h:172
TriangleThreshold
static double TriangleThreshold(const double *histogram)
Definition: threshold.c:565
GetPixelChannels
static size_t GetPixelChannels(const Image *magick_restrict image)
Definition: pixel-accessor.h:137
LocaleCompare
MagickExport int LocaleCompare(const char *p, const char *q)
Definition: locale.c:1435
_Image::filename
char filename[MagickPathExtent]
Definition: image.h:319
GetMagickModule
#define GetMagickModule()
Definition: log.h:28
_GeometryInfo::chi
double chi
Definition: geometry.h:106
GetStringInfoPath
MagickExport const char * GetStringInfoPath(const StringInfo *string_info)
Definition: string.c:1302
ClampToQuantum
static Quantum ClampToQuantum(const MagickRealType value)
Definition: quantum.h:84
GetPixelChannelChannel
static PixelChannel GetPixelChannelChannel(const Image *magick_restrict image, const ssize_t offset)
Definition: pixel-accessor.h:119
GetPixelInfoChannel
static MagickRealType GetPixelInfoChannel(const PixelInfo *magick_restrict pixel_info, const PixelChannel channel)
Definition: pixel-accessor.h:209
AcquireVirtualCacheView
MagickExport CacheView * AcquireVirtualCacheView(const Image *image, ExceptionInfo *exception)
Definition: cache-view.c:149
GetNextToken
MagickExport void GetNextToken(const char *start, const char **end, const size_t extent, char *token)
Definition: token.c:172
AutoThresholdMethod
AutoThresholdMethod
Definition: threshold.h:25
GetXMLTreeAttribute
MagickExport const char * GetXMLTreeAttribute(XMLTreeInfo *xml_info, const char *tag)
Definition: xml-tree.c:779
RandomThresholdImage
MagickExport MagickBooleanType RandomThresholdImage(Image *image, const double min_threshold, const double max_threshold, ExceptionInfo *exception)
Definition: threshold.c:2009
Quantum
unsigned short Quantum
Definition: magick-type.h:82
_GeometryInfo::xi
double xi
Definition: geometry.h:106
SetImageColorspace
MagickExport MagickBooleanType SetImageColorspace(Image *image, const ColorspaceType colorspace, ExceptionInfo *exception)
Definition: colorspace.c:1135
_PixelInfo::black
MagickRealType black
Definition: pixel.h:191
_GeometryInfo
Definition: geometry.h:103
DestroyString
MagickExport char * DestroyString(char *string)
Definition: string.c:823
ParseGeometry
MagickExport MagickStatusType ParseGeometry(const char *geometry, GeometryInfo *geometry_info)
Definition: geometry.c:853
SetPixelChannel
static void SetPixelChannel(const Image *magick_restrict image, const PixelChannel channel, const Quantum quantum, Quantum *magick_restrict pixel)
Definition: pixel-accessor.h:696
_ThresholdMap
Definition: threshold.c:101
DestroyThresholdMap
MagickExport ThresholdMap * DestroyThresholdMap(ThresholdMap *map)
Definition: threshold.c:1202
GetThresholdMapFile
static ThresholdMap * GetThresholdMapFile(const char *, const char *, const char *, ExceptionInfo *)
Definition: threshold.c:1304
BilevelImage
MagickExport MagickBooleanType BilevelImage(Image *image, const double threshold, ExceptionInfo *exception)
Definition: threshold.c:798
random_info
static RandomInfo * random_info
Definition: resource.c:113
PerceptibleThreshold
static Quantum PerceptibleThreshold(const Quantum quantum, const double epsilon)
Definition: threshold.c:1861
random_.h
RelinquishMagickMemory
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1069
MaxPixelChannels
#define MaxPixelChannels
Definition: pixel.h:27
WhiteThresholdImage
MagickExport MagickBooleanType WhiteThresholdImage(Image *image, const char *thresholds, ExceptionInfo *exception)
Definition: threshold.c:2299
ClampImage
MagickExport MagickBooleanType ClampImage(Image *image, ExceptionInfo *exception)
Definition: threshold.c:1080
_PixelInfo::green
MagickRealType green
Definition: pixel.h:191
MagickProgressMonitor
MagickBooleanType(* MagickProgressMonitor)(const char *, const MagickOffsetType, const MagickSizeType, void *)
Definition: monitor.h:26
KapurThreshold
static double KapurThreshold(const Image *image, const double *histogram, ExceptionInfo *exception)
Definition: threshold.c:387
MagickExport
#define MagickExport
Definition: method-attribute.h:80
SyncCacheViewAuthenticPixels
MagickExport MagickBooleanType SyncCacheViewAuthenticPixels(CacheView *magick_restrict cache_view, ExceptionInfo *exception)
Definition: cache-view.c:1100
AcquireAuthenticCacheView
MagickExport CacheView * AcquireAuthenticCacheView(const Image *image, ExceptionInfo *exception)
Definition: cache-view.c:112
_PixelInfo::colorspace
ColorspaceType colorspace
Definition: pixel.h:176
OrderedDitherImage
MagickExport MagickBooleanType OrderedDitherImage(Image *image, const char *threshold_map, ExceptionInfo *exception)
Definition: threshold.c:1671
_PixelInfo
Definition: pixel.h:170
PixelTrait
PixelTrait
Definition: pixel.h:135
GetPixelIntensity
MagickExport MagickRealType GetPixelIntensity(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
Definition: pixel.c:2358
DestroyConfigureOptions
MagickExport LinkedListInfo * DestroyConfigureOptions(LinkedListInfo *options)
Definition: configure.c:311
AutoThresholdImage
MagickExport MagickBooleanType AutoThresholdImage(Image *image, const AutoThresholdMethod method, ExceptionInfo *exception)
Definition: threshold.c:655
_ThresholdMap::levels
ssize_t * levels
Definition: threshold.c:112
DestroyImage
MagickExport Image * DestroyImage(Image *image)
Definition: image.c:1181
ConstantString
MagickExport char * ConstantString(const char *source)
Definition: string.c:700
CloneImage
MagickExport Image * CloneImage(const Image *image, const size_t columns, const size_t rows, const MagickBooleanType detach, ExceptionInfo *exception)
Definition: image.c:796
_Image::colorspace
ColorspaceType colorspace
Definition: image.h:157
NewXMLTree
MagickExport XMLTreeInfo * NewXMLTree(const char *xml, ExceptionInfo *exception)
Definition: xml-tree.c:1956
QuantumRange
#define QuantumRange
Definition: magick-type.h:83
SetImageProgress
MagickExport MagickBooleanType SetImageProgress(const Image *image, const char *tag, const MagickOffsetType offset, const MagickSizeType extent)
Definition: monitor.c:136
_Image::debug
MagickBooleanType debug
Definition: image.h:334