« back to all changes in this revision
Viewing changes to magick/deprecate.c
- browse files at revision 29
- compare with another revision
- download diff
- download tarball
- view history from revision 29
- Committer: Bazaar Package Importer
- Author(s): Colin Watson
- Date: 2011-06-15 11:05:28 UTC
- mfrom: (6.2.11 sid)
- Revision ID: james.westby@ubuntu.com-20110615110528-08jgo07a4846xh8d
Tags: 8:6.6.0.4-3ubuntu1
* Resynchronise with Debian (LP: #797595). Remaining changes:
- Make ufraw-batch (universe) a suggestion instead of a recommendation.
- Make debian/rules install target depend on check; they cannot reliably
be run in parallel.
- Don't set MAKEFLAGS in debian/rules; just pass it to the build.
- Make ufraw-batch (universe) a suggestion instead of a recommendation.
- Make debian/rules install target depend on check; they cannot reliably
be run in parallel.
- Don't set MAKEFLAGS in debian/rules; just pass it to the build.
- files added:
- m4/ac_compile_warnings.m4
- files removed:
- coders/debug.c
- files modified:
- .pc/601824.patch/magick/configure.c
- magick.sh.in *
added
removed
magick/deprecate.c
62
62
#include "magick/enhance.h"
63
63
#include "magick/exception.h"
64
64
#include "magick/exception-private.h"
65
#include "magick/fx.h"
66
65
#include "magick/geometry.h"
67
66
#include "magick/identify.h"
68
67
#include "magick/image.h"
73
72
#include "magick/magick.h"
74
73
#include "magick/monitor.h"
75
74
#include "magick/monitor-private.h"
76
#include "magick/morphology.h"
77
75
#include "magick/paint.h"
78
76
#include "magick/pixel.h"
79
77
#include "magick/pixel-private.h"
110
108
% AcquireCacheViewIndexes() returns the indexes associated with the specified
111
109
% view.
112
110
%
113
% Deprecated, replace with:
114
%
115
% GetCacheViewVirtualIndexQueue(cache_view);
116
%
117
111
% The format of the AcquireCacheViewIndexes method is:
118
112
%
119
113
% const IndexPacket *AcquireCacheViewIndexes(const CacheView *cache_view)
144
138
% as defined by the geometry parameters. A pointer to the pixels is returned
145
139
% if the pixels are transferred, otherwise a NULL is returned.
146
140
%
147
% Deprecated, replace with:
148
%
149
% GetCacheViewVirtualPixels(cache_view,x,y,columns,rows,exception);
150
%
151
141
% The format of the AcquireCacheViewPixels method is:
152
142
%
153
143
% const PixelPacket *AcquireCacheViewPixels(const CacheView *cache_view,
154
% const ssize_t x,const ssize_t y,const size_t columns,
155
% const size_t rows,ExceptionInfo *exception)
144
% const long x,const long y,const unsigned long columns,
145
% const unsigned long rows,ExceptionInfo *exception)
156
146
%
157
147
% A description of each parameter follows:
158
148
%
165
155
%
166
156
*/
167
157
MagickExport const PixelPacket *AcquireCacheViewPixels(
168
const CacheView *cache_view,const ssize_t x,const ssize_t y,
169
const size_t columns,const size_t rows,ExceptionInfo *exception)
158
const CacheView *cache_view,const long x,const long y,
159
const unsigned long columns,const unsigned long rows,ExceptionInfo *exception)
170
160
{
171
161
return(GetCacheViewVirtualPixels(cache_view,x,y,columns,rows,exception));
172
162
}
176
166
% %
177
167
% %
178
168
% %
179
% A c q u i r e I m a g e P i x e l s %
169
% A c q u i r e I m a g e P i x e l s %
180
170
% % % %
181
171
% %
182
172
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
202
192
% thread-safe. In a threaded environment, use GetCacheViewVirtualPixels() or
203
193
% GetCacheViewAuthenticPixels() instead.
204
194
%
205
% Deprecated, replace with:
206
%
207
% GetVirtualPixels(image,x,y,columns,rows,exception);
208
%
209
195
% The format of the AcquireImagePixels() method is:
210
196
%
211
% const PixelPacket *AcquireImagePixels(const Image *image,const ssize_t x,
212
% const ssize_t y,const size_t columns,const size_t rows,
197
% const PixelPacket *AcquireImagePixels(const Image *image,const long x,
198
% const long y,const unsigned long columns,const unsigned long rows,
213
199
% ExceptionInfo *exception)
214
200
%
215
201
% A description of each parameter follows:
223
209
%
224
210
*/
225
211
MagickExport const PixelPacket *AcquireImagePixels(const Image *image,
226
const ssize_t x,const ssize_t y,const size_t columns,
227
const size_t rows,ExceptionInfo *exception)
212
const long x,const long y,const unsigned long columns,
213
const unsigned long rows,ExceptionInfo *exception)
228
214
{
229
215
return(GetVirtualPixels(image,x,y,columns,rows,exception));
230
216
}
241
227
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
242
228
%
243
229
% AcquireIndexes() returns the black channel or the colormap indexes
244
% associated with the last call to QueueAuthenticPixels() or
245
% GetVirtualPixels(). NULL is returned if the black channel or colormap
246
% indexes are not available.
247
%
248
% Deprecated, replace with:
249
%
250
% GetVirtualIndexQueue(image);
230
% associated with the last call to QueueAuthenticPixels() or GetVirtualPixels().
231
% NULL is returned if the black channel or colormap indexes are not available.
251
232
%
252
233
% The format of the AcquireIndexes() method is:
253
234
%
315
296
% location. The image background color is returned if an error occurs. If
316
297
% you plan to modify the pixel, use GetOneCacheViewAuthenticPixel() instead.
317
298
%
318
% Deprecated, replace with:
319
%
320
% GetOneCacheViewVirtualPixel(cache_view,x,y,pixel,exception);
321
%
322
299
% The format of the AcquireOneCacheViewPixel method is:
323
300
%
324
301
% MagickBooleanType AcquireOneCacheViewPixel(const CacheView *cache_view,
325
% const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
302
% const long x,const long y,PixelPacket *pixel,ExceptionInfo *exception)
326
303
%
327
304
% A description of each parameter follows:
328
305
%
336
313
%
337
314
*/
338
315
MagickExport MagickBooleanType AcquireOneCacheViewPixel(
339
const CacheView *cache_view,const ssize_t x,const ssize_t y,PixelPacket *pixel,
316
const CacheView *cache_view,const long x,const long y,PixelPacket *pixel,
340
317
ExceptionInfo *exception)
341
318
{
342
319
return(GetOneCacheViewVirtualPixel(cache_view,x,y,pixel,exception));
357
334
% (x,y) location. The image background color is returned if an error occurs.
358
335
% If you plan to modify the pixel, use GetOneCacheViewAuthenticPixel() instead.
359
336
%
360
% Deprecated, replace with:
361
%
362
% GetOneCacheViewVirtualMethodPixel(cache_view,virtual_pixel_method,
363
% x,y,pixel,exception);
364
%
365
337
% The format of the AcquireOneCacheViewPixel method is:
366
338
%
367
339
% MagickBooleanType AcquireOneCacheViewVirtualPixel(
368
340
% const CacheView *cache_view,
369
% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
370
% const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
341
% const VirtualPixelMethod virtual_pixel_method,const long x,
342
% const long y,PixelPacket *pixel,ExceptionInfo *exception)
371
343
%
372
344
% A description of each parameter follows:
373
345
%
384
356
*/
385
357
MagickExport MagickBooleanType AcquireOneCacheViewVirtualPixel(
386
358
const CacheView *cache_view,const VirtualPixelMethod virtual_pixel_method,
387
const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
359
const long x,const long y,PixelPacket *pixel,ExceptionInfo *exception)
388
360
{
389
361
MagickBooleanType
390
362
status;
409
381
% location. The image background color is returned if an error occurs. If
410
382
% you plan to modify the pixel, use GetOnePixel() instead.
411
383
%
412
% Deprecated, replace with:
413
%
414
% MagickPixelPacket pixel;
415
% GetOneVirtualMagickPixel(image,x,y,&pixel,exception);
416
%
417
384
% The format of the AcquireOneMagickPixel() method is:
418
385
%
419
% MagickPixelPacket AcquireOneMagickPixel(const Image image,const ssize_t x,
420
% const ssize_t y,ExceptionInfo exception)
386
% MagickPixelPacket AcquireOneMagickPixel(const Image image,const long x,
387
% const long y,ExceptionInfo exception)
421
388
%
422
389
% A description of each parameter follows:
423
390
%
429
396
%
430
397
*/
431
398
MagickExport MagickPixelPacket AcquireOneMagickPixel(const Image *image,
432
const ssize_t x,const ssize_t y,ExceptionInfo *exception)
399
const long x,const long y,ExceptionInfo *exception)
433
400
{
434
401
MagickPixelPacket
435
402
pixel;
453
420
% The image background color is returned if an error occurs. If you plan to
454
421
% modify the pixel, use GetOnePixel() instead.
455
422
%
456
% Deprecated, replace with:
457
%
458
% PixelPacket pixel;
459
% GetOneVirtualPixel(image,x,y,&pixel,exception);
460
%
461
423
% The format of the AcquireOnePixel() method is:
462
424
%
463
% PixelPacket AcquireOnePixel(const Image image,const ssize_t x,
464
% const ssize_t y,ExceptionInfo exception)
425
% PixelPacket AcquireOnePixel(const Image image,const long x,
426
% const long y,ExceptionInfo exception)
465
427
%
466
428
% A description of each parameter follows:
467
429
%
472
434
% o exception: return any errors or warnings in this structure.
473
435
%
474
436
*/
475
MagickExport PixelPacket AcquireOnePixel(const Image *image,const ssize_t x,
476
const ssize_t y,ExceptionInfo *exception)
437
MagickExport PixelPacket AcquireOnePixel(const Image *image,const long x,
438
const long y,ExceptionInfo *exception)
477
439
{
478
440
PixelPacket
479
441
pixel;
498
460
% is returned if an error occurs. If you plan to modify the pixel, use
499
461
% GetOnePixel() instead.
500
462
%
501
% Deprecated, replace with:
502
%
503
% PixelPacket pixel;
504
% GetOneVirtualMethodPixel(image,virtual_pixel_method,x,y,&pixel,exception);
505
%
506
463
% The format of the AcquireOneVirtualPixel() method is:
507
464
%
508
465
% PixelPacket AcquireOneVirtualPixel(const Image image,
509
% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
510
% const ssize_t y,ExceptionInfo exception)
466
% const VirtualPixelMethod virtual_pixel_method,const long x,
467
% const long y,ExceptionInfo exception)
511
468
%
512
469
% A description of each parameter follows:
513
470
%
521
478
%
522
479
*/
523
480
MagickExport PixelPacket AcquireOneVirtualPixel(const Image *image,
524
const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
481
const VirtualPixelMethod virtual_pixel_method,const long x,const long y,
525
482
ExceptionInfo *exception)
526
483
{
527
484
PixelPacket
546
503
% AcquirePixels() returns the pixels associated with the last call to
547
504
% QueueAuthenticPixels() or GetVirtualPixels().
548
505
%
549
% Deprecated, replace with:
550
%
551
% GetVirtualPixelQueue(image);
552
%
553
506
% The format of the AcquirePixels() method is:
554
507
%
555
508
% const PixelPacket *AcquirePixels(const Image image)
578
531
% AffinityImage() replaces the colors of an image with the closest color from
579
532
% a reference image.
580
533
%
581
% Deprecated, replace with:
582
%
583
% RemapImage(quantize_info,image,affinity_image);
584
%
585
534
% The format of the AffinityImage method is:
586
535
%
587
536
% MagickBooleanType AffinityImage(const QuantizeInfo *quantize_info,
616
565
% AffinityImages() replaces the colors of a sequence of images with the
617
566
% closest color from a reference image.
618
567
%
619
% Deprecated, replace with:
620
%
621
% RemapImages(quantize_info,images,affinity_image);
622
%
623
568
% The format of the AffinityImage method is:
624
569
%
625
570
% MagickBooleanType AffinityImages(const QuantizeInfo *quantize_info,
654
599
% AllocateImage() returns a pointer to an image structure initialized to
655
600
% default values.
656
601
%
657
% Deprecated, replace with:
658
%
659
% AcquireImage(image_info);
660
%
661
602
% The format of the AllocateImage method is:
662
603
%
663
604
% Image *AllocateImage(const ImageInfo *image_info)
690
631
% it is replaced. AllocateImageColormap() returns MagickTrue if successful,
691
632
% otherwise MagickFalse if there is not enough memory.
692
633
%
693
% Deprecated, replace with:
694
%
695
% AcquireImageColormap(image,colors);
696
%
697
634
% The format of the AllocateImageColormap method is:
698
635
%
699
636
% MagickBooleanType AllocateImageColormap(Image *image,
700
% const size_t colors)
637
% const unsigned long colors)
701
638
%
702
639
% A description of each parameter follows:
703
640
%
707
644
%
708
645
*/
709
646
MagickExport MagickBooleanType AllocateImageColormap(Image *image,
710
const size_t colors)
647
const unsigned long colors)
711
648
{
712
649
return(AcquireImageColormap(image,colors));
713
650
}
727
664
% default values. The next member of image points to the newly allocated
728
665
% image. If there is a memory shortage, next is assigned NULL.
729
666
%
730
% Deprecated, replace with:
731
%
732
% AcquireNextImage(image_info,image);
733
%
734
667
% The format of the AllocateNextImage method is:
735
668
%
736
669
% void AllocateNextImage(const ImageInfo *image_info,Image *image)
809
742
% image averaged. On failure, a NULL image is returned and exception
810
743
% describes the reason for the failure.
811
744
%
812
% Deprecated, replace with:
813
%
814
% EvaluateImages(images,MeanEvaluateOperator,exception);
815
%
816
745
% The format of the AverageImages method is:
817
746
%
818
747
% Image *AverageImages(Image *images,ExceptionInfo *exception)
843
772
% Extract a channel from the image. A channel is a particular color component
844
773
% of each pixel in the image.
845
774
%
846
% Deprecated, replace with:
847
%
848
% SeparateImageChannel(image,channel);
849
%
850
775
% The format of the ChannelImage method is:
851
776
%
852
777
% unsigned int ChannelImage(Image *image,const ChannelType channel)
938
863
% ClipPathImage() sets the image clip mask based any clipping path information
939
864
% if it exists.
940
865
%
941
% Deprecated, replace with:
942
%
943
% ClipImagePath(image,pathname,inside);
944
%
945
866
% The format of the ClipImage method is:
946
867
%
947
868
% MagickBooleanType ClipPathImage(Image *image,const char *pathname,
977
898
%
978
899
% CloneImageAttributes() clones one or more image attributes.
979
900
%
980
% Deprecated, replace with:
981
%
982
% CloneImageProperties(image,clone_image);
983
%
984
901
% The format of the CloneImageAttributes method is:
985
902
%
986
903
% MagickBooleanType CloneImageAttributes(Image *image,
1037
954
register unsigned char
1038
955
*q;
1039
956
1040
register ssize_t
957
register long
1041
958
i;
1042
959
1043
960
assert(destination != (void *) NULL);
1052
969
*/
1053
970
p+=size;
1054
971
q+=size;
1055
for (i=(ssize_t) (size-1); i >= 0; i--)
972
for (i=(long) (size-1); i >= 0; i--)
1056
973
*--q=(*--p);
1057
974
return(destination);
1058
975
}
1071
988
% CloseCacheView() closes the specified view returned by a previous call to
1072
989
% OpenCacheView().
1073
990
%
1074
% Deprecated, replace with:
1075
%
1076
% DestroyCacheView(view_info);
1077
%
1078
991
% The format of the CloseCacheView method is:
1079
992
%
1080
993
% CacheView *CloseCacheView(CacheView *view_info)
1116
1029
%
1117
1030
% MagickBooleanType ColorFloodfillImage(Image *image,
1118
1031
% const DrawInfo *draw_info,const PixelPacket target,
1119
% const ssize_t x_offset,const ssize_t y_offset,const PaintMethod method)
1032
% const long x_offset,const long y_offset,const PaintMethod method)
1120
1033
%
1121
1034
% A description of each parameter follows:
1122
1035
%
1139
1052
ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
1140
1053
else \
1141
1054
{ \
1142
if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
1055
if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (long) image->rows)) \
1143
1056
{ \
1144
1057
s->x1=(double) (left); \
1145
1058
s->y1=(double) (up); \
1151
1064
}
1152
1065
1153
1066
MagickExport MagickBooleanType ColorFloodfillImage(Image *image,
1154
const DrawInfo *draw_info,const PixelPacket target,const ssize_t x_offset,
1155
const ssize_t y_offset,const PaintMethod method)
1067
const DrawInfo *draw_info,const PixelPacket target,const long x_offset,
1068
const long y_offset,const PaintMethod method)
1156
1069
{
1157
1070
Image
1158
1071
*floodplane_image;
1159
1072
1160
ssize_t
1073
long
1161
1074
offset,
1162
1075
start,
1163
1076
x,
1186
1099
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1187
1100
assert(draw_info != (DrawInfo *) NULL);
1188
1101
assert(draw_info->signature == MagickSignature);
1189
if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
1102
if ((x_offset < 0) || (x_offset >= (long) image->columns))
1190
1103
return(MagickFalse);
1191
if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
1104
if ((y_offset < 0) || (y_offset >= (long) image->rows))
1192
1105
return(MagickFalse);
1193
1106
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1194
1107
return(MagickFalse);
1224
1137
register const PixelPacket
1225
1138
*restrict p;
1226
1139
1227
register ssize_t
1140
register long
1228
1141
x;
1229
1142
1230
1143
register PixelPacket
1234
1147
Pop segment off stack.
1235
1148
*/
1236
1149
s--;
1237
x1=(ssize_t) s->x1;
1238
x2=(ssize_t) s->x2;
1239
offset=(ssize_t) s->y2;
1240
y=(ssize_t) s->y1+offset;
1150
x1=(long) s->x1;
1151
x2=(long) s->x2;
1152
offset=(long) s->y2;
1153
y=(long) s->y1+offset;
1241
1154
/*
1242
1155
Recolor neighboring pixels.
1243
1156
*/
1244
p=GetVirtualPixels(image,0,y,(size_t) (x1+1),1,&image->exception);
1245
q=GetAuthenticPixels(floodplane_image,0,y,(size_t) (x1+1),1,
1157
p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,&image->exception);
1158
q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,
1246
1159
&image->exception);
1247
1160
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
1248
1161
break;
1278
1191
{
1279
1192
if (skip == MagickFalse)
1280
1193
{
1281
if (x < (ssize_t) image->columns)
1194
if (x < (long) image->columns)
1282
1195
{
1283
1196
p=GetVirtualPixels(image,x,y,image->columns-x,1,
1284
1197
&image->exception);
1287
1200
if ((p == (const PixelPacket *) NULL) ||
1288
1201
(q == (PixelPacket *) NULL))
1289
1202
break;
1290
for ( ; x < (ssize_t) image->columns; x++)
1203
for ( ; x < (long) image->columns; x++)
1291
1204
{
1292
1205
if (q->opacity == (Quantum) TransparentOpacity)
1293
1206
break;
1314
1227
x++;
1315
1228
if (x <= x2)
1316
1229
{
1317
p=GetVirtualPixels(image,x,y,(size_t) (x2-x+1),1,
1230
p=GetVirtualPixels(image,x,y,(unsigned long) (x2-x+1),1,
1318
1231
&image->exception);
1319
q=GetAuthenticPixels(floodplane_image,x,y,(size_t) (x2-x+1),1,
1232
q=GetAuthenticPixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1,
1320
1233
&image->exception);
1321
1234
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
1322
1235
break;
1339
1252
start=x;
1340
1253
} while (x <= x2);
1341
1254
}
1342
for (y=0; y < (ssize_t) image->rows; y++)
1255
for (y=0; y < (long) image->rows; y++)
1343
1256
{
1344
1257
register const PixelPacket
1345
1258
*restrict p;
1346
1259
1347
register ssize_t
1260
register long
1348
1261
x;
1349
1262
1350
1263
register PixelPacket
1358
1271
q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
1359
1272
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
1360
1273
break;
1361
for (x=0; x < (ssize_t) image->columns; x++)
1274
for (x=0; x < (long) image->columns; x++)
1362
1275
{
1363
1276
if (p->opacity != OpaqueOpacity)
1364
1277
{
1374
1287
}
1375
1288
segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
1376
1289
floodplane_image=DestroyImage(floodplane_image);
1377
return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
1290
return(y == (long) image->rows ? MagickTrue : MagickFalse);
1378
1291
}
1379
1292
1380
1293
/*
1390
1303
%
1391
1304
% DeleteImageAttribute() deletes an attribute from the image.
1392
1305
%
1393
% Deprecated, replace with:
1394
%
1395
% DeleteImageProperty(image,key);
1396
%
1397
1306
% The format of the DeleteImageAttribute method is:
1398
1307
%
1399
1308
% MagickBooleanType DeleteImageAttribute(Image *image,const char *key)
1426
1335
%
1427
1336
% The format of the DeleteImageList method is:
1428
1337
%
1429
% unsigned int DeleteImageList(Image *images,const ssize_t offset)
1338
% unsigned int DeleteImageList(Image *images,const long offset)
1430
1339
%
1431
1340
% A description of each parameter follows:
1432
1341
%
1435
1344
% o offset: the position within the list.
1436
1345
%
1437
1346
*/
1438
MagickExport unsigned int DeleteImageList(Image *images,const ssize_t offset)
1347
MagickExport unsigned int DeleteImageList(Image *images,const long offset)
1439
1348
{
1440
register ssize_t
1349
register long
1441
1350
i;
1442
1351
1443
1352
if (images->debug != MagickFalse)
1469
1378
% It returns MagickTrue if the entry is deleted otherwise MagickFalse if no
1470
1379
% entry is found in the registry that matches the id.
1471
1380
%
1472
% Deprecated, replace with:
1473
%
1474
% char key[MaxTextExtent];
1475
% FormatMagickString(key,MaxTextExtent,"%ld\n",id);
1476
% DeleteImageRegistry(key);
1477
%
1478
1381
% The format of the DeleteMagickRegistry method is:
1479
1382
%
1480
% MagickBooleanType DeleteMagickRegistry(const ssize_t id)
1383
% MagickBooleanType DeleteMagickRegistry(const long id)
1481
1384
%
1482
1385
% A description of each parameter follows:
1483
1386
%
1484
1387
% o id: the registry id.
1485
1388
%
1486
1389
*/
1487
MagickExport MagickBooleanType DeleteMagickRegistry(const ssize_t id)
1390
MagickExport MagickBooleanType DeleteMagickRegistry(const long id)
1488
1391
{
1489
1392
char
1490
1393
key[MaxTextExtent];
1491
1394
1492
(void) FormatMagickString(key,MaxTextExtent,"%.20g\n",(double) id);
1395
(void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
1493
1396
return(DeleteImageRegistry(key));
1494
1397
}
1495
1398
1506
1409
%
1507
1410
% DestroyMagickRegistry() deallocates memory associated the magick registry.
1508
1411
%
1509
% Deprecated, replace with:
1510
%
1511
% RegistryComponentTerminus();
1512
%
1513
1412
% The format of the DestroyMagickRegistry method is:
1514
1413
%
1515
1414
% void DestroyMagickRegistry(void)
1534
1433
% DescribeImage() describes an image by printing its attributes to the file.
1535
1434
% Attributes include the image width, height, size, and others.
1536
1435
%
1537
% Deprecated, replace with:
1538
%
1539
% IdentifyImage(image,file,verbose);
1540
%
1541
1436
% The format of the DescribeImage method is:
1542
1437
%
1543
1438
% MagickBooleanType DescribeImage(Image *image,FILE *file,
1606
1501
%
1607
1502
% DestroyImages() destroys an image list.
1608
1503
%
1609
% Deprecated, replace with:
1610
%
1611
% DestroyImageList(image);
1612
%
1613
1504
% The format of the DestroyImages method is:
1614
1505
%
1615
1506
% void DestroyImages(Image *image)
1641
1532
%
1642
1533
% DestroyMagick() destroys the ImageMagick environment.
1643
1534
%
1644
% Deprecated, replace with:
1645
%
1646
% MagickCoreTerminus();
1647
%
1648
1535
% The format of the DestroyMagick function is:
1649
1536
%
1650
1537
% DestroyMagick(void)
1668
1555
%
1669
1556
% DispatchImage() extracts pixel data from an image and returns it to you.
1670
1557
% The method returns MagickFalse on success otherwise MagickTrue if an error is
1671
% encountered. The data is returned as char, short int, int, ssize_t, float,
1558
% encountered. The data is returned as char, short int, int, long, float,
1672
1559
% or double in the order specified by map.
1673
1560
%
1674
1561
% Suppose you want to extract the first scanline of a 640x480 image as
1676
1563
%
1677
1564
% DispatchImage(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
1678
1565
%
1679
% Deprecated, replace with:
1680
%
1681
% ExportImagePixels(image,x_offset,y_offset,columns,rows,map,type,pixels,
1682
% exception);
1683
%
1684
1566
% The format of the DispatchImage method is:
1685
1567
%
1686
% unsigned int DispatchImage(const Image *image,const ssize_t x_offset,
1687
% const ssize_t y_offset,const size_t columns,
1688
% const size_t rows,const char *map,const StorageType type,
1568
% unsigned int DispatchImage(const Image *image,const long x_offset,
1569
% const long y_offset,const unsigned long columns,
1570
% const unsigned long rows,const char *map,const StorageType type,
1689
1571
% void *pixels,ExceptionInfo *exception)
1690
1572
%
1691
1573
% A description of each parameter follows:
1712
1594
% o exception: return any errors or warnings in this structure.
1713
1595
%
1714
1596
*/
1715
MagickExport unsigned int DispatchImage(const Image *image,const ssize_t x_offset,
1716
const ssize_t y_offset,const size_t columns,const size_t rows,
1597
MagickExport unsigned int DispatchImage(const Image *image,const long x_offset,
1598
const long y_offset,const unsigned long columns,const unsigned long rows,
1717
1599
const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
1718
1600
{
1719
1601
unsigned int
1742
1624
%
1743
1625
% The format of the ExtractSubimageFromImageImage method is:
1744
1626
%
1745
% Image *ExtractSubimageFromImage(const Image *image,
1746
% const Image *reference,ExceptionInfo *exception)
1627
% Image *ExtractSubimageFromImage(const Image *image,const Image *reference,
1628
% ExceptionInfo *exception)
1747
1629
%
1748
1630
% A description of each parameter follows:
1749
1631
%
1756
1638
*/
1757
1639
1758
1640
static double GetSimilarityMetric(const Image *image,const Image *reference,
1759
const ssize_t x_offset,const ssize_t y_offset,const double similarity_threshold,
1641
const long x_offset,const long y_offset,const double similarity_threshold,
1760
1642
ExceptionInfo *exception)
1761
1643
{
1762
1644
CacheView
1763
1645
*image_view,
1764
1646
*reference_view;
1765
1647
1766
ssize_t
1648
long
1767
1649
y;
1768
1650
1769
1651
double
1784
1666
channels++;
1785
1667
image_view=AcquireCacheView(image);
1786
1668
reference_view=AcquireCacheView(reference);
1787
for (y=0; y < (ssize_t) reference->rows; y++)
1669
for (y=0; y < (long) reference->rows; y++)
1788
1670
{
1789
1671
register const IndexPacket
1790
1672
*indexes,
1794
1676
*p,
1795
1677
*q;
1796
1678
1797
register ssize_t
1679
register long
1798
1680
x;
1799
1681
1800
1682
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset+y,
1805
1687
continue;
1806
1688
indexes=GetCacheViewVirtualIndexQueue(image_view);
1807
1689
reference_indexes=GetCacheViewVirtualIndexQueue(reference_view);
1808
for (x=0; x < (ssize_t) reference->columns; x++)
1690
for (x=0; x < (long) reference->columns; x++)
1809
1691
{
1810
1692
MagickRealType
1811
1693
pixel;
1843
1725
MagickExport Image *ExtractSubimageFromImage(Image *image,
1844
1726
const Image *reference,ExceptionInfo *exception)
1845
1727
{
1846
ssize_t
1728
long
1847
1729
y;
1848
1730
1849
1731
double
1862
1744
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1863
1745
#pragma omp parallel for schedule(dynamic,4)
1864
1746
#endif
1865
for (y=0; y < (ssize_t) (image->rows-reference->rows); y++)
1747
for (y=0; y < (long) (image->rows-reference->rows); y++)
1866
1748
{
1867
1749
double
1868
1750
similarity;
1869
1751
1870
register ssize_t
1752
register long
1871
1753
x;
1872
1754
1873
for (x=0; x < (ssize_t) (image->columns-reference->columns); x++)
1755
for (x=0; x < (long) (image->columns-reference->columns); x++)
1874
1756
{
1875
1757
similarity=GetSimilarityMetric(image,reference,x,y,similarity_threshold,
1876
1758
exception);
1903
1785
%
1904
1786
% FlattenImages() Obsolete Function: Use MergeImageLayers() instead.
1905
1787
%
1906
% Deprecated, replace with:
1907
%
1908
% MergeImageLayers(image,FlattenLayer,exception);
1909
%
1910
1788
% The format of the FlattenImage method is:
1911
1789
%
1912
1790
% Image *FlattenImage(Image *image,ExceptionInfo *exception)
2149
2027
% method is used by MatteFloodFill() and other algorithms which compare
2150
2028
% two opacity values.
2151
2029
%
2152
% Deprecated, replace with:
2153
%
2154
% IsOpacitySimilar(image,p,q);
2155
%
2156
2030
% The format of the FuzzyOpacityCompare method is:
2157
2031
%
2158
2032
% void FuzzyOpacityCompare(const Image *image,const PixelPacket *p,
2230
2104
blob=FileToBlob(path,~0,length,exception);
2231
2105
}
2232
2106
#endif
2233
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !(defined(MAGICKCORE_CONFIGURE_PATH) || defined(MAGICKCORE_SHARE_CONFIGURE_PATH))
2107
#if defined(__WINDOWS__) && !(defined(MAGICKCORE_CONFIGURE_PATH) || defined(MAGICKCORE_SHARE_CONFIGURE_PATH))
2234
2108
if (blob == (void *) NULL)
2235
2109
{
2236
2110
char
2313
2187
*/
2314
2188
if ((blob == (void *) NULL) && (IsPathAccessible(path) != MagickFalse))
2315
2189
blob=FileToBlob(path,~0,length,exception);
2316
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
2190
#if defined(__WINDOWS__)
2317
2191
/*
2318
2192
Search Windows registry.
2319
2193
*/
2342
2216
% defined by the geometry parameters. A pointer to the pixels is returned if
2343
2217
% the pixels are transferred, otherwise a NULL is returned.
2344
2218
%
2345
% Deprecated, replace with:
2346
%
2347
% GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
2348
% GetCacheViewException(cache_view));
2349
%
2350
2219
% The format of the GetCacheView method is:
2351
2220
%
2352
% PixelPacket *GetCacheView(CacheView *cache_view,const ssize_t x,
2353
% const ssize_t y,const size_t columns,const size_t rows)
2221
% PixelPacket *GetCacheView(CacheView *cache_view,const long x,
2222
% const long y,const unsigned long columns,const unsigned long rows)
2354
2223
%
2355
2224
% A description of each parameter follows:
2356
2225
%
2360
2229
% pixels.
2361
2230
%
2362
2231
*/
2363
MagickExport PixelPacket *GetCacheView(CacheView *cache_view,const ssize_t x,
2364
const ssize_t y,const size_t columns,const size_t rows)
2232
MagickExport PixelPacket *GetCacheView(CacheView *cache_view,const long x,
2233
const long y,const unsigned long columns,const unsigned long rows)
2365
2234
{
2366
2235
PixelPacket
2367
2236
*pixels;
2385
2254
% GetCacheViewIndexes() returns the indexes associated with the specified
2386
2255
% view.
2387
2256
%
2388
% Deprecated, replace with:
2389
%
2390
% GetCacheViewAuthenticIndexQueue(cache_view);
2391
%
2392
2257
% The format of the GetCacheViewIndexes method is:
2393
2258
%
2394
2259
% IndexPacket *GetCacheViewIndexes(CacheView *cache_view)
2418
2283
% defined by the geometry parameters. A pointer to the pixels is returned if
2419
2284
% the pixels are transferred, otherwise a NULL is returned.
2420
2285
%
2421
% Deprecated, replace with:
2422
%
2423
% GetCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
2424
% GetCacheViewException(cache_view));
2425
%
2426
2286
% The format of the GetCacheViewPixels method is:
2427
2287
%
2428
% PixelPacket *GetCacheViewPixels(CacheView *cache_view,const ssize_t x,
2429
% const ssize_t y,const size_t columns,const size_t rows)
2288
% PixelPacket *GetCacheViewPixels(CacheView *cache_view,const long x,
2289
% const long y,const unsigned long columns,const unsigned long rows)
2430
2290
%
2431
2291
% A description of each parameter follows:
2432
2292
%
2436
2296
% pixels.
2437
2297
%
2438
2298
*/
2439
MagickExport PixelPacket *GetCacheViewPixels(CacheView *cache_view,const ssize_t x,
2440
const ssize_t y,const size_t columns,const size_t rows)
2299
MagickExport PixelPacket *GetCacheViewPixels(CacheView *cache_view,const long x,
2300
const long y,const unsigned long columns,const unsigned long rows)
2441
2301
{
2442
2302
PixelPacket
2443
2303
*pixels;
2537
2397
% GetImageClippingPathAttribute() searches the list of image attributes and
2538
2398
% returns a pointer to a clipping path if it exists otherwise NULL.
2539
2399
%
2540
% Deprecated, replace with:
2541
%
2542
% GetImageAttribute(image,"8BIM:1999,2998");
2543
%
2544
2400
% The format of the GetImageClippingPathAttribute method is:
2545
2401
%
2546
2402
% const ImageAttribute *GetImageClippingPathAttribute(Image *image)
2572
2428
% GetImageFromMagickRegistry() gets an image from the registry as defined by
2573
2429
% its name. If the image is not found, a NULL image is returned.
2574
2430
%
2575
% Deprecated, replace with:
2576
%
2577
% GetImageRegistry(ImageRegistryType,name,exception);
2578
%
2579
2431
% The format of the GetImageFromMagickRegistry method is:
2580
2432
%
2581
% Image *GetImageFromMagickRegistry(const char *name,ssize_t *id,
2433
% Image *GetImageFromMagickRegistry(const char *name,long *id,
2582
2434
% ExceptionInfo *exception)
2583
2435
%
2584
2436
% A description of each parameter follows:
2590
2442
% o exception: return any errors or warnings in this structure.
2591
2443
%
2592
2444
*/
2593
MagickExport Image *GetImageFromMagickRegistry(const char *name,ssize_t *id,
2445
MagickExport Image *GetImageFromMagickRegistry(const char *name,long *id,
2594
2446
ExceptionInfo *exception)
2595
2447
{
2596
2448
*id=0L;
2613
2465
%
2614
2466
% The format of the GetMagickRegistry method is:
2615
2467
%
2616
% const void *GetMagickRegistry(const ssize_t id,RegistryType *type,
2468
% const void *GetMagickRegistry(const long id,RegistryType *type,
2617
2469
% size_t *length,ExceptionInfo *exception)
2618
2470
%
2619
2471
% A description of each parameter follows:
2627
2479
% o exception: return any errors or warnings in this structure.
2628
2480
%
2629
2481
*/
2630
MagickExport void *GetMagickRegistry(const ssize_t id,RegistryType *type,
2482
MagickExport void *GetMagickRegistry(const long id,RegistryType *type,
2631
2483
size_t *length,ExceptionInfo *exception)
2632
2484
{
2633
2485
char
2638
2490
2639
2491
*type=UndefinedRegistryType;
2640
2492
*length=0;
2641
(void) FormatMagickString(key,MaxTextExtent,"%.20g\n",(double) id);
2493
(void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
2642
2494
blob=(void *) GetImageRegistry(ImageRegistryType,key,exception);
2643
2495
if (blob != (void *) NULL)
2644
2496
return(blob);
2662
2514
% GetImageGeometry() returns a region as defined by the geometry string with
2663
2515
% respect to the image and its gravity.
2664
2516
%
2665
% Deprecated, replace with:
2666
%
2667
% if (size_to_fit != MagickFalse)
2668
% ParseRegionGeometry(image,geometry,region_info,&image->exception); else
2669
% ParsePageGeometry(image,geometry,region_info,&image->exception);
2670
%
2671
2517
% The format of the GetImageGeometry method is:
2672
2518
%
2673
2519
% int GetImageGeometry(Image *image,const char *geometry,
2710
2556
%
2711
2557
% GetImageList() returns an image at the specified position in the list.
2712
2558
%
2713
% Deprecated, replace with:
2714
%
2715
% CloneImage(GetImageFromList(images,(ssize_t) offset),0,0,MagickTrue,
2716
% exception);
2717
%
2718
2559
% The format of the GetImageList method is:
2719
2560
%
2720
% Image *GetImageList(const Image *images,const ssize_t offset,
2561
% Image *GetImageList(const Image *images,const long offset,
2721
2562
% ExceptionInfo *exception)
2722
2563
%
2723
2564
% A description of each parameter follows:
2729
2570
% o exception: return any errors or warnings in this structure.
2730
2571
%
2731
2572
*/
2732
MagickExport Image *GetImageList(const Image *images,const ssize_t offset,
2573
MagickExport Image *GetImageList(const Image *images,const long offset,
2733
2574
ExceptionInfo *exception)
2734
2575
{
2735
2576
Image
2737
2578
2738
2579
if (images->debug != MagickFalse)
2739
2580
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
2740
image=CloneImage(GetImageFromList(images,(ssize_t) offset),0,0,MagickTrue,
2581
image=CloneImage(GetImageFromList(images,(long) offset),0,0,MagickTrue,
2741
2582
exception);
2742
2583
return(image);
2743
2584
}
2756
2597
% GetImageListIndex() returns the position in the list of the specified
2757
2598
% image.
2758
2599
%
2759
% Deprecated, replace with:
2760
%
2761
% GetImageIndexInList(images);
2762
%
2763
2600
% The format of the GetImageListIndex method is:
2764
2601
%
2765
% ssize_t GetImageListIndex(const Image *images)
2602
% long GetImageListIndex(const Image *images)
2766
2603
%
2767
2604
% A description of each parameter follows:
2768
2605
%
2769
2606
% o images: the image list.
2770
2607
%
2771
2608
*/
2772
MagickExport ssize_t GetImageListIndex(const Image *images)
2609
MagickExport long GetImageListIndex(const Image *images)
2773
2610
{
2774
2611
if (images->debug != MagickFalse)
2775
2612
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
2789
2626
%
2790
2627
% GetImageListSize() returns the number of images in the list.
2791
2628
%
2792
% Deprecated, replace with:
2793
%
2794
% GetImageListLength(images);
2795
%
2796
2629
% The format of the GetImageListSize method is:
2797
2630
%
2798
% size_t GetImageListSize(const Image *images)
2631
% unsigned long GetImageListSize(const Image *images)
2799
2632
%
2800
2633
% A description of each parameter follows:
2801
2634
%
2802
2635
% o images: the image list.
2803
2636
%
2804
2637
*/
2805
MagickExport size_t GetImageListSize(const Image *images)
2638
MagickExport unsigned long GetImageListSize(const Image *images)
2806
2639
{
2807
2640
if (images->debug != MagickFalse)
2808
2641
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
2839
2672
% array has been updated, the changes must be saved back to the underlying
2840
2673
% image using SyncAuthenticPixels() or they may be lost.
2841
2674
%
2842
% Deprecated, replace with:
2843
%
2844
% GetAuthenticPixels(image,x,y,columns,rows,&image->exception);
2845
%
2846
2675
% The format of the GetImagePixels() method is:
2847
2676
%
2848
% PixelPacket *GetImagePixels(Image *image,const ssize_t x,const ssize_t y,
2849
% const size_t columns,const size_t rows)
2677
% PixelPacket *GetImagePixels(Image *image,const long x,const long y,
2678
% const unsigned long columns,const unsigned long rows)
2850
2679
%
2851
2680
% A description of each parameter follows:
2852
2681
%
2856
2685
% pixels.
2857
2686
%
2858
2687
*/
2859
MagickExport PixelPacket *GetImagePixels(Image *image,const ssize_t x,const ssize_t y,
2860
const size_t columns,const size_t rows)
2688
MagickExport PixelPacket *GetImagePixels(Image *image,const long x,const long y,
2689
const unsigned long columns,const unsigned long rows)
2861
2690
{
2862
2691
return(GetAuthenticPixels(image,x,y,columns,rows,&image->exception));
2863
2692
}
2877
2706
% with the last call to QueueAuthenticPixels() or GetVirtualPixels(). NULL is
2878
2707
% returned if the black channel or colormap indexes are not available.
2879
2708
%
2880
% Deprecated, replace with:
2881
%
2882
% GetAuthenticIndexQueue(image);
2883
%
2884
2709
% The format of the GetIndexes() method is:
2885
2710
%
2886
2711
% IndexPacket *GetIndexes(const Image *image)
2913
2738
% geometry is modified as determined by the meta characters: %, !, <, >,
2914
2739
% and ~.
2915
2740
%
2916
% Deprecated, replace with:
2917
%
2918
% ParseMetaGeometry(geometry,x,y,width,height);
2919
%
2920
2741
% The format of the GetMagickGeometry method is:
2921
2742
%
2922
% unsigned int GetMagickGeometry(const char *geometry,ssize_t *x,ssize_t *y,
2923
% size_t *width,size_t *height)
2743
% unsigned int GetMagickGeometry(const char *geometry,long *x,long *y,
2744
% unsigned long *width,unsigned long *height)
2924
2745
%
2925
2746
% A description of each parameter follows:
2926
2747
%
2934
2755
% as determined by the geometry specification is returned here.
2935
2756
%
2936
2757
*/
2937
MagickExport unsigned int GetMagickGeometry(const char *geometry,ssize_t *x,
2938
ssize_t *y,size_t *width,size_t *height)
2758
MagickExport unsigned int GetMagickGeometry(const char *geometry,long *x,
2759
long *y,unsigned long *width,unsigned long *height)
2939
2760
{
2940
2761
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.3");
2941
2762
return(ParseMetaGeometry(geometry,x,y,width,height));
2954
2775
%
2955
2776
% GetNextImage() returns the next image in a list.
2956
2777
%
2957
% Deprecated, replace with:
2958
%
2959
% GetNextImageInList(images);
2960
%
2961
2778
% The format of the GetNextImage method is:
2962
2779
%
2963
2780
% Image *GetNextImage(const Image *images)
2987
2804
%
2988
2805
% GetNextImageAttribute() gets the next image attribute.
2989
2806
%
2990
% Deprecated, replace with:
2991
%
2992
% const char *property;
2993
% property=GetNextImageProperty(image);
2994
% if (property != (const char *) NULL)
2995
% GetImageAttribute(image,property);
2996
%
2997
2807
% The format of the GetNextImageAttribute method is:
2998
2808
%
2999
2809
% const ImageAttribute *GetNextImageAttribute(const Image *image)
3027
2837
%
3028
2838
% GetNumberScenes() returns the number of images in the list.
3029
2839
%
3030
% Deprecated, replace with:
3031
%
3032
% GetImageListLength(image);
3033
%
3034
2840
% The format of the GetNumberScenes method is:
3035
2841
%
3036
2842
% unsigned int GetNumberScenes(const Image *images)
3061
2867
% GetOnePixel() returns a single pixel at the specified (x,y) location.
3062
2868
% The image background color is returned if an error occurs.
3063
2869
%
3064
% Deprecated, replace with:
3065
%
3066
% GetOneAuthenticPixel(image,x,y,&pixel,&image->exception);
3067
%
3068
2870
% The format of the GetOnePixel() method is:
3069
2871
%
3070
% PixelPacket GetOnePixel(const Image image,const ssize_t x,const ssize_t y)
2872
% PixelPacket GetOnePixel(const Image image,const long x,const long y)
3071
2873
%
3072
2874
% A description of each parameter follows:
3073
2875
%
3076
2878
% o x,y: These values define the location of the pixel to return.
3077
2879
%
3078
2880
*/
3079
MagickExport PixelPacket GetOnePixel(Image *image,const ssize_t x,const ssize_t y)
2881
MagickExport PixelPacket GetOnePixel(Image *image,const long x,const long y)
3080
2882
{
3081
2883
PixelPacket
3082
2884
pixel;
3099
2901
% GetPixels() returns the pixels associated with the last call to
3100
2902
% QueueAuthenticPixels() or GetAuthenticPixels().
3101
2903
%
3102
% Deprecated, replace with:
3103
%
3104
% GetAuthenticPixelQueue(image);
3105
%
3106
2904
% The format of the GetPixels() method is:
3107
2905
%
3108
2906
% PixelPacket *GetPixels(const Image image)
3133
2931
%
3134
2932
% GetPreviousImage() returns the previous image in a list.
3135
2933
%
3136
% Deprecated, replace with:
3137
%
3138
% GetPreviousImageInList(images));
3139
%
3140
2934
% The format of the GetPreviousImage method is:
3141
2935
%
3142
2936
% Image *GetPreviousImage(const Image *images)
3271
3065
%
3272
3066
% InitializeMagick() initializes the ImageMagick environment.
3273
3067
%
3274
% Deprecated, replace with:
3275
%
3276
% MagickCoreGenesis(path,MagickFalse);
3277
%
3278
3068
% The format of the InitializeMagick function is:
3279
3069
%
3280
3070
% InitializeMagick(const char *path)
3394
3184
return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3395
3185
}
3396
3186
3397
static inline ssize_t NearestNeighbor(MagickRealType x)
3187
static inline long NearestNeighbor(MagickRealType x)
3398
3188
{
3399
3189
if (x >= 0.0)
3400
return((ssize_t) (x+0.5));
3401
return((ssize_t) (x-0.5));
3190
return((long) (x+0.5));
3191
return((long) (x-0.5));
3402
3192
}
3403
3193
3404
3194
MagickExport MagickPixelPacket InterpolatePixelColor(const Image *image,
3414
3204
register const PixelPacket
3415
3205
*p;
3416
3206
3417
register ssize_t
3207
register long
3418
3208
i;
3419
3209
3420
3210
assert(image != (Image *) NULL);
3432
3222
alpha[16],
3433
3223
gamma;
3434
3224
3435
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t) floor(y)-
3225
p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-
3436
3226
1,4,4,exception);
3437
3227
if (p == (const PixelPacket *) NULL)
3438
3228
break;
3475
3265
PointInfo
3476
3266
delta;
3477
3267
3478
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t) floor(y)-
3268
p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-
3479
3269
1,4,4,exception);
3480
3270
if (p == (const PixelPacket *) NULL)
3481
3271
break;
3516
3306
PointInfo
3517
3307
delta;
3518
3308
3519
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t) floor(y),2,
3309
p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),2,
3520
3310
2,exception);
3521
3311
if (p == (const PixelPacket *) NULL)
3522
3312
break;
3574
3364
3575
3365
geometry.width=4L;
3576
3366
geometry.height=4L;
3577
geometry.x=(ssize_t) floor(x)-1L;
3578
geometry.y=(ssize_t) floor(y)-1L;
3367
geometry.x=(long) floor(x)-1L;
3368
geometry.y=(long) floor(y)-1L;
3579
3369
excerpt_image=ExcerptImage(image,&geometry,exception);
3580
3370
if (excerpt_image == (Image *) NULL)
3581
3371
break;
3601
3391
MagickPixelPacket
3602
3392
pixels[1];
3603
3393
3604
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t) floor(y),1,
3394
p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),1,
3605
3395
1,exception);
3606
3396
if (p == (const PixelPacket *) NULL)
3607
3397
break;
3623
3413
delta,
3624
3414
luminance;
3625
3415
3626
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t) floor(y),
3416
p=GetCacheViewVirtualPixels(image_view,(long) floor(x),(long) floor(y),
3627
3417
2,2,exception);
3628
3418
if (p == (const PixelPacket *) NULL)
3629
3419
break;
3758
3548
}
3759
3549
case SplineInterpolatePixel:
3760
3550
{
3761
ssize_t
3551
long
3762
3552
j,
3763
3553
n;
3764
3554
3774
3564
PointInfo
3775
3565
delta;
3776
3566
3777
p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t) floor(y)-
3567
p=GetCacheViewVirtualPixels(image_view,(long) floor(x)-1,(long) floor(y)-
3778
3568
1,4,4,exception);
3779
3569
if (p == (const PixelPacket *) NULL)
3780
3570
break;
3792
3582
alpha[n]=1.0;
3793
3583
if (image->matte != MagickFalse)
3794
3584
{
3795
alpha[n]=QuantumScale*((MagickRealType)
3796
GetAlphaPixelComponent(p));
3585
alpha[n]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
3797
3586
pixels[n].red*=alpha[n];
3798
3587
pixels[n].green*=alpha[n];
3799
3588
pixels[n].blue*=alpha[n];
3834
3623
% InterpretImageAttributes() replaces any embedded formatting characters with
3835
3624
% the appropriate image attribute and returns the translated text.
3836
3625
%
3837
% Deprecated, replace with:
3838
%
3839
% InterpretImageProperties(image_info,image,embed_text);
3840
%
3841
3626
% The format of the InterpretImageAttributes method is:
3842
3627
%
3843
3628
% char *InterpretImageAttributes(const ImageInfo *image_info,Image *image,
3922
3707
% appropriatally. This effectivally maps a greyscale gradient into the given
3923
3708
% color gradient.
3924
3709
%
3925
% Deprecated, replace with:
3926
%
3927
% LevelColorsImageChannel(image,channel,black_color,white_color,invert);
3928
%
3929
3710
% The format of the LevelImageColors method is:
3930
3711
%
3931
3712
% MagickBooleanType LevelImageColors(Image *image,const ChannelType channel,
3998
3779
%
3999
3780
% LiberateSemaphoreInfo() relinquishes a semaphore.
4000
3781
%
4001
% Deprecated, replace with:
4002
%
4003
% UnlockSemaphoreInfo(*semaphore_info);
4004
%
4005
3782
% The format of the LiberateSemaphoreInfo method is:
4006
3783
%
4007
3784
% LiberateSemaphoreInfo(void **semaphore_info)
4030
3807
%
4031
3808
% MagickIncarnate() initializes the ImageMagick environment.
4032
3809
%
4033
% Deprecated, replace with:
4034
%
4035
% MagickCoreGenesis(path,MagickFalse);
4036
%
4037
3810
% The format of the MagickIncarnate function is:
4038
3811
%
4039
3812
% MagickIncarnate(const char *path)
4117
3890
% MapImage() replaces the colors of an image with the closest color from a
4118
3891
% reference image.
4119
3892
%
4120
% Deprecated, replace with:
4121
%
4122
% QuantizeInfo quantize_info;
4123
% GetQuantizeInfo(&quantize_info);
4124
% quantize_info.dither=dither;
4125
% RemapImage(&quantize_info,image,map_image);
4126
%
4127
3893
% The format of the MapImage method is:
4128
3894
%
4129
3895
% MagickBooleanType MapImage(Image *image,const Image *map_image,
4174
3940
% MapImages() replaces the colors of a sequence of images with the closest
4175
3941
% color from a reference image.
4176
3942
%
4177
% Deprecated, replace with:
4178
%
4179
% QuantizeInfo quantize_info;
4180
% GetQuantizeInfo(&quantize_info);
4181
% quantize_info.dither=dither;
4182
% RemapImages(&quantize_info,images,map_image);
4183
%
4184
3943
% The format of the MapImage method is:
4185
3944
%
4186
3945
% MagickBooleanType MapImages(Image *images,Image *map_image,
4238
3997
% The format of the MatteFloodfillImage method is:
4239
3998
%
4240
3999
% MagickBooleanType MatteFloodfillImage(Image *image,
4241
% const PixelPacket target,const Quantum opacity,const ssize_t x_offset,
4242
% const ssize_t y_offset,const PaintMethod method)
4000
% const PixelPacket target,const Quantum opacity,const long x_offset,
4001
% const long y_offset,const PaintMethod method)
4243
4002
%
4244
4003
% A description of each parameter follows:
4245
4004
%
4256
4015
%
4257
4016
*/
4258
4017
MagickExport MagickBooleanType MatteFloodfillImage(Image *image,
4259
const PixelPacket target,const Quantum opacity,const ssize_t x_offset,
4260
const ssize_t y_offset,const PaintMethod method)
4018
const PixelPacket target,const Quantum opacity,const long x_offset,
4019
const long y_offset,const PaintMethod method)
4261
4020
{
4262
4021
Image
4263
4022
*floodplane_image;
4264
4023
4265
ssize_t
4024
long
4266
4025
offset,
4267
4026
start,
4268
4027
x,
4286
4045
assert(image->signature == MagickSignature);
4287
4046
if (image->debug != MagickFalse)
4288
4047
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4289
if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
4048
if ((x_offset < 0) || (x_offset >= (long) image->columns))
4290
4049
return(MagickFalse);
4291
if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
4050
if ((y_offset < 0) || (y_offset >= (long) image->rows))
4292
4051
return(MagickFalse);
4293
4052
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
4294
4053
return(MagickFalse);
4324
4083
register const PixelPacket
4325
4084
*restrict p;
4326
4085
4327
register ssize_t
4086
register long
4328
4087
x;
4329
4088
4330
4089
register PixelPacket
4334
4093
Pop segment off stack.
4335
4094
*/
4336
4095
s--;
4337
x1=(ssize_t) s->x1;
4338
x2=(ssize_t) s->x2;
4339
offset=(ssize_t) s->y2;
4340
y=(ssize_t) s->y1+offset;
4096
x1=(long) s->x1;
4097
x2=(long) s->x2;
4098
offset=(long) s->y2;
4099
y=(long) s->y1+offset;
4341
4100
/*
4342
4101
Recolor neighboring pixels.
4343
4102
*/
4344
p=GetVirtualPixels(image,0,y,(size_t) (x1+1),1,&image->exception);
4345
q=GetAuthenticPixels(floodplane_image,0,y,(size_t) (x1+1),1,
4103
p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,&image->exception);
4104
q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,
4346
4105
&image->exception);
4347
4106
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
4348
4107
break;
4378
4137
{
4379
4138
if (skip == MagickFalse)
4380
4139
{
4381
if (x < (ssize_t) image->columns)
4140
if (x < (long) image->columns)
4382
4141
{
4383
4142
p=GetVirtualPixels(image,x,y,image->columns-x,1,
4384
4143
&image->exception);
4387
4146
if ((p == (const PixelPacket *) NULL) ||
4388
4147
(q == (PixelPacket *) NULL))
4389
4148
break;
4390
for ( ; x < (ssize_t) image->columns; x++)
4149
for ( ; x < (long) image->columns; x++)
4391
4150
{
4392
4151
if (q->opacity == (Quantum) TransparentOpacity)
4393
4152
break;
4414
4173
x++;
4415
4174
if (x <= x2)
4416
4175
{
4417
p=GetVirtualPixels(image,x,y,(size_t) (x2-x+1),1,
4176
p=GetVirtualPixels(image,x,y,(unsigned long) (x2-x+1),1,
4418
4177
&image->exception);
4419
q=GetAuthenticPixels(floodplane_image,x,y,(size_t) (x2-x+1),1,
4178
q=GetAuthenticPixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1,
4420
4179
&image->exception);
4421
4180
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
4422
4181
break;
4439
4198
start=x;
4440
4199
} while (x <= x2);
4441
4200
}
4442
for (y=0; y < (ssize_t) image->rows; y++)
4201
for (y=0; y < (long) image->rows; y++)
4443
4202
{
4444
4203
register const PixelPacket
4445
4204
*restrict p;
4446
4205
4447
register ssize_t
4206
register long
4448
4207
x;
4449
4208
4450
4209
register PixelPacket
4458
4217
q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
4459
4218
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
4460
4219
break;
4461
for (x=0; x < (ssize_t) image->columns; x++)
4220
for (x=0; x < (long) image->columns; x++)
4462
4221
{
4463
4222
if (p->opacity != OpaqueOpacity)
4464
4223
q->opacity=opacity;
4470
4229
}
4471
4230
segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
4472
4231
floodplane_image=DestroyImage(floodplane_image);
4473
return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
4232
return(y == (long) image->rows ? MagickTrue : MagickFalse);
4474
4233
}
4475
4234
4476
4235
/*
4486
4245
%
4487
4246
% MaximumImages() returns the maximum intensity of an image sequence.
4488
4247
%
4489
% Deprecated, replace with:
4490
%
4491
% EvaluateImages(images,MinEvaluateOperator,exception);
4492
%
4493
4248
% The format of the MaxImages method is:
4494
4249
%
4495
4250
% Image *MaximumImages(Image *images,ExceptionInfo *exception)
4519
4274
%
4520
4275
% MinimumImages() returns the minimum intensity of an image sequence.
4521
4276
%
4522
% Deprecated, replace with:
4523
%
4524
% EvaluateImages(images,MinEvaluateOperator,exception);
4525
%
4526
4277
% The format of the MinimumImages method is:
4527
4278
%
4528
4279
% Image *MinimumImages(Image *images,ExceptionInfo *exception)
4552
4303
%
4553
4304
% MosaicImages() Obsolete Function: Use MergeImageLayers() instead.
4554
4305
%
4555
% Deprecated, replace with:
4556
%
4557
% MergeImageLayers(image,MosaicLayer,exception);
4558
%
4559
4306
% The format of the MosaicImage method is:
4560
4307
%
4561
4308
% Image *MosaicImages(const Image *image,ExceptionInfo *exception)
4611
4358
{
4612
4359
#define OpaqueImageTag "Opaque/Image"
4613
4360
4614
ssize_t
4361
long
4615
4362
y;
4616
4363
4617
4364
MagickBooleanType
4618
4365
proceed;
4619
4366
4620
register ssize_t
4367
register long
4621
4368
i;
4622
4369
4623
4370
/*
4636
4383
/*
4637
4384
Make DirectClass image opaque.
4638
4385
*/
4639
for (y=0; y < (ssize_t) image->rows; y++)
4386
for (y=0; y < (long) image->rows; y++)
4640
4387
{
4641
register ssize_t
4388
register long
4642
4389
x;
4643
4390
4644
4391
register PixelPacket
4647
4394
q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
4648
4395
if (q == (PixelPacket *) NULL)
4649
4396
break;
4650
for (x=0; x < (ssize_t) image->columns; x++)
4397
for (x=0; x < (long) image->columns; x++)
4651
4398
{
4652
4399
if (IsColorSimilar(image,q,&target) != MagickFalse)
4653
4400
*q=fill;
4655
4402
}
4656
4403
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
4657
4404
break;
4658
proceed=SetImageProgress(image,OpaqueImageTag,(MagickOffsetType) y,
4659
image->rows);
4405
proceed=SetImageProgress(image,OpaqueImageTag,y,image->rows);
4660
4406
if (proceed == MagickFalse)
4661
4407
break;
4662
4408
}
4667
4413
/*
4668
4414
Make PseudoClass image opaque.
4669
4415
*/
4670
for (i=0; i < (ssize_t) image->colors; i++)
4416
for (i=0; i < (long) image->colors; i++)
4671
4417
{
4672
4418
if (IsColorSimilar(image,&image->colormap[i],&target) != MagickFalse)
4673
4419
image->colormap[i]=fill;
4674
4420
}
4675
4421
if (fill.opacity != OpaqueOpacity)
4676
4422
{
4677
for (y=0; y < (ssize_t) image->rows; y++)
4423
for (y=0; y < (long) image->rows; y++)
4678
4424
{
4679
register ssize_t
4425
register long
4680
4426
x;
4681
4427
4682
4428
register PixelPacket
4685
4431
q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
4686
4432
if (q == (PixelPacket *) NULL)
4687
4433
break;
4688
for (x=0; x < (ssize_t) image->columns; x++)
4434
for (x=0; x < (long) image->columns; x++)
4689
4435
{
4690
4436
if (IsColorSimilar(image,q,&target) != MagickFalse)
4691
4437
q->opacity=fill.opacity;
4718
4464
% OpenCacheView() opens a view into the pixel cache, using the
4719
4465
% VirtualPixelMethod that is defined within the given image itself.
4720
4466
%
4721
% Deprecated, replace with:
4722
%
4723
% AcquireCacheView(image);
4724
%
4725
4467
% The format of the OpenCacheView method is:
4726
4468
%
4727
4469
% CacheView *OpenCacheView(const Image *image)
4759
4501
% color red at intensities of 100 and 102 respectively are now
4760
4502
% interpreted as the same color for the purposes of the floodfill.
4761
4503
%
4762
% Deprecated, replace with:
4763
%
4764
% FloodfillPaintImage(image,channel,draw_info,target,x,y,
4765
% method == FloodfillMethod ? MagickFalse : MagickTrue);
4766
%
4767
4504
% The format of the PaintFloodfillImage method is:
4768
4505
%
4769
4506
% MagickBooleanType PaintFloodfillImage(Image *image,
4770
% const ChannelType channel,const MagickPixelPacket target,const ssize_t x,
4771
% const ssize_t y,const DrawInfo *draw_info,const PaintMethod method)
4507
% const ChannelType channel,const MagickPixelPacket target,const long x,
4508
% const long y,const DrawInfo *draw_info,const PaintMethod method)
4772
4509
%
4773
4510
% A description of each parameter follows:
4774
4511
%
4786
4523
%
4787
4524
*/
4788
4525
MagickExport MagickBooleanType PaintFloodfillImage(Image *image,
4789
const ChannelType channel,const MagickPixelPacket *target,const ssize_t x,
4790
const ssize_t y,const DrawInfo *draw_info,const PaintMethod method)
4526
const ChannelType channel,const MagickPixelPacket *target,const long x,
4527
const long y,const DrawInfo *draw_info,const PaintMethod method)
4791
4528
{
4792
4529
MagickBooleanType
4793
4530
status;
4815
4552
% For example, set fuzz to 10 and the color red at intensities of 100 and
4816
4553
% 102 respectively are now interpreted as the same color.
4817
4554
%
4818
% Deprecated, replace with:
4819
%
4820
% OpaquePaintImageChannel(image,DefaultChannels,target,fill,MagickFalse);
4821
% OpaquePaintImageChannel(image,channel,target,fill,MagickFalse);
4822
%
4823
4555
% The format of the PaintOpaqueImage method is:
4824
4556
%
4825
4557
% MagickBooleanType PaintOpaqueImage(Image *image,
4877
4609
% For example, set fuzz to 10 and the color red at intensities of 100 and
4878
4610
% 102 respectively are now interpreted as the same color.
4879
4611
%
4880
% Deprecated, replace with:
4881
%
4882
% TransparentPaintImage(image,target,opacity,MagickFalse);
4883
%
4884
4612
% The format of the PaintTransparentImage method is:
4885
4613
%
4886
4614
% MagickBooleanType PaintTransparentImage(Image *image,
4916
4644
% geometry is modified as determined by the meta characters: %, !, <,
4917
4645
% and >.
4918
4646
%
4919
% Deprecated, replace with:
4920
%
4921
% ParseMetaGeometry(geometry,x,y,width,height);
4922
%
4923
4647
% The format of the ParseImageGeometry method is:
4924
4648
%
4925
% int ParseImageGeometry(char *geometry,ssize_t *x,ssize_t *y,
4926
% size_t *width,size_t *height)
4649
% int ParseImageGeometry(char *geometry,long *x,long *y,
4650
% unsigned long *width,unsigned long *height)
4927
4651
%
4928
4652
% A description of each parameter follows:
4929
4653
%
4940
4664
% as determined by the geometry specification is returned here.
4941
4665
%
4942
4666
*/
4943
MagickExport int ParseImageGeometry(const char *geometry,ssize_t *x,ssize_t *y,
4944
size_t *width,size_t *height)
4667
MagickExport int ParseImageGeometry(const char *geometry,long *x,long *y,
4668
unsigned long *width,unsigned long *height)
4945
4669
{
4946
4670
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.1");
4947
4671
return((int) ParseMetaGeometry(geometry,x,y,width,height));
4961
4685
% ParseSizeGeometry() returns a region as defined by the geometry string with
4962
4686
% respect to the image dimensions and aspect ratio.
4963
4687
%
4964
% Deprecated, replace with:
4965
%
4966
% ParseMetaGeometry(geometry,®ion_info->x,®ion_info->y,
4967
% ®ion_info->width,®ion_info->height);
4968
%
4969
4688
% The format of the ParseSizeGeometry method is:
4970
4689
%
4971
4690
% MagickStatusType ParseSizeGeometry(const Image *image,
5004
4723
%
5005
4724
% PopImageList() removes the last image in the list.
5006
4725
%
5007
% Deprecated, replace with:
5008
%
5009
% RemoveLastImageFromList(images);
5010
%
5011
4726
% The format of the PopImageList method is:
5012
4727
%
5013
4728
% Image *PopImageList(Image **images)
5085
4800
% PostscriptGeometry() replaces any page mneumonic with the equivalent size in
5086
4801
% picas.
5087
4802
%
5088
% Deprecated, replace with:
5089
%
5090
% GetPageGeometry(page);
5091
%
5092
4803
% The format of the PostscriptGeometry method is:
5093
4804
%
5094
4805
% char *PostscriptGeometry(const char *page)
5119
4830
%
5120
4831
% PushImageList() adds an image to the end of the list.
5121
4832
%
5122
% Deprecated, replace with:
5123
%
5124
% AppendImageToList(images,CloneImageList(image,exception));
5125
%
5126
4833
% The format of the PushImageList method is:
5127
4834
%
5128
4835
% unsigned int PushImageList(Image *images,const Image *image,
5224
4931
% distance measure is normalized to a range between 0 and 1. It is
5225
4932
% independent of the range of red, green, and blue values in your image.
5226
4933
%
5227
% Deprecated, replace with:
5228
%
5229
% GetImageQuantizeError(image);
5230
4934
%
5231
4935
% The format of the QuantizationError method is:
5232
4936
%
5287
4991
lower_threshold,
5288
4992
upper_threshold;
5289
4993
5290
ssize_t
4994
long
5291
4995
count,
5292
4996
y;
5293
4997
5301
5005
1.2f, 0.4f, 0.9f, 1.3f, 0.2f},
5302
5006
threshold=128;
5303
5007
5304
size_t
5008
unsigned long
5305
5009
order;
5306
5010
5307
5011
/*
5330
5034
order=1;
5331
5035
lower_threshold=0;
5332
5036
upper_threshold=0;
5333
count=(ssize_t) sscanf(thresholds,"%lf[/x%%]%lf",&lower_threshold,
5037
count=sscanf(thresholds,"%lf[/x%%]%lf",&lower_threshold,
5334
5038
&upper_threshold);
5335
5039
if (strchr(thresholds,'%') != (char *) NULL)
5336
5040
{
5352
5056
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
5353
5057
image->filename);
5354
5058
random_info=AcquireRandomInfo();
5355
for (y=0; y < (ssize_t) image->rows; y++)
5059
for (y=0; y < (long) image->rows; y++)
5356
5060
{
5357
register ssize_t
5061
register long
5358
5062
x;
5359
5063
5360
5064
register IndexPacket
5371
5075
LocaleCompare(channel,"intensity") == 0)
5372
5076
{
5373
5077
indexes=GetAuthenticIndexQueue(image);
5374
for (x=0; x < (ssize_t) image->columns; x++)
5078
for (x=0; x < (long) image->columns; x++)
5375
5079
{
5376
5080
MagickRealType
5377
5081
intensity;
5397
5101
threshold ? 0 : QuantumRange);
5398
5102
index=(IndexPacket) (intensity <= threshold ? 0 : 1);
5399
5103
*indexes++=index;
5400
q->red=q->green=q->blue=image->colormap[(ssize_t) index].red;
5104
q->red=q->green=q->blue=image->colormap[(long) index].red;
5401
5105
q++;
5402
5106
}
5403
5107
}
5406
5110
LocaleCompare(channel,"matte") == 0)
5407
5111
{
5408
5112
if (image->matte != MagickFalse)
5409
for (x=0; x < (ssize_t) image->columns; x++)
5113
for (x=0; x < (long) image->columns; x++)
5410
5114
{
5411
5115
if (order == 1)
5412
5116
{
5493
5197
% %
5494
5198
% %
5495
5199
% %
5496
% R e c o l o r I m a g e %
5497
% %
5498
% %
5499
% %
5500
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5501
%
5502
% RecolorImage() apply color transformation to an image. The method permits
5503
% saturation changes, hue rotation, luminance to alpha, and various other
5504
% effects. Although variable-sized transformation matrices can be used,
5505
% typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA
5506
% (or RGBA with offsets). The matrix is similar to those used by Adobe Flash
5507
% except offsets are in column 6 rather than 5 (in support of CMYKA images)
5508
% and offsets are normalized (divide Flash offset by 255).
5509
%
5510
% The format of the RecolorImage method is:
5511
%
5512
% Image *RecolorImage(const Image *image,const size_t order,
5513
% const double *color_matrix,ExceptionInfo *exception)
5514
%
5515
% A description of each parameter follows:
5516
%
5517
% o image: the image.
5518
%
5519
% o order: the number of columns and rows in the recolor matrix.
5520
%
5521
% o color_matrix: An array of double representing the recolor matrix.
5522
%
5523
% o exception: return any errors or warnings in this structure.
5524
%
5525
*/
5526
MagickExport Image *RecolorImage(const Image *image,const size_t order,
5527
const double *color_matrix,ExceptionInfo *exception)
5528
{
5529
KernelInfo
5530
*kernel_info;
5531
5532
Image
5533
*recolor_image;
5534
5535
kernel_info=AcquireKernelInfo("1");
5536
if (kernel_info == (KernelInfo *) NULL)
5537
return((Image *) NULL);
5538
kernel_info->width=order;
5539
kernel_info->height=order;
5540
kernel_info->values=(double *) color_matrix;
5541
recolor_image=ColorMatrixImage(image,kernel_info,exception);
5542
kernel_info->values=(double *) NULL;
5543
kernel_info=DestroyKernelInfo(kernel_info);
5544
return(recolor_image);
5545
}
5546
5547
/*
5548
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5549
% %
5550
% %
5551
% %
5552
5200
% R e s e t I m a g e A t t r i b u t e I t e r a t o r %
5553
5201
% %
5554
5202
% %
5559
5207
% in conjunction with GetNextImageAttribute() to iterate over all the values
5560
5208
% associated with an image.
5561
5209
%
5562
% Deprecated, replace with:
5563
%
5564
% ResetImagePropertyIterator(image);
5565
%
5566
5210
% The format of the ResetImageAttributeIterator method is:
5567
5211
%
5568
5212
% ResetImageAttributeIterator(const ImageInfo *image)
5592
5236
% defined by the geometry parameters. A pointer to the pixels is returned
5593
5237
% if the pixels are transferred, otherwise a NULL is returned.
5594
5238
%
5595
% Deprecated, replace with:
5596
%
5597
% QueueCacheViewAuthenticPixels(cache_view,x,y,columns,rows,
5598
% GetCacheViewException(cache_view));
5599
%
5600
5239
% The format of the SetCacheViewPixels method is:
5601
5240
%
5602
% PixelPacket *SetCacheViewPixels(CacheView *cache_view,const ssize_t x,
5603
% const ssize_t y,const size_t columns,const size_t rows)
5241
% PixelPacket *SetCacheViewPixels(CacheView *cache_view,const long x,
5242
% const long y,const unsigned long columns,const unsigned long rows)
5604
5243
%
5605
5244
% A description of each parameter follows:
5606
5245
%
5610
5249
% pixels.
5611
5250
%
5612
5251
*/
5613
MagickExport PixelPacket *SetCacheViewPixels(CacheView *cache_view,const ssize_t x,
5614
const ssize_t y,const size_t columns,const size_t rows)
5252
MagickExport PixelPacket *SetCacheViewPixels(CacheView *cache_view,const long x,
5253
const long y,const unsigned long columns,const unsigned long rows)
5615
5254
{
5616
5255
PixelPacket
5617
5256
*pixels;
5646
5285
% cache.
5647
5286
%
5648
5287
*/
5649
MagickExport void SetCacheThreshold(const size_t size)
5288
MagickExport void SetCacheThreshold(const unsigned long size)
5650
5289
{
5651
5290
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.1");
5652
5291
(void) SetMagickResourceLimit(MemoryResource,size*1024*1024);
5716
5355
*/
5717
5356
MagickExport void SetImage(Image *image,const Quantum opacity)
5718
5357
{
5719
ssize_t
5358
long
5720
5359
y;
5721
5360
5722
5361
PixelPacket
5741
5380
/*
5742
5381
Set colormapped or CMYK image.
5743
5382
*/
5744
for (y=0; y < (ssize_t) image->rows; y++)
5383
for (y=0; y < (long) image->rows; y++)
5745
5384
{
5746
5385
register IndexPacket
5747
5386
*restrict indexes;
5748
5387
5749
register ssize_t
5388
register long
5750
5389
x;
5751
5390
5752
5391
register PixelPacket
5755
5394
q=QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
5756
5395
if (q == (PixelPacket *) NULL)
5757
5396
break;
5758
for (x=0; x < (ssize_t) image->columns; x++)
5397
for (x=0; x < (long) image->columns; x++)
5759
5398
*q++=background_color;
5760
5399
indexes=GetAuthenticIndexQueue(image);
5761
for (x=0; x < (ssize_t) image->columns; x++)
5400
for (x=0; x < (long) image->columns; x++)
5762
5401
indexes[x]=(IndexPacket) 0;
5763
5402
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
5764
5403
break;
5768
5407
/*
5769
5408
Set DirectClass image.
5770
5409
*/
5771
for (y=0; y < (ssize_t) image->rows; y++)
5410
for (y=0; y < (long) image->rows; y++)
5772
5411
{
5773
register ssize_t
5412
register long
5774
5413
x;
5775
5414
5776
5415
register PixelPacket
5779
5418
q=QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
5780
5419
if (q == (PixelPacket *) NULL)
5781
5420
break;
5782
for (x=0; x < (ssize_t) image->columns; x++)
5421
for (x=0; x < (long) image->columns; x++)
5783
5422
*q++=background_color;
5784
5423
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
5785
5424
break;
5801
5440
% attribute value. If it is not found in the list, the attribute name
5802
5441
% and value is added to the list.
5803
5442
%
5804
% Deprecated, replace with:
5805
%
5806
% SetImageProperty(image,key,value);
5807
%
5808
5443
% The format of the SetImageAttribute method is:
5809
5444
%
5810
5445
% MagickBooleanType SetImageAttribute(Image *image,const char *key,
5842
5477
% The format of the SetImageList method is:
5843
5478
%
5844
5479
% unsigned int SetImageList(Image *images,const Image *image,
5845
% const ssize_t offset,ExceptionInfo *exception)
5480
% const long offset,ExceptionInfo *exception)
5846
5481
%
5847
5482
% A description of each parameter follows:
5848
5483
%
5856
5491
%
5857
5492
*/
5858
5493
MagickExport unsigned int SetImageList(Image **images,const Image *image,
5859
const ssize_t offset,ExceptionInfo *exception)
5494
const long offset,ExceptionInfo *exception)
5860
5495
{
5861
5496
Image
5862
5497
*clone;
5863
5498
5864
register ssize_t
5499
register long
5865
5500
i;
5866
5501
5867
5502
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.5.2");
5918
5553
% array has been updated, the changes must be saved back to the underlying
5919
5554
% image using SyncAuthenticPixels() or they may be lost.
5920
5555
%
5921
% Deprecated, replace with:
5922
%
5923
% QueueAuthenticPixels(image,x,y,columns,rows,&image->exception);
5924
%
5925
5556
% The format of the SetImagePixels() method is:
5926
5557
%
5927
% PixelPacket *SetImagePixels(Image *image,const ssize_t x,const ssize_t y,
5928
% const size_t columns,const size_t rows)
5558
% PixelPacket *SetImagePixels(Image *image,const long x,const long y,
5559
% const unsigned long columns,const unsigned long rows)
5929
5560
%
5930
5561
% A description of each parameter follows:
5931
5562
%
5938
5569
% pixels.
5939
5570
%
5940
5571
*/
5941
MagickExport PixelPacket *SetImagePixels(Image *image,const ssize_t x,const ssize_t y,
5942
const size_t columns,const size_t rows)
5572
MagickExport PixelPacket *SetImagePixels(Image *image,const long x,const long y,
5573
const unsigned long columns,const unsigned long rows)
5943
5574
{
5944
5575
return(QueueAuthenticPixels(image,x,y,columns,rows,&image->exception));
5945
5576
}
5960
5591
%
5961
5592
% The format of the SetMagickRegistry method is:
5962
5593
%
5963
% ssize_t SetMagickRegistry(const RegistryType type,const void *blob,
5594
% long SetMagickRegistry(const RegistryType type,const void *blob,
5964
5595
% const size_t length,ExceptionInfo *exception)
5965
5596
%
5966
5597
% A description of each parameter follows:
5975
5606
% o exception: return any errors or warnings in this structure.
5976
5607
%
5977
5608
*/
5978
MagickExport ssize_t SetMagickRegistry(const RegistryType type,const void *blob,
5609
MagickExport long SetMagickRegistry(const RegistryType type,const void *blob,
5979
5610
const size_t magick_unused(length),ExceptionInfo *exception)
5980
5611
{
5981
5612
char
5984
5615
MagickBooleanType
5985
5616
status;
5986
5617
5987
static ssize_t
5618
static long
5988
5619
id = 0;
5989
5620
5990
(void) FormatMagickString(key,MaxTextExtent,"%.20g\n",(double) id);
5621
(void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
5991
5622
status=SetImageRegistry(type,key,blob,exception);
5992
5623
if (status == MagickFalse)
5993
5624
return(-1);
6046
5677
%
6047
5678
% ShiftImageList() removes an image from the beginning of the list.
6048
5679
%
6049
% Deprecated, replace with:
6050
%
6051
% RemoveFirstImageFromList(images);
6052
%
6053
5680
% The format of the ShiftImageList method is:
6054
5681
%
6055
5682
% Image *ShiftImageList(Image **images)
6078
5705
%
6079
5706
% SizeBlob() returns the current length of the image file or blob.
6080
5707
%
6081
% Deprecated, replace with:
6082
%
6083
% GetBlobSize(image);
6084
%
6085
5708
% The format of the SizeBlob method is:
6086
5709
%
6087
5710
% off_t SizeBlob(Image *image)
6117
5740
%
6118
5741
% The format of the SpliceImageList method is:
6119
5742
%
6120
% Image *SpliceImageList(Image *images,const ssize_t offset,
6121
% const size_t length,const Image *splices,
5743
% Image *SpliceImageList(Image *images,const long offset,
5744
% const unsigned long length,const Image *splices,
6122
5745
% ExceptionInfo *exception)
6123
5746
%
6124
5747
% A description of each parameter follows:
6134
5757
% o exception: return any errors or warnings in this structure.
6135
5758
%
6136
5759
*/
6137
MagickExport Image *SpliceImageList(Image *images,const ssize_t offset,
6138
const size_t length,const Image *splices,ExceptionInfo *exception)
5760
MagickExport Image *SpliceImageList(Image *images,const long offset,
5761
const unsigned long length,const Image *splices,ExceptionInfo *exception)
6139
5762
{
6140
5763
Image
6141
5764
*clone;
6142
5765
6143
register ssize_t
5766
register long
6144
5767
i;
6145
5768
6146
5769
if (images->debug != MagickFalse)
6223
5846
% cache. It returns MagickTrue if the pixel region is synced, otherwise
6224
5847
% MagickFalse.
6225
5848
%
6226
% Deprecated, replace with:
6227
%
6228
% SyncCacheViewAuthenticPixels(cache_view,GetCacheViewException(cache_view));
6229
%
6230
5849
% The format of the SyncCacheView method is:
6231
5850
%
6232
5851
% MagickBooleanType SyncCacheView(CacheView *cache_view)
6261
5880
% or disk cache. It returns MagickTrue if the pixel region is flushed,
6262
5881
% otherwise MagickFalse.
6263
5882
%
6264
% Deprecated, replace with:
6265
%
6266
% SyncCacheViewAuthenticPixels(cache_view,GetCacheViewException(cache_view));
6267
%
6268
5883
% The format of the SyncCacheViewPixels method is:
6269
5884
%
6270
5885
% MagickBooleanType SyncCacheViewPixels(CacheView *cache_view)
6301
5916
% The method returns MagickTrue if the pixel region is synced, otherwise
6302
5917
% MagickFalse.
6303
5918
%
6304
% Deprecated, replace with:
6305
%
6306
% SyncAuthenticPixels(image,&image->exception);
6307
%
6308
5919
% The format of the SyncImagePixels() method is:
6309
5920
%
6310
5921
% MagickBooleanType SyncImagePixels(Image *image)
6382
5993
IndexPacket
6383
5994
index;
6384
5995
6385
ssize_t
5996
long
6386
5997
y;
6387
5998
6388
5999
/*
6397
6008
if (!AcquireImageColormap(image,2))
6398
6009
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
6399
6010
"UnableToThresholdImage");
6400
for (y=0; y < (ssize_t) image->rows; y++)
6011
for (y=0; y < (long) image->rows; y++)
6401
6012
{
6402
6013
register IndexPacket
6403
6014
*restrict indexes;
6404
6015
6405
register ssize_t
6016
register long
6406
6017
x;
6407
6018
6408
6019
register PixelPacket
6412
6023
if (q == (PixelPacket *) NULL)
6413
6024
break;
6414
6025
indexes=GetAuthenticIndexQueue(image);
6415
for (x=0; x < (ssize_t) image->columns; x++)
6026
for (x=0; x < (long) image->columns; x++)
6416
6027
{
6417
6028
index=(IndexPacket) ((MagickRealType)
6418
6029
PixelIntensityToQuantum(q) <= threshold ? 0 : 1);
6419
6030
indexes[x]=index;
6420
q->red=image->colormap[(ssize_t) index].red;
6421
q->green=image->colormap[(ssize_t) index].green;
6422
q->blue=image->colormap[(ssize_t) index].blue;
6031
q->red=image->colormap[(long) index].red;
6032
q->green=image->colormap[(long) index].green;
6033
q->blue=image->colormap[(long) index].blue;
6423
6034
q++;
6424
6035
}
6425
6036
if (!SyncAuthenticPixels(image,&image->exception))
6467
6078
IndexPacket
6468
6079
index;
6469
6080
6470
ssize_t
6081
long
6471
6082
y;
6472
6083
6473
6084
unsigned int
6513
6124
if (pixel.red == 0)
6514
6125
(void) GetImageDynamicThreshold(image,2.0,2.0,&pixel,&image->exception);
6515
6126
}
6516
for (y=0; y < (ssize_t) image->rows; y++)
6127
for (y=0; y < (long) image->rows; y++)
6517
6128
{
6518
6129
register IndexPacket
6519
6130
*restrict indexes;
6520
6131
6521
register ssize_t
6132
register long
6522
6133
x;
6523
6134
6524
6135
register PixelPacket
6529
6140
break;
6530
6141
indexes=GetAuthenticIndexQueue(image);
6531
6142
if (IsMagickGray(&pixel) != MagickFalse)
6532
for (x=0; x < (ssize_t) image->columns; x++)
6143
for (x=0; x < (long) image->columns; x++)
6533
6144
{
6534
6145
index=(IndexPacket) ((MagickRealType)
6535
6146
PixelIntensityToQuantum(q) <= pixel.red ? 0 : 1);
6536
6147
indexes[x]=index;
6537
q->red=image->colormap[(ssize_t) index].red;
6538
q->green=image->colormap[(ssize_t) index].green;
6539
q->blue=image->colormap[(ssize_t) index].blue;
6148
q->red=image->colormap[(long) index].red;
6149
q->green=image->colormap[(long) index].green;
6150
q->blue=image->colormap[(long) index].blue;
6540
6151
q++;
6541
6152
}
6542
6153
else
6543
for (x=0; x < (ssize_t) image->columns; x++)
6154
for (x=0; x < (long) image->columns; x++)
6544
6155
{
6545
6156
q->red=(Quantum) ((MagickRealType)
6546
6157
q->red <= pixel.red ? 0 : QuantumRange);
6576
6187
% weights are rescaled to normalize the range of the transformed values to
6577
6188
% be [0..QuantumRange].
6578
6189
%
6579
% Deprecated, replace with:
6580
%
6581
% TransformImageColorspace(image,colorspace);
6582
%
6583
6190
% The format of the TransformColorspace method is:
6584
6191
%
6585
6192
% unsigned int (void) TransformColorspace(Image *image,
6692
6299
% TranslateText() replaces any embedded formatting characters with the
6693
6300
% appropriate image attribute and returns the translated text.
6694
6301
%
6695
% Deprecated, replace with:
6696
%
6697
% InterpretImageProperties(image_info,image,embed_text);
6698
%
6699
6302
% The format of the TranslateText method is:
6700
6303
%
6701
6304
% char *TranslateText(const ImageInfo *image_info,Image *image,
6760
6363
{
6761
6364
#define TransparentImageTag "Transparent/Image"
6762
6365
6763
ssize_t
6366
long
6764
6367
y;
6765
6368
6766
6369
MagickBooleanType
6776
6379
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
6777
6380
if (image->matte == MagickFalse)
6778
6381
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
6779
for (y=0; y < (ssize_t) image->rows; y++)
6382
for (y=0; y < (long) image->rows; y++)
6780
6383
{
6781
register ssize_t
6384
register long
6782
6385
x;
6783
6386
6784
6387
register PixelPacket
6787
6390
q=GetAuthenticPixels(image,0,y,image->columns,1,&image->exception);
6788
6391
if (q == (PixelPacket *) NULL)
6789
6392
break;
6790
for (x=0; x < (ssize_t) image->columns; x++)
6393
for (x=0; x < (long) image->columns; x++)
6791
6394
{
6792
6395
if (IsColorSimilar(image,q,&target) != MagickFalse)
6793
6396
q->opacity=opacity;
6795
6398
}
6796
6399
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
6797
6400
break;
6798
proceed=SetImageProgress(image,TransparentImageTag,(MagickOffsetType) y,
6799
image->rows);
6401
proceed=SetImageProgress(image,TransparentImageTag,y,image->rows);
6800
6402
if (proceed == MagickFalse)
6801
6403
break;
6802
6404
}
6816
6418
%
6817
6419
% UnshiftImageList() adds the image to the beginning of the list.
6818
6420
%
6819
% Deprecated, replace with:
6820
%
6821
% PrependImageToList(images,CloneImageList(image,exception));
6822
%
6823
6421
% The format of the UnshiftImageList method is:
6824
6422
%
6825
6423
% unsigned int UnshiftImageList(Image *images,const Image *image,
6857
6455
% not range from 0 to the number of colors in the colormap an exception
6858
6456
% issued and 0 is returned.
6859
6457
%
6860
% Deprecated, replace with:
6861
%
6862
% ConstrainColormapIndex(image,index);
6863
%
6864
6458
% The format of the ValidateColormapIndex method is:
6865
6459
%
6866
6460
% IndexPacket ValidateColormapIndex(Image *image,const unsigned int index)
6875
6469
% o index: This integer is the colormap index.
6876
6470
%
6877
6471
*/
6472
6878
6473
MagickExport IndexPacket ValidateColormapIndex(Image *image,
6879
const size_t index)
6474
const unsigned long index)
6880
6475
{
6881
6476
if (image->debug != MagickFalse)
6882
6477
(void) LogMagickEvent(DeprecateEvent,GetMagickModule(),"last use: v5.4.4");
Loggerhead is a web-based interface for Breezy
Version: 2.0.1