D3 Referência da API

D3 é uma coleção de módulos que são projetados para trabalhar juntos; você pode usar os módulos independentemente ou pode usá-los juntos como parte da compilação padrão. A fonte e a documentação de cada módulo estão disponíveis em seu repositório. Siga os links abaixo para saber mais. Para alterações entre as versões principais, consulte CHANGES; consulte também as notas de lançamento e a referência 3.x.

• Arrays (Estatística, Busca, Iteráveis, Conjuntos, Transformações, Histogramas, Interando)
• Eixos
• Brushes
• Chords
• Cores
• Esquema de cores
• Contornos
• Diagrama Voronoi
• Despachos
• Dragging
• Valores separados por delimitador
• Easings
• Fetches
• Forças
• Formatos numéricos
• Geografias (Paths, Projeções, Esférica matemática, Formas Esféricas, Streams, Transformações)
• Hierarquias
• Interpoladores
• Paths
• Polígonos
• Quadtrees
• Números aleatórios
• Escalas (Continuos, Sequencial, Divergente, Quantizar, Ordinais)
• Seleções (Selecionando, Modificando, Data, Eventos, Controle, Variáveis locais, Namespaces)
• Formas (Arcos, Tortas, Linhas, Áreas, Curvas, Ligações, Símbolos, Pilhas)
• Formatos de hora
• Intervalos de tempo
• Temporizadores
• Transições
• Zoom

D3 usa versão semântica. A versão atual é exposta como d3.version.

Arrays (d3-array)

Manipulação de matriz, ordenação, pesquisa, resumo, etc.

Estatística

Métodos estatísticos básicas para calcular sumarizar .

• d3.min - calcula o valor mínimo em um iterável.
• d3.minIndex - calcula o índice do valor mínimo em um iterável.
• d3.max - calcula o valor máximo em um iterável.
• d3.maxIndex - calcula o índice do valor máximo em um iterável.
• d3.extent - calcula o valor mínimo e máximo em um iterável.
• d3.sum - calcula a soma de uma iteração de números.
• d3.mean - calcula a média aritmética de uma iteração de números.
• d3.median - calcula a mediana de um iterável de números (o quantil 0,5).
• d3.medianIndex - calcula o índice mediano de um iterável de números (o quantil 0,5) .
• d3.mode - calcula o modo (o valor mais comum) de um iterável de números.
• d3.cumsum - calcula a soma cumulativa de um iterável.
• d3.rank - calcula a ordem de classificação de um iterável.
• d3.quantile - calcula um quantil para uma iteração de números.
• d3.quantileIndex - calcula um quantil de índice para um iterável de números.
• d3.quantileSorted - calcula um quantil para uma matriz classificada de números.
• d3.variance - calcula a variância de uma iteração de números.
• d3.deviation - calcula o desvio padrão de uma iteração de números.
• d3.fcumsum - calcula uma soma cumulativa de números com precisão total.
• d3.fsum - calcula uma soma de precisão completa de um iterável de números.
• novo d3.Adder - cria um somador de precisão total.
• adder.add - adiciona um valor a um somador.
• adder.valueOf - retorna uma representação de precisão dupla do valor de um somador.
• d3.blur - desfoca uma matriz de números no lugar.
• d3.blur2 - desfoca uma matriz bidimensional de números no lugar.
• d3.blurImage - desfoque um RGBA ImageData no local.

Busca

Métodos para pesquisar arrays para um elemento específico.

• d3.least - retorna o menor elemento de um iterável.
• d3.leastIndex - retorna o índice do menor elemento de um iterável.
• d3.greatest - retorna o maior elemento de um iterável.
• d3.greatestIndex - retorna o índice do maior elemento de um iterável.
• d3.bisectCenter - busca binária por um valor em uma matriz classificada.
• d3.bisectLeft - pesquisa binária por um valor em uma matriz classificada.
• d3.bisect - pesquisa binária por um valor em uma matriz classificada.
• d3.bisectRight - pesquisa binária por um valor em uma matriz classificada.
• d3.bisector - divide ao meio usando um acessador ou comparador.
• bisector.center - busca binária por um valor em uma matriz classificada.
• bissector.left - bisectLeft, com o comparador fornecido.
• bissector.right - bisectRight, com o comparador fornecido.
• d3.quickselect - reordene uma matriz de números.
• d3.ascending - calcula a ordem natural de dois valores.
• d3.descending - calcula a ordem natural de dois valores.

Transformações

Métodos para transformar arrays e para gerar novos arrays.

• d3.flatGroup - agrupa um iterável em uma matriz plana.
• d3.flatRollup - reduz um iterável em uma matriz simples.
• d3.group - agrupa um iterável em um mapa aninhado.
• d3.groups - agrupa um iterável em uma matriz aninhada.
• d3.groupSort - classifica as chaves de acordo com os valores agrupados.
• d3.index - indexa um iterável em um mapa aninhado.
• d3.indexes - indexa um iterável em uma matriz aninhada.
• d3.rollup - reduz um iterável em um mapa aninhado.
• d3.rollups - reduz um iterável em uma matriz aninhada.
• d3.count - conta valores numéricos válidos em um iterável.
• d3.cross - calcula o produto cartesiano de dois iteráveis.
• d3.merge - mescla vários iteráveis em um array.
• d3.pairs - cria uma matriz de pares adjacentes de elementos.
• d3.permute - reordene um iterável de elementos de acordo com um iterável de índices.
• d3.shuffle - randomize a ordem de um iterável.
• d3.shuffler - randomize a ordem de um iterável.
• d3.ticks - gera valores representativos a partir de um intervalo numérico.
• d3.tickIncrement - gera valores representativos de um intervalo numérico.
• d3.tickStep - gera valores representativos de um intervalo numérico.
• d3.nice - estende um intervalo para alinhar com os ticks.
• d3.range - gera um intervalo de valores numéricos.
• d3.transpose - transpõe um array de arrays.
• d3.zip - transpõe um número variável de arrays.

Iteráveis

• d3.every - teste se todos os valores satisfazem uma condição.
• d3.some - teste se algum valor satisfaz uma condição.
• d3.filter - valores de filtro.
• d3.map - valores do mapa.
• d3.reduce - reduz os valores.
• d3.reverse - inverte a ordem dos valores.
• d3.sort - classifica valores.

Conjuntos

• d3.difference - calcula uma diferença definida.
• d3.disjoint - teste se dois conjuntos são disjuntos.
• d3.intersection - calcula uma interseção definida.
• d3.superset - teste se um conjunto é um superconjunto de outro.
• d3.subset - teste se um conjunto é um subconjunto de outro.
• d3.union - calcula uma união de conjuntos.

Histogramas

Bin discrete samples into continuous, non-overlapping intervals.

• d3.bin - crie um novo gerador de bin.
• bin - agrupa uma determinada matriz de amostras.
• bin.value - especifique um acessador de valor para cada amostra.
• bin.domain - especifique o intervalo de valores observáveis.
• bin.thresholds - especifique como os valores são divididos em compartimentos.
• d3.thresholdFreedmanDiaconis - a regra de binning Freedman–Diaconis.
• d3.thresholdScott - regra de binning de referência normal de Scott.
• d3.thresholdSturges - Fórmula de binning de Sturges.

Interando

• d3.InternMap - um mapa de chave interna.
• d3.InternSet - um conjunto interno de valor.

Eixos (d3-axis)

Marcas de referência legíveis por humanos para escalas.

• d3.axisTop - crie um novo gerador de eixo orientado para cima.
• d3.axisRight - crie um novo gerador de eixo orientado à direita.
• d3.axisBottom - cria um novo gerador de eixo orientado para baixo.
• d3.axisLeft - crie um novo gerador de eixo orientado à esquerda.
• axis - gera um eixo para a seleção dada.
• axis.scale - defina a escala.
• axis.ticks - personalize como os ticks são gerados e formatados.
• axis.tickArguments - personalize como os ticks são gerados e formatados.
• axis.tickValues - defina os valores do tick explicitamente.
• axis.tickFormat - defina o formato do tick explicitamente.
• axis.tickSize - defina o tamanho dos ticks.
• axis.tickSizeInner - defina o tamanho dos ticks internos.
• axis.tickSizeOuter - defina o tamanho dos ticks externos (extensão).
• axis.tickPadding - defina o preenchimento entre marcas e rótulos.
• axis.offset - defina o deslocamento de pixel para bordas nítidas.

Brushes (d3-brush)

Selecione uma região uni ou bidimensional usando o mouse ou toque.

• d3.brush - crie um novo pincel bidimensional.
• d3.brushX - crie um pincel ao longo da dimensão x.
• d3.brushY - crie um pincel ao longo da dimensão y.
• brush - aplique o pincel a uma seleção.
• brush.move - move a seleção do pincel.
• brush.clear - limpa a seleção do pincel.
• brush.extent - define a região que pode ser escovada.
• brush.filter - controle quais eventos de entrada iniciam a escovação.
• brush.touchable - defina o detector de suporte de toque.
• brush.keyModifiers - ativa ou desativa a interação de teclas.
• brush.handleSize - defina o tamanho das alças do pincel.
• brush.on - escuta eventos de pincel.
• d3.brushSelection - obtenha a seleção de pincel para um determinado nó.

Chords (d3-chord)

