asda2432es

✏️ Editing: Scatter.php

<?php

namespace CpChart\Chart;

use CpChart\Data;
use CpChart\Image;
use Exception;

/**
 *  Scatter - class to draw scatter charts
 *
 *  Version     : 2.1.4
 *  Made by     : Jean-Damien POGOLOTTI
 *  Last Update : 19/01/2014
 *
 *  This file can be distributed under the license you can find at :
 *
 *  http://www.pchart.net/license
 *
 *  You can find the whole class documentation on the pChart web site.
 */
class Scatter
{
    /**
     * @var Image
     */
    public $pChartObject;

/**
     * @var Data
     */
    public $pDataObject;

/**
     * @param Image $pChartObject
     * @param Data $pDataObject
     */
    public function __construct(Image $pChartObject, Data $pDataObject)
    {
        $this->pChartObject = $pChartObject;
        $this->pDataObject = $pDataObject;
    }

/**
     * Prepare the scale
     * @param array $Format
     * @return null|int
     * @throws Exception
     */
    public function drawScatterScale(array $Format = [])
    {
        $Mode = isset($Format["Mode"]) ? $Format["Mode"] : SCALE_MODE_FLOATING;
        $Floating = isset($Format["Floating"]) ? $Format["Floating"] : false;
        $XLabelsRotation = isset($Format["XLabelsRotation"]) ? $Format["XLabelsRotation"] : 90;
        $MinDivHeight = isset($Format["MinDivHeight"]) ? $Format["MinDivHeight"] : 20;
        $Factors = isset($Format["Factors"]) ? $Format["Factors"] : [1, 2, 5];
        $ManualScale = isset($Format["ManualScale"])
            ? $Format["ManualScale"] : ["0" => ["Min" => -100, "Max" => 100]]
        ;
        $XMargin = isset($Format["XMargin"]) ? $Format["XMargin"] : 0;
        $YMargin = isset($Format["YMargin"]) ? $Format["YMargin"] : 0;
        $ScaleSpacing = isset($Format["ScaleSpacing"]) ? $Format["ScaleSpacing"] : 15;
        $InnerTickWidth = isset($Format["InnerTickWidth"]) ? $Format["InnerTickWidth"] : 2;
        $OuterTickWidth = isset($Format["OuterTickWidth"]) ? $Format["OuterTickWidth"] : 2;
        $DrawXLines = isset($Format["DrawXLines"]) ? $Format["DrawXLines"] : ALL;
        $DrawYLines = isset($Format["DrawYLines"]) ? $Format["DrawYLines"] : ALL;
        $GridTicks = isset($Format["GridTicks"]) ? $Format["GridTicks"] : 4;
        $GridR = isset($Format["GridR"]) ? $Format["GridR"] : 255;
        $GridG = isset($Format["GridG"]) ? $Format["GridG"] : 255;
        $GridB = isset($Format["GridB"]) ? $Format["GridB"] : 255;
        $GridAlpha = isset($Format["GridAlpha"]) ? $Format["GridAlpha"] : 40;
        $AxisRo = isset($Format["AxisR"]) ? $Format["AxisR"] : 0;
        $AxisGo = isset($Format["AxisG"]) ? $Format["AxisG"] : 0;
        $AxisBo = isset($Format["AxisB"]) ? $Format["AxisB"] : 0;
        $AxisAlpha = isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 100;
        $TickRo = isset($Format["TickR"]) ? $Format["TickR"] : 0;
        $TickGo = isset($Format["TickG"]) ? $Format["TickG"] : 0;
        $TickBo = isset($Format["TickB"]) ? $Format["TickB"] : 0;
        $TickAlpha = isset($Format["TickAlpha"]) ? $Format["TickAlpha"] : 100;
        $DrawSubTicks = isset($Format["DrawSubTicks"]) ? $Format["DrawSubTicks"] : false;
        $InnerSubTickWidth = isset($Format["InnerSubTickWidth"]) ? $Format["InnerSubTickWidth"] : 0;
        $OuterSubTickWidth = isset($Format["OuterSubTickWidth"]) ? $Format["OuterSubTickWidth"] : 2;
        $SubTickR = isset($Format["SubTickR"]) ? $Format["SubTickR"] : 255;
        $SubTickG = isset($Format["SubTickG"]) ? $Format["SubTickG"] : 0;
        $SubTickB = isset($Format["SubTickB"]) ? $Format["SubTickB"] : 0;
        $SubTickAlpha = isset($Format["SubTickAlpha"]) ? $Format["SubTickAlpha"] : 100;
        $XReleasePercent = isset($Format["XReleasePercent"]) ? $Format["XReleasePercent"] : 1;
        $DrawArrows = isset($Format["DrawArrows"]) ? $Format["DrawArrows"] : false;
        $ArrowSize = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 8;
        $CycleBackground = isset($Format["CycleBackground"]) ? $Format["CycleBackground"] : false;
        $BackgroundR1 = isset($Format["BackgroundR1"]) ? $Format["BackgroundR1"] : 255;
        $BackgroundG1 = isset($Format["BackgroundG1"]) ? $Format["BackgroundG1"] : 255;
        $BackgroundB1 = isset($Format["BackgroundB1"]) ? $Format["BackgroundB1"] : 255;
        $BackgroundAlpha1 = isset($Format["BackgroundAlpha1"]) ? $Format["BackgroundAlpha1"] : 10;
        $BackgroundR2 = isset($Format["BackgroundR2"]) ? $Format["BackgroundR2"] : 230;
        $BackgroundG2 = isset($Format["BackgroundG2"]) ? $Format["BackgroundG2"] : 230;
        $BackgroundB2 = isset($Format["BackgroundB2"]) ? $Format["BackgroundB2"] : 230;
        $BackgroundAlpha2 = isset($Format["BackgroundAlpha2"]) ? $Format["BackgroundAlpha2"] : 10;

/* Check if we have at least both one X and Y axis */
        $GotXAxis = false;
        $GotYAxis = false;
        foreach ($this->pDataObject->Data["Axis"] as $AxisID => $AxisSettings) {
            if ($AxisSettings["Identity"] == AXIS_X) {
                $GotXAxis = true;
            }
            if ($AxisSettings["Identity"] == AXIS_Y) {
                $GotYAxis = true;
            }
        }
        if (!$GotXAxis) {
            return SCATTER_MISSING_X_SERIE;
        }
        if (!$GotYAxis) {
            return SCATTER_MISSING_Y_SERIE;
        }

/* Skip a NOTICE event in case of an empty array */
        if ($DrawYLines == NONE) {
            $DrawYLines = ["zarma" => "31"];
        }

$Data = $this->pDataObject->getData();

foreach ($Data["Axis"] as $AxisID => $AxisSettings) {
            if ($AxisSettings["Identity"] == AXIS_X) {
                $Width = $this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1 - $XMargin * 2;
            } else {
                $Width = $this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1 - $YMargin * 2;
            }

$AxisMin = ABSOLUTE_MAX;
            $AxisMax = OUT_OF_SIGHT;
            if ($Mode == SCALE_MODE_FLOATING) {
                foreach ($Data["Series"] as $SerieID => $SerieParameter) {
                    if ($SerieParameter["Axis"] == $AxisID
                        && $Data["Series"][$SerieID]["isDrawable"]
                    ) {
                        $AxisMax = max($AxisMax, $Data["Series"][$SerieID]["Max"]);
                        $AxisMin = min($AxisMin, $Data["Series"][$SerieID]["Min"]);
                    }
                }
                $AutoMargin = (($AxisMax - $AxisMin) / 100) * $XReleasePercent;

$Data["Axis"][$AxisID]["Min"] = $AxisMin - $AutoMargin;
                $Data["Axis"][$AxisID]["Max"] = $AxisMax + $AutoMargin;
            } elseif ($Mode == SCALE_MODE_MANUAL) {
                if (isset($ManualScale[$AxisID]["Min"])
                    && isset($ManualScale[$AxisID]["Max"])
                ) {
                    $Data["Axis"][$AxisID]["Min"] = $ManualScale[$AxisID]["Min"];
                    $Data["Axis"][$AxisID]["Max"] = $ManualScale[$AxisID]["Max"];
                } else {
                    throw new Exception("Manual scale boundaries not set.");
                }
            }

/* Full manual scale */
            if (isset($ManualScale[$AxisID]["Rows"]) && isset($ManualScale[$AxisID]["RowHeight"])) {
                $Scale = [
                    "Rows" => $ManualScale[$AxisID]["Rows"],
                    "RowHeight" => $ManualScale[$AxisID]["RowHeight"],
                    "XMin" => $ManualScale[$AxisID]["Min"],
                    "XMax" => $ManualScale[$AxisID]["Max"]
                ];
            } else {
                $MaxDivs = floor($Width / $MinDivHeight);
                $Scale = $this->pChartObject->computeScale(
                    $Data["Axis"][$AxisID]["Min"],
                    $Data["Axis"][$AxisID]["Max"],
                    $MaxDivs,
                    $Factors,
                    $AxisID
                );
            }

$Data["Axis"][$AxisID]["Margin"] = $AxisSettings["Identity"] == AXIS_X ? $XMargin : $YMargin;
            $Data["Axis"][$AxisID]["ScaleMin"] = $Scale["XMin"];
            $Data["Axis"][$AxisID]["ScaleMax"] = $Scale["XMax"];
            $Data["Axis"][$AxisID]["Rows"] = $Scale["Rows"];
            $Data["Axis"][$AxisID]["RowHeight"] = $Scale["RowHeight"];

if (isset($Scale["Format"])) {
                $Data["Axis"][$AxisID]["Format"] = $Scale["Format"];
            }

if (!isset($Data["Axis"][$AxisID]["Display"])) {
                $Data["Axis"][$AxisID]["Display"] = null;
            }
            if (!isset($Data["Axis"][$AxisID]["Format"])) {
                $Data["Axis"][$AxisID]["Format"] = null;
            }
            if (!isset($Data["Axis"][$AxisID]["Unit"])) {
                $Data["Axis"][$AxisID]["Unit"] = null;
            }
        }

/* Get the default font color */
        $FontColorRo = $this->pChartObject->FontColorR;
        $FontColorGo = $this->pChartObject->FontColorG;
        $FontColorBo = $this->pChartObject->FontColorB;

/* Set the original boundaries */
        $AxisPos["L"] = $this->pChartObject->GraphAreaX1;
        $AxisPos["R"] = $this->pChartObject->GraphAreaX2;
        $AxisPos["T"] = $this->pChartObject->GraphAreaY1;
        $AxisPos["B"] = $this->pChartObject->GraphAreaY2;

foreach ($Data["Axis"] as $AxisID => $AxisSettings) {
            if (isset($AxisSettings["Color"])) {
                $AxisR = $AxisSettings["Color"]["R"];
                $AxisG = $AxisSettings["Color"]["G"];
                $AxisB = $AxisSettings["Color"]["B"];
                $TickR = $AxisSettings["Color"]["R"];
                $TickG = $AxisSettings["Color"]["G"];
                $TickB = $AxisSettings["Color"]["B"];
                $this->pChartObject->setFontProperties(
                    [
                        "R" => $AxisSettings["Color"]["R"],
                        "G" => $AxisSettings["Color"]["G"],
                        "B" => $AxisSettings["Color"]["B"]
                    ]
                );
            } else {
                $AxisR = $AxisRo;
                $AxisG = $AxisGo;
                $AxisB = $AxisBo;
                $TickR = $TickRo;
                $TickG = $TickGo;
                $TickB = $TickBo;
                $this->pChartObject->setFontProperties(
                    ["R" => $FontColorRo, "G" => $FontColorGo, "B" => $FontColorBo]
                );
            }

if ($AxisSettings["Identity"] == AXIS_X) {
                if ($AxisSettings["Position"] == AXIS_POSITION_BOTTOM) {
                    if ($XLabelsRotation == 0) {
                        $LabelAlign = TEXT_ALIGN_TOPMIDDLE;
                        $LabelOffset = 2;
                    }
                    if ($XLabelsRotation > 0 && $XLabelsRotation < 190) {
                        $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
                        $LabelOffset = 5;
                    }
                    if ($XLabelsRotation == 180) {
                        $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE;
                        $LabelOffset = 5;
                    }
                    if ($XLabelsRotation > 180 && $XLabelsRotation < 360) {
                        $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
                        $LabelOffset = 2;
                    }

if ($Floating) {
                        $FloatingOffset = $YMargin;
                        $this->pChartObject->drawLine(
                            $this->pChartObject->GraphAreaX1 + $AxisSettings["Margin"],
                            $AxisPos["B"],
                            $this->pChartObject->GraphAreaX2 - $AxisSettings["Margin"],
                            $AxisPos["B"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    } else {
                        $FloatingOffset = 0;
                        $this->pChartObject->drawLine(
                            $this->pChartObject->GraphAreaX1,
                            $AxisPos["B"],
                            $this->pChartObject->GraphAreaX2,
                            $AxisPos["B"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    }

if ($DrawArrows) {
                        $this->pChartObject->drawArrow(
                            $this->pChartObject->GraphAreaX2 - $AxisSettings["Margin"],
                            $AxisPos["B"],
                            $this->pChartObject->GraphAreaX2 + ($ArrowSize * 2),
                            $AxisPos["B"],
                            ["FillR" => $AxisR, "FillG" => $AxisG, "FillB" => $AxisB, "Size" => $ArrowSize]
                        );
                    }

$Width = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1)
                        - $AxisSettings["Margin"] * 2
                    ;
                    $Step = $Width / $AxisSettings["Rows"];
                    $SubTicksSize = $Step / 2;
                    $MaxBottom = $AxisPos["B"];
                    $LastX = null;
                    for ($i = 0; $i <= $AxisSettings["Rows"]; $i++) {
                        $XPos = $this->pChartObject->GraphAreaX1 + $AxisSettings["Margin"] + $Step * $i;
                        $YPos = $AxisPos["B"];
                        $Value = $this->pChartObject->scaleFormat(
                            $AxisSettings["ScaleMin"] + $AxisSettings["RowHeight"] * $i,
                            $AxisSettings["Display"],
                            $AxisSettings["Format"],
                            $AxisSettings["Unit"]
                        );

if ($i % 2 == 1) {
                            $BGColor = [
                                "R" => $BackgroundR1,
                                "G" => $BackgroundG1,
                                "B" => $BackgroundB1,
                                "Alpha" => $BackgroundAlpha1
                            ];
                        } else {
                            $BGColor = [
                                "R" => $BackgroundR2,
                                "G" => $BackgroundG2,
                                "B" => $BackgroundB2,
                                "Alpha" => $BackgroundAlpha2
                            ];
                        }
                        if ($LastX != null
                            && $CycleBackground
                            && ($DrawXLines == ALL || in_array($AxisID, $DrawXLines))
                        ) {
                            $this->pChartObject->drawFilledRectangle(
                                $LastX,
                                $this->pChartObject->GraphAreaY1 + $FloatingOffset,
                                $XPos,
                                $this->pChartObject->GraphAreaY2 - $FloatingOffset,
                                $BGColor
                            );
                        }

if ($DrawXLines == ALL || in_array($AxisID, $DrawXLines)) {
                            $this->pChartObject->drawLine(
                                $XPos,
                                $this->pChartObject->GraphAreaY1 + $FloatingOffset,
                                $XPos,
                                $this->pChartObject->GraphAreaY2 - $FloatingOffset,
                                [
                                    "R" => $GridR,
                                    "G" => $GridG,
                                    "B" => $GridB,
                                    "Alpha" => $GridAlpha,
                                    "Ticks" => $GridTicks
                                ]
                            );
                        }
                        if ($DrawSubTicks && $i != $AxisSettings["Rows"]) {
                            $this->pChartObject->drawLine(
                                $XPos + $SubTicksSize,
                                $YPos - $InnerSubTickWidth,
                                $XPos + $SubTicksSize,
                                $YPos + $OuterSubTickWidth,
                                [
                                    "R" => $SubTickR,
                                    "G" => $SubTickG,
                                    "B" => $SubTickB,
                                    "Alpha" => $SubTickAlpha
                                ]
                            );
                        }
                        $this->pChartObject->drawLine(
                            $XPos,
                            $YPos - $InnerTickWidth,
                            $XPos,
                            $YPos + $OuterTickWidth,
                            ["R" => $TickR, "G" => $TickG, "B" => $TickB, "Alpha" => $TickAlpha]
                        );
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos + $OuterTickWidth + $LabelOffset,
                            $Value,
                            ["Angle" => $XLabelsRotation, "Align" => $LabelAlign]
                        );
                        $TxtBottom = $YPos + 2 + $OuterTickWidth + 2 + ($Bounds[0]["Y"] - $Bounds[2]["Y"]);
                        $MaxBottom = max($MaxBottom, $TxtBottom);

$LastX = $XPos;
                    }

if (isset($AxisSettings["Name"])) {
                        $YPos = $MaxBottom + 2;
                        $XPos = $this->pChartObject->GraphAreaX1
                            + ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1) / 2
                        ;
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos,
                            $AxisSettings["Name"],
                            ["Align" => TEXT_ALIGN_TOPMIDDLE]
                        );
                        $MaxBottom = $Bounds[0]["Y"];

$this->pDataObject->Data["GraphArea"]["Y2"] = $MaxBottom + $this->pChartObject->FontSize;
                    }

$AxisPos["B"] = $MaxBottom + $ScaleSpacing;
                } elseif ($AxisSettings["Position"] == AXIS_POSITION_TOP) {
                    if ($XLabelsRotation == 0) {
                        $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE;
                        $LabelOffset = 2;
                    }
                    if ($XLabelsRotation > 0 && $XLabelsRotation < 190) {
                        $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
                        $LabelOffset = 2;
                    }
                    if ($XLabelsRotation == 180) {
                        $LabelAlign = TEXT_ALIGN_TOPMIDDLE;
                        $LabelOffset = 5;
                    }
                    if ($XLabelsRotation > 180 && $XLabelsRotation < 360) {
                        $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
                        $LabelOffset = 5;
                    }

if ($Floating) {
                        $FloatingOffset = $YMargin;
                        $this->pChartObject->drawLine(
                            $this->pChartObject->GraphAreaX1 + $AxisSettings["Margin"],
                            $AxisPos["T"],
                            $this->pChartObject->GraphAreaX2 - $AxisSettings["Margin"],
                            $AxisPos["T"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    } else {
                        $FloatingOffset = 0;
                        $this->pChartObject->drawLine(
                            $this->pChartObject->GraphAreaX1,
                            $AxisPos["T"],
                            $this->pChartObject->GraphAreaX2,
                            $AxisPos["T"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    }

if ($DrawArrows) {
                        $this->pChartObject->drawArrow(
                            $this->pChartObject->GraphAreaX2 - $AxisSettings["Margin"],
                            $AxisPos["T"],
                            $this->pChartObject->GraphAreaX2 + ($ArrowSize * 2),
                            $AxisPos["T"],
                            [
                                "FillR" => $AxisR,
                                "FillG" => $AxisG,
                                "FillB" => $AxisB,
                                "Size" => $ArrowSize
                            ]
                        );
                    }

$Width = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1)
                        - $AxisSettings["Margin"] * 2
                    ;
                    $Step = $Width / $AxisSettings["Rows"];
                    $SubTicksSize = $Step / 2;
                    $MinTop = $AxisPos["T"];
                    $LastX = null;
                    for ($i = 0; $i <= $AxisSettings["Rows"]; $i++) {
                        $XPos = $this->pChartObject->GraphAreaX1 + $AxisSettings["Margin"] + $Step * $i;
                        $YPos = $AxisPos["T"];
                        $Value = $this->pChartObject->scaleFormat(
                            $AxisSettings["ScaleMin"] + $AxisSettings["RowHeight"] * $i,
                            $AxisSettings["Display"],
                            $AxisSettings["Format"],
                            $AxisSettings["Unit"]
                        );

if ($DrawSubTicks && $i != $AxisSettings["Rows"]) {
                            $this->pChartObject->drawLine(
                                $XPos + $SubTicksSize,
                                $YPos - $OuterSubTickWidth,
                                $XPos + $SubTicksSize,
                                $YPos + $InnerSubTickWidth,
                                [
                                    "R" => $SubTickR,
                                    "G" => $SubTickG,
                                    "B" => $SubTickB,
                                    "Alpha" => $SubTickAlpha
                                ]
                            );
                        }
                        $this->pChartObject->drawLine(
                            $XPos,
                            $YPos - $OuterTickWidth,
                            $XPos,
                            $YPos + $InnerTickWidth,
                            ["R" => $TickR, "G" => $TickG, "B" => $TickB, "Alpha" => $TickAlpha]
                        );
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos - $OuterTickWidth - $LabelOffset,
                            $Value,
                            ["Angle" => $XLabelsRotation, "Align" => $LabelAlign]
                        );
                        $TxtBox = $YPos - $OuterTickWidth - 4 - ($Bounds[0]["Y"] - $Bounds[2]["Y"]);
                        $MinTop = min($MinTop, $TxtBox);

$LastX = $XPos;
                    }

if (isset($AxisSettings["Name"])) {
                        $YPos = $MinTop - 2;
                        $XPos = $this->pChartObject->GraphAreaX1
                            + ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1) / 2
                        ;
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos,
                            $AxisSettings["Name"],
                            ["Align" => TEXT_ALIGN_BOTTOMMIDDLE]
                        );
                        $MinTop = $Bounds[2]["Y"];

$this->pDataObject->Data["GraphArea"]["Y1"] = $MinTop;
                    }

$AxisPos["T"] = $MinTop - $ScaleSpacing;
                }
            } elseif ($AxisSettings["Identity"] == AXIS_Y) {
                if ($AxisSettings["Position"] == AXIS_POSITION_LEFT) {
                    if ($Floating) {
                        $FloatingOffset = $XMargin;
                        $this->pChartObject->drawLine(
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY1 + $AxisSettings["Margin"],
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY2 - $AxisSettings["Margin"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    } else {
                        $FloatingOffset = 0;
                        $this->pChartObject->drawLine(
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY1,
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY2,
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    }

if ($DrawArrows) {
                        $this->pChartObject->drawArrow(
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY1 + $AxisSettings["Margin"],
                            $AxisPos["L"],
                            $this->pChartObject->GraphAreaY1 - ($ArrowSize * 2),
                            [
                                "FillR" => $AxisR,
                                "FillG" => $AxisG,
                                "FillB" => $AxisB,
                                "Size" => $ArrowSize
                            ]
                        );
                    }

$Height = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1)
                        - $AxisSettings["Margin"] * 2
                    ;
                    $Step = $Height / $AxisSettings["Rows"];
                    $SubTicksSize = $Step / 2;
                    $MinLeft = $AxisPos["L"];
                    $LastY = null;
                    for ($i = 0; $i <= $AxisSettings["Rows"]; $i++) {
                        $YPos = $this->pChartObject->GraphAreaY2 - $AxisSettings["Margin"] - $Step * $i;
                        $XPos = $AxisPos["L"];
                        $Value = $this->pChartObject->scaleFormat(
                            $AxisSettings["ScaleMin"] + $AxisSettings["RowHeight"] * $i,
                            $AxisSettings["Display"],
                            $AxisSettings["Format"],
                            $AxisSettings["Unit"]
                        );

if ($i % 2 == 1) {
                            $BGColor = [
                                "R" => $BackgroundR1,
                                "G" => $BackgroundG1,
                                "B" => $BackgroundB1,
                                "Alpha" => $BackgroundAlpha1
                            ];
                        } else {
                            $BGColor = [
                                "R" => $BackgroundR2,
                                "G" => $BackgroundG2,
                                "B" => $BackgroundB2,
                                "Alpha" => $BackgroundAlpha2
                            ];
                        }
                        if ($LastY != null
                            && $CycleBackground
                            && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))
                        ) {
                            $this->pChartObject->drawFilledRectangle(
                                $this->pChartObject->GraphAreaX1 + $FloatingOffset,
                                $LastY,
                                $this->pChartObject->GraphAreaX2 - $FloatingOffset,
                                $YPos,
                                $BGColor
                            );
                        }

if (($YPos != $this->pChartObject->GraphAreaY1 && $YPos != $this->pChartObject->GraphAreaY2)
                            && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))
                        ) {
                            $this->pChartObject->drawLine(
                                $this->pChartObject->GraphAreaX1 + $FloatingOffset,
                                $YPos,
                                $this->pChartObject->GraphAreaX2 - $FloatingOffset,
                                $YPos,
                                [
                                    "R" => $GridR,
                                    "G" => $GridG,
                                    "B" => $GridB,
                                    "Alpha" => $GridAlpha,
                                    "Ticks" => $GridTicks
                                ]
                            );
                        }

if ($DrawSubTicks && $i != $AxisSettings["Rows"]) {
                            $this->pChartObject->drawLine(
                                $XPos - $OuterSubTickWidth,
                                $YPos - $SubTicksSize,
                                $XPos + $InnerSubTickWidth,
                                $YPos - $SubTicksSize,
                                [
                                    "R" => $SubTickR,
                                    "G" => $SubTickG,
                                    "B" => $SubTickB,
                                    "Alpha" => $SubTickAlpha
                                ]
                            );
                        }
                        $this->pChartObject->drawLine(
                            $XPos - $OuterTickWidth,
                            $YPos,
                            $XPos + $InnerTickWidth,
                            $YPos,
                            ["R" => $TickR, "G" => $TickG, "B" => $TickB, "Alpha" => $TickAlpha]
                        );
                        $Bounds = $this->pChartObject->drawText(
                            $XPos - $OuterTickWidth - 2,
                            $YPos,
                            $Value,
                            ["Align" => TEXT_ALIGN_MIDDLERIGHT]
                        );
                        $TxtLeft = $XPos - $OuterTickWidth - 2 - ($Bounds[1]["X"] - $Bounds[0]["X"]);
                        $MinLeft = min($MinLeft, $TxtLeft);

$LastY = $YPos;
                    }

if (isset($AxisSettings["Name"])) {
                        $XPos = $MinLeft - 2;
                        $YPos = $this->pChartObject->GraphAreaY1
                            + ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1) / 2
                        ;
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos,
                            $AxisSettings["Name"],
                            ["Align" => TEXT_ALIGN_BOTTOMMIDDLE, "Angle" => 90]
                        );
                        $MinLeft = $Bounds[2]["X"];

$this->pDataObject->Data["GraphArea"]["X1"] = $MinLeft;
                    }

$AxisPos["L"] = $MinLeft - $ScaleSpacing;
                } elseif ($AxisSettings["Position"] == AXIS_POSITION_RIGHT) {
                    if ($Floating) {
                        $FloatingOffset = $XMargin;
                        $this->pChartObject->drawLine(
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY1 + $AxisSettings["Margin"],
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY2 - $AxisSettings["Margin"],
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    } else {
                        $FloatingOffset = 0;
                        $this->pChartObject->drawLine(
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY1,
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY2,
                            ["R" => $AxisR, "G" => $AxisG, "B" => $AxisB, "Alpha" => $AxisAlpha]
                        );
                    }

if ($DrawArrows) {
                        $this->pChartObject->drawArrow(
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY1 + $AxisSettings["Margin"],
                            $AxisPos["R"],
                            $this->pChartObject->GraphAreaY1 - ($ArrowSize * 2),
                            [
                                "FillR" => $AxisR,
                                "FillG" => $AxisG,
                                "FillB" => $AxisB,
                                "Size" => $ArrowSize
                            ]
                        );
                    }

$Height = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1)
                        - $AxisSettings["Margin"] * 2
                    ;
                    $Step = $Height / $AxisSettings["Rows"];
                    $SubTicksSize = $Step / 2;
                    $MaxLeft = $AxisPos["R"];
                    $LastY = null;
                    for ($i = 0; $i <= $AxisSettings["Rows"]; $i++) {
                        $YPos = $this->pChartObject->GraphAreaY2 - $AxisSettings["Margin"] - $Step * $i;
                        $XPos = $AxisPos["R"];
                        $Value = $this->pChartObject->scaleFormat(
                            $AxisSettings["ScaleMin"] + $AxisSettings["RowHeight"] * $i,
                            $AxisSettings["Display"],
                            $AxisSettings["Format"],
                            $AxisSettings["Unit"]
                        );

if ($i % 2 == 1) {
                            $BGColor = [
                                "R" => $BackgroundR1,
                                "G" => $BackgroundG1,
                                "B" => $BackgroundB1,
                                "Alpha" => $BackgroundAlpha1
                            ];
                        } else {
                            $BGColor = [
                                "R" => $BackgroundR2,
                                "G" => $BackgroundG2,
                                "B" => $BackgroundB2,
                                "Alpha" => $BackgroundAlpha2
                            ];
                        }
                        if ($LastY != null
                            && $CycleBackground
                            && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))
                        ) {
                            $this->pChartObject->drawFilledRectangle(
                                $this->pChartObject->GraphAreaX1 + $FloatingOffset,
                                $LastY,
                                $this->pChartObject->GraphAreaX2 - $FloatingOffset,
                                $YPos,
                                $BGColor
                            );
                        }

