Algoritmo per modificare un colore per renderlo meno simile allo sfondo


23

Sto creando una demo di 20 palline che si rimbalzano a vicenda, con uno sfondo pieno di un colore a tinta unita. Il colore per ogni palla viene scelto casualmente con randint(0, 255)per ogni componente tupla R, G, B.

Il problema è che alcune palline finiscono con un colore molto simile allo sfondo, rendendole difficili da vedere. Vorrei evitarlo, sia ruotando un altro colore se quello scelto è troppo simile (entro una determinata soglia), sia spostandolo dal colore di sfondo.

Come calcolare un indice di somiglianza da utilizzare come soglia? O come trasformare un colore per renderlo, diciamo, meno blu-ish ?

Disclaimer ovvio: non so nulla della teoria dei colori, quindi non so se i concetti di cui sopra esistano!

Sto programmando in Python, ma sto cercando concetti e strategie, quindi lo pseudo-codice va bene (o solo la teoria).

MODIFICARE:

Per chiarire alcuni punti:

  • Ogni palla ha il suo colore casuale. Vorrei che rimanessero il più casuali possibile e che esplorassero il più possibile lo spazio colore (sia esso RGB o HSV, pygameaccetta entrambi i formati per definire il colore)

  • Vorrei solo evitare che ogni colore fosse "troppo vicino" allo sfondo. Il problema non riguarda solo la tonalità: sto perfettamente bene con una palla azzurra contro uno sfondo blu scuro (o un "blu pieno" contro un blu "bianco ish", ecc.)

  • Per ora, non mi interessa se una palla finisce con un colore simile (o addirittura identico) a un'altra palla. Evitare questo è un bonus, ma è un problema minore.

  • Il colore di sfondo è un colore RGB singolo e costante. Per ora sto usando il blu "base" (0, 0, 255), ma non mi accontento. Quindi considera lo sfondo di un colore arbitrario (con tonalità, luminosità, saturazione, ecc.).

EDIT2:

Versione TL, DR: basta dare un modo per creare X colori casuali in modo che nessuno "sfuma troppo" su uno sfondo di colore arbitrario (ma singolo e costante)



1
Perché non mettere semplicemente un contorno attorno ad ogni palla?
ashes999,

1
Quindi potrebbe esserci un problema nel rendere un colore di contorno distinto sia dal colore di sfondo che dalle sfere;)
Kromster dice che supporta Monica

1
@AlexM .: difficile credere che non ci sia una soluzione facile per "generare colori casuali evitando uno arbitrario"
MestreLion

1
@MestreLion usa solo il nero per il contorno e genera colori con un valore RGB minimo di 128. È così facile.
ashes999,

Risposte:


33

È possibile utilizzare il fatto che i colori compongono uno spazio colore (tridimensionale) e calcolino una distanza in questo spazio colore. È quindi necessario definire una metrica in questo spazio colore per trovare la distanza tra due colori.

Ad esempio, la distanza in uno spazio euclideo tra due punti x = (x1, x2, x3) e y = (y1, y2, y3) è data da d (x, y) = sqrt ((y1-x1) * (y1- x1) + (y2-x2) * (y2-x2) + (y3-x3) * (y3-x3)).

Ora puoi calcolare la distanza tra un colore di palline e il colore di sfondo e, se è troppo piccolo, creare un nuovo colore casuale e riprovare.

Scoprirai che né RGB né HSV sono buoni spazi colore per questo compito. L' articolo di Wikipedia sulla differenza di colore utilizza lo spazio colore L a b e fornisce diverse metriche possibili.

C'è anche una discussione su stackoverflow sull'argomento.


È un approccio molto carino, potrei farlo :) Grazie! Inoltre, ti preoccupi di elaborare un po 'su come trovare una soglia di "distanza minima" adeguata? Se RGB non è adeguato, come convertire in L a b? Non sto cercando metriche di percezione accurate, quindi qualsiasi impostazione predefinita "abbastanza buona" lo farà.
MestreLion,

