MagickCore  7.0.7
Convert, Edit, Or Compose Bitmap Images
pixel.c
Go to the documentation of this file.
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % PPPP IIIII X X EEEEE L %
7 % P P I X X E L %
8 % PPPP I X EEE L %
9 % P I X X E L %
10 % P IIIII X X EEEEE LLLLL %
11 % %
12 % MagickCore Methods to Import/Export Pixels %
13 % %
14 % Software Design %
15 % Cristy %
16 % October 1998 %
17 % %
18 % %
19 % Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization %
20 % dedicated to making software imaging solutions freely available. %
21 % %
22 % You may not use this file except in compliance with the License. You may %
23 % obtain a copy of the License at %
24 % %
25 % https://www.imagemagick.org/script/license.php %
26 % %
27 % Unless required by applicable law or agreed to in writing, software %
28 % distributed under the License is distributed on an "AS IS" BASIS, %
29 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
30 % See the License for the specific language governing permissions and %
31 % limitations under the License. %
32 % %
33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
34 %
35 %
36 */
37 
38 /*
39  Include declarations.
40 */
41 #include "MagickCore/studio.h"
42 #include "MagickCore/property.h"
43 #include "MagickCore/blob.h"
48 #include "MagickCore/draw.h"
49 #include "MagickCore/exception.h"
51 #include "MagickCore/cache.h"
52 #include "MagickCore/constitute.h"
53 #include "MagickCore/delegate.h"
54 #include "MagickCore/geometry.h"
56 #include "MagickCore/list.h"
57 #include "MagickCore/magick.h"
58 #include "MagickCore/memory_.h"
60 #include "MagickCore/monitor.h"
61 #include "MagickCore/option.h"
62 #include "MagickCore/pixel.h"
65 #include "MagickCore/quantum.h"
67 #include "MagickCore/resource_.h"
68 #include "MagickCore/semaphore.h"
69 #include "MagickCore/statistic.h"
70 #include "MagickCore/stream.h"
71 #include "MagickCore/string_.h"
72 #include "MagickCore/transform.h"
73 #include "MagickCore/utility.h"
74 
75 /*
76 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
77 % %
78 % %
79 % %
80 + A c q u i r e P i x e l C h a n n e l M a p %
81 % %
82 % %
83 % %
84 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
85 %
86 % AcquirePixelChannelMap() acquires a pixel component map.
87 %
88 % The format of the AcquirePixelChannelMap() method is:
89 %
90 % PixelChannelMap *AcquirePixelChannelMap(void)
91 %
92 */
94 {
96  *channel_map;
97 
98  register ssize_t
99  i;
100 
102  sizeof(*channel_map));
103  if (channel_map == (PixelChannelMap *) NULL)
104  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
105  (void) memset(channel_map,0,MaxPixelChannels*sizeof(*channel_map));
106  for (i=0; i < MaxPixelChannels; i++)
107  channel_map[i].channel=(PixelChannel) i;
108  return(channel_map);
109 }
110 
111 /*
112 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
113 % %
114 % %
115 % %
116 + C l o n e P i x e l C h a n n e l M a p %
117 % %
118 % %
119 % %
120 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
121 %
122 % ClonePixelChannelMap() clones a pixel component map.
123 %
124 % The format of the ClonePixelChannelMap() method is:
125 %
126 % PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
127 %
128 % A description of each parameter follows:
129 %
130 % o channel_map: the pixel component map.
131 %
132 */
134 {
136  *clone_map;
137 
138  assert(channel_map != (PixelChannelMap *) NULL);
139  clone_map=AcquirePixelChannelMap();
140  if (clone_map == (PixelChannelMap *) NULL)
141  return((PixelChannelMap *) NULL);
142  (void) memcpy(clone_map,channel_map,MaxPixelChannels*
143  sizeof(*channel_map));
144  return(clone_map);
145 }
146 
147 /*
148 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
149 % %
150 % %
151 % %
152 + C l o n e P i x e l I n f o %
153 % %
154 % %
155 % %
156 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
157 %
158 % ClonePixelInfo() makes a duplicate of the given pixel info structure, or if
159 % pixel info is NULL, a new one.
160 %
161 % The format of the ClonePixelInfo method is:
162 %
163 % PixelInfo *ClonePixelInfo(const PixelInfo *pixel)
164 %
165 % A description of each parameter follows:
166 %
167 % o pixel: the pixel info.
168 %
169 */
171 {
172  PixelInfo
173  *pixel_info;
174 
175  pixel_info=(PixelInfo *) AcquireQuantumMemory(1,sizeof(*pixel_info));
176  if (pixel_info == (PixelInfo *) NULL)
177  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
178  *pixel_info=(*pixel);
179  return(pixel_info);
180 }
181 
182 /*
183 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
184 % %
185 % %
186 % %
187 + C o n f o r m P i x e l I n f o %
188 % %
189 % %
190 % %
191 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
192 %
193 % ConformPixelInfo() ensures the pixel conforms with the colorspace and alpha
194 % attribute of the image.
195 %
196 % The format of the ConformPixelInfo method is:
197 %
198 % void *ConformPixelInfo((Image *image,const PixelInfo *source,
199 % PixelInfo *destination,ExceptionInfo *exception)
200 %
201 % A description of each parameter follows:
202 %
203 % o image: the image.
204 %
205 % o source: the source pixel info.
206 %
207 % o destination: the destination pixel info.
208 %
209 % o exception: return any errors or warnings in this structure.
210 %
211 */
212 MagickExport void ConformPixelInfo(Image *image,const PixelInfo *source,
213  PixelInfo *destination,ExceptionInfo *exception)
214 {
215  assert(image != (Image *) NULL);
216  assert(image->signature == MagickCoreSignature);
217  assert(destination != (const PixelInfo *) NULL);
218  *destination=(*source);
219  if (image->colorspace == CMYKColorspace)
220  {
221  if (IssRGBCompatibleColorspace(destination->colorspace))
222  ConvertRGBToCMYK(destination);
223  }
224  else
225  if (destination->colorspace == CMYKColorspace)
226  {
228  ConvertCMYKToRGB(destination);
229  }
230  if ((IsPixelInfoGray(&image->background_color) == MagickFalse) &&
232  (void) TransformImageColorspace(image,sRGBColorspace,exception);
233  if ((destination->alpha_trait != UndefinedPixelTrait) &&
234  (image->alpha_trait == UndefinedPixelTrait))
235  (void) SetImageAlpha(image,OpaqueAlpha,exception);
236 }
237 
238 /*
239 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
240 % %
241 % %
242 % %
243 % D e c o d e P i x e l G a m m a %
244 % %
245 % %
246 % %
247 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
248 %
249 % DecodePixelGamma() applies the expansive power-law nonlinearity to the pixel.
250 %
251 % The format of the DecodePixelGamma method is:
252 %
253 % double DecodePixelGamma(const MagickRealType pixel)
254 %
255 % A description of each parameter follows:
256 %
257 % o pixel: the pixel.
258 %
259 */
260 
261 static inline double DecodeGamma(const double x)
262 {
263  div_t
264  quotient;
265 
266  double
267  p,
268  term[9];
269 
270  int
271  exponent;
272 
273  static const double coefficient[] = /* terms for x^(7/5), x=1.5 */
274  {
275  1.7917488588043277509,
276  0.82045614371976854984,
277  0.027694100686325412819,
278  -0.00094244335181762134018,
279  0.000064355540911469709545,
280  -5.7224404636060757485e-06,
281  5.8767669437311184313e-07,
282  -6.6139920053589721168e-08,
283  7.9323242696227458163e-09
284  };
285 
286  static const double powers_of_two[] = /* (2^x)^(7/5) */
287  {
288  1.0,
289  2.6390158215457883983,
290  6.9644045063689921093,
291  1.8379173679952558018e+01,
292  4.8502930128332728543e+01
293  };
294 
295  /*
296  Compute x^2.4 == x*x^(7/5) == pow(x,2.4).
297  */
298  term[0]=1.0;
299  term[1]=4.0*frexp(x,&exponent)-3.0;
300  term[2]=2.0*term[1]*term[1]-term[0];
301  term[3]=2.0*term[1]*term[2]-term[1];
302  term[4]=2.0*term[1]*term[3]-term[2];
303  term[5]=2.0*term[1]*term[4]-term[3];
304  term[6]=2.0*term[1]*term[5]-term[4];
305  term[7]=2.0*term[1]*term[6]-term[5];
306  term[8]=2.0*term[1]*term[7]-term[6];
307  p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
308  coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
309  coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
310  quotient=div(exponent-1,5);
311  if (quotient.rem < 0)
312  {
313  quotient.quot-=1;
314  quotient.rem+=5;
315  }
316  return(x*ldexp(powers_of_two[quotient.rem]*p,7*quotient.quot));
317 }
318 
320 {
321  if (pixel <= (0.0404482362771076*QuantumRange))
322  return(pixel/12.92f);
324  pixel+0.055)/1.055)));
325 }
326 
327 /*
328 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
329 % %
330 % %
331 % %
332 + D e s t r o y P i x e l C h a n n e l M a p %
333 % %
334 % %
335 % %
336 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
337 %
338 % DestroyPixelChannelMap() deallocates memory associated with the pixel
339 % channel map.
340 %
341 % The format of the DestroyPixelChannelMap() method is:
342 %
343 % PixelChannelMap *DestroyPixelChannelMap(PixelChannelMap *channel_map)
344 %
345 % A description of each parameter follows:
346 %
347 % o channel_map: the pixel component map.
348 %
349 */
351  PixelChannelMap *channel_map)
352 {
353  assert(channel_map != (PixelChannelMap *) NULL);
354  channel_map=(PixelChannelMap *) RelinquishMagickMemory(channel_map);
355  return((PixelChannelMap *) RelinquishMagickMemory(channel_map));
356 }
357 
358 /*
359 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
360 % %
361 % %
362 % %
363 + E n c o d e P i x e l G a m m a %
364 % %
365 % %
366 % %
367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
368 %
369 % EncodePixelGamma() cancels any nonlinearity in the pixel.
370 %
371 % The format of the EncodePixelGamma method is:
372 %
373 % MagickRealType EncodePixelGamma(const double MagickRealType)
374 %
375 % A description of each parameter follows:
376 %
377 % o pixel: the pixel.
378 %
379 */
380 
381 static inline double EncodeGamma(const double x)
382 {
383  div_t
384  quotient;
385 
386  double
387  p,
388  term[9];
389 
390  int
391  exponent;
392 
393  static const double coefficient[] = /* Chebychevi poly: x^(5/12), x=1.5 */
394  {
395  1.1758200232996901923,
396  0.16665763094889061230,
397  -0.0083154894939042125035,
398  0.00075187976780420279038,
399  -0.000083240178519391795367,
400  0.000010229209410070008679,
401  -1.3400466409860246e-06,
402  1.8333422241635376682e-07,
403  -2.5878596761348859722e-08
404  };
405 
406  static const double powers_of_two[] = /* (2^N)^(5/12) */
407  {
408  1.0,
409  1.3348398541700343678,
410  1.7817974362806785482,
411  2.3784142300054420538,
412  3.1748021039363991669,
413  4.2378523774371812394,
414  5.6568542494923805819,
415  7.5509945014535482244,
416  1.0079368399158985525e1,
417  1.3454342644059433809e1,
418  1.7959392772949968275e1,
419  2.3972913230026907883e1
420  };
421 
422  /*
423  Compute x^(1/2.4) == x^(5/12) == pow(x,1.0/2.4).
424  */
425  term[0]=1.0;
426  term[1]=4.0*frexp(x,&exponent)-3.0;
427  term[2]=2.0*term[1]*term[1]-term[0];
428  term[3]=2.0*term[1]*term[2]-term[1];
429  term[4]=2.0*term[1]*term[3]-term[2];
430  term[5]=2.0*term[1]*term[4]-term[3];
431  term[6]=2.0*term[1]*term[5]-term[4];
432  term[7]=2.0*term[1]*term[6]-term[5];
433  term[8]=2.0*term[1]*term[7]-term[6];
434  p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
435  coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
436  coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
437  quotient=div(exponent-1,12);
438  if (quotient.rem < 0)
439  {
440  quotient.quot-=1;
441  quotient.rem+=12;
442  }
443  return(ldexp(powers_of_two[quotient.rem]*p,5*quotient.quot));
444 }
445 
447 {
448  if (pixel <= (0.0031306684425005883*QuantumRange))
449  return(12.92f*pixel);
450  return((MagickRealType) QuantumRange*(1.055*EncodeGamma((double) QuantumScale*
451  pixel)-0.055));
452 }
453 
454 /*
455 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
456 % %
457 % %
458 % %
459 % E x p o r t I m a g e P i x e l s %
460 % %
461 % %
462 % %
463 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
464 %
465 % ExportImagePixels() extracts pixel data from an image and returns it to you.
466 % The method returns MagickTrue on success otherwise MagickFalse if an error is
467 % encountered. The data is returned as char, short int, Quantum, unsigned int,
468 % unsigned long long, float, or double in the order specified by map.
469 %
470 % Suppose you want to extract the first scanline of a 640x480 image as
471 % character data in red-green-blue order:
472 %
473 % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
474 %
475 % The format of the ExportImagePixels method is:
476 %
477 % MagickBooleanType ExportImagePixels(const Image *image,const ssize_t x,
478 % const ssize_t y,const size_t width,const size_t height,
479 % const char *map,const StorageType type,void *pixels,
480 % ExceptionInfo *exception)
481 %
482 % A description of each parameter follows:
483 %
484 % o image: the image.
485 %
486 % o x,y,width,height: These values define the perimeter
487 % of a region of pixels you want to extract.
488 %
489 % o map: This string reflects the expected ordering of the pixel array.
490 % It can be any combination or order of R = red, G = green, B = blue,
491 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
492 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
493 % P = pad.
494 %
495 % o type: Define the data type of the pixels. Float and double types are
496 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
497 % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *),
498 % LongPixel (unsigned int *), LongLongPixel (unsigned long long *),
499 % QuantumPixel (Quantum *), or ShortPixel (unsigned short *).
500 %
501 % o pixels: This array of values contain the pixel components as defined by
502 % map and type. You must preallocate this array where the expected
503 % length varies depending on the values of width, height, map, and type.
504 %
505 % o exception: return any errors or warnings in this structure.
506 %
507 */
508 
510  const RectangleInfo *roi,const char *magick_restrict map,
511  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
512 {
513  register const Quantum
514  *magick_restrict p;
515 
516  register ssize_t
517  x;
518 
519  register unsigned char
520  *magick_restrict q;
521 
522  size_t
523  length;
524 
525  ssize_t
526  y;
527 
528  q=(unsigned char *) pixels;
529  if (LocaleCompare(map,"BGR") == 0)
530  {
531  for (y=0; y < (ssize_t) roi->height; y++)
532  {
533  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
534  if (p == (const Quantum *) NULL)
535  break;
536  for (x=0; x < (ssize_t) roi->width; x++)
537  {
538  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
539  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
540  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
541  p+=GetPixelChannels(image);
542  }
543  }
544  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
545  }
546  if (LocaleCompare(map,"BGRA") == 0)
547  {
548  for (y=0; y < (ssize_t) roi->height; y++)
549  {
550  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
551  if (p == (const Quantum *) NULL)
552  break;
553  for (x=0; x < (ssize_t) roi->width; x++)
554  {
555  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
556  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
557  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
558  *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
559  p+=GetPixelChannels(image);
560  }
561  }
562  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
563  }
564  if (LocaleCompare(map,"BGRP") == 0)
565  {
566  for (y=0; y < (ssize_t) roi->height; y++)
567  {
568  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
569  if (p == (const Quantum *) NULL)
570  break;
571  for (x=0; x < (ssize_t) roi->width; x++)
572  {
573  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
574  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
575  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
576  *q++=ScaleQuantumToChar((Quantum) 0);
577  p+=GetPixelChannels(image);
578  }
579  }
580  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
581  }
582  if (LocaleCompare(map,"I") == 0)
583  {
584  for (y=0; y < (ssize_t) roi->height; y++)
585  {
586  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
587  if (p == (const Quantum *) NULL)
588  break;
589  for (x=0; x < (ssize_t) roi->width; x++)
590  {
591  *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
592  p+=GetPixelChannels(image);
593  }
594  }
595  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
596  }
597  if (LocaleCompare(map,"RGB") == 0)
598  {
599  for (y=0; y < (ssize_t) roi->height; y++)
600  {
601  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
602  if (p == (const Quantum *) NULL)
603  break;
604  for (x=0; x < (ssize_t) roi->width; x++)
605  {
606  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
607  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
608  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
609  p+=GetPixelChannels(image);
610  }
611  }
612  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
613  }
614  if (LocaleCompare(map,"RGBA") == 0)
615  {
616  for (y=0; y < (ssize_t) roi->height; y++)
617  {
618  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
619  if (p == (const Quantum *) NULL)
620  break;
621  for (x=0; x < (ssize_t) roi->width; x++)
622  {
623  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
624  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
625  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
626  *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
627  p+=GetPixelChannels(image);
628  }
629  }
630  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
631  }
632  if (LocaleCompare(map,"RGBP") == 0)
633  {
634  for (y=0; y < (ssize_t) roi->height; y++)
635  {
636  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
637  if (p == (const Quantum *) NULL)
638  break;
639  for (x=0; x < (ssize_t) roi->width; x++)
640  {
641  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
642  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
643  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
644  *q++=ScaleQuantumToChar((Quantum) 0);
645  p+=GetPixelChannels(image);
646  }
647  }
648  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
649  }
650  length=strlen(map);
651  for (y=0; y < (ssize_t) roi->height; y++)
652  {
653  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
654  if (p == (const Quantum *) NULL)
655  break;
656  for (x=0; x < (ssize_t) roi->width; x++)
657  {
658  register ssize_t
659  i;
660 
661  for (i=0; i < (ssize_t) length; i++)
662  {
663  *q=0;
664  switch (quantum_map[i])
665  {
666  case RedQuantum:
667  case CyanQuantum:
668  {
669  *q=ScaleQuantumToChar(GetPixelRed(image,p));
670  break;
671  }
672  case GreenQuantum:
673  case MagentaQuantum:
674  {
675  *q=ScaleQuantumToChar(GetPixelGreen(image,p));
676  break;
677  }
678  case BlueQuantum:
679  case YellowQuantum:
680  {
681  *q=ScaleQuantumToChar(GetPixelBlue(image,p));
682  break;
683  }
684  case AlphaQuantum:
685  {
686  *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
687  break;
688  }
689  case OpacityQuantum:
690  {
691  *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
692  break;
693  }
694  case BlackQuantum:
695  {
696  if (image->colorspace == CMYKColorspace)
697  *q=ScaleQuantumToChar(GetPixelBlack(image,p));
698  break;
699  }
700  case IndexQuantum:
701  {
702  *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
703  break;
704  }
705  default:
706  break;
707  }
708  q++;
709  }
710  p+=GetPixelChannels(image);
711  }
712  }
713  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
714 }
715 
717  const RectangleInfo *roi,const char *magick_restrict map,
718  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
719 {
720  register const Quantum
721  *magick_restrict p;
722 
723  register double
724  *magick_restrict q;
725 
726  register ssize_t
727  x;
728 
729  size_t
730  length;
731 
732  ssize_t
733  y;
734 
735  q=(double *) pixels;
736  if (LocaleCompare(map,"BGR") == 0)
737  {
738  for (y=0; y < (ssize_t) roi->height; y++)
739  {
740  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
741  if (p == (const Quantum *) NULL)
742  break;
743  for (x=0; x < (ssize_t) roi->width; x++)
744  {
745  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
746  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
747  *q++=(double) (QuantumScale*GetPixelRed(image,p));
748  p+=GetPixelChannels(image);
749  }
750  }
751  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
752  }
753  if (LocaleCompare(map,"BGRA") == 0)
754  {
755  for (y=0; y < (ssize_t) roi->height; y++)
756  {
757  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
758  if (p == (const Quantum *) NULL)
759  break;
760  for (x=0; x < (ssize_t) roi->width; x++)
761  {
762  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
763  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
764  *q++=(double) (QuantumScale*GetPixelRed(image,p));
765  *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
766  p+=GetPixelChannels(image);
767  }
768  }
769  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
770  }
771  if (LocaleCompare(map,"BGRP") == 0)
772  {
773  for (y=0; y < (ssize_t) roi->height; y++)
774  {
775  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
776  if (p == (const Quantum *) NULL)
777  break;
778  for (x=0; x < (ssize_t) roi->width; x++)
779  {
780  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
781  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
782  *q++=(double) (QuantumScale*GetPixelRed(image,p));
783  *q++=0.0;
784  p+=GetPixelChannels(image);
785  }
786  }
787  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
788  }
789  if (LocaleCompare(map,"I") == 0)
790  {
791  for (y=0; y < (ssize_t) roi->height; y++)
792  {
793  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
794  if (p == (const Quantum *) NULL)
795  break;
796  for (x=0; x < (ssize_t) roi->width; x++)
797  {
798  *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
799  p+=GetPixelChannels(image);
800  }
801  }
802  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
803  }
804  if (LocaleCompare(map,"RGB") == 0)
805  {
806  for (y=0; y < (ssize_t) roi->height; y++)
807  {
808  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
809  if (p == (const Quantum *) NULL)
810  break;
811  for (x=0; x < (ssize_t) roi->width; x++)
812  {
813  *q++=(double) (QuantumScale*GetPixelRed(image,p));
814  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
815  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
816  p+=GetPixelChannels(image);
817  }
818  }
819  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
820  }
821  if (LocaleCompare(map,"RGBA") == 0)
822  {
823  for (y=0; y < (ssize_t) roi->height; y++)
824  {
825  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
826  if (p == (const Quantum *) NULL)
827  break;
828  for (x=0; x < (ssize_t) roi->width; x++)
829  {
830  *q++=(double) (QuantumScale*GetPixelRed(image,p));
831  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
832  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
833  *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
834  p+=GetPixelChannels(image);
835  }
836  }
837  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
838  }
839  if (LocaleCompare(map,"RGBP") == 0)
840  {
841  for (y=0; y < (ssize_t) roi->height; y++)
842  {
843  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
844  if (p == (const Quantum *) NULL)
845  break;
846  for (x=0; x < (ssize_t) roi->width; x++)
847  {
848  *q++=(double) (QuantumScale*GetPixelRed(image,p));
849  *q++=(double) (QuantumScale*GetPixelGreen(image,p));
850  *q++=(double) (QuantumScale*GetPixelBlue(image,p));
851  *q++=0.0;
852  p+=GetPixelChannels(image);
853  }
854  }
855  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
856  }
857  length=strlen(map);
858  for (y=0; y < (ssize_t) roi->height; y++)
859  {
860  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
861  if (p == (const Quantum *) NULL)
862  break;
863  for (x=0; x < (ssize_t) roi->width; x++)
864  {
865  register ssize_t
866  i;
867 
868  for (i=0; i < (ssize_t) length; i++)
869  {
870  *q=0;
871  switch (quantum_map[i])
872  {
873  case RedQuantum:
874  case CyanQuantum:
875  {
876  *q=(double) (QuantumScale*GetPixelRed(image,p));
877  break;
878  }
879  case GreenQuantum:
880  case MagentaQuantum:
881  {
882  *q=(double) (QuantumScale*GetPixelGreen(image,p));
883  break;
884  }
885  case BlueQuantum:
886  case YellowQuantum:
887  {
888  *q=(double) (QuantumScale*GetPixelBlue(image,p));
889  break;
890  }
891  case AlphaQuantum:
892  {
893  *q=(double) (QuantumScale*GetPixelAlpha(image,p));
894  break;
895  }
896  case OpacityQuantum:
897  {
898  *q=(double) (QuantumScale*GetPixelAlpha(image,p));
899  break;
900  }
901  case BlackQuantum:
902  {
903  if (image->colorspace == CMYKColorspace)
904  *q=(double) (QuantumScale*
905  GetPixelBlack(image,p));
906  break;
907  }
908  case IndexQuantum:
909  {
910  *q=(double) (QuantumScale*GetPixelIntensity(image,p));
911  break;
912  }
913  default:
914  *q=0;
915  }
916  q++;
917  }
918  p+=GetPixelChannels(image);
919  }
920  }
921  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
922 }
923 
925  const RectangleInfo *roi,const char *magick_restrict map,
926  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
927 {
928  register const Quantum
929  *magick_restrict p;
930 
931  register float
932  *magick_restrict q;
933 
934  register ssize_t
935  x;
936 
937  size_t
938  length;
939 
940  ssize_t
941  y;
942 
943  q=(float *) pixels;
944  if (LocaleCompare(map,"BGR") == 0)
945  {
946  for (y=0; y < (ssize_t) roi->height; y++)
947  {
948  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
949  if (p == (const Quantum *) NULL)
950  break;
951  for (x=0; x < (ssize_t) roi->width; x++)
952  {
953  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
954  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
955  *q++=(float) (QuantumScale*GetPixelRed(image,p));
956  p+=GetPixelChannels(image);
957  }
958  }
959  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
960  }
961  if (LocaleCompare(map,"BGRA") == 0)
962  {
963  for (y=0; y < (ssize_t) roi->height; y++)
964  {
965  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
966  if (p == (const Quantum *) NULL)
967  break;
968  for (x=0; x < (ssize_t) roi->width; x++)
969  {
970  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
971  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
972  *q++=(float) (QuantumScale*GetPixelRed(image,p));
973  *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
974  p+=GetPixelChannels(image);
975  }
976  }
977  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
978  }
979  if (LocaleCompare(map,"BGRP") == 0)
980  {
981  for (y=0; y < (ssize_t) roi->height; y++)
982  {
983  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
984  if (p == (const Quantum *) NULL)
985  break;
986  for (x=0; x < (ssize_t) roi->width; x++)
987  {
988  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
989  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
990  *q++=(float) (QuantumScale*GetPixelRed(image,p));
991  *q++=0.0;
992  p+=GetPixelChannels(image);
993  }
994  }
995  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
996  }
997  if (LocaleCompare(map,"I") == 0)
998  {
999  for (y=0; y < (ssize_t) roi->height; y++)
1000  {
1001  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1002  if (p == (const Quantum *) NULL)
1003  break;
1004  for (x=0; x < (ssize_t) roi->width; x++)
1005  {
1006  *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
1007  p+=GetPixelChannels(image);
1008  }
1009  }
1010  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1011  }
1012  if (LocaleCompare(map,"RGB") == 0)
1013  {
1014  for (y=0; y < (ssize_t) roi->height; y++)
1015  {
1016  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1017  if (p == (const Quantum *) NULL)
1018  break;
1019  for (x=0; x < (ssize_t) roi->width; x++)
1020  {
1021  *q++=(float) (QuantumScale*GetPixelRed(image,p));
1022  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
1023  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
1024  p+=GetPixelChannels(image);
1025  }
1026  }
1027  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1028  }
1029  if (LocaleCompare(map,"RGBA") == 0)
1030  {
1031  for (y=0; y < (ssize_t) roi->height; y++)
1032  {
1033  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1034  if (p == (const Quantum *) NULL)
1035  break;
1036  for (x=0; x < (ssize_t) roi->width; x++)
1037  {
1038  *q++=(float) (QuantumScale*GetPixelRed(image,p));
1039  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
1040  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
1041  *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
1042  p+=GetPixelChannels(image);
1043  }
1044  }
1045  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1046  }
1047  if (LocaleCompare(map,"RGBP") == 0)
1048  {
1049  for (y=0; y < (ssize_t) roi->height; y++)
1050  {
1051  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1052  if (p == (const Quantum *) NULL)
1053  break;
1054  for (x=0; x < (ssize_t) roi->width; x++)
1055  {
1056  *q++=(float) (QuantumScale*GetPixelRed(image,p));
1057  *q++=(float) (QuantumScale*GetPixelGreen(image,p));
1058  *q++=(float) (QuantumScale*GetPixelBlue(image,p));
1059  *q++=0.0;
1060  p+=GetPixelChannels(image);
1061  }
1062  }
1063  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1064  }
1065  length=strlen(map);
1066  for (y=0; y < (ssize_t) roi->height; y++)
1067  {
1068  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1069  if (p == (const Quantum *) NULL)
1070  break;
1071  for (x=0; x < (ssize_t) roi->width; x++)
1072  {
1073  register ssize_t
1074  i;
1075 
1076  for (i=0; i < (ssize_t) length; i++)
1077  {
1078  *q=0;
1079  switch (quantum_map[i])
1080  {
1081  case RedQuantum:
1082  case CyanQuantum:
1083  {
1084  *q=(float) (QuantumScale*GetPixelRed(image,p));
1085  break;
1086  }
1087  case GreenQuantum:
1088  case MagentaQuantum:
1089  {
1090  *q=(float) (QuantumScale*GetPixelGreen(image,p));
1091  break;
1092  }
1093  case BlueQuantum:
1094  case YellowQuantum:
1095  {
1096  *q=(float) (QuantumScale*GetPixelBlue(image,p));
1097  break;
1098  }
1099  case AlphaQuantum:
1100  {
1101  *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
1102  break;
1103  }
1104  case OpacityQuantum:
1105  {
1106  *q=(float) (QuantumScale*GetPixelAlpha(image,p));
1107  break;
1108  }
1109  case BlackQuantum:
1110  {
1111  if (image->colorspace == CMYKColorspace)
1112  *q=(float) (QuantumScale* GetPixelBlack(image,p));
1113  break;
1114  }
1115  case IndexQuantum:
1116  {
1117  *q=(float) (QuantumScale*GetPixelIntensity(image,p));
1118  break;
1119  }
1120  default:
1121  *q=0;
1122  }
1123  q++;
1124  }
1125  p+=GetPixelChannels(image);
1126  }
1127  }
1128  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1129 }
1130 
1132  const RectangleInfo *roi,const char *magick_restrict map,
1133  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
1134 {
1135  register const Quantum
1136  *magick_restrict p;
1137 
1138  register ssize_t
1139  x;
1140 
1141  register unsigned int
1142  *magick_restrict q;
1143 
1144  size_t
1145  length;
1146 
1147  ssize_t
1148  y;
1149 
1150  q=(unsigned int *) pixels;
1151  if (LocaleCompare(map,"BGR") == 0)
1152  {
1153  for (y=0; y < (ssize_t) roi->height; y++)
1154  {
1155  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1156  if (p == (const Quantum *) NULL)
1157  break;
1158  for (x=0; x < (ssize_t) roi->width; x++)
1159  {
1160  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1161  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1162  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1163  p+=GetPixelChannels(image);
1164  }
1165  }
1166  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1167  }
1168  if (LocaleCompare(map,"BGRA") == 0)
1169  {
1170  for (y=0; y < (ssize_t) roi->height; y++)
1171  {
1172  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1173  if (p == (const Quantum *) NULL)
1174  break;
1175  for (x=0; x < (ssize_t) roi->width; x++)
1176  {
1177  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1178  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1179  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1180  *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1181  p+=GetPixelChannels(image);
1182  }
1183  }
1184  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1185  }
1186  if (LocaleCompare(map,"BGRP") == 0)
1187  {
1188  for (y=0; y < (ssize_t) roi->height; y++)
1189  {
1190  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1191  if (p == (const Quantum *) NULL)
1192  break;
1193  for (x=0; x < (ssize_t) roi->width; x++)
1194  {
1195  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1196  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1197  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1198  *q++=0;
1199  p+=GetPixelChannels(image);
1200  }
1201  }
1202  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1203  }
1204  if (LocaleCompare(map,"I") == 0)
1205  {
1206  for (y=0; y < (ssize_t) roi->height; y++)
1207  {
1208  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1209  if (p == (const Quantum *) NULL)
1210  break;
1211  for (x=0; x < (ssize_t) roi->width; x++)
1212  {
1213  *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
1214  p+=GetPixelChannels(image);
1215  }
1216  }
1217  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1218  }
1219  if (LocaleCompare(map,"RGB") == 0)
1220  {
1221  for (y=0; y < (ssize_t) roi->height; y++)
1222  {
1223  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1224  if (p == (const Quantum *) NULL)
1225  break;
1226  for (x=0; x < (ssize_t) roi->width; x++)
1227  {
1228  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1229  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1230  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1231  p+=GetPixelChannels(image);
1232  }
1233  }
1234  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1235  }
1236  if (LocaleCompare(map,"RGBA") == 0)
1237  {
1238  for (y=0; y < (ssize_t) roi->height; y++)
1239  {
1240  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1241  if (p == (const Quantum *) NULL)
1242  break;
1243  for (x=0; x < (ssize_t) roi->width; x++)
1244  {
1245  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1246  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1247  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1248  *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1249  p+=GetPixelChannels(image);
1250  }
1251  }
1252  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1253  }
1254  if (LocaleCompare(map,"RGBP") == 0)
1255  {
1256  for (y=0; y < (ssize_t) roi->height; y++)
1257  {
1258  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1259  if (p == (const Quantum *) NULL)
1260  break;
1261  for (x=0; x < (ssize_t) roi->width; x++)
1262  {
1263  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1264  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1265  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1266  *q++=0;
1267  p+=GetPixelChannels(image);
1268  }
1269  }
1270  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1271  }
1272  length=strlen(map);
1273  for (y=0; y < (ssize_t) roi->height; y++)
1274  {
1275  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1276  if (p == (const Quantum *) NULL)
1277  break;
1278  for (x=0; x < (ssize_t) roi->width; x++)
1279  {
1280  register ssize_t
1281  i;
1282 
1283  for (i=0; i < (ssize_t) length; i++)
1284  {
1285  *q=0;
1286  switch (quantum_map[i])
1287  {
1288  case RedQuantum:
1289  case CyanQuantum:
1290  {
1291  *q=ScaleQuantumToLong(GetPixelRed(image,p));
1292  break;
1293  }
1294  case GreenQuantum:
1295  case MagentaQuantum:
1296  {
1297  *q=ScaleQuantumToLong(GetPixelGreen(image,p));
1298  break;
1299  }
1300  case BlueQuantum:
1301  case YellowQuantum:
1302  {
1303  *q=ScaleQuantumToLong(GetPixelBlue(image,p));
1304  break;
1305  }
1306  case AlphaQuantum:
1307  {
1308  *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1309  break;
1310  }
1311  case OpacityQuantum:
1312  {
1313  *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1314  break;
1315  }
1316  case BlackQuantum:
1317  {
1318  if (image->colorspace == CMYKColorspace)
1319  *q=ScaleQuantumToLong(GetPixelBlack(image,p));
1320  break;
1321  }
1322  case IndexQuantum:
1323  {
1324  *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
1325  break;
1326  }
1327  default:
1328  break;
1329  }
1330  q++;
1331  }
1332  p+=GetPixelChannels(image);
1333  }
1334  }
1335  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1336 }
1337 
1339  const RectangleInfo *roi,const char *magick_restrict map,
1340  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
1341 {
1342  register const Quantum
1343  *magick_restrict p;
1344 
1345  register ssize_t
1346  x;
1347 
1348  register MagickSizeType
1349  *magick_restrict q;
1350 
1351  size_t
1352  length;
1353 
1354  ssize_t
1355  y;
1356 
1357  q=(MagickSizeType *) pixels;
1358  if (LocaleCompare(map,"BGR") == 0)
1359  {
1360  for (y=0; y < (ssize_t) roi->height; y++)
1361  {
1362  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1363  if (p == (const Quantum *) NULL)
1364  break;
1365  for (x=0; x < (ssize_t) roi->width; x++)
1366  {
1367  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1368  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1369  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1370  p+=GetPixelChannels(image);
1371  }
1372  }
1373  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1374  }
1375  if (LocaleCompare(map,"BGRA") == 0)
1376  {
1377  for (y=0; y < (ssize_t) roi->height; y++)
1378  {
1379  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1380  if (p == (const Quantum *) NULL)
1381  break;
1382  for (x=0; x < (ssize_t) roi->width; x++)
1383  {
1384  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1385  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1386  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1387  *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1388  p+=GetPixelChannels(image);
1389  }
1390  }
1391  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1392  }
1393  if (LocaleCompare(map,"BGRP") == 0)
1394  {
1395  for (y=0; y < (ssize_t) roi->height; y++)
1396  {
1397  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1398  if (p == (const Quantum *) NULL)
1399  break;
1400  for (x=0; x < (ssize_t) roi->width; x++)
1401  {
1402  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1403  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1404  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1405  *q++=0;
1406  p+=GetPixelChannels(image);
1407  }
1408  }
1409  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1410  }
1411  if (LocaleCompare(map,"I") == 0)
1412  {
1413  for (y=0; y < (ssize_t) roi->height; y++)
1414  {
1415  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1416  if (p == (const Quantum *) NULL)
1417  break;
1418  for (x=0; x < (ssize_t) roi->width; x++)
1419  {
1420  *q++=ScaleQuantumToLongLong(ClampToQuantum(
1421  GetPixelIntensity(image,p)));
1422  p+=GetPixelChannels(image);
1423  }
1424  }
1425  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1426  }
1427  if (LocaleCompare(map,"RGB") == 0)
1428  {
1429  for (y=0; y < (ssize_t) roi->height; y++)
1430  {
1431  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1432  if (p == (const Quantum *) NULL)
1433  break;
1434  for (x=0; x < (ssize_t) roi->width; x++)
1435  {
1436  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1437  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1438  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1439  p+=GetPixelChannels(image);
1440  }
1441  }
1442  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1443  }
1444  if (LocaleCompare(map,"RGBA") == 0)
1445  {
1446  for (y=0; y < (ssize_t) roi->height; y++)
1447  {
1448  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1449  if (p == (const Quantum *) NULL)
1450  break;
1451  for (x=0; x < (ssize_t) roi->width; x++)
1452  {
1453  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1454  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1455  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1456  *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1457  p+=GetPixelChannels(image);
1458  }
1459  }
1460  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1461  }
1462  if (LocaleCompare(map,"RGBP") == 0)
1463  {
1464  for (y=0; y < (ssize_t) roi->height; y++)
1465  {
1466  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1467  if (p == (const Quantum *) NULL)
1468  break;
1469  for (x=0; x < (ssize_t) roi->width; x++)
1470  {
1471  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1472  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1473  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1474  *q++=0;
1475  p+=GetPixelChannels(image);
1476  }
1477  }
1478  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1479  }
1480  length=strlen(map);
1481  for (y=0; y < (ssize_t) roi->height; y++)
1482  {
1483  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1484  if (p == (const Quantum *) NULL)
1485  break;
1486  for (x=0; x < (ssize_t) roi->width; x++)
1487  {
1488  register ssize_t
1489  i;
1490 
1491  for (i=0; i < (ssize_t) length; i++)
1492  {
1493  *q=0;
1494  switch (quantum_map[i])
1495  {
1496  case RedQuantum:
1497  case CyanQuantum:
1498  {
1499  *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
1500  break;
1501  }
1502  case GreenQuantum:
1503  case MagentaQuantum:
1504  {
1505  *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1506  break;
1507  }
1508  case BlueQuantum:
1509  case YellowQuantum:
1510  {
1511  *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1512  break;
1513  }
1514  case AlphaQuantum:
1515  {
1516  *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1517  break;
1518  }
1519  case OpacityQuantum:
1520  {
1521  *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1522  break;
1523  }
1524  case BlackQuantum:
1525  {
1526  if (image->colorspace == CMYKColorspace)
1527  *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
1528  break;
1529  }
1530  case IndexQuantum:
1531  {
1532  *q=ScaleQuantumToLongLong(ClampToQuantum(
1533  GetPixelIntensity(image,p)));
1534  break;
1535  }
1536  default:
1537  break;
1538  }
1539  q++;
1540  }
1541  p+=GetPixelChannels(image);
1542  }
1543  }
1544  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1545 }
1546 
1548  const RectangleInfo *roi,const char *magick_restrict map,
1549  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
1550 {
1551  register const Quantum
1552  *magick_restrict p;
1553 
1554  register Quantum
1555  *magick_restrict q;
1556 
1557  register ssize_t
1558  x;
1559 
1560  size_t
1561  length;
1562 
1563  ssize_t
1564  y;
1565 
1566  q=(Quantum *) pixels;
1567  if (LocaleCompare(map,"BGR") == 0)
1568  {
1569  for (y=0; y < (ssize_t) roi->height; y++)
1570  {
1571  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1572  if (p == (const Quantum *) NULL)
1573  break;
1574  for (x=0; x < (ssize_t) roi->width; x++)
1575  {
1576  *q++=GetPixelBlue(image,p);
1577  *q++=GetPixelGreen(image,p);
1578  *q++=GetPixelRed(image,p);
1579  p+=GetPixelChannels(image);
1580  }
1581  }
1582  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1583  }
1584  if (LocaleCompare(map,"BGRA") == 0)
1585  {
1586  for (y=0; y < (ssize_t) roi->height; y++)
1587  {
1588  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1589  if (p == (const Quantum *) NULL)
1590  break;
1591  for (x=0; x < (ssize_t) roi->width; x++)
1592  {
1593  *q++=GetPixelBlue(image,p);
1594  *q++=GetPixelGreen(image,p);
1595  *q++=GetPixelRed(image,p);
1596  *q++=(Quantum) (GetPixelAlpha(image,p));
1597  p+=GetPixelChannels(image);
1598  }
1599  }
1600  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1601  }
1602  if (LocaleCompare(map,"BGRP") == 0)
1603  {
1604  for (y=0; y < (ssize_t) roi->height; y++)
1605  {
1606  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1607  if (p == (const Quantum *) NULL)
1608  break;
1609  for (x=0; x < (ssize_t) roi->width; x++)
1610  {
1611  *q++=GetPixelBlue(image,p);
1612  *q++=GetPixelGreen(image,p);
1613  *q++=GetPixelRed(image,p);
1614  *q++=(Quantum) 0;
1615  p+=GetPixelChannels(image);
1616  }
1617  }
1618  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1619  }
1620  if (LocaleCompare(map,"I") == 0)
1621  {
1622  for (y=0; y < (ssize_t) roi->height; y++)
1623  {
1624  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1625  if (p == (const Quantum *) NULL)
1626  break;
1627  for (x=0; x < (ssize_t) roi->width; x++)
1628  {
1629  *q++=ClampToQuantum(GetPixelIntensity(image,p));
1630  p+=GetPixelChannels(image);
1631  }
1632  }
1633  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1634  }
1635  if (LocaleCompare(map,"RGB") == 0)
1636  {
1637  for (y=0; y < (ssize_t) roi->height; y++)
1638  {
1639  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1640  if (p == (const Quantum *) NULL)
1641  break;
1642  for (x=0; x < (ssize_t) roi->width; x++)
1643  {
1644  *q++=GetPixelRed(image,p);
1645  *q++=GetPixelGreen(image,p);
1646  *q++=GetPixelBlue(image,p);
1647  p+=GetPixelChannels(image);
1648  }
1649  }
1650  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1651  }
1652  if (LocaleCompare(map,"RGBA") == 0)
1653  {
1654  for (y=0; y < (ssize_t) roi->height; y++)
1655  {
1656  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1657  if (p == (const Quantum *) NULL)
1658  break;
1659  for (x=0; x < (ssize_t) roi->width; x++)
1660  {
1661  *q++=GetPixelRed(image,p);
1662  *q++=GetPixelGreen(image,p);
1663  *q++=GetPixelBlue(image,p);
1664  *q++=(Quantum) (GetPixelAlpha(image,p));
1665  p+=GetPixelChannels(image);
1666  }
1667  }
1668  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1669  }
1670  if (LocaleCompare(map,"RGBP") == 0)
1671  {
1672  for (y=0; y < (ssize_t) roi->height; y++)
1673  {
1674  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1675  if (p == (const Quantum *) NULL)
1676  break;
1677  for (x=0; x < (ssize_t) roi->width; x++)
1678  {
1679  *q++=GetPixelRed(image,p);
1680  *q++=GetPixelGreen(image,p);
1681  *q++=GetPixelBlue(image,p);
1682  *q++=(Quantum) 0;
1683  p+=GetPixelChannels(image);
1684  }
1685  }
1686  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1687  }
1688  length=strlen(map);
1689  for (y=0; y < (ssize_t) roi->height; y++)
1690  {
1691  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1692  if (p == (const Quantum *) NULL)
1693  break;
1694  for (x=0; x < (ssize_t) roi->width; x++)
1695  {
1696  register ssize_t
1697  i;
1698 
1699  for (i=0; i < (ssize_t) length; i++)
1700  {
1701  *q=(Quantum) 0;
1702  switch (quantum_map[i])
1703  {
1704  case RedQuantum:
1705  case CyanQuantum:
1706  {
1707  *q=GetPixelRed(image,p);
1708  break;
1709  }
1710  case GreenQuantum:
1711  case MagentaQuantum:
1712  {
1713  *q=GetPixelGreen(image,p);
1714  break;
1715  }
1716  case BlueQuantum:
1717  case YellowQuantum:
1718  {
1719  *q=GetPixelBlue(image,p);
1720  break;
1721  }
1722  case AlphaQuantum:
1723  {
1724  *q=GetPixelAlpha(image,p);
1725  break;
1726  }
1727  case OpacityQuantum:
1728  {
1729  *q=GetPixelAlpha(image,p);
1730  break;
1731  }
1732  case BlackQuantum:
1733  {
1734  if (image->colorspace == CMYKColorspace)
1735  *q=GetPixelBlack(image,p);
1736  break;
1737  }
1738  case IndexQuantum:
1739  {
1740  *q=ClampToQuantum(GetPixelIntensity(image,p));
1741  break;
1742  }
1743  default:
1744  {
1745  *q=(Quantum) 0;
1746  break;
1747  }
1748  }
1749  q++;
1750  }
1751  p+=GetPixelChannels(image);
1752  }
1753  }
1754  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1755 }
1756 
1758  const RectangleInfo *roi,const char *magick_restrict map,
1759  const QuantumType *quantum_map,void *pixels,ExceptionInfo *exception)
1760 {
1761  register const Quantum
1762  *magick_restrict p;
1763 
1764  register ssize_t
1765  x;
1766 
1767  register unsigned short
1768  *magick_restrict q;
1769 
1770  size_t
1771  length;
1772 
1773  ssize_t
1774  y;
1775 
1776  q=(unsigned short *) pixels;
1777  if (LocaleCompare(map,"BGR") == 0)
1778  {
1779  for (y=0; y < (ssize_t) roi->height; y++)
1780  {
1781  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1782  if (p == (const Quantum *) NULL)
1783  break;
1784  for (x=0; x < (ssize_t) roi->width; x++)
1785  {
1786  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1787  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1788  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1789  p+=GetPixelChannels(image);
1790  }
1791  }
1792  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1793  }
1794  if (LocaleCompare(map,"BGRA") == 0)
1795  {
1796  for (y=0; y < (ssize_t) roi->height; y++)
1797  {
1798  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1799  if (p == (const Quantum *) NULL)
1800  break;
1801  for (x=0; x < (ssize_t) roi->width; x++)
1802  {
1803  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1804  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1805  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1806  *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1807  p+=GetPixelChannels(image);
1808  }
1809  }
1810  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1811  }
1812  if (LocaleCompare(map,"BGRP") == 0)
1813  {
1814  for (y=0; y < (ssize_t) roi->height; y++)
1815  {
1816  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1817  if (p == (const Quantum *) NULL)
1818  break;
1819  for (x=0; x < (ssize_t) roi->width; x++)
1820  {
1821  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1822  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1823  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1824  *q++=0;
1825  p+=GetPixelChannels(image);
1826  }
1827  }
1828  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1829  }
1830  if (LocaleCompare(map,"I") == 0)
1831  {
1832  for (y=0; y < (ssize_t) roi->height; y++)
1833  {
1834  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1835  if (p == (const Quantum *) NULL)
1836  break;
1837  for (x=0; x < (ssize_t) roi->width; x++)
1838  {
1839  *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
1840  p+=GetPixelChannels(image);
1841  }
1842  }
1843  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1844  }
1845  if (LocaleCompare(map,"RGB") == 0)
1846  {
1847  for (y=0; y < (ssize_t) roi->height; y++)
1848  {
1849  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1850  if (p == (const Quantum *) NULL)
1851  break;
1852  for (x=0; x < (ssize_t) roi->width; x++)
1853  {
1854  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1855  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1856  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1857  p+=GetPixelChannels(image);
1858  }
1859  }
1860  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1861  }
1862  if (LocaleCompare(map,"RGBA") == 0)
1863  {
1864  for (y=0; y < (ssize_t) roi->height; y++)
1865  {
1866  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1867  if (p == (const Quantum *) NULL)
1868  break;
1869  for (x=0; x < (ssize_t) roi->width; x++)
1870  {
1871  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1872  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1873  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1874  *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1875  p+=GetPixelChannels(image);
1876  }
1877  }
1878  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1879  }
1880  if (LocaleCompare(map,"RGBP") == 0)
1881  {
1882  for (y=0; y < (ssize_t) roi->height; y++)
1883  {
1884  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1885  if (p == (const Quantum *) NULL)
1886  break;
1887  for (x=0; x < (ssize_t) roi->width; x++)
1888  {
1889  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1890  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1891  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1892  *q++=0;
1893  p+=GetPixelChannels(image);
1894  }
1895  }
1896  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1897  }
1898  length=strlen(map);
1899  for (y=0; y < (ssize_t) roi->height; y++)
1900  {
1901  p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1902  if (p == (const Quantum *) NULL)
1903  break;
1904  for (x=0; x < (ssize_t) roi->width; x++)
1905  {
1906  register ssize_t
1907  i;
1908 
1909  for (i=0; i < (ssize_t) length; i++)
1910  {
1911  *q=0;
1912  switch (quantum_map[i])
1913  {
1914  case RedQuantum:
1915  case CyanQuantum:
1916  {
1917  *q=ScaleQuantumToShort(GetPixelRed(image,p));
1918  break;
1919  }
1920  case GreenQuantum:
1921  case MagentaQuantum:
1922  {
1923  *q=ScaleQuantumToShort(GetPixelGreen(image,p));
1924  break;
1925  }
1926  case BlueQuantum:
1927  case YellowQuantum:
1928  {
1929  *q=ScaleQuantumToShort(GetPixelBlue(image,p));
1930  break;
1931  }
1932  case AlphaQuantum:
1933  {
1934  *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1935  break;
1936  }
1937  case OpacityQuantum:
1938  {
1939  *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1940  break;
1941  }
1942  case BlackQuantum:
1943  {
1944  if (image->colorspace == CMYKColorspace)
1945  *q=ScaleQuantumToShort(GetPixelBlack(image,p));
1946  break;
1947  }
1948  case IndexQuantum:
1949  {
1950  *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
1951  break;
1952  }
1953  default:
1954  break;
1955  }
1956  q++;
1957  }
1958  p+=GetPixelChannels(image);
1959  }
1960  }
1961  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1962 }
1963 
1965  const ssize_t x,const ssize_t y,const size_t width,const size_t height,
1966  const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
1967 {
1969  status;
1970 
1971  QuantumType
1972  *quantum_map;
1973 
1975  roi;
1976 
1977  register ssize_t
1978  i;
1979 
1980  size_t
1981  length;
1982 
1983  assert(image != (Image *) NULL);
1984  assert(image->signature == MagickCoreSignature);
1985  if (image->debug != MagickFalse)
1986  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1987  length=strlen(map);
1988  quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1989  if (quantum_map == (QuantumType *) NULL)
1990  {
1991  (void) ThrowMagickException(exception,GetMagickModule(),
1992  ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
1993  return(MagickFalse);
1994  }
1995  for (i=0; i < (ssize_t) length; i++)
1996  {
1997  switch (map[i])
1998  {
1999  case 'A':
2000  case 'a':
2001  {
2002  quantum_map[i]=AlphaQuantum;
2003  break;
2004  }
2005  case 'B':
2006  case 'b':
2007  {
2008  quantum_map[i]=BlueQuantum;
2009  break;
2010  }
2011  case 'C':
2012  case 'c':
2013  {
2014  quantum_map[i]=CyanQuantum;
2015  if (image->colorspace == CMYKColorspace)
2016  break;
2017  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2018  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2019  "ColorSeparatedImageRequired","`%s'",map);
2020  return(MagickFalse);
2021  }
2022  case 'g':
2023  case 'G':
2024  {
2025  quantum_map[i]=GreenQuantum;
2026  break;
2027  }
2028  case 'I':
2029  case 'i':
2030  {
2031  quantum_map[i]=IndexQuantum;
2032  break;
2033  }
2034  case 'K':
2035  case 'k':
2036  {
2037  quantum_map[i]=BlackQuantum;
2038  if (image->colorspace == CMYKColorspace)
2039  break;
2040  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2041  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2042  "ColorSeparatedImageRequired","`%s'",map);
2043  return(MagickFalse);
2044  }
2045  case 'M':
2046  case 'm':
2047  {
2048  quantum_map[i]=MagentaQuantum;
2049  if (image->colorspace == CMYKColorspace)
2050  break;
2051  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2052  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2053  "ColorSeparatedImageRequired","`%s'",map);
2054  return(MagickFalse);
2055  }
2056  case 'o':
2057  case 'O':
2058  {
2059  quantum_map[i]=OpacityQuantum;
2060  break;
2061  }
2062  case 'P':
2063  case 'p':
2064  {
2065  quantum_map[i]=UndefinedQuantum;
2066  break;
2067  }
2068  case 'R':
2069  case 'r':
2070  {
2071  quantum_map[i]=RedQuantum;
2072  break;
2073  }
2074  case 'Y':
2075  case 'y':
2076  {
2077  quantum_map[i]=YellowQuantum;
2078  if (image->colorspace == CMYKColorspace)
2079  break;
2080  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2081  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2082  "ColorSeparatedImageRequired","`%s'",map);
2083  return(MagickFalse);
2084  }
2085  default:
2086  {
2087  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2089  "UnrecognizedPixelMap","`%s'",map);
2090  return(MagickFalse);
2091  }
2092  }
2093  }
2094  roi.width=width;
2095  roi.height=height;
2096  roi.x=x;
2097  roi.y=y;
2098  switch (type)
2099  {
2100  case CharPixel:
2101  {
2102  status=ExportCharPixel(image,&roi,map,quantum_map,pixels,exception);
2103  break;
2104  }
2105  case DoublePixel:
2106  {
2107  status=ExportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
2108  break;
2109  }
2110  case FloatPixel:
2111  {
2112  status=ExportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
2113  break;
2114  }
2115  case LongPixel:
2116  {
2117  status=ExportLongPixel(image,&roi,map,quantum_map,pixels,exception);
2118  break;
2119  }
2120  case LongLongPixel:
2121  {
2122  status=ExportLongLongPixel(image,&roi,map,quantum_map,pixels,exception);
2123  break;
2124  }
2125  case QuantumPixel:
2126  {
2127  status=ExportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
2128  break;
2129  }
2130  case ShortPixel:
2131  {
2132  status=ExportShortPixel(image,&roi,map,quantum_map,pixels,exception);
2133  break;
2134  }
2135  default:
2136  {
2138  "UnrecognizedPixelMap","`%s'",map);
2139  status=MagickFalse;
2140  }
2141  }
2142  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2143  return(status);
2144 }
2145 
2146 /*
2147 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2148 % %
2149 % %
2150 % %
2151 % G e t P i x e l I n f o %
2152 % %
2153 % %
2154 % %
2155 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2156 %
2157 % GetPixelInfo() initializes the PixelInfo structure.
2158 %
2159 % The format of the GetPixelInfo method is:
2160 %
2161 % GetPixelInfo(const Image *image,PixelInfo *pixel)
2162 %
2163 % A description of each parameter follows:
2164 %
2165 % o image: the image. (optional - may be NULL)
2166 %
2167 % o pixel: Specifies a pointer to a PixelInfo structure.
2168 %
2169 */
2170 MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
2171 {
2172  (void) memset(pixel,0,sizeof(*pixel));
2173  pixel->storage_class=DirectClass;
2174  pixel->colorspace=sRGBColorspace;
2177  pixel->alpha=(double) OpaqueAlpha;
2178  if (image == (const Image *) NULL)
2179  return;
2180  pixel->storage_class=image->storage_class;
2181  pixel->colorspace=image->colorspace;
2182  pixel->alpha_trait=image->alpha_trait;
2183  pixel->depth=image->depth;
2184  pixel->fuzz=image->fuzz;
2185 }
2186 
2187 /*
2188 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2189 % %
2190 % %
2191 % %
2192 % G e t P i x e l I n d o I n t e n s i t y %
2193 % %
2194 % %
2195 % %
2196 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2197 %
2198 % GetPixelInfoIntensity() returns a single sample intensity value from the red,
2199 % green, and blue components of a pixel based on the selected method:
2200 %
2201 % Rec601Luma 0.298839R' + 0.586811G' + 0.114350B'
2202 % Rec601Luminance 0.298839R + 0.586811G + 0.114350B
2203 % Rec709Luma 0.212656R' + 0.715158G' + 0.072186B'
2204 % Rec709Luminance 0.212656R + 0.715158G + 0.072186B
2205 % Brightness max(R', G', B')
2206 % Lightness (min(R', G', B') + max(R', G', B')) / 2.0
2207 %
2208 % MS (R^2 + G^2 + B^2) / 3.0
2209 % RMS sqrt((R^2 + G^2 + B^2) / 3.0
2210 % Average (R + G + B') / 3.0
2211 %
2212 % The format of the GetPixelInfoIntensity method is:
2213 %
2214 % MagickRealType GetPixelInfoIntensity(const Image *image,
2215 % const Quantum *pixel)
2216 %
2217 % A description of each parameter follows:
2218 %
2219 % o image: the image.
2220 %
2221 % o pixel: Specifies a pointer to a Quantum structure.
2222 %
2223 */
2225  const Image *magick_restrict image,const PixelInfo *magick_restrict pixel)
2226 {
2228  blue,
2229  green,
2230  red,
2231  intensity;
2232 
2234  method;
2235 
2237  if (image != (const Image *) NULL)
2238  method=image->intensity;
2239  red=pixel->red;
2240  green=pixel->green;
2241  blue=pixel->blue;
2242  switch (method)
2243  {
2245  {
2246  intensity=(red+green+blue)/3.0;
2247  break;
2248  }
2250  {
2251  intensity=MagickMax(MagickMax(red,green),blue);
2252  break;
2253  }
2255  {
2256  intensity=(MagickMin(MagickMin(red,green),blue)+
2257  MagickMax(MagickMax(red,green),blue))/2.0;
2258  break;
2259  }
2261  {
2262  intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
2263  (3.0*QuantumRange));
2264  break;
2265  }
2267  {
2268  if (pixel->colorspace == RGBColorspace)
2269  {
2270  red=EncodePixelGamma(red);
2271  green=EncodePixelGamma(green);
2272  blue=EncodePixelGamma(blue);
2273  }
2274  intensity=0.298839*red+0.586811*green+0.114350*blue;
2275  break;
2276  }
2278  {
2279  if (pixel->colorspace == sRGBColorspace)
2280  {
2281  red=DecodePixelGamma(red);
2282  green=DecodePixelGamma(green);
2283  blue=DecodePixelGamma(blue);
2284  }
2285  intensity=0.298839*red+0.586811*green+0.114350*blue;
2286  break;
2287  }
2289  default:
2290  {
2291  if (pixel->colorspace == RGBColorspace)
2292  {
2293  red=EncodePixelGamma(red);
2294  green=EncodePixelGamma(green);
2295  blue=EncodePixelGamma(blue);
2296  }
2297  intensity=0.212656*red+0.715158*green+0.072186*blue;
2298  break;
2299  }
2301  {
2302  if (pixel->colorspace == sRGBColorspace)
2303  {
2304  red=DecodePixelGamma(red);
2305  green=DecodePixelGamma(green);
2306  blue=DecodePixelGamma(blue);
2307  }
2308  intensity=0.212656*red+0.715158*green+0.072186*blue;
2309  break;
2310  }
2312  {
2313  intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
2314  sqrt(3.0));
2315  break;
2316  }
2317  }
2318  return(intensity);
2319 }
2320 
2321 /*
2322 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2323 % %
2324 % %
2325 % %
2326 % G e t P i x e l I n t e n s i t y %
2327 % %
2328 % %
2329 % %
2330 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2331 %
2332 % GetPixelIntensity() returns a single sample intensity value from the red,
2333 % green, and blue components of a pixel based on the selected method:
2334 %
2335 % Rec601Luma 0.298839R' + 0.586811G' + 0.114350B'
2336 % Rec601Luminance 0.298839R + 0.586811G + 0.114350B
2337 % Rec709Luma 0.212656R' + 0.715158G' + 0.072186B'
2338 % Rec709Luminance 0.212656R + 0.715158G + 0.072186B
2339 % Brightness max(R', G', B')
2340 % Lightness (min(R', G', B') + max(R', G', B')) / 2.0
2341 %
2342 % MS (R^2 + G^2 + B^2) / 3.0
2343 % RMS sqrt((R^2 + G^2 + B^2) / 3.0
2344 % Average (R + G + B') / 3.0
2345 %
2346 % The format of the GetPixelIntensity method is:
2347 %
2348 % MagickRealType GetPixelIntensity(const Image *image,
2349 % const Quantum *pixel)
2350 %
2351 % A description of each parameter follows:
2352 %
2353 % o image: the image.
2354 %
2355 % o pixel: Specifies a pointer to a Quantum structure.
2356 %
2357 */
2359  const Image *magick_restrict image,const Quantum *magick_restrict pixel)
2360 {
2362  blue,
2363  green,
2364  red,
2365  intensity;
2366 
2367  red=(MagickRealType) GetPixelRed(image,pixel);
2368  green=(MagickRealType) GetPixelGreen(image,pixel);
2369  blue=(MagickRealType) GetPixelBlue(image,pixel);
2370  switch (image->intensity)
2371  {
2373  {
2374  intensity=(red+green+blue)/3.0;
2375  break;
2376  }
2378  {
2379  intensity=MagickMax(MagickMax(red,green),blue);
2380  break;
2381  }
2383  {
2384  intensity=(MagickMin(MagickMin(red,green),blue)+
2385  MagickMax(MagickMax(red,green),blue))/2.0;
2386  break;
2387  }
2389  {
2390  intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
2391  (3.0*QuantumRange));
2392  break;
2393  }
2395  {
2396  if (image->colorspace == RGBColorspace)
2397  {
2398  red=EncodePixelGamma(red);
2399  green=EncodePixelGamma(green);
2400  blue=EncodePixelGamma(blue);
2401  }
2402  intensity=0.298839*red+0.586811*green+0.114350*blue;
2403  break;
2404  }
2406  {
2407  if (image->colorspace == sRGBColorspace)
2408  {
2409  red=DecodePixelGamma(red);
2410  green=DecodePixelGamma(green);
2411  blue=DecodePixelGamma(blue);
2412  }
2413  intensity=0.298839*red+0.586811*green+0.114350*blue;
2414  break;
2415  }
2417  default:
2418  {
2419  if (image->colorspace == RGBColorspace)
2420  {
2421  red=EncodePixelGamma(red);
2422  green=EncodePixelGamma(green);
2423  blue=EncodePixelGamma(blue);
2424  }
2425  intensity=0.212656*red+0.715158*green+0.072186*blue;
2426  break;
2427  }
2429  {
2430  if (image->colorspace == sRGBColorspace)
2431  {
2432  red=DecodePixelGamma(red);
2433  green=DecodePixelGamma(green);
2434  blue=DecodePixelGamma(blue);
2435  }
2436  intensity=0.212656*red+0.715158*green+0.072186*blue;
2437  break;
2438  }
2440  {
2441  intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
2442  sqrt(3.0));
2443  break;
2444  }
2445  }
2446  return(intensity);
2447 }
2448 
2449 /*
2450 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2451 % %
2452 % %
2453 % %
2454 % I m p o r t I m a g e P i x e l s %
2455 % %
2456 % %
2457 % %
2458 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2459 %
2460 % ImportImagePixels() accepts pixel data and stores in the image at the
2461 % location you specify. The method returns MagickTrue on success otherwise
2462 % MagickFalse if an error is encountered. The pixel data can be either char,
2463 % Quantum, short int, unsigned int, unsigned long long, float, or double in
2464 % the order specified by map.
2465 %
2466 % Suppose your want to upload the first scanline of a 640x480 image from
2467 % character data in red-green-blue order:
2468 %
2469 % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
2470 %
2471 % The format of the ImportImagePixels method is:
2472 %
2473 % MagickBooleanType ImportImagePixels(Image *image,const ssize_t x,
2474 % const ssize_t y,const size_t width,const size_t height,
2475 % const char *map,const StorageType type,const void *pixels,
2476 % ExceptionInfo *exception)
2477 %
2478 % A description of each parameter follows:
2479 %
2480 % o image: the image.
2481 %
2482 % o x,y,width,height: These values define the perimeter
2483 % of a region of pixels you want to define.
2484 %
2485 % o map: This string reflects the expected ordering of the pixel array.
2486 % It can be any combination or order of R = red, G = green, B = blue,
2487 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
2488 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
2489 % P = pad.
2490 %
2491 % o type: Define the data type of the pixels. Float and double types are
2492 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
2493 % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *),
2494 % LongPixel (unsigned int *), LongLongPixel (unsigned long long *),
2495 % QuantumPixel (Quantum *), or ShortPixel (unsigned short *).
2496 %
2497 % o pixels: This array of values contain the pixel components as defined by
2498 % map and type. You must preallocate this array where the expected
2499 % length varies depending on the values of width, height, map, and type.
2500 %
2501 % o exception: return any errors or warnings in this structure.
2502 %
2503 */
2504 
2506  const char *magick_restrict map,const QuantumType *quantum_map,
2507  const void *pixels,ExceptionInfo *exception)
2508 {
2509  register const unsigned char
2510  *magick_restrict p;
2511 
2512  register Quantum
2513  *magick_restrict q;
2514 
2515  register ssize_t
2516  x;
2517 
2518  size_t
2519  length;
2520 
2521  ssize_t
2522  y;
2523 
2524  p=(const unsigned char *) pixels;
2525  if (LocaleCompare(map,"BGR") == 0)
2526  {
2527  for (y=0; y < (ssize_t) roi->height; y++)
2528  {
2529  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2530  if (q == (Quantum *) NULL)
2531  break;
2532  for (x=0; x < (ssize_t) roi->width; x++)
2533  {
2534  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2535  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2536  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2537  q+=GetPixelChannels(image);
2538  }
2539  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2540  break;
2541  }
2542  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2543  }
2544  if (LocaleCompare(map,"BGRA") == 0)
2545  {
2546  for (y=0; y < (ssize_t) roi->height; y++)
2547  {
2548  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2549  if (q == (Quantum *) NULL)
2550  break;
2551  for (x=0; x < (ssize_t) roi->width; x++)
2552  {
2553  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2554  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2555  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2556  SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2557  q+=GetPixelChannels(image);
2558  }
2559  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2560  break;
2561  }
2562  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2563  }
2564  if (LocaleCompare(map,"BGRO") == 0)
2565  {
2566  for (y=0; y < (ssize_t) roi->height; y++)
2567  {
2568  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2569  if (q == (Quantum *) NULL)
2570  break;
2571  for (x=0; x < (ssize_t) roi->width; x++)
2572  {
2573  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2574  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2575  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2576  SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2577  q+=GetPixelChannels(image);
2578  }
2579  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2580  break;
2581  }
2582  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2583  }
2584  if (LocaleCompare(map,"BGRP") == 0)
2585  {
2586  for (y=0; y < (ssize_t) roi->height; y++)
2587  {
2588  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2589  if (q == (Quantum *) NULL)
2590  break;
2591  for (x=0; x < (ssize_t) roi->width; x++)
2592  {
2593  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2594  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2595  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2596  p++;
2597  q+=GetPixelChannels(image);
2598  }
2599  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2600  break;
2601  }
2602  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2603  }
2604  if (LocaleCompare(map,"I") == 0)
2605  {
2606  for (y=0; y < (ssize_t) roi->height; y++)
2607  {
2608  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2609  if (q == (Quantum *) NULL)
2610  break;
2611  for (x=0; x < (ssize_t) roi->width; x++)
2612  {
2613  SetPixelGray(image,ScaleCharToQuantum(*p++),q);
2614  q+=GetPixelChannels(image);
2615  }
2616  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2617  break;
2618  }
2619  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2620  }
2621  if (LocaleCompare(map,"RGB") == 0)
2622  {
2623  for (y=0; y < (ssize_t) roi->height; y++)
2624  {
2625  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2626  if (q == (Quantum *) NULL)
2627  break;
2628  for (x=0; x < (ssize_t) roi->width; x++)
2629  {
2630  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2631  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2632  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2633  q+=GetPixelChannels(image);
2634  }
2635  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2636  break;
2637  }
2638  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2639  }
2640  if (LocaleCompare(map,"RGBA") == 0)
2641  {
2642  for (y=0; y < (ssize_t) roi->height; y++)
2643  {
2644  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2645  if (q == (Quantum *) NULL)
2646  break;
2647  for (x=0; x < (ssize_t) roi->width; x++)
2648  {
2649  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2650  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2651  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2652  SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2653  q+=GetPixelChannels(image);
2654  }
2655  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2656  break;
2657  }
2658  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2659  }
2660  if (LocaleCompare(map,"RGBO") == 0)
2661  {
2662  for (y=0; y < (ssize_t) roi->height; y++)
2663  {
2664  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2665  if (q == (Quantum *) NULL)
2666  break;
2667  for (x=0; x < (ssize_t) roi->width; x++)
2668  {
2669  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2670  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2671  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2672  SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2673  q+=GetPixelChannels(image);
2674  }
2675  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2676  break;
2677  }
2678  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2679  }
2680  if (LocaleCompare(map,"RGBP") == 0)
2681  {
2682  for (y=0; y < (ssize_t) roi->height; y++)
2683  {
2684  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2685  if (q == (Quantum *) NULL)
2686  break;
2687  for (x=0; x < (ssize_t) roi->width; x++)
2688  {
2689  SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2690  SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2691  SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2692  p++;
2693  q+=GetPixelChannels(image);
2694  }
2695  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2696  break;
2697  }
2698  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2699  }
2700  length=strlen(map);
2701  for (y=0; y < (ssize_t) roi->height; y++)
2702  {
2703  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2704  if (q == (Quantum *) NULL)
2705  break;
2706  for (x=0; x < (ssize_t) roi->width; x++)
2707  {
2708  register ssize_t
2709  i;
2710 
2711  for (i=0; i < (ssize_t) length; i++)
2712  {
2713  switch (quantum_map[i])
2714  {
2715  case RedQuantum:
2716  case CyanQuantum:
2717  {
2718  SetPixelRed(image,ScaleCharToQuantum(*p),q);
2719  break;
2720  }
2721  case GreenQuantum:
2722  case MagentaQuantum:
2723  {
2724  SetPixelGreen(image,ScaleCharToQuantum(*p),q);
2725  break;
2726  }
2727  case BlueQuantum:
2728  case YellowQuantum:
2729  {
2730  SetPixelBlue(image,ScaleCharToQuantum(*p),q);
2731  break;
2732  }
2733  case AlphaQuantum:
2734  {
2735  SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2736  break;
2737  }
2738  case OpacityQuantum:
2739  {
2740  SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2741  break;
2742  }
2743  case BlackQuantum:
2744  {
2745  SetPixelBlack(image,ScaleCharToQuantum(*p),q);
2746  break;
2747  }
2748  case IndexQuantum:
2749  {
2750  SetPixelGray(image,ScaleCharToQuantum(*p),q);
2751  break;
2752  }
2753  default:
2754  break;
2755  }
2756  p++;
2757  }
2758  q+=GetPixelChannels(image);
2759  }
2760  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2761  break;
2762  }
2763  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2764 }
2765 
2767  const RectangleInfo *roi,const char *magick_restrict map,
2768  const QuantumType *quantum_map,const void *pixels,ExceptionInfo *exception)
2769 {
2770  register const double
2771  *magick_restrict p;
2772 
2773  register Quantum
2774  *magick_restrict q;
2775 
2776  register ssize_t
2777  x;
2778 
2779  size_t
2780  length;
2781 
2782  ssize_t
2783  y;
2784 
2785  p=(const double *) pixels;
2786  if (LocaleCompare(map,"BGR") == 0)
2787  {
2788  for (y=0; y < (ssize_t) roi->height; y++)
2789  {
2790  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2791  if (q == (Quantum *) NULL)
2792  break;
2793  for (x=0; x < (ssize_t) roi->width; x++)
2794  {
2795  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2796  p++;
2797  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2798  p++;
2799  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2800  p++;
2801  q+=GetPixelChannels(image);
2802  }
2803  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2804  break;
2805  }
2806  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2807  }
2808  if (LocaleCompare(map,"BGRA") == 0)
2809  {
2810  for (y=0; y < (ssize_t) roi->height; y++)
2811  {
2812  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2813  if (q == (Quantum *) NULL)
2814  break;
2815  for (x=0; x < (ssize_t) roi->width; x++)
2816  {
2817  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2818  p++;
2819  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2820  p++;
2821  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2822  p++;
2823  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2824  p++;
2825  q+=GetPixelChannels(image);
2826  }
2827  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2828  break;
2829  }
2830  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2831  }
2832  if (LocaleCompare(map,"BGRP") == 0)
2833  {
2834  for (y=0; y < (ssize_t) roi->height; y++)
2835  {
2836  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2837  if (q == (Quantum *) NULL)
2838  break;
2839  for (x=0; x < (ssize_t) roi->width; x++)
2840  {
2841  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2842  p++;
2843  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2844  p++;
2845  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2846  p++;
2847  p++;
2848  q+=GetPixelChannels(image);
2849  }
2850  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2851  break;
2852  }
2853  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2854  }
2855  if (LocaleCompare(map,"I") == 0)
2856  {
2857  for (y=0; y < (ssize_t) roi->height; y++)
2858  {
2859  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2860  if (q == (Quantum *) NULL)
2861  break;
2862  for (x=0; x < (ssize_t) roi->width; x++)
2863  {
2864  SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2865  p++;
2866  q+=GetPixelChannels(image);
2867  }
2868  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2869  break;
2870  }
2871  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2872  }
2873  if (LocaleCompare(map,"RGB") == 0)
2874  {
2875  for (y=0; y < (ssize_t) roi->height; y++)
2876  {
2877  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2878  if (q == (Quantum *) NULL)
2879  break;
2880  for (x=0; x < (ssize_t) roi->width; x++)
2881  {
2882  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2883  p++;
2884  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2885  p++;
2886  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2887  p++;
2888  q+=GetPixelChannels(image);
2889  }
2890  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2891  break;
2892  }
2893  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2894  }
2895  if (LocaleCompare(map,"RGBA") == 0)
2896  {
2897  for (y=0; y < (ssize_t) roi->height; y++)
2898  {
2899  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2900  if (q == (Quantum *) NULL)
2901  break;
2902  for (x=0; x < (ssize_t) roi->width; x++)
2903  {
2904  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2905  p++;
2906  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2907  p++;
2908  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2909  p++;
2910  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2911  p++;
2912  q+=GetPixelChannels(image);
2913  }
2914  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2915  break;
2916  }
2917  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2918  }
2919  if (LocaleCompare(map,"RGBP") == 0)
2920  {
2921  for (y=0; y < (ssize_t) roi->height; y++)
2922  {
2923  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2924  if (q == (Quantum *) NULL)
2925  break;
2926  for (x=0; x < (ssize_t) roi->width; x++)
2927  {
2928  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2929  p++;
2930  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2931  p++;
2932  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2933  p++;
2934  q+=GetPixelChannels(image);
2935  }
2936  if (SyncAuthenticPixels(image,exception) == MagickFalse)
2937  break;
2938  }
2939  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2940  }
2941  length=strlen(map);
2942  for (y=0; y < (ssize_t) roi->height; y++)
2943  {
2944  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2945  if (q == (Quantum *) NULL)
2946  break;
2947  for (x=0; x < (ssize_t) roi->width; x++)
2948  {
2949  register ssize_t
2950  i;
2951 
2952  for (i=0; i < (ssize_t) length; i++)
2953  {
2954  switch (quantum_map[i])
2955  {
2956  case RedQuantum:
2957  case CyanQuantum:
2958  {
2959  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2960  break;
2961  }
2962  case GreenQuantum:
2963  case MagentaQuantum:
2964  {
2965  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2966  break;
2967  }
2968  case BlueQuantum:
2969  case YellowQuantum:
2970  {
2971  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2972  break;
2973  }
2974  case AlphaQuantum:
2975  {
2976  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2977  break;
2978  }
2979  case OpacityQuantum:
2980  {
2981  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2982  break;
2983  }
2984  case BlackQuantum:
2985  {
2986  SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
2987  break;
2988  }
2989  case IndexQuantum:
2990  {
2991  SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2992  break;
2993  }
2994  default:
2995  break;
2996  }
2997  p++;
2998  }
2999  q+=GetPixelChannels(image);
3000  }
3001  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3002  break;
3003  }
3004  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3005 }
3006 
3008  const char *magick_restrict map,const QuantumType *quantum_map,
3009  const void *pixels,ExceptionInfo *exception)
3010 {
3011  register const float
3012  *magick_restrict p;
3013 
3014  register Quantum
3015  *magick_restrict q;
3016 
3017  register ssize_t
3018  x;
3019 
3020  size_t
3021  length;
3022 
3023  ssize_t
3024  y;
3025 
3026  p=(const float *) pixels;
3027  if (LocaleCompare(map,"BGR") == 0)
3028  {
3029  for (y=0; y < (ssize_t) roi->height; y++)
3030  {
3031  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3032  if (q == (Quantum *) NULL)
3033  break;
3034  for (x=0; x < (ssize_t) roi->width; x++)
3035  {
3036  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3037  p++;
3038  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3039  p++;
3040  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3041  p++;
3042  q+=GetPixelChannels(image);
3043  }
3044  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3045  break;
3046  }
3047  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3048  }
3049  if (LocaleCompare(map,"BGRA") == 0)
3050  {
3051  for (y=0; y < (ssize_t) roi->height; y++)
3052  {
3053  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3054  if (q == (Quantum *) NULL)
3055  break;
3056  for (x=0; x < (ssize_t) roi->width; x++)
3057  {
3058  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3059  p++;
3060  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3061  p++;
3062  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3063  p++;
3064  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
3065  p++;
3066  q+=GetPixelChannels(image);
3067  }
3068  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3069  break;
3070  }
3071  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3072  }
3073  if (LocaleCompare(map,"BGRP") == 0)
3074  {
3075  for (y=0; y < (ssize_t) roi->height; y++)
3076  {
3077  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3078  if (q == (Quantum *) NULL)
3079  break;
3080  for (x=0; x < (ssize_t) roi->width; x++)
3081  {
3082  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3083  p++;
3084  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3085  p++;
3086  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3087  p++;
3088  p++;
3089  q+=GetPixelChannels(image);
3090  }
3091  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3092  break;
3093  }
3094  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3095  }
3096  if (LocaleCompare(map,"I") == 0)
3097  {
3098  for (y=0; y < (ssize_t) roi->height; y++)
3099  {
3100  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3101  if (q == (Quantum *) NULL)
3102  break;
3103  for (x=0; x < (ssize_t) roi->width; x++)
3104  {
3105  SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
3106  p++;
3107  q+=GetPixelChannels(image);
3108  }
3109  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3110  break;
3111  }
3112  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3113  }
3114  if (LocaleCompare(map,"RGB") == 0)
3115  {
3116  for (y=0; y < (ssize_t) roi->height; y++)
3117  {
3118  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3119  if (q == (Quantum *) NULL)
3120  break;
3121  for (x=0; x < (ssize_t) roi->width; x++)
3122  {
3123  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3124  p++;
3125  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3126  p++;
3127  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3128  p++;
3129  q+=GetPixelChannels(image);
3130  }
3131  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3132  break;
3133  }
3134  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3135  }
3136  if (LocaleCompare(map,"RGBA") == 0)
3137  {
3138  for (y=0; y < (ssize_t) roi->height; y++)
3139  {
3140  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3141  if (q == (Quantum *) NULL)
3142  break;
3143  for (x=0; x < (ssize_t) roi->width; x++)
3144  {
3145  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3146  p++;
3147  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3148  p++;
3149  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3150  p++;
3151  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
3152  p++;
3153  q+=GetPixelChannels(image);
3154  }
3155  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3156  break;
3157  }
3158  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3159  }
3160  if (LocaleCompare(map,"RGBP") == 0)
3161  {
3162  for (y=0; y < (ssize_t) roi->height; y++)
3163  {
3164  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3165  if (q == (Quantum *) NULL)
3166  break;
3167  for (x=0; x < (ssize_t) roi->width; x++)
3168  {
3169  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3170  p++;
3171  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3172  p++;
3173  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3174  p++;
3175  q+=GetPixelChannels(image);
3176  }
3177  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3178  break;
3179  }
3180  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3181  }
3182  length=strlen(map);
3183  for (y=0; y < (ssize_t) roi->height; y++)
3184  {
3185  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3186  if (q == (Quantum *) NULL)
3187  break;
3188  for (x=0; x < (ssize_t) roi->width; x++)
3189  {
3190  register ssize_t
3191  i;
3192 
3193  for (i=0; i < (ssize_t) length; i++)
3194  {
3195  switch (quantum_map[i])
3196  {
3197  case RedQuantum:
3198  case CyanQuantum:
3199  {
3200  SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
3201  break;
3202  }
3203  case GreenQuantum:
3204  case MagentaQuantum:
3205  {
3206  SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
3207  break;
3208  }
3209  case BlueQuantum:
3210  case YellowQuantum:
3211  {
3212  SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
3213  break;
3214  }
3215  case AlphaQuantum:
3216  {
3217  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
3218  break;
3219  }
3220  case OpacityQuantum:
3221  {
3222  SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
3223  break;
3224  }
3225  case BlackQuantum:
3226  {
3227  SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
3228  break;
3229  }
3230  case IndexQuantum:
3231  {
3232  SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
3233  break;
3234  }
3235  default:
3236  break;
3237  }
3238  p++;
3239  }
3240  q+=GetPixelChannels(image);
3241  }
3242  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3243  break;
3244  }
3245  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3246 }
3247 
3249  const char *magick_restrict map,const QuantumType *quantum_map,
3250  const void *pixels,ExceptionInfo *exception)
3251 {
3252  register const unsigned int
3253  *magick_restrict p;
3254 
3255  register Quantum
3256  *magick_restrict q;
3257 
3258  register ssize_t
3259  x;
3260 
3261  size_t
3262  length;
3263 
3264  ssize_t
3265  y;
3266 
3267  p=(const unsigned int *) pixels;
3268  if (LocaleCompare(map,"BGR") == 0)
3269  {
3270  for (y=0; y < (ssize_t) roi->height; y++)
3271  {
3272  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3273  if (q == (Quantum *) NULL)
3274  break;
3275  for (x=0; x < (ssize_t) roi->width; x++)
3276  {
3277  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3278  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3279  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3280  q+=GetPixelChannels(image);
3281  }
3282  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3283  break;
3284  }
3285  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3286  }
3287  if (LocaleCompare(map,"BGRA") == 0)
3288  {
3289  for (y=0; y < (ssize_t) roi->height; y++)
3290  {
3291  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3292  if (q == (Quantum *) NULL)
3293  break;
3294  for (x=0; x < (ssize_t) roi->width; x++)
3295  {
3296  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3297  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3298  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3299  SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3300  q+=GetPixelChannels(image);
3301  }
3302  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3303  break;
3304  }
3305  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3306  }
3307  if (LocaleCompare(map,"BGRP") == 0)
3308  {
3309  for (y=0; y < (ssize_t) roi->height; y++)
3310  {
3311  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3312  if (q == (Quantum *) NULL)
3313  break;
3314  for (x=0; x < (ssize_t) roi->width; x++)
3315  {
3316  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3317  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3318  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3319  p++;
3320  q+=GetPixelChannels(image);
3321  }
3322  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3323  break;
3324  }
3325  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3326  }
3327  if (LocaleCompare(map,"I") == 0)
3328  {
3329  for (y=0; y < (ssize_t) roi->height; y++)
3330  {
3331  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3332  if (q == (Quantum *) NULL)
3333  break;
3334  for (x=0; x < (ssize_t) roi->width; x++)
3335  {
3336  SetPixelGray(image,ScaleLongToQuantum(*p++),q);
3337  q+=GetPixelChannels(image);
3338  }
3339  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3340  break;
3341  }
3342  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3343  }
3344  if (LocaleCompare(map,"RGB") == 0)
3345  {
3346  for (y=0; y < (ssize_t) roi->height; y++)
3347  {
3348  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3349  if (q == (Quantum *) NULL)
3350  break;
3351  for (x=0; x < (ssize_t) roi->width; x++)
3352  {
3353  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3354  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3355  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3356  q+=GetPixelChannels(image);
3357  }
3358  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3359  break;
3360  }
3361  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3362  }
3363  if (LocaleCompare(map,"RGBA") == 0)
3364  {
3365  for (y=0; y < (ssize_t) roi->height; y++)
3366  {
3367  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3368  if (q == (Quantum *) NULL)
3369  break;
3370  for (x=0; x < (ssize_t) roi->width; x++)
3371  {
3372  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3373  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3374  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3375  SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3376  q+=GetPixelChannels(image);
3377  }
3378  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3379  break;
3380  }
3381  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3382  }
3383  if (LocaleCompare(map,"RGBP") == 0)
3384  {
3385  for (y=0; y < (ssize_t) roi->height; y++)
3386  {
3387  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3388  if (q == (Quantum *) NULL)
3389  break;
3390  for (x=0; x < (ssize_t) roi->width; x++)
3391  {
3392  SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3393  SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3394  SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3395  p++;
3396  q+=GetPixelChannels(image);
3397  }
3398  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3399  break;
3400  }
3401  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3402  }
3403  length=strlen(map);
3404  for (y=0; y < (ssize_t) roi->height; y++)
3405  {
3406  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3407  if (q == (Quantum *) NULL)
3408  break;
3409  for (x=0; x < (ssize_t) roi->width; x++)
3410  {
3411  register ssize_t
3412  i;
3413 
3414  for (i=0; i < (ssize_t) length; i++)
3415  {
3416  switch (quantum_map[i])
3417  {
3418  case RedQuantum:
3419  case CyanQuantum:
3420  {
3421  SetPixelRed(image,ScaleLongToQuantum(*p),q);
3422  break;
3423  }
3424  case GreenQuantum:
3425  case MagentaQuantum:
3426  {
3427  SetPixelGreen(image,ScaleLongToQuantum(*p),q);
3428  break;
3429  }
3430  case BlueQuantum:
3431  case YellowQuantum:
3432  {
3433  SetPixelBlue(image,ScaleLongToQuantum(*p),q);
3434  break;
3435  }
3436  case AlphaQuantum:
3437  {
3438  SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3439  break;
3440  }
3441  case OpacityQuantum:
3442  {
3443  SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3444  break;
3445  }
3446  case BlackQuantum:
3447  {
3448  SetPixelBlack(image,ScaleLongToQuantum(*p),q);
3449  break;
3450  }
3451  case IndexQuantum:
3452  {
3453  SetPixelGray(image,ScaleLongToQuantum(*p),q);
3454  break;
3455  }
3456  default:
3457  break;
3458  }
3459  p++;
3460  }
3461  q+=GetPixelChannels(image);
3462  }
3463  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3464  break;
3465  }
3466  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3467 }
3468 
3470  const RectangleInfo *roi,const char *magick_restrict map,
3471  const QuantumType *quantum_map,const void *pixels,ExceptionInfo *exception)
3472 {
3473  register const MagickSizeType
3474  *magick_restrict p;
3475 
3476  register Quantum
3477  *magick_restrict q;
3478 
3479  register ssize_t
3480  x;
3481 
3482  size_t
3483  length;
3484 
3485  ssize_t
3486  y;
3487 
3488  p=(const MagickSizeType *) pixels;
3489  if (LocaleCompare(map,"BGR") == 0)
3490  {
3491  for (y=0; y < (ssize_t) roi->height; y++)
3492  {
3493  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3494  if (q == (Quantum *) NULL)
3495  break;
3496  for (x=0; x < (ssize_t) roi->width; x++)
3497  {
3498  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3499  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3500  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3501  q+=GetPixelChannels(image);
3502  }
3503  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3504  break;
3505  }
3506  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3507  }
3508  if (LocaleCompare(map,"BGRA") == 0)
3509  {
3510  for (y=0; y < (ssize_t) roi->height; y++)
3511  {
3512  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3513  if (q == (Quantum *) NULL)
3514  break;
3515  for (x=0; x < (ssize_t) roi->width; x++)
3516  {
3517  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3518  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3519  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3520  SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
3521  q+=GetPixelChannels(image);
3522  }
3523  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3524  break;
3525  }
3526  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3527  }
3528  if (LocaleCompare(map,"BGRP") == 0)
3529  {
3530  for (y=0; y < (ssize_t) roi->height; y++)
3531  {
3532  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3533  if (q == (Quantum *) NULL)
3534  break;
3535  for (x=0; x < (ssize_t) roi->width; x++)
3536  {
3537  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3538  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3539  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3540  p++;
3541  q+=GetPixelChannels(image);
3542  }
3543  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3544  break;
3545  }
3546  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3547  }
3548  if (LocaleCompare(map,"I") == 0)
3549  {
3550  for (y=0; y < (ssize_t) roi->height; y++)
3551  {
3552  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3553  if (q == (Quantum *) NULL)
3554  break;
3555  for (x=0; x < (ssize_t) roi->width; x++)
3556  {
3557  SetPixelGray(image,ScaleLongLongToQuantum(*p++),q);
3558  q+=GetPixelChannels(image);
3559  }
3560  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3561  break;
3562  }
3563  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3564  }
3565  if (LocaleCompare(map,"RGB") == 0)
3566  {
3567  for (y=0; y < (ssize_t) roi->height; y++)
3568  {
3569  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3570  if (q == (Quantum *) NULL)
3571  break;
3572  for (x=0; x < (ssize_t) roi->width; x++)
3573  {
3574  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3575  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3576  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3577  q+=GetPixelChannels(image);
3578  }
3579  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3580  break;
3581  }
3582  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3583  }
3584  if (LocaleCompare(map,"RGBA") == 0)
3585  {
3586  for (y=0; y < (ssize_t) roi->height; y++)
3587  {
3588  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3589  if (q == (Quantum *) NULL)
3590  break;
3591  for (x=0; x < (ssize_t) roi->width; x++)
3592  {
3593  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3594  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3595  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3596  SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
3597  q+=GetPixelChannels(image);
3598  }
3599  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3600  break;
3601  }
3602  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3603  }
3604  if (LocaleCompare(map,"RGBP") == 0)
3605  {
3606  for (y=0; y < (ssize_t) roi->height; y++)
3607  {
3608  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3609  if (q == (Quantum *) NULL)
3610  break;
3611  for (x=0; x < (ssize_t) roi->width; x++)
3612  {
3613  SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3614  SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3615  SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3616  p++;
3617  q+=GetPixelChannels(image);
3618  }
3619  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3620  break;
3621  }
3622  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3623  }
3624  length=strlen(map);
3625  for (y=0; y < (ssize_t) roi->height; y++)
3626  {
3627  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3628  if (q == (Quantum *) NULL)
3629  break;
3630  for (x=0; x < (ssize_t) roi->width; x++)
3631  {
3632  register ssize_t
3633  i;
3634 
3635  for (i=0; i < (ssize_t) length; i++)
3636  {
3637  switch (quantum_map[i])
3638  {
3639  case RedQuantum:
3640  case CyanQuantum:
3641  {
3642  SetPixelRed(image,ScaleLongLongToQuantum(*p),q);
3643  break;
3644  }
3645  case GreenQuantum:
3646  case MagentaQuantum:
3647  {
3648  SetPixelGreen(image,ScaleLongLongToQuantum(*p),q);
3649  break;
3650  }
3651  case BlueQuantum:
3652  case YellowQuantum:
3653  {
3654  SetPixelBlue(image,ScaleLongLongToQuantum(*p),q);
3655  break;
3656  }
3657  case AlphaQuantum:
3658  {
3659  SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
3660  break;
3661  }
3662  case OpacityQuantum:
3663  {
3664  SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
3665  break;
3666  }
3667  case BlackQuantum:
3668  {
3669  SetPixelBlack(image,ScaleLongLongToQuantum(*p),q);
3670  break;
3671  }
3672  case IndexQuantum:
3673  {
3674  SetPixelGray(image,ScaleLongLongToQuantum(*p),q);
3675  break;
3676  }
3677  default:
3678  break;
3679  }
3680  p++;
3681  }
3682  q+=GetPixelChannels(image);
3683  }
3684  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3685  break;
3686  }
3687  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3688 }
3689 
3691  const RectangleInfo *roi,const char *magick_restrict map,
3692  const QuantumType *quantum_map,const void *pixels,ExceptionInfo *exception)
3693 {
3694  register const Quantum
3695  *magick_restrict p;
3696 
3697  register Quantum
3698  *magick_restrict q;
3699 
3700  register ssize_t
3701  x;
3702 
3703  size_t
3704  length;
3705 
3706  ssize_t
3707  y;
3708 
3709  p=(const Quantum *) pixels;
3710  if (LocaleCompare(map,"BGR") == 0)
3711  {
3712  for (y=0; y < (ssize_t) roi->height; y++)
3713  {
3714  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3715  if (q == (Quantum *) NULL)
3716  break;
3717  for (x=0; x < (ssize_t) roi->width; x++)
3718  {
3719  SetPixelBlue(image,*p++,q);
3720  SetPixelGreen(image,*p++,q);
3721  SetPixelRed(image,*p++,q);
3722  q+=GetPixelChannels(image);
3723  }
3724  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3725  break;
3726  }
3727  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3728  }
3729  if (LocaleCompare(map,"BGRA") == 0)
3730  {
3731  for (y=0; y < (ssize_t) roi->height; y++)
3732  {
3733  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3734  if (q == (Quantum *) NULL)
3735  break;
3736  for (x=0; x < (ssize_t) roi->width; x++)
3737  {
3738  SetPixelBlue(image,*p++,q);
3739  SetPixelGreen(image,*p++,q);
3740  SetPixelRed(image,*p++,q);
3741  SetPixelAlpha(image,*p++,q);
3742  q+=GetPixelChannels(image);
3743  }
3744  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3745  break;
3746  }
3747  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3748  }
3749  if (LocaleCompare(map,"BGRP") == 0)
3750  {
3751  for (y=0; y < (ssize_t) roi->height; y++)
3752  {
3753  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3754  if (q == (Quantum *) NULL)
3755  break;
3756  for (x=0; x < (ssize_t) roi->width; x++)
3757  {
3758  SetPixelBlue(image,*p++,q);
3759  SetPixelGreen(image,*p++,q);
3760  SetPixelRed(image,*p++,q);
3761  p++;
3762  q+=GetPixelChannels(image);
3763  }
3764  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3765  break;
3766  }
3767  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3768  }
3769  if (LocaleCompare(map,"I") == 0)
3770  {
3771  for (y=0; y < (ssize_t) roi->height; y++)
3772  {
3773  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3774  if (q == (Quantum *) NULL)
3775  break;
3776  for (x=0; x < (ssize_t) roi->width; x++)
3777  {
3778  SetPixelGray(image,*p++,q);
3779  q+=GetPixelChannels(image);
3780  }
3781  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3782  break;
3783  }
3784  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3785  }
3786  if (LocaleCompare(map,"RGB") == 0)
3787  {
3788  for (y=0; y < (ssize_t) roi->height; y++)
3789  {
3790  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3791  if (q == (Quantum *) NULL)
3792  break;
3793  for (x=0; x < (ssize_t) roi->width; x++)
3794  {
3795  SetPixelRed(image,*p++,q);
3796  SetPixelGreen(image,*p++,q);
3797  SetPixelBlue(image,*p++,q);
3798  q+=GetPixelChannels(image);
3799  }
3800  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3801  break;
3802  }
3803  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3804  }
3805  if (LocaleCompare(map,"RGBA") == 0)
3806  {
3807  for (y=0; y < (ssize_t) roi->height; y++)
3808  {
3809  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3810  if (q == (Quantum *) NULL)
3811  break;
3812  for (x=0; x < (ssize_t) roi->width; x++)
3813  {
3814  SetPixelRed(image,*p++,q);
3815  SetPixelGreen(image,*p++,q);
3816  SetPixelBlue(image,*p++,q);
3817  SetPixelAlpha(image,*p++,q);
3818  q+=GetPixelChannels(image);
3819  }
3820  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3821  break;
3822  }
3823  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3824  }
3825  if (LocaleCompare(map,"RGBP") == 0)
3826  {
3827  for (y=0; y < (ssize_t) roi->height; y++)
3828  {
3829  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3830  if (q == (Quantum *) NULL)
3831  break;
3832  for (x=0; x < (ssize_t) roi->width; x++)
3833  {
3834  SetPixelRed(image,*p++,q);
3835  SetPixelGreen(image,*p++,q);
3836  SetPixelBlue(image,*p++,q);
3837  p++;
3838  q+=GetPixelChannels(image);
3839  }
3840  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3841  break;
3842  }
3843  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3844  }
3845  length=strlen(map);
3846  for (y=0; y < (ssize_t) roi->height; y++)
3847  {
3848  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3849  if (q == (Quantum *) NULL)
3850  break;
3851  for (x=0; x < (ssize_t) roi->width; x++)
3852  {
3853  register ssize_t
3854  i;
3855 
3856  for (i=0; i < (ssize_t) length; i++)
3857  {
3858  switch (quantum_map[i])
3859  {
3860  case RedQuantum:
3861  case CyanQuantum:
3862  {
3863  SetPixelRed(image,*p,q);
3864  break;
3865  }
3866  case GreenQuantum:
3867  case MagentaQuantum:
3868  {
3869  SetPixelGreen(image,*p,q);
3870  break;
3871  }
3872  case BlueQuantum:
3873  case YellowQuantum:
3874  {
3875  SetPixelBlue(image,*p,q);
3876  break;
3877  }
3878  case AlphaQuantum:
3879  {
3880  SetPixelAlpha(image,*p,q);
3881  break;
3882  }
3883  case OpacityQuantum:
3884  {
3885  SetPixelAlpha(image,*p,q);
3886  break;
3887  }
3888  case BlackQuantum:
3889  {
3890  SetPixelBlack(image,*p,q);
3891  break;
3892  }
3893  case IndexQuantum:
3894  {
3895  SetPixelGray(image,*p,q);
3896  break;
3897  }
3898  default:
3899  break;
3900  }
3901  p++;
3902  }
3903  q+=GetPixelChannels(image);
3904  }
3905  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3906  break;
3907  }
3908  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3909 }
3910 
3912  const char *magick_restrict map,const QuantumType *quantum_map,
3913  const void *pixels,ExceptionInfo *exception)
3914 {
3915  register const unsigned short
3916  *magick_restrict p;
3917 
3918  register Quantum
3919  *magick_restrict q;
3920 
3921  register ssize_t
3922  x;
3923 
3924  size_t
3925  length;
3926 
3927  ssize_t
3928  y;
3929 
3930  p=(const unsigned short *) pixels;
3931  if (LocaleCompare(map,"BGR") == 0)
3932  {
3933  for (y=0; y < (ssize_t) roi->height; y++)
3934  {
3935  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3936  if (q == (Quantum *) NULL)
3937  break;
3938  for (x=0; x < (ssize_t) roi->width; x++)
3939  {
3940  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3941  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3942  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3943  q+=GetPixelChannels(image);
3944  }
3945  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3946  break;
3947  }
3948  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3949  }
3950  if (LocaleCompare(map,"BGRA") == 0)
3951  {
3952  for (y=0; y < (ssize_t) roi->height; y++)
3953  {
3954  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3955  if (q == (Quantum *) NULL)
3956  break;
3957  for (x=0; x < (ssize_t) roi->width; x++)
3958  {
3959  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3960  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3961  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3962  SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3963  q+=GetPixelChannels(image);
3964  }
3965  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3966  break;
3967  }
3968  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3969  }
3970  if (LocaleCompare(map,"BGRP") == 0)
3971  {
3972  for (y=0; y < (ssize_t) roi->height; y++)
3973  {
3974  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3975  if (q == (Quantum *) NULL)
3976  break;
3977  for (x=0; x < (ssize_t) roi->width; x++)
3978  {
3979  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3980  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3981  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3982  p++;
3983  q+=GetPixelChannels(image);
3984  }
3985  if (SyncAuthenticPixels(image,exception) == MagickFalse)
3986  break;
3987  }
3988  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3989  }
3990  if (LocaleCompare(map,"I") == 0)
3991  {
3992  for (y=0; y < (ssize_t) roi->height; y++)
3993  {
3994  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3995  if (q == (Quantum *) NULL)
3996  break;
3997  for (x=0; x < (ssize_t) roi->width; x++)
3998  {
3999  SetPixelGray(image,ScaleShortToQuantum(*p++),q);
4000  q+=GetPixelChannels(image);
4001  }
4002  if (SyncAuthenticPixels(image,exception) == MagickFalse)
4003  break;
4004  }
4005  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4006  }
4007  if (LocaleCompare(map,"RGB") == 0)
4008  {
4009  for (y=0; y < (ssize_t) roi->height; y++)
4010  {
4011  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4012  if (q == (Quantum *) NULL)
4013  break;
4014  for (x=0; x < (ssize_t) roi->width; x++)
4015  {
4016  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
4017  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
4018  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
4019  q+=GetPixelChannels(image);
4020  }
4021  if (SyncAuthenticPixels(image,exception) == MagickFalse)
4022  break;
4023  }
4024  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4025  }
4026  if (LocaleCompare(map,"RGBA") == 0)
4027  {
4028  for (y=0; y < (ssize_t) roi->height; y++)
4029  {
4030  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4031  if (q == (Quantum *) NULL)
4032  break;
4033  for (x=0; x < (ssize_t) roi->width; x++)
4034  {
4035  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
4036  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
4037  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
4038  SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
4039  q+=GetPixelChannels(image);
4040  }
4041  if (SyncAuthenticPixels(image,exception) == MagickFalse)
4042  break;
4043  }
4044  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4045  }
4046  if (LocaleCompare(map,"RGBP") == 0)
4047  {
4048  for (y=0; y < (ssize_t) roi->height; y++)
4049  {
4050  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4051  if (q == (Quantum *) NULL)
4052  break;
4053  for (x=0; x < (ssize_t) roi->width; x++)
4054  {
4055  SetPixelRed(image,ScaleShortToQuantum(*p++),q);
4056  SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
4057  SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
4058  p++;
4059  q+=GetPixelChannels(image);
4060  }
4061  if (SyncAuthenticPixels(image,exception) == MagickFalse)
4062  break;
4063  }
4064  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4065  }
4066  length=strlen(map);
4067  for (y=0; y < (ssize_t) roi->height; y++)
4068  {
4069  q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4070  if (q == (Quantum *) NULL)
4071  break;
4072  for (x=0; x < (ssize_t) roi->width; x++)
4073  {
4074  register ssize_t
4075  i;
4076 
4077  for (i=0; i < (ssize_t) length; i++)
4078  {
4079  switch (quantum_map[i])
4080  {
4081  case RedQuantum:
4082  case CyanQuantum:
4083  {
4084  SetPixelRed(image,ScaleShortToQuantum(*p),q);
4085  break;
4086  }
4087  case GreenQuantum:
4088  case MagentaQuantum:
4089  {
4090  SetPixelGreen(image,ScaleShortToQuantum(*p),q);
4091  break;
4092  }
4093  case BlueQuantum:
4094  case YellowQuantum:
4095  {
4096  SetPixelBlue(image,ScaleShortToQuantum(*p),q);
4097  break;
4098  }
4099  case AlphaQuantum:
4100  {
4101  SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
4102  break;
4103  }
4104  case OpacityQuantum:
4105  {
4106  SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
4107  break;
4108  }
4109  case BlackQuantum:
4110  {
4111  SetPixelBlack(image,ScaleShortToQuantum(*p),q);
4112  break;
4113  }
4114  case IndexQuantum:
4115  {
4116  SetPixelGray(image,ScaleShortToQuantum(*p),q);
4117  break;
4118  }
4119  default:
4120  break;
4121  }
4122  p++;
4123  }
4124  q+=GetPixelChannels(image);
4125  }
4126  if (SyncAuthenticPixels(image,exception) == MagickFalse)
4127  break;
4128  }
4129  return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4130 }
4131 
4133  const ssize_t y,const size_t width,const size_t height,const char *map,
4134  const StorageType type,const void *pixels,ExceptionInfo *exception)
4135 {
4137  status;
4138 
4139  QuantumType
4140  *quantum_map;
4141 
4143  roi;
4144 
4145  register ssize_t
4146  i;
4147 
4148  size_t
4149  length;
4150 
4151  /*
4152  Allocate image structure.
4153  */
4154  assert(image != (Image *) NULL);
4155  assert(image->signature == MagickCoreSignature);
4156  if (image->debug != MagickFalse)
4157  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4158  length=strlen(map);
4159  quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
4160  if (quantum_map == (QuantumType *) NULL)
4161  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
4162  image->filename);
4163  for (i=0; i < (ssize_t) length; i++)
4164  {
4165  switch (map[i])
4166  {
4167  case 'a':
4168  case 'A':
4169  {
4170  quantum_map[i]=AlphaQuantum;
4172  break;
4173  }
4174  case 'B':
4175  case 'b':
4176  {
4177  quantum_map[i]=BlueQuantum;
4178  break;
4179  }
4180  case 'C':
4181  case 'c':
4182  {
4183  quantum_map[i]=CyanQuantum;
4184  (void) SetImageColorspace(image,CMYKColorspace,exception);
4185  break;
4186  }
4187  case 'g':
4188  case 'G':
4189  {
4190  quantum_map[i]=GreenQuantum;
4191  break;
4192  }
4193  case 'K':
4194  case 'k':
4195  {
4196  quantum_map[i]=BlackQuantum;
4197  (void) SetImageColorspace(image,CMYKColorspace,exception);
4198  break;
4199  }
4200  case 'I':
4201  case 'i':
4202  {
4203  quantum_map[i]=IndexQuantum;
4204  (void) SetImageColorspace(image,GRAYColorspace,exception);
4205  break;
4206  }
4207  case 'm':
4208  case 'M':
4209  {
4210  quantum_map[i]=MagentaQuantum;
4211  (void) SetImageColorspace(image,CMYKColorspace,exception);
4212  break;
4213  }
4214  case 'O':
4215  case 'o':
4216  {
4217  quantum_map[i]=OpacityQuantum;
4219  break;
4220  }
4221  case 'P':
4222  case 'p':
4223  {
4224  quantum_map[i]=UndefinedQuantum;
4225  break;
4226  }
4227  case 'R':
4228  case 'r':
4229  {
4230  quantum_map[i]=RedQuantum;
4231  break;
4232  }
4233  case 'Y':
4234  case 'y':
4235  {
4236  quantum_map[i]=YellowQuantum;
4237  (void) SetImageColorspace(image,CMYKColorspace,exception);
4238  break;
4239  }
4240  default:
4241  {
4242  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4244  "UnrecognizedPixelMap","`%s'",map);
4245  return(MagickFalse);
4246  }
4247  }
4248  }
4249  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
4250  return(MagickFalse);
4251  /*
4252  Transfer the pixels from the pixel data to the image.
4253  */
4254  roi.width=width;
4255  roi.height=height;
4256  roi.x=x;
4257  roi.y=y;
4258  switch (type)
4259  {
4260  case CharPixel:
4261  {
4262  status=ImportCharPixel(image,&roi,map,quantum_map,pixels,exception);
4263  break;
4264  }
4265  case DoublePixel:
4266  {
4267  status=ImportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
4268  break;
4269  }
4270  case FloatPixel:
4271  {
4272  status=ImportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
4273  break;
4274  }
4275  case LongPixel:
4276  {
4277  status=ImportLongPixel(image,&roi,map,quantum_map,pixels,exception);
4278  break;
4279  }
4280  case LongLongPixel:
4281  {
4282  status=ImportLongLongPixel(image,&roi,map,quantum_map,pixels,exception);
4283  break;
4284  }
4285  case QuantumPixel:
4286  {
4287  status=ImportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
4288  break;
4289  }
4290  case ShortPixel:
4291  {
4292  status=ImportShortPixel(image,&roi,map,quantum_map,pixels,exception);
4293  break;
4294  }
4295  default:
4296  {
4298  "UnrecognizedStorageType","`%d'",type);
4299  status=MagickFalse;
4300  }
4301  }
4302  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4303  return(status);
4304 }
4305 
4306 /*
4307 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4308 % %
4309 % %
4310 % %
4311 + I n i t i a l i z e P i x e l C h a n n e l M a p %
4312 % %
4313 % %
4314 % %
4315 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4316 %
4317 % InitializePixelChannelMap() defines the standard pixel component map.
4318 %
4319 % The format of the InitializePixelChannelMap() method is:
4320 %
4321 % void InitializePixelChannelMap(Image *image)
4322 %
4323 % A description of each parameter follows:
4324 %
4325 % o image: the image.
4326 %
4327 */
4329 {
4330  PixelTrait
4331  trait;
4332 
4333  register ssize_t
4334  i;
4335 
4336  ssize_t
4337  n;
4338 
4339  assert(image != (Image *) NULL);
4340  assert(image->signature == MagickCoreSignature);
4341  (void) memset(image->channel_map,0,MaxPixelChannels*
4342  sizeof(*image->channel_map));
4343  trait=UpdatePixelTrait;
4344  if (image->alpha_trait != UndefinedPixelTrait)
4345  trait=(PixelTrait) (trait | BlendPixelTrait);
4346  n=0;
4347  if ((image->colorspace == LinearGRAYColorspace) ||
4348  (image->colorspace == GRAYColorspace))
4349  {
4352  SetPixelChannelAttributes(image,RedPixelChannel,trait,n++);
4353  }
4354  else
4355  {
4356  SetPixelChannelAttributes(image,RedPixelChannel,trait,n++);
4359  }
4360  if (image->colorspace == CMYKColorspace)
4362  for (i=0; i < (ssize_t) image->number_meta_channels; i++)
4363  {
4365  n++;
4366  }
4367  if (image->alpha_trait != UndefinedPixelTrait)
4369  if (image->storage_class == PseudoClass)
4371  if (image->read_mask != MagickFalse)
4373  if (image->write_mask != MagickFalse)
4375  image->number_channels=(size_t) n;
4376  (void) SetPixelChannelMask(image,image->channel_mask);
4377 }
4378 
4379 /*
4380 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4381 % %
4382 % %
4383 % %
4384 % I n t e r p o l a t e P i x e l C h a n n e l %
4385 % %
4386 % %
4387 % %
4388 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4389 %
4390 % InterpolatePixelChannel() applies a pixel interpolation method between a
4391 % floating point coordinate and the pixels surrounding that coordinate. No
4392 % pixel area resampling, or scaling of the result is performed.
4393 %
4394 % Interpolation is restricted to just the specified channel.
4395 %
4396 % The format of the InterpolatePixelChannel method is:
4397 %
4398 % MagickBooleanType InterpolatePixelChannel(const Image *image,
4399 % const CacheView *image_view,const PixelChannel channel,
4400 % const PixelInterpolateMethod method,const double x,const double y,
4401 % double *pixel,ExceptionInfo *exception)
4402 %
4403 % A description of each parameter follows:
4404 %
4405 % o image: the image.
4406 %
4407 % o image_view: the image view.
4408 %
4409 % o channel: the pixel channel to interpolate.
4410 %
4411 % o method: the pixel color interpolation method.
4412 %
4413 % o x,y: A double representing the current (x,y) position of the pixel.
4414 %
4415 % o pixel: return the interpolated pixel here.
4416 %
4417 % o exception: return any errors or warnings in this structure.
4418 %
4419 */
4420 
4421 static inline void CatromWeights(const double x,double (*weights)[4])
4422 {
4423  double
4424  alpha,
4425  beta,
4426  gamma;
4427 
4428  /*
4429  Nicolas Robidoux' 10 flops (4* + 5- + 1+) refactoring of the computation
4430  of the standard four 1D Catmull-Rom weights. The sampling location is
4431  assumed between the second and third input pixel locations, and x is the
4432  position relative to the second input pixel location. Formulas originally
4433  derived for the VIPS (Virtual Image Processing System) library.
4434  */
4435  alpha=(double) 1.0-x;
4436  beta=(double) (-0.5)*x*alpha;
4437  (*weights)[0]=alpha*beta;
4438  (*weights)[3]=x*beta;
4439  /*
4440  The following computation of the inner weights from the outer ones work
4441  for all Keys cubics.
4442  */
4443  gamma=(*weights)[3]-(*weights)[0];
4444  (*weights)[1]=alpha-(*weights)[0]+gamma;
4445  (*weights)[2]=x-(*weights)[3]-gamma;
4446 }
4447 
4448 static inline void SplineWeights(const double x,double (*weights)[4])
4449 {
4450  double
4451  alpha,
4452  beta;
4453 
4454  /*
4455  Nicolas Robidoux' 12 flops (6* + 5- + 1+) refactoring of the computation
4456  of the standard four 1D cubic B-spline smoothing weights. The sampling
4457  location is assumed between the second and third input pixel locations,
4458  and x is the position relative to the second input pixel location.
4459  */
4460  alpha=(double) 1.0-x;
4461  (*weights)[3]=(double) (1.0/6.0)*x*x*x;
4462  (*weights)[0]=(double) (1.0/6.0)*alpha*alpha*alpha;
4463  beta=(*weights)[3]-(*weights)[0];
4464  (*weights)[1]=alpha-(*weights)[0]+beta;
4465  (*weights)[2]=x-(*weights)[3]-beta;
4466 }
4467 
4468 static inline double MeshInterpolate(const PointInfo *delta,const double p,
4469  const double x,const double y)
4470 {
4471  return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
4472 }
4473 
4474 /*
4475 static inline ssize_t NearestNeighbor(const double x)
4476 {
4477  if (x >= 0.0)
4478  return((ssize_t) (x+0.5));
4479  return((ssize_t) (x-0.5));
4480 }
4481 */
4482 
4484  const CacheView_ *image_view,const PixelChannel channel,
4485  const PixelInterpolateMethod method,const double x,const double y,
4486  double *pixel,ExceptionInfo *exception)
4487 {
4488  double
4489  alpha[16],
4490  gamma,
4491  pixels[16];
4492 
4494  status;
4495 
4497  interpolate;
4498 
4499  PixelTrait
4500  traits;
4501 
4502  register const Quantum
4503  *p;
4504 
4505  register ssize_t
4506  i;
4507 
4508  ssize_t
4509  x_offset,
4510  y_offset;
4511 
4512  assert(image != (Image *) NULL);
4513  assert(image->signature == MagickCoreSignature);
4514  assert(image_view != (CacheView *) NULL);
4515  status=MagickTrue;
4516  *pixel=0.0;
4517  traits=GetPixelChannelTraits(image,channel);
4518  x_offset=(ssize_t) floor(x);
4519  y_offset=(ssize_t) floor(y);
4520  interpolate=method;
4521  if (interpolate == UndefinedInterpolatePixel)
4522  interpolate=image->interpolate;
4523  switch (interpolate)
4524  {
4525  case AverageInterpolatePixel: /* nearest 4 neighbours */
4526  case Average9InterpolatePixel: /* nearest 9 neighbours */
4527  case Average16InterpolatePixel: /* nearest 16 neighbours */
4528  {
4529  ssize_t
4530  count;
4531 
4532  count=2; /* size of the area to average - default nearest 4 */
4533  if (interpolate == Average9InterpolatePixel)
4534  {
4535  count=3;
4536  x_offset=(ssize_t) (floor(x+0.5)-1);
4537  y_offset=(ssize_t) (floor(y+0.5)-1);
4538  }
4539  else
4540  if (interpolate == Average16InterpolatePixel)
4541  {
4542  count=4;
4543  x_offset--;
4544  y_offset--;
4545  }
4546  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,
4547  (size_t) count,exception);
4548  if (p == (const Quantum *) NULL)
4549  {
4550  status=MagickFalse;
4551  break;
4552  }
4553  count*=count; /* Number of pixels to average */
4554  if ((traits & BlendPixelTrait) == 0)
4555  for (i=0; i < (ssize_t) count; i++)
4556  {
4557  alpha[i]=1.0;
4558  pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
4559  }
4560  else
4561  for (i=0; i < (ssize_t) count; i++)
4562  {
4563  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4564  GetPixelChannels(image));
4565  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4566  }
4567  for (i=0; i < (ssize_t) count; i++)
4568  {
4569  gamma=PerceptibleReciprocal(alpha[i])/count;
4570  *pixel+=gamma*pixels[i];
4571  }
4572  break;
4573  }
4575  default:
4576  {
4577  PointInfo
4578  delta,
4579  epsilon;
4580 
4581  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4582  if (p == (const Quantum *) NULL)
4583  {
4584  status=MagickFalse;
4585  break;
4586  }
4587  if ((traits & BlendPixelTrait) == 0)
4588  for (i=0; i < 4; i++)
4589  {
4590  alpha[i]=1.0;
4591  pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
4592  }
4593  else
4594  for (i=0; i < 4; i++)
4595  {
4596  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4597  GetPixelChannels(image));
4598  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4599  }
4600  delta.x=x-x_offset;
4601  delta.y=y-y_offset;
4602  epsilon.x=1.0-delta.x;
4603  epsilon.y=1.0-delta.y;
4604  gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4605  (epsilon.x*alpha[2]+delta.x*alpha[3])));
4606  gamma=PerceptibleReciprocal(gamma);
4607  *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
4608  (epsilon.x*pixels[2]+delta.x*pixels[3]));
4609  break;
4610  }
4611  case BlendInterpolatePixel:
4612  {
4613  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4614  if (p == (const Quantum *) NULL)
4615  {
4616  status=MagickFalse;
4617  break;
4618  }
4619  if ((traits & BlendPixelTrait) == 0)
4620  for (i=0; i < 4; i++)
4621  {
4622  alpha[i]=1.0;
4623  pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4624  }
4625  else
4626  for (i=0; i < 4; i++)
4627  {
4628  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4629  GetPixelChannels(image));
4630  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4631  }
4632  gamma=1.0; /* number of pixels blended together (its variable) */
4633  for (i=0; i <= 1L; i++) {
4634  if ((y-y_offset) >= 0.75)
4635  {
4636  alpha[i]=alpha[i+2]; /* take right pixels */
4637  pixels[i]=pixels[i+2];
4638  }
4639  else
4640  if ((y-y_offset) > 0.25)
4641  {
4642  gamma=2.0; /* blend both pixels in row */
4643  alpha[i]+=alpha[i+2]; /* add up alpha weights */
4644  pixels[i]+=pixels[i+2];
4645  }
4646  }
4647  if ((x-x_offset) >= 0.75)
4648  {
4649  alpha[0]=alpha[1]; /* take bottom row blend */
4650  pixels[0]=pixels[1];
4651  }
4652  else
4653  if ((x-x_offset) > 0.25)
4654  {
4655  gamma*=2.0; /* blend both rows */
4656  alpha[0]+=alpha[1]; /* add up alpha weights */
4657  pixels[0]+=pixels[1];
4658  }
4659  if (channel != AlphaPixelChannel)
4660  gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
4661  else
4662  gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
4663  *pixel=gamma*pixels[0];
4664  break;
4665  }
4667  {
4668  double
4669  cx[4],
4670  cy[4];
4671 
4672  p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4673  exception);
4674  if (p == (const Quantum *) NULL)
4675  {
4676  status=MagickFalse;
4677  break;
4678  }
4679  if ((traits & BlendPixelTrait) == 0)
4680  for (i=0; i < 16; i++)
4681  {
4682  alpha[i]=1.0;
4683  pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
4684  }
4685  else
4686  for (i=0; i < 16; i++)
4687  {
4688  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4689  GetPixelChannels(image));
4690  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4691  }
4692  CatromWeights((double) (x-x_offset),&cx);
4693  CatromWeights((double) (y-y_offset),&cy);
4694  gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
4695  PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4696  alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4697  alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4698  alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4699  cx[2]*alpha[14]+cx[3]*alpha[15])));
4700  *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
4701  cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
4702  pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
4703  cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
4704  pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
4705  break;
4706  }
4708  {
4709  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4710  if (p == (const Quantum *) NULL)
4711  {
4712  status=MagickFalse;
4713  break;
4714  }
4715  *pixel=(double) GetPixelChannel(image,channel,p);
4716  break;
4717  }
4719  {
4720  x_offset=(ssize_t) floor(x+0.5);
4721  y_offset=(ssize_t) floor(y+0.5);
4722  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4723  if (p == (const Quantum *) NULL)
4724  {
4725  status=MagickFalse;
4726  break;
4727  }
4728  *pixel=(double) GetPixelChannel(image,channel,p);
4729  break;
4730  }
4731  case MeshInterpolatePixel:
4732  {
4733  PointInfo
4734  delta,
4735  luminance;
4736 
4737  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4738  if (p == (const Quantum *) NULL)
4739  {
4740  status=MagickFalse;
4741  break;
4742  }
4743  if ((traits & BlendPixelTrait) == 0)
4744  for (i=0; i < 4; i++)
4745  {
4746  alpha[i]=1.0;
4747  pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
4748  }
4749  else
4750  for (i=0; i < 4; i++)
4751  {
4752  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4753  GetPixelChannels(image));
4754  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4755  }
4756  delta.x=x-x_offset;
4757  delta.y=y-y_offset;
4758  luminance.x=GetPixelLuma(image,p)-(double)
4759  GetPixelLuma(image,p+3*GetPixelChannels(image));
4760  luminance.y=GetPixelLuma(image,p+GetPixelChannels(image))-(double)
4761  GetPixelLuma(image,p+2*GetPixelChannels(image));
4762  if (fabs(luminance.x) < fabs(luminance.y))
4763  {
4764  /*
4765  Diagonal 0-3 NW-SE.
4766  */
4767  if (delta.x <= delta.y)
4768  {
4769  /*
4770  Bottom-left triangle (pixel: 2, diagonal: 0-3).
4771  */
4772  delta.y=1.0-delta.y;
4773  gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4774  gamma=PerceptibleReciprocal(gamma);
4775  *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
4776  pixels[0]);
4777  }
4778  else
4779  {
4780  /*
4781  Top-right triangle (pixel: 1, diagonal: 0-3).
4782  */
4783  delta.x=1.0-delta.x;
4784  gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4785  gamma=PerceptibleReciprocal(gamma);
4786  *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
4787  pixels[3]);
4788  }
4789  }
4790  else
4791  {
4792  /*
4793  Diagonal 1-2 NE-SW.
4794  */
4795  if (delta.x <= (1.0-delta.y))
4796  {
4797  /*
4798  Top-left triangle (pixel: 0, diagonal: 1-2).
4799  */
4800  gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4801  gamma=PerceptibleReciprocal(gamma);
4802  *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
4803  pixels[2]);
4804  }
4805  else
4806  {
4807  /*
4808  Bottom-right triangle (pixel: 3, diagonal: 1-2).
4809  */
4810  delta.x=1.0-delta.x;
4811  delta.y=1.0-delta.y;
4812  gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4813  gamma=PerceptibleReciprocal(gamma);
4814  *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
4815  pixels[1]);
4816  }
4817  }
4818  break;
4819  }
4821  {
4822  double
4823  cx[4],
4824  cy[4];
4825 
4826  p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4827  exception);
4828  if (p == (const Quantum *) NULL)
4829  {
4830  status=MagickFalse;
4831  break;
4832  }
4833  if ((traits & BlendPixelTrait) == 0)
4834  for (i=0; i < 16; i++)
4835  {
4836  alpha[i]=1.0;
4837  pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
4838  }
4839  else
4840  for (i=0; i < 16; i++)
4841  {
4842  alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4843  GetPixelChannels(image));
4844  pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4845  }
4846  SplineWeights((double) (x-x_offset),&cx);
4847  SplineWeights((double) (y-y_offset),&cy);
4848  gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
4849  PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4850  alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4851  alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4852  alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4853  cx[2]*alpha[14]+cx[3]*alpha[15])));
4854  *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
4855  cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
4856  pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
4857  cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
4858  pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
4859  break;
4860  }
4861  }
4862  return(status);
4863 }
4864 
4865 /*
4866 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4867 % %
4868 % %
4869 % %
4870 % I n t e r p o l a t e P i x e l C h a n n e l s %
4871 % %
4872 % %
4873 % %
4874 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4875 %
4876 % InterpolatePixelChannels() applies a pixel interpolation method between a
4877 % floating point coordinate and the pixels surrounding that coordinate. No
4878 % pixel area resampling, or scaling of the result is performed.
4879 %
4880 % Interpolation is restricted to just the current channel setting of the
4881 % destination image into which the color is to be stored
4882 %
4883 % The format of the InterpolatePixelChannels method is:
4884 %
4885 % MagickBooleanType InterpolatePixelChannels(const Image *source,
4886 % const CacheView *source_view,const Image *destination,
4887 % const PixelInterpolateMethod method,const double x,const double y,
4888 % Quantum *pixel,ExceptionInfo *exception)
4889 %
4890 % A description of each parameter follows:
4891 %
4892 % o source: the source.
4893 %
4894 % o source_view: the source view.
4895 %
4896 % o destination: the destination image, for the interpolated color
4897 %
4898 % o method: the pixel color interpolation method.
4899 %
4900 % o x,y: A double representing the current (x,y) position of the pixel.
4901 %
4902 % o pixel: return the interpolated pixel here.
4903 %
4904 % o exception: return any errors or warnings in this structure.
4905 %
4906 */
4908  const CacheView_ *source_view,const Image *destination,
4909  const PixelInterpolateMethod method,const double x,const double y,
4910  Quantum *pixel,ExceptionInfo *exception)
4911 {
4913  status;
4914 
4915  double
4916  alpha[16],
4917  gamma,
4918  pixels[16];
4919 
4920  register const Quantum
4921  *p;
4922 
4923  register ssize_t
4924  i;
4925 
4926  ssize_t
4927  x_offset,
4928  y_offset;
4929 
4931  interpolate;
4932 
4933  assert(source != (Image *) NULL);
4934  assert(source->signature == MagickCoreSignature);
4935  assert(source_view != (CacheView *) NULL);
4936  status=MagickTrue;
4937  x_offset=(ssize_t) floor(x);
4938  y_offset=(ssize_t) floor(y);
4939  interpolate=method;
4940  if (interpolate == UndefinedInterpolatePixel)
4941  interpolate=source->interpolate;
4942  switch (interpolate)
4943  {
4944  case AverageInterpolatePixel: /* nearest 4 neighbours */
4945  case Average9InterpolatePixel: /* nearest 9 neighbours */
4946  case Average16InterpolatePixel: /* nearest 16 neighbours */
4947  {
4948  ssize_t
4949  count;
4950 
4951  count=2; /* size of the area to average - default nearest 4 */
4952  if (interpolate == Average9InterpolatePixel)
4953  {
4954  count=3;
4955  x_offset=(ssize_t) (floor(x+0.5)-1);
4956  y_offset=(ssize_t) (floor(y+0.5)-1);
4957  }
4958  else
4959  if (interpolate == Average16InterpolatePixel)
4960  {
4961  count=4;
4962  x_offset--;
4963  y_offset--;
4964  }
4965  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,(size_t) count,
4966  (size_t) count,exception);
4967  if (p == (const Quantum *) NULL)
4968  {
4969  status=MagickFalse;
4970  break;
4971  }
4972  count*=count; /* Number of pixels to average */
4973  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4974  {
4975  double
4976  sum;
4977 
4978  register ssize_t
4979  j;
4980 
4981  PixelChannel channel = GetPixelChannelChannel(source,i);
4982  PixelTrait traits = GetPixelChannelTraits(source,channel);
4983  PixelTrait destination_traits=GetPixelChannelTraits(destination,
4984  channel);
4985  if ((traits == UndefinedPixelTrait) ||
4986  (destination_traits == UndefinedPixelTrait))
4987  continue;
4988  for (j=0; j < (ssize_t) count; j++)
4989  pixels[j]=(double) p[j*GetPixelChannels(source)+i];
4990  sum=0.0;
4991  if ((traits & BlendPixelTrait) == 0)
4992  {
4993  for (j=0; j < (ssize_t) count; j++)
4994  sum+=pixels[j];
4995  sum/=count;
4996  SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
4997  continue;
4998  }
4999  for (j=0; j < (ssize_t) count; j++)
5000  {
5001  alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
5002  GetPixelChannels(source));
5003  pixels[j]*=alpha[j];
5004  gamma=PerceptibleReciprocal(alpha[j]);
5005  sum+=gamma*pixels[j];
5006  }
5007  sum/=count;
5008  SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
5009  }
5010  break;
5011  }
5013  default:
5014  {
5015  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
5016  if (p == (const Quantum *) NULL)
5017  {
5018  status=MagickFalse;
5019  break;
5020  }
5021  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5022  {
5023  PointInfo
5024  delta,
5025  epsilon;
5026 
5027  PixelChannel channel = GetPixelChannelChannel(source,i);
5028  PixelTrait traits = GetPixelChannelTraits(source,channel);
5029  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5030  channel);
5031  if ((traits == UndefinedPixelTrait) ||
5032  (destination_traits == UndefinedPixelTrait))
5033  continue;
5034  delta.x=x-x_offset;
5035  delta.y=y-y_offset;
5036  epsilon.x=1.0-delta.x;
5037  epsilon.y=1.0-delta.y;
5038  pixels[0]=(double) p[i];
5039  pixels[1]=(double) p[GetPixelChannels(source)+i];
5040  pixels[2]=(double) p[2*GetPixelChannels(source)+i];
5041  pixels[3]=(double) p[3*GetPixelChannels(source)+i];
5042  if ((traits & BlendPixelTrait) == 0)
5043  {
5044  gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
5045  gamma=PerceptibleReciprocal(gamma);
5046  SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
5047  (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*
5048  pixels[2]+delta.x*pixels[3]))),pixel);
5049  continue;
5050  }
5051  alpha[0]=QuantumScale*GetPixelAlpha(source,p);
5052  alpha[1]=QuantumScale*GetPixelAlpha(source,p+GetPixelChannels(source));
5053  alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
5054  GetPixelChannels(source));
5055  alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
5056  GetPixelChannels(source));
5057  pixels[0]*=alpha[0];
5058  pixels[1]*=alpha[1];
5059  pixels[2]*=alpha[2];
5060  pixels[3]*=alpha[3];
5061  gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
5062  (epsilon.x*alpha[2]+delta.x*alpha[3])));
5063  gamma=PerceptibleReciprocal(gamma);
5064  SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
5065  (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+
5066  delta.x*pixels[3]))),pixel);
5067  }
5068  break;
5069  }
5070  case BlendInterpolatePixel:
5071  {
5072  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
5073  if (p == (const Quantum *) NULL)
5074  {
5075  status=MagickFalse;
5076  break;
5077  }
5078  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5079  {
5080  register ssize_t
5081  j;
5082 
5083  PixelChannel channel = GetPixelChannelChannel(source,i);
5084  PixelTrait traits = GetPixelChannelTraits(source,channel);
5085  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5086  channel);
5087  if ((traits == UndefinedPixelTrait) ||
5088  (destination_traits == UndefinedPixelTrait))
5089  continue;
5090  if (source->alpha_trait != BlendPixelTrait)
5091  for (j=0; j < 4; j++)
5092  {
5093  alpha[j]=1.0;
5094  pixels[j]=(double) p[j*GetPixelChannels(source)+i];
5095  }
5096  else
5097  for (j=0; j < 4; j++)
5098  {
5099  alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
5100  GetPixelChannels(source));
5101  pixels[j]=(double) p[j*GetPixelChannels(source)+i];
5102  if (channel != AlphaPixelChannel)
5103  pixels[j]*=alpha[j];
5104  }
5105  gamma=1.0; /* number of pixels blended together (its variable) */
5106  for (j=0; j <= 1L; j++)
5107  {
5108  if ((y-y_offset) >= 0.75)
5109  {
5110  alpha[j]=alpha[j+2]; /* take right pixels */
5111  pixels[j]=pixels[j+2];
5112  }
5113  else
5114  if ((y-y_offset) > 0.25)
5115  {
5116  gamma=2.0; /* blend both pixels in row */
5117  alpha[j]+=alpha[j+2]; /* add up alpha weights */
5118  pixels[j]+=pixels[j+2];
5119  }
5120  }
5121  if ((x-x_offset) >= 0.75)
5122  {
5123  alpha[0]=alpha[1]; /* take bottom row blend */
5124  pixels[0]=pixels[1];
5125  }
5126  else
5127  if ((x-x_offset) > 0.25)
5128  {
5129  gamma*=2.0; /* blend both rows */
5130  alpha[0]+=alpha[1]; /* add up alpha weights */
5131  pixels[0]+=pixels[1];
5132  }
5133  if (channel != AlphaPixelChannel)
5134  gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
5135  else
5136  gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
5137  SetPixelChannel(destination,channel,ClampToQuantum(gamma*pixels[0]),
5138  pixel);
5139  }
5140  break;
5141  }
5143  {
5144  double
5145  cx[4],
5146  cy[4];
5147 
5148  p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
5149  exception);
5150  if (p == (const Quantum *) NULL)
5151  {
5152  status=MagickFalse;
5153  break;
5154  }
5155  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5156  {
5157  register ssize_t
5158  j;
5159 
5160  PixelChannel channel = GetPixelChannelChannel(source,i);
5161  PixelTrait traits = GetPixelChannelTraits(source,channel);
5162  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5163  channel);
5164  if ((traits == UndefinedPixelTrait) ||
5165  (destination_traits == UndefinedPixelTrait))
5166  continue;
5167  if ((traits & BlendPixelTrait) == 0)
5168  for (j=0; j < 16; j++)
5169  {
5170  alpha[j]=1.0;
5171  pixels[j]=(double) p[j*GetPixelChannels(source)+i];
5172  }
5173  else
5174  for (j=0; j < 16; j++)
5175  {
5176  alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
5177  GetPixelChannels(source));
5178  pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
5179  }
5180  CatromWeights((double) (x-x_offset),&cx);
5181  CatromWeights((double) (y-y_offset),&cy);
5182  gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
5183  PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
5184  alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
5185  alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
5186  alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
5187  cx[2]*alpha[14]+cx[3]*alpha[15])));
5188  SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
5189  pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
5190  (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
5191  cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
5192  pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
5193  pixels[14]+cx[3]*pixels[15]))),pixel);
5194  }
5195  break;
5196  }
5198  {
5199  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
5200  if (p == (const Quantum *) NULL)
5201  {
5202  status=MagickFalse;
5203  break;
5204  }
5205  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5206  {
5207  PixelChannel channel = GetPixelChannelChannel(source,i);
5208  PixelTrait traits = GetPixelChannelTraits(source,channel);
5209  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5210  channel);
5211  if ((traits == UndefinedPixelTrait) ||
5212  (destination_traits == UndefinedPixelTrait))
5213  continue;
5214  SetPixelChannel(destination,channel,p[i],pixel);
5215  }
5216  break;
5217  }
5219  {
5220  x_offset=(ssize_t) floor(x+0.5);
5221  y_offset=(ssize_t) floor(y+0.5);
5222  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
5223  if (p == (const Quantum *) NULL)
5224  {
5225  status=MagickFalse;
5226  break;
5227  }
5228  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5229  {
5230  PixelChannel channel = GetPixelChannelChannel(source,i);
5231  PixelTrait traits = GetPixelChannelTraits(source,channel);
5232  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5233  channel);
5234  if ((traits == UndefinedPixelTrait) ||
5235  (destination_traits == UndefinedPixelTrait))
5236  continue;
5237  SetPixelChannel(destination,channel,p[i],pixel);
5238  }
5239  break;
5240  }
5241  case MeshInterpolatePixel:
5242  {
5243  p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
5244  if (p == (const Quantum *) NULL)
5245  {
5246  status=MagickFalse;
5247  break;
5248  }
5249  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5250  {
5251  PointInfo
5252  delta,
5253  luminance;
5254 
5255  PixelChannel channel = GetPixelChannelChannel(source,i);
5256  PixelTrait traits = GetPixelChannelTraits(source,channel);
5257  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5258  channel);
5259  if ((traits == UndefinedPixelTrait) ||
5260  (destination_traits == UndefinedPixelTrait))
5261  continue;
5262  pixels[0]=(double) p[i];
5263  pixels[1]=(double) p[GetPixelChannels(source)+i];
5264  pixels[2]=(double) p[2*GetPixelChannels(source)+i];
5265  pixels[3]=(double) p[3*GetPixelChannels(source)+i];
5266  if ((traits & BlendPixelTrait) == 0)
5267  {
5268  alpha[0]=1.0;
5269  alpha[1]=1.0;
5270  alpha[2]=1.0;
5271  alpha[3]=1.0;
5272  }
5273  else
5274  {
5275  alpha[0]=QuantumScale*GetPixelAlpha(source,p);
5276  alpha[1]=QuantumScale*GetPixelAlpha(source,p+
5277  GetPixelChannels(source));
5278  alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
5279  GetPixelChannels(source));
5280  alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
5281  GetPixelChannels(source));
5282  }
5283  delta.x=x-x_offset;
5284  delta.y=y-y_offset;
5285  luminance.x=fabs((double) (GetPixelLuma(source,p)-
5286  GetPixelLuma(source,p+3*GetPixelChannels(source))));
5287  luminance.y=fabs((double) (GetPixelLuma(source,p+
5288  GetPixelChannels(source))-GetPixelLuma(source,p+2*
5289  GetPixelChannels(source))));
5290  if (luminance.x < luminance.y)
5291  {
5292  /*
5293  Diagonal 0-3 NW-SE.
5294  */
5295  if (delta.x <= delta.y)
5296  {
5297  /*
5298  Bottom-left triangle (pixel: 2, diagonal: 0-3).
5299  */
5300  delta.y=1.0-delta.y;
5301  gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
5302  gamma=PerceptibleReciprocal(gamma);
5303  SetPixelChannel(destination,channel,ClampToQuantum(gamma*
5304  MeshInterpolate(&delta,pixels[2],pixels[3],pixels[0])),pixel);
5305  }
5306  else
5307  {
5308  /*
5309  Top-right triangle (pixel: 1, diagonal: 0-3).
5310  */
5311  delta.x=1.0-delta.x;
5312  gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
5313  gamma=PerceptibleReciprocal(gamma);
5314  SetPixelChannel(destination,channel,ClampToQuantum(gamma*
5315  MeshInterpolate(&delta,pixels[1],pixels[0],pixels[3])),pixel);
5316  }
5317  }
5318  else
5319  {
5320  /*
5321  Diagonal 1-2 NE-SW.
5322  */
5323  if (delta.x <= (1.0-delta.y))
5324  {
5325  /*
5326  Top-left triangle (pixel: 0, diagonal: 1-2).
5327  */
5328  gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
5329  gamma=PerceptibleReciprocal(gamma);
5330  SetPixelChannel(destination,channel,ClampToQuantum(gamma*
5331  MeshInterpolate(&delta,pixels[0],pixels[1],pixels[2])),pixel);
5332  }
5333  else
5334  {
5335  /*
5336  Bottom-right triangle (pixel: 3, diagonal: 1-2).
5337  */
5338  delta.x=1.0-delta.x;
5339  delta.y=1.0-delta.y;
5340  gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
5341  gamma=PerceptibleReciprocal(gamma);
5342  SetPixelChannel(destination,channel,ClampToQuantum(gamma*
5343  MeshInterpolate(&delta,pixels[3],pixels[2],pixels[1])),pixel);
5344  }
5345  }
5346  }
5347  break;
5348  }
5350  {
5351  double
5352  cx[4],
5353  cy[4];
5354 
5355  p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
5356  exception);
5357  if (p == (const Quantum *) NULL)
5358  {
5359  status=MagickFalse;
5360  break;
5361  }
5362  for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
5363  {
5364  register ssize_t
5365  j;
5366 
5367  PixelChannel channel = GetPixelChannelChannel(source,i);
5368  PixelTrait traits = GetPixelChannelTraits(source,channel);
5369  PixelTrait destination_traits=GetPixelChannelTraits(destination,
5370  channel);
5371  if ((traits == UndefinedPixelTrait) ||
5372  (destination_traits == UndefinedPixelTrait))
5373  continue;
5374  if ((traits & BlendPixelTrait) == 0)
5375  for (j=0; j < 16; j++)
5376  {
5377  alpha[j]=1.0;
5378  pixels[j]=(double) p[j*GetPixelChannels(source)+i];
5379  }
5380  else
5381  for (j=0; j < 16; j++)
5382  {
5383  alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
5384  GetPixelChannels(source));
5385  pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
5386  }
5387  SplineWeights((double) (x-x_offset),&cx);
5388  SplineWeights((double) (y-y_offset),&cy);
5389  gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
5390  PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
5391  alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
5392  alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
5393  alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
5394  cx[2]*alpha[14]+cx[3]*alpha[15])));
5395  SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
5396  pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
5397  (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
5398  cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
5399  pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
5400  pixels[14]+cx[3]*pixels[15]))),pixel);
5401  }
5402  break;
5403  }
5404  }
5405  return(status);
5406 }
5407 
5408 /*
5409 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5410 % %
5411 % %
5412 % %
5413 % I n t e r p o l a t e P i x e l I n f o %
5414 % %
5415 % %
5416 % %
5417 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5418 %
5419 % InterpolatePixelInfo() applies a pixel interpolation method between a
5420 % floating point coordinate and the pixels surrounding that coordinate. No
5421 % pixel area resampling, or scaling of the result is performed.
5422 %
5423 % Interpolation is restricted to just RGBKA channels.
5424 %
5425 % The format of the InterpolatePixelInfo method is:
5426 %
5427 % MagickBooleanType InterpolatePixelInfo(const Image *image,
5428 % const CacheView *image_view,const PixelInterpolateMethod method,
5429 % const double x,const double y,PixelInfo *pixel,
5430 % ExceptionInfo *exception)
5431 %
5432 % A description of each parameter follows:
5433 %
5434 % o image: the image.
5435 %
5436 % o image_view: the image view.
5437 %
5438 % o method: the pixel color interpolation method.
5439 %
5440 % o x,y: A double representing the current (x,y) position of the pixel.
5441 %
5442 % o pixel: return the interpolated pixel here.
5443 %
5444 % o exception: return any errors or warnings in this structure.
5445 %
5446 */
5447 
5448 static inline void AlphaBlendPixelInfo(const Image *image,
5449  const Quantum *pixel,PixelInfo *pixel_info,double *alpha)
5450 {
5451  if (image->alpha_trait == UndefinedPixelTrait)
5452  {
5453  *alpha=1.0;
5454  pixel_info->red=(double) GetPixelRed(image,pixel);
5455  pixel_info->green=(double) GetPixelGreen(image,pixel);
5456  pixel_info->blue=(double) GetPixelBlue(image,pixel);
5457  pixel_info->black=0.0;
5458  if (image->colorspace == CMYKColorspace)
5459  pixel_info->black=(double) GetPixelBlack(image,pixel);
5460  pixel_info->alpha=(double) GetPixelAlpha(image,pixel);
5461  return;
5462  }
5463  *alpha=QuantumScale*GetPixelAlpha(image,pixel);
5464  pixel_info->red=(*alpha*GetPixelRed(image,pixel));
5465  pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
5466  pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
5467  pixel_info->black=0.0;
5468  if (image->colorspace == CMYKColorspace)
5469  pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
5470  pixel_info->alpha=(double) GetPixelAlpha(image,pixel);
5471 }
5472 
5474  const CacheView_ *image_view,const PixelInterpolateMethod method,
5475  const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
5476 {
5478  status;
5479 
5480  double
5481  alpha[16],
5482  gamma;
5483 
5484  PixelInfo
5485  pixels[16];
5486 
5487  register const Quantum
5488  *p;
5489 
5490  register ssize_t
5491  i;
5492 
5493  ssize_t
5494  x_offset,
5495  y_offset;
5496 
5498  interpolate;
5499 
5500  assert(image != (Image *) NULL);
5501  assert(image->signature == MagickCoreSignature);
5502  assert(image_view != (CacheView *) NULL);
5503  status=MagickTrue;
5504  x_offset=(ssize_t) floor(x);
5505  y_offset=(ssize_t) floor(y);
5506  interpolate=method;
5507  if (interpolate == UndefinedInterpolatePixel)
5508  interpolate=image->interpolate;
5509  GetPixelInfoPixel(image,(const Quantum *) NULL,pixel);
5510  (void) memset(&pixels,0,sizeof(pixels));
5511  switch (interpolate)
5512  {
5513  case AverageInterpolatePixel: /* nearest 4 neighbours */
5514  case Average9InterpolatePixel: /* nearest 9 neighbours */
5515  case Average16InterpolatePixel: /* nearest 16 neighbours */
5516  {
5517  ssize_t
5518  count;
5519 
5520  count=2; /* size of the area to average - default nearest 4 */
5521  if (interpolate == Average9InterpolatePixel)
5522  {
5523  count=3;
5524  x_offset=(ssize_t) (floor(x+0.5)-1);
5525  y_offset=(ssize_t) (floor(y+0.5)-1);
5526  }
5527  else if (interpolate == Average16InterpolatePixel)
5528  {
5529  count=4;
5530  x_offset--;
5531  y_offset--;
5532  }
5533  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,
5534  (size_t) count,exception);
5535  if (p == (const Quantum *) NULL)
5536  {
5537  status=MagickFalse;
5538  break;
5539  }
5540  count*=count; /* number of pixels - square of size */
5541  for (i=0; i < (ssize_t) count; i++)
5542  {
5543  AlphaBlendPixelInfo(image,p,pixels,alpha);
5544  gamma=PerceptibleReciprocal(alpha[0]);
5545  pixel->red+=gamma*pixels[0].red;
5546  pixel->green+=gamma*pixels[0].green;
5547  pixel->blue+=gamma*pixels[0].blue;
5548  pixel->black+=gamma*pixels[0].black;
5549  pixel->alpha+=pixels[0].alpha;
5550  p += GetPixelChannels(image);
5551  }
5552  gamma=1.0/count; /* average weighting of each pixel in area */
5553  pixel->red*=gamma;
5554  pixel->green*=gamma;
5555  pixel->blue*=gamma;
5556  pixel->black*=gamma;
5557  pixel->alpha*=gamma;
5558  break;
5559  }
5561  {
5562  *pixel=image->background_color; /* Copy PixelInfo Structure */
5563  break;
5564  }
5566  default:
5567  {
5568  PointInfo
5569  delta,
5570  epsilon;
5571 
5572  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
5573  if (p == (const Quantum *) NULL)
5574  {
5575  status=MagickFalse;
5576  break;
5577  }
5578  for (i=0; i < 4L; i++)
5579  AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
5580  delta.x=x-x_offset;
5581  delta.y=y-y_offset;
5582  epsilon.x=1.0-delta.x;
5583  epsilon.y=1.0-delta.y;
5584  gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
5585  (epsilon.x*alpha[2]+delta.x*alpha[3])));
5586  gamma=PerceptibleReciprocal(gamma);
5587  pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
5588  pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
5589  pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
5590  pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
5591  pixels[3].green));
5592  pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
5593  pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
5594  pixels[3].blue));
5595  if (image->colorspace == CMYKColorspace)
5596  pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
5597  pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
5598  pixels[3].black));
5599  gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
5600  gamma=PerceptibleReciprocal(gamma);
5601  pixel->alpha=gamma*(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
5602  pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
5603  pixels[3].alpha));
5604  break;
5605  }
5606  case BlendInterpolatePixel:
5607  {
5608  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
5609  if (p == (const Quantum *) NULL)
5610  {
5611  status=MagickFalse;
5612  break;
5613  }
5614