462 lines
15 KiB
PHP
462 lines
15 KiB
PHP
<?php
|
|
class ColorGradient
|
|
{
|
|
public $pct;
|
|
public $color;
|
|
|
|
public static function RGB2HSV($R, $G, $B) // RGB values: 0-255, 0-255, 0-255
|
|
{ // HSV values: 0-360, 0-100, 0-100
|
|
// Convert the RGB byte-values to percentages
|
|
$R = ($R / 255);
|
|
$G = ($G / 255);
|
|
$B = ($B / 255);
|
|
|
|
// Calculate a few basic values, the maximum value of R,G,B, the
|
|
// minimum value, and the difference of the two (chroma).
|
|
$maxRGB = max($R, $G, $B);
|
|
$minRGB = min($R, $G, $B);
|
|
$chroma = $maxRGB - $minRGB;
|
|
|
|
// Value (also called Brightness) is the easiest component to calculate,
|
|
// and is simply the highest value among the R,G,B components.
|
|
// We multiply by 100 to turn the decimal into a readable percent value.
|
|
$computedV = 100 * $maxRGB;
|
|
|
|
// Special case if hueless (equal parts RGB make black, white, or grays)
|
|
// Note that Hue is technically undefined when chroma is zero, as
|
|
// attempting to calculate it would cause division by zero (see
|
|
// below), so most applications simply substitute a Hue of zero.
|
|
// Saturation will always be zero in this case, see below for details.
|
|
if ($chroma == 0)
|
|
return array(0, 0, $computedV);
|
|
|
|
// Saturation is also simple to compute, and is simply the chroma
|
|
// over the Value (or Brightness)
|
|
// Again, multiplied by 100 to get a percentage.
|
|
$computedS = 100 * ($chroma / $maxRGB);
|
|
|
|
// Calculate Hue component
|
|
// Hue is calculated on the "chromacity plane", which is represented
|
|
// as a 2D hexagon, divided into six 60-degree sectors. We calculate
|
|
// the bisecting angle as a value 0 <= x < 6, that represents which
|
|
// portion of which sector the line falls on.
|
|
if ($R == $minRGB)
|
|
$h = 3 - (($G - $B) / $chroma);
|
|
elseif ($B == $minRGB)
|
|
$h = 1 - (($R - $G) / $chroma);
|
|
else // $G == $minRGB
|
|
$h = 5 - (($B - $R) / $chroma);
|
|
|
|
// After we have the sector position, we multiply it by the size of
|
|
// each sector's arc (60 degrees) to obtain the angle in degrees.
|
|
$computedH = 60 * $h;
|
|
|
|
return array($computedH, $computedS, $computedV);
|
|
}
|
|
|
|
public static function HSV2RGB($h, $s, $v)
|
|
{
|
|
$s /= 256.0;
|
|
if ($s == 0.0) return array($v,$v,$v);
|
|
$h /= (256.0 / 6.0);
|
|
$i = floor($h);
|
|
$f = $h - $i;
|
|
$p = (integer)($v * (1.0 - $s));
|
|
$q = (integer)($v * (1.0 - $s * $f));
|
|
$t = (integer)($v * (1.0 - $s * (1.0 - $f)));
|
|
switch($i) {
|
|
case 0: return array($v,$t,$p);
|
|
case 1: return array($q,$v,$p);
|
|
case 2: return array($p,$v,$t);
|
|
case 3: return array($p,$q,$v);
|
|
case 4: return array($t,$p,$v);
|
|
default: return array($v,$p,$q);
|
|
}
|
|
}
|
|
|
|
public static function gradient($from_color, $to_color, $graduations = 10)
|
|
{
|
|
$graduations--;
|
|
$startcol = str_replace("#", "", $from_color);
|
|
$endcol = str_replace("#", "", $to_color);
|
|
$RedOrigin = hexdec(substr($startcol, 0, 2));
|
|
$GrnOrigin = hexdec(substr($startcol, 2, 2));
|
|
$BluOrigin = hexdec(substr($startcol, 4, 2));
|
|
if ($graduations >= 2) { // for at least 3 colors
|
|
$GradientSizeRed = (hexdec(substr($endcol, 0, 2)) - $RedOrigin) / $graduations; //Graduation Size Red
|
|
$GradientSizeGrn = (hexdec(substr($endcol, 2, 2)) - $GrnOrigin) / $graduations;
|
|
$GradientSizeBlu = (hexdec(substr($endcol, 4, 2)) - $BluOrigin) / $graduations;
|
|
for ($i = 0; $i <= $graduations; $i++) {
|
|
$RetVal[$i] = strtoupper("#" . str_pad(dechex($RedOrigin + ($GradientSizeRed * $i)), 2, '0', STR_PAD_LEFT) .
|
|
str_pad(dechex($GrnOrigin + ($GradientSizeGrn * $i)), 2, '0', STR_PAD_LEFT) .
|
|
str_pad(dechex($BluOrigin + ($GradientSizeBlu * $i)), 2, '0', STR_PAD_LEFT));
|
|
}
|
|
} elseif ($graduations == 1) { // exactlly 2 colors
|
|
$RetVal[] = $from_color;
|
|
$RetVal[] = $to_color;
|
|
} else { // one color
|
|
$RetVal[] = $from_color;
|
|
}
|
|
return $RetVal;
|
|
}
|
|
|
|
public static function hex2rgb($hex) { return sscanf($hex, "#%02x%02x%02x"); }
|
|
|
|
// ---
|
|
// --- Local fonctions
|
|
// ---
|
|
public static function rgb2hex($rgb) {
|
|
$hex = "#";
|
|
$hex .= str_pad(dechex($rgb[0]), 2, "0", STR_PAD_LEFT);
|
|
$hex .= str_pad(dechex($rgb[1]), 2, "0", STR_PAD_LEFT);
|
|
$hex .= str_pad(dechex($rgb[2]), 2, "0", STR_PAD_LEFT);
|
|
|
|
return $hex; // returns the hex value including the number sign (#)
|
|
}
|
|
}
|
|
|
|
class Plot
|
|
{
|
|
private $aCoords;
|
|
function __construct(&$aCoords)
|
|
{
|
|
$this->aCoords = &$aCoords;
|
|
}
|
|
|
|
public function drawLine($vImage, $vColor, $iPosX = 0, $imaxX = false)
|
|
{
|
|
$maxX = $imaxX;
|
|
if ($imaxX === false) $maxX = imagesx($vImage);
|
|
|
|
reset($this->aCoords);
|
|
list($iPrevX, $iPrevY) = each($this->aCoords);
|
|
|
|
while (list ($x, $y) = each($this->aCoords))
|
|
{
|
|
$laCouleur = null;
|
|
if (!is_array($vColor)) $laCouleur = $vColor;
|
|
else
|
|
{
|
|
$s = count($vColor) - 1;
|
|
$laCouleur = $vColor[$s]->color;
|
|
$pct = $x / $maxX;
|
|
while(($s>0)&&($pct < $vColor[$s]->pct))
|
|
{
|
|
$s -= 1;
|
|
$laCouleur = $vColor[$s]->color;
|
|
}
|
|
}
|
|
imageline($vImage, round($iPrevX), round($iPrevY), round($x), round($y), $laCouleur);
|
|
$iPrevX = $x;
|
|
$iPrevY = $y;
|
|
}
|
|
}
|
|
|
|
public function drawDots($vImage, $vColor, $iPosX = 0, $iPosY = false, $iDotSize = 1) {
|
|
if ($iPosY === false)
|
|
$iPosY = imagesy($vImage);
|
|
$vBorderColor = imagecolorallocate($vImage, 0, 0, 0);
|
|
foreach ($this->aCoords as $x => $y) {
|
|
imagefilledellipse($vImage, $iPosX + round($x), $iPosY - round($y), $iDotSize, $iDotSize, $vColor);
|
|
imageellipse($vImage, $iPosX + round($x), $iPosY - round($y), $iDotSize, $iDotSize, $vBorderColor);
|
|
}
|
|
}
|
|
|
|
public function drawAxis($vImage, $vColor, $iPosX = 0, $iPosY = false) {
|
|
if ($iPosY === false) $iPosY = imagesy($vImage);
|
|
$vImageWidth = imagesx($vImage);
|
|
imageline($vImage, $iPosX, $iPosY, $iPosX, 0, $vColor);
|
|
imageline($vImage, $iPosX, $iPosY, $vImageWidth, $iPosY, $vColor);
|
|
imagefilledpolygon($vImage, array($iPosX, 0, $iPosX - 3, 5, $iPosX + 3, 5), 3, $vColor);
|
|
imagefilledpolygon($vImage, array($vImageWidth, $iPosY, $vImageWidth - 5, $iPosY - 3, $vImageWidth - 5, $iPosY + 3), 3, $vColor);
|
|
}
|
|
}
|
|
|
|
class CubicSplines
|
|
{
|
|
protected $aCoords;
|
|
protected $aCrdX;
|
|
protected $aCrdY;
|
|
protected $aSplines = array();
|
|
protected $iMinX;
|
|
protected $iMaxX;
|
|
protected $iStep;
|
|
protected function prepareCoords(&$aCoords, $iStep, $iMinX = -1, $iMaxX = -1) {
|
|
$this->aCrdX = array();
|
|
$this->aCrdY = array();
|
|
$this->aCoords = array();
|
|
ksort($aCoords);
|
|
foreach ($aCoords as $x => $y) {
|
|
$this->aCrdX[] = $x;
|
|
$this->aCrdY[] = $y;
|
|
}
|
|
$this->iMinX = $iMinX;
|
|
$this->iMaxX = $iMaxX;
|
|
if ($this->iMinX == -1)
|
|
$this->iMinX = min($this->aCrdX);
|
|
if ($this->iMaxX == -1)
|
|
$this->iMaxX = max($this->aCrdX);
|
|
$this->iStep = $iStep;
|
|
}
|
|
public function setInitCoords(&$aCoords, $iStep = 1, $iMinX = -1, $iMaxX = -1) {
|
|
$this->aSplines = array();
|
|
if (count($aCoords) < 4) {
|
|
return false;
|
|
}
|
|
$this->prepareCoords($aCoords, $iStep, $iMinX, $iMaxX);
|
|
$this->buildSpline($this->aCrdX, $this->aCrdY, count($this->aCrdX));
|
|
}
|
|
public function processCoords() {
|
|
for ($x = $this->iMinX; $x <= $this->iMaxX; $x += $this->iStep) {
|
|
$this->aCoords[$x] = $this->funcInterp($x);
|
|
}
|
|
return $this->aCoords;
|
|
}
|
|
private function buildSpline($x, $y, $n) {
|
|
for ($i = 0; $i < $n; ++$i) {
|
|
$this->aSplines[$i]['x'] = $x[$i];
|
|
$this->aSplines[$i]['a'] = $y[$i];
|
|
}
|
|
$this->aSplines[0]['c'] = $this->aSplines[$n - 1]['c'] = 0;
|
|
$alpha[0] = $beta[0] = 0;
|
|
for ($i = 1; $i < $n - 1; ++$i) {
|
|
$h_i = $x[$i] - $x[$i - 1];
|
|
$h_i1 = $x[$i + 1] - $x[$i];
|
|
$A = $h_i;
|
|
$C = 2.0 * ($h_i + $h_i1);
|
|
$B = $h_i1;
|
|
$F = 6.0 * (($y[$i + 1] - $y[$i]) / $h_i1 - ($y[$i] - $y[$i - 1]) / $h_i);
|
|
$z = ($A * $alpha[$i - 1] + $C);
|
|
$alpha[$i] = - $B / $z;
|
|
$beta[$i] = ($F - $A * $beta[$i - 1]) / $z;
|
|
}
|
|
for ($i = $n - 2; $i > 0; --$i) {
|
|
$this->aSplines[$i]['c'] = $alpha[$i] * $this->aSplines[$i + 1]['c'] + $beta[$i];
|
|
}
|
|
for ($i = $n - 1; $i > 0; --$i) {
|
|
$h_i = $x[$i] - $x[$i - 1];
|
|
$this->aSplines[$i]['d'] = ($this->aSplines[$i]['c'] - $this->aSplines[$i - 1]['c']) / $h_i;
|
|
$this->aSplines[$i]['b'] = $h_i * (2.0 * $this->aSplines[$i]['c'] + $this->aSplines[$i - 1]['c']) / 6.0 + ($y[$i] - $y[$i - 1]) / $h_i;
|
|
}
|
|
}
|
|
private function funcInterp($x) {
|
|
$n = count($this->aSplines);
|
|
if ($x <= $this->aSplines[0]['x']) {
|
|
$s = $this->aSplines[1];
|
|
} else {
|
|
if ($x >= $this->aSplines[$n - 1]['x']) {
|
|
$s = $this->aSplines[$n - 1];
|
|
} else {
|
|
$i = 0;
|
|
$j = $n - 1;
|
|
while ($i + 1 < $j) {
|
|
$k = $i + ($j - $i) / 2;
|
|
if ($x <= $this->aSplines[$k]['x']) {
|
|
$j = $k;
|
|
} else {
|
|
$i = $k;
|
|
}
|
|
}
|
|
$s = $this->aSplines[$j];
|
|
}
|
|
}
|
|
$dx = ($x - $s['x']);
|
|
return $s['a'] + ($s['b'] + ($s['c'] / 2.0 + $s['d'] * $dx / 6.0) * $dx) * $dx;
|
|
}
|
|
}
|
|
|
|
class topisto_spline
|
|
{
|
|
public static function DefaultDrawBlock($the_block, $vImage, $x, $y, $graph_width, $graph_height, $type=1)
|
|
{
|
|
topisto_spline::DrawBlock($the_block, $vImage, $x, $y, $graph_width, $graph_height, 3.5, 1, $type);
|
|
topisto_spline::DrawBlock($the_block, $vImage, $x, $y, $graph_width, $graph_height, 5, 30, $type);
|
|
}
|
|
|
|
//
|
|
// modes
|
|
// - 0 : une droite de couleur uniforme
|
|
// - 1 : une droite en dégradé de couleur
|
|
// - 2 : une spline en dégradé de couleur passant les valeurs du hash de la transaction
|
|
// - 3 : la spline dessinée en 2 est atténuée à gauche et amplifiée à droite
|
|
// - 3.5 : idem mode 3, mais avec de la transparence
|
|
// - 4 : $iterations splines oscillants autour de la spline dessinée en 2
|
|
// - 4.5 : les splines sont desssinées en transparence
|
|
//
|
|
public static function DrawBlock($the_block, $vImage, $x, $y, $graph_width, $graph_height, $mode, $iterations, $type=1)
|
|
{
|
|
$somme = 0;
|
|
$min =-1;
|
|
$max = 0;
|
|
$data = blockchain::getTransactionData($the_block, $type);
|
|
$local_iterations = $iterations;
|
|
$n_data = count($data);
|
|
|
|
$vBgColor = imagecolorallocate($vImage, 10, 10, 10);
|
|
imagefilledrectangle($vImage, $x, $y, $x+$graph_width, $y+$graph_height, $vBgColor);
|
|
|
|
// Calcul des min max
|
|
foreach($data as $v)
|
|
{
|
|
if ($v['value'] > $max) $max = $v['value'];
|
|
if (($v['value'] < $min)||($min == -1)) $min = $v['value'];
|
|
$somme += $v['value'];
|
|
}
|
|
if ($min == $max) $max = $min + 1;
|
|
if ($somme == 0) return;
|
|
|
|
// ---
|
|
// --- On se limite à 40 000 traits
|
|
// --- Pour des questions de performance
|
|
// ---
|
|
while(($n_data * $local_iterations)>40000) $local_iterations--;
|
|
|
|
$vColor = array();
|
|
|
|
// Gestion de la transparence
|
|
$alpha = 125;
|
|
if ($mode < 4.5) $alpha = 0;
|
|
if ($mode == 3.5) $alpha = 100;
|
|
|
|
// On choisit des couleurs au hasard
|
|
$hex_val = array(
|
|
ColorGradient::rgb2hex([rand(0,255),rand(0,255),rand(0,255)]),
|
|
ColorGradient::rgb2hex([rand(0,255),rand(0,255),rand(0,255)]),
|
|
ColorGradient::rgb2hex([rand(0,255),rand(0,255),rand(0,255)])
|
|
);
|
|
// dan sla moitié des cas, on s'en tient au "dégradé de feu"
|
|
if (rand(0,100) > 50) $hex_val = array('#D2691E', '#FF8C00', '#EEEEEE');
|
|
|
|
$rgbval = ColorGradient::hex2rgb($hex_val[0]);
|
|
|
|
$n = 0;
|
|
$vColor[$n] = new ColorGradient();
|
|
$vColor[$n]->pct = 0;
|
|
$vColor[$n]->color = imagecolorallocatealpha($vImage, $rgbval[0], $rgbval[1], $rgbval[2], $alpha);
|
|
|
|
$n += 1;
|
|
$vColor[$n] = new ColorGradient();
|
|
$vColor[$n]->pct = 0.1;
|
|
$vColor[$n]->color = imagecolorallocatealpha($vImage, $rgbval[0], $rgbval[1], $rgbval[2], $alpha);
|
|
|
|
if ($mode > 0)
|
|
{
|
|
$gradient = ColorGradient::gradient($hex_val[0], $hex_val[1], 60);
|
|
for($i=0;$i<60;$i++)
|
|
{
|
|
$rgbval = ColorGradient::hex2rgb($gradient[$i]);
|
|
$n += 1;
|
|
$vColor[$n] = new ColorGradient();
|
|
$vColor[$n]->pct = (10+$i) / 100.0;
|
|
$vColor[$n]->color = imagecolorallocatealpha($vImage, $rgbval[0], $rgbval[1], $rgbval[2], $alpha);
|
|
}
|
|
|
|
$gradient = ColorGradient::gradient($hex_val[1], $hex_val[2],30);
|
|
for($i=0;$i<30;$i++)
|
|
{
|
|
$rgbval = ColorGradient::hex2rgb($gradient[$i]);
|
|
$n += 1;
|
|
$vColor[$n] = new ColorGradient();
|
|
$vColor[$n]->pct = (70+$i) / 100.0;
|
|
$vColor[$n]->color = imagecolorallocatealpha($vImage, $rgbval[0], $rgbval[1], $rgbval[2], $alpha);
|
|
}
|
|
}
|
|
|
|
//////////
|
|
$oCurve = new CubicSplines();
|
|
|
|
$marge_x = 10;
|
|
$marge_y = 20;
|
|
|
|
$coef = ($graph_height - (2*$marge_y)) / $somme;
|
|
$dx = $graph_width;
|
|
if ($mode > 0) $dx = round($dx / (TX_HASH_LEN+1));
|
|
|
|
//$limite_x = $x + ($graph_width - $marge_x);
|
|
$limite_x = $x + $graph_width - $marge_x;
|
|
|
|
$h0 = 0;
|
|
$hauteur = $y + $marge_y;
|
|
$special_draw = (count($data) == 1);
|
|
|
|
foreach($data as $transaction)
|
|
{
|
|
//
|
|
// La nouvelle hauteur : cumule des montants de transaction
|
|
//
|
|
$hauteur += $coef * $transaction['value'];
|
|
|
|
//
|
|
// Cas des blocks qui n'ont qu'une seule transaction
|
|
//
|
|
if ($special_draw) $hauteur = $y + ($graph_height / 2);
|
|
|
|
//
|
|
// Ne pas tracer 2 lignes à la même hauteur
|
|
//
|
|
if ((floor($hauteur)-$h0)<2) continue;
|
|
$h0 = floor($hauteur);
|
|
|
|
//
|
|
// On va faire des itérations sur la transaction courante.
|
|
// A chaque itération, on va s'appuyer sur le hash de la transaction
|
|
// mais en introduisant du bruit.
|
|
// On va donc statistiquement tracer une courbe représentant le hash
|
|
//
|
|
for($j=0;$j<$local_iterations;$j++)
|
|
{
|
|
//
|
|
// On recommence en début de ligne
|
|
//
|
|
$x0 = $x + $marge_x;
|
|
|
|
//
|
|
// La première partie est une ligne droite
|
|
//
|
|
imageline($vImage, $x0, $h0, $x0+$dx, $h0, $vColor[0]->color);
|
|
$x0 += $dx;
|
|
|
|
//
|
|
// Le mode 0 consiste à tracer une droite de couleur uniforme
|
|
//
|
|
if (($mode == 0)||($x0 >= $limite_x)) continue;
|
|
|
|
$aCoords = array();
|
|
$facteur = 1;
|
|
|
|
if ($mode > 2) $facteur = 0.04;
|
|
|
|
//
|
|
// On découpe la ligne en fonction du nombre de DIGIT
|
|
// dans le hash des transactions
|
|
//
|
|
$aCoords[$x0] = $h0;
|
|
for ($i = 0; $i < (TX_HASH_LEN-1); $i++)
|
|
{
|
|
$y0 = $h0;
|
|
if ($mode > 1)
|
|
{
|
|
$y0 += (hexdec($transaction['hash'][$i]) - 8) * $facteur;
|
|
$valeur = rand(-16, 16) * $facteur;
|
|
if ($mode > 2) $facteur += 0.02;
|
|
if ($mode > 3) $y0 += $valeur;
|
|
}
|
|
$x0 += $dx;
|
|
$aCoords[$x0] = $y0;
|
|
}
|
|
if ($oCurve)
|
|
{
|
|
$oCurve->setInitCoords($aCoords);
|
|
$r = $oCurve->processCoords();
|
|
if ($r)
|
|
{
|
|
$curveGraph = new Plot($r);
|
|
$curveGraph->drawLine($vImage, $vColor, $x0, $limite_x);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
?>
|