<?php
/*=======================================================================
// File:	JPGRAPH_BAR.PHP
// Description:	Bar plot extension for JpGraph
// Created: 	2001-01-08
// Ver:		$Id: jpgraph_bar.php 957 2007-12-01 14:00:29Z ljp $
//
// Copyright (c) Aditus Consulting. All rights reserved.
//========================================================================
*/

require_once('jpgraph_plotband.php');

// Pattern for Bars
DEFINE('PATTERN_DIAG1', 1);
DEFINE('PATTERN_DIAG2', 2);
DEFINE('PATTERN_DIAG3', 3);
DEFINE('PATTERN_DIAG4', 4);
DEFINE('PATTERN_CROSS1', 5);
DEFINE('PATTERN_CROSS2', 6);
DEFINE('PATTERN_CROSS3', 7);
DEFINE('PATTERN_CROSS4', 8);
DEFINE('PATTERN_STRIPE1', 9);
DEFINE('PATTERN_STRIPE2', 10);

//===================================================
// CLASS BarPlot
// Description: Main code to produce a bar plot
//===================================================
class BarPlot extends Plot
{
    public $fill=false;
    public $fill_color="lightblue"; // Default is to fill with light blue
    public $iPattern=-1;
    public $iPatternDensity=80;
    public $iPatternColor='black';
    public $valuepos='top';
    public $grad=false;
    public $grad_style=1;
    public $grad_fromcolor=array(50,50,200);
    public $grad_tocolor=array(255,255,255);
    public $ymin=0;
    protected $width=0.4; // in percent of major ticks
    protected $abswidth=-1; // Width in absolute pixels
    protected $ybase=0; // Bars start at 0
    protected $align="center";
    protected $bar_shadow=false;
    protected $bar_shadow_color="black";
    protected $bar_shadow_hsize=3;
    protected $bar_shadow_vsize=3;
    
    //---------------
    // CONSTRUCTOR
    public function BarPlot($datay, $datax=false)
    {
        $this->Plot($datay, $datax);
        ++$this->numpoints;
    }

    //---------------
    // PUBLIC METHODS
    
    // Set a drop shadow for the bar (or rather an "up-right" shadow)
    public function SetShadow($color="black", $hsize=3, $vsize=3, $show=true)
    {
        $this->bar_shadow=$show;
        $this->bar_shadow_color=$color;
        $this->bar_shadow_vsize=$vsize;
        $this->bar_shadow_hsize=$hsize;
        
        // Adjust the value margin to compensate for shadow
        $this->value->margin += $vsize;
    }
        
    // DEPRECATED use SetYBase instead
    public function SetYMin($aYStartValue)
    {
        //die("JpGraph Error: Deprecated function SetYMin. Use SetYBase() instead.");
        $this->ybase=$aYStartValue;
    }

    // Specify the base value for the bars
    public function SetYBase($aYStartValue)
    {
        $this->ybase=$aYStartValue;
    }
    
    public function Legend($graph)
    {
        if ($this->grad && $this->legend!="" && !$this->fill) {
            $color=array($this->grad_fromcolor,$this->grad_tocolor);
            // In order to differentiate between gradients and cooors specified as an RGB triple
            $graph->legend->Add(
                $this->legend,
                $color,
                "",
                -$this->grad_style,
                $this->legendcsimtarget,
                $this->legendcsimalt,
                $this->legendcsimwintarget
            );
        } elseif ($this->legend!="" && ($this->iPattern > -1 || is_array($this->iPattern))) {
            if (is_array($this->iPattern)) {
                $p1 = $this->iPattern[0];
                $p2 = $this->iPatternColor[0];
                $p3 = $this->iPatternDensity[0];
            } else {
                $p1 = $this->iPattern;
                $p2 = $this->iPatternColor;
                $p3 = $this->iPatternDensity;
            }
            $color = array($p1,$p2,$p3,$this->fill_color);
            // A kludge: Too mark that we add a pattern we use a type value of < 100
            $graph->legend->Add(
                $this->legend,
                $color,
                "",
                -101,
                $this->legendcsimtarget,
                $this->legendcsimalt,
                $this->legendcsimwintarget
            );
        } elseif ($this->fill_color && $this->legend!="") {
            if (is_array($this->fill_color)) {
                $graph->legend->Add(
                    $this->legend,
                    $this->fill_color[0],
                    "",
                    0,
                    $this->legendcsimtarget,
                    $this->legendcsimalt,
                    $this->legendcsimwintarget
                );
            } else {
                $graph->legend->Add(
                    $this->legend,
                    $this->fill_color,
                    "",
                    0,
                    $this->legendcsimtarget,
                    $this->legendcsimalt,
                    $this->legendcsimwintarget
                );
            }
        }
    }

