Прокрутка всех цветовых комбинаций на вертикальном столбце пикселей

Question

Я пытаюсь прокрутить каждую комбинацию цветов RGB на вертикальном наборе пикселей. В этом примере предположим, что столбец пикселей равен 1080. Я понимаю, что все возможные комбинации составляют примерно 18 миллиардов при этом числе. Кажется, я не могу обернуть голову вокруг структуры цикла. У меня есть цикл для вычисления всех цветовых комбинаций для одного пикселя.

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)+";"; 
     } 
    } 
} 

Теперь мне нужно что-то, что может применить цвет пикселя к столбцу. Я просто не знаю, как выработать логику этого, потому что я должен применять цвет во всех возможных комбинациях. Таким образом, вертикальная полоска белого цвета с вертикальной полосой черного цвета не является моей целью. Скорее спорадический перекос пикселей во всех возможных комбинациях.

Answer 1

То, что вы пытаетесь выполнить, слишком сложно и громоздко для петель.

В принципе, вы пытаетесь подсчитать в базе 256^3 = 16,777,216. И при высоте колонки 1080 количество комбинаций астрономическое!

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

Позвольте мне объяснить упрощенным примером. Вместо высоты столбца 1080, скажем, это высота 4. И вместо 16,777,216 различных цветовых комбинаций для каждого пикселя, скажем, у нас есть только 10 различных цветовых комбинаций.

Кроме того, вместо значений цвета, состоящих из RGB, скажем, каждый цвет может иметь значение от 0 до 9. В этом примере столбец (4 пикселя) может находиться в 10^4 = 10,000 разных состояниях.

Давайте посмотрим на это: подумайте о столбце, который находится на его стороне, поэтому он горизонтален и давайте рассмотрим его, как будто это один из тех комбинационных замков с наборами, которые могут вращаться от 0 до 9.

Это было бы начальное состояние (Все 4 циферблатов/пиксели на цвете = 0):

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

Это было бы конечное состояние (Все 4 циферблатов/пиксели на цвете = 9):

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

в вашем случае, вы бы кодовый замок, который имеет 1080 циферблатов и каждый диск может вращаться от 0-16,777,215

Теперь, я был заинтересован в том, как я могу упростить код так, что у вас нет га ve 1080 для циклов или n для циклов в общем случае, где n - высота столбца.

Вот что я придумал:

// 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; 
     } 
    }   
} 

Примечание: Этот алгоритм увеличивает значения слева направо. Я понял, что это имело смысл приспособить его к реальной проблеме с колонкой в ​​графике, так как вы начнете менять цвета сверху вниз и снизу вверх. Если вы хотите, чтобы цвета начали меняться снизу вверх, тогда его можно легко адаптировать, изменив индексы, приращения до декрементов и т. Д.

Теперь этот пример предназначен для простых целых значений и внутренних массивов. Как мы можем адаптировать его к вашей проблеме с цветами?

Во-первых, давайте предположим, что срез столбец представляет собой массив java.awt.Color

То есть, int [] arr = new int [4]; становится Color [] arr = new Color [4];

Далее, вместо того, чтобы int base = 10; // (0-9) мы имели бы int base = 16777216; // (0-16,777,215)

Теперь, остальная часть код почти такой же, за исключением того, что мы должны адаптировать несколько вещей:

Это:

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

должно стать следующее:

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

Это:

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

должно стать следующее:

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

Наконец, для этой части:

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

Мы можем просто сделать:

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

Кроме того, имейте в виду, что вам нужно будет инициализировать массив цвета. Это можно сделать так:

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

Надеюсь, это поможет. Удачи!