granicus.if.org Git - imagemagick/blob - MagickCore/annotate.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %           AAA   N   N  N   N   OOO   TTTTT   AAA   TTTTT  EEEEE             %
   7 %          A   A  NN  N  NN  N  O   O    T    A   A    T    E                 %
   8 %          AAAAA  N N N  N N N  O   O    T    AAAAA    T    EEE               %
   9 %          A   A  N  NN  N  NN  O   O    T    A   A    T    E                 %
  10 %          A   A  N   N  N   N   OOO     T    A   A    T    EEEEE             %
  11 %                                                                             %
  12 %                                                                             %
  13 %                   MagickCore Image Annotation Methods                       %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 % Digital Applications (www.digapp.com) contributed the stroked text algorithm.
  37 % It was written by Leonard Rosenthol.
  38 %
  39 %
  40 */
  41 \f
  42 /*
  43   Include declarations.
  44 */
  45 #include "MagickCore/studio.h"
  46 #include "MagickCore/annotate.h"
  47 #include "MagickCore/annotate-private.h"
  48 #include "MagickCore/attribute.h"
  49 #include "MagickCore/cache-view.h"
  50 #include "MagickCore/channel.h"
  51 #include "MagickCore/client.h"
  52 #include "MagickCore/color.h"
  53 #include "MagickCore/color-private.h"
  54 #include "MagickCore/colorspace-private.h"
  55 #include "MagickCore/composite.h"
  56 #include "MagickCore/composite-private.h"
  57 #include "MagickCore/constitute.h"
  58 #include "MagickCore/draw.h"
  59 #include "MagickCore/draw-private.h"
  60 #include "MagickCore/enhance.h"
  61 #include "MagickCore/exception.h"
  62 #include "MagickCore/exception-private.h"
  63 #include "MagickCore/gem.h"
  64 #include "MagickCore/geometry.h"
  65 #include "MagickCore/image-private.h"
  66 #include "MagickCore/log.h"
  67 #include "MagickCore/quantum.h"
  68 #include "MagickCore/quantum-private.h"
  69 #include "MagickCore/pixel-accessor.h"
  70 #include "MagickCore/property.h"
  71 #include "MagickCore/resource_.h"
  72 #include "MagickCore/semaphore.h"
  73 #include "MagickCore/statistic.h"
  74 #include "MagickCore/string_.h"
  75 #include "MagickCore/token-private.h"
  76 #include "MagickCore/transform.h"
  77 #include "MagickCore/type.h"
  78 #include "MagickCore/utility.h"
  79 #include "MagickCore/utility-private.h"
  80 #include "MagickCore/xwindow.h"
  81 #include "MagickCore/xwindow-private.h"
  82 #if defined(MAGICKCORE_FREETYPE_DELEGATE)
  83 #if defined(__MINGW32__) || defined(__MINGW64__)
  84 #  undef interface
  85 #endif
  86 #include <ft2build.h>
  87 #if defined(FT_FREETYPE_H)
  88 #  include FT_FREETYPE_H
  89 #else
  90 #  include <freetype/freetype.h>
  91 #endif
  92 #if defined(FT_GLYPH_H)
  93 #  include FT_GLYPH_H
  94 #else
  95 #  include <freetype/ftglyph.h>
  96 #endif
  97 #if defined(FT_OUTLINE_H)
  98 #  include FT_OUTLINE_H
  99 #else
 100 #  include <freetype/ftoutln.h>
 101 #endif
 102 #if defined(FT_BBOX_H)
 103 #  include FT_BBOX_H
 104 #else
 105 #  include <freetype/ftbbox.h>
 106 #endif /* defined(FT_BBOX_H) */
 107 #endif
 108 \f
 109 /*
 110   Annotate semaphores.
 111 */
 112 static SemaphoreInfo
 113   *annotate_semaphore = (SemaphoreInfo *) NULL;
 114 \f
 115 /*
 116   Forward declarations.
 117 */
 118 static MagickBooleanType
 119   RenderType(Image *,const DrawInfo *,const PointInfo *,TypeMetric *,
 120     ExceptionInfo *),
 121   RenderPostscript(Image *,const DrawInfo *,const PointInfo *,TypeMetric *,
 122     ExceptionInfo *),
 123   RenderFreetype(Image *,const DrawInfo *,const char *,const PointInfo *,
 124     TypeMetric *,ExceptionInfo *),
 125   RenderX11(Image *,const DrawInfo *,const PointInfo *,TypeMetric *,
 126     ExceptionInfo *);
 127 \f
 128 /*
 129 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 130 %                                                                             %
 131 %                                                                             %
 132 %                                                                             %
 133 +   A n n o t a t e C o m p o n e n t G e n e s i s                           %
 134 %                                                                             %
 135 %                                                                             %
 136 %                                                                             %
 137 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 138 %
 139 %  AnnotateComponentGenesis() instantiates the annotate component.
 140 %
 141 %  The format of the AnnotateComponentGenesis method is:
 142 %
 143 %      MagickBooleanType AnnotateComponentGenesis(void)
 144 %
 145 */
 146 MagickPrivate MagickBooleanType AnnotateComponentGenesis(void)
 147 {
 148   AcquireSemaphoreInfo(&annotate_semaphore);
 149   return(MagickTrue);
 150 }
 151 \f
 152 /*
 153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 154 %                                                                             %
 155 %                                                                             %
 156 %                                                                             %
 157 +   A n n o t a t e C o m p o n e n t T e r m i n u s                         %
 158 %                                                                             %
 159 %                                                                             %
 160 %                                                                             %
 161 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 162 %
 163 %  AnnotateComponentTerminus() destroys the annotate component.
 164 %
 165 %  The format of the AnnotateComponentTerminus method is:
 166 %
 167 %      AnnotateComponentTerminus(void)
 168 %
 169 */
 170 MagickPrivate void AnnotateComponentTerminus(void)
 171 {
 172   if (annotate_semaphore == (SemaphoreInfo *) NULL)
 173     AcquireSemaphoreInfo(&annotate_semaphore);
 174   DestroySemaphoreInfo(&annotate_semaphore);
 175 }
 176 \f
 177 /*
 178 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 179 %                                                                             %
 180 %                                                                             %
 181 %                                                                             %
 182 %   A n n o t a t e I m a g e                                                 %
 183 %                                                                             %
 184 %                                                                             %
 185 %                                                                             %
 186 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 187 %
 188 %  AnnotateImage() annotates an image with text.  Optionally you can include
 189 %  any of the following bits of information about the image by embedding
 190 %  the appropriate special characters:
 191 %
 192 %    %b   file size in bytes.
 193 %    %c   comment.
 194 %    %d   directory in which the image resides.
 195 %    %e   extension of the image file.
 196 %    %f   original filename of the image.
 197 %    %h   height of image.
 198 %    %i   filename of the image.
 199 %    %k   number of unique colors.
 200 %    %l   image label.
 201 %    %m   image file format.
 202 %    %n   number of images in a image sequence.
 203 %    %o   output image filename.
 204 %    %p   page number of the image.
 205 %    %q   image depth (8 or 16).
 206 %    %q   image depth (8 or 16).
 207 %    %s   image scene number.
 208 %    %t   image filename without any extension.
 209 %    %u   a unique temporary filename.
 210 %    %w   image width.
 211 %    %x   x resolution of the image.
 212 %    %y   y resolution of the image.
 213 %
 214 %  The format of the AnnotateImage method is:
 215 %
 216 %      MagickBooleanType AnnotateImage(Image *image,DrawInfo *draw_info,
 217 %        ExceptionInfo *exception)
 218 %
 219 %  A description of each parameter follows:
 220 %
 221 %    o image: the image.
 222 %
 223 %    o draw_info: the draw info.
 224 %
 225 %    o exception: return any errors or warnings in this structure.
 226 %
 227 */
 228 MagickExport MagickBooleanType AnnotateImage(Image *image,
 229   const DrawInfo *draw_info,ExceptionInfo *exception)
 230 {
 231   char
 232     primitive[MaxTextExtent],
 233     **textlist;
 234
 235   DrawInfo
 236     *annotate,
 237     *annotate_info;
 238
 239   GeometryInfo
 240     geometry_info;
 241
 242   MagickBooleanType
 243     status;
 244
 245   PointInfo
 246     offset;
 247
 248   RectangleInfo
 249     geometry;
 250
 251   register ssize_t
 252     i;
 253
 254   size_t
 255     length;
 256
 257   TypeMetric
 258     metrics;
 259
 260   size_t
 261     height,
 262     number_lines;
 263
 264   assert(image != (Image *) NULL);
 265   assert(image->signature == MagickSignature);
 266   if (image->debug != MagickFalse)
 267     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 268   assert(draw_info != (DrawInfo *) NULL);
 269   assert(draw_info->signature == MagickSignature);
 270   if (draw_info->text == (char *) NULL)
 271     return(MagickFalse);
 272   if (*draw_info->text == '\0')
 273     return(MagickTrue);
 274   textlist=StringToList(draw_info->text);
 275   if (textlist == (char **) NULL)
 276     return(MagickFalse);
 277   length=strlen(textlist[0]);
 278   for (i=1; textlist[i] != (char *) NULL; i++)
 279     if (strlen(textlist[i]) > length)
 280       length=strlen(textlist[i]);
 281   number_lines=(size_t) i;
 282   annotate=CloneDrawInfo((ImageInfo *) NULL,draw_info);
 283   annotate_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
 284   SetGeometry(image,&geometry);
 285   SetGeometryInfo(&geometry_info);
 286   if (annotate_info->geometry != (char *) NULL)
 287     {
 288       (void) ParsePageGeometry(image,annotate_info->geometry,&geometry,
 289         exception);
 290       (void) ParseGeometry(annotate_info->geometry,&geometry_info);
 291     }
 292   if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 293     return(MagickFalse);
 294   if (IsGrayColorspace(image->colorspace) != MagickFalse)
 295     (void) SetImageColorspace(image,sRGBColorspace,exception);
 296   status=MagickTrue;
 297   for (i=0; textlist[i] != (char *) NULL; i++)
 298   {
 299     /*
 300       Position text relative to image.
 301     */
 302     annotate_info->affine.tx=geometry_info.xi-image->page.x;
 303     annotate_info->affine.ty=geometry_info.psi-image->page.y;
 304     (void) CloneString(&annotate->text,textlist[i]);
 305     (void) GetTypeMetrics(image,annotate,&metrics,exception);
 306     height=(ssize_t) (metrics.ascent-metrics.descent+
 307       draw_info->interline_spacing+0.5);
 308     switch (annotate->gravity)
 309     {
 310       case UndefinedGravity:
 311       default:
 312       {
 313         offset.x=annotate_info->affine.tx+i*annotate_info->affine.ry*height;
 314         offset.y=annotate_info->affine.ty+i*annotate_info->affine.sy*height;
 315         break;
 316       }
 317       case NorthWestGravity:
 318       {
 319         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+i*
 320           annotate_info->affine.ry*height+annotate_info->affine.ry*
 321           (metrics.ascent+metrics.descent);
 322         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+i*
 323           annotate_info->affine.sy*height+annotate_info->affine.sy*
 324           metrics.ascent;
 325         break;
 326       }
 327       case NorthGravity:
 328       {
 329         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+
 330           geometry.width/2.0+i*annotate_info->affine.ry*height-
 331           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)/2.0+
 332           annotate_info->affine.ry*(metrics.ascent+metrics.descent);
 333         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+i*
 334           annotate_info->affine.sy*height+annotate_info->affine.sy*
 335           metrics.ascent-annotate_info->affine.rx*(metrics.width-
 336           metrics.bounds.x1)/2.0;
 337         break;
 338       }
 339       case NorthEastGravity:
 340       {
 341         offset.x=(geometry.width == 0 ? 1.0 : -1.0)*annotate_info->affine.tx+
 342           geometry.width+i*annotate_info->affine.ry*height-
 343           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)+
 344           annotate_info->affine.ry*(metrics.ascent+metrics.descent)-1.0;
 345         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+i*
 346           annotate_info->affine.sy*height+annotate_info->affine.sy*
 347           metrics.ascent-annotate_info->affine.rx*(metrics.width-
 348           metrics.bounds.x1);
 349         break;
 350       }
 351       case WestGravity:
 352       {
 353         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+i*
 354           annotate_info->affine.ry*height+annotate_info->affine.ry*
 355           (metrics.ascent+metrics.descent-(number_lines-1.0)*height)/2.0;
 356         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+
 357           geometry.height/2.0+i*annotate_info->affine.sy*height+
 358           annotate_info->affine.sy*(metrics.ascent+metrics.descent-
 359           (number_lines-1.0)*height)/2.0;
 360         break;
 361       }
 362       case CenterGravity:
 363       {
 364         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+
 365           geometry.width/2.0+i*annotate_info->affine.ry*height-
 366           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)/2.0+
 367           annotate_info->affine.ry*(metrics.ascent+metrics.descent-
 368           (number_lines-1)*height)/2.0;
 369         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+
 370           geometry.height/2.0+i*annotate_info->affine.sy*height-
 371           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1)/2.0+
 372           annotate_info->affine.sy*(metrics.ascent+metrics.descent-
 373           (number_lines-1.0)*height)/2.0;
 374         break;
 375       }
 376       case EastGravity:
 377       {
 378         offset.x=(geometry.width == 0 ? 1.0 : -1.0)*annotate_info->affine.tx+
 379           geometry.width+i*annotate_info->affine.ry*height-
 380           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)+
 381           annotate_info->affine.ry*(metrics.ascent+metrics.descent-
 382           (number_lines-1.0)*height)/2.0-1.0;
 383         offset.y=(geometry.height == 0 ? -1.0 : 1.0)*annotate_info->affine.ty+
 384           geometry.height/2.0+i*annotate_info->affine.sy*height-
 385           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1)+
 386           annotate_info->affine.sy*(metrics.ascent+metrics.descent-
 387           (number_lines-1.0)*height)/2.0;
 388         break;
 389       }
 390       case SouthWestGravity:
 391       {
 392         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+i*
 393           annotate_info->affine.ry*height-annotate_info->affine.ry*
 394           (number_lines-1.0)*height;
 395         offset.y=(geometry.height == 0 ? 1.0 : -1.0)*annotate_info->affine.ty+
 396           geometry.height+i*annotate_info->affine.sy*height-
 397           annotate_info->affine.sy*(number_lines-1.0)*height+metrics.descent;
 398         break;
 399       }
 400       case SouthGravity:
 401       {
 402         offset.x=(geometry.width == 0 ? -1.0 : 1.0)*annotate_info->affine.tx+
 403           geometry.width/2.0+i*annotate_info->affine.ry*height-
 404           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)/2.0-
 405           annotate_info->affine.ry*(number_lines-1.0)*height/2.0;
 406         offset.y=(geometry.height == 0 ? 1.0 : -1.0)*annotate_info->affine.ty+
 407           geometry.height+i*annotate_info->affine.sy*height-
 408           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1)/2.0-
 409           annotate_info->affine.sy*(number_lines-1.0)*height+metrics.descent;
 410         break;
 411       }
 412       case SouthEastGravity:
 413       {
 414         offset.x=(geometry.width == 0 ? 1.0 : -1.0)*annotate_info->affine.tx+
 415           geometry.width+i*annotate_info->affine.ry*height-
 416           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)-
 417           annotate_info->affine.ry*(number_lines-1.0)*height-1.0;
 418         offset.y=(geometry.height == 0 ? 1.0 : -1.0)*annotate_info->affine.ty+
 419           geometry.height+i*annotate_info->affine.sy*height-
 420           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1)-
 421           annotate_info->affine.sy*(number_lines-1.0)*height+metrics.descent;
 422         break;
 423       }
 424     }
 425     switch (annotate->align)
 426     {
 427       case LeftAlign:
 428       {
 429         offset.x=annotate_info->affine.tx+i*annotate_info->affine.ry*height;
 430         offset.y=annotate_info->affine.ty+i*annotate_info->affine.sy*height;
 431         break;
 432       }
 433       case CenterAlign:
 434       {
 435         offset.x=annotate_info->affine.tx+i*annotate_info->affine.ry*height-
 436           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1)/2.0;
 437         offset.y=annotate_info->affine.ty+i*annotate_info->affine.sy*height-
 438           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1)/2.0;
 439         break;
 440       }
 441       case RightAlign:
 442       {
 443         offset.x=annotate_info->affine.tx+i*annotate_info->affine.ry*height-
 444           annotate_info->affine.sx*(metrics.width+metrics.bounds.x1);
 445         offset.y=annotate_info->affine.ty+i*annotate_info->affine.sy*height-
 446           annotate_info->affine.rx*(metrics.width+metrics.bounds.x1);
 447         break;
 448       }
 449       default:
 450         break;
 451     }
 452     if (draw_info->undercolor.alpha != TransparentAlpha)
 453       {
 454         DrawInfo
 455           *undercolor_info;
 456
 457         /*
 458           Text box.
 459         */
 460         undercolor_info=CloneDrawInfo((ImageInfo *) NULL,(DrawInfo *) NULL);
 461         undercolor_info->fill=draw_info->undercolor;
 462         undercolor_info->affine=draw_info->affine;
 463         undercolor_info->affine.tx=offset.x-draw_info->affine.ry*metrics.ascent;
 464         undercolor_info->affine.ty=offset.y-draw_info->affine.sy*metrics.ascent;
 465         (void) FormatLocaleString(primitive,MaxTextExtent,
 466           "rectangle 0,0 %g,%.20g",metrics.origin.x,(double) height);
 467         (void) CloneString(&undercolor_info->primitive,primitive);
 468         (void) DrawImage(image,undercolor_info,exception);
 469         (void) DestroyDrawInfo(undercolor_info);
 470       }
 471     annotate_info->affine.tx=offset.x;
 472     annotate_info->affine.ty=offset.y;
 473     (void) FormatLocaleString(primitive,MaxTextExtent,"stroke-width %g "
 474       "line 0,0 %g,0",metrics.underline_thickness,metrics.width);
 475     if (annotate->decorate == OverlineDecoration)
 476       {
 477         annotate_info->affine.ty-=(draw_info->affine.sy*(metrics.ascent+
 478           metrics.descent-metrics.underline_position));
 479         (void) CloneString(&annotate_info->primitive,primitive);
 480         (void) DrawImage(image,annotate_info,exception);
 481       }
 482     else
 483       if (annotate->decorate == UnderlineDecoration)
 484         {
 485           annotate_info->affine.ty-=(draw_info->affine.sy*
 486             metrics.underline_position);
 487           (void) CloneString(&annotate_info->primitive,primitive);
 488           (void) DrawImage(image,annotate_info,exception);
 489         }
 490     /*
 491       Annotate image with text.
 492     */
 493     status=RenderType(image,annotate,&offset,&metrics,exception);
 494     if (status == MagickFalse)
 495       break;
 496     if (annotate->decorate == LineThroughDecoration)
 497       {
 498         annotate_info->affine.ty-=(draw_info->affine.sy*(height+
 499           metrics.underline_position+metrics.descent)/2.0);
 500         (void) CloneString(&annotate_info->primitive,primitive);
 501         (void) DrawImage(image,annotate_info,exception);
 502       }
 503   }
 504   /*
 505     Relinquish resources.
 506   */
 507   annotate_info=DestroyDrawInfo(annotate_info);
 508   annotate=DestroyDrawInfo(annotate);
 509   for (i=0; textlist[i] != (char *) NULL; i++)
 510     textlist[i]=DestroyString(textlist[i]);
 511   textlist=(char **) RelinquishMagickMemory(textlist);
 512   return(status);
 513 }
 514 \f
 515 /*
 516 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 517 %                                                                             %
 518 %                                                                             %
 519 %                                                                             %
 520 %  F o r m a t M a g i c k C a p t i o n                                      %
 521 %                                                                             %
 522 %                                                                             %
 523 %                                                                             %
 524 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 525 %
 526 %  FormatMagickCaption() formats a caption so that it fits within the image
 527 %  width.  It returns the number of lines in the formatted caption.
 528 %
 529 %  The format of the FormatMagickCaption method is:
 530 %
 531 %      ssize_t FormatMagickCaption(Image *image,DrawInfo *draw_info,
 532 %        const MagickBooleanType split,TypeMetric *metrics,char **caption,
 533 %        ExceptionInfo *exception)
 534 %
 535 %  A description of each parameter follows.
 536 %
 537 %    o image:  The image.
 538 %
 539 %    o draw_info: the draw info.
 540 %
 541 %    o split: when no convenient line breaks-- insert newline.
 542 %
 543 %    o metrics: Return the font metrics in this structure.
 544 %
 545 %    o caption: the caption.
 546 %
 547 %    o exception: return any errors or warnings in this structure.
 548 %
 549 */
 550 MagickExport ssize_t FormatMagickCaption(Image *image,DrawInfo *draw_info,
 551   const MagickBooleanType split,TypeMetric *metrics,char **caption,
 552   ExceptionInfo *exception)
 553 {
 554   char
 555     *text;
 556
 557   MagickBooleanType
 558     status;
 559
 560   register char
 561     *p,
 562     *q,
 563     *s;
 564
 565   register ssize_t
 566     i;
 567
 568   size_t
 569     width;
 570
 571   ssize_t
 572     n;
 573
 574   text=AcquireString(draw_info->text);
 575   q=draw_info->text;
 576   s=(char *) NULL;
 577   for (p=(*caption); GetUTFCode(p) != 0; p+=GetUTFOctets(p))
 578   {
 579     if (IsUTFSpace(GetUTFCode(p)) != MagickFalse)
 580       s=p;
 581     if (GetUTFCode(p) == '\n')
 582       q=draw_info->text;
 583     for (i=0; i < (ssize_t) GetUTFOctets(p); i++)
 584       *q++=(*(p+i));
 585     *q='\0';
 586     status=GetTypeMetrics(image,draw_info,metrics,exception);
 587     if (status == MagickFalse)
 588       break;
 589     width=(size_t) floor(metrics->width+metrics->max_advance/2.0+0.5);
 590     if ((width <= image->columns) || (strcmp(text,draw_info->text) == 0))
 591       continue;
 592     (void) strcpy(text,draw_info->text);
 593     if ((s != (char *) NULL) && (GetUTFOctets(s) == 1))
 594       {
 595         *s='\n';
 596         p=s;
 597       }
 598     else
 599       if ((s != (char *) NULL) || (split != MagickFalse))
 600         {
 601           char
 602             *target;
 603
 604           /*
 605             No convenient line breaks-- insert newline.
 606           */
 607           target=AcquireString(*caption);
 608           n=p-(*caption);
 609           CopyMagickString(target,*caption,n+1);
 610           ConcatenateMagickString(target,"\n",strlen(*caption)+1);
 611           ConcatenateMagickString(target,p,strlen(*caption)+2);
 612           (void) DestroyString(*caption);
 613           *caption=target;
 614           p=(*caption)+n;
 615         }
 616     q=draw_info->text;
 617     s=(char *) NULL;
 618   }
 619   text=DestroyString(text);
 620   n=0;
 621   for (p=(*caption); GetUTFCode(p) != 0; p+=GetUTFOctets(p))
 622     if (GetUTFCode(p) == '\n')
 623       n++;
 624   return(n);
 625 }
 626 \f
 627 /*
 628 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 629 %                                                                             %
 630 %                                                                             %
 631 %                                                                             %
 632 %   G e t M u l t i l i n e T y p e M e t r i c s                             %
 633 %                                                                             %
 634 %                                                                             %
 635 %                                                                             %
 636 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 637 %
 638 %  GetMultilineTypeMetrics() returns the following information for the
 639 %  specified font and text:
 640 %
 641 %    character width
 642 %    character height
 643 %    ascender
 644 %    descender
 645 %    text width
 646 %    text height
 647 %    maximum horizontal advance
 648 %    bounds: x1
 649 %    bounds: y1
 650 %    bounds: x2
 651 %    bounds: y2
 652 %    origin: x
 653 %    origin: y
 654 %    underline position
 655 %    underline thickness
 656 %
 657 %  This method is like GetTypeMetrics() but it returns the maximum text width
 658 %  and height for multiple lines of text.
 659 %
 660 %  The format of the GetMultilineTypeMetrics method is:
 661 %
 662 %      MagickBooleanType GetMultilineTypeMetrics(Image *image,
 663 %        const DrawInfo *draw_info,TypeMetric *metrics,ExceptionInfo *exception)
 664 %
 665 %  A description of each parameter follows:
 666 %
 667 %    o image: the image.
 668 %
 669 %    o draw_info: the draw info.
 670 %
 671 %    o metrics: Return the font metrics in this structure.
 672 %
 673 %    o exception: return any errors or warnings in this structure.
 674 %
 675 */
 676 MagickExport MagickBooleanType GetMultilineTypeMetrics(Image *image,
 677   const DrawInfo *draw_info,TypeMetric *metrics,ExceptionInfo *exception)
 678 {
 679   char
 680     **textlist;
 681
 682   DrawInfo
 683     *annotate_info;
 684
 685   MagickBooleanType
 686     status;
 687
 688   register ssize_t
 689     i;
 690
 691   TypeMetric
 692     extent;
 693
 694   assert(image != (Image *) NULL);
 695   assert(image->signature == MagickSignature);
 696   if (image->debug != MagickFalse)
 697     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 698   assert(draw_info != (DrawInfo *) NULL);
 699   assert(draw_info->text != (char *) NULL);
 700   assert(draw_info->signature == MagickSignature);
 701   if (*draw_info->text == '\0')
 702     return(MagickFalse);
 703   annotate_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
 704   annotate_info->text=DestroyString(annotate_info->text);
 705   /*
 706     Convert newlines to multiple lines of text.
 707   */
 708   textlist=StringToList(draw_info->text);
 709   if (textlist == (char **) NULL)
 710     return(MagickFalse);
 711   annotate_info->render=MagickFalse;
 712   annotate_info->direction=UndefinedDirection;
 713   (void) ResetMagickMemory(metrics,0,sizeof(*metrics));
 714   (void) ResetMagickMemory(&extent,0,sizeof(extent));
 715   /*
 716     Find the widest of the text lines.
 717   */
 718   annotate_info->text=textlist[0];
 719   status=GetTypeMetrics(image,annotate_info,&extent,exception);
 720   *metrics=extent;
 721   for (i=1; textlist[i] != (char *) NULL; i++)
 722   {
 723     annotate_info->text=textlist[i];
 724     status=GetTypeMetrics(image,annotate_info,&extent,exception);
 725     if (extent.width > metrics->width)
 726       *metrics=extent;
 727   }
 728   metrics->height=(double) (i*(size_t) (metrics->ascent-metrics->descent+0.5)+
 729     (i-1)*draw_info->interline_spacing);
 730   /*
 731     Relinquish resources.
 732   */
 733   annotate_info->text=(char *) NULL;
 734   annotate_info=DestroyDrawInfo(annotate_info);
 735   for (i=0; textlist[i] != (char *) NULL; i++)
 736     textlist[i]=DestroyString(textlist[i]);
 737   textlist=(char **) RelinquishMagickMemory(textlist);
 738   return(status);
 739 }
 740 \f
 741 /*
 742 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 743 %                                                                             %
 744 %                                                                             %
 745 %                                                                             %
 746 %   G e t T y p e M e t r i c s                                               %
 747 %                                                                             %
 748 %                                                                             %
 749 %                                                                             %
 750 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 751 %
 752 %  GetTypeMetrics() returns the following information for the specified font
 753 %  and text:
 754 %
 755 %    character width
 756 %    character height
 757 %    ascender
 758 %    descender
 759 %    text width
 760 %    text height
 761 %    maximum horizontal advance
 762 %    bounds: x1
 763 %    bounds: y1
 764 %    bounds: x2
 765 %    bounds: y2
 766 %    origin: x
 767 %    origin: y
 768 %    underline position
 769 %    underline thickness
 770 %
 771 %  The format of the GetTypeMetrics method is:
 772 %
 773 %      MagickBooleanType GetTypeMetrics(Image *image,const DrawInfo *draw_info,
 774 %        TypeMetric *metrics,ExceptionInfo *exception)
 775 %
 776 %  A description of each parameter follows:
 777 %
 778 %    o image: the image.
 779 %
 780 %    o draw_info: the draw info.
 781 %
 782 %    o metrics: Return the font metrics in this structure.
 783 %
 784 %    o exception: return any errors or warnings in this structure.
 785 %
 786 */
 787 MagickExport MagickBooleanType GetTypeMetrics(Image *image,
 788   const DrawInfo *draw_info,TypeMetric *metrics,ExceptionInfo *exception)
 789 {
 790   DrawInfo
 791     *annotate_info;
 792
 793   MagickBooleanType
 794     status;
 795
 796   PointInfo
 797     offset;
 798
 799   assert(image != (Image *) NULL);
 800   assert(image->signature == MagickSignature);
 801   if (image->debug != MagickFalse)
 802     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 803   assert(draw_info != (DrawInfo *) NULL);
 804   assert(draw_info->text != (char *) NULL);
 805   assert(draw_info->signature == MagickSignature);
 806   annotate_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
 807   annotate_info->render=MagickFalse;
 808   annotate_info->direction=UndefinedDirection;
 809   (void) ResetMagickMemory(metrics,0,sizeof(*metrics));
 810   offset.x=0.0;
 811   offset.y=0.0;
 812   status=RenderType(image,annotate_info,&offset,metrics,exception);
 813   if (image->debug != MagickFalse)
 814     (void) LogMagickEvent(AnnotateEvent,GetMagickModule(),"Metrics: text: %s; "
 815       "width: %g; height: %g; ascent: %g; descent: %g; max advance: %g; "
 816       "bounds: %g,%g  %g,%g; origin: %g,%g; pixels per em: %g,%g; "
 817       "underline position: %g; underline thickness: %g",annotate_info->text,
 818       metrics->width,metrics->height,metrics->ascent,metrics->descent,
 819       metrics->max_advance,metrics->bounds.x1,metrics->bounds.y1,
 820       metrics->bounds.x2,metrics->bounds.y2,metrics->origin.x,metrics->origin.y,
 821       metrics->pixels_per_em.x,metrics->pixels_per_em.y,
 822       metrics->underline_position,metrics->underline_thickness);
 823   annotate_info=DestroyDrawInfo(annotate_info);
 824   return(status);
 825 }
 826 \f
 827 /*
 828 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 829 %                                                                             %
 830 %                                                                             %
 831 %                                                                             %
 832 +   R e n d e r T y p e                                                       %
 833 %                                                                             %
 834 %                                                                             %
 835 %                                                                             %
 836 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 837 %
 838 %  RenderType() renders text on the image.  It also returns the bounding box of
 839 %  the text relative to the image.
 840 %
 841 %  The format of the RenderType method is:
 842 %
 843 %      MagickBooleanType RenderType(Image *image,DrawInfo *draw_info,
 844 %        const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
 845 %
 846 %  A description of each parameter follows:
 847 %
 848 %    o image: the image.
 849 %
 850 %    o draw_info: the draw info.
 851 %
 852 %    o offset: (x,y) location of text relative to image.
 853 %
 854 %    o metrics: bounding box of text.
 855 %
 856 %    o exception: return any errors or warnings in this structure.
 857 %
 858 */
 859 static MagickBooleanType RenderType(Image *image,const DrawInfo *draw_info,
 860   const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
 861 {
 862   const TypeInfo
 863     *type_info;
 864
 865   DrawInfo
 866     *annotate_info;
 867
 868   MagickBooleanType
 869     status;
 870
 871   type_info=(const TypeInfo *) NULL;
 872   if (draw_info->font != (char *) NULL)
 873     {
 874       if (*draw_info->font == '@')
 875         {
 876           status=RenderFreetype(image,draw_info,draw_info->encoding,offset,
 877             metrics,exception);
 878           return(status);
 879         }
 880       if (*draw_info->font == '-')
 881         return(RenderX11(image,draw_info,offset,metrics,exception));
 882       if (IsPathAccessible(draw_info->font) != MagickFalse)
 883         {
 884           status=RenderFreetype(image,draw_info,draw_info->encoding,offset,
 885             metrics,exception);
 886           return(status);
 887         }
 888       type_info=GetTypeInfo(draw_info->font,exception);
 889       if (type_info == (const TypeInfo *) NULL)
 890         (void) ThrowMagickException(exception,GetMagickModule(),TypeWarning,
 891           "UnableToReadFont","`%s'",draw_info->font);
 892     }
 893   if ((type_info == (const TypeInfo *) NULL) &&
 894       (draw_info->family != (const char *) NULL))
 895     {
 896       type_info=GetTypeInfoByFamily(draw_info->family,draw_info->style,
 897         draw_info->stretch,draw_info->weight,exception);
 898       if (type_info == (const TypeInfo *) NULL)
 899         (void) ThrowMagickException(exception,GetMagickModule(),TypeWarning,
 900           "UnableToReadFont","`%s'",draw_info->family);
 901     }
 902   if (type_info == (const TypeInfo *) NULL)
 903     type_info=GetTypeInfoByFamily("Arial",draw_info->style,
 904       draw_info->stretch,draw_info->weight,exception);
 905   if (type_info == (const TypeInfo *) NULL)
 906     type_info=GetTypeInfoByFamily("Helvetica",draw_info->style,
 907       draw_info->stretch,draw_info->weight,exception);
 908   if (type_info == (const TypeInfo *) NULL)
 909     type_info=GetTypeInfoByFamily("Century Schoolbook",draw_info->style,
 910       draw_info->stretch,draw_info->weight,exception);
 911   if (type_info == (const TypeInfo *) NULL)
 912     type_info=GetTypeInfoByFamily("Sans",draw_info->style,
 913       draw_info->stretch,draw_info->weight,exception);
 914   if (type_info == (const TypeInfo *) NULL)
 915     type_info=GetTypeInfoByFamily((const char *) NULL,draw_info->style,
 916       draw_info->stretch,draw_info->weight,exception);
 917   if (type_info == (const TypeInfo *) NULL)
 918     type_info=GetTypeInfo("*",exception);
 919   if (type_info == (const TypeInfo *) NULL)
 920     {
 921       status=RenderFreetype(image,draw_info,draw_info->encoding,offset,metrics,
 922         exception);
 923       return(status);
 924     }
 925   annotate_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
 926   annotate_info->face=type_info->face;
 927   if (type_info->metrics != (char *) NULL)
 928     (void) CloneString(&annotate_info->metrics,type_info->metrics);
 929   if (type_info->glyphs != (char *) NULL)
 930     (void) CloneString(&annotate_info->font,type_info->glyphs);
 931   status=RenderFreetype(image,annotate_info,type_info->encoding,offset,metrics,
 932     exception);
 933   annotate_info=DestroyDrawInfo(annotate_info);
 934   return(status);
 935 }
 936 \f
 937 /*
 938 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 939 %                                                                             %
 940 %                                                                             %
 941 %                                                                             %
 942 +   R e n d e r F r e e t y p e                                               %
 943 %                                                                             %
 944 %                                                                             %
 945 %                                                                             %
 946 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 947 %
 948 %  RenderFreetype() renders text on the image with a Truetype font.  It also
 949 %  returns the bounding box of the text relative to the image.
 950 %
 951 %  The format of the RenderFreetype method is:
 952 %
 953 %      MagickBooleanType RenderFreetype(Image *image,DrawInfo *draw_info,
 954 %        const char *encoding,const PointInfo *offset,TypeMetric *metrics,
 955 %        ExceptionInfo *exception)
 956 %
 957 %  A description of each parameter follows:
 958 %
 959 %    o image: the image.
 960 %
 961 %    o draw_info: the draw info.
 962 %
 963 %    o encoding: the font encoding.
 964 %
 965 %    o offset: (x,y) location of text relative to image.
 966 %
 967 %    o metrics: bounding box of text.
 968 %
 969 %    o exception: return any errors or warnings in this structure.
 970 %
 971 */
 972
 973 #if defined(MAGICKCORE_FREETYPE_DELEGATE)
 974
 975 static int TraceCubicBezier(FT_Vector *p,FT_Vector *q,FT_Vector *to,
 976   DrawInfo *draw_info)
 977 {
 978   AffineMatrix
 979     affine;
 980
 981   char
 982     path[MaxTextExtent];
 983
 984   affine=draw_info->affine;
 985   (void) FormatLocaleString(path,MaxTextExtent,
 986     "C%g,%g %g,%g %g,%g",affine.tx+p->x/64.0,affine.ty-
 987     p->y/64.0,affine.tx+q->x/64.0,affine.ty-q->y/64.0,affine.tx+to->x/64.0,
 988     affine.ty-to->y/64.0);
 989   (void) ConcatenateString(&draw_info->primitive,path);
 990   return(0);
 991 }
 992
 993 static int TraceLineTo(FT_Vector *to,DrawInfo *draw_info)
 994 {
 995   AffineMatrix
 996     affine;
 997
 998   char
 999     path[MaxTextExtent];
1000
1001   affine=draw_info->affine;
1002   (void) FormatLocaleString(path,MaxTextExtent,"L%g,%g",affine.tx+
1003     to->x/64.0,affine.ty-to->y/64.0);
1004   (void) ConcatenateString(&draw_info->primitive,path);
1005   return(0);
1006 }
1007
1008 static int TraceMoveTo(FT_Vector *to,DrawInfo *draw_info)
1009 {
1010   AffineMatrix
1011     affine;
1012
1013   char
1014     path[MaxTextExtent];
1015
1016   affine=draw_info->affine;
1017   (void) FormatLocaleString(path,MaxTextExtent,"M%g,%g",affine.tx+
1018     to->x/64.0,affine.ty-to->y/64.0);
1019   (void) ConcatenateString(&draw_info->primitive,path);
1020   return(0);
1021 }
1022
1023 static int TraceQuadraticBezier(FT_Vector *control,FT_Vector *to,
1024   DrawInfo *draw_info)
1025 {
1026   AffineMatrix
1027     affine;
1028
1029   char
1030     path[MaxTextExtent];
1031
1032   affine=draw_info->affine;
1033   (void) FormatLocaleString(path,MaxTextExtent,"Q%g,%g %g,%g",
1034     affine.tx+control->x/64.0,affine.ty-control->y/64.0,affine.tx+to->x/64.0,
1035     affine.ty-to->y/64.0);
1036   (void) ConcatenateString(&draw_info->primitive,path);
1037   return(0);
1038 }
1039
1040 static MagickBooleanType RenderFreetype(Image *image,const DrawInfo *draw_info,
1041   const char *encoding,const PointInfo *offset,TypeMetric *metrics,
1042   ExceptionInfo *exception)
1043 {
1044 #if !defined(FT_OPEN_PATHNAME)
1045 #define FT_OPEN_PATHNAME  ft_open_pathname
1046 #endif
1047
1048   typedef struct _GlyphInfo
1049   {
1050     FT_UInt
1051       id;
1052
1053     FT_Vector
1054       origin;
1055
1056     FT_Glyph
1057       image;
1058   } GlyphInfo;
1059
1060   const char
1061     *value;
1062
1063   double
1064     direction;
1065
1066   DrawInfo
1067     *annotate_info;
1068
1069   FT_BBox
1070     bounds;
1071
1072   FT_BitmapGlyph
1073     bitmap;
1074
1075   FT_Encoding
1076     encoding_type;
1077
1078   FT_Error
1079     status;
1080
1081   FT_Face
1082     face;
1083
1084   FT_Int32
1085     flags;
1086
1087   FT_Library
1088     library;
1089
1090   FT_Matrix
1091     affine;
1092
1093   FT_Open_Args
1094     args;
1095
1096   FT_Vector
1097     origin;
1098
1099   GlyphInfo
1100     glyph,
1101     last_glyph;
1102
1103   PointInfo
1104     point,
1105     resolution;
1106
1107   register char
1108     *p;
1109
1110   ssize_t
1111     code,
1112     y;
1113
1114   static FT_Outline_Funcs
1115     OutlineMethods =
1116     {
1117       (FT_Outline_MoveTo_Func) TraceMoveTo,
1118       (FT_Outline_LineTo_Func) TraceLineTo,
1119       (FT_Outline_ConicTo_Func) TraceQuadraticBezier,
1120       (FT_Outline_CubicTo_Func) TraceCubicBezier,
1121       0, 0
1122     };
1123
1124   unsigned char
1125     *utf8;
1126
1127   /*
1128     Initialize Truetype library.
1129   */
1130   status=FT_Init_FreeType(&library);
1131   if (status != 0)
1132     ThrowBinaryException(TypeError,"UnableToInitializeFreetypeLibrary",
1133       image->filename);
1134   args.flags=FT_OPEN_PATHNAME;
1135   if (draw_info->font == (char *) NULL)
1136     args.pathname=ConstantString("helvetica");
1137   else
1138     if (*draw_info->font != '@')
1139       args.pathname=ConstantString(draw_info->font);
1140     else
1141       args.pathname=ConstantString(draw_info->font+1);
1142   face=(FT_Face) NULL;
1143   status=FT_Open_Face(library,&args,(long) draw_info->face,&face);
1144   args.pathname=DestroyString(args.pathname);
1145   if (status != 0)
1146     {
1147       (void) FT_Done_FreeType(library);
1148       (void) ThrowMagickException(exception,GetMagickModule(),TypeError,
1149         "UnableToReadFont","`%s'",draw_info->font);
1150       return(RenderPostscript(image,draw_info,offset,metrics,exception));
1151     }
1152   if ((draw_info->metrics != (char *) NULL) &&
1153       (IsPathAccessible(draw_info->metrics) != MagickFalse))
1154     (void) FT_Attach_File(face,draw_info->metrics);
1155   encoding_type=ft_encoding_unicode;
1156   status=FT_Select_Charmap(face,encoding_type);
1157   if ((status != 0) && (face->num_charmaps != 0))
1158     status=FT_Set_Charmap(face,face->charmaps[0]);
1159   if (encoding != (const char *) NULL)
1160     {
1161       if (LocaleCompare(encoding,"AdobeCustom") == 0)
1162         encoding_type=ft_encoding_adobe_custom;
1163       if (LocaleCompare(encoding,"AdobeExpert") == 0)
1164         encoding_type=ft_encoding_adobe_expert;
1165       if (LocaleCompare(encoding,"AdobeStandard") == 0)
1166         encoding_type=ft_encoding_adobe_standard;
1167       if (LocaleCompare(encoding,"AppleRoman") == 0)
1168         encoding_type=ft_encoding_apple_roman;
1169       if (LocaleCompare(encoding,"BIG5") == 0)
1170         encoding_type=ft_encoding_big5;
1171       if (LocaleCompare(encoding,"GB2312") == 0)
1172         encoding_type=ft_encoding_gb2312;
1173       if (LocaleCompare(encoding,"Johab") == 0)
1174         encoding_type=ft_encoding_johab;
1175 #if defined(ft_encoding_latin_1)
1176       if (LocaleCompare(encoding,"Latin-1") == 0)
1177         encoding_type=ft_encoding_latin_1;
1178 #endif
1179       if (LocaleCompare(encoding,"Latin-2") == 0)
1180         encoding_type=ft_encoding_latin_2;
1181       if (LocaleCompare(encoding,"None") == 0)
1182         encoding_type=ft_encoding_none;
1183       if (LocaleCompare(encoding,"SJIScode") == 0)
1184         encoding_type=ft_encoding_sjis;
1185       if (LocaleCompare(encoding,"Symbol") == 0)
1186         encoding_type=ft_encoding_symbol;
1187       if (LocaleCompare(encoding,"Unicode") == 0)
1188         encoding_type=ft_encoding_unicode;
1189       if (LocaleCompare(encoding,"Wansung") == 0)
1190         encoding_type=ft_encoding_wansung;
1191       status=FT_Select_Charmap(face,encoding_type);
1192       if (status != 0)
1193         ThrowBinaryException(TypeError,"UnrecognizedFontEncoding",encoding);
1194     }
1195   /*
1196     Set text size.
1197   */
1198   resolution.x=DefaultResolution;
1199   resolution.y=DefaultResolution;
1200   if (draw_info->density != (char *) NULL)
1201     {
1202       GeometryInfo
1203         geometry_info;
1204
1205       MagickStatusType
1206         flags;
1207
1208       flags=ParseGeometry(draw_info->density,&geometry_info);
1209       resolution.x=geometry_info.rho;
1210       resolution.y=geometry_info.sigma;
1211       if ((flags & SigmaValue) == 0)
1212         resolution.y=resolution.x;
1213     }
1214   status=FT_Set_Char_Size(face,(FT_F26Dot6) (64.0*draw_info->pointsize),
1215     (FT_F26Dot6) (64.0*draw_info->pointsize),(FT_UInt) resolution.x,
1216     (FT_UInt) resolution.y);
1217   metrics->pixels_per_em.x=face->size->metrics.x_ppem;
1218   metrics->pixels_per_em.y=face->size->metrics.y_ppem;
1219   metrics->ascent=(double) face->size->metrics.ascender/64.0;
1220   metrics->descent=(double) face->size->metrics.descender/64.0;
1221   metrics->width=0;
1222   metrics->origin.x=0;
1223   metrics->origin.y=0;
1224   metrics->height=(double) face->size->metrics.height/64.0;
1225   metrics->max_advance=0.0;
1226   if (face->size->metrics.max_advance > MagickEpsilon)
1227     metrics->max_advance=(double) face->size->metrics.max_advance/64.0;
1228   metrics->bounds.x1=0.0;
1229   metrics->bounds.y1=metrics->descent;
1230   metrics->bounds.x2=metrics->ascent+metrics->descent;
1231   metrics->bounds.y2=metrics->ascent+metrics->descent;
1232   metrics->underline_position=face->underline_position/64.0;
1233   metrics->underline_thickness=face->underline_thickness/64.0;
1234   if ((draw_info->text == (char *) NULL) || (*draw_info->text == '\0'))
1235     {
1236       (void) FT_Done_Face(face);
1237       (void) FT_Done_FreeType(library);
1238       return(MagickTrue);
1239     }
1240   /*
1241     Compute bounding box.
1242   */
1243   if (image->debug != MagickFalse)
1244     (void) LogMagickEvent(AnnotateEvent,GetMagickModule(),"Font %s; "
1245       "font-encoding %s; text-encoding %s; pointsize %g",
1246       draw_info->font != (char *) NULL ? draw_info->font : "none",
1247       encoding != (char *) NULL ? encoding : "none",
1248       draw_info->encoding != (char *) NULL ? draw_info->encoding : "none",
1249       draw_info->pointsize);
1250   flags=FT_LOAD_NO_BITMAP;
1251   if (draw_info->text_antialias == MagickFalse)
1252     flags|=FT_LOAD_TARGET_MONO;
1253   else
1254     {
1255 #if defined(FT_LOAD_TARGET_LIGHT)
1256       flags|=FT_LOAD_TARGET_LIGHT;
1257 #elif defined(FT_LOAD_TARGET_LCD)
1258       flags|=FT_LOAD_TARGET_LCD;
1259 #endif
1260     }
1261   value=GetImageProperty(image,"type:hinting",exception);
1262   if ((value != (const char *) NULL) && (LocaleCompare(value,"off") == 0))
1263     flags|=FT_LOAD_NO_HINTING;
1264   glyph.id=0;
1265   glyph.image=NULL;
1266   last_glyph.id=0;
1267   last_glyph.image=NULL;
1268   origin.x=0;
1269   origin.y=0;
1270   affine.xx=65536L;
1271   affine.yx=0L;
1272   affine.xy=0L;
1273   affine.yy=65536L;
1274   if (draw_info->render != MagickFalse)
1275     {
1276       affine.xx=(FT_Fixed) (65536L*draw_info->affine.sx+0.5);
1277       affine.yx=(FT_Fixed) (-65536L*draw_info->affine.rx+0.5);
1278       affine.xy=(FT_Fixed) (-65536L*draw_info->affine.ry+0.5);
1279       affine.yy=(FT_Fixed) (65536L*draw_info->affine.sy+0.5);
1280     }
1281   annotate_info=CloneDrawInfo((ImageInfo *) NULL,draw_info);
1282   (void) CloneString(&annotate_info->primitive,"path '");
1283   if (draw_info->render != MagickFalse)
1284     {
1285       if (image->storage_class != DirectClass)
1286         (void) SetImageStorageClass(image,DirectClass,exception);
1287       if (image->alpha_trait != BlendPixelTrait)
1288         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1289     }
1290   direction=1.0;
1291   if (draw_info->direction == RightToLeftDirection)
1292     direction=(-1.0);
1293   point.x=0.0;
1294   point.y=0.0;
1295   for (p=draw_info->text; GetUTFCode(p) != 0; p+=GetUTFOctets(p))
1296     if (GetUTFCode(p) < 0)
1297       break;
1298   utf8=(unsigned char *) NULL;
1299   if (GetUTFCode(p) == 0)
1300     p=draw_info->text;
1301   else
1302     {
1303       utf8=ConvertLatin1ToUTF8((unsigned char *) draw_info->text);
1304       if (utf8 != (unsigned char *) NULL)
1305         p=(char *) utf8;
1306     }
1307   for (code=0; GetUTFCode(p) != 0; p+=GetUTFOctets(p))
1308   {
1309     /*
1310       Render UTF-8 sequence.
1311     */
1312     glyph.id=FT_Get_Char_Index(face,GetUTFCode(p));
1313     if (glyph.id == 0)
1314       glyph.id=FT_Get_Char_Index(face,'?');
1315     if ((glyph.id != 0) && (last_glyph.id != 0))
1316       {
1317         if (fabs(draw_info->kerning) >= MagickEpsilon)
1318           origin.x+=(FT_Pos) (64.0*direction*draw_info->kerning);
1319         else
1320           if (FT_HAS_KERNING(face))
1321             {
1322               FT_Vector
1323                 kerning;
1324
1325               status=FT_Get_Kerning(face,last_glyph.id,glyph.id,
1326                 ft_kerning_default,&kerning);
1327               if (status == 0)
1328                 origin.x+=(FT_Pos) (direction*kerning.x);
1329             }
1330         }
1331     glyph.origin=origin;
1332     status=FT_Load_Glyph(face,glyph.id,flags);
1333     if (status != 0)
1334       continue;
1335     status=FT_Get_Glyph(face->glyph,&glyph.image);
1336     if (status != 0)
1337       continue;
1338     status=FT_Outline_Get_BBox(&((FT_OutlineGlyph) glyph.image)->outline,
1339       &bounds);
1340     if (status != 0)
1341       continue;
1342     if ((p == draw_info->text) || (bounds.xMin < metrics->bounds.x1))
1343       metrics->bounds.x1=(double) bounds.xMin;
1344     if ((p == draw_info->text) || (bounds.yMin < metrics->bounds.y1))
1345       metrics->bounds.y1=(double) bounds.yMin;
1346     if ((p == draw_info->text) || (bounds.xMax > metrics->bounds.x2))
1347       metrics->bounds.x2=(double) bounds.xMax;
1348     if ((p == draw_info->text) || (bounds.yMax > metrics->bounds.y2))
1349       metrics->bounds.y2=(double) bounds.yMax;
1350     if (draw_info->render != MagickFalse)
1351       if ((draw_info->stroke.alpha != TransparentAlpha) ||
1352           (draw_info->stroke_pattern != (Image *) NULL))
1353         {
1354           /*
1355             Trace the glyph.
1356           */
1357           annotate_info->affine.tx=glyph.origin.x/64.0;
1358           annotate_info->affine.ty=glyph.origin.y/64.0;
1359           (void) FT_Outline_Decompose(&((FT_OutlineGlyph) glyph.image)->
1360             outline,&OutlineMethods,annotate_info);
1361         }
1362     FT_Vector_Transform(&glyph.origin,&affine);
1363     (void) FT_Glyph_Transform(glyph.image,&affine,&glyph.origin);
1364     status=FT_Glyph_To_Bitmap(&glyph.image,ft_render_mode_normal,
1365       (FT_Vector *) NULL,MagickTrue);
1366     if (status != 0)
1367       continue;
1368     bitmap=(FT_BitmapGlyph) glyph.image;
1369     point.x=offset->x+bitmap->left;
1370     if (bitmap->bitmap.pixel_mode == ft_pixel_mode_mono)
1371       point.x=offset->x+(origin.x >> 6);
1372     point.y=offset->y-bitmap->top;
1373     if (draw_info->render != MagickFalse)
1374       {
1375         CacheView
1376           *image_view;
1377
1378         MagickBooleanType
1379           status;
1380
1381         register unsigned char
1382           *p;
1383
1384         /*
1385           Rasterize the glyph.
1386         */
1387         status=MagickTrue;
1388         image_view=AcquireAuthenticCacheView(image,exception);
1389         p=bitmap->bitmap.buffer;
1390         for (y=0; y < (ssize_t) bitmap->bitmap.rows; y++)
1391         {
1392           MagickBooleanType
1393             active,
1394             sync;
1395
1396           double
1397             fill_opacity;
1398
1399           PixelInfo
1400             fill_color;
1401
1402           register Quantum
1403             *restrict q;
1404
1405           register ssize_t
1406             x;
1407
1408           ssize_t
1409             n,
1410             x_offset,
1411             y_offset;
1412
1413           if (status == MagickFalse)
1414             continue;
1415           x_offset=(ssize_t) ceil(point.x-0.5);
1416           y_offset=(ssize_t) ceil(point.y+y-0.5);
1417           if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
1418             continue;
1419           q=(Quantum *) NULL;
1420           if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
1421             active=MagickFalse;
1422           else
1423             {
1424               q=GetCacheViewAuthenticPixels(image_view,x_offset,y_offset,
1425                 bitmap->bitmap.width,1,exception);
1426               active=q != (Quantum *) NULL ? MagickTrue : MagickFalse;
1427             }
1428           n=y*bitmap->bitmap.pitch-1;
1429           for (x=0; x < (ssize_t) bitmap->bitmap.width; x++)
1430           {
1431             n++;
1432             x_offset++;
1433             if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
1434               {
1435                 q+=GetPixelChannels(image);
1436                 continue;
1437               }
1438             if (bitmap->bitmap.pixel_mode != ft_pixel_mode_mono)
1439               fill_opacity=(double) (p[n])/(bitmap->bitmap.num_grays-1);
1440             else
1441               fill_opacity=((p[(x >> 3)+y*bitmap->bitmap.pitch] &
1442                 (1 << (~x & 0x07)))) == 0 ? 0.0 : 1.0;
1443             if (draw_info->text_antialias == MagickFalse)
1444               fill_opacity=fill_opacity >= 0.5 ? 1.0 : 0.0;
1445             if (active == MagickFalse)
1446               q=GetCacheViewAuthenticPixels(image_view,x_offset,y_offset,1,1,
1447                 exception);
1448             if (q == (Quantum *) NULL)
1449               {
1450                 q+=GetPixelChannels(image);
1451                 continue;
1452               }
1453             GetPixelInfo(image,&fill_color);
1454             (void) GetFillColor(draw_info,x_offset,y_offset,&fill_color,
1455               exception);
1456             fill_opacity=fill_opacity*fill_color.alpha;
1457             CompositePixelOver(image,&fill_color,fill_opacity,q,
1458               GetPixelAlpha(image,q),q);
1459             if (active == MagickFalse)
1460               {
1461                 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1462                 if (sync == MagickFalse)
1463                   status=MagickFalse;
1464               }
1465             q+=GetPixelChannels(image);
1466           }
1467           sync=SyncCacheViewAuthenticPixels(image_view,exception);
1468           if (sync == MagickFalse)
1469             status=MagickFalse;
1470         }
1471         image_view=DestroyCacheView(image_view);
1472       }
1473     if ((bitmap->left+bitmap->bitmap.width) > metrics->width)
1474       metrics->width=bitmap->left+bitmap->bitmap.width;
1475     if ((fabs(draw_info->interword_spacing) >= MagickEpsilon) &&
1476         (IsUTFSpace(GetUTFCode(p)) != MagickFalse) &&
1477         (IsUTFSpace(code) == MagickFalse))
1478       origin.x+=(FT_Pos) (64.0*direction*draw_info->interword_spacing);
1479     else
1480       origin.x+=(FT_Pos) (direction*face->glyph->advance.x);
1481     metrics->origin.x=(double) origin.x;
1482     metrics->origin.y=(double) origin.y;
1483     if (last_glyph.id != 0)
1484       FT_Done_Glyph(last_glyph.image);
1485     last_glyph=glyph;
1486     code=GetUTFCode(p);
1487   }
1488   if (utf8 != (unsigned char *) NULL)
1489     utf8=(unsigned char *) RelinquishMagickMemory(utf8);
1490   if (last_glyph.id != 0)
1491     FT_Done_Glyph(last_glyph.image);
1492   if ((draw_info->stroke.alpha != TransparentAlpha) ||
1493       (draw_info->stroke_pattern != (Image *) NULL))
1494     {
1495       if (draw_info->render != MagickFalse)
1496         {
1497           /*
1498             Draw text stroke.
1499           */
1500           annotate_info->linejoin=RoundJoin;
1501           annotate_info->affine.tx=offset->x;
1502           annotate_info->affine.ty=offset->y;
1503           (void) ConcatenateString(&annotate_info->primitive,"'");
1504           (void) DrawImage(image,annotate_info,exception);
1505         }
1506       }
1507   /*
1508     Determine font metrics.
1509   */
1510   glyph.id=FT_Get_Char_Index(face,'_');
1511   glyph.origin=origin;
1512   status=FT_Load_Glyph(face,glyph.id,flags);
1513   if (status == 0)
1514     {
1515       status=FT_Get_Glyph(face->glyph,&glyph.image);
1516       if (status == 0)
1517         {
1518           status=FT_Outline_Get_BBox(&((FT_OutlineGlyph) glyph.image)->outline,
1519             &bounds);
1520           if (status == 0)
1521             {
1522               FT_Vector_Transform(&glyph.origin,&affine);
1523               (void) FT_Glyph_Transform(glyph.image,&affine,&glyph.origin);
1524               status=FT_Glyph_To_Bitmap(&glyph.image,ft_render_mode_normal,
1525                 (FT_Vector *) NULL,MagickTrue);
1526               bitmap=(FT_BitmapGlyph) glyph.image;
1527               if (bitmap->left > metrics->width)
1528                 metrics->width=bitmap->left;
1529             }
1530         }
1531       FT_Done_Glyph(glyph.image);
1532     }
1533   metrics->width-=metrics->bounds.x1/64.0;
1534   metrics->width+=annotate_info->stroke_width;
1535   metrics->bounds.x1/=64.0;
1536   metrics->bounds.y1/=64.0;
1537   metrics->bounds.x2/=64.0;
1538   metrics->bounds.y2/=64.0;
1539   metrics->origin.x/=64.0;
1540   metrics->origin.y/=64.0;
1541   /*
1542     Relinquish resources.
1543   */
1544   annotate_info=DestroyDrawInfo(annotate_info);
1545   (void) FT_Done_Face(face);
1546   (void) FT_Done_FreeType(library);
1547   return(MagickTrue);
1548 }
1549 #else
1550 static MagickBooleanType RenderFreetype(Image *image,const DrawInfo *draw_info,
1551   const char *magick_unused(encoding),const PointInfo *offset,
1552   TypeMetric *metrics,ExceptionInfo *exception)
1553 {
1554   (void) ThrowMagickException(exception,GetMagickModule(),
1555     MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","'%s' (Freetype)",
1556     draw_info->font != (char *) NULL ? draw_info->font : "none");
1557   return(RenderPostscript(image,draw_info,offset,metrics,exception));
1558 }
1559 #endif
1560 \f
1561 /*
1562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1563 %                                                                             %
1564 %                                                                             %
1565 %                                                                             %
1566 +   R e n d e r P o s t s c r i p t                                           %
1567 %                                                                             %
1568 %                                                                             %
1569 %                                                                             %
1570 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1571 %
1572 %  RenderPostscript() renders text on the image with a Postscript font.  It
1573 %  also returns the bounding box of the text relative to the image.
1574 %
1575 %  The format of the RenderPostscript method is:
1576 %
1577 %      MagickBooleanType RenderPostscript(Image *image,DrawInfo *draw_info,
1578 %        const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
1579 %
1580 %  A description of each parameter follows:
1581 %
1582 %    o image: the image.
1583 %
1584 %    o draw_info: the draw info.
1585 %
1586 %    o offset: (x,y) location of text relative to image.
1587 %
1588 %    o metrics: bounding box of text.
1589 %
1590 %    o exception: return any errors or warnings in this structure.
1591 %
1592 */
1593
1594 static inline size_t MagickMin(const size_t x,const size_t y)
1595 {
1596   if (x < y)
1597     return(x);
1598   return(y);
1599 }
1600
1601 static char *EscapeParenthesis(const char *text)
1602 {
1603   char
1604     *buffer;
1605
1606   register char
1607     *p;
1608
1609   register ssize_t
1610     i;
1611
1612   size_t
1613     escapes;
1614
1615   escapes=0;
1616   buffer=AcquireString(text);
1617   p=buffer;
1618   for (i=0; i < (ssize_t) MagickMin(strlen(text),MaxTextExtent-escapes-1); i++)
1619   {
1620     if ((text[i] == '(') || (text[i] == ')'))
1621       {
1622         *p++='\\';
1623         escapes++;
1624       }
1625     *p++=text[i];
1626   }
1627   *p='\0';
1628   return(buffer);
1629 }
1630
1631 static MagickBooleanType RenderPostscript(Image *image,
1632   const DrawInfo *draw_info,const PointInfo *offset,TypeMetric *metrics,
1633   ExceptionInfo *exception)
1634 {
1635   char
1636     filename[MaxTextExtent],
1637     geometry[MaxTextExtent],
1638     *text;
1639
1640   FILE
1641     *file;
1642
1643   Image
1644     *annotate_image;
1645
1646   ImageInfo
1647     *annotate_info;
1648
1649   int
1650     unique_file;
1651
1652   MagickBooleanType
1653     identity;
1654
1655   PointInfo
1656     extent,
1657     point,
1658     resolution;
1659
1660   register ssize_t
1661     i;
1662
1663   size_t
1664     length;
1665
1666   ssize_t
1667     y;
1668
1669   /*
1670     Render label with a Postscript font.
1671   */
1672   if (image->debug != MagickFalse)
1673     (void) LogMagickEvent(AnnotateEvent,GetMagickModule(),
1674       "Font %s; pointsize %g",draw_info->font != (char *) NULL ?
1675       draw_info->font : "none",draw_info->pointsize);
1676   file=(FILE *) NULL;
1677   unique_file=AcquireUniqueFileResource(filename);
1678   if (unique_file != -1)
1679     file=fdopen(unique_file,"wb");
1680   if ((unique_file == -1) || (file == (FILE *) NULL))
1681     {
1682       ThrowFileException(exception,FileOpenError,"UnableToOpenFile",filename);
1683       return(MagickFalse);
1684     }
1685   (void) FormatLocaleFile(file,"%%!PS-Adobe-3.0\n");
1686   (void) FormatLocaleFile(file,"/ReencodeType\n");
1687   (void) FormatLocaleFile(file,"{\n");
1688   (void) FormatLocaleFile(file,"  findfont dup length\n");
1689   (void) FormatLocaleFile(file,
1690     "  dict begin { 1 index /FID ne {def} {pop pop} ifelse } forall\n");
1691   (void) FormatLocaleFile(file,
1692     "  /Encoding ISOLatin1Encoding def currentdict end definefont pop\n");
1693   (void) FormatLocaleFile(file,"} bind def\n");
1694   /*
1695     Sample to compute bounding box.
1696   */
1697   identity=(fabs(draw_info->affine.sx-draw_info->affine.sy) < MagickEpsilon) &&
1698     (fabs(draw_info->affine.rx) < MagickEpsilon) &&
1699     (fabs(draw_info->affine.ry) < MagickEpsilon) ? MagickTrue : MagickFalse;
1700   extent.x=0.0;
1701   extent.y=0.0;
1702   length=strlen(draw_info->text);
1703   for (i=0; i <= (ssize_t) (length+2); i++)
1704   {
1705     point.x=fabs(draw_info->affine.sx*i*draw_info->pointsize+
1706       draw_info->affine.ry*2.0*draw_info->pointsize);
1707     point.y=fabs(draw_info->affine.rx*i*draw_info->pointsize+
1708       draw_info->affine.sy*2.0*draw_info->pointsize);
1709     if (point.x > extent.x)
1710       extent.x=point.x;
1711     if (point.y > extent.y)
1712       extent.y=point.y;
1713   }
1714   (void) FormatLocaleFile(file,"%g %g moveto\n",identity  != MagickFalse ? 0.0 :
1715     extent.x/2.0,extent.y/2.0);
1716   (void) FormatLocaleFile(file,"%g %g scale\n",draw_info->pointsize,
1717     draw_info->pointsize);
1718   if ((draw_info->font == (char *) NULL) || (*draw_info->font == '\0') ||
1719       (strchr(draw_info->font,'/') != (char *) NULL))
1720     (void) FormatLocaleFile(file,
1721       "/Times-Roman-ISO dup /Times-Roman ReencodeType findfont setfont\n");
1722   else
1723     (void) FormatLocaleFile(file,
1724       "/%s-ISO dup /%s ReencodeType findfont setfont\n",draw_info->font,
1725       draw_info->font);
1726   (void) FormatLocaleFile(file,"[%g %g %g %g 0 0] concat\n",
1727     draw_info->affine.sx,-draw_info->affine.rx,-draw_info->affine.ry,
1728     draw_info->affine.sy);
1729   text=EscapeParenthesis(draw_info->text);
1730   if (identity == MagickFalse)
1731     (void) FormatLocaleFile(file,"(%s) stringwidth pop -0.5 mul -0.5 rmoveto\n",
1732       text);
1733   (void) FormatLocaleFile(file,"(%s) show\n",text);
1734   text=DestroyString(text);
1735   (void) FormatLocaleFile(file,"showpage\n");
1736   (void) fclose(file);
1737   (void) FormatLocaleString(geometry,MaxTextExtent,"%.20gx%.20g+0+0!",
1738     floor(extent.x+0.5),floor(extent.y+0.5));
1739   annotate_info=AcquireImageInfo();
1740   (void) FormatLocaleString(annotate_info->filename,MaxTextExtent,"ps:%s",
1741     filename);
1742   (void) CloneString(&annotate_info->page,geometry);
1743   if (draw_info->density != (char *) NULL)
1744     (void) CloneString(&annotate_info->density,draw_info->density);
1745   annotate_info->antialias=draw_info->text_antialias;
1746   annotate_image=ReadImage(annotate_info,exception);
1747   CatchException(exception);
1748   annotate_info=DestroyImageInfo(annotate_info);
1749   (void) RelinquishUniqueFileResource(filename);
1750   if (annotate_image == (Image *) NULL)
1751     return(MagickFalse);
1752   (void) NegateImage(annotate_image,MagickFalse,exception);
1753   resolution.x=DefaultResolution;
1754   resolution.y=DefaultResolution;
1755   if (draw_info->density != (char *) NULL)
1756     {
1757       GeometryInfo
1758         geometry_info;
1759
1760       MagickStatusType
1761         flags;
1762
1763       flags=ParseGeometry(draw_info->density,&geometry_info);
1764       resolution.x=geometry_info.rho;
1765       resolution.y=geometry_info.sigma;
1766       if ((flags & SigmaValue) == 0)
1767         resolution.y=resolution.x;
1768     }
1769   if (identity == MagickFalse)
1770     (void) TransformImage(&annotate_image,"0x0",(char *) NULL,exception);
1771   else
1772     {
1773       RectangleInfo
1774         crop_info;
1775
1776       crop_info=GetImageBoundingBox(annotate_image,exception);
1777       crop_info.height=(size_t) ((resolution.y/DefaultResolution)*
1778         ExpandAffine(&draw_info->affine)*draw_info->pointsize+0.5);
1779       crop_info.y=(ssize_t) ceil((resolution.y/DefaultResolution)*extent.y/8.0-
1780         0.5);
1781       (void) FormatLocaleString(geometry,MaxTextExtent,
1782         "%.20gx%.20g%+.20g%+.20g",(double) crop_info.width,(double)
1783         crop_info.height,(double) crop_info.x,(double) crop_info.y);
1784       (void) TransformImage(&annotate_image,geometry,(char *) NULL,exception);
1785     }
1786   metrics->pixels_per_em.x=(resolution.y/DefaultResolution)*
1787     ExpandAffine(&draw_info->affine)*draw_info->pointsize;
1788   metrics->pixels_per_em.y=metrics->pixels_per_em.x;
1789   metrics->ascent=metrics->pixels_per_em.x;
1790   metrics->descent=metrics->pixels_per_em.y/-5.0;
1791   metrics->width=(double) annotate_image->columns/
1792     ExpandAffine(&draw_info->affine);
1793   metrics->height=1.152*metrics->pixels_per_em.x;
1794   metrics->max_advance=metrics->pixels_per_em.x;
1795   metrics->bounds.x1=0.0;
1796   metrics->bounds.y1=metrics->descent;
1797   metrics->bounds.x2=metrics->ascent+metrics->descent;
1798   metrics->bounds.y2=metrics->ascent+metrics->descent;
1799   metrics->underline_position=(-2.0);
1800   metrics->underline_thickness=1.0;
1801   if (draw_info->render == MagickFalse)
1802     {
1803       annotate_image=DestroyImage(annotate_image);
1804       return(MagickTrue);
1805     }
1806   if (draw_info->fill.alpha != TransparentAlpha)
1807     {
1808       CacheView
1809         *annotate_view;
1810
1811       MagickBooleanType
1812         sync;
1813
1814       PixelInfo
1815         fill_color;
1816
1817       /*
1818         Render fill color.
1819       */
1820       if (image->alpha_trait != BlendPixelTrait)
1821         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1822       if (annotate_image->alpha_trait != BlendPixelTrait)
1823         (void) SetImageAlphaChannel(annotate_image,OpaqueAlphaChannel,
1824           exception);
1825       fill_color=draw_info->fill;
1826       annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
1827       for (y=0; y < (ssize_t) annotate_image->rows; y++)
1828       {
1829         register ssize_t
1830           x;
1831
1832         register Quantum
1833           *restrict q;
1834
1835         q=GetCacheViewAuthenticPixels(annotate_view,0,y,annotate_image->columns,
1836           1,exception);
1837         if (q == (Quantum *) NULL)
1838           break;
1839         for (x=0; x < (ssize_t) annotate_image->columns; x++)
1840         {
1841           (void) GetFillColor(draw_info,x,y,&fill_color,exception);
1842           SetPixelAlpha(annotate_image,ClampToQuantum((((double) QuantumScale*
1843             GetPixelIntensity(annotate_image,q)*fill_color.alpha))),q);
1844           SetPixelRed(annotate_image,fill_color.red,q);
1845           SetPixelGreen(annotate_image,fill_color.green,q);
1846           SetPixelBlue(annotate_image,fill_color.blue,q);
1847           q+=GetPixelChannels(annotate_image);
1848         }
1849         sync=SyncCacheViewAuthenticPixels(annotate_view,exception);
1850         if (sync == MagickFalse)
1851           break;
1852       }
1853       annotate_view=DestroyCacheView(annotate_view);
1854       (void) CompositeImage(image,annotate_image,OverCompositeOp,MagickTrue,
1855         (ssize_t) ceil(offset->x-0.5),(ssize_t) ceil(offset->y-(metrics->ascent+
1856         metrics->descent)-0.5),exception);
1857     }
1858   annotate_image=DestroyImage(annotate_image);
1859   return(MagickTrue);
1860 }
1861 \f
1862 /*
1863 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1864 %                                                                             %
1865 %                                                                             %
1866 %                                                                             %
1867 +   R e n d e r X 1 1                                                         %
1868 %                                                                             %
1869 %                                                                             %
1870 %                                                                             %
1871 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1872 %
1873 %  RenderX11() renders text on the image with an X11 font.  It also returns the
1874 %  bounding box of the text relative to the image.
1875 %
1876 %  The format of the RenderX11 method is:
1877 %
1878 %      MagickBooleanType RenderX11(Image *image,DrawInfo *draw_info,
1879 %        const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
1880 %
1881 %  A description of each parameter follows:
1882 %
1883 %    o image: the image.
1884 %
1885 %    o draw_info: the draw info.
1886 %
1887 %    o offset: (x,y) location of text relative to image.
1888 %
1889 %    o metrics: bounding box of text.
1890 %
1891 %    o exception: return any errors or warnings in this structure.
1892 %
1893 */
1894 static MagickBooleanType RenderX11(Image *image,const DrawInfo *draw_info,
1895   const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
1896 {
1897   MagickBooleanType
1898     status;
1899
1900   if (annotate_semaphore == (SemaphoreInfo *) NULL)
1901     AcquireSemaphoreInfo(&annotate_semaphore);
1902   LockSemaphoreInfo(annotate_semaphore);
1903   status=XRenderImage(image,draw_info,offset,metrics,exception);
1904   UnlockSemaphoreInfo(annotate_semaphore);
1905   return(status);
1906 }