if (($YPos != $this->pChartObject->GraphAreaY1
                            && $YPos != $this->pChartObject->GraphAreaY2)
                            && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))
                        ) {
                            $this->pChartObject->drawLine(
                                $this->pChartObject->GraphAreaX1 + $FloatingOffset,
                                $YPos,
                                $this->pChartObject->GraphAreaX2 - $FloatingOffset,
                                $YPos,
                                [
                                    "R" => $GridR,
                                    "G" => $GridG,
                                    "B" => $GridB,
                                    "Alpha" => $GridAlpha,
                                    "Ticks" => $GridTicks
                                ]
                            );
                        }

if ($DrawSubTicks && $i != $AxisSettings["Rows"]) {
                            $this->pChartObject->drawLine(
                                $XPos - $InnerSubTickWidth,
                                $YPos - $SubTicksSize,
                                $XPos + $OuterSubTickWidth,
                                $YPos - $SubTicksSize,
                                [
                                    "R" => $SubTickR,
                                    "G" => $SubTickG,
                                    "B" => $SubTickB,
                                    "Alpha" => $SubTickAlpha
                                ]
                            );
                        }
                        $this->pChartObject->drawLine(
                            $XPos - $InnerTickWidth,
                            $YPos,
                            $XPos + $OuterTickWidth,
                            $YPos,
                            ["R" => $TickR, "G" => $TickG, "B" => $TickB, "Alpha" => $TickAlpha]
                        );
                        $Bounds = $this->pChartObject->drawText(
                            $XPos + $OuterTickWidth + 2,
                            $YPos,
                            $Value,
                            ["Align" => TEXT_ALIGN_MIDDLELEFT]
                        );
                        $TxtLeft = $XPos + $OuterTickWidth + 2 + ($Bounds[1]["X"] - $Bounds[0]["X"]);
                        $MaxLeft = max($MaxLeft, $TxtLeft);

