Hur man gör ordentlig Rainbow och slumpmässiga färger med RGB-färgmodellen (4 / 5 steg)

Steg 4: Slumpmässiga färger

OK, rainbow gjort, låt oss göra några fina slumpmässiga färger. Vad kan vara enklare? Bara

byte r, g, b;
r = random(255);
g = random(255);
b = random(255);
setRGBpoint (LED, r, g, b);

kommer att göra, rätt? Jag antar att du redan se att detta kommer att resultera i okontrollerbar kraft fluktuationer. Vad är mer, det här mest ser ut som bara något tonade nyanser av vitt, som det fyller alla tre kanaler med några sopor (i HSV modell som kommer att vara i genomsnitt 50% mättnad – men vi vill ha 100%!).

Titta på detta:

r = random(256);
g = random(256-r);
b = (255-r-g);
setRGBpoint (LED, r, g, b);

Här finns inga problem med strömförbrukning, men du kan se att här särskild algoritmen gynnar den första kanalen (red): det blir 50% av slumpmässiga värden och den andra hälften delas mellan de två återstående ettor. Detta är inte så illa som det ser ut och du bör inte avfärda denna algoritm. Mänskliga ögat är inte så bra med blå och gröna färger (faktiskt, jag har läst någonstans att vi lärt oss att skilja de färgar inte så länge sedan, för gamla egyptierna var samma). Men vi är ganska OK med röda. Vi kan enkelt berätta apart scarlet, orange, ockra, gul och citron – dessa färger är mellan rött och grönt i RGB-modellen. Samma sak gäller för violett, lila, fuchsia, magenta, rose och rosa. Men kan du minnas samma mängd cyan toner? Emerald? ERR... himmelsblå?... Så, lite fusk med rött i din random algoritm kan vara helt ok om du vet vad du gör.

Låt oss prova en riktig random som inte gynnar någon enda färgkanal. För detta föredrar jag att använda en liten mängd byte och en räknare som har ökas varje gång funktionen körs:

byte färg [3].
antal byte, a0, a1, a2;
Color[Count]=random(256);
a0 = count + random (1) + 1;
Color[a0%3]=random(256-color[Count]);
färg [(a0+1) %3] = 255-färg [a0 %3]-färg [antal];
setRGBpoint (LED, färg [0], [1], color[2]);
räkna += random(15); att undvika att upprepa mönster
count % = 3;

Det är ok, men dessa tre randoms är inte mättad nog eftersom vi fyller tre kanaler med vissa värden. Om vi vill ha fina djupa färger ska vi fylla endast två av dem, lämnar den sista en nollpunkt. Denna algoritm kommer att producera sådana färger (i själva verket det helt motsvarar den "power-medvetna" HSV modellen ger oss tydliga nyanser på 100% mättnad):

Color[Count]=random(256);
a0=random(1);
a1 = ((!a0) + count + 1) %3;
a0 = (count + a0 + 1) %3;
färg [a0] = 255-färg [antal];
färg [a1] = 0;
setRGBpoint (LED, färg [0], [1], color[2]);
räkna += random(15); att undvika att upprepa mönster
count % = 3;

Vad sägs om sinus-våg uppslagstabellen vi gjorde tidigare? Det kan också användas, och det ger ännu djupare och klarare färger, skiftat lite mer mot bas röd, grön och blå:

a0=random(240);
färg [antal] = ljus [a0];
a1=random(1);
a2 = ((!a1) + count + 1) %3;
a1 = (count + a1 + 1) %3;
färg [a1] = ljus [(a0+100) % 240];
färg [a2] = 0;
setRGBpoint (4, färg [0], färg [1], color[2]);
greve ++;
count % = 3;

Dessa är bara några exempel, testa dem ut för att hitta vilket som passar dig bäst. Det finns massor av sätt att göra slumpmässiga färger, och det är en bra idé att blanda dem för bättre resultat.