FollowUp: « Tri » couleurs par caractère distinctif

voix
18

question d'origine

Si vous êtes donné N au maximum les couleurs lointaines (et une mesure de distance associée), vous pouvez trouver une façon de trier ces couleurs dans un ordre tel que le premier M sont également assez près d'être un ensemble distinct au maximum?

En d'autres termes, étant donné un bouquet de couleurs distinctes, venez avec un ordre pour que je puisse utiliser autant de couleurs que je dois partir au début et être raisonnablement assuré qu'ils sont tous distincts et que les couleurs voisines sont également très distinctes (par exemple, rouge bleuté est pas à côté de rougeâtre bleu).

Randomizing est OK mais certainement pas optimale.

Précision: Étant donné une grande série et visuellement distincte de couleurs (soit 256 ou 1024), je veux les trier de sorte que lorsque j'utilise le premier, disons, 16 d'entre eux que je reçois un sous-ensemble relativement visuellement distincte de couleurs. Cela équivaut, à peu près, pour dire que je veux trier cette liste de 1024 de sorte que les couleurs individuelles plus étroites sont visuellement, plus ils sont plus éloignés sur la liste.

Créé 04/08/2008 à 16:14
source utilisateur
Dans d'autres langues...                            


9 réponses

voix
2

N couleurs au maximum éloignés peuvent être considérés comme un ensemble de points bien répartis dans un espace en 3 dimensions (couleur). Si vous pouvez les générer à partir d' une séquence de Halton , puis tout préfixe (les premières couleurs M) se compose également de points bien distribués.

Créé 25/08/2008 à 09:44
source utilisateur

voix
2

Il semble perception est important pour vous, dans ce cas, vous voudrez peut-être envisager de travailler avec un espace de couleur perceptif tels que YUV, YCbCr ou Lab. Chaque fois que je l'ai utilisé ceux-ci, ils me ont donné des résultats bien meilleurs que sRGB seul.

La conversion vers et à partir sRGB peut être une douleur, mais dans votre cas, il pourrait effectivement rendre l'algorithme plus simple et en prime il sera surtout trop de travail pour les stores de couleur!

Créé 12/08/2008 à 13:33
source utilisateur

voix
2

Ce problème est appelé quantification des couleurs, et a de nombreux algorithmes bien connus: http://en.wikipedia.org/wiki/Color_quantization Je connais des gens qui ont mis en œuvre l'approche octree à bon escient.

Créé 12/08/2008 à 13:11
source utilisateur

voix
2

Cela semble aussi à moi comme une sorte de graphique de résistance où vous essayez de tracer le chemin de moindre résistance. Si vous inversez les exigences, le chemin de la résistance maximale, il pourrait peut-être utilisé pour produire un ensemble qui produit depuis le début différence maximale que vous allez, et vers la fin commence à revenir à des valeurs plus proches des autres.

Par exemple, voici une façon de faire peut-être ce que vous voulez.

  1. Calculez la distance (ref votre autre poste ) de chaque couleur à toutes les autres couleurs
  2. La somme des distances pour chaque couleur, ce qui vous donne une indication pour la distance de cette couleur est de toutes les autres couleurs au total
  3. Commandez la liste par la distance, en descendant

Cela, il semble, produire une liste qui commence par la couleur qui est la plus éloignée de toutes les autres couleurs, puis aller vers le bas, les couleurs vers la fin de la liste seraient plus proches des autres couleurs en général.

Edit: La lecture de votre réponse à mon premier poste, au sujet de la subdivision spatiale, ne correspond pas exactement à la description ci-dessus, car les couleurs proches d'autres couleurs tomberaient au bas de la liste, mais disons que vous avez un groupe de couleurs quelque part, à moins l'une des couleurs de cette grappe seraient situés près du début de la liste, et il serait celui qui était généralement le plus éloigné de toutes les autres couleurs au total. Si ça a du sens.

Créé 04/08/2008 à 16:38
source utilisateur

voix
1

Vous pouvez trier les couleurs juste candidats en fonction du maximum-distanciée de la distance minimale à l'une des couleurs de l'indice.

En utilisant la distance euclidienne couleur:

public double colordistance(Color color0, Color color1) {
    int c0 = color0.getRGB();
    int c1 = color1.getRGB();
    return distance(((c0>>16)&0xFF), ((c0>>8)&0xFF), (c0&0xFF), ((c1>>16)&0xFF), ((c1>>8)&0xFF), (c1&0xFF));
}

public double distance(int r1, int g1, int b1, int r2, int g2, int b2) {
    int dr = (r1 - r2);
    int dg = (g1 - g2);
    int db = (b1 - b2);
    return Math.sqrt(dr * dr + dg * dg + db * db);
}

Bien que vous pouvez le remplacer par tout ce que vous voulez. Il a juste besoin d'une routine de distance de couleur.

