|
@@ -0,0 +1,1183 @@
|
|
|
+<?php
|
|
|
+/**
|
|
|
+ * Image_Text.
|
|
|
+ *
|
|
|
+ * This is the main file of the Image_Text package. This file has to be included for
|
|
|
+ * usage of Image_Text.
|
|
|
+ *
|
|
|
+ * This is a simple example script, showing Image_Text's facilities.
|
|
|
+ *
|
|
|
+ * PHP version 5
|
|
|
+ *
|
|
|
+ * @category Image
|
|
|
+ * @package Image_Text
|
|
|
+ * @author Tobias Schlitt <toby@php.net>
|
|
|
+ * @copyright 1997-2005 The PHP Group
|
|
|
+ * @license http://www.php.net/license/3_01.txt PHP License
|
|
|
+ * @version CVS: $Id$
|
|
|
+ * @link http://pear.php.net/package/Image_Text
|
|
|
+ * @since File available since Release 0.0.1
|
|
|
+ */
|
|
|
+require_once 'Image/Text/Exception.php';
|
|
|
+/**
|
|
|
+ * Image_Text - Advanced text manipulations in images.
|
|
|
+ *
|
|
|
+ * Image_Text provides advanced text manipulation facilities for GD2 image generation
|
|
|
+ * with PHP. Simply add text clippings to your images, let the class automatically
|
|
|
+ * determine lines, rotate text boxes around their center or top left corner. These
|
|
|
+ * are only a couple of features Image_Text provides.
|
|
|
+ *
|
|
|
+ * @category Image
|
|
|
+ * @package Image_Text
|
|
|
+ * @author Tobias Schlitt <toby@php.net>
|
|
|
+ * @copyright 1997-2005 The PHP Group
|
|
|
+ * @license http://www.php.net/license/3_01.txt PHP License
|
|
|
+ * @version Release: @package_version@
|
|
|
+ * @link http://pear.php.net/package/Image_Text
|
|
|
+ * @since 0.0.1
|
|
|
+ */
|
|
|
+class Image_Text
|
|
|
+{
|
|
|
+ /**
|
|
|
+ * Regex to match HTML style hex triples.
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_REGEX_HTMLCOLOR
|
|
|
+ = "/^[#|]([a-f0-9]{2})?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines horizontal alignment to the left of the text box. (This is standard.)
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_LEFT = "left";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines horizontal alignment to the center of the text box.
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_RIGHT = "right";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines horizontal alignment to the center of the text box.
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_CENTER = "center";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines vertical alignment to the to the top of the text box. (This is
|
|
|
+ * standard.)
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_TOP = "top";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines vertical alignment to the to the middle of the text box.
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_MIDDLE = "middle";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines vertical alignment to the to the bottom of the text box.
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_BOTTOM = "bottom";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * TODO: This constant is useless until now, since justified alignment does not
|
|
|
+ * work yet
|
|
|
+ */
|
|
|
+ const IMAGE_TEXT_ALIGN_JUSTIFY = "justify";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Options array. these options can be set through the constructor or the set()
|
|
|
+ * method.
|
|
|
+ *
|
|
|
+ * Possible options to set are:
|
|
|
+ * <pre>
|
|
|
+ * 'x' | This sets the top left coordinates (using x/y) or the
|
|
|
+ * 'y' | center point coordinates (using cx/cy) for your text
|
|
|
+ * 'cx' | box. The values from cx/cy will overwrite x/y.
|
|
|
+ * 'cy' |
|
|
|
+ *
|
|
|
+ * 'canvas' | You can set different values as a canvas:
|
|
|
+ * | - A gd image resource.
|
|
|
+ * | - An array with 'width' and 'height'.
|
|
|
+ * | - Nothing (the canvas will be measured after the real
|
|
|
+ * | text size).
|
|
|
+ *
|
|
|
+ * 'antialias' | This is usually true. Set it to false to switch
|
|
|
+ * | antialiasing off.
|
|
|
+ *
|
|
|
+ * 'width' | The width and height for your text box.
|
|
|
+ * 'height' |
|
|
|
+ *
|
|
|
+ * 'halign' | Alignment of your text inside the textbox. Use
|
|
|
+ * 'valign' | alignment constants to define vertical and horizontal
|
|
|
+ * | alignment.
|
|
|
+ *
|
|
|
+ * 'angle' | The angle to rotate your text box.
|
|
|
+ *
|
|
|
+ * 'color' | An array of color values. Colors will be rotated in the
|
|
|
+ * | mode you choose (linewise or paragraphwise). Can be in
|
|
|
+ * | the following formats:
|
|
|
+ * | - String representing HTML style hex couples
|
|
|
+ * | (+ unusual alpha couple in the first place,
|
|
|
+ * | optional).
|
|
|
+ * | - Array of int values using 'r', 'g', 'b' and
|
|
|
+ * | optionally 'a' as keys.
|
|
|
+ *
|
|
|
+ * 'color_mode' | The color rotation mode for your color sets. Does only
|
|
|
+ * | apply if you defined multiple colors. Use 'line' or
|
|
|
+ * | 'paragraph'.
|
|
|
+ *
|
|
|
+ * 'background_color' | defines the background color. NULL sets it transparent
|
|
|
+ * 'enable_alpha' | if alpha channel should be enabled. Automatically
|
|
|
+ * | enabled when background_color is set to NULL
|
|
|
+ *
|
|
|
+ * 'font_path' | Location of the font to use. The path only gives the
|
|
|
+ * | directory path (ending with a /).
|
|
|
+ * 'font_file' | The fontfile is given in the 'font_file' option.
|
|
|
+ *
|
|
|
+ * 'font_size' | The font size to render text in (will be overwriten, if
|
|
|
+ * | you use automeasurize).
|
|
|
+ *
|
|
|
+ * 'line_spacing' | Measure for the line spacing to use. Default is 0.5.
|
|
|
+ *
|
|
|
+ * 'min_font_size' | Automeasurize settings. Try to keep this area as small
|
|
|
+ * 'max_font_size' | as possible to get better performance.
|
|
|
+ *
|
|
|
+ * 'image_type' | The type of image (use image type constants). Is
|
|
|
+ * | default set to PNG.
|
|
|
+ *
|
|
|
+ * 'dest_file' | The destination to (optionally) save your file.
|
|
|
+ * </pre>
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ * @see Image_Text::set()
|
|
|
+ */
|
|
|
+
|
|
|
+ private $_options = array(
|
|
|
+ // orientation
|
|
|
+ 'x' => 0,
|
|
|
+ 'y' => 0,
|
|
|
+
|
|
|
+ // surface
|
|
|
+ 'canvas' => null,
|
|
|
+ 'antialias' => true,
|
|
|
+
|
|
|
+ // text clipping
|
|
|
+ 'width' => 0,
|
|
|
+ 'height' => 0,
|
|
|
+
|
|
|
+ // text alignment inside the clipping
|
|
|
+ 'halign' => self::IMAGE_TEXT_ALIGN_LEFT,
|
|
|
+ 'valign' => self::IMAGE_TEXT_ALIGN_TOP,
|
|
|
+
|
|
|
+ // angle to rotate the text clipping
|
|
|
+ 'angle' => 0,
|
|
|
+
|
|
|
+ // color settings
|
|
|
+ 'color' => array('#000000'),
|
|
|
+
|
|
|
+ 'color_mode' => 'line',
|
|
|
+
|
|
|
+ 'background_color' => '#000000',
|
|
|
+ 'enable_alpha' => false,
|
|
|
+
|
|
|
+ // font settings
|
|
|
+ 'font_path' => "./",
|
|
|
+ 'font_file' => null,
|
|
|
+ 'font_size' => 2,
|
|
|
+ 'line_spacing' => 0.5,
|
|
|
+
|
|
|
+ // automasurizing settings
|
|
|
+ 'min_font_size' => 1,
|
|
|
+ 'max_font_size' => 100,
|
|
|
+
|
|
|
+ //max. lines to render
|
|
|
+ 'max_lines' => 100,
|
|
|
+
|
|
|
+ // misc settings
|
|
|
+ 'image_type' => IMAGETYPE_PNG,
|
|
|
+ 'dest_file' => ''
|
|
|
+ );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Contains option names, which can cause re-initialization force.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_reInits = array(
|
|
|
+ 'width', 'height', 'canvas', 'angle', 'font_file', 'font_path', 'font_size'
|
|
|
+ );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The text you want to render.
|
|
|
+ *
|
|
|
+ * @var string
|
|
|
+ */
|
|
|
+ private $_text;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Resource ID of the image canvas.
|
|
|
+ *
|
|
|
+ * @var resource
|
|
|
+ */
|
|
|
+ private $_img;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Tokens (each word).
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_tokens = array();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Fullpath to the font.
|
|
|
+ *
|
|
|
+ * @var string
|
|
|
+ */
|
|
|
+ private $_font;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Contains the bbox of each rendered lines.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_bbox = array();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines in which mode the canvas has be set.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_mode = '';
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Color indices returned by imagecolorallocatealpha.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_colors = array();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Width and height of the (rendered) text.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_realTextSize = array('width' => false, 'height' => false);
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Measurized lines.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_lines = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Fontsize for which the last measuring process was done.
|
|
|
+ *
|
|
|
+ * @var array
|
|
|
+ */
|
|
|
+ private $_measurizedSize = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Is the text object initialized?
|
|
|
+ *
|
|
|
+ * @var bool
|
|
|
+ */
|
|
|
+ private $_init = false;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Constructor
|
|
|
+ *
|
|
|
+ * Set the text and options. This initializes a new Image_Text object. You must
|
|
|
+ * set your text here. Optionally you can set all options here using the $options
|
|
|
+ * parameter. If you finished switching all options you have to call the init()
|
|
|
+ * method first before doing anything further! See Image_Text::set() for further
|
|
|
+ * information.
|
|
|
+ *
|
|
|
+ * @param string $text Text to print.
|
|
|
+ * @param array $options Options.
|
|
|
+ *
|
|
|
+ * @see Image_Text::set(), Image_Text::construct(), Image_Text::init()
|
|
|
+ */
|
|
|
+ public function __construct($text, $options = null)
|
|
|
+ {
|
|
|
+ $this->set('text', $text);
|
|
|
+ if (!empty($options)) {
|
|
|
+ $this->_options = array_merge($this->_options, $options);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Construct and initialize an Image_Text in one step.
|
|
|
+ * This method is called statically and creates plus initializes an Image_Text
|
|
|
+ * object. Beware: You will have to recall init() if you set an option afterwards
|
|
|
+ * manually.
|
|
|
+ *
|
|
|
+ * @param string $text Text to print.
|
|
|
+ * @param array $options Options.
|
|
|
+ *
|
|
|
+ * @return Image_Text
|
|
|
+ * @see Image_Text::set(), Image_Text::Image_Text(), Image_Text::init()
|
|
|
+ */
|
|
|
+ public static function construct($text, $options)
|
|
|
+ {
|
|
|
+ $itext = new Image_Text($text, $options);
|
|
|
+ $itext->init();
|
|
|
+ return $itext;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Set options
|
|
|
+ *
|
|
|
+ * Set a single or multiple options. It may happen that you have to reinitialize
|
|
|
+ * the Image_Text object after changing options. For possible options, please
|
|
|
+ * take a look at the class options array!
|
|
|
+ *
|
|
|
+ * @param array|string $option A single option name or the options array.
|
|
|
+ * @param mixed $value Option value if $option is string.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ * @see Image_Text::Image_Text()
|
|
|
+ * @throws Image_Text_Exception setting the value failed
|
|
|
+ */
|
|
|
+ public function set($option, $value = null)
|
|
|
+ {
|
|
|
+ $reInits = array_flip($this->_reInits);
|
|
|
+ if (!is_array($option)) {
|
|
|
+ if (!isset($value)) {
|
|
|
+ throw new Image_Text_Exception('No value given.');
|
|
|
+ }
|
|
|
+ $option = array($option => $value);
|
|
|
+ }
|
|
|
+ foreach ($option as $opt => $val) {
|
|
|
+ switch ($opt) {
|
|
|
+ case 'color':
|
|
|
+ $this->setColors($val);
|
|
|
+ break;
|
|
|
+ case 'text':
|
|
|
+ if (is_array($val)) {
|
|
|
+ $this->_text = implode('\n', $val);
|
|
|
+ } else {
|
|
|
+ $this->_text = $val;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ $this->_options[$opt] = $val;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (isset($reInits[$opt])) {
|
|
|
+ $this->_init = false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Set the color-set
|
|
|
+ *
|
|
|
+ * Using this method you can set multiple colors for your text. Use a simple
|
|
|
+ * numeric array to determine their order and give it to this function. Multiple
|
|
|
+ * colors will be cycled by the options specified 'color_mode' option. The given
|
|
|
+ * array will overwrite the existing color settings!
|
|
|
+ *
|
|
|
+ * The following colors syntaxes are understood by this method:
|
|
|
+ * <ul>
|
|
|
+ * <li>"#ffff00" hexadecimal format (HTML style), with and without #.</li>
|
|
|
+ * <li>"#08ffff00" hexadecimal format (HTML style) with alpha channel (08),
|
|
|
+ * with and without #.</li>
|
|
|
+ * <li>array with 'r','g','b' and (optionally) 'a' keys, using int values.</li>
|
|
|
+ * </ul>
|
|
|
+ * A single color or an array of colors are allowed here.
|
|
|
+ *
|
|
|
+ * @param array|string $colors Single color or array of colors.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ * @see Image_Text::setColor(), Image_Text::set()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function setColors($colors)
|
|
|
+ {
|
|
|
+ $i = 0;
|
|
|
+ if (is_array($colors) && (is_string($colors[0]) || is_array($colors[0]))) {
|
|
|
+ foreach ($colors as $color) {
|
|
|
+ $this->setColor($color, $i++);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ $this->setColor($colors, $i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Set a color
|
|
|
+ *
|
|
|
+ * This method is used to set a color at a specific color ID inside the color
|
|
|
+ * cycle.
|
|
|
+ *
|
|
|
+ * The following colors syntaxes are understood by this method:
|
|
|
+ * <ul>
|
|
|
+ * <li>"#ffff00" hexadecimal format (HTML style), with and without #.</li>
|
|
|
+ * <li>"#08ffff00" hexadecimal format (HTML style) with alpha channel (08), with
|
|
|
+ * and without #.</li>
|
|
|
+ * <li>array with 'r','g','b' and (optionally) 'a' keys, using int values.</li>
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * @param array|string $color Color value.
|
|
|
+ * @param int $id ID (in the color array) to set color to.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ * @see Image_Text::setColors(), Image_Text::set()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+
|
|
|
+ function setColor($color, $id = 0)
|
|
|
+ {
|
|
|
+ if (is_array($color)) {
|
|
|
+ if (isset($color['r']) && isset($color['g']) && isset($color['b'])) {
|
|
|
+ $color['a'] = isset($color['a']) ? $color['a'] : 0;
|
|
|
+ $this->_options['colors'][$id] = $color;
|
|
|
+ } else if (isset($color[0]) && isset($color[1]) && isset($color[2])) {
|
|
|
+ $color['r'] = $color[0];
|
|
|
+ $color['g'] = $color[1];
|
|
|
+ $color['b'] = $color[2];
|
|
|
+ $color['a'] = isset($color[3]) ? $color[3] : 0;
|
|
|
+ $this->_options['colors'][$id] = $color;
|
|
|
+ } else {
|
|
|
+ throw new Image_Text_Exception(
|
|
|
+ 'Use keys 1,2,3 (optionally) 4 or r,g,b and (optionally) a.'
|
|
|
+ );
|
|
|
+ }
|
|
|
+ } elseif (is_string($color)) {
|
|
|
+ $color = $this->convertString2RGB($color);
|
|
|
+ if ($color) {
|
|
|
+ $this->_options['color'][$id] = $color;
|
|
|
+ } else {
|
|
|
+ throw new Image_Text_Exception('Invalid color.');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if ($this->_img) {
|
|
|
+ $aaFactor = ($this->_options['antialias']) ? 1 : -1;
|
|
|
+ if (function_exists('imagecolorallocatealpha') && isset($color['a'])) {
|
|
|
+ $this->_colors[$id] = $aaFactor *
|
|
|
+ imagecolorallocatealpha(
|
|
|
+ $this->_img,
|
|
|
+ $color['r'], $color['g'], $color['b'], $color['a']
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ $this->_colors[$id] = $aaFactor *
|
|
|
+ imagecolorallocate(
|
|
|
+ $this->_img,
|
|
|
+ $color['r'], $color['g'], $color['b']
|
|
|
+ );
|
|
|
+ }
|
|
|
+ if ($this->_colors[$id] == 0 && $aaFactor == -1) {
|
|
|
+ // correction for black with antialiasing OFF
|
|
|
+ // since color cannot be negative zero
|
|
|
+ $this->_colors[$id] = -256;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Initialize the Image_Text object.
|
|
|
+ *
|
|
|
+ * This method has to be called after setting the options for your Image_Text
|
|
|
+ * object. It initializes the canvas, normalizes some data and checks important
|
|
|
+ * options. Be sure to check the initialization after you switched some options.
|
|
|
+ * The set() method may force you to reinitialize the object.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ * @see Image_Text::set()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function init()
|
|
|
+ {
|
|
|
+ // Does the fontfile exist and is readable?
|
|
|
+ $fontFile = rtrim($this->_options['font_path'], '/\\');
|
|
|
+ $fontFile .= defined('OS_WINDOWS') && OS_WINDOWS ? '\\' : '/';
|
|
|
+ $fontFile .= $this->_options['font_file'];
|
|
|
+ $fontFile = realpath($fontFile);
|
|
|
+
|
|
|
+ if (empty($fontFile)) {
|
|
|
+ throw new Image_Text_Exception('You must supply a font file.');
|
|
|
+ } elseif (!file_exists($fontFile)) {
|
|
|
+ throw new Image_Text_Exception('Font file was not found.');
|
|
|
+ } elseif (!is_readable($fontFile)) {
|
|
|
+ throw new Image_Text_Exception('Font file is not readable.');
|
|
|
+ } elseif (!imagettfbbox(1, 1, $fontFile, 1)) {
|
|
|
+ throw new Image_Text_Exception('Font file is not valid.');
|
|
|
+ }
|
|
|
+ $this->_font = $fontFile;
|
|
|
+
|
|
|
+ // Is the font size to small?
|
|
|
+ if ($this->_options['width'] < 1) {
|
|
|
+ throw new Image_Text_Exception('Width too small. Has to be > 1.');
|
|
|
+ }
|
|
|
+
|
|
|
+ // Check and create canvas
|
|
|
+ $image_canvas = false;
|
|
|
+ switch (true) {
|
|
|
+
|
|
|
+ case (empty($this->_options['canvas'])):
|
|
|
+ // Create new image from width && height of the clipping
|
|
|
+ $this->_img = imagecreatetruecolor(
|
|
|
+ $this->_options['width'], $this->_options['height']
|
|
|
+ );
|
|
|
+ if (!$this->_img) {
|
|
|
+ throw new Image_Text_Exception('Could not create image canvas.');
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case (is_resource($this->_options['canvas']) &&
|
|
|
+ get_resource_type($this->_options['canvas']) == 'gd'):
|
|
|
+ // The canvas is an image resource
|
|
|
+ $image_canvas = true;
|
|
|
+ $this->_img = $this->_options['canvas'];
|
|
|
+ break;
|
|
|
+
|
|
|
+ case (is_array($this->_options['canvas']) &&
|
|
|
+ isset($this->_options['canvas']['width']) &&
|
|
|
+ isset($this->_options['canvas']['height'])):
|
|
|
+
|
|
|
+ // Canvas must be a width and height measure
|
|
|
+ $this->_img = imagecreatetruecolor(
|
|
|
+ $this->_options['canvas']['width'],
|
|
|
+ $this->_options['canvas']['height']
|
|
|
+ );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case (is_array($this->_options['canvas']) &&
|
|
|
+ isset($this->_options['canvas']['size']) &&
|
|
|
+ ($this->_options['canvas']['size'] = 'auto')):
|
|
|
+
|
|
|
+ case (is_string($this->_options['canvas']) &&
|
|
|
+ ($this->_options['canvas'] = 'auto')):
|
|
|
+ $this->_mode = 'auto';
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ throw new Image_Text_Exception('Could not create image canvas.');
|
|
|
+ }
|
|
|
+
|
|
|
+ if ($this->_img) {
|
|
|
+ $this->_options['canvas'] = array();
|
|
|
+ $this->_options['canvas']['width'] = imagesx($this->_img);
|
|
|
+ $this->_options['canvas']['height'] = imagesy($this->_img);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ($this->_options['enable_alpha']) {
|
|
|
+ imagesavealpha($this->_img, true);
|
|
|
+ imagealphablending($this->_img, false);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ($this->_options['background_color'] === null) {
|
|
|
+ $this->_options['enable_alpha'] = true;
|
|
|
+ imagesavealpha($this->_img, true);
|
|
|
+ imagealphablending($this->_img, false);
|
|
|
+ $colBg = imagecolorallocatealpha($this->_img, 255, 255, 255, 127);
|
|
|
+ } else {
|
|
|
+ $arBg = $this->convertString2RGB($this->_options['background_color']);
|
|
|
+ if ($arBg === false) {
|
|
|
+ throw new Image_Text_Exception('Background color is invalid.');
|
|
|
+ }
|
|
|
+ $colBg = imagecolorallocatealpha(
|
|
|
+ $this->_img, $arBg['r'], $arBg['g'], $arBg['b'], $arBg['a']
|
|
|
+ );
|
|
|
+ }
|
|
|
+ if ($image_canvas === false) {
|
|
|
+ imagefilledrectangle(
|
|
|
+ $this->_img,
|
|
|
+ 0, 0,
|
|
|
+ $this->_options['canvas']['width'] - 1,
|
|
|
+ $this->_options['canvas']['height'] - 1,
|
|
|
+ $colBg
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ // Save and repair angle
|
|
|
+ $angle = $this->_options['angle'];
|
|
|
+ while ($angle < 0) {
|
|
|
+ $angle += 360;
|
|
|
+ }
|
|
|
+ if ($angle > 359) {
|
|
|
+ $angle = $angle % 360;
|
|
|
+ }
|
|
|
+ $this->_options['angle'] = $angle;
|
|
|
+
|
|
|
+ // Set the color values
|
|
|
+ $this->setColors($this->_options['color']);
|
|
|
+
|
|
|
+ $this->_lines = null;
|
|
|
+
|
|
|
+ // Initialization is complete
|
|
|
+ $this->_init = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Auto measurize text
|
|
|
+ *
|
|
|
+ * Automatically determines the greatest possible font size to fit the text into
|
|
|
+ * the text box. This method may be very resource intensive on your webserver. A
|
|
|
+ * good tweaking point are the $start and $end parameters, which specify the
|
|
|
+ * range of font sizes to search through. Anyway, the results should be cached if
|
|
|
+ * possible. You can optionally set $start and $end here as a parameter or the
|
|
|
+ * settings of the options array are used.
|
|
|
+ *
|
|
|
+ * @param int|bool $start Fontsize to start testing with.
|
|
|
+ * @param int|bool $end Fontsize to end testing with.
|
|
|
+ *
|
|
|
+ * @return int Fontsize measured
|
|
|
+ * @see Image_Text::measurize()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ * @todo Beware of initialize
|
|
|
+ */
|
|
|
+ public function autoMeasurize($start = false, $end = false)
|
|
|
+ {
|
|
|
+ if (!$this->_init) {
|
|
|
+ throw new Image_Text_Exception('Not initialized. Call ->init() first!');
|
|
|
+ }
|
|
|
+
|
|
|
+ $start = (empty($start)) ? $this->_options['min_font_size'] : $start;
|
|
|
+ $end = (empty($end)) ? $this->_options['max_font_size'] : $end;
|
|
|
+
|
|
|
+ // Run through all possible font sizes until a measurize fails
|
|
|
+ // Not the optimal way. This can be tweaked!
|
|
|
+ for ($i = $start; $i <= $end; $i++) {
|
|
|
+ $this->_options['font_size'] = $i;
|
|
|
+ $res = $this->measurize();
|
|
|
+
|
|
|
+ if ($res === false) {
|
|
|
+ if ($start == $i) {
|
|
|
+ $this->_options['font_size'] = -1;
|
|
|
+ throw new Image_Text_Exception("No possible font size found");
|
|
|
+ }
|
|
|
+ $this->_options['font_size'] -= 1;
|
|
|
+ $this->_measurizedSize = $this->_options['font_size'];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ // Always the last couple of lines is stored here.
|
|
|
+ $this->_lines = $res;
|
|
|
+ }
|
|
|
+ return $this->_options['font_size'];
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Measurize text into the text box
|
|
|
+ *
|
|
|
+ * This method makes your text fit into the defined textbox by measurizing the
|
|
|
+ * lines for your given font-size. You can do this manually before rendering (or
|
|
|
+ * use even Image_Text::autoMeasurize()) or the renderer will do measurizing
|
|
|
+ * automatically.
|
|
|
+ *
|
|
|
+ * @param bool $force Optionally, default is false, set true to force
|
|
|
+ * measurizing.
|
|
|
+ *
|
|
|
+ * @return array Array of measured lines.
|
|
|
+ * @see Image_Text::autoMeasurize()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function measurize($force = false)
|
|
|
+ {
|
|
|
+ if (!$this->_init) {
|
|
|
+ throw new Image_Text_Exception('Not initialized. Call ->init() first!');
|
|
|
+ }
|
|
|
+ $this->_processText();
|
|
|
+
|
|
|
+ // Precaching options
|
|
|
+ $font = $this->_font;
|
|
|
+ $size = $this->_options['font_size'];
|
|
|
+
|
|
|
+ $space = (1 + $this->_options['line_spacing'])
|
|
|
+ * $this->_options['font_size'];
|
|
|
+
|
|
|
+ $max_lines = (int)$this->_options['max_lines'];
|
|
|
+
|
|
|
+ if (($max_lines < 1) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ $block_width = $this->_options['width'];
|
|
|
+ $block_height = $this->_options['height'];
|
|
|
+
|
|
|
+ $colors_cnt = sizeof($this->_colors);
|
|
|
+
|
|
|
+ $text_line = '';
|
|
|
+
|
|
|
+ $lines_cnt = 0;
|
|
|
+
|
|
|
+ $lines = array();
|
|
|
+
|
|
|
+ $text_height = 0;
|
|
|
+ $text_width = 0;
|
|
|
+
|
|
|
+ $i = 0;
|
|
|
+ $para_cnt = 0;
|
|
|
+ $width = 0;
|
|
|
+
|
|
|
+ $beginning_of_line = true;
|
|
|
+
|
|
|
+ // Run through tokens and order them in lines
|
|
|
+ foreach ($this->_tokens as $token) {
|
|
|
+ // Handle new paragraphs
|
|
|
+ if ($token == "\n") {
|
|
|
+ $bounds = imagettfbbox($size, 0, $font, $text_line);
|
|
|
+ if ((++$lines_cnt >= $max_lines) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if ($this->_options['color_mode'] == 'paragraph') {
|
|
|
+ $c = $this->_colors[$para_cnt % $colors_cnt];
|
|
|
+ $i++;
|
|
|
+ } else {
|
|
|
+ $c = $this->_colors[$i++ % $colors_cnt];
|
|
|
+ }
|
|
|
+ $lines[] = array(
|
|
|
+ 'string' => $text_line,
|
|
|
+ 'width' => $bounds[2] - $bounds[0],
|
|
|
+ 'height' => $bounds[1] - $bounds[7],
|
|
|
+ 'bottom_margin' => $bounds[1],
|
|
|
+ 'left_margin' => $bounds[0],
|
|
|
+ 'color' => $c
|
|
|
+ );
|
|
|
+ $text_width = max($text_width, ($bounds[2] - $bounds[0]));
|
|
|
+ $text_height += (int)$space;
|
|
|
+ if (($text_height > $block_height) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ $para_cnt++;
|
|
|
+ $text_line = '';
|
|
|
+ $beginning_of_line = true;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Usual lining up
|
|
|
+
|
|
|
+ if ($beginning_of_line) {
|
|
|
+ $text_line = '';
|
|
|
+ $text_line_next = $token;
|
|
|
+ $beginning_of_line = false;
|
|
|
+ } else {
|
|
|
+ $text_line_next = $text_line . ' ' . $token;
|
|
|
+ }
|
|
|
+ $bounds = imagettfbbox($size, 0, $font, $text_line_next);
|
|
|
+ $prev_width = isset($prev_width) ? $width : 0;
|
|
|
+ $width = $bounds[2] - $bounds[0];
|
|
|
+
|
|
|
+ // Handling of automatic new lines
|
|
|
+ if ($width > $block_width) {
|
|
|
+ if ((++$lines_cnt >= $max_lines) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if ($this->_options['color_mode'] == 'line') {
|
|
|
+ $c = $this->_colors[$i++ % $colors_cnt];
|
|
|
+ } else {
|
|
|
+ $c = $this->_colors[$para_cnt % $colors_cnt];
|
|
|
+ $i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ $lines[] = array(
|
|
|
+ 'string' => $text_line,
|
|
|
+ 'width' => $prev_width,
|
|
|
+ 'height' => $bounds[1] - $bounds[7],
|
|
|
+ 'bottom_margin' => $bounds[1],
|
|
|
+ 'left_margin' => $bounds[0],
|
|
|
+ 'color' => $c
|
|
|
+ );
|
|
|
+ $text_width = max($text_width, ($bounds[2] - $bounds[0]));
|
|
|
+ $text_height += (int)$space;
|
|
|
+ if (($text_height > $block_height) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ $text_line = $token;
|
|
|
+ $bounds = imagettfbbox($size, 0, $font, $text_line);
|
|
|
+ $width = $bounds[2] - $bounds[0];
|
|
|
+ $beginning_of_line = false;
|
|
|
+ } else {
|
|
|
+ $text_line = $text_line_next;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Store remaining line
|
|
|
+ $bounds = imagettfbbox($size, 0, $font, $text_line);
|
|
|
+ $i++;
|
|
|
+ if ($this->_options['color_mode'] == 'line') {
|
|
|
+ $c = $this->_colors[$i % $colors_cnt];
|
|
|
+ } else {
|
|
|
+ $c = $this->_colors[$para_cnt % $colors_cnt];
|
|
|
+ }
|
|
|
+ $lines[] = array(
|
|
|
+ 'string' => $text_line,
|
|
|
+ 'width' => $bounds[2] - $bounds[0],
|
|
|
+ 'height' => $bounds[1] - $bounds[7],
|
|
|
+ 'bottom_margin' => $bounds[1],
|
|
|
+ 'left_margin' => $bounds[0],
|
|
|
+ 'color' => $c
|
|
|
+ );
|
|
|
+
|
|
|
+ // add last line height, but without the line-spacing
|
|
|
+ $text_height += $this->_options['font_size'];
|
|
|
+
|
|
|
+ $text_width = max($text_width, ($bounds[2] - $bounds[0]));
|
|
|
+
|
|
|
+ if (($text_height > $block_height) && !$force) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ $this->_realTextSize = array(
|
|
|
+ 'width' => $text_width, 'height' => $text_height
|
|
|
+ );
|
|
|
+ $this->_measurizedSize = $this->_options['font_size'];
|
|
|
+
|
|
|
+ return $lines;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Render the text in the canvas using the given options.
|
|
|
+ *
|
|
|
+ * This renders the measurized text or automatically measures it first. The
|
|
|
+ * $force parameter can be used to switch of measurizing problems (this may cause
|
|
|
+ * your text being rendered outside a given text box or destroy your image
|
|
|
+ * completely).
|
|
|
+ *
|
|
|
+ * @param bool $force Optional, initially false, set true to silence measurize
|
|
|
+ * errors.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function render($force = false)
|
|
|
+ {
|
|
|
+ if (!$this->_init) {
|
|
|
+ throw new Image_Text_Exception('Not initialized. Call ->init() first!');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!$this->_tokens) {
|
|
|
+ $this->_processText();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (empty($this->_lines)
|
|
|
+ || ($this->_measurizedSize != $this->_options['font_size'])
|
|
|
+ ) {
|
|
|
+ $this->_lines = $this->measurize($force);
|
|
|
+ }
|
|
|
+ $lines = $this->_lines;
|
|
|
+
|
|
|
+ if ($this->_mode === 'auto') {
|
|
|
+ $this->_img = imagecreatetruecolor(
|
|
|
+ $this->_realTextSize['width'],
|
|
|
+ $this->_realTextSize['height']
|
|
|
+ );
|
|
|
+ if (!$this->_img) {
|
|
|
+ throw new Image_Text_Exception('Could not create image canvas.');
|
|
|
+ }
|
|
|
+ $this->_mode = '';
|
|
|
+ $this->setColors($this->_options['color']);
|
|
|
+ }
|
|
|
+
|
|
|
+ $block_width = $this->_options['width'];
|
|
|
+
|
|
|
+ $max_lines = $this->_options['max_lines'];
|
|
|
+
|
|
|
+ $angle = $this->_options['angle'];
|
|
|
+ $radians = round(deg2rad($angle), 3);
|
|
|
+
|
|
|
+ $font = $this->_font;
|
|
|
+ $size = $this->_options['font_size'];
|
|
|
+
|
|
|
+ $line_spacing = $this->_options['line_spacing'];
|
|
|
+
|
|
|
+ $align = $this->_options['halign'];
|
|
|
+
|
|
|
+ $offset = $this->_getOffset();
|
|
|
+
|
|
|
+ $start_x = $offset['x'];
|
|
|
+ $start_y = $offset['y'];
|
|
|
+
|
|
|
+ $sinR = sin($radians);
|
|
|
+ $cosR = cos($radians);
|
|
|
+
|
|
|
+ switch ($this->_options['valign']) {
|
|
|
+ case self::IMAGE_TEXT_ALIGN_TOP:
|
|
|
+ $valign_space = 0;
|
|
|
+ break;
|
|
|
+ case self::IMAGE_TEXT_ALIGN_MIDDLE:
|
|
|
+ $valign_space = ($this->_options['height']
|
|
|
+ - $this->_realTextSize['height']) / 2;
|
|
|
+ break;
|
|
|
+ case self::IMAGE_TEXT_ALIGN_BOTTOM:
|
|
|
+ $valign_space = $this->_options['height']
|
|
|
+ - $this->_realTextSize['height'];
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ $valign_space = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ $space = (1 + $line_spacing) * $size;
|
|
|
+
|
|
|
+ // Adjustment of align + translation of top-left-corner to bottom-left-corner
|
|
|
+ // of first line
|
|
|
+ $new_posx = $start_x + ($sinR * ($valign_space + $size));
|
|
|
+ $new_posy = $start_y + ($cosR * ($valign_space + $size));
|
|
|
+
|
|
|
+ $lines_cnt = min($max_lines, sizeof($lines));
|
|
|
+
|
|
|
+ $bboxes = array();
|
|
|
+ // Go thorugh lines for rendering
|
|
|
+ for ($i = 0; $i < $lines_cnt; $i++) {
|
|
|
+
|
|
|
+ // Calc the new start X and Y (only for line>0)
|
|
|
+ // the distance between the line above is used
|
|
|
+ if ($i > 0) {
|
|
|
+ $new_posx += $sinR * $space;
|
|
|
+ $new_posy += $cosR * $space;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Calc the position of the 1st letter. We can then get the left and
|
|
|
+ // bottom margins 'i' is really not the same than 'j' or 'g'.
|
|
|
+ $left_margin = $lines[$i]['left_margin'];
|
|
|
+ $line_width = $lines[$i]['width'];
|
|
|
+
|
|
|
+ // Calc the position using the block width, the current line width and
|
|
|
+ // obviously the angle. That gives us the offset to slide the line.
|
|
|
+ switch ($align) {
|
|
|
+ case self::IMAGE_TEXT_ALIGN_LEFT:
|
|
|
+ $hyp = 0;
|
|
|
+ break;
|
|
|
+ case self::IMAGE_TEXT_ALIGN_RIGHT:
|
|
|
+ $hyp = $block_width - $line_width - $left_margin;
|
|
|
+ break;
|
|
|
+ case self::IMAGE_TEXT_ALIGN_CENTER:
|
|
|
+ $hyp = ($block_width - $line_width) / 2 - $left_margin;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ $hyp = 0;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ $posx = $new_posx + $cosR * $hyp;
|
|
|
+ $posy = $new_posy - $sinR * $hyp;
|
|
|
+
|
|
|
+ $c = $lines[$i]['color'];
|
|
|
+
|
|
|
+ // Render textline
|
|
|
+ $bboxes[] = imagettftext(
|
|
|
+ $this->_img, $size, $angle, $posx, $posy,
|
|
|
+ $c, $font, $lines[$i]['string']
|
|
|
+ );
|
|
|
+ }
|
|
|
+ $this->_bbox = $bboxes;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Return the image ressource.
|
|
|
+ *
|
|
|
+ * Get the image canvas.
|
|
|
+ *
|
|
|
+ * @return resource Used image resource
|
|
|
+ */
|
|
|
+ public function getImg()
|
|
|
+ {
|
|
|
+ return $this->_img;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Display the image (send it to the browser).
|
|
|
+ *
|
|
|
+ * This will output the image to the users browser. You can use the standard
|
|
|
+ * IMAGETYPE_* constants to determine which image type will be generated.
|
|
|
+ * Optionally you can save your image to a destination you set in the options.
|
|
|
+ *
|
|
|
+ * @param bool $save Save or not the image on printout.
|
|
|
+ * @param bool $free Free the image on exit.
|
|
|
+ *
|
|
|
+ * @return bool True on success
|
|
|
+ * @see Image_Text::save()
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function display($save = false, $free = false)
|
|
|
+ {
|
|
|
+ if (!headers_sent()) {
|
|
|
+ header(
|
|
|
+ "Content-type: " .
|
|
|
+ image_type_to_mime_type($this->_options['image_type'])
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ throw new Image_Text_Exception('Header already sent.');
|
|
|
+ }
|
|
|
+ switch ($this->_options['image_type']) {
|
|
|
+ case IMAGETYPE_PNG:
|
|
|
+ $imgout = 'imagepng';
|
|
|
+ break;
|
|
|
+ case IMAGETYPE_JPEG:
|
|
|
+ $imgout = 'imagejpeg';
|
|
|
+ break;
|
|
|
+ case IMAGETYPE_BMP:
|
|
|
+ $imgout = 'imagebmp';
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new Image_Text_Exception('Unsupported image type.');
|
|
|
+ }
|
|
|
+ if ($save) {
|
|
|
+ $imgout($this->_img);
|
|
|
+ $this->save();
|
|
|
+ } else {
|
|
|
+ $imgout($this->_img);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ($free) {
|
|
|
+ $res = imagedestroy($this->_img);
|
|
|
+ if (!$res) {
|
|
|
+ throw new Image_Text_Exception('Destroying image failed.');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Save image canvas.
|
|
|
+ *
|
|
|
+ * Saves the image to a given destination. You can leave out the destination file
|
|
|
+ * path, if you have the option for that set correctly. Saving is possible with
|
|
|
+ * the display() method, too.
|
|
|
+ *
|
|
|
+ * @param bool|string $destFile The destination to save to (optional, uses
|
|
|
+ * options value else).
|
|
|
+ *
|
|
|
+ * @see Image_Text::display()
|
|
|
+ * @return void
|
|
|
+ * @throws Image_Text_Exception
|
|
|
+ */
|
|
|
+ public function save($destFile = false)
|
|
|
+ {
|
|
|
+ if (!$destFile) {
|
|
|
+ $destFile = $this->_options['dest_file'];
|
|
|
+ }
|
|
|
+ if (!$destFile) {
|
|
|
+ throw new Image_Text_Exception("Invalid desitination file.");
|
|
|
+ }
|
|
|
+
|
|
|
+ switch ($this->_options['image_type']) {
|
|
|
+ case IMAGETYPE_PNG:
|
|
|
+ $imgout = 'imagepng';
|
|
|
+ break;
|
|
|
+ case IMAGETYPE_JPEG:
|
|
|
+ $imgout = 'imagejpeg';
|
|
|
+ break;
|
|
|
+ case IMAGETYPE_BMP:
|
|
|
+ $imgout = 'imagebmp';
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new Image_Text_Exception('Unsupported image type.');
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ $res = $imgout($this->_img, $destFile);
|
|
|
+ if (!$res) {
|
|
|
+ throw new Image_Text_Exception('Saving file failed.');
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Get completely translated offset for text rendering.
|
|
|
+ *
|
|
|
+ * Get completely translated offset for text rendering. Important for usage of
|
|
|
+ * center coords and angles.
|
|
|
+ *
|
|
|
+ * @return array Array of x/y coordinates.
|
|
|
+ */
|
|
|
+ private function _getOffset()
|
|
|
+ {
|
|
|
+ // Presaving data
|
|
|
+ $width = $this->_options['width'];
|
|
|
+ $height = $this->_options['height'];
|
|
|
+ $angle = $this->_options['angle'];
|
|
|
+ $x = $this->_options['x'];
|
|
|
+ $y = $this->_options['y'];
|
|
|
+ // Using center coordinates
|
|
|
+ if (!empty($this->_options['cx']) && !empty($this->_options['cy'])) {
|
|
|
+ $cx = $this->_options['cx'];
|
|
|
+ $cy = $this->_options['cy'];
|
|
|
+ // Calculation top left corner
|
|
|
+ $x = $cx - ($width / 2);
|
|
|
+ $y = $cy - ($height / 2);
|
|
|
+ // Calculating movement to keep the center point on himslf after rotation
|
|
|
+ if ($angle) {
|
|
|
+ $ang = deg2rad($angle);
|
|
|
+ // Vector from the top left cornern ponting to the middle point
|
|
|
+ $vA = array(($cx - $x), ($cy - $y));
|
|
|
+ // Matrix to rotate vector
|
|
|
+ // sinus and cosinus
|
|
|
+ $sin = round(sin($ang), 14);
|
|
|
+ $cos = round(cos($ang), 14);
|
|
|
+ // matrix
|
|
|
+ $mRot = array(
|
|
|
+ $cos, (-$sin),
|
|
|
+ $sin, $cos
|
|
|
+ );
|
|
|
+ // Multiply vector with matrix to get the rotated vector
|
|
|
+ // This results in the location of the center point after rotation
|
|
|
+ $vB = array(
|
|
|
+ ($mRot[0] * $vA[0] + $mRot[2] * $vA[0]),
|
|
|
+ ($mRot[1] * $vA[1] + $mRot[3] * $vA[1])
|
|
|
+ );
|
|
|
+ // To get the movement vector, we subtract the original middle
|
|
|
+ $vC = array(
|
|
|
+ ($vA[0] - $vB[0]),
|
|
|
+ ($vA[1] - $vB[1])
|
|
|
+ );
|
|
|
+ // Finally we move the top left corner coords there
|
|
|
+ $x += $vC[0];
|
|
|
+ $y += $vC[1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return array('x' => (int)round($x, 0), 'y' => (int)round($y, 0));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Convert a color to an array.
|
|
|
+ *
|
|
|
+ * The following colors syntax must be used:
|
|
|
+ * "#08ffff00" hexadecimal format with alpha channel (08)
|
|
|
+ *
|
|
|
+ * @param string $scolor string of colorcode.
|
|
|
+ *
|
|
|
+ * @see Image_Text::IMAGE_TEXT_REGEX_HTMLCOLOR
|
|
|
+ * @return bool|array false if string can't be converted to array
|
|
|
+ */
|
|
|
+ public static function convertString2RGB($scolor)
|
|
|
+ {
|
|
|
+ if (preg_match(self::IMAGE_TEXT_REGEX_HTMLCOLOR, $scolor, $matches)) {
|
|
|
+ return array(
|
|
|
+ 'r' => hexdec($matches[2]),
|
|
|
+ 'g' => hexdec($matches[3]),
|
|
|
+ 'b' => hexdec($matches[4]),
|
|
|
+ 'a' => hexdec(!empty($matches[1]) ? $matches[1] : 0),
|
|
|
+ );
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Extract the tokens from the text.
|
|
|
+ *
|
|
|
+ * @return void
|
|
|
+ */
|
|
|
+ private function _processText()
|
|
|
+ {
|
|
|
+ if (!isset($this->_text)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ $this->_tokens = array();
|
|
|
+
|
|
|
+ // Normalize linebreak to "\n"
|
|
|
+ $this->_text = preg_replace("[\r\n]", "\n", $this->_text);
|
|
|
+
|
|
|
+ // Get each paragraph
|
|
|
+ $paras = explode("\n", $this->_text);
|
|
|
+
|
|
|
+ // loop though the paragraphs
|
|
|
+ // and get each word (token)
|
|
|
+ foreach ($paras as $para) {
|
|
|
+ $words = explode(' ', $para);
|
|
|
+ foreach ($words as $word) {
|
|
|
+ $this->_tokens[] = $word;
|
|
|
+ }
|
|
|
+ // add a "\n" to mark the end of a paragraph
|
|
|
+ $this->_tokens[] = "\n";
|
|
|
+ }
|
|
|
+ // we do not need an end paragraph as the last token
|
|
|
+ array_pop($this->_tokens);
|
|
|
+ }
|
|
|
+}
|