PHP ImagePolygon函数代码示例

 function area($x_start, $y_start, $x_end, $y_end, $type, $colour, $offset)
 {
     //dbug("drawing area type: $type, at offset: $offset");
     if ($this->parameter['zero_axis'] != 'none') {
         $bottom = $this->calculated['boundary_box']['bottom'];
         $zero = $this->calculated['zero_axis'];
         if ($this->parameter['shadow_below_axis']) {
             $zero += $offset;
         }
         $u_start = $x_start + $offset;
         $u_end = $x_end + $offset;
         $v_start = $bottom - $y_start + $offset;
         $v_end = $bottom - $y_end + $offset;
         switch ($type) {
             case 'fill':
                 // draw it this way 'cos the FilledPolygon routine seems a bit buggy.
                 ImageFilledPolygon($this->image, array($u_start, $v_start, $u_end, $v_end, $u_end, $zero, $u_start, $zero), 4, $this->colour[$colour]);
                 ImagePolygon($this->image, array($u_start, $v_start, $u_end, $v_end, $u_end, $zero, $u_start, $zero), 4, $this->colour[$colour]);
                 break;
             case 'open':
                 //ImagePolygon($this->image, array($u_start, $v_start, $u_end, $v_end, $u_end, $zero, $u_start, $zero), 4, $this->colour[$colour]);
                 ImageLine($this->image, $u_start, $v_start, $u_end, $v_end, $this->colour[$colour]);
                 ImageLine($this->image, $u_start, $v_start, $u_start, $zero, $this->colour[$colour]);
                 ImageLine($this->image, $u_end, $v_end, $u_end, $zero, $this->colour[$colour]);
                 break;
         }
     } else {
         $bottom = $this->calculated['boundary_box']['bottom'];
         $u_start = $x_start + $offset;
         $u_end = $x_end + $offset;
         $v_start = $bottom - $y_start + $offset;
         $v_end = $bottom - $y_end + $offset;
         if ($this->parameter['shadow_below_axis']) {
             $bottom += $offset;
         }
         if ($this->parameter['inner_border'] != 'none') {
             $bottom -= 1;
         }
         // 1 pixel above bottom if border is to be drawn.
         switch ($type) {
             case 'fill':
                 ImageFilledPolygon($this->image, array($u_start, $v_start, $u_end, $v_end, $u_end, $bottom, $u_start, $bottom), 4, $this->colour[$colour]);
                 break;
             case 'open':
                 ImagePolygon($this->image, array($u_start, $v_start, $u_end, $v_end, $u_end, $bottom, $u_start, $bottom), 4, $this->colour[$colour]);
                 break;
         }
     }
 }

 protected function DrawDot($x_world, $y_world, $record, $color)
 {
     $index = $record % $this->point_counts;
     $point_size = $this->point_sizes[$index];
     $half_point = (int) ($point_size / 2);
     $x_mid = $this->xtr($x_world);
     $y_mid = $this->ytr($y_world);
     $x1 = $x_mid - $half_point;
     $x2 = $x_mid + $half_point;
     $y1 = $y_mid - $half_point;
     $y2 = $y_mid + $half_point;
     switch ($this->point_shapes[$index]) {
         case 'halfline':
             ImageLine($this->img, $x1, $y_mid, $x_mid, $y_mid, $color);
             break;
         case 'line':
             ImageLine($this->img, $x1, $y_mid, $x2, $y_mid, $color);
             break;
         case 'plus':
             ImageLine($this->img, $x1, $y_mid, $x2, $y_mid, $color);
             ImageLine($this->img, $x_mid, $y1, $x_mid, $y2, $color);
             break;
         case 'cross':
             ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
             ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
             break;
         case 'circle':
             ImageArc($this->img, $x_mid, $y_mid, $point_size, $point_size, 0, 360, $color);
             break;
         case 'dot':
             ImageFilledEllipse($this->img, $x_mid, $y_mid, $point_size, $point_size, $color);
             break;
         case 'diamond':
             $arrpoints = array($x1, $y_mid, $x_mid, $y1, $x2, $y_mid, $x_mid, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'triangle':
             $arrpoints = array($x1, $y_mid, $x2, $y_mid, $x_mid, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'trianglemid':
             $arrpoints = array($x1, $y1, $x2, $y1, $x_mid, $y_mid);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'yield':
             $arrpoints = array($x1, $y1, $x2, $y1, $x_mid, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'delta':
             $arrpoints = array($x1, $y2, $x2, $y2, $x_mid, $y1);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'star':
             ImageLine($this->img, $x1, $y_mid, $x2, $y_mid, $color);
             ImageLine($this->img, $x_mid, $y1, $x_mid, $y2, $color);
             ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
             ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
             break;
         case 'hourglass':
             $arrpoints = array($x1, $y1, $x2, $y1, $x1, $y2, $x2, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'bowtie':
             $arrpoints = array($x1, $y1, $x1, $y2, $x2, $y1, $x2, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'target':
             ImageFilledRectangle($this->img, $x1, $y1, $x_mid, $y_mid, $color);
             ImageFilledRectangle($this->img, $x_mid, $y_mid, $x2, $y2, $color);
             ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
         case 'box':
             ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
         case 'home':
             /* As in: "home plate" (baseball), also looks sort of like a house. */
             $arrpoints = array($x1, $y2, $x2, $y2, $x2, $y_mid, $x_mid, $y1, $x1, $y_mid);
             ImageFilledPolygon($this->img, $arrpoints, 5, $color);
             break;
         case 'up':
             ImagePolygon($this->img, array($x_mid, $y1, $x2, $y2, $x1, $y2), 3, $color);
             break;
         case 'down':
             ImagePolygon($this->img, array($x_mid, $y2, $x1, $y1, $x2, $y1), 3, $color);
             break;
         case 'none':
             /* Special case, no point shape here */
             break;
         default:
             /* Also 'rect' */
             ImageFilledRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
     }
     return TRUE;
 }

 /**
  * Draw a pie slice
  *
  * Parameter array:
  * 
  * 'x': int X center point
  * 
  * 'y': int Y center point
  * 
  * 'rx': int X radius
  * 
  * 'ry': int Y radius
  * 
  * 'v1': int The starting angle (in degrees)
  * 
  * 'v2': int The end angle (in degrees)
  * 
  * 'srx': int [optional] Starting X-radius of the pie slice (i.e. for a doughnut)
  * 
  * 'sry': int [optional] Starting Y-radius of the pie slice (i.e. for a doughnut)
  * 
  * 'fill': mixed [optional] The fill color
  * 
  * 'line': mixed [optional] The line color
  * 
  * @param array $params Parameter array
  */
 function pieslice($params)
 {
     $x = $this->_getX($params['x']);
     $y = $this->_getY($params['y']);
     $rx = $params['rx'];
     $ry = $params['ry'];
     $v1 = $params['v1'];
     $v2 = $params['v2'];
     $srx = isset($params['srx']) ? $params['srx'] : 0;
     $sry = isset($params['sry']) ? $params['sry'] : 0;
     $fillColor = isset($params['fill']) ? $params['fill'] : false;
     $lineColor = isset($params['line']) ? $params['line'] : false;
     $dA = 0.1;
     if ($srx !== false && $sry !== false) {
         $angle = max($v1, $v2);
         while ($angle >= min($v1, $v2)) {
             $polygon[] = $x + $srx * cos(deg2rad($angle % 360));
             $polygon[] = $y + $sry * sin(deg2rad($angle % 360));
             $angle -= $dA;
         }
         if ($angle + $dA > min($v1, $v2)) {
             $polygon[] = $x + $srx * cos(deg2rad(min($v1, $v2) % 360));
             $polygon[] = $y + $sry * sin(deg2rad(min($v1, $v2) % 360));
         }
     } else {
         $polygon[] = $x;
         $polygon[] = $y;
     }
     $angle = min($v1, $v2);
     while ($angle <= max($v1, $v2)) {
         $polygon[] = $x + $rx * cos(deg2rad($angle % 360));
         $polygon[] = $y + $ry * sin(deg2rad($angle % 360));
         $angle += $dA;
     }
     if ($angle - $dA < max($v1, $v2)) {
         $polygon[] = $x + $rx * cos(deg2rad(max($v1, $v2) % 360));
         $polygon[] = $y + $ry * sin(deg2rad(max($v1, $v2) % 360));
     }
     if (($fill = $this->_getFillStyle($fillColor, $x - $rx - 1, $y - $ry - 1, $x + $rx + 1, $y + $ry + 1)) !== false && count($polygon) > 2) {
         ImageFilledPolygon($this->_canvas, $polygon, count($polygon) / 2, $fill);
     }
     if (($line = $this->_getLineStyle($lineColor)) !== false) {
         ImagePolygon($this->_canvas, $polygon, count($polygon) / 2, $line);
     }
     parent::pieSlice($params);
 }

 protected function DrawShape($x, $y, $record, $color, $allow_none = TRUE)
 {
     $index = $record % $this->point_counts;
     $point_size = $this->point_sizes[$index];
     $half_point = (int) ($point_size / 2);
     $x1 = $x - $half_point;
     $x2 = $x + $half_point;
     $y1 = $y - $half_point;
     $y2 = $y + $half_point;
     switch ($this->point_shapes[$index]) {
         case 'halfline':
             ImageLine($this->img, $x1, $y, $x, $y, $color);
             break;
         case 'none':
             /* Special case, no point shape here */
             if ($allow_none) {
                 break;
             }
             // But fall throught to line if a shape is required
         // But fall throught to line if a shape is required
         case 'line':
             ImageLine($this->img, $x1, $y, $x2, $y, $color);
             break;
         case 'plus':
             ImageLine($this->img, $x1, $y, $x2, $y, $color);
             ImageLine($this->img, $x, $y1, $x, $y2, $color);
             break;
         case 'cross':
             ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
             ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
             break;
         case 'circle':
             ImageArc($this->img, $x, $y, $point_size, $point_size, 0, 360, $color);
             break;
         case 'dot':
             ImageFilledEllipse($this->img, $x, $y, $point_size, $point_size, $color);
             break;
         case 'diamond':
             $arrpoints = array($x1, $y, $x, $y1, $x2, $y, $x, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'triangle':
             $arrpoints = array($x1, $y, $x2, $y, $x, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'trianglemid':
             $arrpoints = array($x1, $y1, $x2, $y1, $x, $y);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'yield':
             $arrpoints = array($x1, $y1, $x2, $y1, $x, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'delta':
             $arrpoints = array($x1, $y2, $x2, $y2, $x, $y1);
             ImageFilledPolygon($this->img, $arrpoints, 3, $color);
             break;
         case 'star':
             ImageLine($this->img, $x1, $y, $x2, $y, $color);
             ImageLine($this->img, $x, $y1, $x, $y2, $color);
             ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
             ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
             break;
         case 'hourglass':
             $arrpoints = array($x1, $y1, $x2, $y1, $x1, $y2, $x2, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'bowtie':
             $arrpoints = array($x1, $y1, $x1, $y2, $x2, $y1, $x2, $y2);
             ImageFilledPolygon($this->img, $arrpoints, 4, $color);
             break;
         case 'target':
             ImageFilledRectangle($this->img, $x1, $y1, $x, $y, $color);
             ImageFilledRectangle($this->img, $x, $y, $x2, $y2, $color);
             ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
         case 'box':
             ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
         case 'home':
             /* As in: "home plate" (baseball), also looks sort of like a house. */
             $arrpoints = array($x1, $y2, $x2, $y2, $x2, $y, $x, $y1, $x1, $y);
             ImageFilledPolygon($this->img, $arrpoints, 5, $color);
             break;
         case 'up':
             ImagePolygon($this->img, array($x, $y1, $x2, $y2, $x1, $y2), 3, $color);
             break;
         case 'down':
             ImagePolygon($this->img, array($x, $y2, $x1, $y1, $x2, $y1), 3, $color);
             break;
         default:
             /* Also 'rect' */
             ImageFilledRectangle($this->img, $x1, $y1, $x2, $y2, $color);
             break;
     }
     return TRUE;
 }

     for ($i = 0; $i < strlen($word) + 1; $i++) {
         $text_r = $rand_func(100, 150);
         $text_g = $rand_func(100, 150);
         $text_b = $rand_func(100, 150);
         $text_colour3 = ImageColorAllocate($temp_bg, $text_r, $text_g, $text_b);
         $points = array();
         // draw random squiggle for each character
         // the longer the loop, the more complex the squiggle
         // keep random so OCR can't say "if found shape has 10 points, ignore it"
         // each squiggle will, however, be a closed shape, so OCR could try to find
         // line terminations and start from there. (I don't think they're that advanced yet..)
         for ($j = 1; $j < $rand_func(5, 10); $j++) {
             $points[] = $rand_func(1 * (20 * ($i + 1)), 1 * (50 * ($i + 1)));
             $points[] = $rand_func(30, $height + 30);
         }
         ImagePolygon($temp_bg, $points, intval(sizeof($points) / 2), $text_colour3);
     }
 } else {
     if ($bg_type == 3) {
         // take random chunks of $bg_images and paste them onto the background
         $img_num = sizeof($bg_images);
         for ($i = 0; $i < $img_num; $i++) {
             // read each image and its size
             $temp_im[$i] = ImageCreateFromJPEG($bg_dir . $bg_images[$i]);
             $temp_width[$i] = imagesx($temp_im[$i]);
             $temp_height[$i] = imagesy($temp_im[$i]);
         }
         $blocksize = $rand_func(20, 60);
         for ($i = 0; $i < $width * 2; $i += $blocksize) {
             // could randomise blocksize here... hardly matters
             for ($j = 0; $j < $height * 2; $j += $blocksize) {

$points2[2 * $i + 2] = 100;
$points2[2 * $i + 3] = $ycenter;
ImageFilledPolygon($image, $points2, $the3 - $ths3 + 2, $line3);
ImagePolygon($image, $points2, $the3 - $ths3 + 2, $black);
// Calculate the slice for Admin
$points2[0] = 100;
$points2[1] = $ycenter;
for ($i = 0; $i <= $the4 - $ths4; $i += 1) {
    $theta = ($i + $ths4) / 100;
    $points2[2 * $i + 2] = round(100 + 80 * sin($theta));
    $points2[2 * $i + 3] = round($ycenter + 80 * cos($theta));
}
$points2[2 * $i + 2] = 100;
$points2[2 * $i + 3] = $ycenter;
ImageFilledPolygon($image, $points2, $the4 - $ths4 + 2, $line4);
ImagePolygon($image, $points2, $the4 - $ths4 + 2, $black);
// Label the graph
ImageString($image, 5, 110, 3, 'Effort by Category', $black);
ImageString($image, 3, 60, 200, 'All Periods', $black);
ImageString($image, 3, 230, 200, 'Latest Period', $black);
// Outline the image
ImageLine($image, 0, 0, 379, 0, $dark);
ImageLine($image, 379, 0, 379, 219, $dark);
ImageLine($image, 379, 219, 0, 219, $dark);
ImageLine($image, 0, 219, 0, 0, $dark);
// Expose the graph
header('Content-type: image/png');
ImagePNG($image);
// echo "</p>\n";
//echo "</table>\n";
//echo "<P>\n";

        $polygon = array_merge($polygon, $quad);
        for ($i = 2; $i < $n - 5; $i += 2) {
            //ctxx.bezierCurveTo(cp[2*i-2],cp[2*i-1],cp[2*i],cp[2*i+1],pts[i+2],pts[i+3]);
            $p1 = array($pts[$i], $pts[$i + 1]);
            $p2 = array($cp[2 * $i - 2], $cp[2 * $i - 1]);
            $p3 = array($cp[2 * $i], $cp[2 * $i + 1]);
            $p4 = array($pts[$i + 2], $pts[$i + 3]);
            $bez = Bezier_convert($p1, $p2, $p3, $p4, $t);
            $polygon = array_merge($polygon, $bez);
        }
        //ctxx.quadraticCurveTo(cp[2*n-10],cp[2*n-9],pts[n-2],pts[n-1]); // last arc
        $quad = quadBezier($polygon[count($polygon) - 2], $polygon[count($polygon) - 1], $cp[2 * $n - 10], $cp[2 * $n - 9], $pts[$n - 2], $pts[$n - 1]);
        $polygon = array_merge($polygon, $quad);
    }
    return $polygon;
}
$p = drawSpline(array(50, 250, 550, 250, 550, 750));
//print_r($p); exit;
$img = imagecreatetruecolor(80, 80);
$img2 = imagecreatetruecolor(800, 800);
$bg = ImageColorAllocate($img2, 255, 255, 255);
$fg = ImageColorAllocate($img2, 0, 0, 0);
imagefill($img2, 0, 0, $bg);
imageantialias($img2, true);
ImageSetThickness($img2, 5);
ImagePolygon($img2, $p, count($p) / 2, $fg);
imagearc($img2, 400, 400, 200, 200, 0, 350, $fg);
for ($i = 0; $i < 0; $i++) {
    imagefilter($img2, IMG_FILTER_GAUSSIAN_BLUR);
}
ImagePng($img2);

    /**
     * Output the axis
     * @access private
     */
    function _done()
    {
        parent::_done();

        if (!$this->_font) {
            $this->_font = $GLOBALS['_Image_Graph_font'];
        }

        $value = $this->_getNextLabel();
        
        $lastPosition = false;

        $this->_debug("Enumerating values from $value to ".$this->_getMaximum());
        while ($value <= $this->_getMaximum()) {
            if ((((abs($value) > 0.0001) or ($this->_showLabelZero)) and (($value > $this->_getMinimum()) or ($this->_showLabelMinimum)) and (($value < $this->_getMaximum()) or ($this->_showLabelMaximum))) and ($value>= $this->_getMinimum()) and ($value<= $this->_getMaximum())) {
                $labelPosition = $this->_point($value);

                if (is_object($this->_dataPreProcessor)) {
                    $labelText = $this->_dataPreProcessor->_process($value);
                } else {
                    $labelText = $value;
                }

                $doOutput = false;
                if ($this->_type == IMAGE_GRAPH_AXIS_Y) {
                    $text = new Image_Graph_Text($this->_right - 3, $labelPosition, $labelText, $this->_font);
                    $text->setAlignment(IMAGE_GRAPH_ALIGN_CENTER_Y | IMAGE_GRAPH_ALIGN_RIGHT);
                    
                    if (($text->_fillBottom() < $lastPosition) or ($lastPosition === false)) {
                        $lastPosition = $text->_fillTop();
                        $doOutput = true;
                    }
                } else {
                    $text = new Image_Graph_Text($labelPosition, $this->_top + 3, $labelText, $this->_font);
                    $text->setAlignment(IMAGE_GRAPH_ALIGN_CENTER_X | IMAGE_GRAPH_ALIGN_TOP);

                    if (($text->_fillLeft() > $lastPosition) or ($lastPosition === false)) {
                        $lastPosition = $text->_fillRight();
                        $doOutput = true;
                    }
                }

                if ($doOutput) {
                    $this->add($text);
                    $text->_done();
                }

                if ($this->_type == IMAGE_GRAPH_AXIS_Y) {
                    ImageLine($this->_canvas(), $this->_right, $labelPosition, $this->_right + 6, $labelPosition, $this->_getLineStyle());
                } else {
                    ImageLine($this->_canvas(), $labelPosition, $this->_top, $labelPosition, $this->_top - 6, $this->_getLineStyle());
                }
            }

            $nextValue = $this->_getNextLabel($value);
/*            if ($minorLabelInterval = $this->_minorLabelInterval()) {
                $minorValue = $value + $minorLabelInterval;
                while (($minorValue < $nextValue) and ($minorValue < $this->_getMaximum() - $minorLabelInterval)) {
                    if ($minorValue >= $this->_getMinimum()) {
                        $position = $this->_point($minorValue);
                        if ($this->_type == IMAGE_GRAPH_AXIS_Y) {
                            ImageLine($this->_canvas(), $this->_right, $position, $this->_right + 3, $position, $this->_getLineStyle());
                        } else {
                            ImageLine($this->_canvas(), $position, $this->_top, $position, $this->_top - 3, $this->_getLineStyle());
                        }
                    }

                    $minorValue += $minorLabelInterval;
                }
            }*/

            $value = $nextValue;
        }

        if ($this->_type == IMAGE_GRAPH_AXIS_Y) {
            ImageLine($this->_canvas(), $this->_right, $this->_top, $this->_right, $this->_bottom, $this->_getLineStyle());
            if ($this->_showArrow) {
                $arrow[] = $this->_right - 5;
                $arrow[] = $this->_top + 8;
                $arrow[] = $this->_right;
                $arrow[] = $this->_top;
                $arrow[] = $this->_right + 5;
                $arrow[] = $this->_top + 8;
                ImageFilledPolygon($this->_canvas(), $arrow, count($arrow) / 2, $this->_getFillStyle());
                ImagePolygon($this->_canvas(), $arrow, count($arrow) / 2, $this->_getLineStyle());
            }
        } else {
            ImageLine($this->_canvas(), $this->_left, $this->_top, $this->_right, $this->_top, $this->_getLineStyle());
            if ($this->_showArrow) {
                $arrow[] = $this->_right - 8;
                $arrow[] = $this->_top + 5;
                $arrow[] = $this->_right;
                $arrow[] = $this->_top;
                $arrow[] = $this->_right - 8;
                $arrow[] = $this->_top - 5;
                ImageFilledPolygon($this->_canvas(), $arrow, count($arrow) / 2, $this->_getFillStyle());
//.........这里部分代码省略.........

<?php

$points = array($x1, $y1, $x2, $y2, $x3, $y3);
ImagePolygon($image, $points, count($points) / 2, $color);

        break;
    }
    if ($n == 0 && count($maxcharsinline) == 1) {
        break;
    } else {
        $n++;
    }
    $maxstrlen += $maxcharsinline[$n] * 2;
} while (true);
// end preparations
header("Content-type: image/png");
$decision = ImageCreate($width + 1, $height + 1);
$white = ImageColorAllocate($decision, 255, 255, 255);
$black = ImageColorAllocate($decision, 0, 0, 0);
$points = array(0, floor($height / 2), floor($width / 2), 0, $width, floor($height / 2), floor($width / 2), $height);
ImagePolygon($decision, $points, 4, $black);
$yvalue = 0;
if (strlen($textline[count($maxcharsperline)]) == '0' && count($maxcharsperline) % 2 == '0') {
    $yoffset = round($fontheight / 2);
} else {
    $yoffset = 0;
}
log2file('[drawDcs] textline: ' . strlen($textline[count($maxcharsperline)]));
for ($n = 0; $n <= $m; $n++) {
    log2file('[drawDcs] strlen of textline[$n]: ' . strlen($textline[$n]));
    if (strlen($textline[$n] == '0')) {
        $yvalue = round($fontheight / 2);
        log2file('[drawDcs] strlen=0');
    } else {
        $xval = $leftx[$n] + strlen($textline[$n]) * $fontwidth / 3;
        log2file('[drawDcs] xval: $xval');

function draw_plage($im, $results, $flg, $sx, $sy, $xc, $yc, $xi, $yi)
{
    reset($results);
    $lon = $results['LON'];
    $lat = $results['LAT'];
    $lon_b = xtrans($results['LON_B'] + 360 * $flg, $xc, $xi, $sx);
    $lat_b = ytrans($results['LAT_B'], $yc, $yi, $sy);
    $nb = count($lon);
    /*if ($flg == 0)
    		$col=ImageColorAllocate($im, 105+50*$results['INTENSITY'][0], 0, 0);
    	else
    		$col=ImageColorAllocate($im, 105+50*$results['INTENSITY'][0], 0, 105+50*$results['INTENSITY'][0]);*/
    if ($flg == 0) {
        $col = ImageColorAllocate($im, 255, 200 - 66 * $results['INTENSITY'], 200 - 66 * $results['INTENSITY']);
    } else {
        $col = ImageColorAllocate($im, 255, 200 - 66 * $results['INTENSITY'], 255);
    }
    $cBlack = ImageColorAllocate($im, 0, 0, 0);
    for ($i = 0; $i < $nb; $i++) {
        $points[] = xtrans($lon[$i] + 360 * $flg, $xc, $xi, $sx);
        $points[] = ytrans($lat[$i], $yc, $yi, $sy);
    }
    if (count($points) > 0) {
        ImageFilledPolygon($im, $points, count($points) / 2, $col);
        ImagePolygon($im, $points, count($points) / 2, $cBlack);
    }
    imagefilledellipse($im, $lon_b, $lat_b, 2, 2, $cBlack);
    //ImageFilledRectangle($im, $lon_b-1, $lat_b-1, $lon_b+1, $lat_b+1, $cBlack);
    //$fontwidth = ImageFontWidth($font);
    //$fontheight = ImageFontHeight($font);
    //ImageString($im, 2, $lon_b-($fontwidth/2), $lat_b-$fontheight, "x", $cBlack);
    unset($points);
}

function draw_feat_pix($im, $tab_xpix, $tab_ypix, $c_x, $c_y, $intensity, $feat_id, $filled, $zoom)
{
    global $global;
    $font_ttf = $global['FONT_PATH'];
    $sizey = imagesy($im);
    $nb = count($tab_xpix);
    $points = array();
    if ($filled) {
        $col = ImageColorAllocate($im, 255, 255 - $intensity, 255 - $intensity);
    } else {
        $col = ImageColorAllocate($im, 255, 255, 255);
    }
    if ($filled) {
        $gc_col = ImageColorAllocate($im, 0, 0, 0);
    } else {
        $gc_col = ImageColorAllocate($im, 0, 0, 255);
    }
    for ($i = 0; $i < $nb; $i++) {
        $points[] = $tab_xpix[$i] * $zoom;
        $points[] = $sizey - $tab_ypix[$i] * $zoom;
        // en PHP, l'origine de l'image est coin gauche haut
    }
    if (count($points) > 0) {
        if ($filled) {
            ImageFilledPolygon($im, $points, $nb, $col);
        }
        ImagePolygon($im, $points, $nb, $col);
    }
    imagefilledellipse($im, $c_x * $zoom, $sizey - $c_y * $zoom, 2, 2, $gc_col);
    //ImageString ($im, 3, $c_x*$zoom-strlen($feat_id), $sizey-$c_y*$zoom+5, $feat_id, $gc_col);
    $textArray = explode(' ', $feat_id);
    $y = $sizey - $c_y * $zoom + 15;
    foreach ($textArray as $txt) {
        ImageTTFText($im, 8, 0, $c_x * $zoom - strlen($feat_id) + 10, $y, $gc_col, $font_ttf, $txt);
        $y += 15;
    }
    //ImageTTFText($im, 8, 0, $c_x*$zoom-strlen($feat_id)+10, $sizey-$c_y*$zoom+15, $gc_col, $font_ttf, $feat_id);
}

<?php

header("Content-type: image/png");
// 1 : on indique qu'on va envoyer une image PNG
$image = imagecreate(400, 380);
// 2 : on crée une nouvelle image de taille 400 x 350
// 3 : on s'amuse avec notre image (on va apprendre à le faire)
$orange = imagecolorallocate($image, 255, 128, 0);
$bleu = imagecolorallocate($image, 0, 0, 255);
$bleuclair = imagecolorallocate($image, 156, 227, 254);
$noir = imagecolorallocate($image, 0, 0, 0);
$blanc = imagecolorallocate($image, 255, 255, 255);
//ecrire un texte
imagestring($image, 4, 35, 15, "Salut les Zéros !", $blanc);
// dessiner un trait
ImageLine($image, 30, 30, 120, 120, $noir);
//Voici une illustration en figure suivante.
ImageEllipse($image, 100, 100, 100, 50, $noir);
// un rectangle
ImageRectangle($image, 30, 30, 160, 120, $noir);
//un triangle
$points = array(10, 40, 120, 50, 160, 160);
ImagePolygon($image, $points, 3, $noir);
//imagecolortransparent($image, $orange); // On rend le fond orange transparent
imagepng($image);
// 4 : on a fini de faire joujou, on demande à afficher l'image

 for ($i = 0; $i < $num_points; $i++) {
     //Compute the point
     $points[$i * 2] = $x_center + $data[$i] * $radius / 10 * cos(deg2rad($angles[$i]));
     $points[$i * 2 + 1] = $y_center - $data[$i] * $radius / 10 * sin(deg2rad($angles[$i]));
 }
 ImageFilledPolygon($im, $points, $num_points, $orange);
 ImagePolygon($im, $points, $num_points, $blue);
 //Plot the sub-areas
 $suba_nb = 4;
 for ($i = 0; $i < $suba_nb; $i++) {
     for ($j = 0; $j < $num_points; $j++) {
         //Compute the point
         $points[$j * 2] = $x_center + $radius / $suba_nb * ($i + 1) * cos(deg2rad($angles[$j]));
         $points[$j * 2 + 1] = $y_center - $radius / $suba_nb * ($i + 1) * sin(deg2rad($angles[$j]));
     }
     ImagePolygon($im, $points, $num_points, $grey);
 }
 //Plot the axis
 for ($i = 0; $i < $num_points; $i++) {
     //Axis
     $x = $x_center + $radius * cos(deg2rad($angles[$i]));
     $y = $y_center - $radius * sin(deg2rad($angles[$i]));
     ImageLine($im, $x_center, $y_center, $x, $y, $black);
     //Division
     $x1 = $x - $div_length / 2 * sin(deg2rad($angles[$i]));
     $x2 = $x + $div_length / 2 * sin(deg2rad($angles[$i]));
     $y1 = $y - $div_length / 2 * cos(deg2rad($angles[$i]));
     $y2 = $y + $div_length / 2 * cos(deg2rad($angles[$i]));
     ImageLine($im, $x1, $y1, $x2, $y2, $black);
     //Write the value & label
     $offset_center = -6;

 /**
  * Generate noisy background
  *
  * @param int $width: width of the image in pixels
  * @param int $height: width of the image in pixels
  * @param string $word: the captcha word
  * @param string $backgroundType (see constants)
  * @param array $backgroundImages: array of background image file names
  * @param boolean $morphBackground: if TRUE, the background will be morphed
  * @param boolean $blurBackground: if TRUE, the background will be blurred
  * @return string GD image identifier of noisy background
  */
 public static function generateNoisyBackground($width, $height, $word, $backgroundType, $backgroundImages = array(), $morphBackground = TRUE, $blurBackground = TRUE)
 {
     $image = ImageCreateTrueColor($width, $height);
     if ($backgroundType != self::BACKGROUND_TYPE_TRANSPARENT) {
         // Generate noisy background, to be merged with CAPTCHA later
         // any suggestions on how best to do this much appreciated
         // sample code would be even better!
         // I'm not an OCR expert (hell, I'm not even an image expert; puremango.co.uk was designed in MsPaint)
         // so the noise models are based around my -guesswork- as to what would make it hard for an OCR prog
         // ideally, the character obfuscation would be strong enough not to need additional background noise
         // in any case, I hope at least one of the options given here provide some extra security!
         $tempBackground = ImageCreateTrueColor($width * 1.5, $height * 1.5);
         $background = ImageColorAllocate($image, 255, 255, 255);
         ImageFill($image, 0, 0, $background);
         $tempBackgroundColor = ImageColorAllocate($tempBackground, 255, 255, 255);
         ImageFill($tempBackground, 0, 0, $tempBackgroundColor);
         // We draw all noise onto tempBackground
         // then if we're morphing, merge from tempBackground to image
         // or if not, just copy a $width x $height portion of $tempBackground to $image
         // tempBackground is much larger so that when morphing, the edges retain the noise.
         switch ($backgroundType) {
             case self::BACKGROUND_TYPE_WHITE_WITH_GRID:
                 // Draw grid on x
                 for ($i = RandomContentUtility::getRandomNumberInRange(6, 20); $i < $width * 2; $i += RandomContentUtility::getRandomNumberInRange(10, 25)) {
                     ImageSetThickness($tempBackground, RandomContentUtility::getRandomNumberInRange(2, 6));
                     $textColor = RandomContentUtility::getRandomColor(100, 150);
                     $textColor2 = ImageColorAllocate($tempBackground, $textColor[0], $textColor[1], $textColor[2]);
                     ImageLine($tempBackground, $i, 0, $i, $height * 2, $textColor2);
                 }
                 // Draw grid on y
                 for ($i = RandomContentUtility::getRandomNumberInRange(6, 20); $i < $height * 2; $i += RandomContentUtility::getRandomNumberInRange(10, 25)) {
                     ImageSetThickness($tempBackground, RandomContentUtility::getRandomNumberInRange(2, 6));
                     $textColor = RandomContentUtility::getRandomColor(100, 150);
                     $textColor2 = ImageColorAllocate($tempBackground, $textColor[0], $textColor[1], $textColor[2]);
                     ImageLine($tempBackground, 0, $i, $width * 2, $i, $textColor2);
                 }
                 break;
             case self::BACKGROUND_TYPE_WHITE_WITH_SQUIGGLES:
                 ImageSetThickness($tempBackground, 4);
                 for ($i = 0; $i < strlen($word) + 1; $i++) {
                     $textColor = RandomContentUtility::getRandomColor(100, 150);
                     $textColor2 = ImageColorAllocate($tempBackground, $textColor[0], $textColor[1], $textColor[2]);
                     $points = array();
                     // Draw random squiggle for each character
                     // the longer the loop, the more complex the squiggle
                     // keep random so OCR can't say "if found shape has 10 points, ignore it"
                     // each squiggle will, however, be a closed shape, so OCR could try to find
                     // line terminations and start from there. (I don't think they're that advanced yet..)
                     for ($j = 1; $j < RandomContentUtility::getRandomNumberInRange(5, 10); $j++) {
                         $points[] = RandomContentUtility::getRandomNumberInRange(1 * (20 * ($i + 1)), 1 * (50 * ($i + 1)));
                         $points[] = RandomContentUtility::getRandomNumberInRange(30, $height + 30);
                     }
                     ImagePolygon($tempBackground, $points, intval(sizeof($points) / 2), $textColor2);
                 }
                 break;
             case self::BACKGROUND_TYPE_MORPHED_IMAGE_BLOCKS:
                 // Take random chunks of $backgroundImages and paste them onto the background
                 for ($i = 0; $i < sizeof($backgroundImages); $i++) {
                     // Read each image and its size
                     $tempImages[$i] = ImageCreateFromJPEG(GeneralUtility::getFileAbsFileName($backgroundImages[$i]));
                     $tempWidths[$i] = imagesx($tempImages[$i]);
                     $tempHeights[$i] = imagesy($tempImages[$i]);
                 }
                 $blocksize = RandomContentUtility::getRandomNumberInRange(20, 60);
                 for ($i = 0; $i < $width * 2; $i += $blocksize) {
                     // Could randomise blocksize here... hardly matters
                     for ($j = 0; $j < $height * 2; $j += $blocksize) {
                         $imageIndex = RandomContentUtility::getRandomNumberInRange(0, sizeof($tempImages) - 1);
                         $cut_x = RandomContentUtility::getRandomNumberInRange(0, $tempWidths[$imageIndex] - $blocksize);
                         $cut_y = RandomContentUtility::getRandomNumberInRange(0, $tempHeights[$imageIndex] - $blocksize);
                         ImageCopy($tempBackground, $tempImages[$imageIndex], $i, $j, $cut_x, $cut_y, $blocksize, $blocksize);
                     }
                 }
                 // Cleanup
                 for ($i = 0; $i < sizeof($tempImages); $i++) {
                     ImageDestroy($tempImages[$i]);
                 }
                 break;
         }
         if ($morphBackground) {
             // Morph background
             // We do this separately to the main text morph because:
             // a) the main text morph is done char-by-char, this is done across whole image
             // b) if an attacker could un-morph the background, it would un-morph the CAPTCHA
             // hence background is morphed differently to text
             // why do we morph it at all? it might make it harder for an attacker to remove the background
             // morph_chunk 1 looks better but takes longer
             // this is a different and less perfect morph than the one we do on the CAPTCHA
//.........这里部分代码省略.........