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