    // Gets called before any axis are stroked
    public function PreStrokeAdjust($graph)
    {
        parent::PreStrokeAdjust($graph);

        // If we are using a log Y-scale we want the base to be at the
        // minimum Y-value unless the user have specifically set some other
        // value than the default.
        if (substr($graph->axtype, -3, 3)=="log" && $this->ybase==0) {
            $this->ybase = $graph->yaxis->scale->GetMinVal();
        }
        
        // For a "text" X-axis scale we will adjust the
        // display of the bars a little bit.
        if (substr($graph->axtype, 0, 3)=="tex") {
            // Position the ticks between the bars
            $graph->xaxis->scale->ticks->SetXLabelOffset(0.5, 0);

            // Center the bars
            if ($this->abswidth > -1) {
                $graph->SetTextScaleAbsCenterOff($this->abswidth);
            } else {
                if ($this->align == "center") {
                    $graph->SetTextScaleOff(0.5-$this->width/2);
                } elseif ($this->align == "right") {
                    $graph->SetTextScaleOff(1-$this->width);
                }
            }
        } elseif (($this instanceof AccBarPlot) || ($this instanceof GroupBarPlot)) {
            // We only set an absolute width for linear and int scale
            // for text scale the width will be set to a fraction of
            // the majstep width.
            if ($this->abswidth == -1) {
                // Not set
                // set width to a visuable sensible default
                $this->abswidth = $graph->img->plotwidth/(2*count($this->coords[0]));
            }
        }
    }

    public function Min()
    {
        $m = parent::Min();
        if ($m[1] >= $this->ybase) {
            $m[1] = $this->ybase;
        }
        return $m;
    }

    public function Max()
    {
        $m = parent::Max();
        if ($m[1] <= $this->ybase) {
            $m[1] = $this->ybase;
        }
        return $m;
    }
    
    // Specify width as fractions of the major stepo size
    public function SetWidth($aWidth)
    {
        if ($aWidth > 1) {
            // Interpret this as absolute width
            $this->abswidth=$aWidth;
        } else {
            $this->width=$aWidth;
        }
    }
    
    // Specify width in absolute pixels. If specified this
    // overrides SetWidth()
    public function SetAbsWidth($aWidth)
    {
        $this->abswidth=$aWidth;
    }
        
    public function SetAlign($aAlign)
    {
        $this->align=$aAlign;
    }
    
    public function SetNoFill()
    {
        $this->grad = false;
        $this->fill_color=false;
        $this->fill=false;
    }
        
    public function SetFillColor($aColor)
    {
        $this->fill = true ;
        $this->fill_color=$aColor;
    }
    
    public function SetFillGradient($aFromColor, $aToColor=null, $aStyle=null)
    {
        $this->grad = true;
        $this->grad_fromcolor = $aFromColor;
        $this->grad_tocolor   = $aToColor;
        $this->grad_style     = $aStyle;
    }
    
    public function SetValuePos($aPos)
    {
        $this->valuepos = $aPos;
    }

    public function SetPattern($aPattern, $aColor='black')
    {
        if (is_array($aPattern)) {
            $n = count($aPattern);
            $this->iPattern = array();
            $this->iPatternDensity = array();
            if (is_array($aColor)) {
                $this->iPatternColor = array();
                if (count($aColor) != $n) {
                    JpGraphError::Raise('NUmber of colors is not the same as the number of patterns in BarPlot::SetPattern()');
                }
            } else {
                $this->iPatternColor = $aColor;
            }
            for ($i=0; $i < $n; ++$i) {
                $this->_SetPatternHelper($aPattern[$i], $this->iPattern[$i], $this->iPatternDensity[$i]);
                if (is_array($aColor)) {
                    $this->iPatternColor[$i] = $aColor[$i];
                }
            }
        } else {
            $this->_SetPatternHelper($aPattern, $this->iPattern, $this->iPatternDensity);
            $this->iPatternColor = $aColor;
        }
    }

    public function _SetPatternHelper($aPattern, &$aPatternValue, &$aDensity)
    {
        switch ($aPattern) {
        case PATTERN_DIAG1:
        $aPatternValue= 1;
        $aDensity = 90;
        break;
        case PATTERN_DIAG2:
        $aPatternValue= 1;
        $aDensity = 75;
        break;
        case PATTERN_DIAG3:
        $aPatternValue= 2;
        $aDensity = 90;
        break;
        case PATTERN_DIAG4:
        $aPatternValue= 2;
        $aDensity = 75;
        break;
        case PATTERN_CROSS1:
        $aPatternValue= 8;
        $aDensity = 90;
        break;
        case PATTERN_CROSS2:
        $aPatternValue= 8;
        $aDensity = 78;
        break;
        case PATTERN_CROSS3:
        $aPatternValue= 8;
        $aDensity = 65;
        break;
        case PATTERN_CROSS4:
        $aPatternValue= 7;
        $aDensity = 90;
        break;
        case PATTERN_STRIPE1:
        $aPatternValue= 5;
        $aDensity = 90;
        break;
        case PATTERN_STRIPE2:
        $aPatternValue= 5;
        $aDensity = 75;
        break;
        default:
        JpGraphError::Raise('Unknown pattern specified in call to BarPlot::SetPattern()');
    }
    }