public void colordistancesort(Color[] candidateColors, Color[] indexColors) {
    double current;

    double distance[] = new double[candidateColors.length];
    for (int j = 0; j < candidateColors.length; j++) {
        distance[j] = -1;
        for (int k = 0; k < indexColors.length; k++) {
            current = colordistance(indexColors[k], candidateColors[j]);
            if ((distance[j] == -1) || (current < distance[j])) {
                distance[j] = current;
            }
        }
    }

    //just sorts.
    for (int j = 0; j < candidateColors.length; j++) {
        for (int k = j + 1; k < candidateColors.length; k++) {
            if (distance[j] > distance[k]) {
                double d = distance[k];
                distance[k] = distance[j];
                distance[j] = d;

                Color m = candidateColors[k];
                candidateColors[k] = candidateColors[j];
                candidateColors[j] = m;
            }
        }
    }
}
Créé 03/09/2012 à 21:50
source utilisateur

voix
1
  1. Commencez avec deux listes. CandidateColors, qui contient d'abord vos couleurs et SortedColors distinctes, qui est initialement vide.
  2. Choisissez la couleur et le retirer de CandidateColors et le mettre en SortedColors. Ceci est la première couleur et sera un bon endroit le plus commun, il est donc de choisir une couleur qui jives bien avec votre application.
  3. Pour chaque couleur CandidateColors calculer la distance totale. La distance totale est la somme de la distance de la CandidateColor à chacune des couleurs dans SortedColors.
  4. Retirez la couleur avec la plus grande distance totale de CandidateColors et l'ajouter à la fin de SortedColors.
  5. Si CandidateColors n'est pas vide, retournez à l'étape 3.

Cet algorithme glouton devrait vous donner de bons résultats.

Créé 21/11/2008 à 10:29
source utilisateur

voix
1

Si je comprends bien la question, vous souhaitez obtenir le sous - ensemble de M couleurs avec la plus haute distance moyenne entre les couleurs, étant donné une fonction de distance d .

Autrement dit, compte tenu de l'ensemble initial de N couleurs comme un grand, graphique où undirected toutes les couleurs sont connectés, vous voulez trouver le plus long chemin qui visite des M noeuds.

Résolution des problèmes de graphique NP-complet est bien au-delà de moi, j'ai peur, mais vous pouvez essayer d'exécuter une simulation physique simple:

  1. Générer M points aléatoires dans l' espace couleur
  2. Calculer la distance entre chaque point
  3. Calculer des vecteurs de répulsion pour chaque point qui se déplacera à l'écart de tous les autres points ( en utilisant 1 / ( distance de ^ 2) lorsque l'amplitude du vecteur)
  4. La somme des vecteurs de répulsion pour chaque point
  5. Mettre à jour la position de chaque point en fonction des vecteurs de répulsion sommés
  6. Contraindre toute rupture de coordonnées liées (tels que la luminosité de sens négatif ou au-dessus une)
  7. Répétez l'étape 2 jusqu'à ce que la stabilisent
  8. Pour chaque point, sélectionnez la couleur la plus proche de l'ensemble original de N

Il est loin d' être efficace, mais pour les petits M , il peut être assez efficace, et il donnera à des résultats optimaux.

Si votre fonction de distance de couleur est simple, il peut y avoir une façon plus déterministe de générer le sous-ensemble optimal.

Créé 16/10/2008 à 18:11
source utilisateur

voix
0

Vous pouvez les diviser en format RGB HEX afin que vous puissiez comparer les R avec R de couleur différente, même avec le G et B.

Même format HTML

XX XX XX
RR GG BB

00 00 00 = black
ff ff ff = white
ff 00 00 = red
00 ff 00 = green
00 00 ff = blue

La seule chose que vous devez décider est à quel point vous voulez que les couleurs et ce qui est une différence acceptable pour les segments d'être considérés comme différents.

Créé 04/08/2008 à 16:31
source utilisateur

voix
0

Voulez - vous dire que d'un ensemble de couleurs N, vous devez choisir des couleurs M, où M <N, tel que M est la meilleure représentation des couleurs N dans l'espace M?

Comme un meilleur exemple, réduire une véritable couleur (espace de couleurs 24 bits) à un espace colorimétrique cartographié 8 bits (GIF?).

Il existe des algorithmes de quantification pour cela, comme la subdivision spatiale Adaptive algorithme utilisé par ImageMagic.

Ces algorithmes ne sont généralement pas seulement choisir les couleurs existantes de l'espace source, mais crée de nouvelles couleurs dans l'espace cible qui ressemble le plus aux couleurs source. A titre d'exemple simplifié, si vous avez 3 couleurs dans l'image originale où deux sont rouges (avec une intensité différente ou teintes bleutées, etc.) et le troisième est bleu, et la nécessité de réduire à deux couleurs, l'image cible pourrait avoir une couleur rouge qui est une sorte de moyenne des deux d'origine rouge + la couleur bleue de l'image originale.

Si vous avez besoin de quelque chose d'autre, alors je ne comprends pas votre question :)

Créé 04/08/2008 à 16:29
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more