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