    public function Stroke($img, $xscale, $yscale)
    {
        $numpoints = count($this->coords[0]);
        if (isset($this->coords[1])) {
            if (count($this->coords[1])!=$numpoints) {
                JpGraphError::Raise("Number of X and Y points are not equal. Number of X-points:".count($this->coords[1])."Number of Y-points:$numpoints");
            } else {
                $exist_x = true;
            }
        } else {
            $exist_x = false;
        }
        
        
        $numbars=count($this->coords[0]);

        // Use GetMinVal() instead of scale[0] directly since in the case
        // of log scale we get a correct value. Log scales will have negative
        // values for values < 1 while still not representing negative numbers.
        if ($yscale->GetMinVal() >= 0) {
            $zp=$yscale->scale_abs[0];
        } else {
            $zp=$yscale->Translate(0);
        }

        if ($this->abswidth > -1) {
            $abswidth=$this->abswidth;
        } else {
            $abswidth=round($this->width*$xscale->scale_factor, 0);
        }

        // Count pontetial pattern array to avoid doing the count for each iteration
        if (is_array($this->iPattern)) {
            $np = count($this->iPattern);
        }
            
        $grad = null;
        for ($i=0; $i < $numbars; ++$i) {

        // If value is NULL, or 0 then don't draw a bar at all
            if ($this->coords[0][$i] === null || $this->coords[0][$i] === '') {
                continue;
            }

            if ($exist_x) {
                $x=$this->coords[1][$i];
            } else {
                $x=$i;
            }
            
            $x=$xscale->Translate($x);

            // Comment Note: This confuses the positioning when using acc together with
            // grouped bars. Workaround for fixing #191
            /*
                    if( !$xscale->textscale ) {
                        if($this->align=="center")
                        $x -= $abswidth/2;
                    elseif($this->align=="right")
                        $x -= $abswidth;
                    }
            */
            // Stroke fill color and fill gradient
            $pts=array(
        $x,$zp,
        $x,$yscale->Translate($this->coords[0][$i]),
        $x+$abswidth,$yscale->Translate($this->coords[0][$i]),
        $x+$abswidth,$zp);
            if ($this->grad) {
                if ($grad === null) {
                    $grad = new Gradient($img);
                }
                if (is_array($this->grad_fromcolor)) {
                    // The first argument (grad_fromcolor) can be either an array or a single color. If it is an array
                    // then we have two choices. It can either a) be a single color specified as an RGB triple or it can be
                    // an array to specify both (from, to style) for each individual bar. The way to know the difference is
                    // to investgate the first element. If this element is an integer [0,255] then we assume it is an RGB
                    // triple.
                    $ng = count($this->grad_fromcolor);
                    if ($ng === 3) {
                        if (is_numeric($this->grad_fromcolor[0]) && $this->grad_fromcolor[0] > 0 && $this->grad_fromcolor[0] < 256) {
                            // RGB Triple
                            $fromcolor = $this->grad_fromcolor;
                            $tocolor = $this->grad_tocolor;
                            $style = $this->grad_style;
                        }
                    } else {
                        $fromcolor = $this->grad_fromcolor[$i % $ng][0];
                        $tocolor = $this->grad_fromcolor[$i % $ng][1];
                        $style = $this->grad_fromcolor[$i % $ng][2];
                    }
                    $grad->FilledRectangle(
                        $pts[2],
                        $pts[3],
                        $pts[6],
                        $pts[7],
                        $fromcolor,
                        $tocolor,
                        $style
                    );
                } else {
                    $grad->FilledRectangle(
                        $pts[2],
                        $pts[3],
                        $pts[6],
                        $pts[7],
                        $this->grad_fromcolor,
                        $this->grad_tocolor,
                        $this->grad_style
                    );
                }
            } elseif (!empty($this->fill_color)) {
                if (is_array($this->fill_color)) {
                    $img->PushColor($this->fill_color[$i % count($this->fill_color)]);
                } else {
                    $img->PushColor($this->fill_color);
                }
                $img->FilledPolygon($pts);
                $img->PopColor();
            }
 
            
            // Remember value of this bar
            $val=$this->coords[0][$i];

            if (!empty($val) && !is_numeric($val)) {
                JpGraphError::Raise('All values for a barplot must be numeric. You have specified value['.$i.'] == \''.$val.'\'');
            }

            // Determine the shadow
            if ($this->bar_shadow && $val != 0) {
                $ssh = $this->bar_shadow_hsize;
                $ssv = $this->bar_shadow_vsize;
                // Create points to create a "upper-right" shadow
                if ($val > 0) {
                    $sp[0]=$pts[6];
                    $sp[1]=$pts[7];
                    $sp[2]=$pts[4];
                    $sp[3]=$pts[5];
                    $sp[4]=$pts[2];
                    $sp[5]=$pts[3];
                    $sp[6]=$pts[2]+$ssh;
                    $sp[7]=$pts[3]-$ssv;
                    $sp[8]=$pts[4]+$ssh;
                    $sp[9]=$pts[5]-$ssv;
                    $sp[10]=$pts[6]+$ssh;
                    $sp[11]=$pts[7]-$ssv;
                } elseif ($val < 0) {
                    $sp[0]=$pts[4];
                    $sp[1]=$pts[5];
                    $sp[2]=$pts[6];
                    $sp[3]=$pts[7];
                    $sp[4]=$pts[0];
                    $sp[5]=$pts[1];
                    $sp[6]=$pts[0]+$ssh;
                    $sp[7]=$pts[1]-$ssv;
                    $sp[8]=$pts[6]+$ssh;
                    $sp[9]=$pts[7]-$ssv;
                    $sp[10]=$pts[4]+$ssh;
                    $sp[11]=$pts[5]-$ssv;
                }
                if (is_array($this->bar_shadow_color)) {
                    $numcolors = count($this->bar_shadow_color);
                    if ($numcolors == 0) {
                        JpGraphError::Raise('You have specified an empty array for shadow colors in the bar plot.');
                    }
                    $img->PushColor($this->bar_shadow_color[$i % $numcolors]);
                } else {
                    $img->PushColor($this->bar_shadow_color);
                }
                $img->FilledPolygon($sp);
                $img->PopColor();
            }
            
            // Stroke the pattern
            if (is_array($this->iPattern)) {
                $f = new RectPatternFactory();
                if (is_array($this->iPatternColor)) {
                    $pcolor = $this->iPatternColor[$i % $np];
                } else {
                    $pcolor = $this->iPatternColor;
                }
                $prect = $f->Create($this->iPattern[$i % $np], $pcolor, 1);
                $prect->SetDensity($this->iPatternDensity[$i % $np]);

                if ($val < 0) {
                    $rx = $pts[0];
                    $ry = $pts[1];
                } else {
                    $rx = $pts[2];
                    $ry = $pts[3];
                }
                $width = abs($pts[4]-$pts[0])+1;
                $height = abs($pts[1]-$pts[3])+1;
                $prect->SetPos(new Rectangle($rx, $ry, $width, $height));
                $prect->Stroke($img);
            } else {
                if ($this->iPattern > -1) {
                    $f = new RectPatternFactory();
                    $prect = $f->Create($this->iPattern, $this->iPatternColor, 1);
                    $prect->SetDensity($this->iPatternDensity);
                    if ($val < 0) {
                        $rx = $pts[0];
                        $ry = $pts[1];
                    } else {
                        $rx = $pts[2];
                        $ry = $pts[3];
                    }
                    $width = abs($pts[4]-$pts[0])+1;
                    $height = abs($pts[1]-$pts[3])+1;
                    $prect->SetPos(new Rectangle($rx, $ry, $width, $height));
                    $prect->Stroke($img);
                }
            }
            // Stroke the outline of the bar
            if (is_array($this->color)) {
                $img->SetColor($this->color[$i % count($this->color)]);
            } else {
                $img->SetColor($this->color);
            }

            $pts[] = $pts[0];
            $pts[] = $pts[1];

            if ($this->weight > 0) {
                $img->SetLineWeight($this->weight);
                $img->Polygon($pts);
            }
            
            // Determine how to best position the values of the individual bars
            $x=$pts[2]+($pts[4]-$pts[2])/2;
            if ($this->valuepos=='top') {
                $y=$pts[3];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('right', 'center');
                    } else {
                        $this->value->SetAlign('left', 'center');
                    }
                }
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos=='max') {
                $y=$pts[3];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('left', 'center');
                    } else {
                        $this->value->SetAlign('right', 'center');
                    }
                } else {
                    $this->value->SetAlign('center', 'top');
                }
                $this->value->SetMargin(-3);
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos=='center') {
                $y = ($pts[3] + $pts[1])/2;
                $this->value->SetAlign('center', 'center');
                $this->value->SetMargin(0);
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos=='bottom' || $this->valuepos=='min') {
                $y=$pts[1];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('right', 'center');
                    } else {
                        $this->value->SetAlign('left', 'center');
                    }
                }
                $this->value->SetMargin(3);
                $this->value->Stroke($img, $val, $x, $y);
            } else {
                JpGraphError::Raise('Unknown position for values on bars :'.$this->valuepos);
            }
            // Create the client side image map
            $rpts = $img->ArrRotate($pts);
            $csimcoord=round($rpts[0]).", ".round($rpts[1]);
            for ($j=1; $j < 4; ++$j) {
                $csimcoord .= ", ".round($rpts[2*$j]).", ".round($rpts[2*$j+1]);
            }
            if (!empty($this->csimtargets[$i])) {
                $this->csimareas .= '<area shape="poly" coords="'.$csimcoord.'" ';
                $this->csimareas .= " href=\"".htmlentities($this->csimtargets[$i])."\"";

                if (!empty($this->csimwintargets[$i])) {
                    $this->csimareas .= " target=\"".$this->csimwintargets[$i]."\" ";
                }

                $sval='';
                if (!empty($this->csimalts[$i])) {
                    $sval=sprintf($this->csimalts[$i], $this->coords[0][$i]);
                    $this->csimareas .= " title=\"$sval\" alt=\"$sval\" ";
                }
                $this->csimareas .= " />\n";
            }
        }
        return true;
    }
} // Class

