# keine ähnliche Farben durch Random in Java



## ottens (26. Aug 2011)

Hallo ihr nette Leute, 

ich habe ein Problem und zwar ich soll Farben durch Random erstellen damit
werden Linein bzw Kurven gezeichnet die Frage wie kann man bestimmen bzw
kontrollieren, dass zwei oder mehr als zwei Farben, die mit Random erstellt 
worden sind,  nicht sehr ähnlich aussehen, dass man sie ganz deutlich mit 
den Augen auseinander unterscheiden kann ??

habt ihr einen Vorschlag bitte ?

bedanke mich ganz herzlich  

ottens  :bahnhof:


----------



## SlaterB (26. Aug 2011)

du kannst dir ja die Werte anschauen und bestimmen dass sie um mindestens 20 abweichen müssen,
im hellen oder dunklen Bereich vielleicht mehr oder weniger, 
bei Abweichung bei verschieden Farben reichen vielleicht geringere Grenzen usw.

einfach machen, ausprobieren, und aus Ergebnissen lernen und verfeinern

ich persönlich habe mir aus ähnlichen Grunde mit gewisser Arbeit eine Liste brauchbarer Farben zurechgelegt,
recht helle Farben wie Color.YELLOW, die sich vom weißen Hintergrund kaum unterscheiden, sind eher nicht dabei

```
private static int F = 255; // full
    private static int H = 127; // half
    private static int T = 180; // third, dreiviertel
    private static int Q = 60; // quarter, einviertel
    /**  */
    public static final Paint[] PAINT = new Paint[]
        {Color.RED, //
         new Color(150, 150, 255), // Haupt-blau
         new Color(100, 100, 255), // rot-lila
         Color.GREEN, //
         c(T, Q, Q), // dunkelrot
         c(H, F, F), // hellblau
         c(H, Q, 0), // braun
         c(F, H, H), // hellrot
         c(H, 0, F), // lilablau
         c(T, T, 0), // gold
         c(0, T, T), // mittelgrünblau
         c(F, H, F), // helllila
         Color.GRAY, //
         c(0, F, H), // grünblau
         c(T, H, 0), // dunkelorange/ braun
         c(F, 0, H), // lilarot
         c(H, F, H), // hellgrün
         Color.LIGHT_GRAY,//
         c(0, F, F), // hellgrünblau
         c(F, T, 0), // orange
         c(0, T, F), // mittelgrünblau
         c(F, 0, F), // lila
         c(80, 80, F), // fast normal blau
         c(Q, T, Q), // dunkelgrün
         Color.BLACK, //
         c(Q, Q, T), // dunkelblau
         c(220, 220, 0), // gelb
         c(T, 0, T), // dunkellila
         c(T, F, 0), // hell gelb/grün
         c(H, T, 0), // mittel gelb/grün
         c(Q, H, 0), // dunkel gelb/grün
        };
```
ist natürlich was anderes als komplett zufällige Farben, nur als Alternative


----------



## ottens (26. Aug 2011)

danke für die Antwort aber glaube das wird mir nicht weiterhelfen ich habe so Pool von Farben von diesem Pool werden erst 
die Farben zum zeichnen übernommen dann wenn die Farben im Pool (mehr als ca. 50 Farben) nicht reichen sollen Randomfarben erstellt werden und die Random Farben sollen sich von den Farben, die im Pool sind, sich unterscheiden (optisch).

LG
Ottens


----------



## Fu3L (26. Aug 2011)

Wie sind die Farben denn gespeichert? In Color Objekten? In ihren einzelnen 3 RGB Werten oder als ein Integer?


----------



## ottens (26. Aug 2011)

im Pool werden dir Farben als Color [] Reihung [new Color(r0,g0,b0), new Color(r1,g1,b1) usw ]; weil jede Kurve in der Zeichnung soll ihre Farbe (fest zugeteilt) von der Reihung bekommen, wenn mehr Kurven kommen, soll Zufallfarbe durch Random erstellt werden, die von allen Farben die schon im Pool sind, sich unterscheiden, damit man optisch erkennen kann welch Kurve welche Farbe hat. 


