Options.cpp revision 8418c7e51974060a1c724e25d700d72fb437174b 
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
26Magick::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
43Magick::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
50Magick::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
62void Magick::Options::antiAlias(bool flag_)
63{
64  _drawInfo->text_antialias=static_cast<MagickBooleanType>(
65    flag_ ? MagickTrue : MagickFalse);
66}
67
68bool Magick::Options::antiAlias(void) const
69{
70  return(static_cast<bool>(_drawInfo->text_antialias));
71}
72
73void Magick::Options::adjoin(bool flag_)
74{
75  _imageInfo->adjoin=static_cast<MagickBooleanType>(
76    flag_ ? MagickTrue : MagickFalse);
77}
78
79bool Magick::Options::adjoin(void) const
80{
81  return(static_cast<bool>(_imageInfo->adjoin));
82}
83
84void Magick::Options::backgroundColor(const Magick::Color &color_)
85{
86  _imageInfo->background_color=color_;
87}
88
89Magick::Color Magick::Options::backgroundColor(void) const
90{
91  return(Magick::Color(_imageInfo->background_color));
92}
93
94void 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
102std::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
110void Magick::Options::borderColor(const Color &color_)
111{
112  _imageInfo->border_color=color_;
113  _drawInfo->border_color=color_;
114}
115
116Magick::Color Magick::Options::borderColor(void) const
117{
118  return(Magick::Color(_imageInfo->border_color));
119}
120
121void Magick::Options::boxColor(const Magick::Color &boxColor_)
122{
123  _drawInfo->undercolor=boxColor_;
124}
125
126Magick::Color Magick::Options::boxColor(void) const
127{
128  return(Magick::Color(_drawInfo->undercolor));
129}
130
131void Magick::Options::colorspaceType(Magick::ColorspaceType colorspace_)
132{
133  _imageInfo->colorspace=colorspace_;
134}
135
136Magick::ColorspaceType Magick::Options::colorspaceType(void) const
137{
138  return(static_cast<Magick::ColorspaceType>(_imageInfo->colorspace));
139}
140
141void Magick::Options::compressType(CompressionType compressType_)
142{
143  _imageInfo->compression=compressType_;
144}
145
146Magick::CompressionType Magick::Options::compressType(void) const
147{
148  return(static_cast<Magick::CompressionType>(_imageInfo->compression));
149}
150
151void Magick::Options::colorFuzz(double fuzz_)
152{
153  _imageInfo->fuzz=fuzz_;
154}
155
156double Magick::Options::colorFuzz(void) const
157{
158  return(_imageInfo->fuzz);
159}
160
161void Magick::Options::debug(bool flag_)
162{
163  if  (flag_)
164    SetLogEventMask("All");
165  else
166    SetLogEventMask("None");
167}
168
169bool Magick::Options::debug(void) const
170{
171  if (IsEventLogging())
172    return(true);
173  return(false);
174}
175
176void 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
184Magick::Geometry Magick::Options::density(void) const
185{
186  if (_imageInfo->density)
187    return(Geometry(_imageInfo->density));
188
189  return(Geometry());
190}
191
192void Magick::Options::depth(size_t depth_)
193{
194  _imageInfo->depth=depth_;
195}
196
197size_t Magick::Options::depth(void) const
198{
199  return(_imageInfo->depth);
200}
201
202void Magick::Options::endian(Magick::EndianType endian_)
203{
204  _imageInfo->endian=endian_;
205}
206
207Magick::EndianType Magick::Options::endian(void) const
208{
209  return(_imageInfo->endian);
210}
211
212void Magick::Options::file(FILE *file_)
213{
214  SetImageInfoFile(_imageInfo,file_);
215}
216
217FILE *Magick::Options::file(void) const
218{
219  return(GetImageInfoFile(_imageInfo));
220}
221
222void 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
231std::string Magick::Options::fileName(void) const
232{
233  return(std::string(_imageInfo->filename));
234}
235
236void 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
243Magick::Color Magick::Options::fillColor(void) const
244{
245  return(_drawInfo->fill);
246}
247
248void 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
263const MagickCore::Image *Magick::Options::fillPattern(void) const
264{
265  return(_drawInfo->fill_pattern);
266}
267
268void Magick::Options::fillRule(const Magick::FillRule &fillRule_)
269{
270  _drawInfo->fill_rule=fillRule_;
271}
272
273Magick::FillRule Magick::Options::fillRule(void) const
274{
275  return(_drawInfo->fill_rule);
276}
277
278void 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
292std::string Magick::Options::font(void) const
293{
294  if (_imageInfo->font)
295    return(std::string(_imageInfo->font));
296
297  return(std::string());
298}
299
300void Magick::Options::fontPointsize(double pointSize_)
301{
302  _imageInfo->pointsize=pointSize_;
303  _drawInfo->pointsize=pointSize_;
304}
305
306double Magick::Options::fontPointsize(void) const
307{
308  return(_imageInfo->pointsize);
309}
310
311std::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
327void Magick::Options::interlaceType(Magick::InterlaceType interlace_)
328{
329  _imageInfo->interlace=interlace_;
330}
331
332Magick::InterlaceType Magick::Options::interlaceType(void) const
333{
334  return(static_cast<Magick::InterlaceType>(_imageInfo->interlace));
335}
336
337void 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
349std::string Magick::Options::magick(void) const
350{
351  if (*_imageInfo->magick)
352    return(std::string(_imageInfo->magick));
353
354  return(std::string());
355}
356
357void Magick::Options::matteColor(const Magick::Color &matteColor_)
358{
359  _imageInfo->matte_color=matteColor_;
360}
361
362Magick::Color Magick::Options::matteColor(void) const
363{
364  return(Magick::Color(_imageInfo->matte_color));
365}
366
367void Magick::Options::monochrome(bool monochromeFlag_)
368{
369  _imageInfo->monochrome=(MagickBooleanType) monochromeFlag_;
370}
371
372bool Magick::Options::monochrome(void) const
373{
374  return(static_cast<bool>(_imageInfo->monochrome));
375}
376
377void 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
385Magick::Geometry Magick::Options::page(void) const
386{
387  if (_imageInfo->page)
388    return(Geometry(_imageInfo->page));
389
390  return(Geometry());
391}
392
393void Magick::Options::quality(size_t quality_)
394{
395  _imageInfo->quality=quality_;
396}
397
398size_t Magick::Options::quality(void) const
399{
400  return(_imageInfo->quality);
401}
402
403void Magick::Options::quantizeColors(size_t colors_)
404{
405  _quantizeInfo->number_colors=colors_;
406}
407
408size_t Magick::Options::quantizeColors(void) const
409{
410  return(_quantizeInfo->number_colors);
411}
412
413void Magick::Options::quantizeColorSpace(Magick::ColorspaceType colorSpace_)
414{
415  _quantizeInfo->colorspace=colorSpace_;
416}
417
418Magick::ColorspaceType Magick::Options::quantizeColorSpace(void) const
419{
420  return(static_cast<Magick::ColorspaceType>(_quantizeInfo->colorspace));
421}
422
423void Magick::Options::quantizeDither(bool ditherFlag_)
424{
425  _imageInfo->dither=(MagickBooleanType) ditherFlag_;
426  _quantizeInfo->dither_method=ditherFlag_ ? RiemersmaDitherMethod :
427    NoDitherMethod;
428}
429
430bool Magick::Options::quantizeDither(void) const
431{
432  return(static_cast<bool>(_imageInfo->dither));
433}
434
435void Magick::Options::quantizeDitherMethod(DitherMethod ditherMethod_)
436{
437  _quantizeInfo->dither_method=ditherMethod_;
438}
439
440MagickCore::DitherMethod Magick::Options::quantizeDitherMethod(void) const
441{
442  return(_quantizeInfo->dither_method);
443}
444
445void Magick::Options::quantizeTreeDepth(size_t treeDepth_)
446{
447  _quantizeInfo->tree_depth=treeDepth_;
448}
449
450size_t Magick::Options::quantizeTreeDepth(void) const
451{
452  return(_quantizeInfo->tree_depth);
453}
454
455void Magick::Options::resolutionUnits(Magick::ResolutionType resolutionUnits_)
456{
457  _imageInfo->units=resolutionUnits_;
458}
459
460Magick::ResolutionType Magick::Options::resolutionUnits(void) const
461{
462  return(static_cast<Magick::ResolutionType>(_imageInfo->units));
463}
464
465void 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
474std::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
482void 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
490Magick::Geometry Magick::Options::size(void) const
491{
492  if (_imageInfo->size)
493    return(Geometry(_imageInfo->size));
494
495  return(Geometry());
496}
497
498void Magick::Options::strokeAntiAlias(bool flag_)
499{
500  flag_ ? _drawInfo->stroke_antialias=MagickTrue :
501    _drawInfo->stroke_antialias=MagickFalse;
502}
503
504bool Magick::Options::strokeAntiAlias(void) const
505{
506  return(_drawInfo->stroke_antialias != 0 ? true : false);
507}
508
509void Magick::Options::strokeColor(const Magick::Color &strokeColor_)
510{
511  _drawInfo->stroke=strokeColor_;
512}
513
514Magick::Color Magick::Options::strokeColor(void) const
515{
516  return(_drawInfo->stroke);
517}
518
519void 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
538const double *Magick::Options::strokeDashArray(void) const
539{
540  return(_drawInfo->dash_pattern);
541}
542
543void Magick::Options::strokeDashOffset(double strokeDashOffset_)
544{
545  _drawInfo->dash_offset=strokeDashOffset_;
546}
547
548double Magick::Options::strokeDashOffset(void) const
549{
550  return(_drawInfo->dash_offset);
551}
552
553void Magick::Options::strokeLineCap(Magick::LineCap lineCap_)
554{
555  _drawInfo->linecap=lineCap_;
556}
557
558Magick::LineCap Magick::Options::strokeLineCap(void) const
559{
560  return(_drawInfo->linecap);
561}
562
563void Magick::Options::strokeLineJoin(Magick::LineJoin lineJoin_)
564{
565  _drawInfo->linejoin=lineJoin_;
566}
567
568Magick::LineJoin Magick::Options::strokeLineJoin(void) const
569{
570  return(_drawInfo->linejoin);
571}
572
573void Magick::Options::strokeMiterLimit(size_t miterLimit_)
574{
575  _drawInfo->miterlimit=miterLimit_;
576}
577
578size_t Magick::Options::strokeMiterLimit(void) const
579{
580  return(_drawInfo->miterlimit);
581}
582
583void 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
597const MagickCore::Image *Magick::Options::strokePattern(void) const
598{
599  return(_drawInfo->stroke_pattern);
600}
601
602void Magick::Options::strokeWidth(double strokeWidth_)
603{
604  _drawInfo->stroke_width=strokeWidth_;
605}
606
607double Magick::Options::strokeWidth(void) const
608{
609  return(_drawInfo->stroke_width);
610}
611
612void Magick::Options::subImage(size_t subImage_)
613{
614  _imageInfo->scene=subImage_;
615}
616
617size_t Magick::Options::subImage(void) const
618{
619  return(_imageInfo->scene);
620}
621
622void Magick::Options::subRange(size_t subRange_)
623{
624  _imageInfo->number_scenes=subRange_;
625}
626
627size_t Magick::Options::subRange(void) const
628{
629  return(_imageInfo->number_scenes);
630}
631
632void Magick::Options::textDirection(DirectionType direction_)
633{
634  _drawInfo->direction=direction_;
635}
636
637Magick::DirectionType Magick::Options::textDirection() const
638{
639  return(_drawInfo->direction);
640}
641
642void Magick::Options::textEncoding(const std::string &encoding_)
643{
644  CloneString(&_drawInfo->encoding,encoding_.c_str());
645}
646
647std::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
655void Magick::Options::textGravity(GravityType gravity_)
656{
657  _drawInfo->gravity=gravity_;
658}
659
660Magick::GravityType Magick::Options::textGravity() const
661{
662  return(_drawInfo->gravity);
663}
664
665void Magick::Options::textInterlineSpacing(double spacing_)
666{
667  _drawInfo->interline_spacing=spacing_;
668}
669
670double Magick::Options::textInterlineSpacing(void) const
671{
672  return(_drawInfo->interline_spacing);
673}
674
675void Magick::Options::textInterwordSpacing(double spacing_)
676{
677  _drawInfo->interword_spacing=spacing_;
678}
679
680double Magick::Options::textInterwordSpacing(void) const
681{
682  return(_drawInfo->interword_spacing);
683}
684
685void Magick::Options::textKerning(double kerning_)
686{
687  _drawInfo->kerning=kerning_;
688}
689
690double Magick::Options::textKerning(void) const
691{
692  return(_drawInfo->kerning);
693}
694
695void 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
719void 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
729void 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
755void 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
779void 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
804void 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
829void Magick::Options::type(const Magick::ImageType type_)
830{
831  _imageInfo->type=type_;
832}
833
834Magick::ImageType Magick::Options::type(void) const
835{
836  return(_imageInfo->type);
837}
838
839void Magick::Options::verbose(bool verboseFlag_)
840{
841  _imageInfo->verbose=(MagickBooleanType) verboseFlag_;
842}
843
844bool Magick::Options::verbose(void) const
845{
846  return(static_cast<bool>(_imageInfo->verbose));
847}
848
849void 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
857std::string Magick::Options::view(void) const
858{
859  if (_imageInfo->view)
860    return(std::string(_imageInfo->view));
861
862  return(std::string());
863}
864
865void 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
874std::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
882MagickCore::DrawInfo *Magick::Options::drawInfo(void)
883{
884  return(_drawInfo);
885}
886
887MagickCore::ImageInfo *Magick::Options::imageInfo(void)
888{
889  return(_imageInfo);
890}
891
892MagickCore::QuantizeInfo *Magick::Options::quantizeInfo(void)
893{
894  return(_quantizeInfo);
895}
896
897Magick::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}
908