//===================================================
// CLASS GroupBarPlot
// Description: Produce grouped bar plots
//===================================================
class GroupBarPlot extends BarPlot
{
    private $plots;
    private $nbrplots=0;
    //---------------
    // CONSTRUCTOR
    public function GroupBarPlot($plots)
    {
        $this->width=0.7;
        $this->plots = $plots;
        $this->nbrplots = count($plots);
        if ($this->nbrplots < 1) {
            JpGraphError::Raise('Cannot create GroupBarPlot from empty plot array.');
        }
        for ($i=0; $i < $this->nbrplots; ++$i) {
            if (empty($this->plots[$i]) || !isset($this->plots[$i])) {
                JpGraphError::Raise("Group bar plot element nbr $i is undefined or empty.");
            }
        }
        $this->numpoints = $plots[0]->numpoints;
        $this->width=0.7;
    }

    //---------------
    // PUBLIC METHODS
    public function Legend($graph)
    {
        $n = count($this->plots);
        for ($i=0; $i < $n; ++$i) {
            $c = get_class($this->plots[$i]);
            if (!($this->plots[$i] instanceof BarPlot)) {
                JpGraphError::Raise('One of the objects submitted to GroupBar is not a BarPlot. Make sure that you create the Group Bar plot from an array of BarPlot or AccBarPlot objects. (Class = '.$c.')');
            }
            $this->plots[$i]->DoLegend($graph);
        }
    }
    
