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