<?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);

          }

        }

      }

    }

  }

}

?>