    public function Min()
    {
        list($xmin, $ymin) = $this->plots[0]->Min();
        $n = count($this->plots);
        for ($i=0; $i < $n; ++$i) {
            list($xm, $ym) = $this->plots[$i]->Min();
            $xmin = max($xmin, $xm);
            $ymin = min($ymin, $ym);
        }
        return array($xmin,$ymin);
    }
    
    public function Max()
    {
        list($xmax, $ymax) = $this->plots[0]->Max();
        $n = count($this->plots);
        for ($i=0; $i < $n; ++$i) {
            list($xm, $ym) = $this->plots[$i]->Max();
            $xmax = max($xmax, $xm);
            $ymax = max($ymax, $ym);
        }
        return array($xmax,$ymax);
    }
    
    public function GetCSIMareas()
    {
        $n = count($this->plots);
        $csimareas='';
        for ($i=0; $i < $n; ++$i) {
            $csimareas .= $this->plots[$i]->csimareas;
        }
        return $csimareas;
    }
    
    // Stroke all the bars next to each other
    public function Stroke($img, $xscale, $yscale)
    {
        $tmp=$xscale->off;
        $n = count($this->plots);
        $subwidth = $this->width/$this->nbrplots ;

        for ($i=0; $i < $n; ++$i) {
            $this->plots[$i]->ymin=$this->ybase;
            $this->plots[$i]->SetWidth($subwidth);
        
            // If the client have used SetTextTickInterval() then
            // major_step will be > 1 and the positioning will fail.
            // If we assume it is always one the positioning will work
            // fine with a text scale but this will not work with
            // arbitrary linear scale
            $xscale->off = $tmp+$i*round($xscale->scale_factor* $subwidth);
            $this->plots[$i]->Stroke($img, $xscale, $yscale);
        }
        $xscale->off=$tmp;
    }
} // Class

//===================================================
// CLASS AccBarPlot
// Description: Produce accumulated bar plots
//===================================================
class AccBarPlot extends BarPlot
{
    private $plots=null;
    private $nbrplots=0;
    //---------------
    // CONSTRUCTOR
    public function AccBarPlot($plots)
    {
        $this->plots = $plots;
        $this->nbrplots = count($plots);
        if ($this->nbrplots < 1) {
            JpGraphError::Raise('Cannot create AccBarPlot from empty plot array.');
        }
        for ($i=0; $i < $this->nbrplots; ++$i) {
            if (empty($this->plots[$i]) || !isset($this->plots[$i])) {
                JpGraphError::Raise("Acc bar plot element nbr $i is undefined or empty.");
            }
        }
        $this->numpoints = $plots[0]->numpoints;
        $this->value = new DisplayValue();
    }

