974 lines
31 KiB
PHP
974 lines
31 KiB
PHP
<?php
|
|
/*=======================================================================
|
|
// File: JPGRAPH_POLAR.PHP
|
|
// Description: Polar plot extension for JpGraph
|
|
// Created: 2003-02-02
|
|
// Ver: $Id: jpgraph_polar.php 1796 2009-09-07 09:37:19Z ljp $
|
|
//
|
|
// Copyright (c) Asial Corporation. All rights reserved.
|
|
//========================================================================
|
|
*/
|
|
|
|
require_once('jpgraph_plotmark.inc.php');
|
|
require_once "jpgraph_log.php";
|
|
|
|
|
|
define('POLAR_360', 1);
|
|
define('POLAR_180', 2);
|
|
|
|
//
|
|
// Note. Don't attempt to make sense of this code.
|
|
// In order not to have to be able to inherit the scaling code
|
|
// from the main graph package we have had to make some "tricks" since
|
|
// the original scaling and axis was not designed to do what is
|
|
// required here.
|
|
// There were two option. 1: Re-implement everything and get a clean design
|
|
// and 2: do some "small" trickery and be able to inherit most of
|
|
// the functionlity from the main graph package.
|
|
// We choose 2: here in order to save some time.
|
|
//
|
|
|
|
//--------------------------------------------------------------------------
|
|
// class PolarPlot
|
|
//--------------------------------------------------------------------------
|
|
class PolarPlot
|
|
{
|
|
public $line_style='solid';
|
|
public $mark;
|
|
public $legendcsimtarget='';
|
|
public $legendcsimalt='';
|
|
public $legend="";
|
|
public $csimtargets=array(); // Array of targets for CSIM
|
|
public $csimareas=""; // Resultant CSIM area tags
|
|
public $csimalts=null; // ALT:s for corresponding target
|
|
public $scale=null;
|
|
private $numpoints=0;
|
|
private $iColor='navy';
|
|
private $iFillColor='';
|
|
private $iLineWeight=1;
|
|
private $coord=null;
|
|
|
|
public function __construct($aData)
|
|
{
|
|
$n = count($aData);
|
|
if ($n & 1) {
|
|
JpGraphError::RaiseL(17001);
|
|
//('Polar plots must have an even number of data point. Each data point is a tuple (angle,radius).');
|
|
}
|
|
$this->numpoints = $n/2;
|
|
$this->coord = $aData;
|
|
$this->mark = new PlotMark();
|
|
}
|
|
|
|
public function SetWeight($aWeight)
|
|
{
|
|
$this->iLineWeight = $aWeight;
|
|
}
|
|
|
|
public function SetColor($aColor)
|
|
{
|
|
$this->iColor = $aColor;
|
|
}
|
|
|
|
public function SetFillColor($aColor)
|
|
{
|
|
$this->iFillColor = $aColor;
|
|
}
|
|
|
|
public function Max()
|
|
{
|
|
$m = $this->coord[1];
|
|
$i=1;
|
|
while ($i < $this->numpoints) {
|
|
$m = max($m, $this->coord[2*$i+1]);
|
|
++$i;
|
|
}
|
|
return $m;
|
|
}
|
|
// Set href targets for CSIM
|
|
public function SetCSIMTargets($aTargets, $aAlts=null)
|
|
{
|
|
$this->csimtargets=$aTargets;
|
|
$this->csimalts=$aAlts;
|
|
}
|
|
|
|
// Get all created areas
|
|
public function GetCSIMareas()
|
|
{
|
|
return $this->csimareas;
|
|
}
|
|
|
|
public function SetLegend($aLegend, $aCSIM="", $aCSIMAlt="")
|
|
{
|
|
$this->legend = $aLegend;
|
|
$this->legendcsimtarget = $aCSIM;
|
|
$this->legendcsimalt = $aCSIMAlt;
|
|
}
|
|
|
|
// Private methods
|
|
|
|
public function Legend($aGraph)
|
|
{
|
|
$color = $this->iColor ;
|
|
if ($this->legend != "") {
|
|
if ($this->iFillColor!='') {
|
|
$color = $this->iFillColor;
|
|
$aGraph->legend->Add(
|
|
$this->legend,
|
|
$color,
|
|
$this->mark,
|
|
0,
|
|
$this->legendcsimtarget,
|
|
$this->legendcsimalt
|
|
);
|
|
} else {
|
|
$aGraph->legend->Add(
|
|
$this->legend,
|
|
$color,
|
|
$this->mark,
|
|
$this->line_style,
|
|
$this->legendcsimtarget,
|
|
$this->legendcsimalt
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function Stroke($img, $scale)
|
|
{
|
|
$i=0;
|
|
$p=array();
|
|
$this->csimareas='';
|
|
while ($i < $this->numpoints) {
|
|
list($x1, $y1) = $scale->PTranslate($this->coord[2*$i], $this->coord[2*$i+1]);
|
|
$p[2*$i] = $x1;
|
|
$p[2*$i+1] = $y1;
|
|
|
|
if (isset($this->csimtargets[$i])) {
|
|
$this->mark->SetCSIMTarget($this->csimtargets[$i]);
|
|
$this->mark->SetCSIMAlt($this->csimalts[$i]);
|
|
$this->mark->SetCSIMAltVal($this->coord[2*$i], $this->coord[2*$i+1]);
|
|
$this->mark->Stroke($img, $x1, $y1);
|
|
$this->csimareas .= $this->mark->GetCSIMAreas();
|
|
} else {
|
|
$this->mark->Stroke($img, $x1, $y1);
|
|
}
|
|
|
|
++$i;
|
|
}
|
|
|
|
if ($this->iFillColor != '') {
|
|
$img->SetColor($this->iFillColor);
|
|
$img->FilledPolygon($p);
|
|
}
|
|
$img->SetLineWeight($this->iLineWeight);
|
|
$img->SetColor($this->iColor);
|
|
$img->Polygon($p, $this->iFillColor!='');
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// class PolarAxis
|
|
//--------------------------------------------------------------------------
|
|
class PolarAxis extends Axis
|
|
{
|
|
private $angle_step=15;
|
|
private $angle_color='lightgray';
|
|
private $angle_label_color='black';
|
|
private $angle_fontfam=FF_FONT1;
|
|
private $angle_fontstyle=FS_NORMAL;
|
|
private $angle_fontsize=10;
|
|
private $angle_fontcolor = 'navy';
|
|
private $gridminor_color='lightgray';
|
|
private $gridmajor_color='lightgray';
|
|
private $show_minor_grid = false;
|
|
private $show_major_grid = true ;
|
|
private $show_angle_mark=true;
|
|
private $show_angle_grid=true;
|
|
private $show_angle_label=true;
|
|
private $angle_tick_len=3;
|
|
private $angle_tick_len2=3;
|
|
private $angle_tick_color='black';
|
|
private $show_angle_tick=true;
|
|
private $radius_tick_color='black';
|
|
|
|
public function __construct($img, $aScale)
|
|
{
|
|
parent::__construct($img, $aScale);
|
|
}
|
|
|
|
public function ShowAngleDegreeMark($aFlg=true)
|
|
{
|
|
$this->show_angle_mark = $aFlg;
|
|
}
|
|
|
|
public function SetAngleStep($aStep)
|
|
{
|
|
$this->angle_step=$aStep;
|
|
}
|
|
|
|
public function HideTicks($aFlg=true, $aAngleFlg=true)
|
|
{
|
|
parent::HideTicks($aFlg, $aFlg);
|
|
$this->show_angle_tick = !$aAngleFlg;
|
|
}
|
|
|
|
public function ShowAngleLabel($aFlg=true)
|
|
{
|
|
$this->show_angle_label = $aFlg;
|
|
}
|
|
|
|
public function ShowGrid($aMajor=true, $aMinor=false, $aAngle=true)
|
|
{
|
|
$this->show_minor_grid = $aMinor;
|
|
$this->show_major_grid = $aMajor;
|
|
$this->show_angle_grid = $aAngle ;
|
|
}
|
|
|
|
public function SetAngleFont($aFontFam, $aFontStyle=FS_NORMAL, $aFontSize=10)
|
|
{
|
|
$this->angle_fontfam = $aFontFam;
|
|
$this->angle_fontstyle = $aFontStyle;
|
|
$this->angle_fontsize = $aFontSize;
|
|
}
|
|
|
|
public function SetColor($aColor, $aRadColor='', $aAngleColor='')
|
|
{
|
|
if ($aAngleColor == '') {
|
|
$aAngleColor=$aColor;
|
|
}
|
|
parent::SetColor($aColor, $aRadColor);
|
|
$this->angle_fontcolor = $aAngleColor;
|
|
}
|
|
|
|
public function SetGridColor($aMajorColor, $aMinorColor='', $aAngleColor='')
|
|
{
|
|
if ($aMinorColor == '') {
|
|
$aMinorColor = $aMajorColor;
|
|
}
|
|
if ($aAngleColor == '') {
|
|
$aAngleColor = $aMajorColor;
|
|
}
|
|
|
|
$this->gridminor_color = $aMinorColor;
|
|
$this->gridmajor_color = $aMajorColor;
|
|
$this->angle_color = $aAngleColor;
|
|
}
|
|
|
|
public function SetTickColors($aRadColor, $aAngleColor='')
|
|
{
|
|
$this->radius_tick_color = $aRadColor;
|
|
$this->angle_tick_color = $aAngleColor;
|
|
}
|
|
|
|
// Private methods
|
|
public function StrokeGrid($pos)
|
|
{
|
|
$x = round($this->img->left_margin + $this->img->plotwidth/2);
|
|
$this->scale->ticks->Stroke($this->img, $this->scale, $pos);
|
|
|
|
// Stroke the minor arcs
|
|
$pmin = array();
|
|
$p = $this->scale->ticks->ticks_pos;
|
|
$n = count($p);
|
|
$i = 0;
|
|
$this->img->SetColor($this->gridminor_color);
|
|
while ($i < $n) {
|
|
$r = $p[$i]-$x+1;
|
|
$pmin[]=$r;
|
|
if ($this->show_minor_grid) {
|
|
$this->img->Circle($x, $pos, $r);
|
|
}
|
|
$i++;
|
|
}
|
|
|
|
$limit = max($this->img->plotwidth, $this->img->plotheight)*1.4 ;
|
|
while ($r < $limit) {
|
|
$off = $r;
|
|
$i=1;
|
|
$r = $off + round($p[$i]-$x+1);
|
|
while ($r < $limit && $i < $n) {
|
|
$r = $off+$p[$i]-$x;
|
|
$pmin[]=$r;
|
|
if ($this->show_minor_grid) {
|
|
$this->img->Circle($x, $pos, $r);
|
|
}
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
// Stroke the major arcs
|
|
if ($this->show_major_grid) {
|
|
// First determine how many minor step on
|
|
// every major step. We have recorded the minor radius
|
|
// in pmin and use these values. This is done in order
|
|
// to avoid rounding errors if we were to recalculate the
|
|
// different major radius.
|
|
$pmaj = $this->scale->ticks->maj_ticks_pos;
|
|
$p = $this->scale->ticks->ticks_pos;
|
|
if ($this->scale->name == 'lin') {
|
|
$step=round(($pmaj[1] - $pmaj[0])/($p[1] - $p[0]));
|
|
} else {
|
|
$step=9;
|
|
}
|
|
$n = round(count($pmin)/$step);
|
|
$i = 0;
|
|
$this->img->SetColor($this->gridmajor_color);
|
|
$limit = max($this->img->plotwidth, $this->img->plotheight)*1.4 ;
|
|
$off = $r;
|
|
$i=0;
|
|
$r = $pmin[$i*$step];
|
|
while ($r < $limit && $i < $n) {
|
|
$r = $pmin[$i*$step];
|
|
$this->img->Circle($x, $pos, $r);
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
// Draw angles
|
|
if ($this->show_angle_grid) {
|
|
$this->img->SetColor($this->angle_color);
|
|
$d = max($this->img->plotheight, $this->img->plotwidth)*1.4 ;
|
|
$a = 0;
|
|
$p = $this->scale->ticks->ticks_pos;
|
|
$start_radius = $p[1]-$x;
|
|
while ($a < 360) {
|
|
if ($a == 90 || $a == 270) {
|
|
// Make sure there are no rounding problem with
|
|
// exactly vertical lines
|
|
$this->img->Line(
|
|
$x+$start_radius*cos($a/180*M_PI)+1,
|
|
$pos-$start_radius*sin($a/180*M_PI),
|
|
$x+$start_radius*cos($a/180*M_PI)+1,
|
|
$pos-$d*sin($a/180*M_PI)
|
|
);
|
|
} else {
|
|
$this->img->Line(
|
|
$x+$start_radius*cos($a/180*M_PI)+1,
|
|
$pos-$start_radius*sin($a/180*M_PI),
|
|
$x+$d*cos($a/180*M_PI),
|
|
$pos-$d*sin($a/180*M_PI)
|
|
);
|
|
}
|
|
$a += $this->angle_step;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function StrokeAngleLabels($pos, $type)
|
|
{
|
|
if (!$this->show_angle_label) {
|
|
return;
|
|
}
|
|
|
|
$x0 = round($this->img->left_margin+$this->img->plotwidth/2)+1;
|
|
|
|
$d = max($this->img->plotwidth, $this->img->plotheight)*1.42;
|
|
$a = $this->angle_step;
|
|
$t = new Text();
|
|
$t->SetColor($this->angle_fontcolor);
|
|
$t->SetFont($this->angle_fontfam, $this->angle_fontstyle, $this->angle_fontsize);
|
|
$xright = $this->img->width - $this->img->right_margin;
|
|
$ytop = $this->img->top_margin;
|
|
$xleft = $this->img->left_margin;
|
|
$ybottom = $this->img->height - $this->img->bottom_margin;
|
|
$ha = 'left';
|
|
$va = 'center';
|
|
$w = $this->img->plotwidth/2;
|
|
$h = $this->img->plotheight/2;
|
|
$xt = $x0;
|
|
$yt = $pos;
|
|
$margin=5;
|
|
|
|
$tl = $this->angle_tick_len ; // Outer len
|
|
$tl2 = $this->angle_tick_len2 ; // Interior len
|
|
|
|
$this->img->SetColor($this->angle_tick_color);
|
|
$rot90 = $this->img->a == 90 ;
|
|
|
|
if ($type == POLAR_360) {
|
|
|
|
// Corner angles of the four corners
|
|
$ca1 = atan($h/$w)/M_PI*180;
|
|
$ca2 = 180-$ca1;
|
|
$ca3 = $ca1+180;
|
|
$ca4 = 360-$ca1;
|
|
$end = 360;
|
|
|
|
while ($a < $end) {
|
|
$ca = cos($a/180*M_PI);
|
|
$sa = sin($a/180*M_PI);
|
|
$x = $d*$ca;
|
|
$y = $d*$sa;
|
|
$xt=1000;
|
|
$yt=1000;
|
|
if ($a <= $ca1 || $a >= $ca4) {
|
|
$yt = $pos - $w * $y/$x;
|
|
$xt = $xright + $margin;
|
|
if ($rot90) {
|
|
$ha = 'center';
|
|
$va = 'top';
|
|
} else {
|
|
$ha = 'left';
|
|
$va = 'center';
|
|
}
|
|
$x1=$xright-$tl2;
|
|
$x2=$xright+$tl;
|
|
$y1=$y2=$yt;
|
|
} elseif ($a > $ca1 && $a < $ca2) {
|
|
$xt = $x0 + $h * $x/$y;
|
|
$yt = $ytop - $margin;
|
|
if ($rot90) {
|
|
$ha = 'left';
|
|
$va = 'center';
|
|
} else {
|
|
$ha = 'center';
|
|
$va = 'bottom';
|
|
}
|
|
$y1=$ytop+$tl2;
|
|
$y2=$ytop-$tl;
|
|
$x1=$x2=$xt;
|
|
} elseif ($a >= $ca2 && $a <= $ca3) {
|
|
$yt = $pos + $w * $y/$x;
|
|
$xt = $xleft - $margin;
|
|
if ($rot90) {
|
|
$ha = 'center';
|
|
$va = 'bottom';
|
|
} else {
|
|
$ha = 'right';
|
|
$va = 'center';
|
|
}
|
|
$x1=$xleft+$tl2;
|
|
$x2=$xleft-$tl;
|
|
$y1=$y2=$yt;
|
|
} else {
|
|
$xt = $x0 - $h * $x/$y;
|
|
$yt = $ybottom + $margin;
|
|
if ($rot90) {
|
|
$ha = 'right';
|
|
$va = 'center';
|
|
} else {
|
|
$ha = 'center';
|
|
$va = 'top';
|
|
}
|
|
$y1=$ybottom-$tl2;
|
|
$y2=$ybottom+$tl;
|
|
$x1=$x2=$xt;
|
|
}
|
|
if ($a != 0 && $a != 180) {
|
|
$t->Align($ha, $va);
|
|
if ($this->scale->clockwise) {
|
|
$t->Set(360-$a);
|
|
} else {
|
|
$t->Set($a);
|
|
}
|
|
if ($this->show_angle_mark && $t->font_family > 4) {
|
|
$a .= SymChar::Get('degree');
|
|
}
|
|
$t->Stroke($this->img, $xt, $yt);
|
|
if ($this->show_angle_tick) {
|
|
$this->img->Line($x1, $y1, $x2, $y2);
|
|
}
|
|
}
|
|
$a = (int) $a;
|
|
$a += $this->angle_step;
|
|
}
|
|
} else {
|
|
// POLAR_HALF
|
|
$ca1 = atan($h/$w*2)/M_PI*180;
|
|
$ca2 = 180-$ca1;
|
|
$end = 180;
|
|
while ($a < $end) {
|
|
$ca = cos($a/180*M_PI);
|
|
$sa = sin($a/180*M_PI);
|
|
$x = $d*$ca;
|
|
$y = $d*$sa;
|
|
if ($a <= $ca1) {
|
|
$yt = $pos - $w * $y/$x;
|
|
$xt = $xright + $margin;
|
|
if ($rot90) {
|
|
$ha = 'center';
|
|
$va = 'top';
|
|
} else {
|
|
$ha = 'left';
|
|
$va = 'center';
|
|
}
|
|
$x1=$xright-$tl2;
|
|
$x2=$xright+$tl;
|
|
$y1=$y2=$yt;
|
|
} elseif ($a > $ca1 && $a < $ca2) {
|
|
$xt = $x0 + 2*$h * $x/$y;
|
|
$yt = $ytop - $margin;
|
|
if ($rot90) {
|
|
$ha = 'left';
|
|
$va = 'center';
|
|
} else {
|
|
$ha = 'center';
|
|
$va = 'bottom';
|
|
}
|
|
$y1=$ytop+$tl2;
|
|
$y2=$ytop-$tl;
|
|
$x1=$x2=$xt;
|
|
} elseif ($a >= $ca2) {
|
|
$yt = $pos + $w * $y/$x;
|
|
$xt = $xleft - $margin;
|
|
if ($rot90) {
|
|
$ha = 'center';
|
|
$va = 'bottom';
|
|
} else {
|
|
$ha = 'right';
|
|
$va = 'center';
|
|
}
|
|
$x1=$xleft+$tl2;
|
|
$x2=$xleft-$tl;
|
|
$y1=$y2=$yt;
|
|
}
|
|
$t->Align($ha, $va);
|
|
if ($this->show_angle_mark && $t->font_family > 4) {
|
|
$a .= SymChar::Get('degree');
|
|
}
|
|
$t->Set($a);
|
|
$t->Stroke($this->img, $xt, $yt);
|
|
if ($this->show_angle_tick) {
|
|
$this->img->Line($x1, $y1, $x2, $y2);
|
|
}
|
|
$a = (int) $a;
|
|
$a += $this->angle_step;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function Stroke($pos, $dummy=true)
|
|
{
|
|
$this->img->SetLineWeight($this->weight);
|
|
$this->img->SetColor($this->color);
|
|
$this->img->SetFont($this->font_family, $this->font_style, $this->font_size);
|
|
if (!$this->hide_line) {
|
|
$this->img->FilledRectangle(
|
|
$this->img->left_margin,
|
|
$pos,
|
|
$this->img->width-$this->img->right_margin,
|
|
$pos+$this->weight-1
|
|
);
|
|
}
|
|
$y=$pos+$this->img->GetFontHeight()+$this->title_margin+$this->title->margin;
|
|
if ($this->title_adjust=="high") {
|
|
$this->title->SetPos($this->img->width-$this->img->right_margin, $y, "right", "top");
|
|
} elseif ($this->title_adjust=="middle" || $this->title_adjust=="center") {
|
|
$this->title->SetPos(
|
|
($this->img->width-$this->img->left_margin-$this->img->right_margin)/2+$this->img->left_margin,
|
|
$y,
|
|
"center",
|
|
"top"
|
|
);
|
|
} elseif ($this->title_adjust=="low") {
|
|
$this->title->SetPos($this->img->left_margin, $y, "left", "top");
|
|
} else {
|
|
JpGraphError::RaiseL(17002, $this->title_adjust);
|
|
//('Unknown alignment specified for X-axis title. ('.$this->title_adjust.')');
|
|
}
|
|
|
|
|
|
if (!$this->hide_labels) {
|
|
$this->StrokeLabels($pos, false);
|
|
}
|
|
$this->img->SetColor($this->radius_tick_color);
|
|
$this->scale->ticks->Stroke($this->img, $this->scale, $pos);
|
|
|
|
//
|
|
// Mirror the positions for the left side of the scale
|
|
//
|
|
$mid = 2*($this->img->left_margin+$this->img->plotwidth/2);
|
|
$n = count($this->scale->ticks->ticks_pos);
|
|
$i=0;
|
|
while ($i < $n) {
|
|
$this->scale->ticks->ticks_pos[$i] =
|
|
$mid-$this->scale->ticks->ticks_pos[$i] ;
|
|
++$i;
|
|
}
|
|
|
|
$n = count($this->scale->ticks->maj_ticks_pos);
|
|
$i=0;
|
|
while ($i < $n) {
|
|
$this->scale->ticks->maj_ticks_pos[$i] =
|
|
$mid-$this->scale->ticks->maj_ticks_pos[$i] ;
|
|
++$i;
|
|
}
|
|
|
|
$n = count($this->scale->ticks->maj_ticklabels_pos);
|
|
$i=1;
|
|
while ($i < $n) {
|
|
$this->scale->ticks->maj_ticklabels_pos[$i] =
|
|
$mid-$this->scale->ticks->maj_ticklabels_pos[$i] ;
|
|
++$i;
|
|
}
|
|
|
|
// Draw the left side of the scale
|
|
$n = count($this->scale->ticks->ticks_pos);
|
|
$yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMinTickAbsSize();
|
|
|
|
|
|
// Minor ticks
|
|
if (! $this->scale->ticks->supress_minor_tickmarks) {
|
|
$i=1;
|
|
while ($i < $n/2) {
|
|
$x = round($this->scale->ticks->ticks_pos[$i]) ;
|
|
$this->img->Line($x, $pos, $x, $yu);
|
|
++$i;
|
|
}
|
|
}
|
|
|
|
$n = count($this->scale->ticks->maj_ticks_pos);
|
|
$yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMajTickAbsSize();
|
|
|
|
|
|
// Major ticks
|
|
if (! $this->scale->ticks->supress_tickmarks) {
|
|
$i=1;
|
|
while ($i < $n/2) {
|
|
$x = round($this->scale->ticks->maj_ticks_pos[$i]) ;
|
|
$this->img->Line($x, $pos, $x, $yu);
|
|
++$i;
|
|
}
|
|
}
|
|
if (!$this->hide_labels) {
|
|
$this->StrokeLabels($pos, false);
|
|
}
|
|
$this->title->Stroke($this->img);
|
|
}
|
|
}
|
|
|
|
class PolarScale extends LinearScale
|
|
{
|
|
private $graph;
|
|
public $clockwise=false;
|
|
|
|
public function __construct($aMax, $graph, $aClockwise)
|
|
{
|
|
parent::__construct(0, $aMax, 'x');
|
|
$this->graph = $graph;
|
|
$this->clockwise = $aClockwise;
|
|
}
|
|
|
|
public function SetClockwise($aFlg)
|
|
{
|
|
$this->clockwise = $aFlg;
|
|
}
|
|
|
|
public function _Translate($v)
|
|
{
|
|
return parent::Translate($v);
|
|
}
|
|
|
|
public function PTranslate($aAngle, $aRad)
|
|
{
|
|
$m = $this->scale[1];
|
|
$w = $this->graph->img->plotwidth/2;
|
|
$aRad = $aRad/$m*$w;
|
|
|
|
$a = $aAngle/180 * M_PI;
|
|
if ($this->clockwise) {
|
|
$a = 2*M_PI-$a;
|
|
}
|
|
|
|
$x = cos($a) * $aRad;
|
|
$y = sin($a) * $aRad;
|
|
|
|
$x += $this->_Translate(0);
|
|
|
|
if ($this->graph->iType == POLAR_360) {
|
|
$y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
|
|
} else {
|
|
$y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
|
|
}
|
|
return array($x,$y);
|
|
}
|
|
}
|
|
|
|
class PolarLogScale extends LogScale
|
|
{
|
|
private $graph;
|
|
public $clockwise=false;
|
|
|
|
public function __construct($aMax, $graph, $aClockwise=false)
|
|
{
|
|
parent::__construct(0, $aMax, 'x');
|
|
$this->graph = $graph;
|
|
$this->ticks->SetLabelLogType(LOGLABELS_MAGNITUDE);
|
|
$this->clockwise = $aClockwise;
|
|
}
|
|
|
|
public function SetClockwise($aFlg)
|
|
{
|
|
$this->clockwise = $aFlg;
|
|
}
|
|
|
|
public function PTranslate($aAngle, $aRad)
|
|
{
|
|
if ($aRad == 0) {
|
|
$aRad = 1;
|
|
}
|
|
$aRad = log10($aRad);
|
|
$m = $this->scale[1];
|
|
$w = $this->graph->img->plotwidth/2;
|
|
$aRad = $aRad/$m*$w;
|
|
|
|
$a = $aAngle/180 * M_PI;
|
|
if ($this->clockwise) {
|
|
$a = 2*M_PI-$a;
|
|
}
|
|
|
|
$x = cos($a) * $aRad;
|
|
$y = sin($a) * $aRad;
|
|
|
|
$x += $w+$this->graph->img->left_margin;//$this->_Translate(0);
|
|
if ($this->graph->iType == POLAR_360) {
|
|
$y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
|
|
} else {
|
|
$y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
|
|
}
|
|
return array($x,$y);
|
|
}
|
|
}
|
|
|
|
class PolarGraph extends Graph
|
|
{
|
|
public $scale;
|
|
public $axis;
|
|
public $iType=POLAR_360;
|
|
private $iClockwise=false;
|
|
|
|
public function __construct($aWidth=300, $aHeight=200, $aCachedName="", $aTimeOut=0, $aInline=true)
|
|
{
|
|
parent::__construct($aWidth, $aHeight, $aCachedName, $aTimeOut, $aInline) ;
|
|
$this->SetDensity(TICKD_DENSE);
|
|
$this->SetBox();
|
|
$this->SetMarginColor('white');
|
|
}
|
|
|
|
public function SetDensity($aDense)
|
|
{
|
|
$this->SetTickDensity(TICKD_NORMAL, $aDense);
|
|
}
|
|
|
|
public function SetClockwise($aFlg)
|
|
{
|
|
$this->scale->SetClockwise($aFlg);
|
|
}
|
|
|
|
public function Set90AndMargin($lm=0, $rm=0, $tm=0, $bm=0)
|
|
{
|
|
$adj = ($this->img->height - $this->img->width)/2;
|
|
$this->SetAngle(90);
|
|
$lm2 = -$adj + ($lm-$rm+$tm+$bm)/2;
|
|
$rm2 = -$adj + (-$lm+$rm+$tm+$bm)/2;
|
|
$tm2 = $adj + ($tm-$bm+$lm+$rm)/2;
|
|
$bm2 = $adj + (-$tm+$bm+$lm+$rm)/2;
|
|
$this->SetMargin($lm2, $rm2, $tm2, $bm2);
|
|
$this->axis->SetLabelAlign('right', 'center');
|
|
}
|
|
|
|
public function SetScale($aScale, $rmax=0, $dummy1=1, $dummy2=1, $dummy3=1)
|
|
{
|
|
if ($aScale == 'lin') {
|
|
$this->scale = new PolarScale($rmax, $this, $this->iClockwise);
|
|
} elseif ($aScale == 'log') {
|
|
$this->scale = new PolarLogScale($rmax, $this, $this->iClockwise);
|
|
} else {
|
|
JpGraphError::RaiseL(17004);//('Unknown scale type for polar graph. Must be "lin" or "log"');
|
|
}
|
|
|
|
$this->axis = new PolarAxis($this->img, $this->scale);
|
|
$this->SetMargin(40, 40, 50, 40);
|
|
}
|
|
|
|
public function SetType($aType)
|
|
{
|
|
$this->iType = $aType;
|
|
}
|
|
|
|
public function SetPlotSize($w, $h)
|
|
{
|
|
$this->SetMargin(
|
|
($this->img->width-$w)/2,
|
|
($this->img->width-$w)/2,
|
|
($this->img->height-$h)/2,
|
|
($this->img->height-$h)/2
|
|
);
|
|
}
|
|
|
|
// Private methods
|
|
public function GetPlotsMax()
|
|
{
|
|
$n = count($this->plots);
|
|
$m = $this->plots[0]->Max();
|
|
$i=1;
|
|
while ($i < $n) {
|
|
$m = max($this->plots[$i]->Max(), $m);
|
|
++$i;
|
|
}
|
|
return $m;
|
|
}
|
|
|
|
public function Stroke($aStrokeFileName="")
|
|
{
|
|
|
|
// Start by adjusting the margin so that potential titles will fit.
|
|
$this->AdjustMarginsForTitles();
|
|
|
|
// If the filename is the predefined value = '_csim_special_'
|
|
// we assume that the call to stroke only needs to do enough
|
|
// to correctly generate the CSIM maps.
|
|
// We use this variable to skip things we don't strictly need
|
|
// to do to generate the image map to improve performance
|
|
// a best we can. Therefor you will see a lot of tests !$_csim in the
|
|
// code below.
|
|
$_csim = ($aStrokeFileName===_CSIM_SPECIALFILE);
|
|
|
|
// We need to know if we have stroked the plot in the
|
|
// GetCSIMareas. Otherwise the CSIM hasn't been generated
|
|
// and in the case of GetCSIM called before stroke to generate
|
|
// CSIM without storing an image to disk GetCSIM must call Stroke.
|
|
$this->iHasStroked = true;
|
|
|
|
//Check if we should autoscale axis
|
|
if (!$this->scale->IsSpecified() && count($this->plots)>0) {
|
|
$max = $this->GetPlotsMax();
|
|
$t1 = $this->img->plotwidth;
|
|
$this->img->plotwidth /= 2;
|
|
$t2 = $this->img->left_margin;
|
|
$this->img->left_margin += $this->img->plotwidth+1;
|
|
$this->scale->AutoScale(
|
|
$this->img,
|
|
0,
|
|
$max,
|
|
$this->img->plotwidth/$this->xtick_factor/2
|
|
);
|
|
$this->img->plotwidth = $t1;
|
|
$this->img->left_margin = $t2;
|
|
} else {
|
|
// The tick calculation will use the user suplied min/max values to determine
|
|
// the ticks. If auto_ticks is false the exact user specifed min and max
|
|
// values will be used for the scale.
|
|
// If auto_ticks is true then the scale might be slightly adjusted
|
|
// so that the min and max values falls on an even major step.
|
|
//$min = 0;
|
|
$max = $this->scale->scale[1];
|
|
$t1 = $this->img->plotwidth;
|
|
$this->img->plotwidth /= 2;
|
|
$t2 = $this->img->left_margin;
|
|
$this->img->left_margin += $this->img->plotwidth+1;
|
|
$this->scale->AutoScale(
|
|
$this->img,
|
|
0,
|
|
$max,
|
|
$this->img->plotwidth/$this->xtick_factor/2
|
|
);
|
|
$this->img->plotwidth = $t1;
|
|
$this->img->left_margin = $t2;
|
|
}
|
|
|
|
if ($this->iType == POLAR_180) {
|
|
$pos = $this->img->height - $this->img->bottom_margin;
|
|
} else {
|
|
$pos = $this->img->plotheight/2 + $this->img->top_margin;
|
|
}
|
|
|
|
if (!$_csim) {
|
|
$this->StrokePlotArea();
|
|
}
|
|
|
|
$this->iDoClipping = true;
|
|
|
|
if ($this->iDoClipping) {
|
|
$oldimage = $this->img->CloneCanvasH();
|
|
}
|
|
|
|
if (!$_csim) {
|
|
$this->axis->StrokeGrid($pos);
|
|
}
|
|
|
|
// Stroke all plots for Y1 axis
|
|
for ($i=0; $i < count($this->plots); ++$i) {
|
|
$this->plots[$i]->Stroke($this->img, $this->scale);
|
|
}
|
|
|
|
|
|
if ($this->iDoClipping) {
|
|
// Clipping only supports graphs at 0 and 90 degrees
|
|
if ($this->img->a == 0) {
|
|
$this->img->CopyCanvasH(
|
|
$oldimage,
|
|
$this->img->img,
|
|
$this->img->left_margin,
|
|
$this->img->top_margin,
|
|
$this->img->left_margin,
|
|
$this->img->top_margin,
|
|
$this->img->plotwidth+1,
|
|
$this->img->plotheight+1
|
|
);
|
|
} elseif ($this->img->a == 90) {
|
|
$adj1 = round(($this->img->height - $this->img->width)/2);
|
|
$adj2 = round(($this->img->width - $this->img->height)/2);
|
|
$lm = $this->img->left_margin;
|
|
$rm = $this->img->right_margin;
|
|
$tm = $this->img->top_margin;
|
|
$bm = $this->img->bottom_margin;
|
|
$this->img->CopyCanvasH(
|
|
$oldimage,
|
|
$this->img->img,
|
|
$adj2 + round(($lm-$rm+$tm+$bm)/2),
|
|
$adj1 + round(($tm-$bm+$lm+$rm)/2),
|
|
$adj2 + round(($lm-$rm+$tm+$bm)/2),
|
|
$adj1 + round(($tm-$bm+$lm+$rm)/2),
|
|
$this->img->plotheight+1,
|
|
$this->img->plotwidth+1
|
|
);
|
|
}
|
|
$this->img->Destroy();
|
|
$this->img->SetCanvasH($oldimage);
|
|
}
|
|
|
|
if (!$_csim) {
|
|
$this->axis->Stroke($pos);
|
|
$this->axis->StrokeAngleLabels($pos, $this->iType);
|
|
}
|
|
|
|
if (!$_csim) {
|
|
$this->StrokePlotBox();
|
|
$this->footer->Stroke($this->img);
|
|
|
|
// The titles and legends never gets rotated so make sure
|
|
// that the angle is 0 before stroking them
|
|
$aa = $this->img->SetAngle(0);
|
|
$this->StrokeTitles();
|
|
}
|
|
|
|
for ($i=0; $i < count($this->plots) ; ++$i) {
|
|
$this->plots[$i]->Legend($this);
|
|
}
|
|
|
|
$this->legend->Stroke($this->img);
|
|
|
|
if (!$_csim) {
|
|
$this->StrokeTexts();
|
|
$this->img->SetAngle($aa);
|
|
|
|
// Draw an outline around the image map
|
|
if (_JPG_DEBUG) {
|
|
$this->DisplayClientSideaImageMapAreas();
|
|
}
|
|
|
|
// If the filename is given as the special "__handle"
|
|
// then the image handler is returned and the image is NOT
|
|
// streamed back
|
|
if ($aStrokeFileName == _IMG_HANDLER) {
|
|
return $this->img->img;
|
|
} else {
|
|
// Finally stream the generated picture
|
|
$this->cache->PutAndStream($this->img, $this->cache_name, $this->inline, $aStrokeFileName);
|
|
}
|
|
}
|
|
}
|
|
}
|