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