best Grüße

ottens


----------



## Fu3L (26. Aug 2011)

```
Color c = new Color(200,200,200);
int col = c.getRGB();
int r = (col >> 16) & 0xff; //MIr fällt grad ein: Man könnte auch einfach Color.getRed() etc nehmen^^
int g = (col >> 8) & 0xff;
int b = (col) & 0xff;
Random rnd = new Random();
int r2 = rnd.nextInt(256);
int g2 = rnd.nextInt(256);
int b2 = rnd.nextInt(256);
//Diesen Vergleich für alle Farben durchführen
if(!(Math.abd(r2-r)+Math.abs(g2-g)+Math.abs(b2-b) >= 30)) {
   //Sobald einer keinen Erfolg liefert neue Werte probieren
} 
//Wenn alle den Unterschied erfüllen, dann ist das neue Color Objekt wie folgt:
int newCol =  r << 16 | g << 8 | b;
Color newColorObject = new Color(newCol);
```

Wäre etwas was mit nach Slaters Post so einfallen würde^^ Keine Garantie auf hinreichend passende Resultate^^


----------



## ottens (26. Aug 2011)

Oh Oh Oh wo finde Erklärung ? werde einfach probieren was glaubst du ?

ich bin nicht so sehr erfahren damit, aber Einsteiger nur !

bedanke mich ganz herzlich, wenn dir noch was einfällt bitte  her damit .

Grüße

Ottens  :bahnhof:


----------



## Fu3L (26. Aug 2011)

Ich interpretierer deinen Post so, dass du nicht weißt, wie dus anwenden sollst?

c soll ein Beispielwert für eine Farbe deines Arrays sein. Du erzeugst eine neue Farbe (r2, g2, b2) und kontrollierst dann in einer Schleife jeden Wert des Arrays. Wenn das if einmal betreten wird, musst du eine neue Farbe erzeugen und das Array nochma von vorne durchgehen. Wird das Array einmal ganz durchgegangen, ohne dass das if anschlägt, dann kannste n neues Colorobjekt erzeugen.


----------



## ottens (26. Aug 2011)

werde testen es ist aber ganz lieb von dir mensch so Forum findet man nette leute wie du 
das Problem aber, im Pool (bei mir Reihung von Colors-Objekte) die Farben an Kurven festzugeteilt 
vom Anfangan.
also 
Kurve 1 sollte new Color (r1,g1,b1)
Kurve 2 sollte new Color (r2,g2,b2) 
        .
        .
        .
      usw
von der Reihung zugetielt werden, wenn noch mehr Kurven gebraucht werden, dann 
sollte Random-Farbe erstellt werden.

werde dein Code aber versuchen zu verstehen vielleicht ergibt sich eine Idee,womit ich weiter kommen kann.

viele Gruß

Ottens


----------



## 0x7F800000 (26. Aug 2011)

```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class DifferentColors {

	// 241, 251 sind primzahlen, also wiederholen sich die Farben mit der Periode
	// lcm(241, 251, 256) = 241*251*256 = 15485696
	// wenn es nur darum geht, dass zwei nebeneinander stehende punkte nicht verschmelzen,
	// dann sollte es reichen:
	
	public static Color createColor(int i){
		return new Color((56 + i * 122) % 241, (130 + i * 67) % 251, (220 + i * 45) % 256); 
	}
	
	// kleines demo
	public static void main(String... _){
		
		class Animated extends JComponent implements ActionListener{
			private static final long serialVersionUID = 1L;
			private Timer timer = new Timer(200, this);
			{
				timer.start();
			}
			private int t = 0;
			@Override
			public void paint(Graphics g){
				for(int r = 0; r < 32; r++){
					g.setColor(createColor((r + t)*32));
					g.fillRect(16*r, 0, 16, 512);
					
				}
				t ++;
			}	
			public void actionPerformed(ActionEvent e){ repaint(); }
		}
		
		JFrame f = new JFrame("colors");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new Animated()); 
		f.setSize(new Dimension(512, 512));
		f.setVisible(true);
	}
}
```
einfach mal laufen lassen... Nebeneinander kommende Streifen kann man imho ganz gut auseinanderhalten. Dass du mehr als 15 Mio von irgendwelchen Dingen malen willst, glaube ich nicht: so viele Pixel gibt's nicht auf dem Bildschirm. Du brauchst natürlich nur die kleine createColor methode, diese bemüht random nicht, sondern arbeitet direkt mit %, das ist schneller, und genauso pseudo-random wie Random selbst.

