Scrollen durch alle Farbkombinationen auf einer vertikalen Spalte von Pixeln

Question

Ich versuche, durch jede einzelne mögliche RGB-Farbkombination auf einem vertikalen Satz von Pixeln zu scrollen. In diesem Beispiel wird angenommen, dass die Pixelspalte 1080 ist. Ich verstehe, dass alle möglichen Kombinationen bei dieser Zahl ungefähr 18 Milliarden betragen. Ich kann meinen Kopf nicht um die Schleifenstruktur wickeln. Ich habe hier die Möglichkeit, alle Farbkombinationen für ein Pixel zu berechnen.

for(int r = 0;r < 256;r++){ 
    for(int g = 0;g < 256;g++){ 
     for(int b = 0;b < 256;b++){ 
      pixelC = 
      Integer.toString(r)+":"+ 
      Integer.toString(g)+":"+ 
      Integer.toString(b)+";"; 
     } 
    } 
} 

Jetzt brauche ich etwas, das die Pixelfarbe auf die Säule angewendet werden können. Ich bin mir einfach nicht sicher, wie ich die Logik dafür ausarbeiten soll, weil ich die Farbe in allen möglichen Kombinationen anwenden muss. Es ist also nicht mein Ziel, einen vertikalen Streifen aus ganzem Weiß mit einem senkrechten schwarzen Streifen zu haben. Eher ein sporadisches Aufpäppeln von Pixeln in allen möglichen Kombinationen.

Answer 1

Was Sie versuchen zu erreichen, ist mit For-Schleifen zu schwierig und umständlich.

Grundsätzlich versuchen Sie, in Basis 256^3 = 16,777,216 zu zählen. Und mit einer Spaltenhöhe von 1080 ist die Anzahl der Kombinationen astronomisch!

(256^3)^1080 ≈ 4.983 × 10^7802 

Lassen Sie mich mit einem vereinfachten Beispiel erklären. Statt einer Spaltenhöhe von 1080 nehmen wir an, dass es eine Höhe von 4 hat. Und anstatt 16.777.216 verschiedene Farbkombinationen für jedes Pixel zu haben, sagen wir, dass wir nur 10 verschiedene Farbkombinationen haben.

Außerdem, anstelle von Farbwerten, die aus RGB bestehen, sagen wir, dass jede Farbe einen Wert von 0-9 haben kann. In diesem Beispiel kann die Spalte (von 4 Pixeln) in 10^4 = 10,000 verschiedenen Zuständen sein.

Lassen Sie uns dies visualisieren: Denken Sie daran, dass die Säule auf der Seite ist, so dass sie horizontal ist und behandeln Sie sie wie eines dieser Kombinationsschlösser mit Zifferblättern, die von 0-9 drehen können.

Diese den Anfangszustand (insgesamt 4 Zifferblätter/Pixel bei Farb = 0) sein würde:

------------------------- 
| 0 | 0 | 0 | 0 | 
------------------------- 

(Alle 4 Zifferblätter/Pixel bei Farb = 9) Dies wäre der Endzustand:

------------------------- 
| 9 | 9 | 9 | 9 | 
------------------------- 

in Ihrem Fall würden Sie eine Kombinationsschloss, die 1080 wählt und jedes Rad kann von 0-16,777,215

Jetzt spinnen hat, war ich daran interessiert, wie ich den Code vereinfachen können, so dass Sie nicht haben zu ha 1080 für Schleifen oder n für Schleifen im allgemeinen Fall, wo n die Höhe der Spalte ist.

Hier ist, was ich kam mit:

// This represents the combination lock with 4 dials 
int [] arr = new int [4]; 

// This represents how many states each dial can be in 
int base = 10; // (0-9) 

boolean done = false; 

while (!done) 
{ 
    // just for printing out the current state of the array 
    System.out.println(Arrays.toString(arr)); 

    int index = 0; 

    // get to the first dial that has not reached its max value 
    while (index < arr.length && arr[index] == base - 1) 
    { 
     index++; 
    } 

    // all dials are at the max value -> we are done 
    if (index == arr.length) 
    { 
     done = true; 
    } 
    else 
    { 
     // increase the first dial we found to not have a max value 
     arr[index]++; 

     // set all dials before it to 0 
     for (int i = 0; i < index; i++) 
     { 
      arr[i] = 0; 
     } 
    }   
} 

Hinweis: Dieser Algorithmus erhöht die Werte von links nach rechts. Ich fand, dass dies sinnvoll war, wenn man es an das tatsächliche Problem mit einer Spalte in einer Grafik anpasste, da man anfing, die Farben von oben nach unten und von unten nach oben zu ändern. Wenn Sie möchten, dass Farben sich von unten nach oben ändern, können Sie die Indizes, Inkremente, Dekremente usw. einfach anpassen.

Nun ist dieses Beispiel für einfache ganzzahlige Werte und int-Arrays. Wie können wir es an Ihr Problem mit Farben anpassen?

Zuerst nehmen wir an, dass die Spalte Scheibe ist ein Array von java.awt.Color

Das heißt, int [] arr = new int [4]; wird Color [] arr = new Color [4];

Als nächstes statt int base = 10; // (0-9) wir int base = 16777216; // (0-16,777,215)

Jetzt haben würde, den Rest der Code ist ziemlich genau das gleiche, außer wir müssen ein paar Dinge anpassen:

Dies ist:

while (index < arr.length && arr[index] == base - 1) 
{ 
    index++; 
} 

Needs dies werden:

while (index < arr.length && arr[index].equals(Color.WHITE)) 
{ 
    index++; 
} 

dieses:

// increase the first dial we found to not have a max value 
arr[index]++; 

Needs dies werden:

// increase the first color we found to not have a max value 
Color current = arr[index]; 
arr[index] = new Color(current.getRGB() + 1); 

Schließlich für diesen Teil:

// set all dials before it to 0 
for (int i = 0; i < index; i++) 
{ 
    arr[i] = 0; 
} 

Wir können einfach tun:

// set all colors before it to 0 
for (int i = 0; i < index; i++) 
{ 
    arr[i] = Color.BLACK; 
} 

Auch im Auge behalten, müssen Sie die Farb Array initialisieren. Dies kann so gemacht werden:

for (int i = 0; i < arr.length; i++) 
{ 
    arr[i] = Color.BLACK; 
} 

Ich hoffe, das hilft. Viel Glück!