Tickmark algorithme pour un axe de graphique

Je suis à la recherche d'un algorithme qui place les marques de graduation sur l'axe, en partant d'une série à l'écran, d'une largeur d'affichage, et une fonction de mesure d'une chaîne de largeur pour une marque de graduation.

Par exemple, étant donné que j'ai besoin d'afficher entre 1e-6 et 5e-6 et d'une largeur d'affichage en pixels, l'algorithme de déterminer que je devrais mettre les graduations (par exemple) à 1e-6, 2e-6, 3e-6, 4e-6 et 5e-6. Donné une largeur plus petite, elle peut décider que le placement optimal est qu'au même poste, soit 2e-6 et 4e-6 (depuis mettre plus les graduations elles se chevauchent).

Un algorithme intelligent donneront la préférence pour les graduations multiples de 10, 5 et 2. Aussi, un algorithme intelligent serait symétrique autour de zéro.

InformationsquelleAutor Nick | 2008-10-25
  1. 6

    Comme je n'aime aucune des solutions que j'ai trouvé jusqu'à présent, j'ai mis en place mon propre. C'est en C#, mais il peut être facilement traduit dans toute autre langue.

    Essentiellement, il choisit à partir d'une liste d'étapes possibles de la plus petite qui affiche toutes les valeurs, sans laisser aucune valeur exactement sur le bord de la, vous permet de sélectionner facilement possible les étapes que vous souhaitez utiliser (sans avoir à modifier laid if-else if blocs), et prend en charge toute une gamme de valeurs. J'ai utilisé un C# Tuple pour retourner trois valeurs, juste pour un accès rapide et simple démonstration.

    private static Tuple<decimal, decimal, decimal> GetScaleDetails(decimal min, decimal max)
{
    //Minimal increment to avoid round extreme values to be on the edge of the chart
    decimal epsilon = (max - min) /1e6m;
    max += epsilon;
    min -= epsilon;
    decimal range = max - min;

    //Target number of values to be displayed on the Y axis (it may be less)
    int stepCount = 20;
    //First approximation
    decimal roughStep = range /(stepCount - 1);

    //Set best step for the range
    decimal[] goodNormalizedSteps = { 1, 1.5m, 2, 2.5m, 5, 7.5m, 10 }; //keep the 10 at the end
    //Or use these if you prefer:  { 1, 2, 5, 10 };

    //Normalize rough step to find the normalized one that fits best
    decimal stepPower = (decimal)Math.Pow(10, -Math.Floor(Math.Log10((double)Math.Abs(roughStep))));
    var normalizedStep = roughStep * stepPower;
    var goodNormalizedStep = goodNormalizedSteps.First(n => n >= normalizedStep);
    decimal step = goodNormalizedStep /stepPower;

    //Determine the scale limits based on the chosen step.
    decimal scaleMax = Math.Ceiling(max /step) * step;
    decimal scaleMin = Math.Floor(min /step) * step;

    return new Tuple<decimal, decimal, decimal>(scaleMin, scaleMax, step);
}

