# Lichtspektrum dezimal nach RGB



## Frunobulax (10. Feb 2009)

Hallo, das hat zwar nichts mit Java direkt zu tun aber mit Grafik.
Ich würde gerne Dezimalzahlen in RGB Werte umwandeln.
So nach dem vertrauten Schema Rot>Gelb>Grün>Türkis>Blau und dann vielleicht noch Lila.
Linear und fließend.
Suchmaschinen haben bisher noch nicht viel gebracht. Ich finde z.B. für "dezimal nach RGB stetig" eher
RGB nach grau. 
So gestelzte Eigenkonstruktionen wie von a bis b eher Rot , aber zunehmend mehr Grün
und noch kein Blau. Von b bis c ... gefallen mir nicht. Eine detaillierte Beschreibung des dreidimensionalen
RGB Raumes bringt auch nicht so viel. Am liebsten wäre mir eine Funktion, eine Matrix, eine Klasse, eine 
Interpretation. Das leuchtet eher ein. Freue mich wenn sich hier schon mal jemand Gedanken darüber
gemacht hat und mir was vorschlägt.

Thomas


----------



## Ebenius (10. Feb 2009)

Ich bin mir nicht sicher was Du machen möchtest. Willst Du ein Diagramm einfärben, oder willst Du zwischen Farbräumen hin- und herrechnen? Hilft Dir vielleicht ein Hinweis auf die ColorSpace-Klasse schon weiter?

Ebenius


----------



## hdi (10. Feb 2009)

> Ich würde gerne Dezimalzahlen in RGB Werte umwandeln.



Du willst_ eine_ Dezimalzahl in einen RGB Wert umwandeln? Wieso? 
Das ist als ob du Strings in longs umwandeln willst. Natürlich kannst du dir irgendein
Mapping überlegen, aber was soll das?

Was hast du damit vor? Ein RGB Wert besteht aus 3 Zahlen zwischen je 0 und 255,
wenn du von rot nach grün übergehen willst, musst du nur zwei Dinge wissen:

Rot = 255 0 0
Grün = 0 255 0

Jetzt machst du dir einen Algorithmus flowingColorChange(Color start, Color end),
und da drin näherst du alle 3 Zahlen von start nach end an.
In diesem Fall würde sich der Blau-Ton nicht ändern, allerdings würde zB alle 5 ms
der rotwert um eins sinken, und der grünwert um eins steigen.

Zwischenzeitlich landest du bei

127 127 0 = irgendeine hässliche Art von gelb

Und wenn dir das halt einfach farblich nicht gefällt, näherst du den blauwert zur Hälfte an und zurück:

255 0 0 -> 125 125 125  -> 0 255 0 // wobei grau auch nicht so geil ist 

Ich meine da gibt es doch keinen ultimativen Algorithmus, der _den_ Farbübergang beschreibt?
Oder irre ich mich? Man kann sich sicher ausrechnen wieviele verschiedene Varianten eines Übergangs es gibt,
aber wie genau du es dann machst, das musst du einfach festlegen. Programmier es halt so, wie es dir gefällt..

Man muss sich immer ein Kriterium überlegen, das ist nicht gottgegeben. Du fragst dich ja immer: 
Wie ist es am schnellsten? Wie am erfolgreichsten? Wie am kürzesten? In diesem Fall halt: Wie am schönsten?


----------



## Ebenius (10. Feb 2009)

hdi hat gesagt.:
			
		

> Du willst_ eine_ Dezimalzahl in einen RGB Wert umwandeln? Wieso? Das ist als ob du Strings in longs umwandeln willst.


So unsinnig ist das gar nicht. Eher sogar ziemlich gewöhnlich: 
	
	
	
	





```
final int WHITE = 0xffffff; // quite usual RGB representation
```
Lässt sich dann auch super damit zur Farbe machen: 
	
	
	
	





```
new Color(WHITE);
```
Siehe auch: Color.Color(int).

Allerdings bleibt die Frage bestehen, was der ThreadOpener eigentlich möchte.

Ebenius


----------



## hdi (10. Feb 2009)

Ja bei Hexa ist das was anderes, weil es dafür eine festgelegte Definition gibt, bzw. das ist so üblich.
Die besteht auch nur aus 3 Blöcken die die Farbkanäle beschreiben.
Aber eine Dezimalzahl? Klar er kann von Hex nach Dez wandeln. Aber wie du ja auch schon sagst:
Why  ???:L


----------



## Gast (10. Feb 2009)

