<!-- Quelltextanzeige, Anleitung und Beispiel von: 
Dr. O. Hoffmann, siehe http://hoffmann.bplaced.net/hilfe.php 

Quelltext ab hier: --> 
 
<?php
# zufälliges Potential und Gradient mit Hexagonzellen und Gaußfilter

# hex-Farbangabe
function hex($fr,$fg,$fb){
     return sprintf("#%02X%02X%02X", $fr, $fg, $fb);
}

# Verhältnis x zu y, fest!
$ky=sqrt(3/4);


# Titelinformation pro Kachel anzeigen?
if(isset($_GET['title'])) {
 $title=htmlspecialchars($_GET['title']);
} else {
 $title=1;
}
if ($title !=0) {
 $title=1;
}


# Typ Gradientendarstellung (0-5 oder -1: ohne)
if(isset($_GET['qtyp'])) {
 $qtyp=htmlspecialchars($_GET['qtyp']);
} else {
 $qtyp="3";
}

# Kachelradius
if(isset($_GET['kr'])) {
 $kr=htmlspecialchars($_GET['kr']);
} else {
 $kr="10";
}

#Skalierungsfaktor Gradientensymbol
if(isset($_GET['ds'])) {
 $ds=htmlspecialchars($_GET['ds']);
} else {
 $ds=$kr/30;
}

#zusätzlicher Drehwinkel in Grad für das Gradientensymbol 
if(isset($_GET['dw'])) {
 $dw=htmlspecialchars($_GET['dw']);
} else {
 $dw=0;
}

# Standardabweichung Gaußfilter
if(isset($_GET['gauss'])) {
 $gauss=htmlspecialchars($_GET['gauss']);
} else {
 $gauss=$kr;
}
$gauss=abs($gauss);

# PotentialfillMin
if(isset($_GET['fmin'])) {
 $fmin=htmlspecialchars($_GET['fmin']);
} else {
 $fmin='#fff';
}

#PotentialfillMax
if(isset($_GET['fmax'])) {
 $fmax=htmlspecialchars($_GET['fmax']);
} else {
 $fmax='#fff';
}

# Typ der Farbskala
if(isset($_GET['ftyp'])) {
 $ftyp=htmlspecialchars($_GET['ftyp']);
} else {
 $ftyp=7;
}
$ftyp=max(-15,min(15,round($ftyp)));
$fdummy=max(1,abs($ftyp));
$fname="farben$fdummy.ppm";


# spiegeln? (derzeit nicht sinnvoll, nur wenn die x-Achse eine Spiegelachse ist)
if(isset($_GET['as'])) {
 $as=htmlspecialchars($_GET['as']);
} else {
 $as=0;
}


# veränderliche Daten Potential

# Zahl der Iterationen
if(isset($_GET['iter'])) {
 $iter=htmlspecialchars($_GET['iter']);
} else {
 $iter=20;
}
$iter=max(1,min(200,ceil($iter)));

# Gewichtung aktuelle Kachel zu den sechs Nachbarn bei der Iteration
if(isset($_GET['selbst'])) {
 $selbst=htmlspecialchars($_GET['selbst']);
} else {
 $selbst=1;
}

#darzustellender Bereich, ganze Zahlen!
if(isset($_GET['xv'])) {
 $xv=htmlspecialchars($_GET['xv']);
} else {
 $xv=-21;
}
$xv=max(-200,(round($xv)));


if(isset($_GET['xb'])) {
 $xb=htmlspecialchars($_GET['xb']);
} else {
 $xb=20;
}
$xb=min(200,round(max($xv+1,$xb)));


if(isset($_GET['yv'])) {
 $yv=htmlspecialchars($_GET['yv']);
} else {
 $yv=ceil($xv*$ky);
}
$yv=max(-200,round($yv));


if(isset($_GET['yb'])) {
 $yb=htmlspecialchars($_GET['yb']);
} else {
 $yb=ceil($xb*$ky);
}
$yb=min(200,round(max($yv+1,$yb)));


# bis hier veränderliche Daten

# Normierungsfaktor für Iteration
$k=1/($selbst+6);