Übrigens: mit Random zu versuchen, "deutlich unterschiedliche" Farben zu erzeugen ist ein Unding: eigentlich hat man sich beim Random sehr viele Gedanken gemacht, wie man erreicht, dass genau solche Effekte *nicht* auftreten. Was du brauchst ist also ein *schlechter* Zufallsgenerator, wie der in [c]createColor()[/c].


----------



## 0x7F800000 (26. Aug 2011)

Ach, jetzt versteh ich was du willst... Du willst die fahrebn *paarweise* weit voneinander haben, nicht nur zwei nacheinanderfolgende.

Folgender Versuch:

```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import static java.lang.Math.*;

public class DifferentColors2 {

	public static Color[] createColors(int i){
		double[][] x = new double[i][3];
		double[][] v = new double[i][3];
		double[][] a = new double[i][3];
		
		// punkte irgendwie auf einer kugel verteilen
		for(int j = 0; j < i; j++){
			x[j][0] = 0.5 + 0.01 * cos(j*78.34 + 78);
			x[j][1] = 0.5 + 0.01 * sin(j*56.9 + 10.2);
			x[j][2] = 0.5 + 0.01 * sin(j*77 + 99.78);
		}
		
		// partikel mit 1/r kräften voneinander abstoßen, herumfliegen lassen
		double[] diff = new double[3];
		double dt = 0.03;
		for(double t = 0; t < 10; t += dt){
			for(int j = 0; j < i; j++){
				// beschleunigungen auf 0 setzen
				for(int k = 0; k < 3; k++) a[j][k] = 0d;
				// beschleunigungen auf 1/r setzen
				for(int l = 0; l < i; l++){
					if(l != j){
						for(int k = 0; k < 3; k++) diff[k] = x[j][k] - x[l][k];
						double rSquare = 0d;
						for(int k = 0; k < 3; k++) rSquare += diff[k]*diff[k];
						for(int k = 0; k < 3; k++) a[j][k] += 0.1 * diff[k] / (0.0001 + rSquare);
					}
				}
			}
			
			for(int j = 0; j < i; j++){
				// geschwindigkeit aktualisieren
				for(int k = 0; k < 3; k++){
					v[j][k] *= 0.95;  // reibung
					v[j][k] += a[j][k] * dt;
				}
				// position aktualisieren
				for(int k = 0; k < 3; k++){
					x[j][k] += v[j][k]*dt;
				    if(x[j][k] < 0){ v[j][k] *= -1; x[j][k] = 0.001*j; }
				    if(x[j][k] > 1){ v[j][k] *= -1; x[j][k] = 1 - 0.001*j; }
				}
			}
		}
		
		// positionen in farben übersetzen
		Color[] result = new Color[i];
		for(int j = 0; j < i; j++){
			result[j] = new Color((float)x[j][0], (float)x[j][1], (float)x[j][2]);
		}
		return(result);
	}
	
	// kleines demo
	public static void main(String... _){
		
		class Animated extends JComponent implements ActionListener{
			private static final long serialVersionUID = 1L;
			private Timer timer = new Timer(1000, this);
			{
				timer.start();
			}
			private int t = 0;
			@Override
			public void paint(Graphics g){
				int r = 0;
				
				for(Color color: createColors(t)){
					g.setColor(color);
					g.fillRect((512/t)*r, 0, (512/t), 512);
					r += 1;
				}
				t = (t + 1)%32;
			}	
			public void actionPerformed(ActionEvent e){ repaint(); }
		}
		
		JFrame f = new JFrame("colors");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new Animated()); 
		f.setSize(new Dimension(512, 512));
		f.setVisible(true);
	}
}
```
Hier werden einfach Teilchen in den Farbraum-Würfel reingeworfen, und dotzen dadrin herum, bis sie weit genug voneinander weggewandert sind.

