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