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