Comment éviter le journal zéro dans le graphique en utilisant d3.js

Je travaille actuellement sur la bibliothèque d3.js.I a un graphique linéaire utilisant le Graphique de ligne dynamique. Nous avons ici l'option de dessin de puissance linéaire et log. Mais mon problème est que je pourrais avoir certaines valeurs zéro dans mon ensemble de données et que log 0 est indéfini, de sorte que le code ne peut pas le tracer. Ici, dans mon code, l'échelle est définie comme celle-ci

y = d3.scale.log().domain([0.1, max_y _value]).range([h, 0]).nice();

Et c'est ainsi qu'il est utilisé

  lineFunction = d3.svg.line() .y(function(d) { return y(d); });

Je sais que c'est une question étrange. Mais est-ce qu'il y a une manière par laquelle je peux gérer la valeur du journal 0 afin que, si j'ai une valeur zéro unique, le reste est trapé correctement. Puis-je donner deux domaines et une portée dans la même déclaration (pour gérer 0 valeur) si oui, comment va-t-il se lier à l'axe y?

Merci. Toute aide sera appréciée.

J'ai résolu mon problème en utilisant une fonction de serrage . C'est ainsi que j'ai changé le code:

 y = d3.scale.log().clamp(true).domain([0.1, max_y _value]).range([h, 0]).nice();

Si vous avez un domaine qui possède l'une des limites du domaine, l'échelle 0 log ne fonctionnera pas pour vous. De plus, l'échelle de journal vous fournit une fonction tick () avec un nombre de tiques impossible à configurer.

Mon affectation actuelle consiste à afficher des données avec des domaines et des plages arbitraires sur un tableau de diffusion à échelle linéaire, MAIS, éventuellement, l'utilisateur peut passer à une échelle logarithmique. Ceci inclut les domaines problématiques [0, n] et [n, 0].

Voici une solution à laquelle j'ai abordé ces cas: le problème peut être évité si nous utilisons une échelle linéaire pour projeter notre domaine dans une gamme arbitraire avec des limites positives. Je choisis [1,10] mais il peut prendre n'importe quel nombre positif. Ensuite, nous pouvons utiliser une balance log normale.

 d3.scale.genericLog = function() { return GenericLog(); }; function GenericLog() { var PROJECTION=[1,10]; var linearScale, logScale; linearScale=d3.scale.linear(); linearScale.range(PROJECTION); logScale=d3.scale.log(); logScale.domain(PROJECTION); function scale(x) { return logScale(linearScale(x)); } scale.domain = function(x) { if (!arguments.length) return linearScale.domain(); linearScale.domain(x); return scale; }; scale.range = function(x) { if (!arguments.length) return logScale.range(); logScale.range(x); return scale; }; scale.ticks = function(m) { return linearScale.ticks(m); }; return scale; }

Usage:

 var scale1 = d3.scale.genericLog().domain([0,1]).range([500,1000]); var scale2 = d3.scale.genericLog().domain([-10,0]).range([500,1000]); scale1(0) //500 scale2(-10) //500 scale2(0) //100

J'ai seulement besoin des fonctions de la gamme (), de l'échelle (), des tiques (), donc je ne l'ai inclus que ces dernières, mais il ne faudrait pas plus de 5 minutes pour mettre en œuvre toutes les autres. Aussi: notez que j'utilise les valeurs de ticks () de l'échelle linéaire parce que je devais limiter le nombre de tiques et c'est plus facile avec l'échelle linéaire.

ÉDIT: CONSULTEZ En fonction de ce que vous choisissez comme PROJECTION, cela va fausser votre échelle logarithmique. L'intervalle plus large que vous utilisez sera plus proche de la partie inférieure de votre échelle.