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