• d3.chord - crie um novo layout de acorde.
• chord - calcula o layout para a matriz fornecida.
• chord.padAngle - defina o preenchimento entre grupos adjacentes.
• chord.sortGroups - define a ordem do grupo.
• chord.sortSubgroups - define a ordem de origem e destino dentro dos grupos.
• chord.sortChords - defina a ordem dos acordes nos grupos.
• d3.chordDirected - crie um gerador de acordes direcionados.
• d3.chordTranspose - crie um gerador de acordes transpostos.
• d3.ribbon - crie um gerador de forma de fita.
• ribbon - gera uma forma de fita.
• ribbon.source - defina o acessador de origem.
• ribbon.target - defina o acessador de destino.
• ribbon.radius - defina a origem da fita e o raio de destino.
• ribbon.sourceRadius - defina o raio de origem da fita.
• ribbon.targetRadius - defina o raio de destino da faixa de opções.
• ribbon.startAngle - defina a origem da fita ou o ângulo inicial de destino.
• ribbon.endAngle - defina a origem da fita ou o ângulo final de destino.
• ribbon.padAngle - defina o acessador de ângulo do pad.
• ribbon.context - defina o contexto de renderização.
• d3.ribbonArrow - crie um gerador de fita de seta.
• ribbonArrow.headRadius - defina o acessor do raio da ponta da seta.

Cores (d3-color)

Manipulação de cores e conversão de espaços de cores.

• d3.color - analisa o especificador de cor CSS fornecido.
• color.opacity - a opacidade da cor.
• color.rgb - calcule o equivalente RGB desta cor.
• color.copy - retorna uma cópia desta cor.
• color.brighter - crie uma cópia mais brilhante desta cor.
• color.darker - cria uma cópia mais escura desta cor.
• color.displayable - retorna verdadeiro se a cor puder ser exibida em hardware padrão.
• color.formatHex - retorna a representação de string RRGBBB hexadecimal desta cor.
• color.formatHex8 - retorna a representação de string hexadecimal RRGGBBAA desta cor.
• color.formatHsl - retorna a representação de string RGB desta cor.
• color.formatRgb - retorna a representação de string HSL desta cor.
• color.toString - retorna a representação de string RGB desta cor.
• d3.rgb - cria uma nova cor RGB.
• rgb.clamp - retorna a cópia desta cor presa ao espaço de cores RGB.
• d3.hsl - crie uma nova cor HSL.
• hsl.clamp - retorna a cópia desta cor presa ao espaço de cores HSL.
• d3.lab - crie uma nova cor Lab.
• d3.gray - crie um novo Lab gray.
• d3.hcl - crie uma nova cor HCL.
• d3.lch - cria uma nova cor HCL.
• d3.cubehelix - crie uma nova cor Cubehelix.

Esquema de cores (d3-scale-chromatic)

Cores e paletas para escalas quantitativas, ordinais e categóricas.

Categórico

• d3.schemeCategory10 - uma matriz de dez cores categóricas.
• d3.schemeAccent - uma matriz de oito cores categóricas.
• d3.schemeDark2 - uma matriz de oito cores categóricas.
• d3.schemePaired - uma matriz de doze cores categóricas.
• d3.schemePastel1 - uma matriz de nove cores categóricas.
• d3.schemePastel2 - uma matriz de oito cores categóricas.
• d3.schemeSet1 - uma matriz de nove cores categóricas.
• d3.schemeSet2 - uma matriz de oito cores categóricas.
• d3.schemeSet3 - uma matriz de doze cores categóricas.
• d3.schemeTableau10 - uma matriz de dez cores categóricas.

Divergente

• d3.interpolateBrBG - interpolador ColorBrewer BrBG.
• d3.interpolatePiYG - interpolador ColorBrewer PiYG.
• d3.interpolatePRGn - interpolador ColorBrewer PRGn.
• d3.interpolatePuOr - interpolador ColorBrewer PuOr.
• d3.interpolateRdBu - interpolador ColorBrewer RdBu.
• d3.interpolateRdGy - interpolador ColorBrewer RdGy.
• d3.interpolateRdYlBu - interpolador ColorBrewer RdYlBu.
• d3.interpolateRdYlGn - interpolador ColorBrewer RdYlGn.
• d3.interpolateSpectral - ColorBrewer interpolador espectral.
• d3.schemeBrBG - Esquema ColorBrewer BrBG.
• d3.schemePiYG - Esquema ColorBrewer PiYG.
• d3.schemePRGn - Esquema ColorBrewer PRGn.
• d3.schemePuOr - Esquema ColorBrewer PuOr.
• d3.schemeRdBu - Esquema ColorBrewer RdBu.
• d3.schemeRdGy - Esquema ColorBrewer RdGy.
• d3.schemeRdYlBu - Esquema ColorBrewer RdYlBu.
• d3.schemeRdYlGn - Esquema ColorBrewer RdYlGn.
• d3.schemeSpectral - Esquema espectral do ColorBrewer.

Sequencial (Single Hue)

• d3.interpolateBlues -
• d3.interpolateGreens -
• d3.interpolateGreys -
• d3.interpolateOranges -
• d3.interpolatePurples -
• d3.interpolateReds -
• d3.schemeBlues -
• d3.schemeGreens -
• d3.schemeGreys -
• d3.schemeOranges -
• d3.schemePurples -
• d3.schemeReds -

Sequencial (Multi-Hue)

• d3.interpolateBuGn - interpolador ColorBrewer BuGn.
• d3.interpolateBuPu - interpolador ColorBrewer BuPu.
• d3.interpolateCividis - interpolador cividis.
• d3.interpolateCool - interpolador legal.
• d3.interpolateCubehelixDefault - interpolador cubehelix.
• d3.interpolateGnBu - interpolador ColorBrewer GnBu.
• d3.interpolateInferno - interpolador inferno.
• d3.interpolateMagma - interpolador de magma.
• d3.interpolateOrRd - interpolador ColorBrewer OrRd.
• d3.interpolatePlasma - interpolador de plasma.
• d3.interpolatePuBu - interpolador ColorBrewer PuBu.
• d3.interpolatePuBuGn - interpolador ColorBrewer PuBuGn.
• d3.interpolatePuRd - interpolador ColorBrewer PuRd.
• d3.interpolateRdPu - interpolador ColorBrewer RdPu.
• d3.interpolateTurbo - interpolador turbo.
• d3.interpolateViridis - interpolador viridis.
• d3.interpolateWarm - interpolador quente.
• d3.interpolateYlGn - interpolador ColorBrewer YlGn.
• d3.interpolateYlGnBu - interpolador ColorBrewer YlGnBu.
• d3.interpolateYlOrBr - interpolador ColorBrewer YlOrBr.
• d3.interpolateYlOrRd - interpolador ColorBrewer YlOrRd.
• d3.schemeBuGn - Esquema ColorBrewer BuGn.
• d3.schemeBuPu - Esquema ColorBrewer BuPu.
• d3.schemeGnBu - Esquema ColorBrewer GnBu.
• d3.schemeOrRd - Esquema ColorBrewer OrRd.
• d3.schemePuBu - Esquema ColorBrewer PuBu.
• d3.schemePuBuGn - Esquema ColorBrewer PuBuGn.
• d3.schemePuRd - Esquema ColorBrewer PuRd.
• d3.schemeRdPu - Esquema ColorBrewer RdPu.
• d3.schemeYlGn - Esquema ColorBrewer YlGn.
• d3.schemeYlGnBu - Esquema ColorBrewer YlGnBu.
• d3.schemeYlOrBr - Esquema ColorBrewer YlOrBr.
• d3.schemeYlOrRd - Esquema ColorBrewer YlOrRd.

Cíclico

• d3.interpolateRainbow - o arco-íris “menos zangado”
• d3.interpolateSinebow - o arco-íris suave “sinebow”

Contornos (d3-contour)

Calcular polígonos de contorno usando quadrados em movimento.

• d3.contours - crie um novo gerador de contorno.
• contours - calcula os contornos para uma determinada grade de valores.
• contours.contour - calcula um contorno para um determinado valor.
• contours.size - defina o tamanho de um gerador de contorno.
• contours.smooth - define se os contornos gerados são suavizados ou não.
• contours.thresholds - define os limites de um gerador de contorno.
• d3.contourDensity - crie um novo estimador de densidade.
• density - estima a densidade de uma determinada matriz de amostras.
• density.x - defina o acessador x do estimador de densidade.
• density.y - defina o acessador y do estimador de densidade.
• density.weight - defina o acessador weight do estimador de densidade.
• density.size - defina o tamanho do estimador de densidade.
• density.cellSize - defina o tamanho da célula do estimador de densidade.
• density.thresholds - defina os limites do estimador de densidade.
• density.bandwidth - defina a largura de banda do estimador de densidade.
• density.contours - calcula contornos de densidade.

Diagrama Voronoi (d3-delaunay)

Calcule o diagrama de Voronoi de um conjunto de pontos bidimensionais.