http://www.fourmilab.ch/documents/specrend/


----------



## Frunobulax (10. Feb 2009)

Also zunächst mal Ebenius, der noch falsche Quelltext steht unter :
http://www.java-forum.org/de/topic82431_bildausschnitt-markieren-auch-einfach.html  unten.
Den jetzigen stell ich da hin wenn er aufgeräumt ist.
Da habe ich von einer HTML Farbskala Seite einfach 143 Farbwerte abkopiert, die dem Spektrum von einem Prisma 
irgendwie nahekommen. Das sind aber nur 143 Werte und ich hab z.Zt. 1300 Iterationen, wo irgendwo die
divergenz starten kann.
Danke für deine Hilfe, das Repaint() Problem ist hinreichend gelöst.



> Why?



Das Ergebnis steht unter http://www.emotiongenerator.com/neogrid
Jetzt möchte ich die Mandelbrotmenge schön harmonisch einfärben.

ZB bei 0 iterationen schwarz
bei 1 bis 143 iterationen dunkelviolett ubergehend in helleres blau über violett und blau
von 143 bis 287 iteationen helleres blau über türkis bis irgendein grün
so etwa bei 514 hässliches gelb (es muß ja nicht ganz liear sein, schadet aber nichts)
usw.
So zusammensetzen kann ich das selber. Aber es gibt vielleicht 'ne Interpolation dafür
die in 3 Zeilen da steht und recht genau das Spektrum von einem Regenbogen trifft, 
wenn ich ihn überquere. Details kann ich dann ja noch variieren, jenachdem wie
es den Testbenutzern am besten gefällt.



> Wie ist es am schnellsten? Wie am erfolgreichsten? Wie am kürzesten?



Das wäre dann schnell und schön.

Sicher gibt es bessere Abbildungen aus einem Dreidimensionalen Raum in einen
Eindimensionalen als umgekehrt. Die gesuchte Abbildung wäre dann auch nicht die einzige.
Es gibt eine ganze Palette von Abbildungen, die ähnliches auf unterschiedliche Weise machen.
Ich brauche erst mal eine. Schadet auch nichts wenn so ein Vorschlag im Net steht.

Schaue mir jetzt http://www.fourmilab.ch/documents/specrend/ an


----------



## 0x7F800000 (10. Feb 2009)

wozu willst du denn diesen Physikalisch korrekten Regenbogen da?
Geht's dir nicht darum, die Mandelbrotmenge schön anzumalen?
Dann ist regenbogen nämlich imho eine recht gruselige Farbenkombination, die sehr schnell langweilig wird.



















Diejenigen Farbkombinationen, die hübsch aussehen, bestehen meiner meinung nach aus konstrastreichen dunklen und hellen farben, die sich abwechseln. Und normalerweise braucht man keine 7 verschiedene reine farbtöne, sondern höchstens 3-4 ansonsten wird's zu bunt.

Bei allen beispielen wurde stinknormale lineare Interpolation mit 6-10 "Stützfarben" verwendet.
Farbwahl sollte man bei dieser Sache flexibel gestalten, das kostet nichts und verzehnfacht den Spaß auf einen Schlag.


----------



## Frunobulax (10. Feb 2009)

Ja, ist mir klar. Bizarre Farben können auch viel speed haben. Guter Tipp.Wollte halt mal was normales "Regenbogen" ausprobieren.
Ich hab auch gerade mit "Regenbogen" was gefunden:
http://www.java2s.com/Code/Java/2D-Graphics-GUI/RainbowColor.htm
Ich muß nur im Kreis oder Viereck darin herumfahren. Dann hab ich es.
"Mandelbrotmenge" gibt auch ganz interessante Fraktale bei z=z^2-c wenn man z für den Ort nimmt und nicht c .Und für c eine konstante 
einsetzt, zb cx=0.4  cy= -0.3 . Hab noch nicht weiter experimentiert, Das nur so nebenbei. Sieht so aus (Könnte es Italia-Fraktal nennen):


----------



## OliverKroll (11. Feb 2009)

Auf
http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Color.html#RGBtoHSB(int,%20int,%20int,%20float[])
gibt es eine Methode 
HSBtoRGB, 
die das gewünschte Ergebnis liefern sollte.


----------



## Frunobulax (5. Mrz 2009)

Hallo,

