Hallo,
ich habe mir einen color-chooser (gui) gebaut, was sich für mich als schwieriger herausgestellt hat, als ich dachte.
Signatur (die Klasse beerbt JComponent):
Dies erzeugt erzeugt nx * ny gefärbte Quadrate die zur Auswahl zur Verfügung stehen.
Jetzt stand ich vor dem Problem, alle Permutationen der Farben von (0,0,0) bis (255,255,255) gleichmäßig auf nx*ny aufzuteilen. Ich glaube man nennt das Interpolation.
Schlussendlich kam ich auf die Idee, den gesamten Farbraum durch die Anzahl der Felder zu teilen, um in diesem Abstand darüber zu iterieren. Dann fasse ich den Anteil jeder Iteration als eine Zahl zur Basis 256 auf und extrahiere damit also die einzelnen der drei Komponenten:
(Das wäre sicher mit bitshift eleganter gewesen, habe ich mittlerweile gelernt)
Jetzt hat sich aber herausgestellt, dass es bestimmte Anzahlen von Feldern nx*ny gibt, die sehr ungünstige Interpolationen erzeugen; im schlimmsten Fall nur Grauwerte (das ist aber kein Problem mehr); störend sind sehr ähnlich wirkende Farben mit größerem Abstand zueinander.
Durch Ausprobieren fand ich heraus, dass diese sehr ähnlich wirkenden Farben die gleiche Komponentensumme haben.
Ausprobieren hiess wirklich brut-force - deswegen schreibe ich hier: mir fehlt die nötige Mathematik und das Verständnis, wann es zu solchen Effekten kommt und wann nicht.
Ich meine, ich hätte gerne irgendeine Berechnungsvorschrift, die mir nicht nur sagt, wann gleiche Komponentensummen nicht vorkommen (die gibt es), sondern mir gleich mitliefert, was eine besonders günstige Anzahl wäre.
Kann mir da jemand auf die Sprünge helfen ?
ich habe mir einen color-chooser (gui) gebaut, was sich für mich als schwieriger herausgestellt hat, als ich dachte.
Signatur (die Klasse beerbt JComponent):
Java:
public SmallColorChooser(final int nx, final int ny, final int fieldSize)Dies erzeugt erzeugt nx * ny gefärbte Quadrate die zur Auswahl zur Verfügung stehen.
Jetzt stand ich vor dem Problem, alle Permutationen der Farben von (0,0,0) bis (255,255,255) gleichmäßig auf nx*ny aufzuteilen. Ich glaube man nennt das Interpolation.
Schlussendlich kam ich auf die Idee, den gesamten Farbraum durch die Anzahl der Felder zu teilen, um in diesem Abstand darüber zu iterieren. Dann fasse ich den Anteil jeder Iteration als eine Zahl zur Basis 256 auf und extrahiere damit also die einzelnen der drei Komponenten:
(Das wäre sicher mit bitshift eleganter gewesen, habe ich mittlerweile gelernt)
Java:
final int base = 256;
final int step = (base*base*base-1)/(n-1);
int[] rgb = new int[3];
int v;
for(int i = 0; i < n; ++i) {
//elided
v = i*step;
for(int j = 0; j < rgb.length; ++j) {
rgb[j] = v%base;
v /= base;
}
field[i].setBackground(new Color(rgb[0], rgb[1], rgb[2]));
}Jetzt hat sich aber herausgestellt, dass es bestimmte Anzahlen von Feldern nx*ny gibt, die sehr ungünstige Interpolationen erzeugen; im schlimmsten Fall nur Grauwerte (das ist aber kein Problem mehr); störend sind sehr ähnlich wirkende Farben mit größerem Abstand zueinander.
Durch Ausprobieren fand ich heraus, dass diese sehr ähnlich wirkenden Farben die gleiche Komponentensumme haben.
Ausprobieren hiess wirklich brut-force - deswegen schreibe ich hier: mir fehlt die nötige Mathematik und das Verständnis, wann es zu solchen Effekten kommt und wann nicht.
Ich meine, ich hätte gerne irgendeine Berechnungsvorschrift, die mir nicht nur sagt, wann gleiche Komponentensummen nicht vorkommen (die gibt es), sondern mir gleich mitliefert, was eine besonders günstige Anzahl wäre.
Kann mir da jemand auf die Sprünge helfen ?