• new Delaunay - cria uma triangulação delaunay para uma matriz de coordenadas de ponto.
• Delaunay.from - cria uma triangulação delaunay para um iterável de pontos.
• delaunay.points - as coordenadas dos pontos.
• delaunay.halfedges - as meias-bordas delaunay.
• delaunay.hull - o casco convexo como índices de pontos.
• delaunay.triangles - os triângulos delaunay.
• delaunay.inedges - as bordas delaunay
• delaunay.find - encontre o ponto mais próximo na triangulação delaunay.
• delaunay.neighbors - os vizinhos de um ponto na triangulação delaunay.
• delaunay.render - renderiza as arestas da triangulação delaunay.
• delaunay.renderHull - renderiza o casco convexo.
• delaunay.renderTriangle - renderiza um triângulo.
• delaunay.renderPoints - renderiza os pontos.
• delaunay.hullPolygon - o casco convexo fechado como coordenadas de ponto.
• delaunay.trianglePolygons - iterar sobre todos os triângulos como polígonos.
• delaunay.trianglePolygon - retorna um triângulo como um polígono.
• delaunay.update - atualize uma triangulação delaunay no local.
• delaunay.voronoi - calcula o diagrama voronoi associado a uma triangulação delaunay.
• voronoi.delaunay - a triangulação delaunay da fonte do diagrama de voronoi.
• voronoi.circumcenters - os circuncentros dos triângulos.
• voronoi.vectors - instruções para as células externas (infinitas) do diagrama voronoi.
• voronoi.xmin - defina o limite xmin da extensão.
• voronoi.ymin - defina o limite ymin da extensão.
• voronoi.xmax - defina o limite xmax da extensão.
• voronoi.ymax - defina o limite ymax da extensão.
• voronoi.contains - teste se um ponto está dentro de uma célula voronoi.
• voronoi.neighbors - os vizinhos de um ponto no diagrama de voronoi.
• voronoi.render - renderiza a malha de células voronoi.
• voronoi.renderBounds - renderiza a extensão.
• voronoi.renderCell - renderiza uma célula voronoi.
• voronoi.cellPolygons - iterar sobre todas as células como polígonos.
• voronoi.cellPolygon - retorna uma célula como um polígono.
• voronoi.update - atualize um diagrama voronoi no local.

Despachos (d3-dispatch)

Separe preocupações usando retornos de chamada nomeados.

• d3.dispatch - crie um despachante de evento personalizado.
• dispatch.on - registrar ou cancelar o registro de um ouvinte de evento.
• dispatch.copy - cria uma cópia de um dispatcher.
• dispatch.call - despacha um evento para ouvintes registrados.
• dispatch.apply - despacha um evento para ouvintes registrados.

Dragging (d3-drag)

Arraste e solte SVG, HTML ou Canvas usando o mouse ou entrada de toque.

• d3.drag - cria um comportamento de arrastar.
• drag - aplica o comportamento de arrastar a uma seleção.
• drag.container - defina o sistema de coordenadas.
• drag.filter - ignore alguns eventos de entrada iniciais.
• drag.touchable - defina o detector de suporte de toque.
• drag.subject - define o que está sendo arrastado.
• drag.clickDistance - defina o limite de distância do clique.
• drag.on - ouça eventos de arrastar.
• d3.dragDisable - evita arrastar e soltar nativo e seleção de texto.
• d3.dragEnable - permite arrastar e soltar nativo e seleção de texto.
• event.on - ouça eventos de arrastar no gesto atual.

Valores separados por delimitador (d3-dsv)

Analisar e formatar valores separados por delimitador, mais comumente CSV e TSV.

• d3.csvParse - analisa a string CSV fornecida, retornando uma matriz de objetos.
• d3.csvParseRows - analisa a string CSV fornecida, retornando uma matriz de linhas.
• d3.csvFormat - formata a matriz de objetos fornecida como CSV.
• d3.csvFormatBody - formata a matriz de objetos fornecida como CSV.
• d3.csvFormatRows - formata a matriz de linhas fornecida como CSV.
• d3.csvFormatRow - formata a linha fornecida como CSV.
• d3.csvFormatValue - formata o valor fornecido como CSV.
• d3.tsvParse - analisa a string TSV fornecida, retornando uma matriz de objetos.
• d3.tsvParseRows - analisa a string TSV fornecida, retornando uma matriz de linhas.
• d3.tsvFormat - formata a matriz de objetos fornecida como TSV.
• d3.tsvFormatBody - formata a matriz de objetos fornecida como TSV.
• d3.tsvFormatRows - formata a matriz de linhas fornecida como TSV.
• d3.tsvFormatRow - formata a linha fornecida como TSV.
• d3.tsvFormatValue - formata o valor fornecido como TSV.
• d3.dsvFormat - cria um novo analisador e formatador para o delimitador fornecido.
• dsv.parse - analisa a string fornecida, retornando uma matriz de objetos.
• dsv.parseRows - analisa a string fornecida, retornando uma matriz de linhas.
• dsv.format - formata a matriz de objetos fornecida.
• dsv.formatBody - formata a matriz de objetos fornecida.
• dsv.formatRows - formata a matriz de linhas fornecida.
• dsv.formatRow - formata a linha fornecida.
• dsv.formatValue - formata o valor fornecido.
• d3.autoType - infere automaticamente tipos de valor para o objeto fornecido.

Easings (d3-ease)

Easing funções para animação suave.

• ease - facilita o tempo normalizado fornecido.
• d3.easeLinear - atenuação linear; a função identidade.
• d3.easePolyIn - atenuação polinomial; eleva o tempo à potência dada.
• d3.easePolyOut - atenuação polinomial reversa.
• d3.easePoly - um alias para easyPolyInOut.
• d3.easePolyInOut - atenuação polinomial simétrica.
• poly.exponent - especifique o expoente polinomial.
• d3.easeQuadIn - atenuação quadrática; tempo de quadrados.
• d3.easeQuadOut - easing quadrático reverso.
• d3.easeQuad - um alias paraeasyQuadInOut.
• d3.easeQuadInOut - atenuação quadrática simétrica.
• d3.easeCubicIn - atenuação cúbica; tempo de cubos.
• d3.easeCubicOut - atenuação cúbica reversa.
• d3.easeCubic - um alias paraeasyCubicInOut.
• d3.easeCubicInOut - atenuação cúbica simétrica.
• d3.easeSinIn - atenuação senoidal.
• d3.easeSinOut - easing senoidal reverso.
• d3.easeSin - um apelido para easySinInOut.
• d3.easeSinInOut - atenuação senoidal simétrica.
• d3.easeExpIn - atenuação exponencial.
• d3.easeExpOut - atenuação exponencial reversa.
• d3.easeExp - um alias para easyExpInOut.
• d3.easeExpInOut - atenuação exponencial simétrica.
• d3.easeCircleIn - atenuação circular.
• d3.easeCircleOut - easing circular reverso.
• d3.easeCircle - um alias paraeasyCircleInOut.
• d3.easeCircleInOut - atenuação circular simétrica.
• d3.easeElasticIn - flexibilização elástica, como um elástico.
• d3.easeElastic - um alias para easeElasticOut.
• d3.easeElasticOut - easing elástico reverso.
• d3.easeElasticInOut - atenuação elástica simétrica.
• elastic.amplitude - especifique a amplitude elástica.
• elastic.period - especifique o período elástico.
• d3.easeBackIn - easing antecipatório, como um dançarino dobrando os joelhos antes de pular.
• d3.easeBackOut - easing antecipatório reverso.
• d3.easeBack - um alias para easyBackInOut.
• d3.easeBackInOut - easing antecipatório simétrico.
• back.overshoot - especifique a quantidade de overshoot.
• d3.easeBounceIn - bounce easing, como uma bola de borracha.
• d3.easeBounce - um alias paraeasyBounceOut.
• d3.easeBounceOut - suavização de rejeição reversa.
• d3.easeBounceInOut - atenuação de salto simétrico.

Fetches (d3-fetch)

Métodos de conveniência no topo da API Fetch.

• d3.blob - obtenha um arquivo como um blob.
• d3.buffer - obtém um arquivo como um buffer de matriz.
• d3.csv - obtenha um arquivo de valores separados por vírgula (CSV).
• d3.dsv - obtenha um arquivo de valores separados por delimitador (CSV).
• d3.html - obtenha um arquivo HTML.
• d3.image - obtenha uma imagem.
• d3.json - obtenha um arquivo JSON.
• d3.svg - obtenha um arquivo SVG.
• d3.text - obtenha um arquivo de texto simples.
• d3.tsv - obtenha um arquivo de valores separados por tabulações (TSV).
• d3.xml - obtenha um arquivo XML.

Forças (d3-force)

Layout de gráfico direcionado por força usando a integração Verlet de velocidade.

• d3.forceSimulation - crie uma nova simulação de força.
• simulation.restart - reaqueça e reinicie o cronômetro da simulação.
• simulation.stop - pare o cronômetro da simulação.
• simulação.tick - avance a simulação um passo.
• simulação.nodes - defina os nós da simulação.
• simulação.alpha - defina o alfa atual.
• simulation.alphaMin - defina o limite alfa mínimo.
• simulation.alphaDecay - defina a taxa de decaimento exponencial alfa.
• simulation.alphaTarget - defina o alfa alvo.
• simulation.velocityDecay - defina a taxa de decaimento da velocidade.
• simulation.force - adicionar ou remover um force.
• simulation.find - encontre o nó mais próximo da posição especificada.
• simulation.randomSource - defina a fonte aleatória da simulação.
• simulation.on - adicionar ou remover um ouvinte de evento.
• force - aplique a força.
• force.initialize - inicialize a força com os nós fornecidos.
• d3.forceCenter - cria uma força centralizadora.
• center.x - defina a coordenada x do centro.
• center.y - defina a coordenada y do centro.
• center.strength - defina a intensidade da força de centralização.
• d3.forceCollide - cria uma força de colisão circular.
• collide.radius - defina o raio do círculo.
• collide.strength - defina a intensidade da resolução de colisão.
• collide.iterations - defina o número de iterações.
• d3.forceLink - cria uma força de link.
• link.links - defina a matriz de links.
• link.id - vincula nós por índice numérico ou identificador de string.
• link.distance - defina a distância do link.
• link.strength - defina a força do link.
• link.iterations - defina o número de iterações.
• d3.forceManyBody - crie uma força de muitos corpos.
• manyBody.strength - defina a intensidade da força.
• manyBody.theta - define a precisão da aproximação Barnes–Hut.
• manyBody.distanceMin - limita a força quando os nós estão próximos.
• manyBody.distanceMax - limita a força quando os nós estão distantes.
• d3.forceX - crie uma força de posicionamento x.
• x.strength - defina a intensidade da força.
• x.x - defina a coordenada x de destino.
• d3.forceY - crie uma força de posicionamento y.
• y.strength - defina a intensidade da força.
• y.y - defina a coordenada y de destino.
• d3.forceRadial - cria uma força de posicionamento radial.
• radial.strength - defina a intensidade da força.
• radial.radius - defina o raio alvo.
• radial.x - defina a coordenada x do centro do alvo.
• radial.y - defina a coordenada y do centro do alvo.

