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