Comment générer cette séquence spécifique de nombres?

Question

Apparemment, il n'y a pas de liste prédéfinie disponible dans .net.

Je voudrais utiliser un certain nombre de couleurs standard, par exemple quelque chose comme le rouge, vert, bleu, jaune, ... soit les couleurs typiques composées de 00 et FF composants, suivis par ceux avec des composants 7F supplémentaires, ...

Y at-il un moyen de récupérer ces couleurs "standard" ou dois-je écrire le IEnumerable<Color> moi-même?

Éditer: Ceci est une sortie possible pour les valeurs RVB.

S'il vous plaît noter que pour des questions ensembles en ce que l'énumération 00/FF doit être terminée avant 80 est ajouté, et l'énumération 00/80/FF doit être complet avant d'ajouter 40/b0, etc. . La commande dans un ensemble n'a pas d'importance (c'est-à-dire que 00 FF 00 peut précéder 00 00 FF).

00 00 00 // start out with 00 and FF components 
00 00 FF 
00 FF 00 
FF 00 00 
FF FF 00 
FF 00 FF 
00 FF FF 
FF FF FF 
00 00 80 // ok, now add 80 
00 80 00 
... 
80 80 80 
FF 00 80 
FF 80 00 
FF 80 80 
80 FF 00 
80 FF 80 
FF FF 80 
... 
// now add 40 and B0 

Answer 1

Ceci est un moyen assez rapide pour générer la séquence:

public static IEnumerable<Color> StandardColors() 
{ 
    int r = 0; 
    int g = 0; 
    int b = 0; 
    int inc = 0x100; 

    yield return Color.FromArgb (0, 0, 0); 

    while (true) { 
     if (((r | g | b) & inc) != 0) { 
      int outR = r == 0 ? 0 : r - 1; 
      int outG = g == 0 ? 0 : g - 1; 
      int outB = b == 0 ? 0 : b - 1; 
      yield return Color.FromArgb (outR, outG, outB); 
     } 

     r += inc; 
     if (r > 256) { 
      r = 0; 
      g += inc; 

      if (g > 256) { 
       g = 0; 
       b += inc; 

       if (b > 256) { 
        b = 0; 
        inc >>= 1; 

        if (inc <= 1) { 
         break; 
        } 
       } 
      } 
     } 
    } 
} 

Cela peut certainement être amélioré. Par exemple, avoir une variable outR/G/B séparée doit être évitée, et l'incrémentation doit être via 2 * inc à partir d'une valeur impaire (basée sur inc) pour éviter d'avoir à tester si la valeur a déjà été générée plus tôt.

En utilisant ce test

static void Main (string[] args) 
{ 
    var colors = StandardColorEnumerator.StandardColors().Take (15) 
     .Concat (StandardColorEnumerator.StandardColors().Skip (1000).Take (10)); 
    foreach (var color in colors) { 
     Console.WriteLine (color.B + "\t" + color.G + "\t" + color.R); 
    } 

    Console.ReadKey (true); 
} 

la sortie suivante est générée:

0  0  0 
0  0  255 
0  255  0 
0  255  255 
255  0  0 
255  0  255 
255  255  0 
255  255  255 
0  0  127 
0  127  0 
0  127  127 
0  127  255 
0  255  127 
127  0  0 
127  0  127 

15  47  191 
15  47  207 
15  47  223 
15  47  239 
15  47  255 
15  63  0 
15  63  15 
15  63  31 
15  63  47 
15  63  63 

Answer 2

La classe Colors a un certain nombre de couleurs ARVB prédéfinies sur elle, tout comme la struct Color. Ces choses détiennent comme Yellow, White, Green etc ...

Si vous voulez que les couleurs système définies par l'utilisateur, vous pouvez utiliser la classe SystemColors qui a des choses comme ActiveBorder, WindowText etc ...

---

Mise à jour:

il n'y a rien dans le cadre qui trie les couleurs par leurs valeurs ARVB en tant que telle, car elle ne fait pas vraiment beaucoup de sens

Vous pouvez utiliser Linq pour trier une liste de couleurs par leurs composants (méthode d'extension OrderBy).

Answer 3

Probablement, la classe SystemColors est la bonne chose pour vous.

Answer 4

couleurs afaik « Standard » ne sont pas égaux aux couleurs RVB avec une valeur basée sur bagout que vous avez décrit. Par exemple, la couleur mauve a la valeur # B803FF RGB (où "fuchsia" similaire a # FF00FF).