An dieser Variante kann man die Wege der Teilchen im Farbraum verfolgen, es ist lahm, für nix zu gebrauchen, aber recht lustig:

```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import static java.lang.Math.*;

public class DifferentColors2 {

	public static Color[] createColors(int i, double maxT){
		double[][] x = new double[i][3];
		double[][] v = new double[i][3];
		double[][] a = new double[i][3];
		
		// punkte irgendwie auf einer kugel verteilen
		for(int j = 0; j < i; j++){
			x[j][0] = 0.5 + 0.01 * cos(j*78.34 + 78);
			x[j][1] = 0.5 + 0.01 * sin(j*56.9 + 10.2);
			x[j][2] = 0.5 + 0.01 * sin(j*77 + 99.78);
		}
		
		// partikel mit 1/r kräften voneinander abstoßen, herumfliegen lassen
		double[] diff = new double[3];
		double dt = 0.03;
		for(double t = 0; t < maxT; t += dt){
			for(int j = 0; j < i; j++){
				// beschleunigungen auf 0 setzen
				for(int k = 0; k < 3; k++) a[j][k] = 0d;
				// beschleunigungen auf 1/r setzen
				for(int l = 0; l < i; l++){
					if(l != j){
						for(int k = 0; k < 3; k++) diff[k] = x[j][k] - x[l][k];
						double rSquare = 0d;
						for(int k = 0; k < 3; k++) rSquare += diff[k]*diff[k];
						for(int k = 0; k < 3; k++) a[j][k] += 0.1 * diff[k] / (0.0001 + rSquare);
					}
				}
			}
			
			for(int j = 0; j < i; j++){
				// geschwindigkeit aktualisieren
				for(int k = 0; k < 3; k++){
					v[j][k] *= 0.95;  // reibung
					v[j][k] += a[j][k] * dt;
				}
				// position aktualisieren
				for(int k = 0; k < 3; k++){
					x[j][k] += v[j][k]*dt;
				    if(x[j][k] < 0){ v[j][k] *= -1; x[j][k] = 0.001*j; }
				    if(x[j][k] > 1){ v[j][k] *= -1; x[j][k] = 1 - 0.001*j; }
				}
			}
		}
		
		// positionen in farben übersetzen
		Color[] result = new Color[i];
		for(int j = 0; j < i; j++){
			result[j] = new Color((float)x[j][0], (float)x[j][1], (float)x[j][2]);
		}
		return(result);
	}
	
	// kleines demo
	public static void main(String... _){
		
		class Animated extends JComponent implements ActionListener{
			private static final long serialVersionUID = 1L;
			private Timer timer = new Timer(1000, this);
			{
				timer.start();
			}
			private int t = 0;
			@Override
			public void paint(Graphics g){
				for(int c = 0; c < 64; c ++ ){
					int r = 0;
					
					for(Color color: createColors(t, c*0.5)){
						g.setColor(color);
						g.fillRect((512/t)*r, c*8, (512/t), 8);
						r += 1;
					}
				}
				t = (t + 1)%32;
			}	
			public void actionPerformed(ActionEvent e){ repaint(); }
		}
		
		JFrame f = new JFrame("colors");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new Animated()); 
		f.setSize(new Dimension(512, 512));
		f.setVisible(true);
	}
}
```


----------



## ottens (28. Aug 2011)

danke 0x7F800000 für die Antwort 

ich brauche folgends, wenn man Farben mit Random erstellt und damit Kurven zeichnet, dass die 
Kurven mit verschiedenen Farben gezeichnet werden, dass man die Kurven ganz leicht mit den Augen auseinander halten kann und nicht zwei oder mehr gleich oder ähnliche Farben kommen gelichzeitig in 
der Zeichnung vor ???

danke für die Antwort werde dein Code testen 

LG

Ottens


----------



## bERt0r (28. Aug 2011)

Also ich weis ja nicht, wenn in deinem Farbpool schon 50 Farben drin sind, wirds ein bisschen knapp mit neuen Farben, die sich deutlich von den bisherigen unterscheiden... Hast du wirklich so viele verschieden Farben nötig?