Formatos numéricos (d3-format)

Formatar números para consumo humano.

• d3.format - alias para locale.format na localidade padrão.
• d3.formatPrefix - alias para locale.formatPrefix na localidade padrão.
• locale.format - cria um formato numérico.
• locale.formatPrefix - cria um formato de número de prefixo SI.
• d3.formatSpecifier - analisa um especificador de formato numérico.
• novo d3.FormatSpecifier - aumenta um objeto especificador de formato numérico.
• d3.precisionFixed - calcula precisão decimal para notação de ponto fixo.
• d3.precisionPrefix - calcula a precisão decimal para notação de prefixo SI.
• d3.precisionRound - calcula dígitos significativos para notação arredondada.
• d3.formatLocale - defina uma localidade personalizada.
• d3.formatDefaultLocale - define a localidade padrão.

Geografias (d3-geo)

Projeções geográficas, formas e matemática.

Paths

• d3.geoPath - crie um novo gerador de caminho geográfico.
• path - projeta e renderiza o recurso especificado.
• path.area - calcula a área planar projetada de um determinado recurso.
• path.bounds - calcula a caixa delimitadora planar projetada de um determinado recurso.
• path.centroid - calcula o centróide planar projetado de um determinado recurso.
• path.measure - calcula o comprimento planar projetado de um determinado recurso.
• path.projection - defina a projeção geográfica.
• path.context - defina o contexto de renderização.
• path.digits - defina a precisão de saída.
• path.pointRadius - defina o raio para exibir recursos de ponto.

Projeções

• projection - projeta o ponto especificado da esfera para o plano.

• projection.invert - desprojeta o ponto especificado do plano para a esfera.

• projection.stream - envolve o fluxo especificado na geometria do projeto.

• projection.preclip - defina a função de recorte esférico da projeção.

• projection.postclip - defina a função de recorte cartesiano da projeção.

• projection.clipAngle - defina o raio do círculo do clipe.

• projection.clipExtent - defina a extensão do clipe da viewport, em pixels.

• projection.scale - defina o fator de escala.

• projection.translate - defina o deslocamento da tradução.

• projection.center - defina o ponto central.

• projection.angle - defina a rotação pós-projeção.

• projection.reflectX - reflete a dimensão x.

• projection.reflectY - reflete a dimensão y.

• projection.rotate - defina os ângulos de rotação esférica de três eixos.

• projection.precision - defina o limite de precisão para amostragem adaptativa.

• projection.fitExtent - defina a escala e traduza para caber em um objeto GeoJSON.

• projection.fitSize - defina a escala e traduza para caber em um objeto GeoJSON.

• projection.fitWidth - defina a escala e traduza para ajustar um objeto GeoJSON.

• projection.fitHeight - defina a escala e traduza para caber em um objeto GeoJSON.

• d3.geoAzimuthalEqualArea - a projeção azimutal de área igual.

• d3.geoAzimuthalEqualAreaRaw - a projeção de área igual azimutal bruta.

• d3.geoAzimuthalEquidistant - a projeção equidistante azimutal.

• d3.geoAzimuthalEquidistantRaw - a projeção equidistante azimutal bruta.

• d3.geoGnomonic - a projeção gnomônica.

• d3.geoGnomonicRaw - a projeção gnomônica bruta.

• d3.geoOrthographic - a projeção ortográfica azimutal.

• d3.geoOrthographicRaw - a projeção ortográfica azimutal bruta.

• d3.geoStereographic - a projeção estereográfica azimutal.

• d3.geoStereographicRaw - a projeção estereográfica azimutal bruta.

• d3.geoEqualEarth - a projeção Equal Earth.

• d3.geoEqualEarthRaw - a projeção Equal Earth bruta.

• d3.geoAlbersUsa - uma projeção composta de Albers para os Estados Unidos.

• conic.parallels - defina os dois paralelos padrão.

• d3.geoAlbers - a projeção cônica de área igual de Albers.

• d3.geoConicConformal - a projeção conforme cônica.

• d3.geoConicConformalRaw - a projeção conformal cônica bruta.

• d3.geoConicEqualArea - a projeção cônica de área igual (Albers).

• d3.geoConicEqualAreaRaw - a projeção de área igual cônica bruta (Albers).

• d3.geoConicEquidistant - a projeção cônica equidistante.

• d3.geoConicEquidistantRaw - a projeção equidistante cônica bruta.

• d3.geoEquirectangular - a projeção equirectangular (plate carreé).

• d3.geoEquirectangularRaw - a projeção equirectangular bruta (plate carreé).

• d3.geoMercator - a projeção esférica de Mercator.

• d3.geoMercatorRaw - a projeção bruta de Mercator.

• d3.geoTransverseMercator - a projeção esférica transversal de Mercator.

• d3.geoTransverseMercatorRaw - a projeção esférica transversa bruta de Mercator.

• d3.geoNaturalEarth1 - a projeção Equal Earth, versão 1.

• d3.geoNaturalEarth1Raw - a projeção bruta Equal Earth, versão 1

Projeções brutas

• project - projeta o ponto especificado da esfera para o plano.
• project.invert - desprojeta o ponto especificado do plano para a esfera.
• d3.geoProjection - crie uma projeção personalizada.
• d3.geoProjectionMutator - crie uma projeção configurável personalizada.

Esférica matemática

• d3.geoArea - calcula a área esférica de um determinado recurso.
• d3.geoBounds - calcula a caixa delimitadora de latitude-longitude para um determinado recurso.
• d3.geoCentroid - calcula o centróide esférico de um determinado recurso.
• d3.geoDistance - calcula a distância do grande arco entre dois pontos.
• d3.geoLength - calcula o comprimento de uma string de linha ou o perímetro de um polígono.
• d3.geoInterpolate - interpolar entre dois pontos ao longo de um grande arco.
• d3.geoContains - teste se um ponto está dentro de um determinado recurso.
• d3.geoRotation - cria uma função de rotação para os ângulos especificados.
• rotation - gire o ponto dado ao redor da esfera.
• rotation.invert - desgirar o ponto dado ao redor da esfera.

Formas Esféricas

• d3.geoCircle - crie um gerador de círculos.
• círculo - gera um círculo por partes como um polígono.
• circle.center - especifique o centro do círculo em latitude e longitude.
• circle.radius - especifique o raio angular em graus.
• circle.precision - especifique a precisão do círculo por partes.
• d3.geoGraticule - crie um gerador de gratícula.
• graticule - gera uma MultiLineString de meridianos e paralelos.
• graticule.lines - gera uma matriz de LineStrings de meridianos e paralelos.
• graticule.outline - gera um Polígono da extensão da gratícula.
• graticule.extent - obter ou definir as extensões principais e secundárias.
• graticule.extentMajor - obtenha ou defina a extensão principal.
• graticule.extentMinor - obtenha ou defina a extensão menor.
• graticule.step - obter ou definir os intervalos de passo maior e menor.
• graticule.stepMajor - obtenha ou defina os principais intervalos de passos.
• graticule.stepMinor - obtenha ou defina os intervalos de passo menores.
• graticule.precision - obtenha ou defina a precisão latitudinal.
• d3.geoGraticule10 - gera a gratícula global padrão de 10°.

Streams

• d3.geoStream - converte um objeto GeoJSON em um fluxo de geometria.
• stream.point - indica um ponto com as coordenadas especificadas.
• stream.lineStart - indica o início de uma linha ou anel.
• stream.lineEnd - indica o fim de uma linha ou anel.
• stream.polygonStart - indica o início de um polígono.
• stream.polygonEnd - indica o fim de um polígono.
• stream.sphere - indica a esfera.

Transformações

• d3.geoTransform - defina uma transformação de geometria personalizada.
• d3.geoIdentity - dimensionar, traduzir ou recortar geometria planar.

Recorte

• preclip - pré-clipping em coordenadas geográficas.
• postclip - pós-clipping em coordenadas planares.
• d3.geoClipAntimeridian - corta geometrias esféricas que cruzam o antimeridiano.
• d3.geoClipCircle - recorta geometrias esféricas em um pequeno círculo.
• d3.geoClipRectangle - recorta geometrias planas em uma viewport retangular.

Hierarquias (d3-hierarchy)

Algoritmos de layout para visualização de dados hierárquicos.