# Feld zufällig bestimmen
for ($i = $xv; $i <=$xb; $i++) {

$i1=$i-3;
$i2=$i+3;

for ($j = $yv; $j <=$yb; $j++) {

#$j1=$j-3;
#$j2=$j+3;

#$a[$i][$j]=100/(1+$i*$i*$ky*$ky+$j*$j);
#$a[$i][$j]=100/(1+$i1*$i1+$j1*$j1)-100/(1+$i2*$i2+$j2*$j2);
$a[$i][$j]=mt_rand(-100,100);
}
}


for ($h = 0; $h <=$iter; $h++) {

for ($i = $xv; $i <=$xb; $i++) {
$i1=$i+1;
$i2=$i-1;
if ($i2 < $xv) {
$i2=$i2+$xb-$xv;
} 
if ($i1 > $xb) {
$i1=$i1-$xb+$xv;
}


for ($j = $yv; $j <=$yb; $j++) {
$j1=$j+1;
$j2=$j-1;
if ($j2 < $yv) {
$j2=$j2+$yb-$yv;
} 
if ($j1 > $yb) {
$j1=$j1-$yb+$yv;
}

# Potential glätten
if ($i%2==0) {
$dummy=$selbst*$a[$i][$j]+$a[$i][$j1]+$a[$i][$j2]+$a[$i2][$j2]+$a[$i2][$j]+$a[$i1][$j2]+$a[$i1][$j];
} else {
$dummy=$selbst*$a[$i][$j]+$a[$i][$j1]+$a[$i][$j2]+$a[$i2][$j]+$a[$i2][$j1]+$a[$i1][$j]+$a[$i1][$j1];
}

$b[$i][$j]=$k*$dummy;

}
}

$a=$b;

}


$amax=-10000;
$amin=10000;
$k=0;
for ($i = $xv; $i <=$xb; $i++) {
for ($j = $yv; $j <=$yb; $j++) {
$k=$k+1;
$amax=max($amax,$a[$i][$j]);
$amin=min($amin,$a[$i][$j]);

}
}
$panz=$k;
$danz=$k;


$k=0;
$ateil=1/($amax-$amin);
for ($i = $xv; $i <=$xb; $i++) {
$i1=$i+1;
$i2=$i-1;
if ($i2 < $xv) {
$i2=$i2+$xb-$xv;
} 
if ($i1 > $xb) {
$i1=$i1-$xb+$xv;
}


for ($j = $yv; $j <=$yb; $j++) {
$j1=$j+1;
$j2=$j-1;
if ($j2 < $yv) {
$j2=$j2+$yb-$yv;
} 
if ($j1 > $yb) {
$j1=$j1-$yb+$yv;
}

# Gradient bestimmen
if ($i%2==0) {
$d1=$a[$i][$j2]-$a[$i][$j];
$d2=$a[$i][$j1]-$a[$i][$j];
$d3=$a[$i2][$j2]-$a[$i][$j];
$d4=$a[$i2][$j]-$a[$i][$j];
$d5=$a[$i1][$j2]-$a[$i][$j];
$d6=$a[$i1][$j]-$a[$i][$j];
} else {
$d1=$a[$i][$j2]-$a[$i][$j];
$d2=$a[$i][$j1]-$a[$i][$j];
$d3=$a[$i2][$j]-$a[$i][$j];
$d4=$a[$i2][$j1]-$a[$i][$j];
$d5=$a[$i1][$j]-$a[$i][$j];
$d6=$a[$i1][$j1]-$a[$i][$j];
}
$dadi=$ky*(-$d3-$d4+$d5+$d6);
$dadj=-$d1+$d2+0.5*(-$d3-$d5+$d4+$d6);

if ($dadi==0 AND $dadj==0) {
$win='no';
} else {
$win=rad2deg(atan2($dadj,$dadi));
}
if ($i%2==0) {
$y=$j;
} else {
$y=$j+0.5;
}
$x=round($i*$ky,2);

$vert=round(($a[$i][$j]-$amin)*$ateil,5);
$k=$k+1;

# für die Ausgabe
$pot[$k][0]=$x*$kr*2;
$pot[$k][1]=$y*$kr*2;
$pot[$k][2]=$vert;
$pot[$k][3]=$win+$dw;

}
}

$pot[$k+1][0]=$pot[$k][0]+10000;

