linea21-externals
[ class tree: linea21-externals ] [ index: linea21-externals ] [ all elements ]
Packages:
linea21-core
linea21-externals
linea21-languages
linea21-modules
linea21-templates
linea21-utils

Source for file gd.class.php

Documentation is available at gd.class.php

  1. <?php
  2. /*
  3.  * This work is hereby released into the Public Domain.
  4.  * To view a copy of the public domain dedication,
  5.  * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
  6.  * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
  7.  *
  8.  */
  9.  
  10. require_once dirname(__FILE__)."/../Driver.class.php";
  11.  
  12. /**
  13.  * Draw your objects
  14.  *
  15.  * @package linea21.externals
  16.  * @subpackage artichow
  17.  */
  18.  
  19. class awGDDriver extends Driver {
  20.  
  21.   /**
  22.    * A GD resource
  23.    *
  24.    * @var $resource 
  25.    */
  26.   public $resource;
  27.  
  28.   public function __construct() {
  29.     parent::__construct();
  30.  
  31.     $this->driverString = 'gd';
  32.   }
  33.  
  34.   public function init(awImage $image) {
  35.  
  36.     if($this->resource === NULL) {
  37.           
  38.       $this->setImageSize($image->width, $image->height);
  39.           
  40.       // Create image
  41.       $this->resource = imagecreatetruecolor($this->imageWidth, $this->imageHeight);
  42.       if(!$this->resource) {
  43.         awImage::drawError("Class Image: Unable to create a graph.");
  44.       }
  45.           
  46.       imagealphablending($this->resource, TRUE);
  47.           
  48.       // Antialiasing is now handled by the Driver object
  49.       $this->setAntiAliasing($image->getAntiAliasing());
  50.           
  51.       // Original color
  52.       $this->filledRectangle(
  53.       new awWhite,
  54.       new awLine(
  55.       new awPoint(0, 0),
  56.       new awPoint($this->imageWidth, $this->imageHeight)
  57.       )
  58.       );
  59.           
  60.       $shadow = $image->shadow;
  61.       if($shadow !== NULL) {
  62.         $shadow = $shadow->getSpace();
  63.         $p1 = new awPoint($shadow->left, $shadow->top);
  64.         $p2 = new awPoint($this->imageWidth - $shadow->right - 1, $this->imageHeight - $shadow->bottom - 1);
  65.  
  66.  
  67.         // Draw image background
  68.         $this->filledRectangle($image->getBackground(), new awLine($p1, $p2));
  69.  
  70.         // Draw image border
  71.         $image->border->rectangle($this, $p1, $p2);
  72.       }
  73.           
  74.     }
  75.   }
  76.  
  77.   public function initFromFile(awFileImage $fileImage, $file) {
  78.  
  79.     $image = @getimagesize((string)$file);
  80.  
  81.     if($image and in_array($image[2], array(2, 3))) {
  82.  
  83.       $fileImage->setSize($image[0], $image[1]);
  84.           
  85.       switch($image[2]) {
  86.             
  87.         case 2 :
  88.           $this->resource = imagecreatefromjpeg($file);
  89.           break;
  90.               
  91.         case 3 :
  92.           $this->resource = imagecreatefrompng($file);
  93.           break;
  94.               
  95.       }
  96.  
  97.       $this->setImageSize($fileImage->width, $fileImage->height);
  98.     } else {
  99.       awImage::drawError("Class FileImage: Artichow does not support the format of this image (must be in PNG or JPEG)");
  100.     }
  101.   }
  102.  
  103.   public function setImageSize($width, $height) {
  104.  
  105.     $this->imageWidth = $width;
  106.     $this->imageHeight = $height;
  107.  
  108.   }
  109.  
  110.   public function setPosition($x, $y) {
  111.  
  112.     // Calculate absolute position
  113.     $this->x = round($x * $this->imageWidth - $this->w / 2);
  114.     $this->y = round($y * $this->imageHeight - $this->h / 2);
  115.  
  116.   }
  117.  
  118.   public function setAbsPosition($x, $y) {
  119.  
  120.     $this->x = $x;
  121.     $this->y = $y;
  122.  
  123.   }
  124.  
  125.   public function movePosition($x, $y) {
  126.  
  127.     $this->x += (int)$x;
  128.     $this->y += (int)$y;
  129.  
  130.   }
  131.  
  132.   public function setSize($w, $h) {
  133.  
  134.     // Calcul absolute size
  135.     $this->w = round($w * $this->imageWidth);
  136.     $this->h = round($h * $this->imageHeight);
  137.  
  138.     return $this->getSize();
  139.  
  140.   }
  141.  
  142.   public function setAbsSize($w, $h) {
  143.  
  144.     $this->w = $w;
  145.     $this->h = $h;
  146.  
  147.     return $this->getSize();
  148.  
  149.   }
  150.  
  151.   public function getSize() {
  152.  
  153.     return array($this->w, $this->h);
  154.  
  155.   }
  156.  
  157.   public function setAntiAliasing($bool) {
  158.  
  159.     if(function_exists('imageantialias')) {
  160.       imageantialias($this->resource, (bool)$bool);
  161.  
  162.       $this->antiAliasing = (bool)$bool;
  163.     } elseif($bool == true) {
  164.       awImage::drawErrorFile('missing-anti-aliasing');
  165.     }
  166.   }
  167.  
  168.   public function getColor(awColor $color) {
  169.  
  170.     if($color->alpha === 0 or function_exists('imagecolorallocatealpha') === FALSE) {
  171.       $gdColor = imagecolorallocate($this->resource, $color->red, $color->green, $color->blue);
  172.     } else {
  173.       $gdColor = imagecolorallocatealpha($this->resource, $color->red, $color->green, $color->blue, $color->alpha);
  174.     }
  175.  
  176.     return $gdColor;
  177.   }
  178.  
  179.   public function copyImage(awImage $image, awPoint $p1, awPoint $p2) {
  180.  
  181.     list($x1, $y1) = $p1->getLocation();
  182.     list($x2, $y2) = $p2->getLocation();
  183.  
  184.     $driver = $image->getDriver();
  185.     imagecopy($this->resource, $driver->resource, $this->x + $x1, $this->y + $y1, 0, 0, $x2 - $x1, $y2 - $y1);
  186.  
  187.   }
  188.  
  189.   public function copyResizeImage(awImage $image, awPoint $d1, awPoint $d2, awPoint $s1, awPoint $s2, $resample = TRUE) {
  190.  
  191.     if($resample) {
  192.       $function = 'imagecopyresampled';
  193.     } else {
  194.       $function = 'imagecopyresized';
  195.     }
  196.  
  197.     $driver = $image->getDriver();
  198.  
  199.     $function(
  200.     $this->resource,
  201.     $driver->resource,
  202.     $this->x + $d1->x, $this->y + $d1->y,
  203.     $s1->x, $s1->y,
  204.     $d2->x - $d1->x, $d2->y - $d1->y,
  205.     $s2->x - $s1->x, $s2->y - $s1->y
  206.     );
  207.  
  208.   }
  209.  
  210.   public function string(awText $text, awPoint $point, $width = NULL) {
  211.  
  212.     $font = $text->getFont();
  213.  
  214.     // Can we deal with that font?
  215.     /**
  216.     if($this->isCompatibleWithFont($font) === FALSE) {
  217.     awImage::drawError('Class GDDriver: Incompatible font type (\''.get_class($font).'\')');
  218.     }*/
  219.  
  220.     // Check which FontDriver to use
  221.     if($font instanceof awPHPFont) {
  222.       $fontDriver = $this->phpFontDriver;
  223.     } else {
  224.       $fontDriver = $this->fileFontDriver;
  225.     }
  226.  
  227.     if($text->getBackground() !== NULL or $text->border->visible()) {
  228.  
  229.       list($left, $right, $top, $bottom) = $text->getPadding();
  230.  
  231.       $textWidth = $fontDriver->getTextWidth($text, $this);
  232.       $textHeight = $fontDriver->getTextHeight($text, $this);
  233.           
  234.       $x1 = floor($point->x - $left);
  235.       $y1 = floor($point->y - $top);
  236.       $x2 = $x1 + $textWidth + $left + $right;
  237.       $y2 = $y1 + $textHeight + $top + $bottom;
  238.           
  239.       $this->filledRectangle(
  240.       $text->getBackground(),
  241.       awLine::build($x1, $y1, $x2, $y2)
  242.       );
  243.           
  244.       $text->border->rectangle(
  245.       $this,
  246.       new awPoint($x1 - 1, $y1 - 1),
  247.       new awPoint($x2 + 1, $y2 + 1)
  248.       );
  249.           
  250.     }
  251.  
  252.     $fontDriver->string($this, $text, $point, $width);
  253.  
  254.   }
  255.  
  256.   public function point(awColor $color, awPoint $p) {
  257.  
  258.     if($p->isHidden() === FALSE) {
  259.       $rgb = $this->getColor($color);
  260.       imagesetpixel($this->resource, $this->x + round($p->x), $this->y + round($p->y), $rgb);
  261.     }
  262.  
  263.   }
  264.  
  265.   public function line(awColor $color, awLine $line) {
  266.  
  267.     if($line->thickness > 0 and $line->isHidden() === FALSE) {
  268.  
  269.       $rgb = $this->getColor($color);
  270.       $thickness = $line->thickness;
  271.           
  272.       list($p1, $p2) = $line->getLocation();
  273.           
  274.       $this->startThickness($thickness);
  275.           
  276.       switch($line->getStyle()) {
  277.             
  278.         case awLine::SOLID :
  279.           imageline($this->resource, $this->x + round($p1->x), $this->y + round($p1->y), $this->x + round($p2->x), $this->y + round($p2->y), $rgb);
  280.           break;
  281.               
  282.         case awLine::DOTTED :
  283.           $size = sqrt(pow($p2->y - $p1->y, 2) + pow($p2->x - $p1->x, 2));
  284.           $cos = ($p2->x - $p1->x) / $size;
  285.           $sin = ($p2->y - $p1->y) / $size;
  286.           for($i = 0; $i <= $size; $i += 2) {
  287.             $p = new awPoint(
  288.             round($i * $cos + $p1->x),
  289.             round($i * $sin + $p1->y)
  290.             );
  291.             $this->point($color, $p);
  292.           }
  293.           break;
  294.               
  295.         case awLine::DASHED :
  296.           $width = $p2->x - $p1->x;
  297.           $height = $p2->y - $p1->y;
  298.           $size = sqrt(pow($height, 2) + pow($width, 2));
  299.               
  300.           if($size == 0) {
  301.             return;
  302.           }
  303.               
  304.           $cos = $width / $size;
  305.           $sin = $height / $size;
  306.               
  307.           $functionX = ($width  > 0) ? 'min' : 'max';
  308.           $functionY = ($height > 0) ? 'min' : 'max';
  309.               
  310.           for($i = 0; $i <= $size; $i += 6) {
  311.  
  312.             $t1 = new awPoint(
  313.             round($i * $cos + $p1->x),
  314.             round($i * $sin + $p1->y)
  315.             );
  316.  
  317.             $t2 = new awPoint(
  318.             round($functionX(($i + 3) * $cos, $width) + $p1->x),
  319.             round($functionY(($i + 3) * $sin, $height) + $p1->y)
  320.             );
  321.  
  322.             $this->line($color, new awLine($t1, $t2));
  323.  
  324.           }
  325.           break;
  326.               
  327.       }
  328.           
  329.       $this->stopThickness($thickness);
  330.           
  331.     }
  332.  
  333.   }
  334.  
  335.   public function arc(awColor $color, awPoint $center, $width, $height, $from, $to) {
  336.  
  337.     imagefilledarc(
  338.     $this->resource,
  339.     $this->x + $center->x, $this->y + $center->y,
  340.     $width, $height,
  341.     $from, $to,
  342.     $this->getColor($color),
  343.     IMG_ARC_EDGED | IMG_ARC_NOFILL
  344.     );
  345.  
  346.   }
  347.  
  348.   public function filledArc(awColor $color, awPoint $center, $width, $height, $from, $to) {
  349.  
  350.     imagefilledarc(
  351.     $this->resource,
  352.     $this->x + $center->x, $this->y + $center->y,
  353.     $width, $height,
  354.     $from, $to,
  355.     $this->getColor($color),
  356.     IMG_ARC_PIE
  357.     );
  358.  
  359.   }
  360.  
  361.   public function ellipse(awColor $color, awPoint $center, $width, $height) {
  362.  
  363.     list($x, $y) = $center->getLocation();
  364.  
  365.     $rgb = $this->getColor($color);
  366.     imageellipse(
  367.     $this->resource,
  368.     $this->x + $x,
  369.     $this->y + $y,
  370.     $width,
  371.     $height,
  372.     $rgb
  373.     );
  374.  
  375.   }
  376.  
  377.   public function filledEllipse($background, awPoint $center, $width, $height) {
  378.  
  379.     if($background instanceof awColor) {
  380.  
  381.       list($x, $y) = $center->getLocation();
  382.  
  383.       $rgb = $this->getColor($background);
  384.           
  385.       imagefilledellipse(
  386.       $this->resource,
  387.       $this->x + $x,
  388.       $this->y + $y,
  389.       $width,
  390.       $height,
  391.       $rgb
  392.       );
  393.           
  394.     } else if($background instanceof awGradient) {
  395.  
  396.       list($x, $y) = $center->getLocation();
  397.           
  398.       $x1 = $x - round($width / 2);
  399.       $y1 = $y - round($height / 2);
  400.       $x2 = $x1 + $width;
  401.       $y2 = $y1 + $height;
  402.  
  403.       $gradientDriver = new awGDGradientDriver($this);
  404.       $gradientDriver->filledEllipse(
  405.       $background,
  406.       $x1, $y1,
  407.       $x2, $y2
  408.       );
  409.  
  410.     }
  411.  
  412.   }
  413.  
  414.   public function rectangle(awColor $color, awLine $line) {
  415.  
  416.     list($p1, $p2) = $line->getLocation();
  417.  
  418.     switch($line->getStyle()) {
  419.  
  420.       case awLine::SOLID :
  421.         $thickness = $line->getThickness();
  422.         $this->startThickness($thickness);
  423.         $rgb = $this->getColor($color);
  424.         imagerectangle($this->resource, $this->x + $p1->x, $this->y + $p1->y, $this->x + $p2->x, $this->y + $p2->y, $rgb);
  425.         $this->stopThickness($thickness);
  426.         break;
  427.             
  428.       default :
  429.         /* <php5> */
  430.         $side = clone $line;
  431.         /* </php5> */
  432.  
  433.         /* <php4> --
  434.          $side = new Line($p1, $p2);
  435.          -- </php4> */
  436.  
  437.         // Top side
  438.         $side->setLocation(
  439.         new awPoint($p1->x, $p1->y),
  440.         new awPoint($p2->x, $p1->y)
  441.         );
  442.         $this->line($color, $side);
  443.  
  444.         // Right side
  445.         $side->setLocation(
  446.         new awPoint($p2->x, $p1->y),
  447.         new awPoint($p2->x, $p2->y)
  448.         );
  449.         $this->line($color, $side);
  450.  
  451.         // Bottom side
  452.         $side->setLocation(
  453.         new awPoint($p1->x, $p2->y),
  454.         new awPoint($p2->x, $p2->y)
  455.         );
  456.         $this->line($color, $side);
  457.  
  458.         // Left side
  459.         $side->setLocation(
  460.         new awPoint($p1->x, $p1->y),
  461.         new awPoint($p1->x, $p2->y)
  462.         );
  463.         $this->line($color, $side);
  464.             
  465.         break;
  466.  
  467.     }
  468.  
  469.   }
  470.  
  471.   public function filledRectangle($background, awLine $line) {
  472.  
  473.     $p1 = $line->p1;
  474.     $p2 = $line->p2;
  475.  
  476.     if($background instanceof awColor) {
  477.       $rgb = $this->getColor($background);
  478.       imagefilledrectangle($this->resource, $this->x + $p1->x, $this->y + $p1->y, $this->x + $p2->x, $this->y + $p2->y, $rgb);
  479.     } else if($background instanceof awGradient) {
  480.       $gradientDriver = new awGDGradientDriver($this);
  481.       $gradientDriver->filledRectangle($background, $p1, $p2);
  482.     }
  483.  
  484.   }
  485.  
  486.   public function polygon(awColor $color, awPolygon $polygon) {
  487.  
  488.     switch($polygon->getStyle()) {
  489.  
  490.       case awPolygon::SOLID :
  491.         $thickness = $polygon->getThickness();
  492.         $this->startThickness($thickness);
  493.         $points = $this->getPolygonPoints($polygon);
  494.         $rgb = $this->getColor($color);
  495.         imagepolygon($this->resource, $points, $polygon->count(), $rgb);
  496.         $this->stopThickness($thickness);
  497.         break;
  498.  
  499.       default :
  500.             
  501.         if($polygon->count() > 1) {
  502.  
  503.           $prev = $polygon->get(0);
  504.               
  505.           $line = new awLine;
  506.           $line->setStyle($polygon->getStyle());
  507.           $line->setThickness($polygon->getThickness());
  508.               
  509.           for($i = 1; $i < $polygon->count(); $i++) {
  510.             $current = $polygon->get($i);
  511.             $line->setLocation($prev, $current);
  512.             $this->line($color, $line);
  513.             $prev = $current;
  514.           }
  515.               
  516.           // Close the polygon
  517.           $line->setLocation($prev, $polygon->get(0));
  518.           $this->line($color, $line);
  519.               
  520.         }
  521.  
  522.     }
  523.  
  524.   }
  525.  
  526.   public function filledPolygon($background, awPolygon $polygon) {
  527.  
  528.     if($background instanceof awColor) {
  529.           
  530.       $points = $this->getPolygonPoints($polygon);
  531.       $rgb = $this->getColor($background);
  532.           
  533.       imagefilledpolygon($this->resource, $points, $polygon->count(), $rgb);
  534.           
  535.     } else if($background instanceof awGradient) {
  536.           
  537.       $gradientDriver = new awGDGradientDriver($this);
  538.       $gradientDriver->filledPolygon($background, $polygon);
  539.           
  540.     }
  541.  
  542.   }
  543.  
  544.   public function send(awImage $image) {
  545.  
  546.     $this->drawImage($image);
  547.  
  548.   }
  549.  
  550.   public function get(awImage $image) {
  551.  
  552.     return $this->drawImage($image, TRUE, FALSE);
  553.  
  554.   }
  555.  
  556.   public function getTextWidth(awText $text) {
  557.     $font = $text->getFont();
  558.  
  559.     if($font instanceof awPHPFont) {
  560.       $fontDriver = $this->phpFontDriver;
  561.     } else {
  562.       $fontDriver = $this->fileFontDriver;
  563.     }
  564.  
  565.     return $fontDriver->getTextWidth($text, $this);
  566.   }
  567.  
  568.   public function getTextHeight(awText $text) {
  569.     $font = $text->getFont();
  570.  
  571.     if($font instanceof awPHPFont) {
  572.       $fontDriver = $this->phpFontDriver;
  573.     } else {
  574.       $fontDriver = $this->fileFontDriver;
  575.     }
  576.  
  577.     return $fontDriver->getTextHeight($text, $this);
  578.   }
  579.  
  580.   protected function isCompatibleWithFont(awFont $font) {
  581.     if($font instanceof awFDBFont) {
  582.       return FALSE;
  583.     } else {
  584.       return TRUE;
  585.     }
  586.   }
  587.  
  588.   private function drawImage(awImage $image, $return = FALSE, $header = TRUE) {
  589.  
  590.     $format = $image->getFormatString();
  591.  
  592.     // Test if format is available
  593.     if((imagetypes() & $image->getFormat()) === FALSE) {
  594.       awImage::drawError("Class Image: Format '".$format."' is not available on your system. Check that your PHP has been compiled with the good libraries.");
  595.     }
  596.  
  597.     // Get some infos about this image
  598.     switch($format) {
  599.       case 'jpeg' :
  600.         $function = 'imagejpeg';
  601.         break;
  602.       case 'png' :
  603.         $function = 'imagepng';
  604.         break;
  605.       case 'gif' :
  606.         $function = 'imagegif';
  607.         break;
  608.     }
  609.  
  610.     // Send headers to the browser
  611.     if($header === TRUE) {
  612.       $image->sendHeaders();
  613.     }
  614.  
  615.     if($return) {
  616.       ob_start();
  617.     }
  618.  
  619.     $function($this->resource);
  620.  
  621.     if($return) {
  622.       return ob_get_clean();
  623.     }
  624.   }
  625.  
  626.   private function getPolygonPoints(awPolygon $polygon) {
  627.  
  628.     $points = array();
  629.  
  630.     foreach($polygon->all() as $point) {
  631.       $points[] = $point->x + $this->x;
  632.       $points[] = $point->y + $this->y;
  633.     }
  634.  
  635.     return $points;
  636.  
  637.   }
  638.  
  639.   private function startThickness($thickness) {
  640.  
  641.     if($thickness > 1) {
  642.  
  643.       // Beurk :'(
  644.       if($this->antiAliasing and function_exists('imageantialias')) {
  645.         imageantialias($this->resource, FALSE);
  646.       }
  647.       imagesetthickness($this->resource, $thickness);
  648.           
  649.     }
  650.  
  651.   }
  652.  
  653.   private function stopThickness($thickness) {
  654.  
  655.     if($thickness > 1) {
  656.  
  657.       if($this->antiAliasing and function_exists('imageantialias')) {
  658.         imageantialias($this->resource, TRUE);
  659.       }
  660.       imagesetthickness($this->resource, 1);
  661.           
  662.     }
  663.  
  664.   }
  665.  
  666.  
  667. }
  668.  
  669. registerClass('GDDriver');
  670.  
  671. /**
  672.  * To your gradients
  673.  *
  674.  * @package linea21.externals
  675.  * @subpackage artichow
  676.  */
  677.  
  678. class awGDGradientDriver {
  679.  
  680.   /**
  681.    * A driver
  682.    *
  683.    * @var awGDDriver 
  684.    */
  685.   protected $driver;
  686.  
  687.   /**
  688.    * Build your GDGradientDriver
  689.    *
  690.    * @var awGDDriver $driver 
  691.    */
  692.   public function __construct(awGDDriver $driver) {
  693.  
  694.     $this->driver = $driver;
  695.  
  696.   }
  697.  
  698.   public function drawFilledFlatTriangle(awGradient $gradient, awPoint $a, awPoint $b, awPoint $c) {
  699.  
  700.     if($gradient->angle !== 0) {
  701.       awImage::drawError("Class GDGradientDriver: Flat triangles can only be used with 0 degree gradients.");
  702.     }
  703.  
  704.     // Look for right-angled triangle
  705.     if($a->x !== $b->x and $b->x !== $c->x) {
  706.       awImage::drawError("Class GDGradientDriver: Not right-angled flat triangles are not supported yet.");
  707.     }
  708.  
  709.     if($a->x === $b->x) {
  710.       $d = $a;
  711.       $e = $c;
  712.     } else {
  713.       $d = $c;
  714.       $e = $a;
  715.     }
  716.  
  717.     $this->init($gradient, $b->y - $d->y);
  718.  
  719.     for($i = $c->y + 1; $i < $b->y; $i++) {
  720.           
  721.       $color = $this->color($i - $d->y);
  722.       $pos = ($i - $d->y) / ($b->y - $d->y);
  723.           
  724.       $p1 = new awPoint($e->x, $i);
  725.       $p2 = new awPoint(1 + floor($e->x - $pos * ($e->x - $d->x)), $i);
  726.           
  727.       $this->driver->filledRectangle($color, new awLine($p1, $p2));
  728.           
  729.       unset($color);
  730.           
  731.     }
  732.  
  733.   }
  734.  
  735.   protected function drawFilledTriangle(awGradient $gradient, awPolygon $polygon) {
  736.  
  737.     if($gradient->angle === 0) {
  738.       $this->drawFilledTriangleVertically($gradient, $polygon);
  739.     } elseif($gradient->angle === 90) {
  740.       $this->drawFilledTriangleHorizontally($gradient, $polygon);
  741.     }
  742.  
  743.   }
  744.  
  745.   private function drawFilledTriangleVertically(awGradient $gradient, awPolygon $polygon) {
  746.     list($yMin, $yMax) = $polygon->getBoxYRange();
  747.  
  748.     $this->init($gradient, $yMax - $yMin);
  749.  
  750.     // Get the triangle line we will draw our lines from
  751.     $fromLine = NULL;
  752.     $lines = $polygon->getLines();
  753.  
  754.     $count = count($lines);
  755.         
  756.     // Pick the side of the triangle going from the top
  757.     // to the bottom of the surrounding box
  758.     for($i = 0; $i < $count; $i++) {
  759.       if($lines[$i]->isTopToBottom($polygon)) {
  760.         list($fromLine) = array_splice($lines, $i, 1);
  761.         break;
  762.       }
  763.     }
  764.  
  765.     // If for some reason the three points are aligned,
  766.     // $fromLine will still be NULL
  767.     if($fromLine === NULL) {
  768.       return;
  769.     }
  770.  
  771.     $fillLine = NULL;
  772.     for($y = round($yMin); $y < round($yMax); $y++) {
  773.           
  774.       $fromX = $fromLine->getXFrom($y);
  775.           
  776.       $toX = array();
  777.       foreach($lines as $line) {
  778.         $xValue = $line->getXFrom($y);
  779.  
  780.         if(!is_null($xValue)) {
  781.           $toX[] = $xValue;
  782.         }
  783.       }
  784.           
  785.       if(count($toX) === 1) {
  786.         $fillLine = new Line(
  787.         new Point($fromX, $y),
  788.         new Point($toX[0], $y)
  789.         );
  790.       } else {
  791.             
  792.         $line1 = new Line(
  793.         new Point($fromX, $y),
  794.         new Point($toX[0], $y)
  795.         );
  796.         $line2 = new  Line(
  797.         new Point($fromX, $y),
  798.         new Point($toX[1], $y)
  799.         );
  800.             
  801.         if($line1->getSize() < $line2->getSize()) {
  802.           $fillLine = $line1;
  803.         } else {
  804.           $fillLine = $line2;
  805.         }
  806.       }
  807.           
  808.       if(!$fillLine->isPoint()) {
  809.         $color = $this->color($y - $yMin);
  810.         $this->driver->line($color, $fillLine);
  811.  
  812.         unset($color);
  813.       }
  814.     }
  815.  
  816.   }
  817.  
  818.   private function drawFilledTriangleHorizontally(awGradient $gradient, awPolygon $polygon) {
  819.     list($xMin, $xMax) = $polygon->getBoxXRange();
  820.  
  821.     $this->init($gradient, $xMax - $xMin);
  822.  
  823.     // Get the triangle line we will draw our lines from
  824.     $fromLine = NULL;
  825.     $lines = $polygon->getLines();
  826.  
  827.     $count = count($lines);
  828.         
  829.     // Pick the side of the triangle going all the way
  830.     // from the left side to the right side of the surrounding box
  831.     for($i = 0; $i < $count; $i++) {
  832.       if($lines[$i]->isLeftToRight($polygon)) {
  833.         list($fromLine) = array_splice($lines, $i, 1);
  834.         break;
  835.       }
  836.     }
  837.  
  838.     // If for some reason the three points are aligned,
  839.     // $fromLine will still be NULL
  840.     if($fromLine === NULL) {
  841.       return;
  842.     }
  843.  
  844.     $fillLine = NULL;
  845.     for($x = round($xMin); $x < round($xMax); $x++) {
  846.           
  847.       $fromY = floor($fromLine->getYFrom($x));
  848.           
  849.       $toY = array();
  850.       foreach($lines as $line) {
  851.         $yValue = $line->getYFrom($x);
  852.  
  853.         if(!is_null($yValue)) {
  854.           $toY[] = floor($yValue);
  855.         }
  856.       }
  857.           
  858.       if(count($toY) === 1) {
  859.         $fillLine = new Line(
  860.         new Point($x, $fromY),
  861.         new Point($x, $toY[0])
  862.         );
  863.       } else {
  864.             
  865.         $line1 = new Line(
  866.         new Point($x, $fromY),
  867.         new Point($x, $toY[0])
  868.         );
  869.         $line2 = new  Line(
  870.         new Point($x, $fromY),
  871.         new Point($x, $toY[1])
  872.         );
  873.             
  874.         if($line1->getSize() < $line2->getSize()) {
  875.           $fillLine = $line1;
  876.         } else {
  877.           $fillLine = $line2;
  878.         }
  879.       }
  880.           
  881.       $color = $this->color($x - $xMin);
  882.       if($fillLine->isPoint()) {
  883.         $this->driver->point($color, $fillLine->p1);
  884.       } elseif($fillLine->getSize() >= 1) {
  885.         $this->driver->line($color, $fillLine);
  886.       }
  887.       unset($color);
  888.     }
  889.  
  890.   }
  891.  
  892.   public function filledRectangle(awGradient $gradient, awPoint $p1, awPoint $p2) {
  893.  
  894.     list($x1, $y1) = $p1->getLocation();
  895.     list($x2, $y2) = $p2->getLocation();
  896.  
  897.     if($y1 < $y2) {
  898.       $y1 ^= $y2 ^= $y1 ^= $y2;
  899.     }
  900.  
  901.     if($x2 < $x1) {
  902.       $x1 ^= $x2 ^= $x1 ^= $x2;
  903.     }
  904.  
  905.     if($gradient instanceof awLinearGradient) {
  906.       $this->rectangleLinearGradient($gradient, new awPoint($x1, $y1), new awPoint($x2, $y2));
  907.     } else {
  908.       awImage::drawError("Class GDGradientDriver: This gradient is not supported by rectangles.");
  909.     }
  910.  
  911.   }
  912.  
  913.   public function filledPolygon(awGradient $gradient, awPolygon $polygon) {
  914.  
  915.     if($gradient instanceof awLinearGradient) {
  916.       $this->polygonLinearGradient($gradient, $polygon);
  917.     } else {
  918.       awImage::drawError("Class GDGradientDriver: This gradient is not supported by polygons.");
  919.     }
  920.  
  921.   }
  922.  
  923.   protected function rectangleLinearGradient(awLinearGradient $gradient, awPoint $p1, awPoint $p2) {
  924.  
  925.     list($x1, $y1) = $p1->getLocation();
  926.     list($x2, $y2) = $p2->getLocation();
  927.  
  928.     if($y1 - $y2 > 0) {
  929.  
  930.       if($gradient->angle === 0) {
  931.             
  932.         $this->init($gradient, $y1 - $y2);
  933.  
  934.         for($i = $y2; $i <= $y1; $i++) {
  935.  
  936.           $color = $this->color($i - $y2);
  937.               
  938.           $p1 = new awPoint($x1, $i);
  939.           $p2 = new awPoint($x2, $i);
  940.               
  941.           $this->driver->filledRectangle($color, new awLine($p1, $p2));
  942.               
  943.           unset($color);
  944.               
  945.         }
  946.  
  947.       } else if($gradient->angle === 90) {
  948.             
  949.         $this->init($gradient, $x2 - $x1);
  950.  
  951.         for($i = $x1; $i <= $x2; $i++) {
  952.  
  953.           $color = $this->color($i - $x1);
  954.               
  955.           $p1 = new awPoint($i, $y2);
  956.           $p2 = new awPoint($i, $y1);
  957.               
  958.           $this->driver->filledRectangle($color, new awLine($p1, $p2));
  959.               
  960.           unset($color);
  961.               
  962.         }
  963.  
  964.       }
  965.           
  966.     }
  967.  
  968.   }
  969.  
  970.   public function filledEllipse(awGradient $gradient, $x1, $y1, $x2, $y2) {
  971.  
  972.     if($y1 < $y2) {
  973.       $y1 ^= $y2 ^= $y1 ^= $y2;
  974.     }
  975.  
  976.     if($x2 < $x1) {
  977.       $x1 ^= $x2 ^= $x1 ^= $x2;
  978.     }
  979.  
  980.     if($gradient instanceof awRadialGradient) {
  981.       $this->ellipseRadialGradient($gradient, $x1, $y1, $x2, $y2);
  982.     } else if($gradient instanceof awLinearGradient) {
  983.       $this->ellipseLinearGradient($gradient, $x1, $y1, $x2, $y2);
  984.     } else {
  985.       awImage::drawError("Class GDGradientDriver: This gradient is not supported by ellipses.");
  986.     }
  987.  
  988.   }
  989.  
  990.   protected function ellipseRadialGradient(awGradient $gradient, $x1, $y1, $x2, $y2) {
  991.  
  992.     if($y1 - $y2 > 0) {
  993.  
  994.       if($y1 - $y2 != $x2 - $x1) {
  995.         awImage::drawError("Class GDGradientDriver: Radial gradients are only implemented on circle, not ellipses.");
  996.       }
  997.           
  998.       $c = new awPoint($x1 + ($x2 - $x1) / 2, $y1 + ($y2 - $y1) / 2);
  999.       $r = ($x2 - $x1) / 2;
  1000.       $ok = array();
  1001.           
  1002.       // Init gradient
  1003.       $this->init($gradient, $r);
  1004.           
  1005.       for($i = 0; $i <= $r; $i += 0.45) {
  1006.             
  1007.         $p = ceil((2 * M_PI * $i));
  1008.  
  1009.         if($p > 0) {
  1010.           $interval = 360 / $p;
  1011.         } else {
  1012.           $interval = 360;
  1013.         }
  1014.  
  1015.         $color = $this->color($i);
  1016.  
  1017.         for($j = 0; $j < 360; $j += $interval) {
  1018.  
  1019.           $rad = ($j / 360) * (2 * M_PI);
  1020.               
  1021.           $x = round($i * cos($rad));
  1022.           $y = round($i * sin($rad));
  1023.               
  1024.           $l = sqrt($x * $x + $y * $y);
  1025.               
  1026.           if($l <= $r) {
  1027.                 
  1028.             if(
  1029.             array_key_exists((int)$x, $ok) === FALSE or
  1030.             array_key_exists((int)$y, $ok[$x]) === FALSE
  1031.             ) {
  1032.  
  1033.               // Print the point
  1034.               $this->driver->point($color, new awPoint($c->x + $x, $c->y + $y));
  1035.                   
  1036.               $ok[(int)$x][(int)$y] = TRUE;
  1037.  
  1038.             }
  1039.  
  1040.           }
  1041.  
  1042.         }
  1043.  
  1044.         unset($color);
  1045.             
  1046.       }
  1047.  
  1048.     }
  1049.  
  1050.   }
  1051.  
  1052.   protected function ellipseLinearGradient(awGradient $gradient, $x1, $y1, $x2, $y2) {
  1053.  
  1054.     // Gauche->droite : 90°
  1055.  
  1056.     if($y1 - $y2 > 0) {
  1057.  
  1058.       if($y1 - $y2 != $x2 - $x1) {
  1059.         awImage::drawError("Class GDGradientDriver: Linear gradients are only implemented on circle, not ellipses.");
  1060.       }
  1061.           
  1062.       $r = ($x2 - $x1) / 2;
  1063.           
  1064.       // Init gradient
  1065.       $this->init($gradient, $x2 - $x1);
  1066.           
  1067.       for($i = -$r; $i <= $r; $i++) {
  1068.  
  1069.         $h = sin(acos($i / $r)) * $r;
  1070.  
  1071.         $color = $this->color($i + $r);
  1072.  
  1073.         if($gradient->angle === 90) {
  1074.  
  1075.           // Print the line
  1076.           $p1 = new awPoint(
  1077.           $x1 + $i + $r,
  1078.           round(max($y2 + $r - $h + 1, $y2))
  1079.           );
  1080.               
  1081.           $p2 = new awPoint(
  1082.           $x1 + $i + $r,
  1083.           round(min($y1 - $r + $h - 1, $y1))
  1084.           );
  1085.               
  1086.         } else {
  1087.  
  1088.           // Print the line
  1089.           $p1 = new awPoint(
  1090.           round(max($x1 + $r - $h + 1, $x1)),
  1091.           $y2 + $i + $r
  1092.           );
  1093.               
  1094.           $p2 = new awPoint(
  1095.           round(min($x2 - $r + $h - 1, $x2)),
  1096.           $y2 + $i + $r
  1097.           );
  1098.               
  1099.         }
  1100.  
  1101.         $this->driver->filledRectangle($color, new awLine($p1, $p2));
  1102.  
  1103.         unset($color);
  1104.             
  1105.       }
  1106.  
  1107.     }
  1108.  
  1109.   }
  1110.  
  1111.   protected function polygonLinearGradient(awLinearGradient $gradient, awPolygon $polygon) {
  1112.  
  1113.     $count = $polygon->count();
  1114.  
  1115.     if($count >= 4) {
  1116.  
  1117.       $left = $polygon->get(0);
  1118.       $right = $polygon->get($count - 1);
  1119.           
  1120.       if($gradient->angle === 0) {
  1121.             
  1122.         // Get polygon maximum and minimum
  1123.         $offset = $polygon->get(0);
  1124.         $max = $min = $offset->y;
  1125.         for($i = 1; $i < $count - 1; $i++) {
  1126.           $offset = $polygon->get($i);
  1127.           $max = max($max, $offset->y);
  1128.           $min = min($min, $offset->y);
  1129.         }
  1130.  
  1131.         $this->init($gradient, $max - $min);
  1132.             
  1133.         $prev = $polygon->get(1);
  1134.  
  1135.         $sum = 0;
  1136.             
  1137.         for($i = 2; $i < $count - 1; $i++) {
  1138.  
  1139.           $current = $polygon->get($i);
  1140.               
  1141.           $interval = 1;
  1142.               
  1143.           if($i !== $count - 2) {
  1144.             $current->x -= $interval;
  1145.           }
  1146.               
  1147.           if($current->x - $prev->x > 0) {
  1148.  
  1149.             // Draw rectangle
  1150.             $x1 = $prev->x;
  1151.             $x2 = $current->x;
  1152.             $y1 = max($prev->y, $current->y);
  1153.             $y2 = $left->y;
  1154.  
  1155.             $gradient = new awLinearGradient(
  1156.             $this->color($max - $min - ($y2 - $y1)),
  1157.             $this->color($max - $min),
  1158.             0
  1159.             );
  1160.  
  1161.             if($y1 > $y2) {
  1162.               $y2 = $y1;
  1163.             }
  1164.  
  1165.             $this->driver->filledRectangle(
  1166.             $gradient,
  1167.             awLine::build($x1, $y1, $x2, $y2)
  1168.             );
  1169.  
  1170.             $top = ($prev->y < $current->y) ? $current : $prev;
  1171.             $bottom = ($prev->y >= $current->y) ? $current : $prev;
  1172.  
  1173.             $gradient = new awLinearGradient(
  1174.             $this->color($bottom->y - $min),
  1175.             $this->color($max - $min - ($y2 - $y1)),
  1176.             0
  1177.             );
  1178.  
  1179.  
  1180.             $gradientDriver = new awGDGradientDriver($this->driver);
  1181.             $gradientDriver->drawFilledFlatTriangle(
  1182.             $gradient,
  1183.             new awPoint($prev->x, min($prev->y, $current->y)),
  1184.             $top,
  1185.             new awPoint($current->x, min($prev->y, $current->y))
  1186.             );
  1187.             unset($gradientDriver);
  1188.  
  1189.             $sum += $current->x - $prev->x;
  1190.  
  1191.           }
  1192.               
  1193.           $prev = $current;
  1194.           $prev->x += $interval;
  1195.  
  1196.         }
  1197.             
  1198.       } else if($gradient->angle === 90) {
  1199.  
  1200.         $width = $right->x - $left->x;
  1201.         $this->init($gradient, $width);
  1202.  
  1203.         $pos = 1;
  1204.         $next = $polygon->get($pos++);
  1205.  
  1206.         $this->next($polygon, $pos, $prev, $next);
  1207.             
  1208.         for($i = 0; $i <= $width; $i++) {
  1209.  
  1210.           $x = $left->x + $i;
  1211.               
  1212.           $y1 = round($prev->y + ($next->y - $prev->y) * (($i + $left->x - $prev->x) / ($next->x - $prev->x)));
  1213.           $y2 = $left->y;
  1214.  
  1215.           // Draw line
  1216.           $color = $this->color($i);
  1217.           // YaPB : PHP does not handle alpha on lines
  1218.           $this->driver->filledRectangle($color, awLine::build($x, $y1, $x, $y2));
  1219.  
  1220.           unset($color);
  1221.               
  1222.           // Jump to next point
  1223.           if($next->x == $i + $left->x) {
  1224.                 
  1225.             $this->next($polygon, $pos, $prev, $next);
  1226.  
  1227.           }
  1228.  
  1229.         }
  1230.  
  1231.       }
  1232.           
  1233.     } else if($count === 3) {
  1234.       $this->drawFilledTriangle(
  1235.       $gradient,
  1236.       $polygon
  1237.       );
  1238.     }
  1239.  
  1240.   }
  1241.  
  1242.   private function next($polygon, &$pos, &$prev, &$next) {
  1243.  
  1244.     do {
  1245.       $prev = $next;
  1246.       $next = $polygon->get($pos++);
  1247.     }
  1248.     while($next->x - $prev->x == 0 and $pos < $polygon->count());
  1249.  
  1250.   }
  1251.  
  1252.   /**
  1253.    * Start colors
  1254.    *
  1255.    * @var int 
  1256.    */
  1257.   private $r1, $g1, $b1, $a1;
  1258.  
  1259.   /**
  1260.    * Stop colors
  1261.    *
  1262.    * @var int 
  1263.    */
  1264.   private $r2, $g2, $b2, $a2;
  1265.  
  1266.   /**
  1267.    * Gradient size in pixels
  1268.    *
  1269.    * @var int 
  1270.    */
  1271.   private $size;
  1272.  
  1273.  
  1274.   private function init(awGradient $gradient, $size) {
  1275.  
  1276.     list(
  1277.     $this->r1, $this->g1, $this->b1, $this->a1
  1278.     ) = $gradient->from->rgba();
  1279.  
  1280.     list(
  1281.     $this->r2, $this->g2, $this->b2, $this->a2
  1282.     ) = $gradient->to->rgba();
  1283.  
  1284.     $this->size = $size;
  1285.   }
  1286.  
  1287.   private function color($pos) {
  1288.  
  1289.     return new awColor(
  1290.     $this->getRed($pos),
  1291.     $this->getGreen($pos),
  1292.     $this->getBlue($pos),
  1293.     $this->getAlpha($pos)
  1294.     );
  1295.  
  1296.   }
  1297.  
  1298.  
  1299.   private function getRed($pos) {
  1300.     if((float)$this->size !== 0.0) {
  1301.       return (int)round($this->r1 + ($pos / $this->size) * ($this->r2 - $this->r1));
  1302.     } else {
  1303.       return 0;
  1304.     }
  1305.   }
  1306.  
  1307.   private function getGreen($pos) {
  1308.     if((float)$this->size !== 0.0) {
  1309.       return (int)round($this->g1 + ($pos / $this->size) * ($this->g2 - $this->g1));
  1310.     } else {
  1311.       return 0;
  1312.     }
  1313.   }
  1314.  
  1315.   private function getBlue($pos) {
  1316.     if((float)$this->size !== 0.0) {
  1317.       return (int)round($this->b1 + ($pos / $this->size) * ($this->b2 - $this->b1));
  1318.     } else {
  1319.       return 0;
  1320.     }
  1321.   }
  1322.  
  1323.   private function getAlpha($pos) {
  1324.     if((float)$this->size !== 0.0) {
  1325.       return (int)round(($this->a1 + ($pos / $this->size) * ($this->a2 - $this->a1)) / 127 * 100);
  1326.     } else {
  1327.       return 0;
  1328.     }
  1329.   }
  1330.  
  1331. }
  1332.  
  1333. registerClass('GDGradientDriver');
  1334.  
  1335. /*
  1336.  * Check for GD2
  1337.  */
  1338. if(function_exists('imagecreatetruecolor') === FALSE) {
  1339.   awImage::drawErrorFile('missing-gd2');
  1340. }
  1341.  
  1342. ?>
Documentation generated on Fri, 01 Apr 2011 09:31:05 +0200 by phpDocumentor 1.4.1