----------



## Marco13 (29. Aug 2011)

Ohne die bisherigen Bemühungen zuuu sehr torpedieren zu wollen: Auf Basis von RGB ist das ganze noch schwieriger als ohnehin schon. Zwei Farben wie (0,20,0) und (0,0,20) kann man kaum noch sinnvoll unterscheiden. 
#001400 html color code
#000014 html color code

Abgesehen davon, dass man als Mensch (sofern man nicht Farbenblind ist, was verbreiteter ist, als man vielleicht denkt) sehr viel empfindlicher für Grüntöne ist - also, man tendiert stärker dazu, eine Farbe als "Grün(lich)" zu bezeichnen als z.B. "Rot". Eigentlich müßte man das berücksichtigen. 

Darüber hinaus... man liest manchmal Zahlen, wie viele Farben ein Mensch unterscheiden kann. "Och, etliche Millionen ". Das bringt aber nichts. Erstaunlicherweise gibt es nur eine handvoll (bzw. irgendwas um die 10) Farben, die unabhängig vom Kulturkreis als getrennte Farben (mit unterschiedlichen Namen) erkannt werden (und das, was wir als "Grün" und "Blau" unterscheiden, muss da nicht dazugehören). 

Wie viele Farben man sinnvoll für eine Visualisierung einsetzen kann? Das liegt wohl irgendwo dazwischen, und hängt von dem ab, was dargestellt werden soll. Für Kurvenverläufe wird schon die Frage der zu erwartenden _Stetigkeit_ der Kurven wichtig sein. Alles in allem kann man aber sagen, dass tendenziell bei mehr als 10 Farben das Ergebnis nur noch als "bunter Matsch" angesehen wird.

WENN man schon unterschiedliche Farben braucht, man sich überlegen sollte, ob man da im HSB-Modell nicht sinnvoller rumrechnen kann. Ansonsten sollte man vielleicht noch andere Visuelle Attribute (Liniendicke, Linienstil) in Erwägung ziehen.

Noch ein kleiner Link:
Color Survey Results  xkcd


----------



## ottens (29. Aug 2011)

danke für alle die auf meine Fragen geantwortet haben und bin immer dankbar für 
neue Ideen oder Vorschlägen

wegen den Farben habe ja echt brauche ich menge und sollen die Farben, die mit Random erstellt werden sich optisch von allen Farben, die sich im Pool befinden, unterscheiden.

LG

Ottens


----------



## Andi_CH (29. Aug 2011)

Wenn du es schaffst "optisch unterscheiden" algorithmisch zu formulieren kann man es auch programmieren, aber das ist gar nicht so einfach.
Ich weiss nur, dass das im letzten Projekt (es wurden da diverse Zusatzinformationene auf geographischen Karten eingeblendet) aufgegeben wurde und die Farben nach wie vor manuell optmiert werden.


----------



## Marco13 (29. Aug 2011)

Rein formal ist es einfach: Man bestimmt ein Distanzmaß zwischen Farben, und jedes mal, wenn eine neue Farbe gebraucht wird, wählt man die, die zu allen schon bestehenden den größten Abstand hat. Aber irgendwie kam vom OT zu wenig zurück, als dass ich mich da jetzt nochmal öffentlich dahinterklemmen würde. Vielleicht selbst, aus Neugier, aber das ist ja unabhängig von diesem Thread hier.


----------



## Andi_CH (29. Aug 2011)

Leider ein häufiges Verhalten, wenn die TOs gar nicht so genau wissen worauf sie sich einlassen ;-)

Wir haben Linien über die ganze Karte bzw. den ganzen Monitor hinweg gezeichnet - bestimme nur schon mal alle Farben die geschnitten werden - wie lang ist die Strecke der einzelnen Farbe ist (bei kurzen Stücken ist es egal wenn man die Linie nicht sieht -> zoomabhängigkeit) und finde dann die Beste Farbe 

