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