$LastY = $YPos;
                    }

if (isset($AxisSettings["Name"])) {
                        $XPos = $MaxLeft + 6;
                        $YPos = $this->pChartObject->GraphAreaY1
                            + ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1) / 2
                        ;
                        $Bounds = $this->pChartObject->drawText(
                            $XPos,
                            $YPos,
                            $AxisSettings["Name"],
                            ["Align" => TEXT_ALIGN_BOTTOMMIDDLE, "Angle" => 270]
                        );
                        $MaxLeft = $Bounds[2]["X"];

$this->pDataObject->Data["GraphArea"]["X2"] = $MaxLeft + $this->pChartObject->FontSize;
                    }

$AxisPos["R"] = $MaxLeft + $ScaleSpacing;
                }
            }
        }

$this->pDataObject->saveAxisConfig($Data["Axis"]);
    }

/**
     * Draw a scatter plot chart
     * @param array $Format
     */
    public function drawScatterPlotChart($Format = null)
    {
        $PlotSize = isset($Format["PlotSize"]) ? $Format["PlotSize"] : 3;
        $PlotBorder = isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : false;
        $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : 250;
        $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : 250;
        $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : 250;
        $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;
        $BorderSize = isset($Format["BorderSize"]) ? $Format["BorderSize"] : 1;
        $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
        $ImageMapTitle = isset($Format["ImageMapTitle"]) ? $Format["ImageMapTitle"] : null;

$Data = $this->pDataObject->getData();

$BorderColor = ["R" => $BorderR, "G" => $BorderG, "B" => $BorderB, "Alpha" => $BorderAlpha];

foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true) {
                $SerieX = $Series["X"];
                $SerieValuesX = $Data["Series"][$SerieX]["Data"];
                $SerieXAxis = $Data["Series"][$SerieX]["Axis"];
                $SerieY = $Series["Y"];
                $SerieValuesY = $Data["Series"][$SerieY]["Data"];
                $SerieYAxis = $Data["Series"][$SerieY]["Axis"];

if ($ImageMapTitle == null) {
                    $Description = sprintf(
                        "%s / %s",
                        $Data["Series"][$Series["X"]]["Description"],
                        $Data["Series"][$Series["Y"]]["Description"]
                    );
                } else {
                    $Description = $ImageMapTitle;
                }

if (isset($Series["Picture"]) && $Series["Picture"] != "") {
                    $Picture = $Series["Picture"];
                    list($PicWidth, $PicHeight, $PicType) = $this->pChartObject->getPicInfo($Picture);
                } else {
                    $Picture = null;
                }

$PosArrayX = $this->getPosArray($SerieValuesX, $SerieXAxis);
                if (!is_array($PosArrayX)) {
                    $Value = $PosArrayX;
                    $PosArrayX = [];
                    $PosArrayX[0] = $Value;
                }
                $PosArrayY = $this->getPosArray($SerieValuesY, $SerieYAxis);
                if (!is_array($PosArrayY)) {
                    $Value = $PosArrayY;
                    $PosArrayY = [];
                    $PosArrayY[0] = $Value;
                }

$Color = [
                    "R" => $Series["Color"]["R"],
                    "G" => $Series["Color"]["G"],
                    "B" => $Series["Color"]["B"],
                    "Alpha" => $Series["Color"]["Alpha"]
                ];

foreach ($PosArrayX as $Key => $Value) {
                    $X = $Value;
                    $Y = $PosArrayY[$Key];

if ($X != VOID && $Y != VOID) {
                        $RealValue = sprintf(
                            "%s / %s",
                            round($Data["Series"][$Series["X"]]["Data"][$Key], 2),
                            round($Data["Series"][$Series["Y"]]["Data"][$Key], 2)
                        );
                        if ($RecordImageMap) {
                            $this->pChartObject->addToImageMap(
                                "CIRCLE",
                                sprintf(
                                    "%s,%s,%s",
                                    floor($X),
                                    floor($Y),
                                    floor($PlotSize + $BorderSize)
                                ),
                                $this->pChartObject->toHTMLColor(
                                    $Series["Color"]["R"],
                                    $Series["Color"]["G"],
                                    $Series["Color"]["B"]
                                ),
                                $Description,
                                $RealValue
                            );
                        }

if (isset($Series["Shape"])) {
                            $this->pChartObject->drawShape(
                                $X,
                                $Y,
                                $Series["Shape"],
                                $PlotSize,
                                $PlotBorder,
                                $BorderSize,
                                $Series["Color"]["R"],
                                $Series["Color"]["G"],
                                $Series["Color"]["B"],
                                $Series["Color"]["Alpha"],
                                $BorderR,
                                $BorderG,
                                $BorderB,
                                $BorderAlpha
                            );
                        } elseif ($Picture == null) {
                            if ($PlotBorder) {
                                $this->pChartObject->drawFilledCircle(
                                    $X,
                                    $Y,
                                    $PlotSize + $BorderSize,
                                    $BorderColor
                                );
                            }
                            $this->pChartObject->drawFilledCircle($X, $Y, $PlotSize, $Color);
                        } else {
                            $this->pChartObject->drawFromPicture(
                                $PicType,
                                $Picture,
                                $X - $PicWidth / 2,
                                $Y - $PicHeight / 2
                            );
                        }
                    }
                }
            }
        }
    }

