source: ImageMagick/branches/ImageMagick-6/magick/pixel.c @ 8127

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