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