/**
     * Draw a scatter line chart
     * @param array $Format
     */
    public function drawScatterLineChart($Format = null)
    {
        $Data = $this->pDataObject->getData();
        $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
        $ImageMapTitle = isset($Format["ImageMapTitle"]) ? $Format["ImageMapTitle"] : null;
        $ImageMapPlotSize = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 10;

/* Parse all the series to draw */
        foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true) {
                $SerieX = $Series["X"];
                $SerieValuesX = $Data["Series"][$SerieX]["Data"];
                $SerieXAxis = $Data["Series"][$SerieX]["Axis"];
                $SerieY = $Series["Y"];
                $SerieValuesY = $Data["Series"][$SerieY]["Data"];
                $SerieYAxis = $Data["Series"][$SerieY]["Axis"];
                $Ticks = $Series["Ticks"];
                $Weight = $Series["Weight"];

$Color = [
                    "R" => $Series["Color"]["R"],
                    "G" => $Series["Color"]["G"],
                    "B" => $Series["Color"]["B"],
                    "Alpha" => $Series["Color"]["Alpha"]
                ];
                if ($Ticks != 0) {
                    $Color["Ticks"] = $Ticks;
                }
                if ($Weight != 0) {
                    $Color["Weight"] = $Weight;
                }

$LastX = VOID;
                $LastY = VOID;
                foreach ($PosArrayX as $Key => $Value) {
                    $X = $Value;
                    $Y = $PosArrayY[$Key];

if ($X != VOID && $Y != VOID) {
                        $RealValue = sprintf(
                            "%s / %s",
                            round($Data["Series"][$Series["X"]]["Data"][$Key], 2),
                            round($Data["Series"][$Series["Y"]]["Data"][$Key], 2)
                        );
                        if ($RecordImageMap) {
                            $this->pChartObject->addToImageMap(
                                "CIRCLE",
                                sprintf("%s,%s,%s", floor($X), floor($Y), $ImageMapPlotSize),
                                $this->pChartObject->toHTMLColor(
                                    $Series["Color"]["R"],
                                    $Series["Color"]["G"],
                                    $Series["Color"]["B"]
                                ),
                                $Description,
                                $RealValue
                            );
                        }
                    }

if ($X != VOID && $Y != VOID && $LastX != VOID && $LastY != VOID) {
                        $this->pChartObject->drawLine($LastX, $LastY, $X, $Y, $Color);
                    }
                    $LastX = $X;
                    $LastY = $Y;
                }
            }
        }
    }

