Die Ausgabe erfolgt in eine SVG Grafik direkt im Browser.
Mein erster Ansatz hat Unicode zeichen als Ausgabe verwendet. Ich hab mich dann allerdings für SVG entschieden weil ich damit noch nie gearbeitet hab.
Leider hab ich es zeitlich nicht mehr geschafft die Kontrastspreizung einzubauen aber es erfüllt auch so seinen Zweck.
Parameter / Optionen werden per GET übergeben.

Get Parameter :
image = Pfad zur Bilddatei
dither = Dither anwenden ( 1 = true / 0 false , 1 = default)
ditherRetCols = Anzahl Farben die nach dem dithern erhaltten bleiben soll
blockSize = Anzahl Pixel² die von der OriginalGrafik als ein Pixel zusammengenommen ( default = 1 , Bsp: 2 entspricht 2x2 Pixel)
diceSize = Länge bzw. Breite der Würfel ( 10 = default )

Im Anhang gibts das obama Bild einmal mit den Default Werten und einmal mit einer diceSize = 2

PHP-Code:

<?php

Class diceArt{
    public $imageHandle; 
    public $imageW;
    public $imageH;
    protected $imageType;
    protected $allowedExtensions = Array("gif","jpg","png");
    protected $luminanceLevels = Array();
    protected $maxLuminance;
    protected $blockSize;
    protected $temp = Array("red"=>Array(),"green"=>Array(),"blue"=>Array());
    protected $diceSize;
    public $dicedImage = '';
    
    public function __construct($image,$dither,$ditherRetCols,$blockSize,$diceSize){
            # Funktionsaufruf um das Bild zu laden ($image = Pfad zur Bilddatei)
        $this->imageHandle = $this->getImage($image);    
        if(!$this->imageHandle){
            echo 'Unsupported Filetype or Unable to load Image File';
            return false;
        }
            # blockSize bestimmt die die Anzahl Pixel² die vom Originalbild zusammen gefasst werden um die Helligkeit zu berechnen. ( 1 = default, 2 entspräche einem Bereich von 2x2 Pixeln)
        $this->blockSize = (ctype_digit($blockSize)) ? $blockSize : 1; 
        
            # diceSize bestimmt die Größe ( Breite/Höhe ) der Ausgegebenen Würfel ( 10 = default = Würfel mit Breite/Höhe = 10px)
        $this->diceSize = (ctype_digit($diceSize)) ? $diceSize : 10; 
        
            # Ermitteln der Breite des Originalbildes
        $this->imageW = $this->getImageDimensions('x');    
        
            # Ermitteln der Höhe des Originalbildes
        $this->imageH = $this->getImageDimensions('y'); 
        
            # Funktionsaufruf um das Bild zu "dithern". $ditherRetCols ist die Anzahl der Farben des Originalsbildes die erhalten bleiben sollen
        if($dither == 1){
            $ditherRetCols = (ctype_digit($ditherRetCols)) ? $ditherRetCols : 6; 
            $this->imageHandle = $this->applyDither($ditherRetCols); 
        }
             # Funktionsaufruf um das Bild von oben->unten und links->rechts zu durchlaufen.
        $this->traverseImage('contrast');
    }
    
    protected function getImage($image){
            # Ermitteln der Dateiendung des Originalbildes
        $image_ext = pathinfo($image);
        $this->imageType = $image_ext['extension']; 
        
            # Prüfen ob die Dateiendung unterstützt wird ( Erlaubt sind gif/png/jpg )
        if (in_array($this->imageType,$this->allowedExtensions)){    
        
                # Bilderstellen mit der jeweiligen Funktion
            switch ($this->imageType){    
                case 'gif':
                    $im = imagecreatefromgif($image);
                break;
                case 'jpg':
                    $im = imagecreatefromjpeg($image);
                break;
                case 'png':
                    $im = imagecreatefrompng($image);
                break;            
            }
            return $im;
        }else{
            return false;
        }
    }
    
        # Funktion um Breite und / Höhe der Bildes zu ermitteln
    protected function getImageDimensions($axis){
        if(!isset($axis)){
            echo 'No Axis defined';
            return false;
        }else{
            switch ($axis){
                case 'x':
                    return imagesx($this->imageHandle);
                break;
                case 'y':
                    return imagesy($this->imageHandle);
                break;
            }
        }
    }
    
        # Funktion zum "dithern" des Bildes ( das Neu erstellen und kopieren ist leider für notwendig um die funktionalität von imagetruecolortopalette zu gewährleisten.)
    protected function applyDither($ditherRetCols){    
                # Erstellen eines leeren truecolor Bildes mit Breite/Höhe vom Original
            $dstimage=imagecreatetruecolor($this->imageW,$this->imageH);
            $srcimage=$this->imageHandle;
                
                # 1 : 1 Kopie des Originalbildes
            imagecopyresampled($dstimage,$srcimage,0,0,0,0, $this->imageW,$this->imageH,$this->imageW,$this->imageH);
                # Eigentliche Funktion die für das "dithern" zuständig ist
            imagetruecolortopalette($dstimage,true,$ditherRetCols);

            return $dstimage;
    }
    
        # Funktion die die RGB Farben eines Pixels in Form eines Arrays zurück liefert
    protected function getRGBColors($handle,$x,$y){
        $pxlColor = imagecolorat($handle, $x,$y);
        $pxlColorArr = ImageColorsForIndex($handle, $pxlColor);
        return $pxlColorArr;
    }
    
        # Funktion zum berechnen der Helligkeit eines Pixels anhand der RGB Farben
    protected function calculateLuminance($red,$green,$blue){
        $lum = (0.299 * $red) + (0.587 * $green) + (0.114 * $blue);
        return $lum;
    }
    
        # Funktion zum erstellen der Würfel
    protected function buildDice($x,$y,$lum){
            /* $x und $y sind die Koordinaten des zu erstellenden Würfels
                1 / blockSize bewirkt das bei einer blockSize != 1 die Würfel immernoch, ohne einen Abstand zwischen einander, Platziert werden
                * diceSize bewirkt das die Koordinaten jeweils um die Breite/Höhe der Würfel verschoben werden da die Würfel ansonsten in einander liegen würden.
            */
        $x=($x * ( 1 / $this->blockSize)) * $this->diceSize;
        $y=($y * ( 1 / $this->blockSize)) * $this->diceSize;
        
            # Erstellt ein neues SVG-Rechteck mit den errechneten Koordinaten, der angegebenen Breite/Höhe und einer Linienstärke von Würfelbreite/20  (entspricht 0.5 pixel bei einem 10x10 Würfel)
        $this->dicedImage .= '<rect x="' . $x . '" y="' . $y . '" width="' . $this->diceSize . '" height="' . $this->diceSize . '" stroke-width="' . $this->diceSize/20 . '"/>';
            
            /* Bestimmt anhand der Berechneten Helligkeit welcher Würfel zu erstellen ist ( von o.n.u 6,5,4,3,2,1 )
                $coords ist ein Array mit x/y Paaren die die errechneten Koordinaten der Würfelaugen beinhaltet.
                Die Koordinaten sind Abhängig von den Koordinaten des Würfels sowie von der Größe des Würfels.
            */
        if($lum<=($this->maxLuminance/6)){
            $coords = Array("x1" => $x+($this->diceSize/3.3),"y1" => $y+($this->diceSize/3.3),"x2" => $x+($this->diceSize/1.43),"y2" => $y+($this->diceSize/3.3),"x3" => $x+($this->diceSize/1.43),"y3" => $y+($this->diceSize/1.43),"x4" => $x+($this->diceSize/3.3),"y4" => $y+($this->diceSize/1.43),"x5" => $x+($this->diceSize/3.3),"y5" => $y+($this->diceSize/2),"x6" => $x+($this->diceSize/1.43),"y6" => $y+($this->diceSize/2));
        }
            elseif($lum<=($this->maxLuminance/6) * 2){
                $coords = Array("x1" => $x+($this->diceSize/3.3),"y1" => $y+($this->diceSize/3.3),"x2" => $x+($this->diceSize/1.43),"y2" => $y+($this->diceSize/3.3),"x3" => $x+($this->diceSize/2),"y3" => $y+($this->diceSize/2),"x4" => $x+($this->diceSize/1.43),"y4" => $y+($this->diceSize/1.43),"x5" => $x+($this->diceSize/3.3),"y5" => $y+($this->diceSize/1.43));
            }
                elseif($lum<=($this->maxLuminance/6) * 3){
                    $coords = Array("x1" => $x+($this->diceSize/3.3),"y1" => $y+($this->diceSize/3.3),"x2" => $x+($this->diceSize/1.43),"y2" => $y+($this->diceSize/3.3),"x3" => $x+($this->diceSize/1.43),"y3" => $y+($this->diceSize/1.43),"x4" => $x+($this->diceSize/3.3),"y4" => $y+($this->diceSize/1.43));
                }
                    elseif($lum<=($this->maxLuminance/6) * 4){
                        $coords = Array("x1" => $x+($this->diceSize/3.3),"y1" => $y+($this->diceSize/3.3),"x2" => $x+($this->diceSize/2),"y2" => $y+($this->diceSize/2),"x3" => $x+($this->diceSize/1.43),"y3" => $y+($this->diceSize/1.43));
                    }
                        elseif($lum<=($this->maxLuminance/6) * 5){
                            $coords = Array("x1" => $x+($this->diceSize/3.3),"y1" => $y+($this->diceSize/3.3),"x2" => $x+($this->diceSize/1.43),"y2" => $y+($this->diceSize/1.43));
                        }
                            else{
                                $coords = Array("x1" => $x+($this->diceSize/2),"y1"=>$y+($this->diceSize/2));
                            }
            
            # Übergibt das WürfelAugen Koordinaten Array an die Funktion zum erstellen der Würfelaugen 
        $eyes = $this->diceEyes($coords);
        $this->dicedImage .= $eyes;
        return true;
    }
    
        # Funktion zum erstellen der Würfelaugen
    protected function diceEyes($coords){
        $diceEyes = '';
        
            # Durchläuft das Koordinaten Array für die Anzahl der x/y Paare
        for($i=1;$i<=count($coords)/2;$i++){
            $x = 'x' . $i;
            $y = 'y' . $i;
            
                # Erstellt einen Kreis den übergebenen Koordinaten (cx=x1 cy=y1 ...) und mit einem radius von Würfelbreite/12.5 (entspricht 0.8 pixel bei einem 10x10 Würfel)
            $diceEyes .= '<circle cx="' . $coords[$x] . '" cy="' . $coords[$y] . '" r="' . $this->diceSize/12.5 . '" />';
        }
        return $diceEyes;
    }
    
        /*
            Funktion zum durchlaufen des Bildes von o->u und l->r
            Die Schleifen laufen per Default über jede Pixel.
            Wenn blockSize != 1 laufen die Schleifen nur noch über jeden n-ten Pixel
            Eine Interne Schleife gruppiert die Übersprungenen Pixel und errechnet den Durchschnitt der Helligkeit
        */
    protected function traverseImage($type){
        for($y=0;$y<$this->imageH;$y+=$this->blockSize){
            for($x=0;$x<$this->imageW;$x+=$this->blockSize){
                switch ($type){
                        
                        /* 
                            Der erste Aufruf der traverseImage Funktion spricht nur den 'contrast' Fall an
                            Es wird versucht den Kontrast zu verbessern. ( Ehrlich gesagt keine Ahnung obs funktioniert )
                        */
                    case 'contrast':
                            for($i=0;$i<$this->blockSize;$i++){
                            
                                $xx = $x + $i;
                                $yy = $y + $i;
                                if(!($xx >= $this->imageW) && !($yy >= $this->imageH)){
                                    $colorArr = $this->getRGBColors($this->imageHandle,$x,$y);
                                    $this->luminanceLevels[] = $this->calculateLuminance($colorArr['red'],$colorArr['green'],$colorArr['blue']);
                                }
                            }                
                    break;
                    
                            /*
                                Der zweite Aufruf der traverseImage Funktion kommt von sich selbst und spricht nur den 'draw' Fall an
                            */
                    case 'draw':
                                /*
                                    Eine Schleife die für x < blockSize läuft
                                    Es werden die RGB Farben von einem oder ( falls blockSize != 1 ) mehreren Pixel ermittelt und in einem Array "gespeichert" 
                                */
                            for($i=0;$i<$this->blockSize;$i++){
                                $xx = $x + $i;
                                $yy = $y + $i;
                                    
                                    /* Prüft ob sich die angegebenen Pixel innerhalt des Bildes befinden ( out of Bound )
                                        Falls ja werden die RGB Werte des Pixels ermittelt und in das temp Array geschrieben
                                    */
                                if(!($xx >= $this->imageW) && !($yy >= $this->imageH)){
                                    $colorArr = $this->getRGBColors($this->imageHandle,$xx,$yy);
                                    $this->temp['red'][] = $colorArr['red'];
                                    $this->temp['green'][] = $colorArr['green'];
                                    $this->temp['blue'][] = $colorArr['blue'];
                                }
                            }
                            
                                # Ermittelt den Durchschnitlichen Wert der RGB Farben
                            $red = array_sum($this->temp['red']) / count($this->temp['red']);
                            $green = array_sum($this->temp['green']) / count($this->temp['green']);
                            $blue = array_sum($this->temp['blue']) / count($this->temp['blue']);
                            
                                # Schickt die RGB Farben zur Helligkeits berechnung und Anschliessend zur Würfelerstellung ;)
                            $lumLvl = $this->calculateLuminance($red,$green,$blue);
                            $this->buildDice($x,$y,$lumLvl);
                                                        
                                # Leert die Arrays wieder um falsche Werte zu verhindern
                            $this->temp['red'] = Array();
                            $this->temp['green'] = Array();
                            $this->temp['blue'] = Array();
                    break;
                }            
            }
        }
            
            /* Wird nur beim ersten Funktionsaufruf von traverseImage ausgeführt. 
                Setzt die Maximale Helligkeit und ruft danach traverseImage auf
            */
        if($type=='contrast'){
            $this->maxLuminance = max($this->luminanceLevels);
            unset($this->luminanceLevels);
            $this->traverseImage('draw');
        }
        return true;
    }
    
        # Funktion zum Ausgeben des Würfelbildes
    public function drawImage(){
        $this->dicedImage .= '</svg>';
        echo $this->dicedImage;
    }

}#EO Class

if (isset($_GET['image'])){
    $image_Path = $_GET['image'];
    $dither = (isset($_GET['dither'])) ? $_GET['dither'] : 1;
    $ditherRetCols = (isset($_GET['ditherRetCols'])) ? $_GET['ditherRetCols'] : 6;
    $blockSize = (isset($_GET['blockSize'])) ? $_GET['blockSize'] : 1;
    $diceSize = (isset($_GET['diceSize'])) ? $_GET['diceSize'] : 10;
    
    $draw = new diceArt($image_Path,$dither,$ditherRetCols,$blockSize,$diceSize);
    
    header("Content-Type: image/svg+xml");
    echo '<?xml version="1.0" encoding="UTF-8"?>';
    
    ?>
    <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
      <svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events"
     version="1.1" baseProfile="full"
     width="<?php echo $draw->imageW * $diceSize . 'px';?>" height="<?php echo $draw->imageH * $diceSize . 'px';?>">
     <defs>
        <style type="text/css"><![CDATA[
          rect {
            fill:white;
            stroke:#ccc;
          }
          circle {
            fill:black;
          }
        ]]></style>
  </defs>

    <?php
    $draw->drawImage();
}else{
    echo 'No image given';
}