granicus.if.org Git - imagemagick/blob - Magick++/lib/Options.cpp

   1 // This may look like C code, but it is really -*- C++ -*-
   2 //
   3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
   4 //
   5 // Implementation of Options
   6 //
   7 // A wrapper around DrawInfo, ImageInfo, and QuantizeInfo
   8 //
   9
  10 #define MAGICKCORE_IMPLEMENTATION  1
  11 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
  12
  13 #include "Magick++/Include.h"
  14 #include <string>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <math.h>
  18
  19 #include "Magick++/Options.h"
  20 #include "Magick++/Functions.h"
  21 #include "Magick++/Exception.h"
  22
  23 #define MagickPI  3.14159265358979323846264338327950288419716939937510
  24 #define DegreesToRadians(x)  (MagickPI*(x)/180.0)
  25
  26 Magick::Options::Options(void)
  27   : _imageInfo(static_cast<ImageInfo*>(AcquireMagickMemory(
  28       sizeof(ImageInfo)))),
  29     _quantizeInfo(static_cast<QuantizeInfo*>(AcquireMagickMemory(
  30       sizeof(QuantizeInfo)))),
  31     _drawInfo(static_cast<DrawInfo*>(AcquireMagickMemory(sizeof(DrawInfo))))
  32 {
  33   // Initialize image info with defaults
  34   GetImageInfo(_imageInfo);
  35
  36   // Initialize quantization info
  37   GetQuantizeInfo(_quantizeInfo);
  38
  39   // Initialize drawing info
  40   GetDrawInfo(_imageInfo,_drawInfo);
  41 }
  42
  43 Magick::Options::Options(const Magick::Options& options_)
  44   : _imageInfo(CloneImageInfo(options_._imageInfo )),
  45     _quantizeInfo(CloneQuantizeInfo(options_._quantizeInfo)),
  46     _drawInfo(CloneDrawInfo(_imageInfo,options_._drawInfo))
  47 {
  48 }
  49
  50 Magick::Options::~Options()
  51 {
  52   // Destroy image info
  53    _imageInfo=DestroyImageInfo(_imageInfo);
  54
  55   // Destroy quantization info
  56    _quantizeInfo=DestroyQuantizeInfo(_quantizeInfo);
  57
  58   // Destroy drawing info
  59    _drawInfo=DestroyDrawInfo(_drawInfo);
  60 }
  61
  62 void Magick::Options::antiAlias(bool flag_)
  63 {
  64   _drawInfo->text_antialias=static_cast<MagickBooleanType>(
  65     flag_ ? MagickTrue : MagickFalse);
  66 }
  67
  68 bool Magick::Options::antiAlias(void) const
  69 {
  70   return(static_cast<bool>(_drawInfo->text_antialias));
  71 }
  72
  73 void Magick::Options::adjoin(bool flag_)
  74 {
  75   _imageInfo->adjoin=static_cast<MagickBooleanType>(
  76     flag_ ? MagickTrue : MagickFalse);
  77 }
  78
  79 bool Magick::Options::adjoin(void) const
  80 {
  81   return(static_cast<bool>(_imageInfo->adjoin));
  82 }
  83
  84 void Magick::Options::backgroundColor(const Magick::Color &color_)
  85 {
  86   _imageInfo->background_color=color_;
  87 }
  88
  89 Magick::Color Magick::Options::backgroundColor(void) const
  90 {
  91   return(Magick::Color(_imageInfo->background_color));
  92 }
  93
  94 void Magick::Options::backgroundTexture(const std::string &backgroundTexture_)
  95 {
  96   if (backgroundTexture_.length() == 0)
  97     _imageInfo->texture=(char *) RelinquishMagickMemory(_imageInfo->texture);
  98   else
  99     Magick::CloneString(&_imageInfo->texture,backgroundTexture_);
 100 }
 101
 102 std::string Magick::Options::backgroundTexture(void) const
 103 {
 104   if (_imageInfo->texture)
 105     return(std::string(_imageInfo->texture));
 106   else
 107     return(std::string());
 108 }
 109
 110 void Magick::Options::borderColor(const Color &color_)
 111 {
 112   _imageInfo->border_color=color_;
 113   _drawInfo->border_color=color_;
 114 }
 115
 116 Magick::Color Magick::Options::borderColor(void) const
 117 {
 118   return(Magick::Color(_imageInfo->border_color));
 119 }
 120
 121 void Magick::Options::boxColor(const Magick::Color &boxColor_)
 122 {
 123   _drawInfo->undercolor=boxColor_;
 124 }
 125
 126 Magick::Color Magick::Options::boxColor(void) const
 127 {
 128   return(Magick::Color(_drawInfo->undercolor));
 129 }
 130
 131 void Magick::Options::colorspaceType(Magick::ColorspaceType colorspace_)
 132 {
 133   _imageInfo->colorspace=colorspace_;
 134 }
 135
 136 Magick::ColorspaceType Magick::Options::colorspaceType(void) const
 137 {
 138   return(static_cast<Magick::ColorspaceType>(_imageInfo->colorspace));
 139 }
 140
 141 void Magick::Options::compressType(CompressionType compressType_)
 142 {
 143   _imageInfo->compression=compressType_;
 144 }
 145
 146 Magick::CompressionType Magick::Options::compressType(void) const
 147 {
 148   return(static_cast<Magick::CompressionType>(_imageInfo->compression));
 149 }
 150
 151 void Magick::Options::colorFuzz(double fuzz_)
 152 {
 153   _imageInfo->fuzz=fuzz_;
 154 }
 155
 156 double Magick::Options::colorFuzz(void) const
 157 {
 158   return(_imageInfo->fuzz);
 159 }
 160
 161 void Magick::Options::debug(bool flag_)
 162 {
 163   if  (flag_)
 164     SetLogEventMask("All");
 165   else
 166     SetLogEventMask("None");
 167 }
 168
 169 bool Magick::Options::debug(void) const
 170 {
 171   if (IsEventLogging())
 172     return(true);
 173   return(false);
 174 }
 175
 176 void Magick::Options::density(const Magick::Geometry &density_)
 177 {
 178   if ( !density_.isValid() )
 179     _imageInfo->density=(char *) RelinquishMagickMemory(_imageInfo->density);
 180   else
 181     Magick::CloneString(&_imageInfo->density,density_);
 182 }
 183
 184 Magick::Geometry Magick::Options::density(void) const
 185 {
 186   if (_imageInfo->density)
 187     return(Geometry(_imageInfo->density));
 188
 189   return(Geometry());
 190 }
 191
 192 void Magick::Options::depth(size_t depth_)
 193 {
 194   _imageInfo->depth=depth_;
 195 }
 196
 197 size_t Magick::Options::depth(void) const
 198 {
 199   return(_imageInfo->depth);
 200 }
 201
 202 void Magick::Options::endian(Magick::EndianType endian_)
 203 {
 204   _imageInfo->endian=endian_;
 205 }
 206
 207 Magick::EndianType Magick::Options::endian(void) const
 208 {
 209   return(_imageInfo->endian);
 210 }
 211
 212 void Magick::Options::file(FILE *file_)
 213 {
 214   SetImageInfoFile(_imageInfo,file_);
 215 }
 216
 217 FILE *Magick::Options::file(void) const
 218 {
 219   return(GetImageInfoFile(_imageInfo));
 220 }
 221
 222 void Magick::Options::fileName(const std::string &fileName_)
 223 {
 224   fileName_.copy(_imageInfo->filename,MaxTextExtent-1);
 225   if (fileName_.length() > MaxTextExtent-1)
 226     _imageInfo->filename[MaxTextExtent-1]=0;
 227   else
 228     _imageInfo->filename[fileName_.length()]=0;
 229 }
 230
 231 std::string Magick::Options::fileName(void) const
 232 {
 233   return(std::string(_imageInfo->filename));
 234 }
 235
 236 void Magick::Options::fillColor(const Magick::Color &fillColor_)
 237 {
 238   _drawInfo->fill=fillColor_;
 239   if (fillColor_ == Magick::Color())
 240     fillPattern((const MagickCore::Image*) NULL);
 241 }
 242
 243 Magick::Color Magick::Options::fillColor(void) const
 244 {
 245   return(_drawInfo->fill);
 246 }
 247
 248 void Magick::Options::fillPattern(const MagickCore::Image *fillPattern_)
 249 {
 250   if (_drawInfo->fill_pattern)
 251       _drawInfo->fill_pattern=DestroyImageList(_drawInfo->fill_pattern);
 252
 253   if (fillPattern_)
 254     {
 255       GetPPException;
 256       _drawInfo->fill_pattern=CloneImage(const_cast<MagickCore::Image*>(
 257         fillPattern_),0,0,static_cast<MagickBooleanType>(MagickTrue),
 258         &exceptionInfo);
 259       ThrowPPException;
 260     }
 261 }
 262
 263 const MagickCore::Image *Magick::Options::fillPattern(void) const
 264 {
 265   return(_drawInfo->fill_pattern);
 266 }
 267
 268 void Magick::Options::fillRule(const Magick::FillRule &fillRule_)
 269 {
 270   _drawInfo->fill_rule=fillRule_;
 271 }
 272
 273 Magick::FillRule Magick::Options::fillRule(void) const
 274 {
 275   return(_drawInfo->fill_rule);
 276 }
 277
 278 void Magick::Options::font(const std::string &font_)
 279 {
 280   if (font_.length() == 0)
 281     {
 282       _imageInfo->font=(char *) RelinquishMagickMemory(_imageInfo->font);
 283       _drawInfo->font=(char *) RelinquishMagickMemory(_drawInfo->font);
 284     }
 285   else
 286     {
 287       Magick::CloneString(&_imageInfo->font,font_);
 288       Magick::CloneString(&_drawInfo->font,font_);
 289     }
 290 }
 291
 292 std::string Magick::Options::font(void) const
 293 {
 294   if (_imageInfo->font)
 295     return(std::string(_imageInfo->font));
 296
 297   return(std::string());
 298 }
 299
 300 void Magick::Options::fontPointsize(double pointSize_)
 301 {
 302   _imageInfo->pointsize=pointSize_;
 303   _drawInfo->pointsize=pointSize_;
 304 }
 305
 306 double Magick::Options::fontPointsize(void) const
 307 {
 308   return(_imageInfo->pointsize);
 309 }
 310
 311 std::string Magick::Options::format(void) const
 312 {
 313   const MagickInfo
 314     *magick_info=0;
 315
 316   GetPPException;
 317   if (*_imageInfo->magick != '\0' )
 318     magick_info = GetMagickInfo(_imageInfo->magick,&exceptionInfo);
 319   ThrowPPException;
 320
 321   if ((magick_info != 0) && (*magick_info->description != '\0'))
 322     return(std::string( magick_info->description));
 323
 324   return(std::string());
 325 }
 326
 327 void Magick::Options::interlaceType(Magick::InterlaceType interlace_)
 328 {
 329   _imageInfo->interlace=interlace_;
 330 }
 331
 332 Magick::InterlaceType Magick::Options::interlaceType(void) const
 333 {
 334   return(static_cast<Magick::InterlaceType>(_imageInfo->interlace));
 335 }
 336
 337 void Magick::Options::magick(const std::string &magick_)
 338 {
 339   FormatLocaleString(_imageInfo->filename,MaxTextExtent,"%.1024s:",
 340     magick_.c_str());
 341   GetPPException;
 342   SetImageInfo(_imageInfo,1,&exceptionInfo);
 343   if (*_imageInfo->magick == '\0')
 344     throwExceptionExplicit(OptionWarning, "Unrecognized image format",
 345       magick_.c_str());
 346   (void) DestroyExceptionInfo(&exceptionInfo);
 347 }
 348
 349 std::string Magick::Options::magick(void) const
 350 {
 351   if (_imageInfo->magick && *_imageInfo->magick)
 352     return(std::string(_imageInfo->magick));
 353
 354   return(std::string());
 355 }
 356
 357 void Magick::Options::matteColor(const Magick::Color &matteColor_)
 358 {
 359   _imageInfo->matte_color=matteColor_;
 360 }
 361
 362 Magick::Color Magick::Options::matteColor(void) const
 363 {
 364   return(Magick::Color(_imageInfo->matte_color));
 365 }
 366
 367 void Magick::Options::monochrome(bool monochromeFlag_)
 368 {
 369   _imageInfo->monochrome=(MagickBooleanType) monochromeFlag_;
 370 }
 371
 372 bool Magick::Options::monochrome(void) const
 373 {
 374   return(static_cast<bool>(_imageInfo->monochrome));
 375 }
 376
 377 void Magick::Options::page(const Magick::Geometry &pageSize_)
 378 {
 379   if (!pageSize_.isValid())
 380     _imageInfo->page=(char *) RelinquishMagickMemory(_imageInfo->page);
 381   else
 382     Magick::CloneString(&_imageInfo->page,pageSize_);
 383 }
 384
 385 Magick::Geometry Magick::Options::page(void) const
 386 {
 387   if (_imageInfo->page)
 388     return(Geometry(_imageInfo->page));
 389
 390   return(Geometry());
 391 }
 392
 393 void Magick::Options::quality(size_t quality_)
 394 {
 395   _imageInfo->quality=quality_;
 396 }
 397
 398 size_t Magick::Options::quality(void) const
 399 {
 400   return(_imageInfo->quality);
 401 }
 402
 403 void Magick::Options::quantizeColors(size_t colors_)
 404 {
 405   _quantizeInfo->number_colors=colors_;
 406 }
 407
 408 size_t Magick::Options::quantizeColors(void) const
 409 {
 410   return(_quantizeInfo->number_colors);
 411 }
 412
 413 void Magick::Options::quantizeColorSpace(Magick::ColorspaceType colorSpace_)
 414 {
 415   _quantizeInfo->colorspace=colorSpace_;
 416 }
 417
 418 Magick::ColorspaceType Magick::Options::quantizeColorSpace(void) const
 419 {
 420   return(static_cast<Magick::ColorspaceType>(_quantizeInfo->colorspace));
 421 }
 422
 423 void Magick::Options::quantizeDither(bool ditherFlag_)
 424 {
 425   _imageInfo->dither=(MagickBooleanType) ditherFlag_;
 426   _quantizeInfo->dither_method=ditherFlag_ ? RiemersmaDitherMethod :
 427     NoDitherMethod;
 428 }
 429
 430 bool Magick::Options::quantizeDither(void) const
 431 {
 432   return(static_cast<bool>(_imageInfo->dither));
 433 }
 434
 435 void Magick::Options::quantizeDitherMethod(DitherMethod ditherMethod_)
 436 {
 437   _quantizeInfo->dither_method=ditherMethod_;
 438 }
 439
 440 MagickCore::DitherMethod Magick::Options::quantizeDitherMethod(void) const
 441 {
 442   return(_quantizeInfo->dither_method);
 443 }
 444
 445 void Magick::Options::quantizeTreeDepth(size_t treeDepth_)
 446 {
 447   _quantizeInfo->tree_depth=treeDepth_;
 448 }
 449
 450 size_t Magick::Options::quantizeTreeDepth(void) const
 451 {
 452   return(_quantizeInfo->tree_depth);
 453 }
 454
 455 void Magick::Options::resolutionUnits(Magick::ResolutionType resolutionUnits_)
 456 {
 457   _imageInfo->units=resolutionUnits_;
 458 }
 459
 460 Magick::ResolutionType Magick::Options::resolutionUnits(void) const
 461 {
 462   return(static_cast<Magick::ResolutionType>(_imageInfo->units));
 463 }
 464
 465 void Magick::Options::samplingFactor(const std::string &samplingFactor_)
 466 {
 467   if (samplingFactor_.length() == 0)
 468     _imageInfo->sampling_factor=(char *) RelinquishMagickMemory(
 469       _imageInfo->sampling_factor);
 470   else
 471     Magick::CloneString(&_imageInfo->sampling_factor,samplingFactor_);
 472 }
 473
 474 std::string Magick::Options::samplingFactor(void) const
 475 {
 476   if (_imageInfo->sampling_factor)
 477     return(std::string(_imageInfo->sampling_factor));
 478
 479   return(std::string());
 480 }
 481
 482 void Magick::Options::size(const Geometry &geometry_)
 483 {
 484   _imageInfo->size=(char *) RelinquishMagickMemory(_imageInfo->size);
 485
 486   if (geometry_.isValid())
 487     Magick::CloneString(&_imageInfo->size,geometry_);
 488 }
 489
 490 Magick::Geometry Magick::Options::size(void) const
 491 {
 492   if (_imageInfo->size)
 493     return(Geometry(_imageInfo->size));
 494
 495   return(Geometry());
 496 }
 497
 498 void Magick::Options::strokeAntiAlias(bool flag_)
 499 {
 500   flag_ ? _drawInfo->stroke_antialias=MagickTrue :
 501     _drawInfo->stroke_antialias=MagickFalse;
 502 }
 503
 504 bool Magick::Options::strokeAntiAlias(void) const
 505 {
 506   return(_drawInfo->stroke_antialias != 0 ? true : false);
 507 }
 508
 509 void Magick::Options::strokeColor(const Magick::Color &strokeColor_)
 510 {
 511   _drawInfo->stroke=strokeColor_;
 512 }
 513
 514 Magick::Color Magick::Options::strokeColor(void) const
 515 {
 516   return(_drawInfo->stroke);
 517 }
 518
 519 void Magick::Options::strokeDashArray(const double *strokeDashArray_)
 520 {
 521   _drawInfo->dash_pattern=(double *) RelinquishMagickMemory(
 522     _drawInfo->dash_pattern);
 523
 524   if(strokeDashArray_)
 525     {
 526       size_t
 527         x;
 528       // Count elements in dash array
 529       for (x=0; strokeDashArray_[x]; x++) ;
 530       // Allocate elements
 531       _drawInfo->dash_pattern=static_cast<double*>(AcquireMagickMemory((x+1)*
 532         sizeof(double)));
 533       // Copy elements
 534       memcpy(_drawInfo->dash_pattern,strokeDashArray_,(x+1)*sizeof(double));
 535     }
 536 }
 537
 538 const double *Magick::Options::strokeDashArray(void) const
 539 {
 540   return(_drawInfo->dash_pattern);
 541 }
 542
 543 void Magick::Options::strokeDashOffset(double strokeDashOffset_)
 544 {
 545   _drawInfo->dash_offset=strokeDashOffset_;
 546 }
 547
 548 double Magick::Options::strokeDashOffset(void) const
 549 {
 550   return(_drawInfo->dash_offset);
 551 }
 552
 553 void Magick::Options::strokeLineCap(Magick::LineCap lineCap_)
 554 {
 555   _drawInfo->linecap=lineCap_;
 556 }
 557
 558 Magick::LineCap Magick::Options::strokeLineCap(void) const
 559 {
 560   return(_drawInfo->linecap);
 561 }
 562
 563 void Magick::Options::strokeLineJoin(Magick::LineJoin lineJoin_)
 564 {
 565   _drawInfo->linejoin=lineJoin_;
 566 }
 567
 568 Magick::LineJoin Magick::Options::strokeLineJoin(void) const
 569 {
 570   return(_drawInfo->linejoin);
 571 }
 572
 573 void Magick::Options::strokeMiterLimit(size_t miterLimit_)
 574 {
 575   _drawInfo->miterlimit=miterLimit_;
 576 }
 577
 578 size_t Magick::Options::strokeMiterLimit(void) const
 579 {
 580   return(_drawInfo->miterlimit);
 581 }
 582
 583 void Magick::Options::strokePattern(const MagickCore::Image *strokePattern_)
 584 {
 585   if (_drawInfo->stroke_pattern)
 586     _drawInfo->stroke_pattern=DestroyImageList(_drawInfo->stroke_pattern);
 587
 588   if (strokePattern_)
 589     {
 590       GetPPException;
 591       _drawInfo->stroke_pattern=CloneImage( const_cast<MagickCore::Image*>(
 592         strokePattern_),0,0,MagickTrue,&exceptionInfo);
 593       ThrowPPException;
 594     }
 595 }
 596
 597 const MagickCore::Image *Magick::Options::strokePattern(void) const
 598 {
 599   return(_drawInfo->stroke_pattern);
 600 }
 601
 602 void Magick::Options::strokeWidth(double strokeWidth_)
 603 {
 604   _drawInfo->stroke_width=strokeWidth_;
 605 }
 606
 607 double Magick::Options::strokeWidth(void) const
 608 {
 609   return(_drawInfo->stroke_width);
 610 }
 611
 612 void Magick::Options::subImage(size_t subImage_)
 613 {
 614   _imageInfo->scene=subImage_;
 615 }
 616
 617 size_t Magick::Options::subImage(void) const
 618 {
 619   return(_imageInfo->scene);
 620 }
 621
 622 void Magick::Options::subRange(size_t subRange_)
 623 {
 624   _imageInfo->number_scenes=subRange_;
 625 }
 626
 627 size_t Magick::Options::subRange(void) const
 628 {
 629   return(_imageInfo->number_scenes);
 630 }
 631
 632 void Magick::Options::textDirection(DirectionType direction_)
 633 {
 634   _drawInfo->direction=direction_;
 635 }
 636
 637 Magick::DirectionType Magick::Options::textDirection() const
 638 {
 639   return(_drawInfo->direction);
 640 }
 641
 642 void Magick::Options::textEncoding(const std::string &encoding_)
 643 {
 644   CloneString(&_drawInfo->encoding,encoding_.c_str());
 645 }
 646
 647 std::string Magick::Options::textEncoding(void) const
 648 {
 649   if (_drawInfo->encoding && *_drawInfo->encoding)
 650     return(std::string(_drawInfo->encoding));
 651
 652   return(std::string());
 653 }
 654
 655 void Magick::Options::textGravity(GravityType gravity_)
 656 {
 657   _drawInfo->gravity=gravity_;
 658 }
 659
 660 Magick::GravityType Magick::Options::textGravity() const
 661 {
 662   return(_drawInfo->gravity);
 663 }
 664
 665 void Magick::Options::textInterlineSpacing(double spacing_)
 666 {
 667   _drawInfo->interline_spacing=spacing_;
 668 }
 669
 670 double Magick::Options::textInterlineSpacing(void) const
 671 {
 672   return(_drawInfo->interline_spacing);
 673 }
 674
 675 void Magick::Options::textInterwordSpacing(double spacing_)
 676 {
 677   _drawInfo->interword_spacing=spacing_;
 678 }
 679
 680 double Magick::Options::textInterwordSpacing(void) const
 681 {
 682   return(_drawInfo->interword_spacing);
 683 }
 684
 685 void Magick::Options::textKerning(double kerning_)
 686 {
 687   _drawInfo->kerning=kerning_;
 688 }
 689
 690 double Magick::Options::textKerning(void) const
 691 {
 692   return(_drawInfo->kerning);
 693 }
 694
 695 void Magick::Options::transformOrigin(double tx_,double ty_)
 696 {
 697   AffineMatrix
 698     affine,
 699     current=_drawInfo->affine;
 700
 701   affine.sx=1.0;
 702   affine.rx=0.0;
 703   affine.ry=0.0;
 704   affine.sy=1.0;
 705   affine.tx=0.0;
 706   affine.ty=0.0;
 707
 708   affine.tx=tx_;
 709   affine.ty=ty_;
 710
 711   _drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 712   _drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 713   _drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 714   _drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 715   _drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
 716   _drawInfo->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
 717 }
 718
 719 void Magick::Options::transformReset(void)
 720 {
 721   _drawInfo->affine.sx=1.0;
 722   _drawInfo->affine.rx=0.0;
 723   _drawInfo->affine.ry=0.0;
 724   _drawInfo->affine.sy=1.0;
 725   _drawInfo->affine.tx=0.0;
 726   _drawInfo->affine.ty=0.0;
 727 }
 728
 729 void Magick::Options::transformRotation(double angle_)
 730 {
 731   AffineMatrix
 732     affine,
 733     current=_drawInfo->affine;
 734
 735   affine.sx=1.0;
 736   affine.rx=0.0;
 737   affine.ry=0.0;
 738   affine.sy=1.0;
 739   affine.tx=0.0;
 740   affine.ty=0.0;
 741
 742   affine.sx=cos(DegreesToRadians(fmod(angle_,360.0)));
 743   affine.rx=(-sin(DegreesToRadians(fmod(angle_,360.0))));
 744   affine.ry=sin(DegreesToRadians(fmod(angle_,360.0)));
 745   affine.sy=cos(DegreesToRadians(fmod(angle_,360.0)));
 746
 747   _drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 748   _drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 749   _drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 750   _drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 751   _drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
 752   _drawInfo->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
 753 }
 754
 755 void Magick::Options::transformScale(double sx_,double sy_)
 756 {
 757   AffineMatrix
 758     affine,
 759     current=_drawInfo->affine;
 760
 761   affine.sx=1.0;
 762   affine.rx=0.0;
 763   affine.ry=0.0;
 764   affine.sy=1.0;
 765   affine.tx=0.0;
 766   affine.ty=0.0;
 767
 768   affine.sx=sx_;
 769   affine.sy=sy_;
 770
 771   _drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 772   _drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 773   _drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 774   _drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 775   _drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
 776   _drawInfo->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
 777 }
 778
 779 void Magick::Options::transformSkewX(double skewx_)
 780 {
 781   AffineMatrix
 782     affine,
 783     current=_drawInfo->affine;
 784
 785   affine.sx=1.0;
 786   affine.rx=0.0;
 787   affine.ry=0.0;
 788   affine.sy=1.0;
 789   affine.tx=0.0;
 790   affine.ty=0.0;
 791
 792   affine.sx=1.0;
 793   affine.ry=tan(DegreesToRadians(fmod(skewx_,360.0)));
 794   affine.sy=1.0;
 795
 796   _drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 797   _drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 798   _drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 799   _drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 800   _drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
 801   _drawInfo->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
 802 }
 803
 804 void Magick::Options::transformSkewY(double skewy_)
 805 {
 806   AffineMatrix
 807     affine,
 808     current=_drawInfo->affine;
 809
 810   affine.sx=1.0;
 811   affine.rx=0.0;
 812   affine.ry=0.0;
 813   affine.sy=1.0;
 814   affine.tx=0.0;
 815   affine.ty=0.0;
 816
 817   affine.sx=1.0;
 818   affine.rx=tan(DegreesToRadians(fmod(skewy_,360.0)));
 819   affine.sy=1.0;
 820
 821   _drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 822   _drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 823   _drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 824   _drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 825   _drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
 826   _drawInfo->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
 827 }
 828
 829 void Magick::Options::type(const Magick::ImageType type_)
 830 {
 831   _imageInfo->type=type_;
 832 }
 833
 834 Magick::ImageType Magick::Options::type(void) const
 835 {
 836   return(_imageInfo->type);
 837 }
 838
 839 void Magick::Options::verbose(bool verboseFlag_)
 840 {
 841   _imageInfo->verbose=(MagickBooleanType) verboseFlag_;
 842 }
 843
 844 bool Magick::Options::verbose(void) const
 845 {
 846   return(static_cast<bool>(_imageInfo->verbose));
 847 }
 848
 849 void Magick::Options::view(const std::string &view_)
 850 {
 851   if (view_.length() == 0)
 852     _imageInfo->view=(char *) RelinquishMagickMemory(_imageInfo->view);
 853   else
 854     Magick::CloneString(&_imageInfo->view, view_);
 855 }
 856
 857 std::string Magick::Options::view(void) const
 858 {
 859   if (_imageInfo->view)
 860     return(std::string(_imageInfo->view));
 861
 862   return(std::string());
 863 }
 864
 865 void Magick::Options::x11Display(const std::string &display_)
 866 {
 867   if (display_.length() == 0)
 868     _imageInfo->server_name=(char *) RelinquishMagickMemory(
 869       _imageInfo->server_name);
 870   else
 871     Magick::CloneString(&_imageInfo->server_name,display_);
 872 }
 873
 874 std::string Magick::Options::x11Display(void) const
 875 {
 876   if (_imageInfo->server_name)
 877     return(std::string( _imageInfo->server_name));
 878
 879   return(std::string());
 880 }
 881
 882 MagickCore::DrawInfo *Magick::Options::drawInfo(void)
 883 {
 884   return(_drawInfo);
 885 }
 886
 887 MagickCore::ImageInfo *Magick::Options::imageInfo(void)
 888 {
 889   return(_imageInfo);
 890 }
 891
 892 MagickCore::QuantizeInfo *Magick::Options::quantizeInfo(void)
 893 {
 894   return(_quantizeInfo);
 895 }
 896
 897 Magick::Options::Options(const MagickCore::ImageInfo* imageInfo_,
 898   const MagickCore::QuantizeInfo* quantizeInfo_,
 899   const MagickCore::DrawInfo* drawInfo_)
 900 : _imageInfo(0),
 901   _quantizeInfo(0),
 902   _drawInfo(0)
 903 {
 904   _imageInfo=CloneImageInfo(imageInfo_);
 905   _quantizeInfo=CloneQuantizeInfo(quantizeInfo_);
 906   _drawInfo=CloneDrawInfo(imageInfo_,drawInfo_);
 907 }