/**
     * Draw a scatter spline chart
     * @param array $Format
     */
    public function drawScatterSplineChart(array $Format = [])
    {
        $Data = $this->pDataObject->getData();
        $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
        $ImageMapTitle = isset($Format["ImageMapTitle"]) ? $Format["ImageMapTitle"] : null;
        $ImageMapPlotSize = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 10;

$SplineSettings = [
                    "R" => $Series["Color"]["R"],
                    "G" => $Series["Color"]["G"],
                    "B" => $Series["Color"]["B"],
                    "Alpha" => $Series["Color"]["Alpha"]
                ];
                if ($Ticks != 0) {
                    $SplineSettings["Ticks"] = $Ticks;
                }
                if ($Weight != 0) {
                    $SplineSettings["Weight"] = $Weight;
                }

$LastX = VOID;
                $LastY = VOID;
                $WayPoints = [];
                $Forces = [];
                foreach ($PosArrayX as $Key => $Value) {
                    $X = $Value;
                    $Y = $PosArrayY[$Key];
                    $Force = $this->pChartObject->getLength($LastX, $LastY, $X, $Y) / 5;

if ($X != VOID && $Y != VOID) {
                        $RealValue = sprintf(
                            "%s / %s",
                            round($Data["Series"][$Series["X"]]["Data"][$Key], 2),
                            round($Data["Series"][$Series["Y"]]["Data"][$Key], 2)
                        );
                        if ($RecordImageMap) {
                            $this->pChartObject->addToImageMap(
                                "CIRCLE",
                                sprintf("%s,%s,%s", floor($X), floor($Y), $ImageMapPlotSize),
                                $this->pChartObject->toHTMLColor(
                                    $Series["Color"]["R"],
                                    $Series["Color"]["G"],
                                    $Series["Color"]["B"]
                                ),
                                $Description,
                                $RealValue
                            );
                        }
                    }

if ($X != VOID && $Y != VOID) {
                        $WayPoints[] = [$X, $Y];
                        $Forces[] = $Force;
                    }

if ($Y == VOID || $X == VOID) {
                        $SplineSettings["Forces"] = $Forces;
                        $this->pChartObject->drawSpline($WayPoints, $SplineSettings);
                        $WayPoints = [];
                        $Forces = [];
                    }

$LastX = $X;
                    $LastY = $Y;
                }
                $SplineSettings["Forces"] = $Forces;
                $this->pChartObject->drawSpline($WayPoints, $SplineSettings);
            }
        }
    }

/**
     * Return the scaled plot position
     * @param mixed $Values
     * @param string $AxisID
     * @return mixed
     */
    public function getPosArray($Values, $AxisID)
    {
        $Data = $this->pDataObject->getData();

if (!is_array($Values)) {
            $Values = [$Values];
        }

if ($Data["Axis"][$AxisID]["Identity"] == AXIS_X) {
            $Height = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1)
                - $Data["Axis"][$AxisID]["Margin"] * 2
            ;
            $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
            $Step = $Height / $ScaleHeight;

$Result = [];
            foreach ($Values as $Key => $Value) {
                if ($Value == VOID) {
                    $Result[] = VOID;
                } else {
                    $Result[] = $this->pChartObject->GraphAreaX1
                        + $Data["Axis"][$AxisID]["Margin"]
                        + ($Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]))
                    ;
                }
            }
        } else {
            $Height = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1)
                - $Data["Axis"][$AxisID]["Margin"] * 2
            ;
            $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
            $Step = $Height / $ScaleHeight;

$Result = [];
            foreach ($Values as $Key => $Value) {
                if ($Value == VOID) {
                    $Result[] = VOID;
                } else {
                    $Result[] = $this->pChartObject->GraphAreaY2
                        - $Data["Axis"][$AxisID]["Margin"]
                        - ($Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]))
                    ;
                }
            }
        }
        return count($Result) == 1 ? reset($Result) : $Result;
    }

/**
     * Draw the legend of the active series
     * @param int $X
     * @param int $Y
     * @param array $Format
     */
    public function drawScatterLegend($X, $Y, array $Format = [])
    {
        $Family = isset($Format["Family"]) ? $Format["Family"] : LEGEND_FAMILY_BOX;
        $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->pChartObject->FontName;
        $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->pChartObject->FontSize;
        $FontR = isset($Format["FontR"]) ? $Format["FontR"] : $this->pChartObject->FontColorR;
        $FontG = isset($Format["FontG"]) ? $Format["FontG"] : $this->pChartObject->FontColorG;
        $FontB = isset($Format["FontB"]) ? $Format["FontB"] : $this->pChartObject->FontColorB;
        $BoxWidth = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;
        $BoxHeight = isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;
        $IconAreaWidth = isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;
        $IconAreaHeight = isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;
        $XSpacing = isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;
        $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 5;
        $R = isset($Format["R"]) ? $Format["R"] : 200;
        $G = isset($Format["G"]) ? $Format["G"] : 200;
        $B = isset($Format["B"]) ? $Format["B"] : 200;
        $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
        $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : 255;
        $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : 255;
        $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : 255;
        $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : null;
        $Style = isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;
        $Mode = isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;

if ($Surrounding != null) {
            $BorderR = $R + $Surrounding;
            $BorderG = $G + $Surrounding;
            $BorderB = $B + $Surrounding;
        }

$Data = $this->pDataObject->getData();

foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true && isset($Series["Picture"])) {
                list($PicWidth, $PicHeight) = $this->pChartObject->getPicInfo($Series["Picture"]);
                if ($IconAreaWidth < $PicWidth) {
                    $IconAreaWidth = $PicWidth;
                }
                if ($IconAreaHeight < $PicHeight) {
                    $IconAreaHeight = $PicHeight;
                }
            }
        }

$YStep = max($this->pChartObject->FontSize, $IconAreaHeight) + 5;
        $XStep = $XSpacing;

$Boundaries = [];
        $Boundaries["L"] = $X;
        $Boundaries["T"] = $Y;
        $Boundaries["R"] = 0;
        $Boundaries["B"] = 0;
        $vY = $Y;
        $vX = $X;
        foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true) {
                if ($Mode == LEGEND_VERTICAL) {
                    $BoxArray = $this->pChartObject->getTextBox(
                        $vX + $IconAreaWidth + 4,
                        $vY + $IconAreaHeight / 2,
                        $FontName,
                        $FontSize,
                        0,
                        $Series["Description"]
                    );

if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
                        $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
                    }
                    if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
                        $Boundaries["R"] = $BoxArray[1]["X"] + 2;
                    }
                    if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
                        $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
                    }

$Lines = preg_split("/\n/", $Series["Description"]);
                    $vY = $vY + max($this->pChartObject->FontSize * count($Lines), $IconAreaHeight) + 5;
                } elseif ($Mode == LEGEND_HORIZONTAL) {
                    $Lines = preg_split("/\n/", $Series["Description"]);
                    $Width = [];
                    foreach ($Lines as $Key => $Value) {
                        $BoxArray = $this->pChartObject->getTextBox(
                            $vX + $IconAreaWidth + 6,
                            $Y + $IconAreaHeight / 2 + (($this->pChartObject->FontSize + 3) * $Key),
                            $FontName,
                            $FontSize,
                            0,
                            $Value
                        );

if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
                            $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
                        }
                        if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
                            $Boundaries["R"] = $BoxArray[1]["X"] + 2;
                        }
                        if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
                            $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
                        }