static void Main()
{
    //Dummy code to show a usage example.
    var minimumValue = data.Min();
    var maximumValue = data.Max();
    var results = GetScaleDetails(minimumValue, maximumValue);
    chart.YAxis.MinValue = results.Item1;
    chart.YAxis.MaxValue = results.Item2;
    chart.YAxis.Step = results.Item3;
}
    • Salut, j'ai trouvé un problème avec int stepCount = 8; minimumValue = 0.33, maximumValue=0.55 il retourne {scaleMin: 0.3, scaleMax: 0.55 étape: 0.05} donc, cela signifie que la 6e étape est 0.3+0.05*6 = 0.6, 7e étape est de 0,65, 8e étape est de 0,7: 6ème, 7ème, 8ème numéro sont plus grands que les scaleMax: 0.55........
    • J'ai essayé, mais le retour scaleMax est 0.6. Il évite d'avoir des valeurs extrêmes exactement sur l'axe des limites. Et pour éviter d'avoir bizarre étapes ou trop larges gammes, le compromis est d'avoir le moins d'étapes. Notez le commentaire qui dit "Cible nombre de valeurs à afficher sur l'axe des Y (c'est peut être moins)". Si vous voulez un stepCount d'exactement 8, vous devez avoir une plus laide de l'étape, ou un plus grand axe de la gamme, cette logique qui considère la pire des options. Vous pouvez essayer d'ajouter plus de valeurs à goodNormalizedSteps, comme 0.3, 0.8.
    • Vous aurez besoin d'ajouter 3.15m ou 3.2m à goodNormalizedSteps avoir exactement 8 étapes.
    • Une autre option que j'ai trouvé: ajouter 3.33, idéalement comme ceci: ...2.5m, 10/3m, 5, .... Vous obtiendrez 8 les étapes de 0,3 à 0.5666.
    InformationsquelleAutor Andrew
  2. 2

    Prendre le plus long des segments sur zéro (ou à tout le graphique, si le zéro n'est pas dans la gamme) - par exemple, si vous avez quelque chose sur l'intervalle [-5, 1], [le -5,0].

    Figure d'environ combien de temps ce segment sera, dans les tiques. C'est juste de diviser la longueur par la largeur d'une case à cocher. Supposons donc que la méthode dit que nous pouvons mettre 11 tiques à partir de -5 à 0. C'est notre limite supérieure. Pour le côté le plus court, nous allons simplement refléter le résultat sur le côté le plus long.

    Maintenant essayer de mettre plusieurs (jusqu'à 11) les tiques, tels que le marqueur de chaque à cocher dans le formulaire i*10*10^n, i*5*10^n, i*2*10^n, où n est un entier, et i est l'indice de la tique. Maintenant, c'est un problème d'optimisation, nous voulons maximiser le nombre de tiques, nous pouvons mettre en, alors que dans le même temps de minimiser la distance entre le dernier tick et la fin de la suite. Afin d'attribuer un score pour obtenir autant de tiques que l'on peut, moins que la limite supérieure, et d'attribuer un score à obtenir le dernier tick près de la n - vous aurez à expérimenter ici.

    Dans l'exemple ci-dessus, essayez de n = 1. Nous obtenons 1 tick (i=0). n = 2 nous donne 1 tique, et nous sommes loin de la limite inférieure, de sorte que nous savons que nous devons aller dans l'autre sens. n = 0 nous donne 6 tiques, à chaque entier de point de point de. n = -1 nous donne 12 tiques (0, -0.5, ..., -5.0). n = -2 nous donne 24 tiques, et ainsi de suite. L'algorithme de calcul va leur donner à chacun un score plus élevé signifie une meilleure méthode.

    Le faire de nouveau, pour le i * 5 * 10^n, et i*2*10^n, et de prendre celui avec le meilleur score.

    (par exemple l'algorithme de scoring, dire que le score est de la distance à la dernière tique fois le nombre maximum de tiques moins le nombre de besoin. Ce sera probablement mauvais, mais il va me servir de point de départ décent).

    InformationsquelleAutor mindvirus
  3. 0

    Ce simple algorithme donne un intervalle qui est multiple de 1, 2, ou 5 fois une puissance de 10. Et l'axe de la gamme est divisée en au moins 5 intervalles. L'exemple de code est en langage java:

    protected double calculateInterval(double range) {
    double x = Math.pow(10.0, Math.floor(Math.log10(range)));
    if (range /x >= 5)
        return x;
    else if (range /(x /2.0) >= 5)
        return x /2.0;
    else
        return x /5.0;
}

    C'est une alternative, pour un minimum de 10 intervalles:

    protected double calculateInterval(double range) {
    double x = Math.pow(10.0, Math.floor(Math.log10(range)));
    if (range /(x /2.0) >= 10)
        return x /2.0;
    else if (range /(x /5.0) >= 10)
        return x /5.0;
    else
        return x /10.0;
}
    InformationsquelleAutor Giorgio Barchiesi
  4. 0

    J'ai été en utilisant jQuery flot graphique de la bibliothèque. Il est open source et ne l'axe/tique génération assez bien. Je vous suggère de regarder le code et le pincement des idées à partir de là.

    • S'il vous plaît ne pas ajouter des réponses sans exemples, comme de simples liens souffrent de la pourriture. Cependant, je ne suis pas downvoting, comme le flot s'avère être exactement ce dont j'ai besoin!
    InformationsquelleAutor Tom
  5. -4

    quel est votre langage de développement ? J'ai un contrôle de graphique en C++ qui permet de résoudre ce problème facilement en utilisant une combinaison de logarithme, celings etc. Si vous voulez vous pouvez expliquer le code pour vous.

    • Mon dev langue est le C#, mais je ne me dérangerait pas de voir une implémentation C++--je peux traduire.
    InformationsquelleAutor