• d3.hierarchy - constrói um nó raiz a partir de dados hierárquicos.
• node.ancestors - gera uma matriz de ancestrais.
• node.descendants - gera uma matriz de descendentes.
• node.leaves - gera um array de folhas.
• node.find - encontre um nó na hierarquia.
• node.path - gera o caminho mais curto para outro nó.
• node.links - gera uma matriz de links.
• node.sum - avalia e agrega valores quantitativos.
• node.count - conte o número de folhas.
• node.sort - classifica todos os irmãos descendentes.
• node[Symbol.iterator] - iterar em uma hierarquia.
• node.each - travessia em largura.
• node.eachAfter - travessia pós-ordem.
• node.eachBefore - travessia de pré-encomenda.
• node.copy - copia uma hierarquia.
• d3.stratify - cria um novo operador stratify.
• stratify - construa um nó raiz a partir de dados tabulares.
• stratify.id - defina o acessador de id do nó.
• stratify.parentId - defina o acessador de id do nó pai.
• stratify.path - defina o acessador de caminho.
• d3.cluster - crie um novo layout de cluster (dendrograma).
• cluster - layout da hierarquia especificada em um dendrograma.
• cluster.size - defina o tamanho do layout.
• cluster.nodeSize - defina o tamanho do nó.
• cluster.separation - define a separação entre as folhas.
• d3.tree - crie um novo layout de árvore organizada.
• tree - layout da hierarquia especificada em uma árvore organizada.
• tree.size - defina o tamanho do layout.
• tree.nodeSize - defina o tamanho do nó.
• tree.separation - defina a separação entre os nós.
• d3.treemap - crie um novo layout de mapa de árvore.
• treemap - layout da hierarquia especificada como um mapa de árvore.
• treemap.tile - defina o método de mosaico.
• treemap.size - defina o tamanho do layout.
• treemap.round - define se as coordenadas de saída são arredondadas.
• treemap.padding - defina o preenchimento.
• treemap.paddingInner - defina o preenchimento entre irmãos.
• treemap.paddingOuter - defina o preenchimento entre pai e filhos.
• treemap.paddingTop - defina o preenchimento entre a borda superior do pai e os filhos.
• treemap.paddingRight - defina o preenchimento entre a borda direita do pai e os filhos.
• treemap.paddingBottom - defina o preenchimento entre a borda inferior do pai e os filhos.
• treemap.paddingLeft - defina o preenchimento entre a borda esquerda do pai e os filhos.
• d3.treemapBinary - lado a lado usando uma árvore binária balanceada.
• d3.treemapDice - lado a lado em uma linha horizontal.
• d3.treemapSlice - lado a lado em uma coluna vertical.
• d3.treemapSliceDice - alterne entre cortar e cortar.
• d3.treemapSquarify - lado a lado usando linhas quadradas por Bruls et. al.
• d3.treemapResquarify - como d3.treemapSquarify, mas executa atualizações estáveis.
• squarify.ratio - defina a proporção do retângulo desejado.
• d3.partition - crie um novo layout de partição (pingente de gelo ou sunburst).
• partition - layout da hierarquia especificada como um diagrama de partição.
• partition.size - defina o tamanho do layout.
• partition.round - define se as coordenadas de saída são arredondadas.
• partition.padding - defina o preenchimento.
• d3.pack - crie um novo layout de empacotamento circular.
• pack - faça o layout da hierarquia especificada usando o empacotamento circular.
• pack.radius - defina o acessor radius.
• pack.size - defina o tamanho do layout.
• pack.padding - defina o preenchimento.
• d3.packSiblings - empacota a matriz especificada de círculos.
• d3.packEnclose - coloque a matriz especificada de círculos.

Interpoladores (d3-interpolate)

Interpole números, cores, strings, arrays, objetos, o que for!

• d3.interpolate - interpola valores arbitrários.
• d3.interpolateNumber - interpolar números.
• d3.interpolateRound - interpolar inteiros.
• d3.interpolateString - interpola strings com números embutidos.
• d3.interpolateDate - interpolar datas.
• d3.interpolateArray - interpola matrizes de valores arbitrários.
• d3.interpolateNumberArray - interpola matrizes de números.
• d3.interpolateObject - interpolar objetos arbitrários.
• d3.interpolateTransformCss - interpola transformações CSS 2D.
• d3.interpolateTransformSvg - interpola transformações 2D SVG.
• d3.interpolateZoom - zoom e panorâmica entre duas visualizações.
• interpolateZoom.rho - defina a curvatura rho do interpolador de zoom.
• d3.interpolateDiscrete - gera um interpolador discreto a partir de um conjunto de valores.
• d3.quantize - gera amostras com espaçamento uniforme a partir de um interpolador.
• d3.interpolateRgb - interpolar cores RGB.
• d3.interpolateRgbBasis - gera um B-spline através de um conjunto de cores.
• d3.interpolateRgbBasisClosed - gera um B-spline fechado por meio de um conjunto de cores.
• d3.interpolateHsl - interpolar cores HSL.
• d3.interpolateHslLong - interpolar cores HSL, o caminho mais longo.
• d3.interpolateLab - interpola as cores do Lab.
• d3.interpolateHcl - interpolar cores HCL.
• d3.interpolateHclLong - interpolar cores HCL, o caminho mais longo.
• d3.interpolateCubehelix - interpolar cores Cubehelix.
• d3.interpolateCubehelixLong - interpolar cores Cubehelix, o caminho mais longo.
• interpolate.gamma - aplique correção de gama durante a interpolação.
• d3.interpolateHue - interpola um ângulo de tonalidade.
• d3.interpolateBasis - gera um B-spline por meio de um conjunto de valores.
• d3.interpolateBasisClosed - gera um B-spline fechado por meio de um conjunto de valores.
• d3.piecewise - gera um interpolador linear por partes a partir de um conjunto de valores.

Paths (d3-path)

Serialize comandos de caminho do Canvas para SVG.

• d3.path - crie um novo serializador de caminho.
• path.moveTo - move para o ponto especificado.
• path.closePath - fecha o subcaminho atual.
• path.lineTo - desenha um segmento de linha reta.
• path.quadraticCurveTo - desenha um segmento Bézier quadrático.
• path.bezierCurveTo - desenha um segmento cúbico de Bézier.
• path.arcTo - desenha um segmento de arco circular.
• path.arc - desenha um segmento de arco circular.
• path.rect - desenha um retângulo.
• path.digits - defina a precisão de saída.
• path.toString - serializar para uma string de dados de caminho SVG.

Poligonos (d3-polygon)

Operações geométricas para polígonos bidimensionais.

• d3.polygonArea - calcula a área do polígono fornecido.
• d3.polygonCentroid - calcula o centróide do polígono fornecido.
• d3.polygonHull - calcula a cobertura convexa dos pontos dados.
• d3.polygonContains - testa se um ponto está dentro de um polígono.
• d3.polygonLength - calcula o comprimento do perímetro do polígono fornecido.

Quadtrees (d3-quadtree)

Subdivisão espacial recursiva bidimensional.

• d3.quadtree - cria uma nova quadtree vazia.
• quadtree.x - defina o acessador x.
• quadtree.y - defina o acessador y.
• quadtree.extent - estenda a quadtree para cobrir uma extensão.
• quadtree.cover - estenda a quadtree para cobrir um ponto.
• quadtree.add - adiciona um dado a uma quadtree.
• quadtree.addAll - adiciona uma matriz de dados a uma quadtree.
• quadtree.remove - remove um dado de uma quadtree.
• quadtree.removeAll - remove uma matriz de dados de uma quadtree.
• quadtree.copy - cria uma cópia de um quadtree.
• quadtree.root - obtenha o nó raiz do quadtree.
• quadtree.data - recupera todos os dados do quadtree.
• quadtree.size - conte o número de dados na quadtree.
• quadtree.find - encontre rapidamente o datum mais próximo em uma quadtree.
• quadtree.visit - visita seletivamente nós em uma quadtree.
• quadtree.visitAfter - visite todos os nós em uma quadtree.

Números aleatórios (d3-random)

Gere números aleatórios de várias distribuições.

• d3.randomUniform - de uma distribuição uniforme.
• d3.randomInt - de uma distribuição inteira uniforme.
• d3.randomNormal - de uma distribuição normal.
• d3.randomLogNormal - de uma distribuição log-normal.
• d3.randomBates - de uma distribuição Bates.
• d3.randomIrwinHall - de uma distribuição Irwin–Hall.
• d3.randomExponential - de uma distribuição exponencial.
• d3.randomPareto - de uma distribuição de Pareto.
• d3.randomBernoulli - de uma distribuição de Bernoulli.
• d3.randomGeometric - de uma distribuição geométrica.
• d3.randomBinomial - de uma distribuição binomial.
• d3.randomGamma - de uma distribuição gama.
• d3.randomBeta - de uma distribuição beta.
• d3.randomWeibull - de uma distribuição Weibull, Gumbel ou Fréchet.
• d3.randomCauchy - de uma distribuição Cauchy.
• d3.randomLogistic - de uma distribuição logística.
• d3.randomPoisson - de uma distribuição de Poisson.
• random.source - defina a fonte de aleatoriedade.
• d3.randomLcg - um gerador de números pseudoaleatórios semeados.

Escalas (d3-scale)

Codificações que mapeiam dados abstratos para representação visual.

Escalas Contínuas

Mapeie um domínio quantitativo contínuo para um intervalo contínuo.

