00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #include "magick/studio.h"
00044 #include "magick/property.h"
00045 #include "magick/blob.h"
00046 #include "magick/blob-private.h"
00047 #include "magick/cache.h"
00048 #include "magick/cache-view.h"
00049 #include "magick/client.h"
00050 #include "magick/color.h"
00051 #include "magick/color-private.h"
00052 #include "magick/colorspace.h"
00053 #include "magick/composite.h"
00054 #include "magick/composite-private.h"
00055 #include "magick/constitute.h"
00056 #include "magick/deprecate.h"
00057 #include "magick/draw.h"
00058 #include "magick/draw-private.h"
00059 #include "magick/effect.h"
00060 #include "magick/exception.h"
00061 #include "magick/exception-private.h"
00062 #include "magick/geometry.h"
00063 #include "magick/identify.h"
00064 #include "magick/image.h"
00065 #include "magick/image-private.h"
00066 #include "magick/list.h"
00067 #include "magick/log.h"
00068 #include "magick/memory_.h"
00069 #include "magick/magick.h"
00070 #include "magick/monitor.h"
00071 #include "magick/monitor-private.h"
00072 #include "magick/paint.h"
00073 #include "magick/pixel.h"
00074 #include "magick/pixel-private.h"
00075 #include "magick/quantize.h"
00076 #include "magick/random_.h"
00077 #include "magick/resource_.h"
00078 #include "magick/semaphore.h"
00079 #include "magick/segment.h"
00080 #include "magick/splay-tree.h"
00081 #include "magick/string_.h"
00082 #include "magick/threshold.h"
00083 #include "magick/transform.h"
00084 #include "magick/utility.h"
00085
00086 #if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
00087
00088
00089
00090 static MonitorHandler
00091 monitor_handler = (MonitorHandler) NULL;
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116 MagickExport const IndexPacket *AcquireCacheViewIndexes(
00117 const ViewInfo *cache_view)
00118 {
00119 return(GetCacheViewVirtualIndexQueue(cache_view));
00120 }
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153 MagickExport const PixelPacket *AcquireCacheViewPixels(
00154 const ViewInfo *cache_view,const long x,const long y,
00155 const unsigned long columns,const unsigned long rows,ExceptionInfo *exception)
00156 {
00157 return(GetCacheViewVirtualPixels(cache_view,x,y,columns,rows,exception));
00158 }
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208 MagickExport const PixelPacket *AcquireImagePixels(const Image *image,
00209 const long x,const long y,const unsigned long columns,
00210 const unsigned long rows,ExceptionInfo *exception)
00211 {
00212 return(GetVirtualPixels(image,x,y,columns,rows,exception));
00213 }
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242 MagickExport const IndexPacket *AcquireIndexes(const Image *image)
00243 {
00244 return(GetVirtualIndexQueue(image));
00245 }
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270 MagickExport void *AcquireMemory(const size_t size)
00271 {
00272 void
00273 *allocation;
00274
00275 assert(size != 0);
00276 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
00277 allocation=malloc(size);
00278 return(allocation);
00279 }
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312 MagickExport MagickBooleanType AcquireOneCacheViewPixel(
00313 const ViewInfo *cache_view,const long x,const long y,PixelPacket *pixel,
00314 ExceptionInfo *exception)
00315 {
00316 return(GetOneCacheViewVirtualPixel(cache_view,x,y,pixel,exception));
00317 }
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 MagickExport MagickBooleanType AcquireOneCacheViewVirtualPixel(
00355 const ViewInfo *cache_view,const VirtualPixelMethod virtual_pixel_method,
00356 const long x,const long y,PixelPacket *pixel,ExceptionInfo *exception)
00357 {
00358 MagickBooleanType
00359 status;
00360
00361 status=GetOneCacheViewVirtualMethodPixel(cache_view,virtual_pixel_method,
00362 x,y,pixel,exception);
00363 return(status);
00364 }
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395 MagickExport MagickPixelPacket AcquireOneMagickPixel(const Image *image,
00396 const long x,const long y,ExceptionInfo *exception)
00397 {
00398 MagickPixelPacket
00399 pixel;
00400
00401 (void) GetOneVirtualMagickPixel(image,x,y,&pixel,exception);
00402 return(pixel);
00403 }
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434 MagickExport PixelPacket AcquireOnePixel(const Image *image,const long x,
00435 const long y,ExceptionInfo *exception)
00436 {
00437 PixelPacket
00438 pixel;
00439
00440 (void) GetOneVirtualPixel(image,x,y,&pixel,exception);
00441 return(pixel);
00442 }
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477 MagickExport PixelPacket AcquireOneVirtualPixel(const Image *image,
00478 const VirtualPixelMethod virtual_pixel_method,const long x,const long y,
00479 ExceptionInfo *exception)
00480 {
00481 PixelPacket
00482 pixel;
00483
00484 (void) GetOneVirtualMethodPixel(image,virtual_pixel_method,x,y,&pixel,
00485 exception);
00486 return(pixel);
00487 }
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512 MagickExport const PixelPacket *AcquirePixels(const Image *image)
00513 {
00514 return(GetVirtualPixelQueue(image));
00515 }
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545 MagickExport MagickBooleanType AffinityImage(const QuantizeInfo *quantize_info,
00546 Image *image,const Image *affinity_image)
00547 {
00548 return(RemapImage(quantize_info,image,affinity_image));
00549 }
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579 MagickExport MagickBooleanType AffinityImages(const QuantizeInfo *quantize_info,
00580 Image *images,const Image *affinity_image)
00581 {
00582 return(RemapImages(quantize_info,images,affinity_image));
00583 }
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610 MagickExport Image *AllocateImage(const ImageInfo *image_info)
00611 {
00612 return(AcquireImage(image_info));
00613 }
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643 MagickExport MagickBooleanType AllocateImageColormap(Image *image,
00644 const unsigned long colors)
00645 {
00646 return(AcquireImageColormap(image,colors));
00647 }
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677 MagickExport void AllocateNextImage(const ImageInfo *image_info,Image *image)
00678 {
00679 AcquireNextImage(image_info,image);
00680 }
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705 MagickExport char *AllocateString(const char *source)
00706 {
00707 char
00708 *destination;
00709
00710 size_t
00711 length;
00712
00713 assert(source != (const char *) NULL);
00714 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
00715 length=strlen(source)+MaxTextExtent+1;
00716 destination=(char *) AcquireQuantumMemory(length,sizeof(*destination));
00717 if (destination == (char *) NULL)
00718 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
00719 *destination='\0';
00720 if (source != (char *) NULL)
00721 (void) CopyMagickString(destination,source,length);
00722 return(destination);
00723 }
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752 MagickExport unsigned int ChannelImage(Image *image,const ChannelType channel)
00753 {
00754 return(SeparateImageChannel(image,channel));
00755 }
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782 MagickExport unsigned int ChannelThresholdImage(Image *image,const char *level)
00783 {
00784 MagickPixelPacket
00785 threshold;
00786
00787 GeometryInfo
00788 geometry_info;
00789
00790 unsigned int
00791 flags,
00792 status;
00793
00794 assert(image != (Image *) NULL);
00795 assert(image->signature == MagickSignature);
00796 if (image->debug != MagickFalse)
00797 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
00798 if (image->debug != MagickFalse)
00799 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
00800 if (level == (char *) NULL)
00801 return(MagickFalse);
00802 flags=ParseGeometry(level,&geometry_info);
00803 threshold.red=geometry_info.rho;
00804 threshold.green=geometry_info.sigma;
00805 if ((flags & SigmaValue) == 0)
00806 threshold.green=threshold.red;
00807 threshold.blue=geometry_info.xi;
00808 if ((flags & XiValue) == 0)
00809 threshold.blue=threshold.red;
00810 status=BilevelImageChannel(image,RedChannel,threshold.red);
00811 status|=BilevelImageChannel(image,GreenChannel,threshold.green);
00812 status|=BilevelImageChannel(image,BlueChannel,threshold.blue);
00813 return(status);
00814 }
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846 MagickExport MagickBooleanType ClipPathImage(Image *image,const char *pathname,
00847 const MagickBooleanType inside)
00848 {
00849 return(ClipImagePath(image,pathname,inside));
00850 }
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877 MagickExport MagickBooleanType CloneImageAttributes(Image *image,
00878 const Image *clone_image)
00879 {
00880 return(CloneImageProperties(image,clone_image));
00881 }
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912 MagickExport void *CloneMemory(void *destination,const void *source,
00913 const size_t size)
00914 {
00915 register const unsigned char
00916 *p;
00917
00918 register unsigned char
00919 *q;
00920
00921 register long
00922 i;
00923
00924 assert(destination != (void *) NULL);
00925 assert(source != (const void *) NULL);
00926 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
00927 p=(const unsigned char *) source;
00928 q=(unsigned char *) destination;
00929 if ((p <= q) || ((p+size) >= q))
00930 return(CopyMagickMemory(destination,source,size));
00931
00932
00933
00934 p+=size;
00935 q+=size;
00936 for (i=(long) (size-1); i >= 0; i--)
00937 *--q=(*--p);
00938 return(destination);
00939 }
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964 MagickExport ViewInfo *CloseCacheView(ViewInfo *view_info)
00965 {
00966 return(DestroyCacheView(view_info));
00967 }
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012 #define MaxStacksize (1UL << 15)
01013 #define PushSegmentStack(up,left,right,delta) \
01014 { \
01015 if (s >= (segment_stack+MaxStacksize)) \
01016 ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
01017 else \
01018 { \
01019 if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (long) image->rows)) \
01020 { \
01021 s->x1=(double) (left); \
01022 s->y1=(double) (up); \
01023 s->x2=(double) (right); \
01024 s->y2=(double) (delta); \
01025 s++; \
01026 } \
01027 } \
01028 }
01029
01030 MagickExport MagickBooleanType ColorFloodfillImage(Image *image,
01031 const DrawInfo *draw_info,const PixelPacket target,const long x_offset,
01032 const long y_offset,const PaintMethod method)
01033 {
01034 Image
01035 *floodplane_image;
01036
01037 long
01038 offset,
01039 start,
01040 x,
01041 x1,
01042 x2,
01043 y;
01044
01045 MagickBooleanType
01046 skip;
01047
01048 PixelPacket
01049 fill_color;
01050
01051 register SegmentInfo
01052 *s;
01053
01054 SegmentInfo
01055 *segment_stack;
01056
01057
01058
01059
01060 assert(image != (Image *) NULL);
01061 assert(image->signature == MagickSignature);
01062 if (image->debug != MagickFalse)
01063 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
01064 assert(draw_info != (DrawInfo *) NULL);
01065 assert(draw_info->signature == MagickSignature);
01066 if ((x_offset < 0) || (x_offset >= (long) image->columns))
01067 return(MagickFalse);
01068 if ((y_offset < 0) || (y_offset >= (long) image->rows))
01069 return(MagickFalse);
01070 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
01071 return(MagickFalse);
01072 if (image->matte == MagickFalse)
01073 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
01074 floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
01075 &image->exception);
01076 if (floodplane_image == (Image *) NULL)
01077 return(MagickFalse);
01078 (void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel);
01079
01080
01081
01082 segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
01083 sizeof(*segment_stack));
01084 if (segment_stack == (SegmentInfo *) NULL)
01085 {
01086 floodplane_image=DestroyImage(floodplane_image);
01087 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
01088 image->filename);
01089 }
01090
01091
01092
01093 x=x_offset;
01094 y=y_offset;
01095 start=0;
01096 s=segment_stack;
01097 PushSegmentStack(y,x,x,1);
01098 PushSegmentStack(y+1,x,x,-1);
01099 while (s > segment_stack)
01100 {
01101 register const PixelPacket
01102 *__restrict p;
01103
01104 register long
01105 x;
01106
01107 register PixelPacket
01108 *__restrict q;
01109
01110
01111
01112
01113 s--;
01114 x1=(long) s->x1;
01115 x2=(long) s->x2;
01116 offset=(long) s->y2;
01117 y=(long) s->y1+offset;
01118
01119
01120
01121 p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,&image->exception);
01122 q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,
01123 &image->exception);
01124 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
01125 break;
01126 p+=x1;
01127 q+=x1;
01128 for (x=x1; x >= 0; x--)
01129 {
01130 if (q->opacity == (Quantum) TransparentOpacity)
01131 break;
01132 if (method == FloodfillMethod)
01133 {
01134 if (IsColorSimilar(image,p,&target) == MagickFalse)
01135 break;
01136 }
01137 else
01138 if (IsColorSimilar(image,p,&target) != MagickFalse)
01139 break;
01140 q->opacity=(Quantum) TransparentOpacity;
01141 p--;
01142 q--;
01143 }
01144 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
01145 break;
01146 skip=x >= x1 ? MagickTrue : MagickFalse;
01147 if (skip == MagickFalse)
01148 {
01149 start=x+1;
01150 if (start < x1)
01151 PushSegmentStack(y,start,x1-1,-offset);
01152 x=x1+1;
01153 }
01154 do
01155 {
01156 if (skip == MagickFalse)
01157 {
01158 if (x < (long) image->columns)
01159 {
01160 p=GetVirtualPixels(image,x,y,image->columns-x,1,
01161 &image->exception);
01162 q=GetAuthenticPixels(floodplane_image,x,y,image->columns-x,1,
01163 &image->exception);
01164 if ((p == (const PixelPacket *) NULL) ||
01165 (q == (PixelPacket *) NULL))
01166 break;
01167 for ( ; x < (long) image->columns; x++)
01168 {
01169 if (q->opacity == (Quantum) TransparentOpacity)
01170 break;
01171 if (method == FloodfillMethod)
01172 {
01173 if (IsColorSimilar(image,p,&target) == MagickFalse)
01174 break;
01175 }
01176 else
01177 if (IsColorSimilar(image,p,&target) != MagickFalse)
01178 break;
01179 q->opacity=(Quantum) TransparentOpacity;
01180 p++;
01181 q++;
01182 }
01183 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
01184 break;
01185 }
01186 PushSegmentStack(y,start,x-1,offset);
01187 if (x > (x2+1))
01188 PushSegmentStack(y,x2+1,x-1,-offset);
01189 }
01190 skip=MagickFalse;
01191 x++;
01192 if (x <= x2)
01193 {
01194 p=GetVirtualPixels(image,x,y,(unsigned long) (x2-x+1),1,
01195 &image->exception);
01196 q=GetAuthenticPixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1,
01197 &image->exception);
01198 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
01199 break;
01200 for ( ; x <= x2; x++)
01201 {
01202 if (q->opacity == (Quantum) TransparentOpacity)
01203 break;
01204 if (method == FloodfillMethod)
01205 {
01206 if (IsColorSimilar(image,p,&target) != MagickFalse)
01207 break;
01208 }
01209 else
01210 if (IsColorSimilar(image,p,&target) == MagickFalse)
01211 break;
01212 p++;
01213 q++;
01214 }
01215 }
01216 start=x;
01217 } while (x <= x2);
01218 }
01219 for (y=0; y < (long) image->rows; y++)
01220 {
01221 register const PixelPacket
01222 *__restrict p;
01223
01224 register long
01225 x;
01226
01227 register PixelPacket
01228 *__restrict q;
01229
01230
01231
01232
01233 p=GetVirtualPixels(floodplane_image,0,y,image->columns,1,
01234 &image->exception);
01235 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
01236 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
01237 break;
01238 for (x=0; x < (long) image->columns; x++)
01239 {
01240 if (p->opacity != OpaqueOpacity)
01241 {
01242 (void) GetFillColor(draw_info,x,y,&fill_color);
01243 MagickCompositeOver(&fill_color,(MagickRealType) fill_color.opacity,q,
01244 (MagickRealType) q->opacity,q);
01245 }
01246 p++;
01247 q++;
01248 }
01249 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
01250 break;
01251 }
01252 segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
01253 floodplane_image=DestroyImage(floodplane_image);
01254 return(y == (long) image->rows ? MagickTrue : MagickFalse);
01255 }
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281 MagickExport MagickBooleanType DeleteImageAttribute(Image *image,
01282 const char *key)
01283 {
01284 return(DeleteImageProperty(image,key));
01285 }
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311 MagickExport unsigned int DeleteImageList(Image *images,const long offset)
01312 {
01313 register long
01314 i;
01315
01316 if (images->debug != MagickFalse)
01317 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
01318 while (GetPreviousImageInList(images) != (Image *) NULL)
01319 images=GetPreviousImageInList(images);
01320 for (i=0; i < offset; i++)
01321 {
01322 if (GetNextImageInList(images) == (Image *) NULL)
01323 return(MagickFalse);
01324 images=GetNextImageInList(images);
01325 }
01326 DeleteImageFromList(&images);
01327 return(MagickTrue);
01328 }
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354 MagickExport MagickBooleanType DeleteMagickRegistry(const long id)
01355 {
01356 char
01357 key[MaxTextExtent];
01358
01359 (void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
01360 return(DeleteImageRegistry(key));
01361 }
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381 MagickExport void DestroyMagickRegistry(void)
01382 {
01383 DestroyImageRegistry();
01384 }
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415 MagickExport MagickBooleanType DescribeImage(Image *image,FILE *file,
01416 const MagickBooleanType verbose)
01417 {
01418 return(IdentifyImage(image,file,verbose));
01419 }
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444 MagickExport void DestroyImageAttributes(Image *image)
01445 {
01446 assert(image != (Image *) NULL);
01447 assert(image->signature == MagickSignature);
01448 if (image->debug != MagickFalse)
01449 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
01450 if (image->attributes != (void *) NULL)
01451 image->attributes=(void *) DestroySplayTree((SplayTreeInfo *)
01452 image->attributes);
01453 }
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477 MagickExport void DestroyImages(Image *image)
01478 {
01479 if (image == (Image *) NULL)
01480 return;
01481 if (image->debug != MagickFalse)
01482 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.4.3");
01483 image=DestroyImageList(image);
01484 }
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504 MagickExport void DestroyMagick(void)
01505 {
01506 MagickCoreTerminus();
01507 }
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542
01543
01544
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561 MagickExport unsigned int DispatchImage(const Image *image,const long x_offset,
01562 const long y_offset,const unsigned long columns,const unsigned long rows,
01563 const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
01564 {
01565 unsigned int
01566 status;
01567
01568 if (image->debug != MagickFalse)
01569 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.6");
01570 status=ExportImagePixels(image,x_offset,y_offset,columns,rows,map,type,pixels,
01571 exception);
01572 return(status);
01573 }
01574
01575
01576
01577
01578
01579
01580
01581
01582
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604 static double GetSimilarityMetric(const Image *image,const Image *referemce,
01605 const long x_offset,const long y_offset,const double similarity_threshold,
01606 ExceptionInfo *exception)
01607 {
01608 long
01609 y;
01610
01611 double
01612 channels,
01613 normalized_similarity,
01614 similarity;
01615
01616 ViewInfo
01617 *image_view,
01618 *referemce_view;
01619
01620
01621
01622
01623 normalized_similarity=1.0;
01624 similarity=0.0;
01625 channels=3;
01626 if ((image->matte != MagickFalse) && (referemce->matte != MagickFalse))
01627 channels++;
01628 if ((image->colorspace == CMYKColorspace) &&
01629 (referemce->colorspace == CMYKColorspace))
01630 channels++;
01631 image_view=AcquireCacheView(image);
01632 referemce_view=AcquireCacheView(referemce);
01633 for (y=0; y < (long) referemce->rows; y++)
01634 {
01635 register const IndexPacket
01636 *indexes,
01637 *referemce_indexes;
01638
01639 register const PixelPacket
01640 *p,
01641 *q;
01642
01643 register long
01644 x;
01645
01646 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset+y,
01647 referemce->columns,1,exception);
01648 q=GetCacheViewVirtualPixels(referemce_view,0,y,referemce->columns,1,
01649 exception);
01650 if ((p == (const PixelPacket *) NULL) || (q == (const PixelPacket *) NULL))
01651 continue;
01652 indexes=GetCacheViewVirtualIndexQueue(image_view);
01653 referemce_indexes=GetCacheViewVirtualIndexQueue(referemce_view);
01654 for (x=0; x < (long) referemce->columns; x++)
01655 {
01656 MagickRealType
01657 pixel;
01658
01659 pixel=QuantumScale*(p->red-(double) q->red);
01660 similarity+=pixel*pixel;
01661 pixel=QuantumScale*(p->green-(double) q->green);
01662 similarity+=pixel*pixel;
01663 pixel=QuantumScale*(p->blue-(double) q->blue);
01664 similarity+=pixel*pixel;
01665 if ((image->matte != MagickFalse) && (referemce->matte != MagickFalse))
01666 {
01667 pixel=QuantumScale*(p->opacity-(double) q->opacity);
01668 similarity+=pixel*pixel;
01669 }
01670 if ((image->colorspace == CMYKColorspace) &&
01671 (referemce->colorspace == CMYKColorspace))
01672 {
01673 pixel=QuantumScale*(indexes[x]-(double) referemce_indexes[x]);
01674 similarity+=pixel*pixel;
01675 }
01676 p++;
01677 q++;
01678 }
01679 normalized_similarity=sqrt(similarity)/referemce->columns/referemce->rows/
01680 channels;
01681 if (normalized_similarity > similarity_threshold)
01682 break;
01683 }
01684 referemce_view=DestroyCacheView(referemce_view);
01685 image_view=DestroyCacheView(image_view);
01686 return(normalized_similarity);
01687 }
01688
01689 MagickExport Image *ExtractSubimageFromImage(Image *image,const Image *referemce,
01690 ExceptionInfo *exception)
01691 {
01692 long
01693 y;
01694
01695 double
01696 similarity_threshold;
01697
01698 RectangleInfo
01699 offset;
01700
01701
01702
01703
01704 if ((referemce->columns > image->columns) || (referemce->rows > image->rows))
01705 return((Image *) NULL);
01706 similarity_threshold=HUGE_VAL;
01707 SetGeometry(referemce,&offset);
01708 #if defined(MAGICKCORE_OPENMP_SUPPORT)
01709 #pragma omp parallel for schedule(dynamic,4)
01710 #endif
01711 for (y=0; y < (long) (image->rows-referemce->rows); y++)
01712 {
01713 double
01714 similarity;
01715
01716 register long
01717 x;
01718
01719 for (x=0; x < (long) (image->columns-referemce->columns); x++)
01720 {
01721 similarity=GetSimilarityMetric(image,referemce,x,y,similarity_threshold,
01722 exception);
01723 #if defined(MAGICKCORE_OPENMP_SUPPORT)
01724 #pragma omp critical (MagickCore_ExtractSubimageFromImage)
01725 #endif
01726 if (similarity < similarity_threshold)
01727 {
01728 similarity_threshold=similarity;
01729 offset.x=x;
01730 offset.y=y;
01731 }
01732 }
01733 }
01734 if (similarity_threshold > (QuantumScale*referemce->fuzz/100.0))
01735 return((Image *) NULL);
01736 return(CropImage(image,&offset,exception));
01737 }
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763 MagickExport Image *FlattenImages(Image *image,ExceptionInfo *exception)
01764 {
01765 return(MergeImageLayers(image,FlattenLayer,exception));
01766 }
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798 MagickExport MagickBooleanType FormatImageAttributeList(Image *image,
01799 const char *key,const char *format,va_list operands)
01800 {
01801 char
01802 value[MaxTextExtent];
01803
01804 int
01805 n;
01806
01807 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
01808 n=vsnprintf(value,MaxTextExtent,format,operands);
01809 #else
01810 n=vsprintf(value,format,operands);
01811 #endif
01812 if (n < 0)
01813 value[MaxTextExtent-1]='\0';
01814 return(SetImageAttribute(image,key,value));
01815 }
01816
01817 MagickExport MagickBooleanType FormatImageAttribute(Image *image,
01818 const char *key,const char *format,...)
01819 {
01820 MagickBooleanType
01821 status;
01822
01823 va_list
01824 operands;
01825
01826 va_start(operands,format);
01827 status=FormatImageAttributeList(image,key,format,operands);
01828 va_end(operands);
01829 return(status);
01830 }
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848
01849
01850
01851
01852
01853
01854
01855
01856
01857
01858
01859 MagickExport void FormatStringList(char *string,const char *format,
01860 va_list operands)
01861 {
01862 int
01863 n;
01864
01865 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
01866 #if defined(MAGICKCORE_HAVE_VSNPRINTF)
01867 n=vsnprintf(string,MaxTextExtent,format,operands);
01868 #else
01869 n=vsprintf(string,format,operands);
01870 #endif
01871 if (n < 0)
01872 string[MaxTextExtent-1]='\0';
01873 }
01874
01875 MagickExport void FormatString(char *string,const char *format,...)
01876 {
01877 va_list
01878 operands;
01879
01880 va_start(operands,format);
01881 FormatStringList(string,format,operands);
01882 va_end(operands);
01883 return;
01884 }
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913
01914 MagickExport unsigned int FuzzyColorMatch(const PixelPacket *p,
01915 const PixelPacket *q,const double fuzz)
01916 {
01917 MagickPixelPacket
01918 pixel;
01919
01920 register MagickRealType
01921 distance;
01922
01923 if ((fuzz == 0.0) && (p->red == q->red) && (p->green == q->green) &&
01924 (p->blue == q->blue))
01925 return(MagickTrue);
01926 pixel.red=p->red-(MagickRealType) q->red;
01927 distance=pixel.red*pixel.red;
01928 if (distance > (fuzz*fuzz))
01929 return(MagickFalse);
01930 pixel.green=p->green-(MagickRealType) q->green;
01931 distance+=pixel.green*pixel.green;
01932 if (distance > (fuzz*fuzz))
01933 return(MagickFalse);
01934 pixel.blue=p->blue-(MagickRealType) q->blue;
01935 distance+=pixel.blue*pixel.blue;
01936 if (distance > (fuzz*fuzz))
01937 return(MagickFalse);
01938 return(MagickTrue);
01939 }
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969
01970
01971 MagickExport MagickBooleanType FuzzyColorCompare(const Image *image,
01972 const PixelPacket *p,const PixelPacket *q)
01973 {
01974 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v6.2.5");
01975 return(IsColorSimilar(image,p,q));
01976 }
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002
02003
02004
02005
02006
02007
02008 MagickExport MagickBooleanType FuzzyOpacityCompare(const Image *image,
02009 const PixelPacket *p,const PixelPacket *q)
02010 {
02011 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v6.2.5");
02012 return(IsOpacitySimilar(image,p,q));
02013 }
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044 MagickExport void *GetConfigureBlob(const char *filename,char *path,
02045 size_t *length,ExceptionInfo *exception)
02046 {
02047 void
02048 *blob;
02049
02050 assert(filename != (const char *) NULL);
02051 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
02052 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
02053 assert(path != (char *) NULL);
02054 assert(length != (size_t *) NULL);
02055 assert(exception != (ExceptionInfo *) NULL);
02056 blob=(void *) NULL;
02057 (void) CopyMagickString(path,filename,MaxTextExtent);
02058 #if defined(MAGICKCORE_INSTALLED_SUPPORT)
02059 #if defined(MAGICKCORE_LIBRARY_PATH)
02060 if (blob == (void *) NULL)
02061 {
02062
02063
02064
02065 (void) FormatMagickString(path,MaxTextExtent,"%s%s",
02066 MAGICKCORE_LIBRARY_PATH,filename);
02067 if (IsPathAccessible(path) != MagickFalse)
02068 blob=FileToBlob(path,~0,length,exception);
02069 }
02070 #endif
02071 #if defined(__WINDOWS__) && !(defined(MAGICKCORE_CONFIGURE_PATH) || defined(MAGICKCORE_SHARE_CONFIGURE_PATH))
02072 if (blob == (void *) NULL)
02073 {
02074 char
02075 *key_value;
02076
02077
02078
02079
02080 key_value=NTRegistryKeyLookup("ConfigurePath");
02081 if (key_value != (char *) NULL)
02082 {
02083 (void) FormatMagickString(path,MaxTextExtent,"%s%s%s",key_value,
02084 DirectorySeparator,filename);
02085 if (IsPathAccessible(path) != MagickFalse)
02086 blob=FileToBlob(path,~0,length,exception);
02087 }
02088 }
02089 #endif
02090 #else
02091 if (blob == (void *) NULL)
02092 {
02093 char
02094 *home;
02095
02096 home=GetEnvironmentValue("MAGICK_HOME");
02097 if (home != (char *) NULL)
02098 {
02099
02100
02101
02102 #if !defined(MAGICKCORE_POSIX_SUPPORT)
02103 (void) FormatMagickString(path,MaxTextExtent,"%s%s%s",home,
02104 DirectorySeparator,filename);
02105 #else
02106 (void) FormatMagickString(path,MaxTextExtent,"%s/lib/%s/%s",home,
02107 MAGICKCORE_LIBRARY_RELATIVE_PATH,filename);
02108 #endif
02109 if (IsPathAccessible(path) != MagickFalse)
02110 blob=FileToBlob(path,~0,length,exception);
02111 home=DestroyString(home);
02112 }
02113 home=GetEnvironmentValue("HOME");
02114 if (home == (char *) NULL)
02115 home=GetEnvironmentValue("USERPROFILE");
02116 if (home != (char *) NULL)
02117 {
02118
02119
02120
02121 (void) FormatMagickString(path,MaxTextExtent,"%s%s.magick%s%s",home,
02122 DirectorySeparator,DirectorySeparator,filename);
02123 if ((IsPathAccessible(path) != MagickFalse) && (blob == (void *) NULL))
02124 blob=FileToBlob(path,~0,length,exception);
02125 home=DestroyString(home);
02126 }
02127 }
02128 if ((blob == (void *) NULL) && (*GetClientPath() != '\0'))
02129 {
02130 #if !defined(MAGICKCORE_POSIX_SUPPORT)
02131 (void) FormatMagickString(path,MaxTextExtent,"%s%s%s",GetClientPath(),
02132 DirectorySeparator,filename);
02133 #else
02134 char
02135 prefix[MaxTextExtent];
02136
02137
02138
02139
02140 (void) CopyMagickString(prefix,GetClientPath(),
02141 MaxTextExtent);
02142 ChopPathComponents(prefix,1);
02143 (void) FormatMagickString(path,MaxTextExtent,"%s/lib/%s/%s",prefix,
02144 MAGICKCORE_LIBRARY_RELATIVE_PATH,filename);
02145 #endif
02146 if (IsPathAccessible(path) != MagickFalse)
02147 blob=FileToBlob(path,~0,length,exception);
02148 }
02149
02150
02151
02152 if ((blob == (void *) NULL) && (IsPathAccessible(path) != MagickFalse))
02153 blob=FileToBlob(path,~0,length,exception);
02154 #if defined(__WINDOWS__)
02155
02156
02157
02158 if (blob == (void *) NULL)
02159 blob=NTResourceToBlob(filename);
02160 #endif
02161 #endif
02162 if (blob == (void *) NULL)
02163 (void) ThrowMagickException(exception,GetMagickModule(),ConfigureWarning,
02164 "UnableToOpenConfigureFile","`%s'",path);
02165 return(blob);
02166 }
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182
02183
02184
02185
02186
02187
02188
02189
02190
02191
02192
02193
02194
02195
02196 MagickExport PixelPacket *GetCacheView(ViewInfo *cache_view,const long x,
02197 const long y,const unsigned long columns,const unsigned long rows)
02198 {
02199 PixelPacket
02200 *pixels;
02201
02202 pixels=GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
02203 GetCacheViewException(cache_view));
02204 return(pixels);
02205 }
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230 MagickExport IndexPacket *GetCacheViewIndexes(ViewInfo *cache_view)
02231 {
02232 return(GetCacheViewAuthenticIndexQueue(cache_view));
02233 }
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263 MagickExport PixelPacket *GetCacheViewPixels(ViewInfo *cache_view,const long x,
02264 const long y,const unsigned long columns,const unsigned long rows)
02265 {
02266 PixelPacket
02267 *pixels;
02268
02269 pixels=GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
02270 GetCacheViewException(cache_view));
02271 return(pixels);
02272 }
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301
02302 static void *DestroyAttribute(void *attribute)
02303 {
02304 register ImageAttribute
02305 *p;
02306
02307 p=(ImageAttribute *) attribute;
02308 if (p->value != (char *) NULL)
02309 p->value=DestroyString(p->value);
02310 return(RelinquishMagickMemory(p));
02311 }
02312
02313 MagickExport const ImageAttribute *GetImageAttribute(const Image *image,
02314 const char *key)
02315 {
02316 const char
02317 *value;
02318
02319 ImageAttribute
02320 *attribute;
02321
02322 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v6.3.1");
02323 value=GetImageProperty(image,key);
02324 if (value == (const char *) NULL)
02325 return((const ImageAttribute *) NULL);
02326 if (image->attributes == (void *) NULL)
02327 ((Image *) image)->attributes=NewSplayTree(CompareSplayTreeString,
02328 RelinquishMagickMemory,DestroyAttribute);
02329 else
02330 {
02331 const ImageAttribute
02332 *attribute;
02333
02334 attribute=(const ImageAttribute *) GetValueFromSplayTree((SplayTreeInfo *)
02335 image->attributes,key);
02336 if (attribute != (const ImageAttribute *) NULL)
02337 return(attribute);
02338 }
02339 attribute=(ImageAttribute *) AcquireMagickMemory(sizeof(*attribute));
02340 if (attribute == (ImageAttribute *) NULL)
02341 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
02342 (void) ResetMagickMemory(attribute,0,sizeof(*attribute));
02343 attribute->key=ConstantString(key);
02344 attribute->value=ConstantString(value);
02345 (void) AddValueToSplayTree((SplayTreeInfo *) ((Image *) image)->attributes,
02346 attribute->key,attribute);
02347 return((const ImageAttribute *) attribute);
02348 }
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362
02363
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376 MagickExport const ImageAttribute *GetImageClippingPathAttribute(Image *image)
02377 {
02378 return(GetImageAttribute(image,"8BIM:1999,2998"));
02379 }
02380
02381
02382
02383
02384
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408
02409 MagickExport Image *GetImageFromMagickRegistry(const char *name,long *id,
02410 ExceptionInfo *exception)
02411 {
02412 *id=0L;
02413 return((Image *) GetImageRegistry(ImageRegistryType,name,exception));
02414 }
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446 MagickExport void *GetMagickRegistry(const long id,RegistryType *type,
02447 size_t *length,ExceptionInfo *exception)
02448 {
02449 char
02450 key[MaxTextExtent];
02451
02452 void
02453 *blob;
02454
02455 *type=UndefinedRegistryType;
02456 *length=0;
02457 (void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
02458 blob=(void *) GetImageRegistry(ImageRegistryType,key,exception);
02459 if (blob != (void *) NULL)
02460 return(blob);
02461 blob=(void *) GetImageRegistry(ImageInfoRegistryType,key,exception);
02462 if (blob != (void *) NULL)
02463 return(blob);
02464 return((void *) GetImageRegistry(UndefinedRegistryType,key,exception));
02465 }
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500 MagickExport int GetImageGeometry(Image *image,const char *geometry,
02501 const unsigned int size_to_fit,RectangleInfo *region_info)
02502 {
02503 if (image->debug != MagickFalse)
02504 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.4");
02505 if (size_to_fit != MagickFalse)
02506 return((int) ParseRegionGeometry(image,geometry,region_info,&image->exception));
02507 return((int) ParsePageGeometry(image,geometry,region_info,&image->exception));
02508 }
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537 MagickExport Image *GetImageList(const Image *images,const long offset,
02538 ExceptionInfo *exception)
02539 {
02540 Image
02541 *image;
02542
02543 if (images->debug != MagickFalse)
02544 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02545 image=CloneImage(GetImageFromList(images,(long) offset),0,0,MagickTrue,
02546 exception);
02547 return(image);
02548 }
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573 MagickExport long GetImageListIndex(const Image *images)
02574 {
02575 if (images->debug != MagickFalse)
02576 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02577 return(GetImageIndexInList(images));
02578 }
02579
02580
02581
02582
02583
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602 MagickExport unsigned long GetImageListSize(const Image *images)
02603 {
02604 if (images->debug != MagickFalse)
02605 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02606 return(GetImageListLength(images));
02607 }
02608
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652 MagickExport PixelPacket *GetImagePixels(Image *image,const long x,const long y,
02653 const unsigned long columns,const unsigned long rows)
02654 {
02655 return(GetAuthenticPixels(image,x,y,columns,rows,&image->exception));
02656 }
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682
02683
02684
02685 MagickExport IndexPacket *GetIndexes(const Image *image)
02686 {
02687 return(GetAuthenticIndexQueue(image));
02688 }
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
02720
02721
02722 MagickExport unsigned int GetMagickGeometry(const char *geometry,long *x,
02723 long *y,unsigned long *width,unsigned long *height)
02724 {
02725 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.3");
02726 return(ParseMetaGeometry(geometry,x,y,width,height));
02727 }
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751 MagickExport Image *GetNextImage(const Image *images)
02752 {
02753 if (images->debug != MagickFalse)
02754 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02755 return(GetNextImageInList(images));
02756 }
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770
02771
02772
02773
02774
02775
02776
02777
02778
02779
02780 MagickExport const ImageAttribute *GetNextImageAttribute(const Image *image)
02781 {
02782 const char
02783 *property;
02784
02785 property=GetNextImageProperty(image);
02786 if (property == (const char *) NULL)
02787 return((const ImageAttribute *) NULL);
02788 return(GetImageAttribute(image,property));
02789 }
02790
02791
02792
02793
02794
02795
02796
02797
02798
02799
02800
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813 MagickExport unsigned int GetNumberScenes(const Image *image)
02814 {
02815 if (image->debug != MagickFalse)
02816 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02817 return((unsigned int) GetImageListLength(image));
02818 }
02819
02820
02821
02822
02823
02824
02825
02826
02827
02828
02829
02830
02831
02832
02833
02834
02835
02836
02837
02838
02839
02840
02841
02842
02843
02844
02845 MagickExport PixelPacket GetOnePixel(Image *image,const long x,const long y)
02846 {
02847 PixelPacket
02848 pixel;
02849
02850 (void) GetOneAuthenticPixel(image,x,y,&pixel,&image->exception);
02851 return(pixel);
02852 }
02853
02854
02855
02856
02857
02858
02859
02860
02861
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879
02880 MagickExport PixelPacket *GetPixels(const Image *image)
02881 {
02882 return(GetAuthenticPixelQueue(image));
02883 }
02884
02885
02886
02887
02888
02889
02890
02891
02892
02893
02894
02895
02896
02897
02898
02899
02900
02901
02902
02903
02904
02905
02906
02907 MagickExport Image *GetPreviousImage(const Image *images)
02908 {
02909 if (images->debug != MagickFalse)
02910 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
02911 return(GetPreviousImageInList(images));
02912 }
02913
02914
02915
02916
02917
02918
02919
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933
02934
02935
02936
02937
02938
02939
02940
02941
02942 static inline MagickRealType HueToRGB(MagickRealType m1,MagickRealType m2,
02943 MagickRealType hue)
02944 {
02945 if (hue < 0.0)
02946 hue+=1.0;
02947 if (hue > 1.0)
02948 hue-=1.0;
02949 if ((6.0*hue) < 1.0)
02950 return(m1+6.0*(m2-m1)*hue);
02951 if ((2.0*hue) < 1.0)
02952 return(m2);
02953 if ((3.0*hue) < 2.0)
02954 return(m1+6.0*(m2-m1)*(2.0/3.0-hue));
02955 return(m1);
02956 }
02957
02958 MagickExport void HSLTransform(const double hue,const double saturation,
02959 const double lightness,Quantum *red,Quantum *green,Quantum *blue)
02960 {
02961 MagickRealType
02962 b,
02963 g,
02964 r,
02965 m1,
02966 m2;
02967
02968
02969
02970
02971 assert(red != (Quantum *) NULL);
02972 assert(green != (Quantum *) NULL);
02973 assert(blue != (Quantum *) NULL);
02974 if (lightness <= 0.5)
02975 m2=lightness*(saturation+1.0);
02976 else
02977 m2=lightness+saturation-lightness*saturation;
02978 m1=2.0*lightness-m2;
02979 r=HueToRGB(m1,m2,hue+1.0/3.0);
02980 g=HueToRGB(m1,m2,hue);
02981 b=HueToRGB(m1,m2,hue-1.0/3.0);
02982 *red=RoundToQuantum((MagickRealType) QuantumRange*r);
02983 *green=RoundToQuantum((MagickRealType) QuantumRange*g);
02984 *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
02985 }
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003
03004
03005
03006
03007
03008
03009 MagickExport void IdentityAffine(AffineMatrix *affine)
03010 {
03011 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
03012 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
03013 assert(affine != (AffineMatrix *) NULL);
03014 (void) ResetMagickMemory(affine,0,sizeof(AffineMatrix));
03015 affine->sx=1.0;
03016 affine->sy=1.0;
03017 }
03018
03019
03020
03021
03022
03023
03024
03025
03026
03027
03028
03029
03030
03031
03032
03033
03034
03035
03036
03037
03038
03039
03040
03041 MagickExport void InitializeMagick(const char *path)
03042 {
03043 MagickCoreGenesis(path,MagickFalse);
03044 }
03045
03046
03047
03048
03049
03050
03051
03052
03053
03054
03055
03056
03057
03058
03059
03060
03061
03062
03063
03064
03065
03066
03067
03068
03069
03070
03071
03072
03073
03074
03075
03076
03077
03078
03079
03080 static inline double MagickMax(const double x,const double y)
03081 {
03082 if (x > y)
03083 return(x);
03084 return(y);
03085 }
03086
03087 static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
03088 MagickPixelPacket *pixel)
03089 {
03090 MagickRealType
03091 dx2,
03092 p,
03093 q,
03094 r,
03095 s;
03096
03097 dx2=dx*dx;
03098 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
03099 q=(pixels[0].red-pixels[1].red)-p;
03100 r=pixels[2].red-pixels[0].red;
03101 s=pixels[1].red;
03102 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
03103 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
03104 q=(pixels[0].green-pixels[1].green)-p;
03105 r=pixels[2].green-pixels[0].green;
03106 s=pixels[1].green;
03107 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
03108 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
03109 q=(pixels[0].blue-pixels[1].blue)-p;
03110 r=pixels[2].blue-pixels[0].blue;
03111 s=pixels[1].blue;
03112 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
03113 p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
03114 q=(pixels[0].opacity-pixels[1].opacity)-p;
03115 r=pixels[2].opacity-pixels[0].opacity;
03116 s=pixels[1].opacity;
03117 pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
03118 if (pixel->colorspace == CMYKColorspace)
03119 {
03120 p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
03121 q=(pixels[0].index-pixels[1].index)-p;
03122 r=pixels[2].index-pixels[0].index;
03123 s=pixels[1].index;
03124 pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
03125 }
03126 }
03127
03128 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
03129 {
03130 MagickRealType
03131 alpha,
03132 gamma;
03133
03134 alpha=MagickMax(x+2.0,0.0);
03135 gamma=1.0*alpha*alpha*alpha;
03136 alpha=MagickMax(x+1.0,0.0);
03137 gamma-=4.0*alpha*alpha*alpha;
03138 alpha=MagickMax(x+0.0,0.0);
03139 gamma+=6.0*alpha*alpha*alpha;
03140 alpha=MagickMax(x-1.0,0.0);
03141 gamma-=4.0*alpha*alpha*alpha;
03142 return(gamma/6.0);
03143 }
03144
03145 static inline double MeshInterpolate(const PointInfo *delta,const double p,
03146 const double x,const double y)
03147 {
03148 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
03149 }
03150
03151 static inline long NearestNeighbor(MagickRealType x)
03152 {
03153 if (x >= 0.0)
03154 return((long) (x+0.5));
03155 return((long) (x-0.5));
03156 }
03157
03158 MagickExport MagickPixelPacket InterpolatePixelColor(const Image *image,
03159 ViewInfo *image_view,const InterpolatePixelMethod method,const double x,
03160 const double y,ExceptionInfo *exception)
03161 {
03162 MagickPixelPacket
03163 pixel;
03164
03165 register const IndexPacket
03166 *indexes;
03167
03168 register const PixelPacket
03169 *p;
03170
03171 register long
03172 i;
03173
03174 assert(image != (Image *) NULL);
03175 assert(image->signature == MagickSignature);
03176 assert(image_view != (ViewInfo *) NULL);
03177 GetMagickPixelPacket(image,&pixel);
03178 switch (method)
03179 {
03180 case AverageInterpolatePixel:
03181 {
03182 MagickPixelPacket
03183 pixels[16];
03184
03185 MagickRealType
03186 alpha[16],
03187 gamma;
03188
03189 p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-1,
03190 4,4,exception);
03191 if (p == (const PixelPacket *) NULL)
03192 break;
03193 indexes=GetCacheViewVirtualIndexQueue(image_view);
03194 for (i=0; i < 16L; i++)
03195 {
03196 GetMagickPixelPacket(image,pixels+i);
03197 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
03198 alpha[i]=1.0;
03199 if (image->matte != MagickFalse)
03200 {
03201 alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
03202 pixels[i].red*=alpha[i];
03203 pixels[i].green*=alpha[i];
03204 pixels[i].blue*=alpha[i];
03205 if (image->colorspace == CMYKColorspace)
03206 pixels[i].index*=alpha[i];
03207 }
03208 gamma=alpha[i];
03209 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03210 pixel.red+=gamma*0.0625*pixels[i].red;
03211 pixel.green+=gamma*0.0625*pixels[i].green;
03212 pixel.blue+=gamma*0.0625*pixels[i].blue;
03213 pixel.opacity+=0.0625*pixels[i].opacity;
03214 if (image->colorspace == CMYKColorspace)
03215 pixel.index+=gamma*0.0625*pixels[i].index;
03216 p++;
03217 }
03218 break;
03219 }
03220 case BicubicInterpolatePixel:
03221 {
03222 MagickPixelPacket
03223 pixels[16],
03224 u[4];
03225
03226 MagickRealType
03227 alpha[16];
03228
03229 PointInfo
03230 delta;
03231
03232 p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-1,
03233 4,4,exception);
03234 if (p == (const PixelPacket *) NULL)
03235 break;
03236 indexes=GetCacheViewVirtualIndexQueue(image_view);
03237 for (i=0; i < 16L; i++)
03238 {
03239 GetMagickPixelPacket(image,pixels+i);
03240 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
03241 alpha[i]=1.0;
03242 if (image->matte != MagickFalse)
03243 {
03244 alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
03245 pixels[i].red*=alpha[i];
03246 pixels[i].green*=alpha[i];
03247 pixels[i].blue*=alpha[i];
03248 if (image->colorspace == CMYKColorspace)
03249 pixels[i].index*=alpha[i];
03250 }
03251 p++;
03252 }
03253 delta.x=x-floor(x);
03254 for (i=0; i < 4L; i++)
03255 BicubicInterpolate(pixels+4*i,delta.x,u+i);
03256 delta.y=y-floor(y);
03257 BicubicInterpolate(u,delta.y,&pixel);
03258 break;
03259 }
03260 case BilinearInterpolatePixel:
03261 default:
03262 {
03263 MagickPixelPacket
03264 pixels[16];
03265
03266 MagickRealType
03267 alpha[16],
03268 gamma;
03269
03270 PointInfo
03271 delta;
03272
03273 p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),2,2,
03274 exception);
03275 if (p == (const PixelPacket *) NULL)
03276 break;
03277 indexes=GetCacheViewVirtualIndexQueue(image_view);
03278 for (i=0; i < 4L; i++)
03279 {
03280 GetMagickPixelPacket(image,pixels+i);
03281 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
03282 alpha[i]=1.0;
03283 if (image->matte != MagickFalse)
03284 {
03285 alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
03286 pixels[i].red*=alpha[i];
03287 pixels[i].green*=alpha[i];
03288 pixels[i].blue*=alpha[i];
03289 if (image->colorspace == CMYKColorspace)
03290 pixels[i].index*=alpha[i];
03291 }
03292 p++;
03293 }
03294 delta.x=x-floor(x);
03295 delta.y=y-floor(y);
03296 gamma=(((1.0-delta.y)*((1.0-delta.x)*alpha[0]+delta.x*alpha[1])+delta.y*
03297 ((1.0-delta.x)*alpha[2]+delta.x*alpha[3])));
03298 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03299 pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
03300 pixels[1].red)+delta.y*((1.0-delta.x)*pixels[2].red+delta.x*
03301 pixels[3].red));
03302 pixel.green=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].green+delta.x*
03303 pixels[1].green)+delta.y*((1.0-delta.x)*pixels[2].green+
03304 delta.x*pixels[3].green));
03305 pixel.blue=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].blue+delta.x*
03306 pixels[1].blue)+delta.y*((1.0-delta.x)*pixels[2].blue+delta.x*
03307 pixels[3].blue));
03308 pixel.opacity=((1.0-delta.y)*((1.0-delta.x)*pixels[0].opacity+delta.x*
03309 pixels[1].opacity)+delta.y*((1.0-delta.x)*pixels[2].opacity+delta.x*
03310 pixels[3].opacity));
03311 if (image->colorspace == CMYKColorspace)
03312 pixel.index=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].index+delta.x*
03313 pixels[1].index)+delta.y*((1.0-delta.x)*pixels[2].index+delta.x*
03314 pixels[3].index));
03315 break;
03316 }
03317 case FilterInterpolatePixel:
03318 {
03319 Image
03320 *excerpt_image,
03321 *filter_image;
03322
03323 MagickPixelPacket
03324 pixels[1];
03325
03326 RectangleInfo
03327 geometry;
03328
03329 geometry.width=4L;
03330 geometry.height=4L;
03331 geometry.x=(long) floor(x)-1L;
03332 geometry.y=(long) floor(y)-1L;
03333 excerpt_image=ExcerptImage(image,&geometry,exception);
03334 if (excerpt_image == (Image *) NULL)
03335 break;
03336 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
03337 exception);
03338 excerpt_image=DestroyImage(excerpt_image);
03339 if (filter_image == (Image *) NULL)
03340 break;
03341 p=GetVirtualPixels(filter_image,0,0,1,1,exception);
03342 if (p == (const PixelPacket *) NULL)
03343 {
03344 filter_image=DestroyImage(filter_image);
03345 break;
03346 }
03347 indexes=GetVirtualIndexQueue(filter_image);
03348 GetMagickPixelPacket(image,pixels);
03349 SetMagickPixelPacket(image,p,indexes,&pixel);
03350 filter_image=DestroyImage(filter_image);
03351 break;
03352 }
03353 case IntegerInterpolatePixel:
03354 {
03355 MagickPixelPacket
03356 pixels[1];
03357
03358 p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),1,1,
03359 exception);
03360 if (p == (const PixelPacket *) NULL)
03361 break;
03362 indexes=GetCacheViewVirtualIndexQueue(image_view);
03363 GetMagickPixelPacket(image,pixels);
03364 SetMagickPixelPacket(image,p,indexes,&pixel);
03365 break;
03366 }
03367 case MeshInterpolatePixel:
03368 {
03369 MagickPixelPacket
03370 pixels[4];
03371
03372 MagickRealType
03373 alpha[4],
03374 gamma;
03375
03376 PointInfo
03377 delta,
03378 luminance;
03379
03380 p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),
03381 2,2,exception);
03382 if (p == (const PixelPacket *) NULL)
03383 break;
03384 indexes=GetCacheViewVirtualIndexQueue(image_view);
03385 for (i=0; i < 4L; i++)
03386 {
03387 GetMagickPixelPacket(image,pixels+i);
03388 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
03389 alpha[i]=1.0;
03390 if (image->matte != MagickFalse)
03391 {
03392 alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
03393 pixels[i].red*=alpha[i];
03394 pixels[i].green*=alpha[i];
03395 pixels[i].blue*=alpha[i];
03396 if (image->colorspace == CMYKColorspace)
03397 pixels[i].index*=alpha[i];
03398 }
03399 p++;
03400 }
03401 delta.x=x-floor(x);
03402 delta.y=y-floor(y);
03403 luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
03404 luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
03405 if (fabs(luminance.x) < fabs(luminance.y))
03406 {
03407
03408
03409
03410 if (delta.x <= delta.y)
03411 {
03412
03413
03414
03415 delta.y=1.0-delta.y;
03416 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
03417 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03418 pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
03419 pixels[3].red,pixels[0].red);
03420 pixel.green=gamma*MeshInterpolate(&delta,pixels[2].green,
03421 pixels[3].green,pixels[0].green);
03422 pixel.blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
03423 pixels[3].blue,pixels[0].blue);
03424 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
03425 pixels[3].opacity,pixels[0].opacity);
03426 if (image->colorspace == CMYKColorspace)
03427 pixel.index=gamma*MeshInterpolate(&delta,pixels[2].index,
03428 pixels[3].index,pixels[0].index);
03429 }
03430 else
03431 {
03432
03433
03434
03435 delta.x=1.0-delta.x;
03436 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
03437 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03438 pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
03439 pixels[0].red,pixels[3].red);
03440 pixel.green=gamma*MeshInterpolate(&delta,pixels[1].green,
03441 pixels[0].green,pixels[3].green);
03442 pixel.blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
03443 pixels[0].blue,pixels[3].blue);
03444 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
03445 pixels[0].opacity,pixels[3].opacity);
03446 if (image->colorspace == CMYKColorspace)
03447 pixel.index=gamma*MeshInterpolate(&delta,pixels[1].index,
03448 pixels[0].index,pixels[3].index);
03449 }
03450 }
03451 else
03452 {
03453
03454
03455
03456 if (delta.x <= (1.0-delta.y))
03457 {
03458
03459
03460
03461 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
03462 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03463 pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
03464 pixels[1].red,pixels[2].red);
03465 pixel.green=gamma*MeshInterpolate(&delta,pixels[0].green,
03466 pixels[1].green,pixels[2].green);
03467 pixel.blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
03468 pixels[1].blue,pixels[2].blue);
03469 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
03470 pixels[1].opacity,pixels[2].opacity);
03471 if (image->colorspace == CMYKColorspace)
03472 pixel.index=gamma*MeshInterpolate(&delta,pixels[0].index,
03473 pixels[1].index,pixels[2].index);
03474 }
03475 else
03476 {
03477
03478
03479
03480 delta.x=1.0-delta.x;
03481 delta.y=1.0-delta.y;
03482 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
03483 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03484 pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
03485 pixels[2].red,pixels[1].red);
03486 pixel.green=gamma*MeshInterpolate(&delta,pixels[3].green,
03487 pixels[2].green,pixels[1].green);
03488 pixel.blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
03489 pixels[2].blue,pixels[1].blue);
03490 pixel.opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
03491 pixels[2].opacity,pixels[1].opacity);
03492 if (image->colorspace == CMYKColorspace)
03493 pixel.index=gamma*MeshInterpolate(&delta,pixels[3].index,
03494 pixels[2].index,pixels[1].index);
03495 }
03496 }
03497 break;
03498 }
03499 case NearestNeighborInterpolatePixel:
03500 {
03501 MagickPixelPacket
03502 pixels[1];
03503
03504 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),NearestNeighbor(y),
03505 1,1,exception);
03506 if (p == (const PixelPacket *) NULL)
03507 break;
03508 indexes=GetCacheViewVirtualIndexQueue(image_view);
03509 GetMagickPixelPacket(image,pixels);
03510 SetMagickPixelPacket(image,p,indexes,&pixel);
03511 break;
03512 }
03513 case SplineInterpolatePixel:
03514 {
03515 long
03516 j,
03517 n;
03518
03519 MagickPixelPacket
03520 pixels[16];
03521
03522 MagickRealType
03523 alpha[16],
03524 dx,
03525 dy,
03526 gamma;
03527
03528 PointInfo
03529 delta;
03530
03531 p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-1,
03532 4,4,exception);
03533 if (p == (const PixelPacket *) NULL)
03534 break;
03535 indexes=GetCacheViewVirtualIndexQueue(image_view);
03536 n=0;
03537 delta.x=x-floor(x);
03538 delta.y=y-floor(y);
03539 for (i=(-1); i < 3L; i++)
03540 {
03541 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
03542 for (j=(-1); j < 3L; j++)
03543 {
03544 GetMagickPixelPacket(image,pixels+n);
03545 SetMagickPixelPacket(image,p,indexes+n,pixels+n);
03546 alpha[n]=1.0;
03547 if (image->matte != MagickFalse)
03548 {
03549 alpha[n]=QuantumScale*((MagickRealType) QuantumRange-p->opacity);
03550 pixels[n].red*=alpha[n];
03551 pixels[n].green*=alpha[n];
03552 pixels[n].blue*=alpha[n];
03553 if (image->colorspace == CMYKColorspace)
03554 pixels[n].index*=alpha[n];
03555 }
03556 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
03557 gamma=alpha[n];
03558 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
03559 pixel.red+=gamma*dx*dy*pixels[n].red;
03560 pixel.green+=gamma*dx*dy*pixels[n].green;
03561 pixel.blue+=gamma*dx*dy*pixels[n].blue;
03562 if (image->matte != MagickFalse)
03563 pixel.opacity+=dx*dy*pixels[n].opacity;
03564 if (image->colorspace == CMYKColorspace)
03565 pixel.index+=gamma*dx*dy*pixels[n].index;
03566 n++;
03567 p++;
03568 }
03569 }
03570 break;
03571 }
03572 }
03573 return(pixel);
03574 }
03575
03576
03577
03578
03579
03580
03581
03582
03583
03584
03585
03586
03587
03588
03589
03590
03591
03592
03593
03594
03595
03596
03597
03598
03599
03600
03601
03602
03603
03604
03605 MagickExport char *InterpretImageAttributes(const ImageInfo *image_info,
03606 Image *image,const char *embed_text)
03607 {
03608 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v6.3.1");
03609 return(InterpretImageProperties(image_info,image,embed_text));
03610 }
03611
03612
03613
03614
03615
03616
03617
03618
03619
03620
03621
03622
03623
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03634
03635
03636
03637
03638 MagickExport unsigned int IsSubimage(const char *geometry,
03639 const unsigned int pedantic)
03640 {
03641 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
03642 if (geometry == (const char *) NULL)
03643 return(MagickFalse);
03644 if ((strchr(geometry,'x') != (char *) NULL) ||
03645 (strchr(geometry,'X') != (char *) NULL))
03646 return(MagickFalse);
03647 if ((pedantic != MagickFalse) && (strchr(geometry,',') != (char *) NULL))
03648 return(MagickFalse);
03649 return(MagickTrue);
03650 }
03651
03652
03653
03654
03655
03656
03657
03658
03659
03660
03661
03662
03663
03664
03665
03666
03667
03668
03669
03670
03671
03672
03673
03674
03675 MagickExport void LiberateMemory(void **memory)
03676 {
03677 assert(memory != (void **) NULL);
03678 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
03679 if (*memory == (void *) NULL)
03680 return;
03681 free(*memory);
03682 *memory=(void *) NULL;
03683 }
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702
03703
03704
03705
03706
03707 MagickExport void LiberateSemaphoreInfo(SemaphoreInfo **semaphore_info)
03708 {
03709 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.7");
03710 RelinquishSemaphoreInfo(*semaphore_info);
03711 }
03712
03713
03714
03715
03716
03717
03718
03719
03720
03721
03722
03723
03724
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736 MagickExport void MagickIncarnate(const char *path)
03737 {
03738 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.1");
03739 InitializeMagick(path);
03740 }
03741
03742
03743
03744
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757
03758
03759
03760
03761
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774 MagickExport MagickBooleanType MagickMonitor(const char *text,
03775 const MagickOffsetType offset,const MagickSizeType span,
03776 void *magick_unused(client_data))
03777 {
03778 ExceptionInfo
03779 *exception;
03780
03781 MagickBooleanType
03782 status;
03783
03784 assert(text != (const char *) NULL);
03785 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",text);
03786 ProcessPendingEvents(text);
03787 status=MagickTrue;
03788 exception=AcquireExceptionInfo();
03789 if (monitor_handler != (MonitorHandler) NULL)
03790 status=(*monitor_handler)(text,offset,span,exception);
03791 exception=DestroyExceptionInfo(exception);
03792 return(status);
03793 }
03794
03795
03796
03797
03798
03799
03800
03801
03802
03803
03804
03805
03806
03807
03808
03809
03810
03811
03812
03813
03814
03815
03816
03817
03818
03819
03820
03821
03822
03823
03824
03825 MagickExport MagickBooleanType MapImage(Image *image,const Image *map_image,
03826 const MagickBooleanType dither)
03827 {
03828 QuantizeInfo
03829 quantize_info;
03830
03831
03832
03833
03834 assert(image != (Image *) NULL);
03835 assert(image->signature == MagickSignature);
03836 if (image->debug != MagickFalse)
03837 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
03838 assert(map_image != (Image *) NULL);
03839 assert(map_image->signature == MagickSignature);
03840 GetQuantizeInfo(&quantize_info);
03841 quantize_info.dither=dither;
03842 return(RemapImage(&quantize_info,image,map_image));
03843 }
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857
03858
03859
03860
03861
03862
03863
03864
03865
03866
03867
03868
03869
03870
03871
03872
03873
03874
03875 MagickExport MagickBooleanType MapImages(Image *images,const Image *map_image,
03876 const MagickBooleanType dither)
03877 {
03878 QuantizeInfo
03879 quantize_info;
03880
03881 assert(images != (Image *) NULL);
03882 assert(images->signature == MagickSignature);
03883 if (images->debug != MagickFalse)
03884 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
03885 GetQuantizeInfo(&quantize_info);
03886 quantize_info.dither=dither;
03887 return(RemapImages(&quantize_info,images,map_image));
03888 }
03889
03890
03891
03892
03893
03894
03895
03896
03897
03898
03899
03900
03901
03902
03903
03904
03905
03906
03907
03908
03909
03910
03911
03912
03913
03914
03915
03916
03917
03918
03919
03920
03921
03922
03923
03924
03925
03926
03927
03928
03929
03930
03931
03932
03933 MagickExport MagickBooleanType MatteFloodfillImage(Image *image,
03934 const PixelPacket target,const Quantum opacity,const long x_offset,
03935 const long y_offset,const PaintMethod method)
03936 {
03937 Image
03938 *floodplane_image;
03939
03940 long
03941 offset,
03942 start,
03943 x,
03944 x1,
03945 x2,
03946 y;
03947
03948 MagickBooleanType
03949 skip;
03950
03951 register SegmentInfo
03952 *s;
03953
03954 SegmentInfo
03955 *segment_stack;
03956
03957
03958
03959
03960 assert(image != (Image *) NULL);
03961 assert(image->signature == MagickSignature);
03962 if (image->debug != MagickFalse)
03963 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
03964 if ((x_offset < 0) || (x_offset >= (long) image->columns))
03965 return(MagickFalse);
03966 if ((y_offset < 0) || (y_offset >= (long) image->rows))
03967 return(MagickFalse);
03968 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
03969 return(MagickFalse);
03970 if (image->matte == MagickFalse)
03971 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
03972 floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
03973 &image->exception);
03974 if (floodplane_image == (Image *) NULL)
03975 return(MagickFalse);
03976 (void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel);
03977
03978
03979
03980 segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
03981 sizeof(*segment_stack));
03982 if (segment_stack == (SegmentInfo *) NULL)
03983 {
03984 floodplane_image=DestroyImage(floodplane_image);
03985 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
03986 image->filename);
03987 }
03988
03989
03990
03991 x=x_offset;
03992 y=y_offset;
03993 start=0;
03994 s=segment_stack;
03995 PushSegmentStack(y,x,x,1);
03996 PushSegmentStack(y+1,x,x,-1);
03997 while (s > segment_stack)
03998 {
03999 register const PixelPacket
04000 *__restrict p;
04001
04002 register long
04003 x;
04004
04005 register PixelPacket
04006 *__restrict q;
04007
04008
04009
04010
04011 s--;
04012 x1=(long) s->x1;
04013 x2=(long) s->x2;
04014 offset=(long) s->y2;
04015 y=(long) s->y1+offset;
04016
04017
04018
04019 p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,&image->exception);
04020 q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,
04021 &image->exception);
04022 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
04023 break;
04024 p+=x1;
04025 q+=x1;
04026 for (x=x1; x >= 0; x--)
04027 {
04028 if (q->opacity == (Quantum) TransparentOpacity)
04029 break;
04030 if (method == FloodfillMethod)
04031 {
04032 if (IsColorSimilar(image,p,&target) == MagickFalse)
04033 break;
04034 }
04035 else
04036 if (IsColorSimilar(image,p,&target) != MagickFalse)
04037 break;
04038 q->opacity=(Quantum) TransparentOpacity;
04039 q--;
04040 p--;
04041 }
04042 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
04043 break;
04044 skip=x >= x1 ? MagickTrue : MagickFalse;
04045 if (skip == MagickFalse)
04046 {
04047 start=x+1;
04048 if (start < x1)
04049 PushSegmentStack(y,start,x1-1,-offset);
04050 x=x1+1;
04051 }
04052 do
04053 {
04054 if (skip == MagickFalse)
04055 {
04056 if (x < (long) image->columns)
04057 {
04058 p=GetVirtualPixels(image,x,y,image->columns-x,1,
04059 &image->exception);
04060 q=GetAuthenticPixels(floodplane_image,x,y,image->columns-x,1,
04061 &image->exception);
04062 if ((p == (const PixelPacket *) NULL) ||
04063 (q == (PixelPacket *) NULL))
04064 break;
04065 for ( ; x < (long) image->columns; x++)
04066 {
04067 if (q->opacity == (Quantum) TransparentOpacity)
04068 break;
04069 if (method == FloodfillMethod)
04070 {
04071 if (IsColorSimilar(image,p,&target) == MagickFalse)
04072 break;
04073 }
04074 else
04075 if (IsColorSimilar(image,p,&target) != MagickFalse)
04076 break;
04077 q->opacity=(Quantum) TransparentOpacity;
04078 q++;
04079 p++;
04080 }
04081 if (SyncAuthenticPixels(floodplane_image,&image->exception) == MagickFalse)
04082 break;
04083 }
04084 PushSegmentStack(y,start,x-1,offset);
04085 if (x > (x2+1))
04086 PushSegmentStack(y,x2+1,x-1,-offset);
04087 }
04088 skip=MagickFalse;
04089 x++;
04090 if (x <= x2)
04091 {
04092 p=GetVirtualPixels(image,x,y,(unsigned long) (x2-x+1),1,
04093 &image->exception);
04094 q=GetAuthenticPixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1,
04095 &image->exception);
04096 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
04097 break;
04098 for ( ; x <= x2; x++)
04099 {
04100 if (q->opacity == (Quantum) TransparentOpacity)
04101 break;
04102 if (method == FloodfillMethod)
04103 {
04104 if (IsColorSimilar(image,p,&target) != MagickFalse)
04105 break;
04106 }
04107 else
04108 if (IsColorSimilar(image,p,&target) == MagickFalse)
04109 break;
04110 p++;
04111 q++;
04112 }
04113 }
04114 start=x;
04115 } while (x <= x2);
04116 }
04117 for (y=0; y < (long) image->rows; y++)
04118 {
04119 register const PixelPacket
04120 *__restrict p;
04121
04122 register long
04123 x;
04124
04125 register PixelPacket
04126 *__restrict q;
04127
04128
04129
04130
04131 p=GetVirtualPixels(floodplane_image,0,y,image->columns,1,
04132 &image->exception);
04133 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
04134 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
04135 break;
04136 for (x=0; x < (long) image->columns; x++)
04137 {
04138 if (p->opacity != OpaqueOpacity)
04139 q->opacity=opacity;
04140 p++;
04141 q++;
04142 }
04143 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
04144 break;
04145 }
04146 segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
04147 floodplane_image=DestroyImage(floodplane_image);
04148 return(y == (long) image->rows ? MagickTrue : MagickFalse);
04149 }
04150
04151
04152
04153
04154
04155
04156
04157
04158
04159
04160
04161
04162
04163
04164
04165
04166
04167
04168
04169
04170
04171
04172
04173
04174
04175 MagickExport Image *MosaicImages(Image *image,ExceptionInfo *exception)
04176 {
04177 return(MergeImageLayers(image,MosaicLayer,exception));
04178 }
04179
04180
04181
04182
04183
04184
04185
04186
04187
04188
04189
04190
04191
04192
04193
04194
04195
04196
04197
04198
04199
04200
04201
04202
04203
04204
04205
04206
04207
04208
04209
04210
04211
04212
04213
04214 MagickExport MagickBooleanType OpaqueImage(Image *image,
04215 const PixelPacket target,const PixelPacket fill)
04216 {
04217 #define OpaqueImageTag "Opaque/Image"
04218
04219 long
04220 y;
04221
04222 MagickBooleanType
04223 proceed;
04224
04225 register long
04226 i;
04227
04228
04229
04230
04231 assert(image != (Image *) NULL);
04232 assert(image->signature == MagickSignature);
04233 (void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v6.1.0");
04234 if (image->debug != MagickFalse)
04235 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
04236 switch (image->storage_class)
04237 {
04238 case DirectClass:
04239 default:
04240 {
04241
04242
04243
04244 for (y=0; y < (long) image->rows; y++)
04245 {
04246 register long
04247 x;
04248
04249 register PixelPacket
04250 *__restrict q;
04251
04252 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
04253 if (q == (PixelPacket *) NULL)
04254 break;
04255 for (x=0; x < (long) image->columns; x++)
04256 {
04257 if (IsColorSimilar(image,q,&target) != MagickFalse)
04258 *q=fill;
04259 q++;
04260 }
04261 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
04262 break;
04263 proceed=SetImageProgress(image,OpaqueImageTag,y,image->rows);
04264 if (proceed == MagickFalse)
04265 break;
04266 }
04267 break;
04268 }
04269 case PseudoClass:
04270 {
04271
04272
04273
04274 for (i=0; i < (long) image->colors; i++)
04275 {
04276 if (IsColorSimilar(image,&image->colormap[i],&target) != MagickFalse)
04277 image->colormap[i]=fill;
04278 }
04279 if (fill.opacity != OpaqueOpacity)
04280 {
04281 for (y=0; y < (long) image->rows; y++)
04282 {
04283 register long
04284 x;
04285
04286 register PixelPacket
04287 *__restrict q;
04288
04289 q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
04290 if (q == (PixelPacket *) NULL)
04291 break;
04292 for (x=0; x < (long) image->columns; x++)
04293 {
04294 if (IsColorSimilar(image,q,&target) != MagickFalse)
04295 q->opacity=fill.opacity;
04296 q++;
04297 }
04298 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
04299 break;
04300 }
04301 }
04302 (void) SyncImage(image);
04303 break;
04304 }
04305 }
04306 if (fill.opacity != OpaqueOpacity)
04307 image->matte=MagickTrue;
04308 return(MagickTrue);
04309 }
04310
04311
04312
04313
04314
04315
04316
04317
04318
04319
04320
04321
04322
04323
04324
04325
04326
04327
04328
04329
04330
04331
04332
04333
04334 MagickExport ViewInfo *OpenCacheView(const Image *image)
04335 {
04336 return(AcquireCacheView(image));
04337 }
04338
04339
04340
04341
04342
04343
04344
04345
04346
04347
04348
04349
04350
04351
04352
04353
04354
04355
04356
04357
04358
04359
04360
04361
04362
04363
04364
04365
04366
04367
04368
04369
04370
04371