$Width[] = $BoxArray[1]["X"];
                    }
                    $vX = max($Width) + $XStep;
                }
            }
        }
        $vY = $vY - $YStep;
        $vX = $vX - $XStep;

$TopOffset = $Y - $Boundaries["T"];
        if ($Boundaries["B"] - ($vY + $IconAreaHeight) < $TopOffset) {
            $Boundaries["B"] = $vY + $IconAreaHeight + $TopOffset;
        }

if ($Style == LEGEND_ROUND) {
            $this->pChartObject->drawRoundedFilledRectangle(
                $Boundaries["L"] - $Margin,
                $Boundaries["T"] - $Margin,
                $Boundaries["R"] + $Margin,
                $Boundaries["B"] + $Margin,
                $Margin,
                [
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha,
                    "BorderR" => $BorderR,
                    "BorderG" => $BorderG,
                    "BorderB" => $BorderB
                ]
            );
        } elseif ($Style == LEGEND_BOX) {
            $this->pChartObject->drawFilledRectangle(
                $Boundaries["L"] - $Margin,
                $Boundaries["T"] - $Margin,
                $Boundaries["R"] + $Margin,
                $Boundaries["B"] + $Margin,
                [
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha,
                    "BorderR" => $BorderR,
                    "BorderG" => $BorderG,
                    "BorderB" => $BorderB
                ]
            );
        }
        $RestoreShadow = $this->pChartObject->Shadow;
        $this->Shadow = false;
        foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true) {
                $R = $Series["Color"]["R"];
                $G = $Series["Color"]["G"];
                $B = $Series["Color"]["B"];
                $Ticks = $Series["Ticks"];
                $Weight = $Series["Weight"];

if (isset($Series["Picture"])) {
                    $Picture = $Series["Picture"];
                    list($PicWidth, $PicHeight) = $this->pChartObject->getPicInfo($Picture);
                    $PicX = $X + $IconAreaWidth / 2;
                    $PicY = $Y + $IconAreaHeight / 2;

$this->pChartObject->drawFromPNG($PicX - $PicWidth / 2, $PicY - $PicHeight / 2, $Picture);
                } else {
                    if ($Family == LEGEND_FAMILY_BOX) {
                        if ($BoxWidth != $IconAreaWidth) {
                            $XOffset = floor(($IconAreaWidth - $BoxWidth) / 2);
                        } else {
                            $XOffset = 0;
                        }
                        if ($BoxHeight != $IconAreaHeight) {
                            $YOffset = floor(($IconAreaHeight - $BoxHeight) / 2);
                        } else {
                            $YOffset = 0;
                        }

$this->pChartObject->drawFilledRectangle(
                            $X + 1 + $XOffset,
                            $Y + 1 + $YOffset,
                            $X + $BoxWidth + $XOffset + 1,
                            $Y + $BoxHeight + 1 + $YOffset,
                            ["R" => 0, "G" => 0, "B" => 0, "Alpha" => 20]
                        );
                        $this->pChartObject->drawFilledRectangle(
                            $X + $XOffset,
                            $Y + $YOffset,
                            $X + $BoxWidth + $XOffset,
                            $Y + $BoxHeight + $YOffset,
                            ["R" => $R, "G" => $G, "B" => $B, "Surrounding" => 20]
                        );
                    } elseif ($Family == LEGEND_FAMILY_CIRCLE) {
                        $this->pChartObject->drawFilledCircle(
                            $X + 1 + $IconAreaWidth / 2,
                            $Y + 1 + $IconAreaHeight / 2,
                            min($IconAreaHeight / 2, $IconAreaWidth / 2),
                            ["R" => 0, "G" => 0, "B" => 0, "Alpha" => 20]
                        );
                        $this->pChartObject->drawFilledCircle(
                            $X + $IconAreaWidth / 2,
                            $Y + $IconAreaHeight / 2,
                            min($IconAreaHeight / 2, $IconAreaWidth / 2),
                            ["R" => $R, "G" => $G, "B" => $B, "Surrounding" => 20]
                        );
                    } elseif ($Family == LEGEND_FAMILY_LINE) {
                        $this->pChartObject->drawLine(
                            $X + 1,
                            $Y + 1 + $IconAreaHeight / 2,
                            $X + 1 + $IconAreaWidth,
                            $Y + 1 + $IconAreaHeight / 2,
                            [
                                "R" => 0,
                                "G" => 0,
                                "B" => 0,
                                "Alpha" => 20,
                                "Ticks" => $Ticks,
                                "Weight" => $Weight
                            ]
                        );
                        $this->pChartObject->drawLine(
                            $X,
                            $Y + $IconAreaHeight / 2,
                            $X + $IconAreaWidth,
                            $Y + $IconAreaHeight / 2,
                            ["R" => $R, "G" => $G, "B" => $B, "Ticks" => $Ticks, "Weight" => $Weight]
                        );
                    }
                }

if ($Mode == LEGEND_VERTICAL) {
                    $Lines = preg_split("/\n/", $Series["Description"]);
                    foreach ($Lines as $Key => $Value) {
                        $this->pChartObject->drawText(
                            $X + $IconAreaWidth + 4,
                            $Y + $IconAreaHeight / 2 + (($this->pChartObject->FontSize + 3) * $Key),
                            $Value,
                            [
                                "R" => $FontR,
                                "G" => $FontG,
                                "B" => $FontB,
                                "Align" => TEXT_ALIGN_MIDDLELEFT
                            ]
                        );
                    }
                    $Y = $Y + max($this->pChartObject->FontSize * count($Lines), $IconAreaHeight) + 5;
                } elseif ($Mode == LEGEND_HORIZONTAL) {
                    $Lines = preg_split("/\n/", $Series["Description"]);
                    $Width = [];
                    foreach ($Lines as $Key => $Value) {
                        $BoxArray = $this->pChartObject->drawText(
                            $X + $IconAreaWidth + 4,
                            $Y + $IconAreaHeight / 2 + (($this->pChartObject->FontSize + 3) * $Key),
                            $Value,
                            [
                                "R" => $FontR,
                                "G" => $FontG,
                                "B" => $FontB,
                                "Align" => TEXT_ALIGN_MIDDLELEFT
                            ]
                        );
                        $Width[] = $BoxArray[1]["X"];
                    }
                    $X = max($Width) + 2 + $XStep;
                }
            }
        }

$this->Shadow = $RestoreShadow;
    }

/**
     * Get the legend box size
     * @param array $Format
     * @return array
     */
    public function getScatterLegendSize(array $Format = [])
    {
        $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->pChartObject->FontName;
        $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->pChartObject->FontSize;
        $BoxSize = isset($Format["BoxSize"]) ? $Format["BoxSize"] : 5;
        $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 5;
        $Mode = isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;
        $XSpacing = isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;

$YStep = max($this->pChartObject->FontSize, $BoxSize) + 5;
        $XStep = $BoxSize + 5;

$X = 100;
        $Y = 100;

$Data = $this->pDataObject->getData();

$YStep = max($this->pChartObject->FontSize, $IconAreaHeight) + 5;
        $XStep = $XSpacing;

if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
                            $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
                        }
                        if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
                            $Boundaries["R"] = $BoxArray[1]["X"] + 2;
                        }
                        if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
                            $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
                        }

$Width[] = $BoxArray[1]["X"];
                    }
                    $vX = max($Width) + $XStep;
                }
            }
        }
        $vY = $vY - $YStep;
        $vX = $vX - $XStep;

$TopOffset = $Y - $Boundaries["T"];
        if ($Boundaries["B"] - ($vY + $BoxSize) < $TopOffset) {
            $Boundaries["B"] = $vY + $BoxSize + $TopOffset;
        }

$Width = ($Boundaries["R"] + $Margin) - ($Boundaries["L"] - $Margin);
        $Height = ($Boundaries["B"] + $Margin) - ($Boundaries["T"] - $Margin);

return ["Width" => $Width, "Height" => $Height];
    }

