Ein Bild "programmieren" -> Mit welcher Umgebung und möglichst geringem Aufwand

[slneu87]

Hi,

Ich habe eine Idee für ein schönes Bild. Ich hab einen Testdruck von einem Fotodrucker, der Ausdruck ist ca. 60x60cm. Das Bild ist gekachelt, jeweils 1x1cm und die Farben der Kacheln sind über das gesamte RGB Spektrum zufällig.

Ich will so etwas ähnliches jetzt auch machen, allerdings mit eigenen Farben (bzw. speziellen Farbverläufen).

Da es ein paar tausend Kacheln sind fällt das "per Hand machen" mit Photoshop flach.

Die Programmierung ist nicht das Problem, ich habe Erfahrung in vielen Sprachen und i.d.r. kann jede farbige Rectangles auf einem Canvas erzeugen. Ich bräuchte aber ja folgenden Prozess:

1.) Canvas erzeugen, so dass eine für 60x60cm druckfähige Auflösung herauskommt (wie rechne ich das in Pixel um)?
2.) Die Kacheln erzeugen und entsprechend färben
3.) Das Canvas als JPEG (o.ä.) in eine Datei schreiben.

und um es etwas schwieriger zu machen ( ): Wenn irgend möglich ohne Xcode, weil ich das nicht mehr installiert habe und es auf meinem Rechner ein riesen Act ist das zum Laufen zu bekommen.

Am liebsten hätte ich irgendeine Websprache denke ich, weil die am einfachsten ist. Könnte JavaScript so etwas?


Grüße

 

[1Valla7Foldum4A]

Könntest du das Bild mal hochladen? — Ich kann mir irgendwie nichts darunter vorstellen.

 

[TEXnician]

Du hast nach möglichst geringem Aufwand gefragt, kannst du haben. In Mathematica kannst du mit der "Image"-Funktion (siehe http://reference.wolfram.com/language/ref/Image.html), aus einem Array/einer Matrix mit Farbwerten ein Bild, das so viele Kacheln in Höhe und Breite hat wie die Matrix Zeilen/Spalten hat. Mit der Option ImageSize kontrollierst du die Anzahl der Pixel. Am Ende dann mit der Funktion "Export" passend exportieren. Das Array/Matrix kannst du dann füllen wie es dir beliebt (Stichwort: Funktion "Table).

 

[WollMac]

Moin,

1.) Canvas erzeugen, so dass eine für 60x60cm druckfähige Auflösung herauskommt (wie rechne ich das in Pixel um)?

Kommt auf die gewünschte Auflösung an.
Bei 300 dpi wären das 7080 Pixel Kantenlänge.
Rechenweg:
60 cm geteilt durch 2,54 (ein Inch =2,54 cm) =23,6
23,6 mal gewünschte Auflösung.

 

[TEXnician]

Oder man erstellt eine Vektorgraphik, die die einfarbigen, großen (quadratischen) Flächen/Kacheln enthält. Die kann man dann beliebig skalieren und muss nicht erst kompliziert Rastergraphiken erstellen, deren Auflösung man dann anpassen muss, wenn man das Bild größer drucken will.

 

[debok]

“Bilder programmieren” – das klingt, als wäre Processing genau das Richtige.

 

[TEXnician]

Hier mal ein Beispiel in Mathematica:

f[x_, y_] := {x, y, (x + y)/2}
n = 30;
m = 20;
Tabelle = Table[f[i/n, j/m], {i, 1, n}, {j, 1, m}];
Bild = Image[Tabelle, ColorSpace -> "RGB"]
Export["Test.jpeg", Bild]

Kurz zur Erklärung: Die Funktion f bildet den Farbverlauf ab. Da wir am Ende einen farbigen Verlauf im RGB-Farbraum wollen, müssen dazu Tupel von je drei Farbwerten (rot, grün, blau) berechnet werden. Die Beispielfunktion sollte ansonsten selbsterklärend sein (zumindest dann, wenn man Mathematica-Code lesen kann).

Als nächstes werden die Anzahl Kacheln in x- (hier n) und y-Richtung (hier m) festgelegt. Am Ende werden quadratische Kacheln erzeugt. Danach wird eine Tabelle der Farbwerte erzeugt und anschließend mit der Funktion "Image" in ein Farbbild konvertiert. Das Ergebnis wird dann exportiert.

Hier im Anhang habe ich mal das Ergebnis angehängt. Und ja, es ist sehr klein, nämlich genau 30x20 Pixel groß. Mehr braucht es hier auch nicht, denn wie bereits erwähnt enthält das Bild so bereits alle Informationen. Man kann es dann natürlich für den Druck noch in ein größeres Bild konvertieren, das kann man am Monitor simulieren, wenn man das Bild einfach entsprechend vergrößert darstellt.

 

[TEXnician]

Scheint ja nicht so wichtig zu sein.

Noch ein etwas günstigerer Tipp: In TikZ kann man ganz einfach farbige Rechtecke erzeugen. Mit zwei geschachtelten foreach-Schleifen kann man so eine "Matrix" aus Rechtecken erzeugen. Die Farbwerte kann man sich dann aus den Iterationsindices berechnen lassen (ähnlich wie bei der Mathematica-Lösung). Die Vorteile: TikZ ist kostenlos und Opensource und es werden direkt Vektorgraphiken erzeug, womit sich das Skalierungsproblem erst gar nicht ergibt.

 

[TEXnician]

Hier mal eine Lösung für ConTeXt (für LaTeX müssen nur ein paar kleine Änderungen vorgenommen werden):

\usemodule[tikz]
\usetikzlibrary[math]

\def\hoehe{20cm}
\def\breite{20cm}

\definepapersize[blatt][width=\breite,height=\hoehe]

\setuppapersize[blatt][blatt]

\setuplayout[backspace=0cm, topspace=0cm,header=0cm,footer=0cm,top=0cm,topdistance=0cm,headerdistance=0cm,footerdistance=0cm,bottomdistance=0cm,bottom=0cm,bottomspace=0cm,cutspace=0cm,leftedge=0cm,leftedgedistance=0cm,leftmargin=0cm,leftmargindistance=0cm,rightmargindistance=0cm,rightmargin=0cm,rightedgedistance=0cm,rightedge=0cm,horoffset=0cm,voroffset=0cm]

\starttext


\starttikzpicture

\tikzmath{
\groesse = 20;
\nx = 20;
\ny = 30;
\stepinx = \groesse/\nx;
\stepiny = \groesse/\ny;
}

\foreach \x in {1,2,...,\nx} {
    \foreach \y in {1,2,...,\ny} {
        \pgfmathsetmacro{\rvalue}{\x/\nx}
        \pgfmathsetmacro{\gvalue}{\y/\ny}
        \pgfmathsetmacro{\bvalue}{0.5*(\x/\nx+\y/\ny)}
        
        \pgfmathsetmacro{\xcoor}{\x/\nx*\groesse}
        \pgfmathsetmacro{\ycoor}{\y/\ny*\groesse}
        \definecolor[mycolor][r=\rvalue,g=\gvalue,b=\bvalue]
        \filldraw[,mycolor] (\xcoor,\ycoor) rectangle ++(\stepinx,\stepiny);
    }
}

\stoptikzpicture


\stoptext