Resultat: Die Farbe einer Linie ist nicht über die ganze Länge konstant, aber von Anfang bis Ende 
"ähnlich" und ändert die des "Ähnlichkeitsbereiches" zoomabhängig - eingestellt sind feste Werte zwischen denen interpoliert wird


----------



## Landei (29. Aug 2011)

Ich hatte mal eine Klasse für die Netscape-Farbnamen geschrieben. Die unterscheiden sich eigentlich ganz gut voneinander, da sie ja den "üblichen" Farbbereich für Webseiten abdecken sollten (eventuell sollte man die sehr hellen und sehr dunklen rauswerfen).


```
import java.awt.Color;

public enum NetscapeColor {

    aliceblue(0xF0F8FF),
    antiquewhite(0xFAEBD7),
    aqua(0x00FFFF),
    aquamarine(0x7FFFD4),
    azure(0xF0FFFF),
    beige(0xF5F5DC),
    bisque(0xFFE4C4),
    black(0x000000),
    blanchedalmond(0xFFEBCD),
    blue(0x0000FF),
    blueviolet(0x8A2BE2),
    brown(0xA52A2A),
    burlywood(0xDEB887),
    cadetblue(0x5F9EA0),
    chartreuse(0x7FFF00),
    chocolate(0xD2691E),
    coral(0xFF7F50),
    cornflowerblue(0x6495ED),
    cornsilk(0xFFF8DC),
    crimson(0xDC143C),
    cyan(0x00FFFF),
    darkblue(0x00008B),
    darkcyan(0x008B8B),
    darkgoldenrod(0xB8860B),
    darkgray(0xA9A9A9),
    darkgreen(0x006400),
    darkkhaki(0xBDB76B),
    darkmagenta(0x8B008B),
    darkolivegreen(0x556B2F),
    darkorange(0xFF8C00),
    darkorchid(0x9932CC),
    darkred(0x8B0000),
    darksalmon(0xE9967A),
    darkseagreen(0x8FBC8F),
    darkslateblue(0x483D8B),
    darkslategray(0x2F4F4F),
    darkturquoise(0x00CED1),
    darkviolet(0x9400D3),
    deeppink(0xFF1493),
    deepskyblue(0x00BFFF),
    dimgray(0x696969),
    dodgerblue(0x1E90FF),
    firebrick(0xB22222),
    floralwhite(0xFFFAF0),
    forestgreen(0x228B22),
    fuchsia(0xFF00FF),
    gainsboro(0xDCDCDC),
    ghostwhite(0xF8F8FF),
    gold(0xFFD700),
    goldenrod(0xDAA520),
    gray(0x808080),
    green(0x008000),
    greenyellow(0xADFF2F),
    honeydew(0xF0FFF0),
    hotpink(0xFF69B4),
    indianred(0xCD5C5C),
    indigo(0x4B0082),
    ivory(0xFFFFF0),
    khaki(0xF0E68C),
    lavender(0xE6E6FA),
    lavenderblush(0xFFF0F5),
    lawngreen(0x7CFC00),
    lemonchiffon(0xFFFACD),
    lightblue(0xADD8E6),
    lightcoral(0xF08080),
    lightcyan(0xE0FFFF),
    lightgoldenrodyellow(0xFAFAD2),
    lightgreen(0x90EE90),
    lightgrey(0xD3D3D3),
    lightpink(0xFFB6C1),
    lightsalmon(0xFFA07A),
    lightseagreen(0x20B2AA),
    lightskyblue(0x87CEFA),
    lightslategray(0x778899),
    lightsteelblue(0xB0C4DE),
    lightyellow(0xFFFFE0),
    lime(0x00FF00),
    limegreen(0x32CD32),
    linen(0xFAF0E6),
    magenta(0xFF00FF),
    maroon(0x800000),
    mediumaquamarine(0x66CDAA),
    mediumblue(0x0000CD),
    mediumorchid(0xBA55D3),
    mediumpurple(0x9370DB),
    mediumseagreen(0x3CB371),
    mediumslateblue(0x7B68EE),
    mediumspringgreen(0x00FA9A),
    mediumturquoise(0x48D1CC),
    mediumvioletred(0xC71585),
    midnightblue(0x191970),
    mintcream(0xF5FFFA),
    mistyrose(0xFFE4E1),
    moccasin(0xFFE4B5),
    navajowhite(0xFFDEAD),
    navy(0x000080),
    oldlace(0xFDF5E6),
    olive(0x808000),
    olivedrab(0x6B8E23),
    orange(0xFFA500),
    orangered(0xFF4500),
    orchid(0xDA70D6),
    palegoldenrod(0xEEE8AA),
    palegreen(0x98FB98),
    paleturquoise(0xAFEEEE),
    palevioletred(0xDB7093),
    papayawhip(0xFFEFD5),
    peachpuff(0xFFDAB9),
    peru(0xCD853F),
    pink(0xFFC0CB),
    plum(0xDDA0DD),
    powderblue(0xB0E0E6),
    purple(0x800080),
    red(0xFF0000),
    rosybrown(0xBC8F8F),
    royalblue(0x4169E1),
    saddlebrown(0x8B4513),
    salmon(0xFA8072),
    sandybrown(0xF4A460),
    seagreen(0x2E8B57),
    seashell(0xFFF5EE),
    sienna(0xA0522D),
    silver(0xC0C0C0),
    skyblue(0x87CEEB),
    slateblue(0x6A5ACD),
    slategray(0x708090),
    snow(0xFFFAFA),
    springgreen(0x00FF7F),
    steelblue(0x4682B4),
    tan(0xD2B48C),
    teal(0x008080),
    thistle(0xD8BFD8),
    tomato(0xFF6347),
    turquoise(0x40E0D0),
    violet(0xEE82EE),
    wheat(0xF5DEB3),
    white(0xFFFFFF),
    whitesmoke(0xF5F5F5),
    yellow(0xFFFF00),
    yellowgreen(0x9ACD32);

    private int code;

    NetscapeColor(int code) {
        this.code = code;
    }

    public Color get() {
        return new Color(code);
    }

    public int getCode() {
        return code;
    }

}
```