/**
     * Draw the line of best fit
     * @param array $Format
     */
    public function drawScatterBestFit(array $Format = [])
    {
        $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : 0;

$Data = $this->pDataObject->getData();

foreach ($Data["ScatterSeries"] as $Key => $Series) {
            if ($Series["isDrawable"] == true) {
                $SerieX = $Series["X"];
                $SerieXAxis = $Data["Series"][$SerieX]["Axis"];
                $SerieY = $Series["Y"];
                $SerieYAxis = $Data["Series"][$SerieY]["Axis"];

$Color = [
                    "R" => $Series["Color"]["R"],
                    "G" => $Series["Color"]["G"],
                    "B" => $Series["Color"]["B"],
                    "Alpha" => $Series["Color"]["Alpha"]
                ];
                $Color["Ticks"] = $Ticks;

$PosArrayX = $Data["Series"][$Series["X"]]["Data"];
                $PosArrayY = $Data["Series"][$Series["Y"]]["Data"];

$Sxy = 0;
                $Sx = 0;
                $Sy = 0;
                $Sxx = 0;
                foreach ($PosArrayX as $Key => $Value) {
                    $X = $Value;
                    $Y = $PosArrayY[$Key];

$Sxy = $Sxy + $X * $Y;
                    $Sx = $Sx + $X;
                    $Sy = $Sy + $Y;
                    $Sxx = $Sxx + $X * $X;
                }

$n = count($PosArrayX);

if ((($n * $Sxx) == ($Sx * $Sx))) {
                    $X1 = $this->getPosArray($Data["Axis"][$SerieXAxis]["ScaleMin"], $SerieXAxis);
                    $X2 = $X1;
                    $Y1 = $this->pChartObject->GraphAreaY1;
                    $Y2 = $this->pChartObject->GraphAreaY2;
                } else {
                    $M = (($n * $Sxy) - ($Sx * $Sy)) / (($n * $Sxx) - ($Sx * $Sx));
                    $B = (($Sy) - ($M * $Sx)) / ($n);

$X1 = $this->getPosArray($Data["Axis"][$SerieXAxis]["ScaleMin"], $SerieXAxis);
                    $Y1 = $this->getPosArray($M * $Data["Axis"][$SerieXAxis]["ScaleMin"] + $B, $SerieYAxis);
                    $X2 = $this->getPosArray($Data["Axis"][$SerieXAxis]["ScaleMax"], $SerieXAxis);
                    $Y2 = $this->getPosArray($M * $Data["Axis"][$SerieXAxis]["ScaleMax"] + $B, $SerieYAxis);

$RealM = -($Y2 - $Y1) / ($X2 - $X1);

if ($Y1 < $this->pChartObject->GraphAreaY1) {
                        $X1 = $X1 + ($this->pChartObject->GraphAreaY1 - $Y1 / $RealM);
                        $Y1 = $this->pChartObject->GraphAreaY1;
                    }
                    if ($Y1 > $this->pChartObject->GraphAreaY2) {
                        $X1 = $X1 + ($Y1 - $this->pChartObject->GraphAreaY2) / $RealM;
                        $Y1 = $this->pChartObject->GraphAreaY2;
                    }
                    if ($Y2 < $this->pChartObject->GraphAreaY1) {
                        $X2 = $X2 - ($this->pChartObject->GraphAreaY1 - $Y2) / $RealM;
                        $Y2 = $this->pChartObject->GraphAreaY1;
                    }
                    if ($Y2 > $this->pChartObject->GraphAreaY2) {
                        $X2 = $X2 - ($Y2 - $this->pChartObject->GraphAreaY2) / $RealM;
                        $Y2 = $this->pChartObject->GraphAreaY2;
                    }
                }

$this->pChartObject->drawLine($X1, $Y1, $X2, $Y2, $Color);
            }
        }
    }

/**
     *
     * @param string $ScatterSerieID
     * @param mixed $Points
     * @param array $Format
     * @return null|int
     */
    public function writeScatterLabel($ScatterSerieID, $Points, array $Format = [])
    {
        $DrawPoint = isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;
        $Decimals = isset($Format["Decimals"]) ? $Format["Decimals"] : null;

$Data = $this->pDataObject->getData();

if (!is_array($Points)) {
            $Points = [$Points];
        }

if (!isset($Data["ScatterSeries"][$ScatterSerieID])) {
            return 0;
        }
        $Series = $Data["ScatterSeries"][$ScatterSerieID];

$SerieX = $Series["X"];
        $SerieValuesX = $Data["Series"][$SerieX]["Data"];
        $SerieXAxis = $Data["Series"][$SerieX]["Axis"];

$SerieY = $Series["Y"];
        $SerieValuesY = $Data["Series"][$SerieY]["Data"];
        $SerieYAxis = $Data["Series"][$SerieY]["Axis"];

$PosArrayX = $this->getPosArray($SerieValuesX, $SerieXAxis);
        if (!is_array($PosArrayX)) {
            $Value = $PosArrayX;
            $PosArrayX = [];
            $PosArrayX[0] = $Value;
        }
        $PosArrayY = $this->getPosArray($SerieValuesY, $SerieYAxis);
        if (!is_array($PosArrayY)) {
            $Value = $PosArrayY;
            $PosArrayY = [];
            $PosArrayY[0] = $Value;
        }

foreach ($Points as $Key => $Point) {
            if (isset($PosArrayX[$Point]) && isset($PosArrayY[$Point])) {
                $X = floor($PosArrayX[$Point]);
                $Y = floor($PosArrayY[$Point]);

if ($DrawPoint == LABEL_POINT_CIRCLE) {
                    $this->pChartObject->drawFilledCircle(
                        $X,
                        $Y,
                        3,
                        [
                            "R" => 255,
                            "G" => 255,
                            "B" => 255,
                            "BorderR" => 0,
                            "BorderG" => 0,
                            "BorderB" => 0
                        ]
                    );
                } elseif ($DrawPoint == LABEL_POINT_BOX) {
                    $this->pChartObject->drawFilledRectangle(
                        $X - 2,
                        $Y - 2,
                        $X + 2,
                        $Y + 2,
                        [
                            "R" => 255,
                            "G" => 255,
                            "B" => 255,
                            "BorderR" => 0,
                            "BorderG" => 0,
                            "BorderB" => 0
                        ]
                    );
                }
                $Serie = [];
                $Serie["R"] = $Series["Color"]["R"];
                $Serie["G"] = $Series["Color"]["G"];
                $Serie["B"] = $Series["Color"]["B"];
                $Serie["Alpha"] = $Series["Color"]["Alpha"];

$XAxisMode = $Data["Axis"][$SerieXAxis]["Display"];
                $XAxisFormat = $Data["Axis"][$SerieXAxis]["Format"];
                $XAxisUnit = $Data["Axis"][$SerieXAxis]["Unit"];
                if ($Decimals == null) {
                    $XValue = $SerieValuesX[$Point];
                } else {
                    $XValue = round($SerieValuesX[$Point], $Decimals);
                }
                $XValue = $this->pChartObject->scaleFormat($XValue, $XAxisMode, $XAxisFormat, $XAxisUnit);

$YAxisMode = $Data["Axis"][$SerieYAxis]["Display"];
                $YAxisFormat = $Data["Axis"][$SerieYAxis]["Format"];
                $YAxisUnit = $Data["Axis"][$SerieYAxis]["Unit"];
                if ($Decimals == null) {
                    $YValue = $SerieValuesY[$Point];
                } else {
                    $YValue = round($SerieValuesY[$Point], $Decimals);
                }
                $YValue = $this->pChartObject->scaleFormat($YValue, $YAxisMode, $YAxisFormat, $YAxisUnit);

$Caption = sprintf("%s / %s", $XValue, $YValue);

if (isset($Series["Description"])) {
                    $Description = $Series["Description"];
                } else {
                    $Description = "No description";
                }
                $Series = [["Format" => $Serie, "Caption" => $Caption]];

$this->pChartObject->drawLabelBox($X, $Y - 3, $Description, $Series, $Format);
            }
        }
    }