    //---------------
    // PUBLIC METHODS
    public function Legend($graph)
    {
        $n = count($this->plots);
        for ($i=$n-1; $i >= 0; --$i) {
            $c = get_class($this->plots[$i]);
            if (!($this->plots[$i] instanceof BarPlot)) {
                JpGraphError::Raise('One of the objects submitted to AccBar is not a BarPlot. Make sure that you create the AccBar plot from an array of BarPlot objects.(Class='.$c.')');
            }
            $this->plots[$i]->DoLegend($graph);
        }
    }

    public function Max()
    {
        list($xmax) = $this->plots[0]->Max();
        $nmax=0;
        for ($i=0; $i < count($this->plots); ++$i) {
            $n = count($this->plots[$i]->coords[0]);
            $nmax = max($nmax, $n);
            list($x) = $this->plots[$i]->Max();
            $xmax = max($xmax, $x);
        }
        for ($i = 0; $i < $nmax; $i++) {
            // Get y-value for bar $i by adding the
            // individual bars from all the plots added.
            // It would be wrong to just add the
            // individual plots max y-value since that
            // would in most cases give to large y-value.
            $y=0;
            if (!isset($this->plots[0]->coords[0][$i])) {
                JpGraphError::RaiseL(2014);
            }
            if ($this->plots[0]->coords[0][$i] > 0) {
                $y=$this->plots[0]->coords[0][$i];
            }
            for ($j = 1; $j < $this->nbrplots; $j++) {
                if (!isset($this->plots[$j]->coords[0][$i])) {
                    JpGraphError::RaiseL(2014);
                }
                if ($this->plots[$j]->coords[0][$i] > 0) {
                    $y += $this->plots[$j]->coords[0][$i];
                }
            }
            $ymax[$i] = $y;
        }
        $ymax = max($ymax);

        // Bar always start at baseline
        if ($ymax <= $this->ybase) {
            $ymax = $this->ybase;
        }
        return array($xmax,$ymax);
    }

    public function Min()
    {
        $nmax=0;
        list($xmin, $ysetmin) = $this->plots[0]->Min();
        for ($i=0; $i < count($this->plots); ++$i) {
            $n = count($this->plots[$i]->coords[0]);
            $nmax = max($nmax, $n);
            list($x, $y) = $this->plots[$i]->Min();
            $xmin = Min($xmin, $x);
            $ysetmin = Min($y, $ysetmin);
        }
        for ($i = 0; $i < $nmax; $i++) {
            // Get y-value for bar $i by adding the
            // individual bars from all the plots added.
            // It would be wrong to just add the
            // individual plots max y-value since that
            // would in most cases give to large y-value.
            $y=0;
            if ($this->plots[0]->coords[0][$i] < 0) {
                $y=$this->plots[0]->coords[0][$i];
            }
            for ($j = 1; $j < $this->nbrplots; $j++) {
                if ($this->plots[$j]->coords[0][$i] < 0) {
                    $y += $this->plots[ $j ]->coords[0][$i];
                }
            }
            $ymin[$i] = $y;
        }
        $ymin = Min($ysetmin, Min($ymin));
        // Bar always start at baseline
        if ($ymin >= $this->ybase) {
            $ymin = $this->ybase;
        }
        return array($xmin,$ymin);
    }

