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