/**
     * Draw a Scatter threshold
     * @param mixed $Value
     * @param array $Format
     * @return array
     */
    public function drawScatterThreshold($Value, array $Format = [])
    {
        $AxisID = isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
        $R = isset($Format["R"]) ? $Format["R"] : 255;
        $G = isset($Format["G"]) ? $Format["G"] : 0;
        $B = isset($Format["B"]) ? $Format["B"] : 0;
        $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 50;
        $Weight = isset($Format["Weight"]) ? $Format["Weight"] : null;
        $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : 3;
        $Wide = isset($Format["Wide"]) ? $Format["Wide"] : false;
        $WideFactor = isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;
        $WriteCaption = isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : false;
        $Caption = isset($Format["Caption"]) ? $Format["Caption"] : null;
        $CaptionAlign = isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;
        $CaptionOffset = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 10;
        $CaptionR = isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;
        $CaptionG = isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;
        $CaptionB = isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;
        $CaptionAlpha = isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;
        $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : true;
        $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : false;
        $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;
        $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : true;
        $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
        $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
        $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
        $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
        $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;
        $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
        $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
        $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
        $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
        $BoxBorderAlpha = isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

$CaptionSettings = [
            "DrawBox" => $DrawBox,
            "DrawBoxBorder" => $DrawBoxBorder,
            "BorderOffset" => $BorderOffset,
            "BoxRounded" => $BoxRounded,
            "RoundedRadius" => $RoundedRadius,
            "BoxR" => $BoxR,
            "BoxG" => $BoxG,
            "BoxB" => $BoxB,
            "BoxAlpha" => $BoxAlpha,
            "BoxSurrounding" => $BoxSurrounding,
            "BoxBorderR" => $BoxBorderR,
            "BoxBorderG" => $BoxBorderG,
            "BoxBorderB" => $BoxBorderB,
            "BoxBorderAlpha" => $BoxBorderAlpha,
            "R" => $CaptionR,
            "G" => $CaptionG,
            "B" => $CaptionB,
            "Alpha" => $CaptionAlpha
        ];

if ($Caption == null) {
            $Caption = $Value;
        }

$Data = $this->pDataObject->getData();

if (!isset($Data["Axis"][$AxisID])) {
            return -1;
        }

if ($Data["Axis"][$AxisID]["Identity"] == AXIS_Y) {
            $X1 = $this->pChartObject->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"];
            $X2 = $this->pChartObject->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"];
            $Y = $this->getPosArray($Value, $AxisID);

$this->pChartObject->drawLine(
                $X1,
                $Y,
                $X2,
                $Y,
                [
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha,
                    "Ticks" => $Ticks,
                    "Weight" => $Weight
                ]
            );

if ($Wide) {
                $this->pChartObject->drawLine(
                    $X1,
                    $Y - 1,
                    $X2,
                    $Y - 1,
                    [
                        "R" => $R,
                        "G" => $G,
                        "B" => $B,
                        "Alpha" => $Alpha / $WideFactor,
                        "Ticks" => $Ticks
                    ]
                );
                $this->pChartObject->drawLine(
                    $X1,
                    $Y + 1,
                    $X2,
                    $Y + 1,
                    [
                        "R" => $R,
                        "G" => $G,
                        "B" => $B,
                        "Alpha" => $Alpha / $WideFactor,
                        "Ticks" => $Ticks
                    ]
                );
            }

if ($WriteCaption) {
                if ($CaptionAlign == CAPTION_LEFT_TOP) {
                    $X = $this->pChartObject->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] + $CaptionOffset;
                    $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT;
                } else {
                    $X = $this->pChartObject->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"] - $CaptionOffset;
                    $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT;
                }
                $this->pChartObject->drawText($X, $Y, $Caption, $CaptionSettings);
            }

return ["Y" => $Y];
        } elseif ($Data["Axis"][$AxisID]["Identity"] == AXIS_X) {
            $X = $this->getPosArray($Value, $AxisID);
            $Y1 = $this->pChartObject->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"];
            $Y2 = $this->pChartObject->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"];

$this->pChartObject->drawLine(
                $X,
                $Y1,
                $X,
                $Y2,
                [
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha,
                    "Ticks" => $Ticks,
                    "Weight" => $Weight
                ]
            );

if ($Wide) {
                $this->pChartObject->drawLine(
                    $X - 1,
                    $Y1,
                    $X - 1,
                    $Y2,
                    ["R" => $R, "G" => $G, "B" => $B, "Alpha" => $Alpha / $WideFactor, "Ticks" => $Ticks]
                );
                $this->pChartObject->drawLine(
                    $X + 1,
                    $Y1,
                    $X + 1,
                    $Y2,
                    ["R" => $R, "G" => $G, "B" => $B, "Alpha" => $Alpha / $WideFactor, "Ticks" => $Ticks]
                );
            }

if ($WriteCaption) {
                if ($CaptionAlign == CAPTION_LEFT_TOP) {
                    $Y = $this->pChartObject->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"] + $CaptionOffset;
                    $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
                } else {
                    $Y = $this->pChartObject->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"] - $CaptionOffset;
                    $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE;
                }

$CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
                $this->pChartObject->drawText($X, $Y, $Caption, $CaptionSettings);
            }

return ["X" => $X];
        }
    }

/**
     * Draw a Scatter threshold area
     * @param int|float $Value1
     * @param int|float $Value2
     * @param array $Format
     * @return type
     */
    public function drawScatterThresholdArea($Value1, $Value2, array $Format = [])
    {
        $AxisID = isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
        $R = isset($Format["R"]) ? $Format["R"] : 255;
        $G = isset($Format["G"]) ? $Format["G"] : 0;
        $B = isset($Format["B"]) ? $Format["B"] : 0;
        $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 20;
        $Border = isset($Format["Border"]) ? $Format["Border"] : true;
        $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
        $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
        $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
        $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;
        $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;
        $AreaName = isset($Format["AreaName"]) ? $Format["AreaName"] : "La ouate de phoque"; //null;
        $NameAngle = isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;
        $NameR = isset($Format["NameR"]) ? $Format["NameR"] : 255;
        $NameG = isset($Format["NameG"]) ? $Format["NameG"] : 255;
        $NameB = isset($Format["NameB"]) ? $Format["NameB"] : 255;
        $NameAlpha = isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;
        $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : true;

if ($Value1 > $Value2) {
            list($Value1, $Value2) = [$Value2, $Value1];
        }

$RestoreShadow = $this->pChartObject->Shadow;
        if ($DisableShadowOnArea && $this->pChartObject->Shadow) {
            $this->pChartObject->Shadow = false;
        }

if ($BorderAlpha > 100) {
            $BorderAlpha = 100;
        }

$Data = $this->pDataObject->getData();

if (!isset($Data["Axis"][$AxisID])) {
            return -1;
        }

if ($Data["Axis"][$AxisID]["Identity"] == AXIS_X) {
            $Y1 = $this->pChartObject->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"];
            $Y2 = $this->pChartObject->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"];
            $X1 = $this->getPosArray($Value1, $AxisID);
            $X2 = $this->getPosArray($Value2, $AxisID);

if ($X1 <= $this->pChartObject->GraphAreaX1) {
                $X1 = $this->pChartObject->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"];
            }
            if ($X2 >= $this->pChartObject->GraphAreaX2) {
                $X2 = $this->pChartObject->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"];
            }

$this->pChartObject->drawFilledRectangle(
                $X1,
                $Y1,
                $X2,
                $Y2,
                ["R" => $R, "G" => $G, "B" => $B, "Alpha" => $Alpha]
            );

if ($Border) {
                $this->pChartObject->drawLine(
                    $X1,
                    $Y1,
                    $X1,
                    $Y2,
                    [
                        "R" => $BorderR,
                        "G" => $BorderG,
                        "B" => $BorderB,
                        "Alpha" => $BorderAlpha,
                        "Ticks" => $BorderTicks
                    ]
                );
                $this->pChartObject->drawLine(
                    $X2,
                    $Y1,
                    $X2,
                    $Y2,
                    [
                        "R" => $BorderR,
                        "G" => $BorderG,
                        "B" => $BorderB,
                        "Alpha" => $BorderAlpha,
                        "Ticks" => $BorderTicks
                    ]
                );
            }

if ($AreaName != null) {
                $XPos = ($X2 - $X1) / 2 + $X1;
                $YPos = ($Y2 - $Y1) / 2 + $Y1;

if ($NameAngle == ZONE_NAME_ANGLE_AUTO) {
                    $TxtPos = $this->pChartObject->getTextBox(
                        $XPos,
                        $YPos,
                        $this->pChartObject->FontName,
                        $this->pChartObject->FontSize,
                        0,
                        $AreaName
                    );
                    $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];
                    if (abs($X2 - $X1) > $TxtWidth) {
                        $NameAngle = 0;
                    } else {
                        $NameAngle = 90;
                    }
                }
                $this->pChartObject->Shadow = $RestoreShadow;
                $this->pChartObject->drawText(
                    $XPos,
                    $YPos,
                    $AreaName,
                    [
                        "R" => $NameR,
                        "G" => $NameG,
                        "B" => $NameB,
                        "Alpha" => $NameAlpha,
                        "Angle" => $NameAngle,
                        "Align" => TEXT_ALIGN_MIDDLEMIDDLE
                    ]
                );
                if ($DisableShadowOnArea) {
                    $this->pChartObject->Shadow = false;
                }
            }

$this->pChartObject->Shadow = $RestoreShadow;
            return ["X1" => $X1, "X2" => $X2];
        } elseif ($Data["Axis"][$AxisID]["Identity"] == AXIS_Y) {
            $X1 = $this->pChartObject->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"];
            $X2 = $this->pChartObject->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"];
            $Y1 = $this->getPosArray($Value1, $AxisID);
            $Y2 = $this->getPosArray($Value2, $AxisID);

if ($Y1 >= $this->pChartObject->GraphAreaY2) {
                $Y1 = $this->pChartObject->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"];
            }
            if ($Y2 <= $this->pChartObject->GraphAreaY1) {
                $Y2 = $this->pChartObject->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"];
            }

if ($Border) {
                $this->pChartObject->drawLine(
                    $X1,
                    $Y1,
                    $X2,
                    $Y1,
                    [
                        "R" => $BorderR,
                        "G" => $BorderG,
                        "B" => $BorderB,
                        "Alpha" => $BorderAlpha,
                        "Ticks" => $BorderTicks
                    ]
                );
                $this->pChartObject->drawLine(
                    $X1,
                    $Y2,
                    $X2,
                    $Y2,
                    [
                        "R" => $BorderR,
                        "G" => $BorderG,
                        "B" => $BorderB,
                        "Alpha" => $BorderAlpha,
                        "Ticks" => $BorderTicks
                    ]
                );
            }

if ($AreaName != null) {
                $XPos = ($X2 - $X1) / 2 + $X1;
                $YPos = ($Y2 - $Y1) / 2 + $Y1;

$this->pChartObject->Shadow = $RestoreShadow;
                $this->pChartObject->drawText(
                    $YPos,
                    $XPos,
                    $AreaName,
                    [
                        "R" => $NameR,
                        "G" => $NameG,
                        "B" => $NameB,
                        "Alpha" => $NameAlpha,
                        "Angle" => 0,
                        "Align" => TEXT_ALIGN_MIDDLEMIDDLE
                    ]
                );
                if ($DisableShadowOnArea) {
                    $this->Shadow = false;
                }
            }

$this->pChartObject->Shadow = $RestoreShadow;
            return ["Y1" => $Y1, "Y2" => $Y2];
        }
    }
}

Ubuntu

Sid Gifari From Gifari Industries - BD Cyber Security Team