hab blue auf 128 gesetzt, dass das 2 dimensional geht ist nicht gleich einleuchtend. danke für eure "Hospitality"
das Ergebnis (Hab die Julia Menge entdeckt ; )steht in Regenbogenfarben unter:
Applet HTML Page
Es ist nicht Speicherfressend, trotz dem *=getgraphics, der Quelltext hier:

[HIGHLIGHT="Java"]package javaapplication43;

/**
 *
 * @author thomas
 */

import java.awt.*;
import java.awt.Color;
import java.awt.event.*;
import java.applet.*;


public class Grafik09 extends Applet implements
MouseListener, MouseMotionListener {


int mouseX1 = 0, mouseY1 = 0,mouseX2 = 0, mouseY2 = 0;
int mouseX1o=0,mouseY1o=0,mouseX2o=0,mouseY2o=0;
int clicko=0,click=0,click2=0,normal=2,ex=1,abso=0,pressed=2,release=0;
double pattern=250,paramx=(double)1.2,paramy=(double)1.2;
Graphics g;
int red=0,green=0,blue=0; Color Co;


  // die Methode wird beim Start des Applets aufgerufen

  public void init() {

   resize(600, 600);

    addMouseListener(this);

    addMouseMotionListener(this);
 }


  public void paint(Graphics g) {
    int zb1;
    double x,y,xx,yy,zz,zx,zy,zxx,zyy,z,zb;





/*    String[] dataf = {
"000000",
"000080",
"00008B",
"0000CD",
"0000FF",
"006400",
"008000",
"008080",
"008B8B",
"00BFFF",
"00CED1",
"00FA9A",
"00FF00",
"00FF7F",
"00FFFF",
"00FFFF",
"191970",
"1E90FF",
"20B2AA",
"228B22",
"2E8B57",
"2F4F4F",
"32CD32",
"3CB371",
"40E0D0",
"4169E1",
"4682B4",
"483D8B",
"48D1CC",
"4B0082",
"556B2F",
"5F9EA0",
"6495ED",
"66CDAA",
"696969",
"6A5ACD",
"6B8E23",
"708090",
"778899",
"7B68EE",
"7CFC00",
"7FFF00",
"7FFFD4",
"800000",
"800080",
"808000",
"808080",
"87CEEB",
"87CEFA",
"8A2BE2",
"8B0000",
"8B008B",
"8B4513",
"8FBC8F",
"90EE90",
"9370D8",
"9400D3",
"98FB98",
"9932CC",
"9ACD32",
"A0522D",
"A52A2A",
"A9A9A9",
"ADD8E6",
"ADFF2F",
"AFEEEE",
"B0C4DE",
"B0E0E6",
"B22222",
"B8860B",
"BA55D3",
"BC8F8F",
"BDB76B",
"C0C0C0",
"C71585",
"CD5C5C",
"CD853F",
"D2691E",
"D2B48C",
"D3D3D3",
"D87093",
"D8BFD8",
"DA70D6",
"DAA520",
"DC143C",
"DCDCDC",
"DDA0DD",
"DEB887",
"E0FFFF",
"E6E6FA",
"E9967A",
"EE82EE",
"EEE8AA",
"F08080",
"F0E68C",
"F0F8FF",
"F0FFF0",
"F0FFFF",
"F4A460",
"F5DEB3",
"F5F5DC",
"F5F5F5",
"F5FFFA",
"F8F8FF",
"FA8072",
"FAEBD7",
"FAF0E6",
"FAFAD2",
"FDF5E6",
"FF0000",
"FF00FF",
"FF00FF",
"FF1493",
"FF4500",
"FF6347",
"FF69B4",
"FF7F50",
"FF8C00",
"FFA07A",
"FFA500",
"FFB6C1",
"FFC0CB",
"FFD700",
"FFDAB9",
"FFDEAD",
"FFE4B5",
"FFE4C4",
"FFE4E1",
"FFEBCD",
"FFEFD5",
"FFF0F5",
"FFF5EE",
"FFF8DC",
"FFFACD",
"FFFAF0",
"FFFAFA",
"FFFF00",
"FFFFE0",
"FFFFF0",
"FFFFFF"
  };*/


if(normal==2){

    for(x=0;x<601;x++){
        xx=x/pattern- paramx;
        for(y=0;y<601;y++){
        yy=   y / pattern - paramy;
        z=0;zz=0;
        zx=xx;zy=yy;
        while(zz<4 && z<1021){

        zxx=      (zx * zx) - (zy * zy) +0.272;//+0.4,
        zyy=      (2* zx * zy) + -0.479;//-0.3

        zz=zxx*zxx+zyy*zyy;
        z++;
        zx=zxx;zy=zyy;
        }
        zb=z;
        zb1=(int) zb;
p3(zb1);
    //g.setColor(new Color(Integer.parseInt(dataf[zb1], 16)));
g.setColor(new Color(red,green,blue));
        g.drawLine((int)x, (int)y, (int)x, (int)y);
        }

        clicko=0;click=0;click2=0;normal=2;abso=0;pressed=2;

        }
}else {paint2(g);}
    normal=2;

  }

public void paint2(Graphics g) {
g.setXORMode(Color.white);



if(clicko==2)
{
    g.drawLine(mouseX1o,mouseY1o,mouseX2o,mouseY1o);
    g.drawLine(mouseX2o,mouseY1o,mouseX2o,mouseY2o);
    g.drawLine(mouseX2o,mouseY2o,mouseX1o,mouseY2o);
    g.drawLine(mouseX1o,mouseY2o,mouseX1o,mouseY1o);

}

if(click2!=2){
    g.drawLine(mouseX1,mouseY1,mouseX2,mouseY1);
    g.drawLine(mouseX2,mouseY1,mouseX2,mouseY2);
    g.drawLine(mouseX2,mouseY2,mouseX1,mouseY2);
    g.drawLine(mouseX1,mouseY2,mouseX1,mouseY1);

}


mouseX1o=mouseX1;
mouseX2o=mouseX2;
mouseY1o=mouseY1;
mouseY2o=mouseY2;
clicko=click;
click2=0;pressed=2;



}

public void p3(int ganzz)
{
if(ganzz<20)
{
red=255;
green=255;
blue=255;
}
if(ganzz<256 && ganzz>=20)
{
red=ganzz;
green=0;
blue=128;
}
if(ganzz>=256 && ganzz<512)
{
red=255;
green=ganzz-256;
blue=128;
}
if(ganzz>=512 && ganzz<768)
{
red=767-ganzz;
green=255;
blue=128;
}
if(ganzz>=768 && ganzz<1022)
{
red=0;
green=1023-ganzz;
blue=128;
}

}


public void mouseClicked(MouseEvent me)

    {



    }



    public void mouseEntered(MouseEvent me)

   {

   click=0;ex=1;pressed=2;


    }



    public void mouseExited(MouseEvent me)

   {
  pressed=2;
  g=getGraphics(); 
   normal=1;
   click=0;
   clicko=2;
   click2=2;
   ex=2;
   paint(g);

    }



    public void mousePressed(MouseEvent me)

   {

pressed=5;

       mouseX1 = me.getX();

    mouseY1 = me.getY();

    click = 2;



    }



    public void mouseReleased(MouseEvent me)

{


        abso=(mouseX2-mouseX1)*(mouseY2-mouseY1);
 abso=java.lang.Math.abs(abso);


        if(ex!=2 && abso>10 && pressed==2){
normal=1;
g=getGraphics();
clicko=2;
click2=2;
paint(g);


double newPosX=0,newPosY=0,newDX;
int temp;
if(mouseX1>mouseX2){temp=mouseX1;mouseX1=mouseX2;mouseX2=temp;}
if(mouseY1>mouseY2){temp=mouseY1;mouseY1=mouseY2;mouseY2=temp;}

newPosX=-((double)mouseX1/pattern-paramx);
newPosY=-((double)mouseY1/pattern-paramy);
newDX=(double)mouseX2-(double)mouseX1;
newDX=java.lang.Math.abs(newDX)/pattern;
paramx=newPosX;
paramy=newPosY;
pattern=600/newDX;
mouseX1=0;
mouseY1=0;
mouseX2=0;
mouseY2=0;
mouseX1o=0;
mouseY1o=0;
mouseX2o=0;
mouseY2o=0;


 showStatus("Ex " + ex+ ", Pressed" + pressed+" Release " +release+"abso"+abso); 

release++;
repaint();}ex=1;


    }



    public void mouseDragged(MouseEvent me)

        {
        pressed=2;
   g=getGraphics();
   normal=1;
    if(click==2){
    mouseX2 = me.getX();
    mouseY2 = me.getY();
   paint(g);


    }

    }



    public void mouseMoved(MouseEvent me) {

pressed=2;

    }

}[/HIGHLIGHT]

Da meine "Neuentdeckung", Juliamenge aus der Maldelbrotmenge aber ein alter Hut ist,
hab ich neue Fraktalideen. Wenn irgendeine klappt poste ich sie hier.


----------

