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