/usr/include/ImageMagick-6/Magick++/Image.h is in libmagick++-6-headers 8:6.9.7.4+dfsg-16ubuntu6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 | // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2013-2015
//
// Definition of Image, the representation of a single image in Magick++
//
#if !defined(Magick_Image_header)
#define Magick_Image_header
#include "Magick++/Include.h"
#include <string>
#include <list>
#include "Magick++/Blob.h"
#include "Magick++/ChannelMoments.h"
#include "Magick++/Color.h"
#include "Magick++/Drawable.h"
#include "Magick++/Exception.h"
#include "Magick++/Geometry.h"
#include "Magick++/TypeMetric.h"
namespace Magick
{
// Forward declarations
class Options;
class ImageRef;
extern MagickPPExport const char *borderGeometryDefault;
extern MagickPPExport const char *frameGeometryDefault;
extern MagickPPExport const char *raiseGeometryDefault;
// Compare two Image objects regardless of LHS/RHS
// Image sizes and signatures are used as basis of comparison
MagickPPExport int operator ==
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator !=
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator >
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator <
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator >=
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator <=
(const Magick::Image &left_,const Magick::Image &right_);
//
// Image is the representation of an image. In reality, it actually
// a handle object which contains a pointer to a shared reference
// object (ImageRef). As such, this object is extremely space efficient.
//
class MagickPPExport Image
{
public:
// Obtain image statistics. Statistics are normalized to the range
// of 0.0 to 1.0 and are output to the specified ImageStatistics
// structure.
typedef struct _ImageChannelStatistics
{
/* Minimum value observed */
double maximum;
/* Maximum value observed */
double minimum;
/* Average (mean) value observed */
double mean;
/* Standard deviation, sqrt(variance) */
double standard_deviation;
/* Variance */
double variance;
/* Kurtosis */
double kurtosis;
/* Skewness */
double skewness;
} ImageChannelStatistics;
typedef struct _ImageStatistics
{
ImageChannelStatistics red;
ImageChannelStatistics green;
ImageChannelStatistics blue;
ImageChannelStatistics opacity;
} ImageStatistics;
// Default constructor
Image(void);
// Construct Image from in-memory BLOB
Image(const Blob &blob_);
// Construct Image of specified size from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_);
// Construct Image of specified size and depth from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const size_t depth_);
// Construct Image of specified size, depth, and format from
// in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const size_t depth_,
const std::string &magick_);
// Construct Image of specified size, and format from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const std::string &magick_);
// Construct a blank image canvas of specified size and color
Image(const Geometry &size_,const Color &color_);
// Copy constructor
Image(const Image &image_);
// Copy constructor to copy part of the image
Image(const Image &image_,const Geometry &geometry_);
// Construct an image based on an array of raw pixels, of
// specified type and mapping, in memory
Image(const size_t width_,const size_t height_,const std::string &map_,
const StorageType type_,const void *pixels_);
// Construct from image file or image specification
Image(const std::string &imageSpec_);
// Destructor
virtual ~Image();
// Assignment operator
Image& operator=(const Image &image_);
// Join images into a single multi-image file
void adjoin(const bool flag_);
bool adjoin(void) const;
// Anti-alias Postscript and TrueType fonts (default true)
void antiAlias(const bool flag_);
bool antiAlias(void) const;
// Time in 1/100ths of a second which must expire before
// displaying the next image in an animated sequence.
void animationDelay(const size_t delay_);
size_t animationDelay(void) const;
// Number of iterations to loop an animation (e.g. Netscape loop
// extension) for.
void animationIterations(const size_t iterations_);
size_t animationIterations(void) const;
// Lessen (or intensify) when adding noise to an image.
void attenuate(const double attenuate_);
// Image background color
void backgroundColor(const Color &color_);
Color backgroundColor(void) const;
// Name of texture image to tile onto the image background
void backgroundTexture(const std::string &backgroundTexture_);
std::string backgroundTexture(void) const;
// Base image width (before transformations)
size_t baseColumns(void) const;
// Base image filename (before transformations)
std::string baseFilename(void) const;
// Base image height (before transformations)
size_t baseRows(void) const;
// Use black point compensation.
void blackPointCompensation(const bool flag_);
bool blackPointCompensation(void) const;
// Image border color
void borderColor(const Color &color_);
Color borderColor(void) const;
// Return smallest bounding box enclosing non-border pixels. The
// current fuzz value is used when discriminating between pixels.
// This is the crop bounding box used by crop(Geometry(0,0));
Geometry boundingBox(void) const;
// Text bounding-box base color (default none)
void boxColor(const Color &boxColor_);
Color boxColor(void) const;
// This method is now deprecated. Please use ResourceLimits instead.
static void cacheThreshold(const size_t threshold_);
// Image class (DirectClass or PseudoClass)
// NOTE: setting a DirectClass image to PseudoClass will result in
// the loss of color information if the number of colors in the
// image is greater than the maximum palette size (either 256 or
// 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when
// ImageMagick was built).
void classType(const ClassType class_);
ClassType classType(void) const;
// Associate a clip mask with the image. The clip mask must be the
// same dimensions as the image. Pass an invalid image to unset an
// existing clip mask.
void clipMask(const Image &clipMask_);
Image clipMask(void) const;
// Colors within this distance are considered equal
void colorFuzz(const double fuzz_);
double colorFuzz(void) const;
// Colormap size (number of colormap entries)
void colorMapSize(const size_t entries_);
size_t colorMapSize(void) const;
// Image Color Space
void colorSpace(const ColorspaceType colorSpace_);
ColorspaceType colorSpace(void) const;
void colorspaceType(const ColorspaceType colorSpace_);
ColorspaceType colorspaceType(void) const;
// Image width
size_t columns(void) const;
// Comment image (add comment string to image)
void comment(const std::string &comment_);
std::string comment(void) const;
// Composition operator to be used when composition is implicitly
// used (such as for image flattening).
void compose(const CompositeOperator compose_);
CompositeOperator compose(void) const;
// Compression type
void compressType(const CompressionType compressType_);
CompressionType compressType(void) const;
// Enable printing of debug messages from ImageMagick
void debug(const bool flag_);
bool debug(void) const;
// Vertical and horizontal resolution in pixels of the image
void density(const Geometry &geomery_);
Geometry density(void) const;
// Image depth (bits allocated to red/green/blue components)
void depth(const size_t depth_);
size_t depth(void) const;
// Tile names from within an image montage
std::string directory(void) const;
// Endianness (little like Intel or big like SPARC) for image
// formats which support endian-specific options.
void endian(const EndianType endian_);
EndianType endian(void) const;
// Exif profile (BLOB)
void exifProfile(const Blob &exifProfile_);
Blob exifProfile(void) const;
// Image file name
void fileName(const std::string &fileName_);
std::string fileName(void) const;
// Number of bytes of the image on disk
off_t fileSize(void) const;
// Color to use when filling drawn objects
void fillColor(const Color &fillColor_);
Color fillColor(void) const;
// Rule to use when filling drawn objects
void fillRule(const FillRule &fillRule_);
FillRule fillRule(void) const;
// Pattern to use while filling drawn objects.
void fillPattern(const Image &fillPattern_);
Image fillPattern(void) const;
// Filter to use when resizing image
void filterType(const FilterTypes filterType_);
FilterTypes filterType(void) const;
// Text rendering font
void font(const std::string &font_);
std::string font(void) const;
// Font family
void fontFamily(const std::string &family_);
std::string fontFamily(void) const;
// Font point size
void fontPointsize(const double pointSize_);
double fontPointsize(void) const;
// Font style
void fontStyle(const StyleType style_);
StyleType fontStyle(void) const;
// Font weight
void fontWeight(const size_t weight_);
size_t fontWeight(void) const;
// Long image format description
std::string format(void) const;
// Formats the specified expression
// More info here: http://www.imagemagick.org/script/escape.php
std::string formatExpression(const std::string expression);
// Gamma level of the image
double gamma(void) const;
// Preferred size of the image when encoding
Geometry geometry(void) const;
// GIF disposal method
void gifDisposeMethod(const size_t disposeMethod_);
size_t gifDisposeMethod(void) const;
// When comparing images, emphasize pixel differences with this color.
void highlightColor(const Color color_);
// ICC color profile (BLOB)
void iccColorProfile(const Blob &colorProfile_);
Blob iccColorProfile(void) const;
// Type of interlacing to use
void interlaceType(const InterlaceType interlace_);
InterlaceType interlaceType(void) const;
// Pixel color interpolation method to use
void interpolate(const InterpolatePixelMethod interpolate_);
InterpolatePixelMethod interpolate(void) const;
// IPTC profile (BLOB)
void iptcProfile(const Blob &iptcProfile_);
Blob iptcProfile(void) const;
// Returns true if none of the pixels in the image have an alpha value
// other than OpaqueAlpha (QuantumRange).
bool isOpaque(void) const;
// Does object contain valid image?
void isValid(const bool isValid_);
bool isValid(void) const;
// Image label
void label(const std::string &label_);
std::string label(void) const;
// Stroke width for drawing vector objects (default one)
// This method is now deprecated. Please use strokeWidth instead.
void lineWidth(const double lineWidth_);
double lineWidth(void) const;
// When comparing images, de-emphasize pixel differences with this color.
void lowlightColor(const Color color_);
// File type magick identifier (.e.g "GIF")
void magick(const std::string &magick_);
std::string magick(void) const;
// Associate a mask with the image. The mask must be the same dimensions
// as the image. Pass an invalid image to unset an existing clip mask.
void mask(const Image &mask_);
Image mask(void) const;
// Image supports transparency (matte channel)
void matte(const bool matteFlag_);
bool matte(void) const;
// Transparent color
void matteColor(const Color &matteColor_);
Color matteColor(void) const;
// The mean error per pixel computed when an image is color reduced
double meanErrorPerPixel(void) const;
// Image modulus depth (minimum number of bits required to support
// red/green/blue components without loss of accuracy)
void modulusDepth(const size_t modulusDepth_);
size_t modulusDepth(void) const;
// Transform image to black and white
void monochrome(const bool monochromeFlag_);
bool monochrome(void) const;
// Tile size and offset within an image montage
Geometry montageGeometry(void) const;
// The normalized max error per pixel computed when an image is
// color reduced.
double normalizedMaxError(void) const;
// The normalized mean error per pixel computed when an image is
// color reduced.
double normalizedMeanError(void) const;
// Image orientation
void orientation(const OrientationType orientation_);
OrientationType orientation(void) const;
// Preferred size and location of an image canvas.
void page(const Geometry &pageSize_);
Geometry page(void) const;
// Pen color (deprecated, don't use any more)
void penColor(const Color &penColor_);
Color penColor(void) const;
// Pen texture image (deprecated, don't use any more)
void penTexture(const Image &penTexture_);
Image penTexture(void) const;
// JPEG/MIFF/PNG compression level (default 75).
void quality(const size_t quality_);
size_t quality(void) const;
// Maximum number of colors to quantize to
void quantizeColors(const size_t colors_);
size_t quantizeColors(void) const;
// Colorspace to quantize in.
void quantizeColorSpace(const ColorspaceType colorSpace_);
ColorspaceType quantizeColorSpace(void) const;
// Dither image during quantization (default true).
void quantizeDither(const bool ditherFlag_);
bool quantizeDither(void) const;
// Dither method
void quantizeDitherMethod(const DitherMethod ditherMethod_);
DitherMethod quantizeDitherMethod(void) const;
// Quantization tree-depth
void quantizeTreeDepth(const size_t treeDepth_);
size_t quantizeTreeDepth(void) const;
// Suppress all warning messages. Error messages are still reported.
void quiet(const bool quiet_);
bool quiet(void) const;
// The type of rendering intent
void renderingIntent(const RenderingIntent renderingIntent_);
RenderingIntent renderingIntent(void) const;
// Units of image resolution
void resolutionUnits(const ResolutionType resolutionUnits_);
ResolutionType resolutionUnits(void) const;
// The number of pixel rows in the image
size_t rows(void) const;
// Image scene number
void scene(const size_t scene_);
size_t scene(void) const;
// Width and height of a raw image
void size(const Geometry &geometry_);
Geometry size(void) const;
// enabled/disable stroke anti-aliasing
void strokeAntiAlias(const bool flag_);
bool strokeAntiAlias(void) const;
// Color to use when drawing object outlines
void strokeColor(const Color &strokeColor_);
Color strokeColor(void) const;
// Specify the pattern of dashes and gaps used to stroke
// paths. The strokeDashArray represents a zero-terminated array
// of numbers that specify the lengths of alternating dashes and
// gaps in pixels. If an odd number of values is provided, then
// the list of values is repeated to yield an even number of
// values. A typical strokeDashArray_ array might contain the
// members 5 3 2 0, where the zero value indicates the end of the
// pattern array.
void strokeDashArray(const double *strokeDashArray_);
const double *strokeDashArray(void) const;
// While drawing using a dash pattern, specify distance into the
// dash pattern to start the dash (default 0).
void strokeDashOffset(const double strokeDashOffset_);
double strokeDashOffset(void) const;
// Specify the shape to be used at the end of open subpaths when
// they are stroked. Values of LineCap are UndefinedCap, ButtCap,
// RoundCap, and SquareCap.
void strokeLineCap(const LineCap lineCap_);
LineCap strokeLineCap(void) const;
// Specify the shape to be used at the corners of paths (or other
// vector shapes) when they are stroked. Values of LineJoin are
// UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
void strokeLineJoin(const LineJoin lineJoin_);
LineJoin strokeLineJoin(void) const;
// Specify miter limit. When two line segments meet at a sharp
// angle and miter joins have been specified for 'lineJoin', it is
// possible for the miter to extend far beyond the thickness of
// the line stroking the path. The miterLimit' imposes a limit on
// the ratio of the miter length to the 'lineWidth'. The default
// value of this parameter is 4.
void strokeMiterLimit(const size_t miterLimit_);
size_t strokeMiterLimit(void) const;
// Pattern image to use while stroking object outlines.
void strokePattern(const Image &strokePattern_);
Image strokePattern(void) const;
// Stroke width for drawing vector objects (default one)
void strokeWidth(const double strokeWidth_);
double strokeWidth(void) const;
// Subimage of an image sequence
void subImage(const size_t subImage_);
size_t subImage(void) const;
// Number of images relative to the base image
void subRange(const size_t subRange_);
size_t subRange(void) const;
// Render text right-to-left or left-to-right.
void textDirection(DirectionType direction_);
DirectionType textDirection() const;
// Annotation text encoding (e.g. "UTF-16")
void textEncoding(const std::string &encoding_);
std::string textEncoding(void) const;
// Text gravity.
void textGravity(GravityType gravity_);
GravityType textGravity() const;
// Text inter-line spacing
void textInterlineSpacing(double spacing_);
double textInterlineSpacing(void) const;
// Text inter-word spacing
void textInterwordSpacing(double spacing_);
double textInterwordSpacing(void) const;
// Text inter-character kerning
void textKerning(double kerning_);
double textKerning(void) const;
// Text undercolor box
void textUnderColor(const Color &underColor_);
Color textUnderColor(void) const;
// Tile name
void tileName(const std::string &tileName_);
std::string tileName(void) const;
// Number of colors in the image
size_t totalColors(void) const;
// Rotation to use when annotating with text or drawing
void transformRotation(const double angle_);
// Skew to use in X axis when annotating with text or drawing
void transformSkewX(const double skewx_);
// Skew to use in Y axis when annotating with text or drawing
void transformSkewY(const double skewy_);
// Image representation type (also see type operation)
// Available types:
// Bilevel Grayscale GrayscaleMatte
// Palette PaletteMatte TrueColor
// TrueColorMatte ColorSeparation ColorSeparationMatte
void type(const ImageType type_);
ImageType type(void) const;
// Print detailed information about the image
void verbose(const bool verboseFlag_);
bool verbose(void) const;
// FlashPix viewing parameters
void view(const std::string &view_);
std::string view(void) const;
// Virtual pixel method
void virtualPixelMethod(const VirtualPixelMethod virtual_pixel_method_);
VirtualPixelMethod virtualPixelMethod(void) const;
// X11 display to display to, obtain fonts from, or to capture
// image from
void x11Display(const std::string &display_);
std::string x11Display(void) const;
// x resolution of the image
double xResolution(void) const;
// y resolution of the image
double yResolution(void) const;
// Adaptive-blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void adaptiveBlur(const double radius_=0.0,const double sigma_=1.0);
// This is shortcut function for a fast interpolative resize using mesh
// interpolation. It works well for small resizes of less than +/- 50%
// of the original image size. For larger resizing on images a full
// filtered and slower resize function should be used instead.
void adaptiveResize(const Geometry &geometry_);
// Adaptively sharpens the image by sharpening more intensely near image
// edges and less intensely far from edges. We sharpen the image with a
// Gaussian operator of the given radius and standard deviation (sigma).
// For reasonable results, radius should be larger than sigma.
void adaptiveSharpen(const double radius_=0.0,const double sigma_=1.0);
void adaptiveSharpenChannel(const ChannelType channel_,
const double radius_=0.0,const double sigma_=1.0);
// Local adaptive threshold image
// http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
// Width x height define the size of the pixel neighborhood
// offset = constant to subtract from pixel neighborhood mean
void adaptiveThreshold(const size_t width,const size_t height,
const ::ssize_t offset=0);
// Add noise to image with specified noise type
void addNoise(const NoiseType noiseType_);
void addNoiseChannel(const ChannelType channel_,
const NoiseType noiseType_);
// Transform image by specified affine (or free transform) matrix.
void affineTransform(const DrawableAffine &affine);
// Activates, deactivates, resets, or sets the alpha channel.
void alphaChannel(AlphaChannelType alphaType_);
//
// Annotate image (draw text on image)
//
// Gravity effects text placement in bounding area according to rules:
// NorthWestGravity text bottom-left corner placed at top-left
// NorthGravity text bottom-center placed at top-center
// NorthEastGravity text bottom-right corner placed at top-right
// WestGravity text left-center placed at left-center
// CenterGravity text center placed at center
// EastGravity text right-center placed at right-center
// SouthWestGravity text top-left placed at bottom-left
// SouthGravity text top-center placed at bottom-center
// SouthEastGravity text top-right placed at bottom-right
// Annotate using specified text, and placement location
void annotate(const std::string &text_,const Geometry &location_);
// Annotate using specified text, bounding area, and placement
// gravity
void annotate(const std::string &text_,const Geometry &boundingArea_,
const GravityType gravity_);
// Annotate with text using specified text, bounding area,
// placement gravity, and rotation.
void annotate(const std::string &text_,const Geometry &boundingArea_,
const GravityType gravity_,const double degrees_);
// Annotate with text (bounding area is entire image) and placement
// gravity.
void annotate(const std::string &text_,const GravityType gravity_);
// Inserts the artifact with the specified name and value into
// the artifact tree of the image.
void artifact(const std::string &name_,const std::string &value_);
// Returns the value of the artifact with the specified name.
std::string artifact(const std::string &name_) const;
// Access/Update a named image attribute
void attribute(const std::string name_,const std::string value_);
std::string attribute(const std::string name_ ) const;
// Extracts the 'mean' from the image and adjust the image to try
// make set its gamma appropriatally.
void autoGamma(void);
void autoGammaChannel(const ChannelType channel_);
// Adjusts the levels of a particular image channel by scaling the
// minimum and maximum values to the full quantum range.
void autoLevel(void);
void autoLevelChannel(const ChannelType channel_);
// Adjusts an image so that its orientation is suitable for viewing.
void autoOrient(void);
// Forces all pixels below the threshold into black while leaving all
// pixels at or above the threshold unchanged.
void blackThreshold(const std::string &threshold_);
void blackThresholdChannel(const ChannelType channel_,
const std::string &threshold_);
// Simulate a scene at nighttime in the moonlight.
void blueShift(const double factor_=1.5);
// Blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void blur(const double radius_=0.0,const double sigma_=1.0);
void blurChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Border image (add border to image)
void border(const Geometry &geometry_=borderGeometryDefault);
// Changes the brightness and/or contrast of an image. It converts the
// brightness and contrast parameters into slope and intercept and calls
// a polynomical function to apply to the image.
void brightnessContrast(const double brightness_=0.0,
const double contrast_=0.0);
void brightnessContrastChannel(const ChannelType channel_,
const double brightness_=0.0,const double contrast_=0.0);
// Uses a multi-stage algorithm to detect a wide range of edges in images.
void cannyEdge(const double radius_=0.0,const double sigma_=1.0,
const double lowerPercent_=0.1,const double upperPercent_=0.3);
// Accepts a lightweight Color Correction Collection
// (CCC) file which solely contains one or more color corrections and
// applies the correction to the image.
void cdl(const std::string &cdl_);
// Extract channel from image
void channel(const ChannelType channel_);
// Set or obtain modulus channel depth
void channelDepth(const ChannelType channel_,const size_t depth_);
size_t channelDepth(const ChannelType channel_);
// Charcoal effect image (looks like charcoal sketch)
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void charcoal(const double radius_=0.0,const double sigma_=1.0);
// Chop image (remove vertical or horizontal subregion of image)
// FIXME: describe how geometry argument is used to select either
// horizontal or vertical subregion of image.
void chop(const Geometry &geometry_);
// Chromaticity blue primary point (e.g. x=0.15, y=0.06)
void chromaBluePrimary(const double x_,const double y_);
void chromaBluePrimary(double *x_, double *y_) const;
// Chromaticity green primary point (e.g. x=0.3, y=0.6)
void chromaGreenPrimary(const double x_,const double y_);
void chromaGreenPrimary(double *x_,double *y_) const;
// Chromaticity red primary point (e.g. x=0.64, y=0.33)
void chromaRedPrimary(const double x_,const double y_);
void chromaRedPrimary(double *x_,double *y_) const;
// Chromaticity white point (e.g. x=0.3127, y=0.329)
void chromaWhitePoint(const double x_,const double y_);
void chromaWhitePoint(double *x_,double *y_) const;
// Set each pixel whose value is below zero to zero and any the
// pixel whose value is above the quantum range to the quantum range (e.g.
// 65535) otherwise the pixel value remains unchanged.
void clamp(void);
void clampChannel(const ChannelType channel_);
// Sets the image clip mask based on any clipping path information
// if it exists.
void clip(void);
void clipPath(const std::string pathname_,const bool inside_);
// Apply a color lookup table (CLUT) to the image.
void clut(const Image &clutImage_);
void clutChannel(const ChannelType channel_,const Image &clutImage_);
// Colorize image with pen color, using specified percent opacity.
void colorize(const unsigned int opacity_,const Color &penColor_);
// Colorize image with pen color, using specified percent opacity
// for red, green, and blue quantums
void colorize(const unsigned int opacityRed_,
const unsigned int opacityGreen_,const unsigned int opacityBlue_,
const Color &penColor_);
// Color at colormap position index_
void colorMap(const size_t index_,const Color &color_);
Color colorMap(const size_t index_) const;
// Apply a color matrix to the image channels. The user supplied
// matrix may be of order 1 to 5 (1x1 through 5x5).
void colorMatrix(const size_t order_,const double *color_matrix_);
// Compare current image with another image
// Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
// in the current image. False is returned if the images are identical.
bool compare(const Image &reference_);
// Compare current image with another image
// Returns the distortion based on the specified metric.
double compare(const Image &reference_,const MetricType metric_);
double compareChannel(const ChannelType channel_,const Image &reference_,
const MetricType metric_);
// Compare current image with another image
// Sets the distortion and returns the difference image.
Image compare(const Image &reference_,const MetricType metric_,
double *distortion);
Image compareChannel(const ChannelType channel_,const Image &reference_,
const MetricType metric_,double *distortion );
// Compose an image onto another at specified offset and using
// specified algorithm
void composite(const Image &compositeImage_,const Geometry &offset_,
const CompositeOperator compose_=InCompositeOp);
void composite(const Image &compositeImage_,const GravityType gravity_,
const CompositeOperator compose_=InCompositeOp);
void composite(const Image &compositeImage_,const ::ssize_t xOffset_,
const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp);
// Determines the connected-components of the image
void connectedComponents(const size_t connectivity_);
// Contrast image (enhance intensity differences in image)
void contrast(const size_t sharpen_);
// A simple image enhancement technique that attempts to improve the
// contrast in an image by 'stretching' the range of intensity values
// it contains to span a desired range of values. It differs from the
// more sophisticated histogram equalization in that it can only apply a
// linear scaling function to the image pixel values. As a result the
// 'enhancement' is less harsh.
void contrastStretch(const double black_point_,const double white_point_);
void contrastStretchChannel(const ChannelType channel_,
const double black_point_,const double white_point_);
// Convolve image. Applies a user-specified convolution to the image.
// order_ represents the number of columns and rows in the filter kernel.
// kernel_ is an array of doubles representing the convolution kernel.
void convolve(const size_t order_,const double *kernel_);
// Copies pixels from the source image as defined by the geometry the
// destination image at the specified offset.
void copyPixels(const Image &source_,const Geometry &geometry_,
const Offset &offset_);
// Crop image (subregion of original image)
void crop(const Geometry &geometry_);
// Cycle image colormap
void cycleColormap(const ::ssize_t amount_);
// Converts cipher pixels to plain pixels.
void decipher(const std::string &passphrase_);
// Tagged image format define. Similar to the defineValue() method
// except that passing the flag_ value 'true' creates a value-less
// define with that format and key. Passing the flag_ value 'false'
// removes any existing matching definition. The method returns 'true'
// if a matching key exists, and 'false' if no matching key exists.
void defineSet(const std::string &magick_,const std::string &key_,
bool flag_);
bool defineSet(const std::string &magick_,const std::string &key_) const;
// Tagged image format define (set/access coder-specific option) The
// magick_ option specifies the coder the define applies to. The key_
// option provides the key specific to that coder. The value_ option
// provides the value to set (if any). See the defineSet() method if the
// key must be removed entirely.
void defineValue(const std::string &magick_,const std::string &key_,
const std::string &value_);
std::string defineValue(const std::string &magick_,
const std::string &key_) const;
// Removes skew from the image. Skew is an artifact that occurs in scanned
// images because of the camera being misaligned, imperfections in the
// scanning or surface, or simply because the paper was not placed
// completely flat when scanned. The value of threshold_ ranges from 0
// to QuantumRange.
void deskew(const double threshold_);
// Despeckle image (reduce speckle noise)
void despeckle(void);
// Determines the color type of the image. This method can be used to
// automaticly make the type GrayScale.
ImageType determineType(void) const;
// Display image on screen
void display(void);
// Distort image. distorts an image using various distortion methods, by
// mapping color lookups of the source image to a new destination image
// usally of the same size as the source image, unless 'bestfit' is set to
// true.
void distort(const DistortImageMethod method_,
const size_t number_arguments_,const double *arguments_,
const bool bestfit_=false);
// Draw on image using a single drawable
void draw(const Drawable &drawable_);
// Draw on image using a drawable list
void draw(const std::list<Magick::Drawable> &drawable_);
// Edge image (hilight edges in image)
void edge(const double radius_=0.0);
// Emboss image (hilight edges with 3D effect)
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void emboss(const double radius_=0.0,const double sigma_=1.0);
// Converts pixels to cipher-pixels.
void encipher(const std::string &passphrase_);
// Enhance image (minimize noise)
void enhance(void);
// Equalize image (histogram equalization)
void equalize(void);
// Erase image to current "background color"
void erase(void);
// Extend the image as defined by the geometry.
void extent(const Geometry &geometry_);
void extent(const Geometry &geometry_,const Color &backgroundColor);
void extent(const Geometry &geometry_,const Color &backgroundColor,
const GravityType gravity_ );
void extent(const Geometry &geometry_,const GravityType gravity_);
// Flip image (reflect each scanline in the vertical direction)
void flip(void);
// Flood-fill color across pixels that match the color of the
// target pixel and are neighbors of the target pixel.
// Uses current fuzz setting when determining color match.
void floodFillColor(const Geometry &point_,const Color &fillColor_);
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const bool invert_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const bool invert_);
// Flood-fill color across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const Color &borderColor_);
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const Color &borderColor_,const bool invert_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const Color &borderColor_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const Color &borderColor_,const bool invert_);
// Floodfill pixels matching color (within fuzz factor) of target
// pixel(x,y) with replacement opacity value using method.
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const bool invert_=false);
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const PaintMethod method_);
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const Color &target_,
const bool invert_=false);
// Flood-fill texture across pixels that match the color of the
// target pixel and are neighbors of the target pixel.
// Uses current fuzz setting when determining color match.
void floodFillTexture(const Geometry &point_,const Image &texture_);
void floodFillTexture(const Geometry &point_,const Image &texture_,
const bool invert_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const bool invert_);
// Flood-fill texture across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
void floodFillTexture(const Geometry &point_,const Image &texture_,
const Color &borderColor_);
void floodFillTexture(const Geometry &point_,const Image &texture_,
const Color &borderColor_,const bool invert_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const Color &borderColor_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const Color &borderColor_,const bool invert_);
// Flop image (reflect each scanline in the horizontal direction)
void flop(void);
// Obtain font metrics for text string given current font,
// pointsize, and density settings.
void fontTypeMetrics(const std::string &text_,TypeMetric *metrics);
// Obtain multi line font metrics for text string given current font,
// pointsize, and density settings.
void fontTypeMetricsMultiline(const std::string &text_,
TypeMetric *metrics);
// Frame image
void frame(const Geometry &geometry_=frameGeometryDefault);
void frame(const size_t width_,const size_t height_,
const ::ssize_t innerBevel_=6, const ::ssize_t outerBevel_=6);
// Applies a mathematical expression to the image.
void fx(const std::string expression);
void fx(const std::string expression,const Magick::ChannelType channel);
// Gamma correct image
void gamma(const double gamma_);
void gamma(const double gammaRed_,const double gammaGreen_,
const double gammaBlue_);
// Gaussian blur image
// The number of neighbor pixels to be included in the convolution
// mask is specified by 'width_'. The standard deviation of the
// gaussian bell curve is specified by 'sigma_'.
void gaussianBlur(const double width_,const double sigma_);
void gaussianBlurChannel(const ChannelType channel_,const double width_,
const double sigma_);
// Obtain immutable image pixel indexes (valid for PseudoClass images)
const IndexPacket *getConstIndexes(void) const;
// Transfers read-only pixels from the image to the pixel cache as
// defined by the specified region
const PixelPacket *getConstPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_) const;
// Obtain mutable image pixel indexes (valid for PseudoClass images)
IndexPacket *getIndexes(void);
// Transfers pixels from the image to the pixel cache as defined
// by the specified region. Modified pixels may be subsequently
// transferred back to the image via syncPixels. This method is
// valid for DirectClass images.
PixelPacket *getPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Converts the colors in the image to gray.
void grayscale(const PixelIntensityMethod method_);
// Apply a color lookup table (Hald CLUT) to the image.
void haldClut(const Image &clutImage_);
// Identifies lines in the image.
void houghLine(const size_t width_,const size_t height_,
const size_t threshold_=40);
// Implode image (special effect)
void implode(const double factor_);
// Implements the inverse discrete Fourier transform (DFT) of the image
// either as a magnitude / phase or real / imaginary image pair.
void inverseFourierTransform(const Image &phase_);
void inverseFourierTransform(const Image &phase_,const bool magnitude_);
// An edge preserving noise reduction filter.
void kuwahara(const double radius_=0.0,const double sigma_=1.0);
void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Level image. Adjust the levels of the image by scaling the
// colors falling between specified white and black points to the
// full available quantum range. The parameters provided represent
// the black, mid (gamma), and white points. The black point
// specifies the darkest color in the image. Colors darker than
// the black point are set to zero. Mid point (gamma) specifies a
// gamma correction to apply to the image. White point specifies
// the lightest color in the image. Colors brighter than the
// white point are set to the maximum quantum value. The black and
// white point have the valid range 0 to QuantumRange while mid (gamma)
// has a useful range of 0 to ten.
void level(const double black_point,const double white_point,
const double mid_point=1.0);
void levelChannel(const ChannelType channel,const double black_point,
const double white_point,const double mid_point=1.0);
// Maps the given color to "black" and "white" values, linearly spreading
// out the colors, and level values on a channel by channel bases, as
// per level(). The given colors allows you to specify different level
// ranges for each of the color channels separately.
void levelColors(const Color &blackColor_,const Color &whiteColor_,
const bool invert_=true);
void levelColorsChannel(const ChannelType channel_,
const Color &blackColor_,const Color &whiteColor_,
const bool invert_=true);
// Levelize applies the reversed level operation to just the specific
// channels specified.It compresses the full range of color values, so
// that they lie between the given black and white points. Gamma is
// applied before the values are mapped.
void levelize(const double blackPoint_,const double whitePoint_,
const double gamma_=1.0);
void levelizeChannel(const ChannelType channel_,const double blackPoint_,
const double whitePoint_,const double gamma_=1.0);
// Discards any pixels below the black point and above the white point and
// levels the remaining pixels.
void linearStretch(const double blackPoint_,const double whitePoint_);
// Rescales image with seam carving.
void liquidRescale(const Geometry &geometry_);
// Local contrast enhancement
void localContrast(const double radius_,const double strength_);
// Magnify image by integral size
void magnify(void);
// Remap image colors with closest color from reference image
void map(const Image &mapImage_,const bool dither_=false);
// Floodfill designated area with replacement opacity value
void matteFloodfill(const Color &target_,const unsigned int opacity_,
const ::ssize_t x_,const ::ssize_t y_,const PaintMethod method_);
// Filter image by replacing each pixel component with the median
// color in a circular neighborhood
void medianFilter(const double radius_=0.0);
// Merge image layers (deprecated, don't use any more)
void mergeLayers(const ImageLayerMethod layerType_);
// Reduce image by integral size
void minify(void);
// Modulate percent hue, saturation, and brightness of an image
void modulate(const double brightness_,const double saturation_,
const double hue_);
// Returns the normalized moments of one or more image channels.
ImageMoments moments(void) const;
// Applies a kernel to the image according to the given mophology method.
void morphology(const MorphologyMethod method_,const std::string kernel_,
const ssize_t iterations_=1);
void morphology(const MorphologyMethod method_,
const KernelInfoType kernel_,const std::string arguments_,
const ssize_t iterations_=1);
void morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const std::string kernel_,
const ssize_t iterations_=1);
void morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const KernelInfoType kernel_,
const std::string arguments_,const ssize_t iterations_=1);
// Motion blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
// The angle_ parameter specifies the angle the object appears
// to be comming from (zero degrees is from the right).
void motionBlur(const double radius_,const double sigma_,
const double angle_);
// Negate colors in image. Set grayscale to only negate grayscale
// values in image.
void negate(const bool grayscale_=false);
void negateChannel(const ChannelType channel_,const bool grayscale_=false);
// Normalize image (increase contrast by normalizing the pixel
// values to span the full range of color values)
void normalize(void);
// Oilpaint image (image looks like oil painting)
void oilPaint(const double radius_=3.0);
// Set or attenuate the opacity channel in the image. If the image
// pixels are opaque then they are set to the specified opacity
// value, otherwise they are blended with the supplied opacity
// value. The value of opacity_ ranges from 0 (completely opaque)
// to QuantumRange. The defines OpaqueOpacity and TransparentOpacity are
// available to specify completely opaque or completely
// transparent, respectively.
void opacity(const unsigned int opacity_);
// Change color of opaque pixel to specified pen color.
void opaque(const Color &opaqueColor_,const Color &penColor_,
const bool invert_=MagickFalse);
// Perform a ordered dither based on a number of pre-defined dithering
// threshold maps, but over multiple intensity levels.
void orderedDither(std::string thresholdMap_);
void orderedDitherChannel(const ChannelType channel_,
std::string thresholdMap_);
// Set each pixel whose value is less than epsilon to epsilon or
// -epsilon (whichever is closer) otherwise the pixel value remains
// unchanged.
void perceptible(const double epsilon_);
void perceptibleChannel(const ChannelType channel_,const double epsilon_);
// Ping is similar to read except only enough of the image is read
// to determine the image columns, rows, and filesize. Access the
// columns(), rows(), and fileSize() attributes after invoking
// ping. The image data is not valid after calling ping.
void ping(const Blob &blob_);
// Ping is similar to read except only enough of the image is read
// to determine the image columns, rows, and filesize. Access the
// columns(), rows(), and fileSize() attributes after invoking
// ping. The image data is not valid after calling ping.
void ping(const std::string &imageSpec_);
// Get/set pixel color at location x & y.
void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_);
Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const;
// Simulates a Polaroid picture.
void polaroid(const std::string &caption_,const double angle_);
// Reduces the image to a limited number of colors for a "poster" effect.
void posterize(const size_t levels_,const bool dither_=false);
void posterizeChannel(const ChannelType channel_, const size_t levels_,
const bool dither_=false);
// Execute a named process module using an argc/argv syntax similar to
// that accepted by a C 'main' routine. An exception is thrown if the
// requested process module doesn't exist, fails to load, or fails during
// execution.
void process(std::string name_,const ::ssize_t argc_,const char **argv_);
// Add or remove a named profile to/from the image. Remove the
// profile by passing an empty Blob (e.g. Blob()). Valid names are
// "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name.
void profile(const std::string name_,const Blob &colorProfile_);
// Retrieve a named profile from the image. Valid names are:
// "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC"
// or an existing user/format-defined profile name.
Blob profile(const std::string name_) const;
// Quantize image (reduce number of colors)
void quantize(const bool measureError_=false);
// Apply a value with an arithmetic, relational, or logical operator.
void quantumOperator(const ChannelType channel_,
const MagickEvaluateOperator operator_,double rvalue_);
// Apply a value with an arithmetic, relational, or logical operator.
void quantumOperator(const ChannelType channel_,
const MagickFunction function_,const size_t number_parameters_,
const double *parameters_);
// Apply a value with an arithmetic, relational, or logical operator.
void quantumOperator(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_,const ChannelType channel_,
const MagickEvaluateOperator operator_,const double rvalue_);
// Raise image (lighten or darken the edges of an image to give a
// 3-D raised or lowered effect)
void raise(const Geometry &geometry_=raiseGeometryDefault,
const bool raisedFlag_=false);
// Random threshold image.
//
// Changes the value of individual pixels based on the intensity
// of each pixel compared to a random threshold. The result is a
// low-contrast, two color image. The thresholds_ argument is a
// geometry containing LOWxHIGH thresholds. If the string
// contains 2x2, 3x3, or 4x4, then an ordered dither of order 2,
// 3, or 4 will be performed instead. If a channel_ argument is
// specified then only the specified channel is altered. This is
// a very fast alternative to 'quantize' based dithering.
void randomThreshold(const Geometry &thresholds_);
void randomThresholdChannel(const Geometry &thresholds_,
const ChannelType channel_);
// Read single image frame from in-memory BLOB
void read(const Blob &blob_);
// Read single image frame of specified size from in-memory BLOB
void read(const Blob &blob_,const Geometry &size_);
// Read single image frame of specified size and depth from
// in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,const size_t depth_);
// Read single image frame of specified size, depth, and format
// from in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,const size_t depth_,
const std::string &magick_);
// Read single image frame of specified size, and format from
// in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,
const std::string &magick_);
// Read single image frame of specified size into current object
void read(const Geometry &size_,const std::string &imageSpec_);
// Read single image frame from an array of raw pixels, with
// specified storage type (ConstituteImage), e.g.
// image.read( 640, 480, "RGB", 0, pixels );
void read(const size_t width_,const size_t height_,const std::string &map_,
const StorageType type_,const void *pixels_);
// Read single image frame into current object
void read(const std::string &imageSpec_);
// Transfers one or more pixel components from a buffer or file
// into the image pixel cache of an image.
// Used to support image decoders.
void readPixels(const QuantumType quantum_,const unsigned char *source_);
// Reduce noise in image using a noise peak elimination filter
void reduceNoise(void);
void reduceNoise(const double order_);
// Resets the image page canvas and position.
void repage();
// Resize image in terms of its pixel size.
void resample(const Geometry &geometry_);
// Resize image to specified size.
void resize(const Geometry &geometry_);
// Roll image (rolls image vertically and horizontally) by specified
// number of columnms and rows)
void roll(const Geometry &roll_);
void roll(const size_t columns_,const size_t rows_);
// Rotate image counter-clockwise by specified number of degrees.
void rotate(const double degrees_);
// Rotational blur image.
void rotationalBlur(const double angle_);
void rotationalBlurChannel(const ChannelType channel_,
const double angle_);
// Resize image by using pixel sampling algorithm
void sample(const Geometry &geometry_);
// Resize image by using simple ratio algorithm
void scale(const Geometry &geometry_);
// Segment (coalesce similar image components) by analyzing the
// histograms of the color components and identifying units that
// are homogeneous with the fuzzy c-means technique. Also uses
// QuantizeColorSpace and Verbose image attributes
void segment(const double clusterThreshold_=1.0,
const double smoothingThreshold_=1.5);
// Selectively blur pixels within a contrast threshold. It is similar to
// the unsharpen mask that sharpens everything with contrast above a
// certain threshold.
void selectiveBlur(const double radius_,const double sigma_,
const double threshold_);
void selectiveBlurChannel(const ChannelType channel_,const double radius_,
const double sigma_,const double threshold_);
// Separates a channel from the image and returns it as a grayscale image.
Image separate(const ChannelType channel_) const;
// Applies a special effect to the image, similar to the effect achieved in
// a photo darkroom by sepia toning. Threshold ranges from 0 to
// QuantumRange and is a measure of the extent of the sepia toning.
// A threshold of 80% is a good starting point for a reasonable tone.
void sepiaTone(const double threshold_);
// Allocates a pixel cache region to store image pixels as defined
// by the region rectangle. This area is subsequently transferred
// from the pixel cache to the image via syncPixels.
PixelPacket *setPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Shade image using distant light source
void shade(const double azimuth_=30,const double elevation_=30,
const bool colorShading_=false);
// Simulate an image shadow
void shadow(const double percent_opacity_=80.0,const double sigma_=0.5,
const ssize_t x_=5,const ssize_t y_=5);
// Sharpen pixels in image
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void sharpen(const double radius_=0.0,const double sigma_=1.0);
void sharpenChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Shave pixels from image edges.
void shave(const Geometry &geometry_);
// Shear image (create parallelogram by sliding image by X or Y axis)
void shear(const double xShearAngle_,const double yShearAngle_);
// adjust the image contrast with a non-linear sigmoidal contrast algorithm
void sigmoidalContrast(const size_t sharpen_,const double contrast,
const double midpoint=QuantumRange/2.0);
// Image signature. Set force_ to true in order to re-calculate
// the signature regardless of whether the image data has been
// modified.
std::string signature(const bool force_=false) const;
// Simulates a pencil sketch. We convolve the image with a Gaussian
// operator of the given radius and standard deviation (sigma). For
// reasonable results, radius should be larger than sigma. Use a
// radius of 0 and SketchImage() selects a suitable radius for you.
void sketch(const double radius_=0.0,const double sigma_=1.0,
const double angle_=0.0);
// Solarize image (similar to effect seen when exposing a
// photographic film to light during the development process)
void solarize(const double factor_=50.0);
// Sparse color image, given a set of coordinates, interpolates the colors
// found at those coordinates, across the whole image, using various
// methods.
void sparseColor(const ChannelType channel,const SparseColorMethod method,
const size_t number_arguments,const double *arguments);
// Splice the background color into the image.
void splice(const Geometry &geometry_);
void splice(const Geometry &geometry_,const Color &backgroundColor_);
void splice(const Geometry &geometry_,const Color &backgroundColor_,
const GravityType gravity_);
// Spread pixels randomly within image by specified ammount
void spread(const size_t amount_=3);
void statistics(ImageStatistics *statistics) const;
// Add a digital watermark to the image (based on second image)
void stegano(const Image &watermark_);
// Create an image which appears in stereo when viewed with
// red-blue glasses (Red image on left, blue on right)
void stereo(const Image &rightImage_);
// Strip strips an image of all profiles and comments.
void strip(void);
// Search for the specified image at EVERY possible location in this image.
// This is slow! very very slow.. It returns a similarity image such that
// an exact match location is completely white and if none of the pixels
// match, black, otherwise some gray level in-between.
Image subImageSearch(const Image &reference_,const MetricType metric_,
Geometry *offset_,double *similarityMetric_,
const double similarityThreshold=(-1.0));
// Swirl image (image pixels are rotated by degrees)
void swirl(const double degrees_);
// Transfers the image cache pixels to the image.
void syncPixels(void);
// Channel a texture on image background
void texture(const Image &texture_);
// Threshold image
void threshold(const double threshold_);
// Resize image to thumbnail size
void thumbnail(const Geometry &geometry_);
// Applies a color vector to each pixel in the image. The length of the
// vector is 0 for black and white and at its maximum for the midtones.
// The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
void tint(const std::string opacity_);
// Transform image based on image and crop geometries
// Crop geometry is optional
void transform(const Geometry &imageGeometry_);
void transform(const Geometry &imageGeometry_,
const Geometry &cropGeometry_);
// Origin of coordinate system to use when annotating with text or drawing
void transformOrigin(const double x_,const double y_);
// Reset transformation parameters to default
void transformReset(void);
// Scale to use when annotating with text or drawing
void transformScale(const double sx_,const double sy_);
// Add matte image to image, setting pixels matching color to
// transparent
void transparent(const Color &color_);
// Add matte image to image, for all the pixels that lies in between
// the given two color
void transparentChroma(const Color &colorLow_,const Color &colorHigh_);
// Creates a horizontal mirror image by reflecting the pixels around the
// central y-axis while rotating them by 90 degrees.
void transpose(void);
// Creates a vertical mirror image by reflecting the pixels around the
// central x-axis while rotating them by 270 degrees.
void transverse(void);
// Trim edges that are the background color from the image
void trim(void);
// Returns the unique colors of an image.
Image uniqueColors(void) const;
// Replace image with a sharpened version of the original image
// using the unsharp mask algorithm.
// radius_
// the radius of the Gaussian, in pixels, not counting the
// center pixel.
// sigma_
// the standard deviation of the Gaussian, in pixels.
// amount_
// the percentage of the difference between the original and
// the blur image that is added back into the original.
// threshold_
// the threshold in pixels needed to apply the diffence amount.
void unsharpmask(const double radius_,const double sigma_,
const double amount_,const double threshold_);
void unsharpmaskChannel(const ChannelType channel_,const double radius_,
const double sigma_,const double amount_,const double threshold_);
// Softens the edges of the image in vignette style.
void vignette(const double radius_=0.0,const double sigma_=1.0,
const ssize_t x_=0,const ssize_t y_=0);
// Map image pixels to a sine wave
void wave(const double amplitude_=25.0,const double wavelength_=150.0);
// Removes noise from the image using a wavelet transform.
void waveletDenoise(const double threshold_,const double softness_);
// Forces all pixels above the threshold into white while leaving all
// pixels at or below the threshold unchanged.
void whiteThreshold(const std::string &threshold_);
void whiteThresholdChannel(const ChannelType channel_,
const std::string &threshold_);
// Write single image frame to in-memory BLOB, with optional
// format and adjoin parameters.
void write(Blob *blob_);
void write(Blob *blob_,const std::string &magick_);
void write(Blob *blob_,const std::string &magick_,const size_t depth_);
// Write single image frame to an array of pixels with storage
// type specified by user (DispatchImage), e.g.
// image.write( 0, 0, 640, 1, "RGB", 0, pixels );
void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_,
const size_t rows_,const std::string& map_,const StorageType type_,
void *pixels_);
// Write single image frame to a file
void write(const std::string &imageSpec_);
// Transfers one or more pixel components from the image pixel
// cache to a buffer or file.
// Used to support image encoders.
void writePixels(const QuantumType quantum_,unsigned char *destination_);
// Zoom image to specified size.
void zoom(const Geometry &geometry_);
//////////////////////////////////////////////////////////////////////
//
// No user-serviceable parts beyond this point
//
//////////////////////////////////////////////////////////////////////
// Construct with MagickCore::Image and default options
Image(MagickCore::Image *image_);
// Retrieve Image*
MagickCore::Image *&image(void);
const MagickCore::Image *constImage(void) const;
// Retrieve ImageInfo*
MagickCore::ImageInfo *imageInfo(void);
const MagickCore::ImageInfo *constImageInfo(void) const;
// Retrieve Options*
Options *options(void);
const Options *constOptions(void) const;
// Retrieve QuantizeInfo*
MagickCore::QuantizeInfo *quantizeInfo(void);
const MagickCore::QuantizeInfo *constQuantizeInfo(void) const;
// Prepare to update image (copy if reference > 1)
void modifyImage(void);
// Replace current image (reference counted)
MagickCore::Image *replaceImage(MagickCore::Image *replacement_);
// Test for ImageMagick error and throw exception if error
void throwImageException(void) const;
private:
void read(MagickCore::Image *image,
MagickCore::ExceptionInfo *exceptionInfo);
void floodFill(const ssize_t x_,const ssize_t y_,
const Magick::Image *fillPattern_,const Color &fill_,
const MagickCore::PixelPacket *target,const bool invert_);
ImageRef *_imgRef;
};
} // end of namespace Magick
//
// Inlines
//
inline Magick::ClassType Magick::Image::classType(void) const
{
return static_cast<Magick::ClassType>(constImage()->storage_class);
}
inline size_t Magick::Image::columns(void) const
{
return constImage()->columns;
}
inline void Magick::Image::lineWidth(const double lineWidth_)
{
strokeWidth(lineWidth_);
}
inline double Magick::Image::lineWidth(void) const
{
return strokeWidth();
}
inline void Magick::Image::reduceNoise(void)
{
reduceNoise(3.0);
}
inline size_t Magick::Image::rows(void) const
{
return constImage()->rows;
}
#endif // Magick_Image_header
|