Kleiner Test:


```
import java.awt.Color;
import java.awt.GridLayout;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;

public class NetscapeColorTest {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Netscape Colors");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel = new JPanel(new GridLayout(NetscapeColor.values().length,1));
        for(NetscapeColor color : NetscapeColor.values()) {
           JLabel label = new JLabel(color.toString() + " - #" + Integer.toHexString(color.getCode()));
           Color c = color.get();
           label.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
           label.setOpaque(true);
           label.setBackground(c);
           label.setForeground(c.getRed() + c.getGreen() + c.getBlue() > 300
                   ? Color.black : Color.white);
           panel.add(label);
        }
        frame.getContentPane().add(new JScrollPane(panel));
        frame.setSize(300,500);
        frame.setLocation(50,50);
        frame.setVisible(true);
    }
}
```


----------



## ottens (30. Aug 2011)

Hallo an alle,

also es geht, aber weiß jemand wie ich die farben so verschieden mit Random erstellen kann  ??

hat jemnd eine Idee ?

Danke


----------



## 0x7F800000 (30. Aug 2011)

ottens hat gesagt.:


> also es geht


Was geht? (Das ist eine Frage, keine Begrüßung)



> aber weiß jemand wie ich die farben so verschieden mit Random erstellen kann  ??
> hat jemnd eine Idee ?


Wir haben hier schon Dutzend verschiedener Ansätze gepostet, deine Rückmeldungen lassen aber irgendwie nicht darauf schließen, dass du dich mit diesen Vorschlägen auseinandergesetzt hättest. Sag konkret was du willst, was dir an den anderen Vorschlägen nicht gefällt, definiere exakt was *"so verschieden"* zu bedeuten hat. Eine auf das Menschliche Auge zugeschnittene Metrisierung der Farbräume ist offenbar nicht trivial. Einfach nur mit "es geht" kommt man hier nicht voran.


----------



## Landei (30. Aug 2011)

Wenn du von einer vorgegebenen Liste von Farben ausgehst, pack sie in eine Liste, und lasse selbige mit [c]java.util.Collections.shuffle()[/c] durchmischen.


----------