# Farben laden
$farben = file($fname);
$fzeilen = count($farben);
for ($j = 0; $j <$fzeilen; $j++) {
$foo = preg_replace("/\s{2,}/", " ", $farben[$j]);
$c = explode(" ", trim($foo));

if ($ftyp <0 ) {
$jj=$fzeilen-$j-1;
} else {
$jj=$j;
}

$fr=$c[0];
$fg=$c[1];
$fb=$c[2];
#$fc[$j]="rgb($fr,$fg,$fb)";
$fc[$jj]=hex($fr,$fg,$fb);
}
unset($farben);
 
# Größe der viewBox bestimmen
$vbx=round(($xv-2)*$kr*$ky*2);
$vby=round(($yv-2)*$kr*2);
$vbw=round(($xb-$xv+4)*$kr*$ky*2);
$vbh=round(($yb-$yv+4)*$kr*2);
$viewBox="$vbx $vby $vbw $vbh";

# Gradientdarstellung
$dipd='';


if ($qtyp !=-1) {
# Pfeil mit Drehpunkt 0,0 am Ende
  if ($qtyp == 0) {
    $dipd='<path id="p" d="M0,-2 0,2 8,2 8,8 32,0 8,-8 8,-2Z" transform="scale('.$ds.')" />
';
# Pfeil mit Drehpunkt 0,0 in der Mitte
  } elseif ($qtyp == 1) {
    $dipd='<path id="p" d="M-16,-2 -16,2 -8,2 -8,8 16,0 -8,-8 -8,-2Z" transform="scale('.$ds.')" />
';
# spitzes Dreieck, Drehpunkt 0,0 am dicken Ende
  } elseif ($qtyp == 2) {
    $dipd='<path id="p" d="M30,0 0,6 0,-6Z" transform="scale('.$ds.')" />
';
# spitze Kurve, Drehpunkt 0,0 am dicken Ende
  } elseif ($qtyp == 3) {
    $dipd='<path id="p" d="M24,0C0,-6 -4,-10 -4,0 -4,10 0,6 24,0 ZM0,-2 0,2M-2,0 2,0" transform="scale('.$ds.')" />
';
# Balken
  } elseif ($qtyp == 4) {
    $dipd='<path id="p" d="M16,4 -16,4 -16,-4 16,-4Z" transform="scale('.$ds.')" />';
# Drei Kreise
  } else {
    $dipd='<g id="p" transform="scale('.$ds.')">
    <circle cx="-5" r="12" />
    <circle cx="5" r="8" />
    <circle cx="15" r="4" />
    </g> 
';
   }
# Kreis für Gradient 0
$dc=10*$ds;
$dipd.="<circle id='c' r='$dc' />
";
}

# Hexagon 
      $hg=1.05;
      $hf=sqrt(3.0/2.0);
      $lx=$kr/2*$hf*$hg;
      $ly=$kr*$hf*$hg;
      $lz=$kr*$hg;
 
      $hex="<path id='r' d='M$lx,-$lz $ly,0 $lx,$lz -$lx,$lz -$ly,0 -$lx,-$lz Z' />
";   
   
  if ($gauss != 0) {   
  $raus='<g filter="url(#fi)">
';   
  } else {
  $raus='';  
  }
   
  # Potential raushauen
  $raus.='<g id="pot" fill="none">
';
  
  $x=$pot[1][0];
  $raus.="<g transform='translate($x)'>
";
  for ($j = 1; $j <=$panz; $j++) {
    $w=round($pot[$j][2]*($fzeilen-1));
    $y=$pot[$j][1];
    $raus.=" <use xlink:href='#r' y='$y' ";
    
        if ($w < 0.0) {
          $raus.="fill='$fmin'";
        } elseif ($w >= $fzeilen) {
          $raus.="fill='$fmax'";
        } else {
          $raus.="fill='$fc[$w]'";
        }
        if ($title==1) {
        $t=$pot[$j][2];
        $raus.="><title>$t</title></use>
";
        } else {
        $raus.="/>
";        
        }
       if ($pot[$j+1][0] != $pot[$j][0]) {
         $raus.='</g>
';
        if ($j != $panz) {
          $x=$pot[$j+1][0];
          $raus.="<g transform='translate($x)'>
";
        }
       }
  }
  
  $raus.='</g> <!-- Potentialfeld Ende -->