• contínuo - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• continuous.invert - calcula o valor do domínio correspondente a um determinado valor de intervalo.
• continuous.domain - defina o domínio de entrada.
• continuous.range - defina o intervalo de saída.
• continuous.rangeRound - defina o intervalo de saída e ative o arredondamento.
• contínuo.clamp - habilita a fixação ao domínio ou intervalo.
• continuous.unknown - defina o valor de saída para entradas desconhecidas.
• continuous.interpolate - defina o interpolador de saída.
• continuous.ticks - calcula valores representativos do domínio.
• contínuo.tickFormat - formata ticks para consumo humano.
• contínuo.nice - estenda o domínio para bons números redondos.
• continuous.copy - crie uma cópia desta escala.
• d3.tickFormat - formata ticks para consumo humano.
• d3.scaleLinear - cria uma escala linear quantitativa.
• d3.scalePow - crie uma escala de potência quantitativa.
• pow - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• pow.invert - calcula o valor do domínio correspondente a um determinado valor de intervalo.
• pow.exponent - defina o expoente de potência.
• pow.domain - defina o domínio de entrada.
• pow.range - defina o intervalo de saída.
• pow.rangeRound - defina o intervalo de saída e ative o arredondamento.
• pow.clamp - permite a fixação no domínio ou intervalo.
• pow.interpolate - defina o interpolador de saída.
• pow.ticks - calcula valores representativos do domínio.
• pow.tickFormat - formata ticks para consumo humano.
• pow.nice - estenda o domínio para bons números redondos.
• pow.copy - crie uma cópia desta escala.
• d3.scaleSqrt - crie uma escala de potência quantitativa com expoente 0,5.
• d3.scaleLog - crie uma escala logarítmica quantitativa.
• log - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• log.invert - calcula o valor do domínio correspondente a um determinado valor de intervalo.
• log.base - defina a base logarítmica.
• log.domain - defina o domínio de entrada.
• log.range - defina o intervalo de saída.
• log.rangeRound - defina o intervalo de saída e ative o arredondamento.
• log.clamp - habilita a fixação ao domínio ou intervalo.
• log.interpolate - defina o interpolador de saída.
• log.ticks - calcula valores representativos do domínio.
• log.tickFormat - formata ticks para consumo humano.
• [log.nice](https://github.

Escalas sequenciais

Mapeie um domínio quantitativo contínuo para um interpolador fixo contínuo.

• d3.scaleSequential - cria uma escala sequencial.
• sequential - calcula o valor do intervalo correspondente a um valor de entrada.
• sequential.domain - defina o domínio de entrada.
• sequential.clamp - ativa a fixação no domínio.
• sequential.interpolator - defina o interpolador de saída da balança.
• sequential.range - defina o intervalo de saída.
• sequential.rangeRound - defina o intervalo de saída e ative o arredondamento.
• sequential.copy - crie uma cópia desta escala.
• d3.scaleSequentialLog - cria uma escala sequencial logarítmica.
• d3.scaleSequentialPow - crie uma escala sequencial de potência.
• d3.scaleSequentialSqrt - crie uma escala sequencial de potência com expoente 0,5.
• d3.scaleSequentialSymlog - cria uma escala sequencial logarítmica simétrica.
• d3.scaleSequentialQuantile - crie uma escala sequencial usando uma transformação p-quantil.
• sequentialQuantile.quantiles - retorna os quantis da escala.

Escalas Divergentes

Mapeie um domínio quantitativo contínuo para um interpolador fixo contínuo.

• d3.scaleDiverging - cria uma escala divergente.
• diverging - calcula o valor do intervalo correspondente a um valor de entrada.
• diverging.domain - defina o domínio de entrada.
• diverging.clamp - permite a fixação no domínio ou intervalo.
• diverging.interpolator - defina o interpolador de saída da escala.
• diverging.range - defina o intervalo de saída.
• diverging.rangeRound - defina o intervalo de saída e ative o arredondamento.
• diverging.copy - crie uma cópia desta escala.
• diverging.unknown - defina o valor de saída para entradas desconhecidas.
• d3.scaleDivergingLog - cria uma escala logarítmica divergente.
• d3.scaleDivergingPow - cria uma escala de potência divergente.
• d3.scaleDivergingSqrt - crie uma escala de potência divergente com expoente 0,5.
• d3.scaleDivergingSymlog - cria uma escala logarítmica simétrica divergente.

Escalas de quantização

Mapeie um domínio quantitativo contínuo para um intervalo discreto.

• d3.scaleQuantize - cria uma escala linear de quantização uniforme.
• quantize - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• quantize.invertExtent - calcula os valores de domínio correspondentes a um determinado valor de intervalo.
• quantize.domain - defina o domínio de entrada.
• quantize.range - defina o intervalo de saída.
• quantize.ticks - calcula valores representativos do domínio.
• quantize.tickFormat - formata ticks para consumo humano.
• quantize.nice - estenda o domínio para bons números redondos.
• quantize.thresholds - retorna a matriz de limites calculados dentro do domínio.
• quantize.copy - crie uma cópia desta escala.
• d3.scaleQuantile - cria uma escala linear de quantização quantílica.
• quantile - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• quantile.invertExtent - calcula os valores de domínio correspondentes a um determinado valor de intervalo.
• quantile.domain - defina o domínio de entrada.
• quantile.range - defina o intervalo de saída.
• quantile.quantiles - obtenha os limites de quantil.
• quantile.copy - crie uma cópia desta escala.
• d3.scaleThreshold - cria uma escala linear de quantização arbitrária.
• threshold - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• threshold.invertExtent - calcula os valores de domínio correspondentes a um determinado valor de intervalo.
• threshold.domain - defina o domínio de entrada.
• threshold.range - defina o intervalo de saída.
• threshold.copy - crie uma cópia desta escala.

Escalas Ordinais

Mapeie um domínio discreto para um intervalo discreto.

• d3.scaleOrdinal - cria uma escala ordinal.
• ordinal - calcula o valor do intervalo correspondente a um determinado valor de domínio.
• ordinal.domain - defina o domínio de entrada.
• ordinal.range - defina o intervalo de saída.
• ordinal.unknown - defina o valor de saída para entradas desconhecidas.
• ordinal.copy - crie uma cópia desta escala.
• d3.scaleImplicit - um valor desconhecido especial para domínios implícitos.
• d3.scaleBand - cria uma escala de banda ordinal.
• band - calcula o início da banda correspondente a um determinado valor de domínio.
• band.domain - defina o domínio de entrada.
• band.range - defina o intervalo de saída.
• band.rangeRound - defina o intervalo de saída e ative o arredondamento.
• band.round - ativa o arredondamento.
• band.paddingInner - define o preenchimento entre as bandas.
• band.paddingOuter - define o preenchimento fora da primeira e última bandas.
• band.padding - define o preenchimento fora e entre as bandas.
• band.align - defina o alinhamento da banda, se houver espaço extra.
• band.bandwidth - obtém a largura de cada banda.
• band.step - obtenha a distância entre os inícios de bandas adjacentes.
• band.copy - crie uma cópia desta escala.
• d3.scalePoint - cria uma escala de ponto ordinal.
• point - calcula o ponto correspondente a um determinado valor de domínio.
• point.domain - defina o domínio de entrada.
• point.range - defina o intervalo de saída.
• point.rangeRound - defina o intervalo de saída e ative o arredondamento.
• point.round - ativa o arredondamento.
• point.padding - define o preenchimento fora do primeiro e do último ponto.
• point.align - defina o alinhamento do ponto, se houver espaço extra.
• point.bandwidth - retorna zero.
• point.step - obtém a distância entre o início de pontos adjacentes.
• point.copy - crie uma cópia desta escala.

Seleções (d3-selection)

Transforme o DOM selecionando elementos e juntando-se aos dados.

Selecionando Elementos

• d3.selection - select the root document element.
• d3.select - select an element from the document.
• d3.selectAll - select multiple elements from the document.
• selection.select - select a descendant element for each selected element.
• selection.selectAll - select multiple descendants for each selected element.
• selection.filter - filter elements based on data.
• selection.merge - merge this selection with another.
• selection.selectChild - select a child element for each selected element.
• selection.selectChildren - select the children elements for each selected element.
• selection.selection - return the selection.
• d3.matcher - test whether an element matches a selector.
• d3.selector - select an element.
• d3.selectorAll - select elements.
• d3.window - get a node’s owner window.
• d3.style - get a node’s current style value.

Modificando Elementos

• selection.attr - obter ou definir um atributo.
• selection.classed - obter, adicionar ou remover classes CSS.
• selection.style - obtenha ou defina uma propriedade de estilo.
• selection.property - obtenha ou defina uma propriedade (bruta).
• selection.text - obtenha ou defina o conteúdo do texto.
• selection.html - obtenha ou defina o HTML interno.
• selection.append - criar, anexar e selecionar novos elementos.
• selection.insert - criar, inserir e selecionar novos elementos.
• selection.remove - remove elementos do documento.
• selection.clone - insere clones de elementos selecionados.
• selection.sort - classifica os elementos no documento com base nos dados.
• selection.order - reordena elementos no documento para corresponder à seleção.
• selection.raise - reordena cada elemento como o último filho de seu pai.
• selection.lower - reordena cada elemento como o primeiro filho de seu pai.
• d3.create - cria e seleciona um elemento separado.
• d3.creator - cria um elemento por nome.

Junção de Dados

• selection.data - bind elements to data.
• selection.join - enter, update or exit elements based on data.
• selection.enter - get the enter selection (data missing elements).
• selection.exit - get the exit selection (elements missing data).
• selection.datum - get or set element data (without joining).

Manipulando Eventos

• selection.on - add or remove event listeners.
• selection.dispatch - dispatch a custom event.
• d3.pointer - get the pointer’s position of an event.
• d3.pointers - get the pointers’ positions of an event.

Controle de fluxo

• selection.each - call a function for each element.
• selection.call - call a function with this selection.
• selection.empty - returns true if this selection is empty.
• selection.nodes - returns an array of all selected elements.
• selection.node - returns the first (non-null) element.
• selection.size - returns the count of elements.
• selection[Symbol.iterator] - iterate over the selection’s nodes.

Variáveis locais

• d3.local - declares a new local variable.
• local.set - set a local variable’s value.
• local.get - get a local variable’s value.
• local.remove - delete a local variable.
• local.toString - get the property identifier of a local variable.

Namespaces

• d3.namespace - qualify a prefixed XML name, such as “xlink:href”.
• d3.namespaces - the built-in XML namespaces.

Formas (d3-shape)

Primitivas gráficas para visualização.

Arcos

Setores circulares ou anulares, como em um gráfico de pizza ou rosca.

• d3.arc - crie um novo gerador de arco.
• arc - gera um arco para o datum fornecido.
• arc.centroid - calcula o ponto médio de um arco.
• arc.innerRadius - defina o raio interno.
• arc.outerRadius - defina o raio externo.
• arc.cornerRadius - defina o raio do canto, para cantos arredondados.
• arc.startAngle - defina o ângulo inicial.
• arc.endAngle - defina o ângulo final.
• arc.padAngle - defina o ângulo entre arcos adjacentes, para arcos preenchidos.
• arc.padRadius - defina o raio no qual linearizar o preenchimento.
• arc.context - defina o contexto de renderização.
• arc.digits - defina a precisão de saída.

Tortas

Calcule os ângulos necessários para representar um conjunto de dados tabular como um gráfico de pizza ou rosca.

• d3.pie - crie um novo gerador de pizza.
• pie - calcule os ângulos do arco para o conjunto de dados fornecido.
• pie.value - defina o acessador de valor.
• pie.sort - defina o comparador de ordem de classificação.
• pie.sortValues - defina o comparador de ordem de classificação.
• pie.startAngle - defina o ângulo inicial geral.
• pie.endAngle - defina o ângulo final geral.
• pie.padAngle - defina o ângulo do pad entre arcos adjacentes.

Linhas

Uma spline ou polilinha, como em um gráfico de linha.

• d3.line - crie um novo gerador de linha.
• line - gera uma linha para o conjunto de dados fornecido.
• line.x - defina o acessador x.
• line.y - defina o acessador y.
• line.defined - defina o acessador definido.
• line.curve - defina o interpolador de curva.
• line.context - defina o contexto de renderização.
• line.digits - defina a precisão de saída.
• d3.lineRadial - crie um novo gerador de linha radial.
• lineRadial - gera uma linha para o conjunto de dados fornecido.
• lineRadial.angle - defina o acessador de ângulo.
• lineRadial.radius - defina o acessor radius.
• lineRadial.defined - define o acessador definido.
• lineRadial.curve - define o interpolador de curva.
• lineRadial.context - defina o contexto de renderização.
• lineRadial.digits - defina a precisão de saída.

Áreas

Uma área, definida por uma linha superior e uma linha de base delimitadoras, como em um gráfico de área.

• d3.area - crie um novo gerador de área.
• area - gera uma área para o conjunto de dados fornecido.
• area.x - defina os acessadores x0 e x1.
• area.x0 - defina o acessador x da linha de base.
• area.x1 - define o acessador x da linha superior.
• area.y - defina os acessadores y0 e y1.
• area.y0 - defina o acessador y da linha de base.
• area.y1 - define o acessador y da linha superior.
• area.defined - defina o acessador definido.
• area.curve - defina o interpolador de curva.
• area.context - defina o contexto de renderização.
• area.digits - defina a precisão de saída.
• area.lineX0 - deriva uma linha para a borda esquerda de uma área.
• area.lineY0 - deriva uma linha para a borda superior de uma área.
• area.lineX1 - deriva uma linha para a borda direita de uma área.
• area.lineY1 - deriva uma linha para a borda inferior de uma área.
• d3.areaRadial - crie um novo gerador de área radial.
• areaRadial - gera uma área para o conjunto de dados fornecido.
• areaRadial.angle - defina os acessadores de ângulo inicial e final.
• areaRadial.startAngle - defina o acessador de ângulo inicial.
• areaRadial.endAngle - defina o acessador de ângulo final.
• areaRadial.radius - defina os acessadores de raio interno e externo.
• areaRadial.innerRadius - defina o acessador de raio interno.
• areaRadial.outerRadius - defina o acessador de raio externo.
• areaRadial.defined - defina o acessador definido.
• areaRadial.curve - define o interpolador de curva.
• areaRadial.context - defina o contexto de renderização.
• areaRadial.digits - defina a precisão de saída.
• areaRadial.lineStartAngle - deriva uma linha para a borda inicial de uma área.
• areaRadial.lineInnerRadius - deriva uma linha para a borda interna de uma área.
• areaRadial.lineEndAngle - deriva uma linha para a borda final de uma área.
• areaRadial.lineOuterRadius - deriva uma linha para a borda externa de uma área.

Curvas

Interpolar entre pontos para produzir uma forma contínua.

• d3.curveBasis - uma spline de base cúbica, repetindo os pontos finais.
• d3.curveBasisClosed - uma spline de base cúbica fechada.
• d3.curveBasisOpen - uma spline de base cúbica.
• d3.curveBundle - uma spline de base cúbica endireitada.
• bundle.beta - defina a tensão do pacote beta.
• d3.curveBumpX - uma spline Bézier cúbica com tangentes horizontais.
• d3.curveBumpY - uma spline Bézier cúbica com tangentes verticais.
• d3.curveCardinal - uma spline cardinal cúbica, com diferença unilateral em cada extremidade.
• d3.curveCardinalClosed - uma spline cardinal cúbica fechada.
• d3.curveCardinalOpen - uma spline cardinal cúbica.
• cardinal.tension - defina a tensão do spline cardinal.
• d3.curveCatmullRom - uma spline Catmull–Rom cúbica, com diferença unilateral em cada extremidade.
• d3.curveCatmullRomClosed - uma spline Catmull–Rom cúbica fechada.
• d3.curveCatmullRomOpen - uma spline Catmull–Rom cúbica.
• catmullRom.alpha - defina o parâmetro Catmull–Rom alpha.
• d3.curveLinear - uma polilinha.
• d3.curveLinearClosed - uma polilinha fechada.
• d3.curveMonotoneX - uma spline cúbica que, dada a monotonicidade em x, a preserva em * y*.
• d3.curveMonotoneY - uma spline cúbica que, dada a monotonicidade em y, a preserva em * x*.
• d3.curveNatural - uma spline cúbica natural.
• d3.curveStep - uma função constante por partes.
• d3.curveStepAfter - uma função constante por partes.
• d3.curveStepBefore - uma função constante por partes.
• curve.areaStart - inicia um novo segmento de área.
• curve.areaEnd - finaliza o segmento de área atual.
• curve.lineStart - inicia um novo segmento de linha.
• curve.lineEnd - finaliza o segmento de linha atual.
• curve.point - adiciona um ponto ao segmento de linha atual.

Ligações

Uma curva de Bézier cúbica suave de uma fonte para um alvo.

• d3.link - crie um novo gerador de link.
• d3.linkVertical - crie um novo gerador de link vertical.
• d3.linkHorizontal - crie um novo gerador de link horizontal.
• link - gerar um link.
• link.source - defina o acessador de origem.
• link.target - defina o acessador de destino.
• link.x - defina o ponto x-accessor.
• link.y - defina o ponto y-accessor.
• link.context - defina o contexto de renderização.
• link.digits - defina a precisão de saída.
• d3.linkRadial - crie um novo gerador de link radial.
• linkRadial.angle - define o acessador angle do ponto.
• linkRadial.radius - define o acessador radius do ponto.

Símbolos

Uma codificação de forma categórica, como em um gráfico de dispersão.

• d3.symbol - crie um novo gerador de símbolos.
• symbol - gera um símbolo para o dado dado.
• symbol.type - defina o tipo de símbolo.
• symbol.size - defina o tamanho do símbolo em pixels quadrados.
• symbol.context - defina o contexto de renderização.
• symbol.digits - defina a precisão de saída.
• d3.symbolsFill - uma matriz de tipos de símbolos integrados para preenchimento.
• d3.symbolsStroke - uma matriz de tipos de símbolos integrados para traçado.
• d3.symbolAsterisk - um asterisco; para AVC.
• d3.symbolCircle - um círculo; para preenchimento ou curso.
• d3.symbolCross - uma cruz grega com braços de igual comprimento; Para preencher.
• d3.symbolDiamond - um losango; Para preencher.
• d3.symbolDiamond2 - um quadrado girado; para AVC.
• d3.symbolPlus - um sinal de mais; para AVC.
• d3.symbolSquare - um quadrado; Para preencher.
• d3.symbolSquare2 - um quadrado; para AVC.
• d3.symbolStar - uma estrela pentagonal (pentagrama); Para preencher.
• d3.symbolTriangle - um triângulo apontando para cima; Para preencher.
• d3.symbolTriangle2 - um triângulo apontando para cima; para AVC.
• d3.symbolWye - uma forma de Y; Para preencher.
• d3.symbolX - uma forma de X; para AVC.
• d3.pointRadial - coordenadas relativas de um ponto dado um ângulo e raio.
• symbolType.draw - desenhe este símbolo para o contexto dado.

Pilhas

Empilhe as formas, posicionando uma adjacente à outra, como em um gráfico de barras empilhadas.

• d3.stack - crie um novo gerador de pilha.
• stack - gera uma pilha para o conjunto de dados fornecido.
• stack.keys - defina o acessador de chaves.
• stack.value - defina o acessador de valor.
• stack.order - defina o acessador do pedido.
• stack.offset - defina o acessador de deslocamento.
• d3.stackOrderAppearance - coloque a série mais antiga na parte inferior.
• d3.stackOrderAscending - coloque a menor série na parte inferior.
• d3.stackOrderDescending - coloque a maior série na parte inferior.
• d3.stackOrderInsideOut - coloque as séries anteriores no meio.
• d3.stackOrderNone - use a ordem da série fornecida.
• d3.stackOrderReverse - use o reverso da ordem da série fornecida.
• d3.stackOffsetExpand - normaliza a linha de base para zero e a linha superior para um.
• d3.stackOffsetDiverging - positivo acima de zero; negativo abaixo de zero.
• d3.stackOffsetNone - aplica uma linha de base zero.
• d3.stackOffsetSilhouette - centraliza o streamgraph em torno de zero.
• d3.stackOffsetWiggle - minimiza a oscilação do streamgraph.

Formatos de Tempo (d3-time-format)

Analisar e formatar horários, inspirados em strptime e strftime.

• d3.timeFormat - alias para locale.format na localidade padrão.
• d3.timeParse - alias para locale.parse na localidade padrão.
• d3.utcFormat - alias para locale.utcFormat na localidade padrão.
• d3.utcParse - alias para locale.utcParse na localidade padrão.
• d3.isoFormat - um formatador ISO 8601 UTC.
• d3.isoParse - um analisador ISO 8601 UTC.
• locale.format - cria um formatador de hora.
• locale.parse - cria um analisador de tempo.
• locale.utcFormat - cria um formatador UTC.
• locale.utcParse - cria um analisador UTC.
• d3.timeFormatLocale - defina uma localidade personalizada.
• d3.timeFormatDefaultLocale - defina a localidade padrão.

Intervalos de Tempo (d3-time)

Uma calculadora para as peculiares convenções de tempo da humanidade.

• d3.timeInterval - implemente um novo intervalo de tempo personalizado.
• interval - alias para interval.floor.
• interval.floor - arredondar para o limite mais próximo.
• interval.round - arredonda para o limite mais próximo.
• interval.ceil - arredonda para o limite mais próximo.
• interval.offset - compensa uma data em alguns intervalos.
• interval.range - gera um intervalo de datas nos limites do intervalo.
• interval.filter - cria um subconjunto filtrado desse intervalo.
• interval.every - cria um subconjunto filtrado desse intervalo.
• interval.count - limites de intervalo de contagem entre duas datas.
• d3.timeMillisecond, [d3.utcMillisecond](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMillisecond) - o intervalo de milissegundos.
• d3.timeMilliseconds, [d3.utcMilliseconds](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMillisecond) - aliases para milisecond.range.
• d3.timeSecond, [d3.utcSecond](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSecond) - o segundo intervalo.
• d3.timeSeconds, [d3.utcSeconds](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSecond) - aliases para second.range.
• d3.timeMinute, [d3.utcMinute](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMinute) - o intervalo de minutos.
• d3.timeMinutes, [d3.utcMinutes](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMinute) - aliases para minute.range.
• d3.timeHour, [d3.utcHour](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeHour) - o intervalo de horas.
• d3.timeHours, [d3.utcHours](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeHour) - aliases para hour.range.
• d3.timeDay, [d3.utcDay](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeDay), d3.unixDay - o intervalo do dia.
• d3.timeDays, [d3.utcDays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeDay), d3.unixDays - aliases para day.range.
• d3.timeWeek, [d3.utcWeek](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeWeek) - apelidos para domingo.
• d3.timeWeeks, [d3.utcWeeks](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeWeek) - aliases para week.range.
• d3.timeSunday, [d3.utcSunday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSunday) - o intervalo da semana, começando no domingo.
• d3.timeSundays, [d3.utcSundays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSunday) - aliases para sunday.range.
• d3.timeMonday, [d3.utcMonday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMonday) - o intervalo da semana, começando na segunda-feira.
• d3.timeMondays, [d3.utcMondays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMonday) - aliases para monday.range.
• d3.timeTuesday, [d3.utcTuesday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeTuesday) - o intervalo da semana, começando na terça-feira.
• d3.timeTuesdays, [d3.utcTuesdays](https://github.com/d3/ d3-time/blob/v3.
• d3.timeWednesday, [d3.utcWednesday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeWednesday) - o intervalo da semana, começando na quarta-feira.
• d3.timeWednesdays, [d3.utcWednesdays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeWednesday) - aliases para quarta-feira.intervalo.
• d3.timeThursday, [d3.utcThursday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeThursday) - o intervalo da semana, começando na quinta-feira.
• d3.timeThursdays, [d3.utcThursdays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeThursday) - aliases para thursday.range.
• d3.timeFriday, [d3.utcFriday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeFriday) - o intervalo da semana, começando na sexta-feira.
• d3.timeFridays, [d3.utcFridays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeFriday) - aliases para friday.range.
• d3.timeSaturday, [d3.utcSaturday](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSaturday) - o intervalo da semana, começando no sábado.
• d3.timeSaturdays, [d3.utcSaturdays](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeSaturday) - aliases para saburday.range.
• d3.timeMonth, [d3.utcMonth](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMonth) - o intervalo do mês.
• d3.timeMonths, [d3.utcMonths](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeMonth) - aliases para months.range.
• d3.timeYear, [d3.utcYear](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeYear) - o intervalo de ano.
• d3.timeYears, [d3.utcYears](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#timeYear) - aliases para year.range.
• d3.timeTicks, [d3.utcTicks](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#utcTicks) -
• d3.timeTickInterval, [d3.utcTickInterval](https://github.com/d3/ d3-time/blob/v3.1.0/README.md#utcTickInterval) -

Temporizadores (d3-timer)

Uma fila eficiente para gerenciar milhares de animações simultâneas.

• d3.now - obtenha o tempo atual de alta resolução.
• d3.timer - agende um novo cronômetro.
• timer.restart - redefina a hora de início do cronômetro e o retorno de chamada.
• timer.stop - pare o cronômetro.
• d3.timerFlush - execute imediatamente quaisquer temporizadores qualificados.
• d3.timeout - agende um cronômetro que pare em seu primeiro retorno de chamada.
• d3.interval - agende um timer que é chamado com um período configurável.

Transições (d3-transition)

Transições animadas para seleções.

• selection.transition - agende uma transição para os elementos selecionados.
• selection.interrupt - interrompe e cancela transições nos elementos selecionados.
• d3.interrupt - interrompe a transição ativa para um determinado nó.
• d3.transition - agende uma transição no elemento raiz do documento.
• transition.select - agende uma transição nos elementos selecionados.
• transition.selectAll - agende uma transição nos elementos selecionados.
• transition.selectChild - selecione um elemento filho para cada elemento selecionado.
• transition.selectChildren - selecione os elementos filhos para cada elemento selecionado.
• transition.selection - retorna uma seleção para esta transição.
• transition.filter - filtra elementos com base nos dados.
• transition.merge - mescla esta transição com outra.
• transition.transition - agende uma nova transição após esta.
• d3.active - selecione a transição ativa para um determinado nó.
• transition.attr - entre o atributo fornecido usando o interpolador padrão.
• transition.attrTween - entre o atributo fornecido usando um interpolador personalizado.
• transition.style - entre a propriedade de estilo fornecida usando o interpolador padrão.
• transition.styleTween - interpolação da propriedade de estilo fornecida usando um interpolador personalizado.
• transition.text - defina o conteúdo do texto quando a transição começar.
• transition.textTween - entre o texto usando um interpolador personalizado.
• transition.remove - remove os elementos selecionados quando a transição termina.
• transition.tween - execute o código personalizado durante a transição.
• transition.delay - especifique o atraso por elemento em milissegundos.
• transition.duration - especifique a duração por elemento em milissegundos.
• transition.ease - especifique a função de atenuação.
• transition.easeVarying - especifica uma fábrica de funções de atenuação.
• transition.end - uma promessa que resolve quando uma transição termina.
• transition.on - aguarda o final de uma transição.
• transition.each - chama uma função para cada elemento.
• transition.call - chama uma função com esta transição.
• transition.empty - retorna verdadeiro se esta transição estiver vazia.
• transition.nodes - retorna uma matriz de todos os elementos selecionados.
• transition.node - retorna o primeiro elemento (não nulo).
• transition.size - retorna a contagem de elementos.

Zoom (d3-zoom)

Pan e zoom no SVG, HTML ou Canvas usando o mouse ou a entrada de toque.

• d3.zoom - cria um comportamento de zoom.
• zoom - aplica o comportamento de zoom aos elementos selecionados.
• zoom.transform - altera a transformação dos elementos selecionados.
• zoom.translateBy - traduz a transformação para os elementos selecionados.
• zoom.translateTo - traduz a transformação para os elementos selecionados.
• zoom.scaleBy - dimensiona a transformação para os elementos selecionados.
• zoom.scaleTo - dimensiona a transformação para os elementos selecionados.
• zoom.constrain - substitui a lógica de restrição de transformação.
• zoom.filter - controla quais eventos de entrada iniciam o zoom.
• zoom.touchable - defina o detector de suporte ao toque.
• zoom.wheelDelta - substitui a escala para eventos de roda.
• zoom.extent - defina a extensão da viewport.
• zoom.scaleExtent - defina o intervalo de escala permitido.
• zoom.translateExtent - defina a extensão do mundo com zoom.
• zoom.clickDistance - defina o limite de distância do clique.
• zoom.tapDistance - defina o limite de distância de toque.
• zoom.duration - defina a duração das transições de zoom.
• zoom.interpolate - controle a interpolação das transições de zoom.
• zoom.on - ouça eventos de zoom.
• d3.zoomTransform - obtenha a transformação de zoom para um determinado elemento.
• transform.scale - escala uma transformação pelo valor especificado.
• transform.translate - traduz uma transformação pelo valor especificado.
• transform.apply - aplique a transformação ao ponto especificado.
• transform.applyX - aplique a transformação à coordenada x fornecida.
• transform.applyY - aplique a transformação à coordenada y fornecida.
• transform.invert - cancela a aplicação da transformação no ponto especificado.
• transform.invertX - cancela a aplicação da transformação à coordenada x fornecida.
• transform.invertY - cancela a aplicação da transformação à coordenada y fornecida.
• transform.rescaleX - aplique a transformação ao domínio de uma escala x.
• transform.rescaleY - aplique a transformação a um domínio de escala y.
• transform.toString - formate a transformação como uma string de transformação SVG.
• d3.zoomIdentity - a transformação de identidade.