1
Adoro questa risposta, ben ponderata, una buona spiegazione di come svolgere il compito fornendo le equazioni e i riferimenti necessari. Buona prima risposta
Tom 'Blue' Piddock,

1
Se stai cercando un'approssimazione "abbastanza buona" della percezione umana, potresti voler esaminare lo spazio colore YUV , che ha una conversione diretta da RGB.
trm,

5
Risparmia un po 'di tempo e non prendere la radice quadrata (costosa). Basta fare il valore minimo della distanza del colore che si confronta con il quadrato.
Chris Cudmore,

1
@MestreLion Lo spazio colore L a b * è stato inventato per essere percettivamente uniforme, il che significa che la distanza percepita tra due colori è uguale alla distanza effettiva nello spazio colore. Poiché i colori RGB dipendono dal dispositivo, non è possibile convertire direttamente tra Lab e RGB. Tuttavia, se si utilizza uno spazio colore RGB assoluto specifico, è possibile convertirli. Vedi questo articolo: en.wikipedia.org/wiki/SRGB_color_space e questo articolo: en.wikipedia.org/wiki/Lab_color_space
jwir3

8

La pagina degli standard di accessibilità del web delle Nazioni Unite ( http://www.un.org/webaccessibility/1_visual/13_colourcontrast.shtml ) indica uno standard per garantire un corretto contrasto del testo sui siti Web, tenendo presente che alcuni utenti sono daltonici. Questo potrebbe essere particolarmente importante per te poiché alcuni dei tuoi utenti potrebbero anche essere daltonici (sarebbe difficile distinguere una palla rossa da uno sfondo verde se hanno la stessa luminanza).

La pagina delle Nazioni Unite fa riferimento all'analizzatore del rapporto di contrasto del colore della luminosità Juicy Studios all'indirizzo ( http://juicystudio.com/services/luminositycontrastratio.php#specify ) che afferma che il testo sullo sfondo deve avere un rapporto di contrasto di 4,5: 1, ad eccezione di ciò che I credi di essere simile al tuo caso:

  • Testo grande: il testo e le immagini su larga scala del testo su larga scala hanno un rapporto di contrasto di almeno 3: 1

Che cos'è un rapporto di contrasto? Seguendo ulteriormente i collegamenti ipertestuali (è divertente!) Arriviamo a una pagina W3 che definisce il rapporto di contrasto come:

Contrast Ratio = (L1 + 0.05)/(L2 + 0.05)

Dove L1 e L2 sono le luminanze relative dei colori. L1 è il colore più luminoso, L2 è il colore meno luminoso. Ancora una volta, seguiamo il collegamento alla stessa pagina W3 che specifica:

L = 0.2126 * R + 0.7152 * G + 0.0722 * B where R, G and B are defined as:

if RsRGB <= 0.03928 then R = RsRGB/12.92 else R = ((RsRGB+0.055)/1.055) ^ 2.4
if GsRGB <= 0.03928 then G = GsRGB/12.92 else G = ((GsRGB+0.055)/1.055) ^ 2.4
if BsRGB <= 0.03928 then B = BsRGB/12.92 else B = ((BsRGB+0.055)/1.055) ^ 2.4
and RsRGB, GsRGB, and BsRGB are defined as:

RsRGB = R8bit/255
GsRGB = G8bit/255
BsRGB = B8bit/255

NOTA : il simbolo del cursore ^ sopra si riferisce all'esponenziazione (x²)

Abbiamo un framework abbastanza buono per un algoritmo di contrasto (che è daltonico!)

  • Determina i valori R, G, B per ciascun colore
  • Determina la luminanza per ogni colore
  • Se il rapporto di contrasto tra il colore più luminoso e il colore meno luminoso è inferiore a 3, ripetere il test!

2
Potrebbe voler notare che ^ dovrebbe essere esponenziale. Per noi pazzi utenti C-like significa xor (pensavo sinceramente che stavi provando a fare un'operazione bit a bit su valori in virgola mobile per un minuto).
Pharap,

È un approccio fantastico , mi piace! :)
MestreLion

E non preoccuparti ^, non penserei mai a un XOR bit a bit in questo contesto. (o in realtà. C'mon C phreaks, ^è il simbolo di fatto per l'espiazione in pseudo-codici (anche se pochissime lingue lo usano effettivamente ... in python è **)
MestreLion

1
Sto solo aggiustando errori di battitura. Inoltre, se una persona ha problemi con ^, è probabile che anche qualcun altro in futuro possa farlo. Non fa male essere specifici.
Giovanni

1
@John Nessun problema,. Non sono sicuro da dove provenga la confusione (cioè quale lingua ha usato ^ per quale scopo prima). So solo che ^ viene talvolta utilizzato per l'espiazione a causa della mia esperienza con VB (non conosco altre lingue che lo usano come esponenziale, ma probabilmente ce ne sono alcuni). Proprio come un avvertimento però, è il simbolo del cursore , non il simbolo della carota . Potrebbe voler cambiarlo prima che qualcuno faccia uno scherzo divino sulla programmazione con le verdure (in particolare uno che coinvolge radici quadrate).
Pharap,

2

L'uso di valori RGB generando un 0-255valore casuale per ciascun componente potrebbe non solo creare colori simili allo sfondo, ma anche ottenere colori molto simili per le sfere.

Probabilmente sceglierei un approccio meno casuale e creerei colori che sono invece garantiti diversi. È possibile creare un colore per ogni ~ 32 gradi nell'intervallo di tonalità e alternare la luminosità o la saturazione (utilizzare il modello di colore HSV anziché RGB).

Quindi qualcosa del genere:

numColors = 20;
stepSize = 360 / (numColors / 2 + 1); // hue step size
for(i = 0; i < numColors; i++){
    color = HSV(i / 2 * stepSize, 0.5 + (i % 2) * 0.5, 1.0) 
}

che creerà 20 colori, ben distribuiti. Questo presuppone che si sta utilizzando il calcolo integer, quindi i = 0e i = 1creerà lo stesso valore di tonalità.

Ovviamente questo non si ridimensiona troppo bene .. Se hai 100 valori di colore da creare, la spaziatura della tonalità potrebbe non essere sufficiente e finirai di nuovo con colori simili. In tal caso è anche possibile variare il Vvalore (luminosità).

Non so come sia il colore di sfondo, ma HSV semplifica anche il confronto dei colori (basta confrontare i 3 componenti e non dimenticare che HUE è circolare (0 == 360)).

AGGIORNARE:

Dal momento che non ho davvero risposto alla tua domanda, ma piuttosto fornito un altro approccio, ecco come potrebbe apparire un algoritmo per uno sfondo arbitrario e palline colorate completamente casuali (questo è un approccio a forza bruta ma dovrebbe funzionare bene per il tuo caso d'uso):

// background color, currently equals RGB(0, 0, 255)
bg = HSV(240, 1.0, 1.0)

// number of colors to create is equal to the amount of balls
numColors = balls.length

// set threshold to compare colors. you can tweak this to your liking
threshold = 0.15

for(i = 0; i < numColors; i++){
    do {
        // assuming rnd returns a random float 0-1 inclusive
        color = HSV(rnd() * 360, rnd(), rnd())
        // calculate delta values, normalize hue to 0-1
        dH = (180 - abs(abs(bg.h - color.h) - 180)) / 360
        dS = bg.s - color.s
        dV = bg.v - color.v
        // "distance" between bg and color
        difference = sqrt(dH * dH + dS * dS + dV * dV)
    } while(difference < threshold)

    ball[i].color = color
}

A proposito del tuo algoritmo, come tiene conto del colore di sfondo?
MestreLion,

Al momento non sta prendendo in considerazione il colore di sfondo ... è possibile modificarlo confrontando i colori generati (come descritto nell'ultimo paragrafo) e quindi creare un colore con un diverso V(poiché l'algoritmo corrente non lo altera).
Bummzack,

@MestreLion Aggiunto un aggiornamento con un algoritmo alternativo
bummzack

Fantastico, sembra una bella strategia. La forza bruta è OK, i colori vengono generati una sola volta durante l'inizializzazione, non all'interno del ciclo di gioco. Sembra che tu stia usando lo stesso approccio di René, con una semplice distanza euclidea in HSV, giusto? Qualche riferimento di una soglia adatta per HSV? H, S e V pesano allo stesso modo in distanza come in RGB?
MestreLion

@MestreLion Sì, il mio secondo algoritmo è praticamente quello che René ha spiegato nella sua risposta. Purtroppo non esiste un valore definitivo per una buona soglia poiché i cambiamenti di colore non sono percepiti in modo uniforme. Riconosciamo i cambiamenti nel verde molto più velocemente rispetto al blu ... quindi per i toni del verde una soglia più piccola potrebbe funzionare ma non sarà sufficiente per altri colori ecc. Per quanto ne so lo spazio colore Lab è vicino alla percezione del colore umano e potrebbe essere più adatto se non si ottengono risultati desiderabili con lo spazio colore HSV.
Bummzack,

1

Dal momento che hai detto che hai uno sfondo stazionario, il colore delle palle può ancora essere casuale ma devono cadere a determinate distanze che complimentano ancora lo sfondo.

Nozioni di base. Prima di farlo, devi conoscere le basi. Considera i seguenti colori:

Black   #000000 rgb(0,0,0)
Red     #FF0000 rgb(255,0,0)
Green   #00FF00 rgb(0,255,0)
Blue    #0000FF rgb(0,0,255)
Yellow  #FFFF00 rgb(255,255,0)
Cyan    #00FFFF rgb(0,255,255)
Pink    #FF00FF rgb(255,0,255)
Gray    #C0C0C0 rgb(192,192,192)
White   #FFFFFF rgb(255,255,255)

Miscela di colori RGB [(0..255), (0..255), (0..255)] crea nuovi colori come sopra.

Calcolo dei colori negativi Il calcolo dei colori negativi è come trasformare il rosso in ciano, il verde in viola, il blu in giallo.

Red     #FF0000 rgb(255,0,0) ->     Cyan    #00FFFF rgb(0,255,255)
Green   #00FF00 rgb(0,255,0) ->     Purple   #FF00FF    rgb(255,0,255)
Blue    #0000FF rgb(0,0,255) ->     Yellow  #FFFF00 rgb(255,255,0)

Colore complementare

Come riferimento sui colori complementari di calcolo: http://serennu.com/colour/rgbtohsl.php

Informazioni su HSL

HSL esprime i colori in termini di tonalità, saturazione e luminosità, fornendo un numero per ciascuno di questi tre attributi del colore.

La tonalità è la posizione del colore sulla ruota dei colori, espressa in gradi da 0 ° a 359 °, che rappresenta i 360 ° della ruota; 0 ° essendo rosso, 180 ° essendo rosso di colore opposto ciano, e così via.

La saturazione è l'intensità del colore, quanto è opaca o luminosa. Più bassa è la saturazione, più opaco (più grigio) appare il colore. Questo valore è espresso in percentuale, con il 100% di saturazione completa, il più luminoso e lo 0% senza saturazione, grigio.

La leggerezza è la luce del colore. Leggermente diverso dalla saturazione. Più bianco è il colore, maggiore è il suo valore di Luminosità, più nero è, minore è la sua Luminosità. Quindi il 100% di luminosità trasforma il colore in bianco, lo 0% di luminosità trasforma il colore in nero e il colore "puro" sarebbe il 50% di luminosità.

È più facile vedere la differenza tra Saturazione e Luminosità che spiegarla. Se vuoi chiarire, prova a visualizzare le variazioni di Luminosità e Saturazione nella pagina del calcolatore di colore, scegliendo un colore abbastanza brillante come colore di partenza.

Quindi la notazione HSL si presenta così, fornendo i valori di Tonalità, Saturazione e Luminosità in questo ordine: t

Rosso: 0 ° 100% 50% Rosa pallido: 0 ° 100% 90% Ciano: 180 ° 100% 50% Ecco i passaggi:

  1. Converti il ​​tuo colore in HSL.

  2. Cambia il valore della tonalità in quello della tonalità opposta (ad esempio, se la tonalità è 50 °, quella opposta si troverà a 230 ° sulla ruota - 180 ° più avanti).

  3. Lascia i valori di saturazione e luminosità per come erano.

  4. Converti questo nuovo valore HSL nella tua notazione cromatica originale (RGB o altro).

Siti come EasyRGB.com possono eseguire conversioni generiche da RGB a HSL o viceversa.

Esempio di programmazione fatto in PHP come da riferimento

Conversione da RGB a HSL

Il valore sopra Blue # 0000FF rgb (0,0,255) può essere presentato come Red esadecimale 00 + Green esadecimale 00 + Blue esadecimale FF

$redhex  = substr($hexcode,0,2);
$greenhex = substr($hexcode,2,2);
$bluehex = substr($hexcode,4,2);

Può anche essere presentato come decimale rosso 0 + decimale verde 0 + decimale blu 255

$var_r = (hexdec($redhex)) / 255;
$var_g = (hexdec($greenhex)) / 255;
$var_b = (hexdec($bluehex)) / 255;

Ora collega questi valori nella routine rgb2hsl. Di seguito è la mia versione PHP del codice generico di EasyRGB.com per quella conversione:

L'input è $ var_r, $ var_g e $ var_b dall'alto L'output è equivalente HSL come $ h, $ s e $ l - questi sono nuovamente espressi come frazioni di 1, come i valori di input

$var_min = min($var_r,$var_g,$var_b);ttt
$var_max = max($var_r,$var_g,$var_b);
$del_max = $var_max - $var_min;

$l = ($var_max + $var_min) / 2;

if ($del_max == 0)
{
        $h = 0;
        $s = 0;
}
else
{
        if ($l < 0.5)
        {
                $s = $del_max / ($var_max + $var_min);
        }
        else
        {
                $s = $del_max / (2 - $var_max - $var_min);
        };

        $del_r = ((($var_max - $var_r) / 6) + ($del_max / 2)) / $del_max;
        $del_g = ((($var_max - $var_g) / 6) + ($del_max / 2)) / $del_max;
        $del_b = ((($var_max - $var_b) / 6) + ($del_max / 2)) / $del_max;

        if ($var_r == $var_max)
        {
                $h = $del_b - $del_g;
        }
        elseif ($var_g == $var_max)
        {
                $h = (1 / 3) + $del_r - $del_b;
        }
        elseif ($var_b == $var_max)
        {
                $h = (2 / 3) + $del_g - $del_r;
        };

        if ($h < 0)
        {
                $h += 1;
        };

        if ($h > 1)
        {
                $h -= 1;
        };
};

Quindi ora abbiamo il colore come valore HSL, nelle variabili $ h, $ s e $ l. Queste tre variabili di output vengono nuovamente mantenute come frazioni di 1 in questa fase, piuttosto che come gradi e percentuali. Ad esempio, il ciano (180 ° 100% 50%) verrebbe fuori come $ h = 0,5, $ s = 1 e $ l = 0,5.

Quindi trova il valore della tonalità opposta, cioè quella che è 180 °, o 0,5, di distanza (sono sicuro che i matematici hanno un modo più elegante di dotarlo, ma):

Calcola la tonalità opposta, $ h2

            $h2 = $h + 0.5;

            if ($h2 > 1)
                    {
                            $h2 -= 1;
                    };

Il valore HSL del colore complementare è ora in $ h2, $ s, $ l. Quindi siamo pronti a riconvertirlo in RGB (di nuovo, la mia versione PHP della formula EasyRGB.com). Nota che i formati di input e output sono diversi questa volta, vedi i miei commenti nella parte superiore del codice:

L'input è il valore HSL di colore complementare, tenuto in $ h2, $ s, $ l come frazioni di 1 L'output è RGB nel normale formato 255 255 255, tenuto in $ r, $ g, $ b La tonalità viene convertita usando la funzione hue_2_rgb, mostrata alla fine di questo codice

    if ($s == 0)
    {
            $r = $l * 255;
            $g = $l * 255;
            $b = $l * 255;
    }
    else
    {
            if ($l < 0.5)
            {
                    $var_2 = $l * (1 + $s);
            }
            elset
            {
                    $var_2 = ($l + $s) - ($s * $l);
            };

            $var_1 = 2 * $l - $var_2;
            $r = 255 * hue_2_rgb($var_1,$var_2,$h2 + (1 / 3));
            $g = 255 * hue_2_rgb($var_1,$var_2,$h2);
            $b = 255 * hue_2_rgb($var_1,$var_2,$h2 - (1 / 3));
    };

   // Function to convert hue to RGB, called from above

    function hue_2_rgb($v1,$v2,$vh)
    {
            if ($vh < 0)
            {
                    $vh += 1;
            };

            if ($vh > 1)
            {
                    $vh -= 1;
            };

            if ((6 * $vh) < 1)
            {
                    return ($v1 + ($v2 - $v1) * 6 * $vh);
            };

            if ((2 * $vh) < 1)
            {
                    return ($v2);
            };

            if ((3 * $vh) < 2)
            {
                    return ($v1 + ($v2 - $v1) * ((2 / 3 - $vh) * 6));
            };

            return ($v1);
    };

E dopo quella routine, finalmente abbiamo $ r, $ ge $ b in formato 255 255 255 (RGB), che possiamo convertire in sei cifre esadecimali:

    $rhex = sprintf("%02X",round($r));
    $ghex = sprintf("%02X",round($g));
    $bhex = sprintf("%02X",round($b));

    $rgbhex = $rhex.$ghex.$bhex;

$ rgbhex è la nostra risposta: il colore complementare in esadecimale.

Dal momento che il tuo colore di sfondo è blu o 0,0.255 lo è HSL

Tonalità (H): 240 gradi / Saturazione (S): 100% / Luminosità (L): 4,9%

l'opposto di 240 è 60 in un cerchio, quindi la conversione in RGB dà un valore di # 181800


Grazie! Ma il collegamento parla della generazione di un "colore complementare" (qualunque esso sia) di se stesso . Non ho ancora idea di come usarlo per risolvere il mio problema: assicurati che ogni colore casuale non sia simile al colore di sfondo. Il colore di sfondo è costante, monocolore e ci sono più sfere.
MestreLion,

Grazie Krom che lo fa ora. @MestreLion, poiché lo sfondo è costante puoi specificare un intervallo per le tue palle che integri ancora lo sfondo.
Ace Caserya,

Attualmente esponendo la mia risposta.
Ace Caserya,

Fatto. Non faccio cosa cambiare molto nella spiegazione dei siti perché è spiegata abbastanza bene. Crediti ai ragazzi di EasyRGB.com
Ace Caserya


1

Mi piacerebbe ampliare l'idea di @ ashes999 di creare uno schema.

Il mio codice sarà il più possibile simile a pitone dalla cima della mia testa (non ho mai scritto una riga di pitone in vita mia, ma ho dato un'occhiata a un libro una o due volte).

def lerp(a,b,value): # assuming your library was not kind enough to give you this for free
    return a + ((b - a) * value);

def drawRandomBall(bgColour,radius,point):
    var ballColour = Colour(random(0,255),random(0,255),random(0,255);
    var outlineColour = Colour(lerp(bgColour.R,255 - ballColour.R,0.5),lerp(bgColour.G,255 - ballColour.G,0.5),lerp(bgColour.B,255 - ballColour.B,0.5));
    fillCircle(point,radius+1,outlineColour);
    fillCircle(point,radius,ballColour);

Potrebbe non sembrare particolarmente bello e non è davvero l'ideale per il codice di produzione, ma dovrebbe essere una soluzione rapida. Non ho testato il codice in quanto non ho esattamente un programma "palle che rimbalzano intorno allo schermo" che posso mutilare per testarlo.


Modificare:

Dopo aver visto il codice effettivo in uso, la situazione si è capovolta, quindi offro questa soluzione.

Sostituire le righe 276-284 con le seguenti:

# Colour generator
def generateColourNonBG(leeway):
    color = (randint(0,255), randint(0,255), randint(0,255))
    while color[0] >= BG_COLOR[0]-leeway and color[0] =< BG_COLOR[0] + leeway and
    color[1] >= BG_COLOR[1]-leeway and color[1] =< BG_COLOR[1] + leeway and
    color[2] >= BG_COLOR[2]-leeway and color[2] =< BG_COLOR[2] + leeway:
        color = (randint(0,255), randint(0,255), randint(0,255))

# Ball generator
def generateBall():
    Ball(generateColourNonBG(5),
                   radius=randint(10, radius),
                   position=[randint(100, screen.get_size()[0]-radius),
                             randint(100, screen.get_size()[0]-radius)],
                   velocity=[randint(50, 50+vel[0]), randint(50, 50+vel[1])],
                   )                       

# Create the balls
balls = pygame.sprite.Group()
for _ in xrange(BALLS):
    balls.add(generateBall())

In questa nuova versione semplificata, un metodo di fabbrica sputa le palle e un metodo specializzato genera i colori. Il generatore di colori verifica il colore generato casualmente per vedere se rientra in una certa gamma di vicinanza al colore di sfondo. Un colore è considerato troppo vicino al colore BG se tutti e tre i suoi canali di colore si trovano all'interno di leewayentrambi i lati di BG. Quindi, se il margine di manovra è 0, vengono rifiutati solo i colori che corrispondono esattamente a BG. Ho scelto 5 come predefinito, che rifiuta il colore BG e i 5 colori su entrambi i lati. Poiché il colore BG è bianco, non sono sicuro che rifiuterà il nero perché le cifre si avvolgono. Questo può essere evitato con l'uso delle funzioni min e max, ma le ho lasciate fuori per brevità.


Sono aperto a qualsiasi strategia :) per quanto riguarda un programma di mutilazione, posso darti che: github.com/MestreLion/rainballs linee pertinenti sarebbe 279-284
MestreLion

Sto usando pygamecome libreria. No Lerp, solo conversioni RGB-HSV-CYMK di base: pygame.org/docs/ref/color.html
MestreLion

@MestreLion Oh signore, ora devo installare Pygame e Python per testarlo. Mi sono sparato al piede con questo XP. Lerping è facile, la lerpfunzione nella mia risposta è tutto quello che c'è da fare. (Lerp significa "interpolazione lineare").
Pharap,

@MestreLion Armeggiato un po ', risulta che la mia versione di Python non piace che la stampa venga chiamata senza parentesi. Risolto il problema, ma ora ho errori da pygame non riuscire a trovare le librerie giuste. Riscriverò il mio codice per adattarlo a quello che hai, ma non posso provarlo fino a quando non aggiusto pygame. Ti consiglio di aggiungere quel file alla domanda se non l'hai già fatto (nel caso qualcuno si senta abbastanza gentile da scrivere un po 'di pitone per te).
Pharap,

Sei printdiverso perché stai usando Python 3, e sono ancora in Python 2. E non sono sicuro che sia pygamestato ancora portato su Py3. Bottomline: non preoccuparti :) La domanda riguarda i colori, non hai bisogno di palle che rimbalzano intorno :)
MestreLion

1

Per un formato RGB, questo sembra funzionare abbastanza bene ed è banale:

diversity_score = (abs (r1 - r2) + abs (g1 - g2) + abs (b1 - b2)) / 765.0

Questo ti darà un punteggio tra 0.0 e 1.0. Più è basso, più è difficile distinguere due colori.

Dovrebbe essere ovvio, ma per completezza: i valori r, g, b devono prima essere lanciati su un numero in virgola mobile e si presume che il loro valore massimo sia 255.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.