'; 
  
  # spiegeln ...
      if ($as == 1) {
       $raus.='<use xlink:href="#pot" transform="scale(1,-1)"/>
';
      }
  
  # Gaussfilter zu
  if ($gauss != 0) {   
  $raus.='</g> <!-- Gaußfilter Ende -->
';   
  }
  
if ($qtyp !=-1) { 
  # Gradient rüber
   $raus.='<g id="gr" fill="white" stroke="black" stroke-width="2">
';
  $x=$pot[1][0];
  $raus.="<g transform='translate($x)'>
";
  for ($j = 1; $j <=$danz; $j++) { 
    $x=$pot[$j][0];
    $y=$pot[$j][1];
 
    if ($pot[$j][3] !='no') {
     $win=round($pot[$j][3]);
     if ($title==1) {
      $raus.="<use xlink:href='#p' transform='translate(0,$y) rotate($win)'><title>$win</title></use>
";
     } else {
      $raus.="<use xlink:href='#p' transform='translate(0,$y) rotate($win)' />
";     
     }
    } else {
    $raus.="<use xlink:href='#c' transform='translate(0,$y)'><title>Gradient 0</title></use>
";
    }
    if ($pot[$j+1][0] != $pot[$j][0]) {
         $raus.='</g>
';
      if ($j != $panz) {
          $x=$pot[$j+1][0];
          $raus.="<g transform='translate($x)'>
";
      }
    }
  }
   $raus.='</g><!-- Ende Gradient -->
';
# spiegeln ...
   if ($as == 1) {
    $raus.='<use xlink:href="#gr" transform="scale(1,-1)"/>
';
   }
}
   
 # Bild in Speicher schreiben
ob_start(); 
echo '<?xml version="1.0"?>
';
?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
 xmlns:xlink="http://www.w3.org/1999/xlink" xml:lang="de" 
 viewBox="<?php echo $viewBox?>"
 font-family="monospace" font-size="24">
 <title>Farbfeld: Potential und Gradient</title>
 <desc>Zufälliges Farbfeld mit Gradienten
 
Parameter:
title: Titelinformation pro Kachel anzeigen? (0: nein, sonst ja)
qtyp: Typ Gradientendarstellung (0-5 oder -1: ohne)
kr: Kachelradius (nicht so relevant, weil sich die Größe des Bildes ohnehin an den verfügbaren Darstellungsbereich anpaßt), typisch 10
ds: Skalierungsfaktor Gradientensymbol, typisch kr/30
dw: Zusätzlicher Drehwinkel in Grad für das Gradientensymbol 
gauss: Standardabweichung Gaußfilter,  typisch kr, bei 0 abgeschaltet
ftyp: Typ der Farbskala (1 bis 715 oder -15 bis -1 für umgedrehte Skala)
fmin, fmax: Farbwert für Potential kleiner als das Minimum, beziehungsweise Maximum (bei diesem Zufallsfeld sollte dies nicht auftreten, weil es auf den zulässigen Bereich skaliert ist)
iter: Anzahl der Iterationen der Zufallslandschaft. typisch 20 (nicht mehr als 200)
selbst: Gewichtung gegenüber den sechs Nachbarn, die jeweils mit 1 berücksichtigt werden, Voreinstellung ist 1
xv,xb,yv,yb: Bereich von bis für x, beziehungsweise y, ganze Zahlen, aus dem Kachelradius ergibt sich der Abstand der Punkte.
Die Werte sind nach oben und unten vom Betrag her auf maximal 200 begrenzt
 </desc>
 <defs>
   
   <?php echo $dipd?> 
   
   <?php echo $hex?>
   
   <filter id="fi"> 
     <feGaussianBlur in="SourceGraphic" stdDeviation="<?php echo $gauss?>" result="Gauss" />
   </filter>
 </defs>
 <circle r="20000" fill="white" />
 
<?php echo $raus?>

</svg>


<?php
# Daten in Speicher lesen:
$data=ob_get_contents(); 
# Speicher leeren:
ob_clean();
# svg-header senden:
 $content="Content-type: image/svg+xml";
 header($content);
 header("Cache-Control: no-store, no-cache, must-revalidate");  // HTTP/1.1
 header("Cache-Control: post-check=0, pre-check=0", false); 
# Daten komprimieren:
$gzipdata = gzencode($data, 9);
$data="";
# gzip-Daten raushauen:
header("Content-encoding: gzip");
echo $gzipdata ;
?>