    // Stroke acc bar plot
    public function Stroke($img, $xscale, $yscale)
    {
        $pattern=null;
        $img->SetLineWeight($this->weight);
        for ($i=0; $i < $this->numpoints-1; $i++) {
            $accy = 0;
            $accy_neg = 0;
            for ($j=0; $j < $this->nbrplots; ++$j) {
                $img->SetColor($this->plots[$j]->color);

                if ($this->plots[$j]->coords[0][$i] >= 0) {
                    $yt=$yscale->Translate($this->plots[$j]->coords[0][$i]+$accy);
                    $accyt=$yscale->Translate($accy);
                    $accy+=$this->plots[$j]->coords[0][$i];
                } else {
                    //if ( $this->plots[$j]->coords[0][$i] < 0 || $accy_neg < 0 ) {
                    $yt=$yscale->Translate($this->plots[$j]->coords[0][$i]+$accy_neg);
                    $accyt=$yscale->Translate($accy_neg);
                    $accy_neg+=$this->plots[$j]->coords[0][$i];
                }
                
                $xt=$xscale->Translate($i);

                if ($this->abswidth > -1) {
                    $abswidth=$this->abswidth;
                } else {
                    $abswidth=round($this->width*$xscale->scale_factor, 0);
                }
        
                $pts=array($xt,$accyt,$xt,$yt,$xt+$abswidth,$yt,$xt+$abswidth,$accyt);

                if ($this->bar_shadow) {
                    $ssh = $this->bar_shadow_hsize;
                    $ssv = $this->bar_shadow_vsize;
            
                    // We must also differ if we are a positive or negative bar.
                    if ($j === 0) {
                        // This gets extra complicated since we have to
                        // see all plots to see if we are negative. It could
                        // for example be that all plots are 0 until the very
                        // last one. We therefore need to save the initial setup
                        // for both the negative and positive case

                        // In case the final bar is positive
                        $sp[0]=$pts[6]+1;
                        $sp[1]=$pts[7];
                        $sp[2]=$pts[6]+$ssh;
                        $sp[3]=$pts[7]-$ssv;

                        // In case the final bar is negative
                        $nsp[0]=$pts[0];
                        $nsp[1]=$pts[1];
                        $nsp[2]=$pts[0]+$ssh;
                        $nsp[3]=$pts[1]-$ssv;
                        $nsp[4]=$pts[6]+$ssh;
                        $nsp[5]=$pts[7]-$ssv;
                        $nsp[10]=$pts[6]+1;
                        $nsp[11]=$pts[7];
                    }

                    if ($j === $this->nbrplots-1) {
                        // If this is the last plot of the bar and
                        // the total value is larger than 0 then we
                        // add the shadow.
                        if (is_array($this->bar_shadow_color)) {
                            $numcolors = count($this->bar_shadow_color);
                            if ($numcolors == 0) {
                                JpGraphError::Raise('You have specified an empty array for shadow colors in the bar plot.');
                            }
                            $img->PushColor($this->bar_shadow_color[$i % $numcolors]);
                        } else {
                            $img->PushColor($this->bar_shadow_color);
                        }

                        if ($accy > 0) {
                            $sp[4]=$pts[4]+$ssh;
                            $sp[5]=$pts[5]-$ssv;
                            $sp[6]=$pts[2]+$ssh;
                            $sp[7]=$pts[3]-$ssv;
                            $sp[8]=$pts[2];
                            $sp[9]=$pts[3]-1;
                            $sp[10]=$pts[4]+1;
                            $sp[11]=$pts[5];
                            $img->FilledPolygon($sp, 4);
                        } elseif ($accy_neg < 0) {
                            $nsp[6]=$pts[4]+$ssh;
                            $nsp[7]=$pts[5]-$ssv;
                            $nsp[8]=$pts[4]+1;
                            $nsp[9]=$pts[5];
                            $img->FilledPolygon($nsp, 4);
                        }
                        $img->PopColor();
                    }
                }


                // If value is NULL or 0, then don't draw a bar at all
                if ($this->plots[$j]->coords[0][$i] == 0) {
                    continue;
                }

                if ($this->plots[$j]->grad) {
                    $grad = new Gradient($img);
                    $grad->FilledRectangle(
                        $pts[2],
                        $pts[3],
                        $pts[6],
                        $pts[7],
                        $this->plots[$j]->grad_fromcolor,
                        $this->plots[$j]->grad_tocolor,
                        $this->plots[$j]->grad_style
                    );
                } else {
                    if (is_array($this->plots[$j]->fill_color)) {
                        $numcolors = count($this->plots[$j]->fill_color);
                        $fillcolor = $this->plots[$j]->fill_color[$i % $numcolors];
                        // If the bar is specified to be non filled then the fill color is false
                        if ($fillcolor !== false) {
                            $img->SetColor($this->plots[$j]->fill_color[$i % $numcolors]);
                        }
                    } else {
                        $fillcolor = $this->plots[$j]->fill_color;
                        if ($fillcolor !== false) {
                            $img->SetColor($this->plots[$j]->fill_color);
                        }
                    }
                    if ($fillcolor !== false) {
                        $img->FilledPolygon($pts);
                    }
                    $img->SetColor($this->plots[$j]->color);
                }

                // Stroke the pattern
                if ($this->plots[$j]->iPattern > -1) {
                    if ($pattern===null) {
                        $pattern = new RectPatternFactory();
                    }
        
                    $prect = $pattern->Create($this->plots[$j]->iPattern, $this->plots[$j]->iPatternColor, 1);
                    $prect->SetDensity($this->plots[$j]->iPatternDensity);
                    if ($this->plots[$j]->coords[0][$i] < 0) {
                        $rx = $pts[0];
                        $ry = $pts[1];
                    } else {
                        $rx = $pts[2];
                        $ry = $pts[3];
                    }
                    $width = abs($pts[4]-$pts[0])+1;
                    $height = abs($pts[1]-$pts[3])+1;
                    $prect->SetPos(new Rectangle($rx, $ry, $width, $height));
                    $prect->Stroke($img);
                }


                // CSIM array

                if ($i < count($this->plots[$j]->csimtargets)) {
                    // Create the client side image map
                    $rpts = $img->ArrRotate($pts);
                    $csimcoord=round($rpts[0]).", ".round($rpts[1]);
                    for ($k=1; $k < 4; ++$k) {
                        $csimcoord .= ", ".round($rpts[2*$k]).", ".round($rpts[2*$k+1]);
                    }
                    if (! empty($this->plots[$j]->csimtargets[$i])) {
                        $this->csimareas.= '<area shape="poly" coords="'.$csimcoord.'" ';
                        $this->csimareas.= " href=\"".$this->plots[$j]->csimtargets[$i]."\" ";

                        if (! empty($this->plots[$j]->csimwintargets[$i])) {
                            $this->csimareas.= " target=\"".$this->plots[$j]->csimwintargets[$i]."\" ";
                        }

                        $sval='';
                        if (!empty($this->plots[$j]->csimalts[$i])) {
                            $sval=sprintf($this->plots[$j]->csimalts[$i], $this->plots[$j]->coords[0][$i]);
                            $this->csimareas .= " title=\"$sval\" ";
                        }
                        $this->csimareas .= " alt=\"$sval\" />\n";
                    }
                }

                $pts[] = $pts[0];
                $pts[] = $pts[1];
                $img->SetLineWeight($this->plots[$j]->line_weight);
                $img->Polygon($pts);
                $img->SetLineWeight(1);
            }
        
            // Draw labels for each acc.bar
    
            $x=$pts[2]+($pts[4]-$pts[2])/2;
            if ($this->bar_shadow) {
                $x += $ssh;
            }

            // First stroke the accumulated value for the entire bar
            // This value is always placed at the top/bottom of the bars
            if ($accy_neg < 0) {
                $y=$yscale->Translate($accy_neg);
                $this->value->Stroke($img, $accy_neg, $x, $y);
            } else {
                $y=$yscale->Translate($accy);
                $this->value->Stroke($img, $accy, $x, $y);
            }

            $accy = 0;
            $accy_neg = 0;
            for ($j=0; $j < $this->nbrplots; ++$j) {

        // We don't print 0 values in an accumulated bar plot
                if ($this->plots[$j]->coords[0][$i] == 0) {
                    continue;
                }
            
                if ($this->plots[$j]->coords[0][$i] > 0) {
                    $yt=$yscale->Translate($this->plots[$j]->coords[0][$i]+$accy);
                    $accyt=$yscale->Translate($accy);
                    if ($this->plots[$j]->valuepos=='center') {
                        $y = $accyt-($accyt-$yt)/2;
                    } elseif ($this->plots[$j]->valuepos=='bottom') {
                        $y = $accyt;
                    } else { // top or max
                        $y = $accyt-($accyt-$yt);
                    }
                    $accy+=$this->plots[$j]->coords[0][$i];
                    if ($this->plots[$j]->valuepos=='center') {
                        $this->plots[$j]->value->SetAlign("center", "center");
                        $this->plots[$j]->value->SetMargin(0);
                    } elseif ($this->plots[$j]->valuepos=='bottom') {
                        $this->plots[$j]->value->SetAlign('center', 'bottom');
                        $this->plots[$j]->value->SetMargin(2);
                    } else {
                        $this->plots[$j]->value->SetAlign('center', 'top');
                        $this->plots[$j]->value->SetMargin(1);
                    }
                } else {
                    $yt=$yscale->Translate($this->plots[$j]->coords[0][$i]+$accy_neg);
                    $accyt=$yscale->Translate($accy_neg);
                    $accy_neg+=$this->plots[$j]->coords[0][$i];
                    if ($this->plots[$j]->valuepos=='center') {
                        $y = $accyt-($accyt-$yt)/2;
                    } elseif ($this->plots[$j]->valuepos=='bottom') {
                        $y = $accyt;
                    } else {
                        $y = $accyt-($accyt-$yt);
                    }
                    if ($this->plots[$j]->valuepos=='center') {
                        $this->plots[$j]->value->SetAlign("center", "center");
                        $this->plots[$j]->value->SetMargin(0);
                    } elseif ($this->plots[$j]->valuepos=='bottom') {
                        $this->plots[$j]->value->SetAlign('center', $j==0 ? 'bottom':'top');
                        $this->plots[$j]->value->SetMargin(-2);
                    } else {
                        $this->plots[$j]->value->SetAlign('center', 'bottom');
                        $this->plots[$j]->value->SetMargin(-1);
                    }
                }
                $this->plots[$j]->value->Stroke($img, $this->plots[$j]->coords[0][$i], $x, $y);
            }
        }
        return true;
    }
} // Class

/* EOF */