dc/web/docs/api-latest.md

A multi-dimensional charting library built to work natively with crossfilter and rendered using d3.js

<a name="dc"></a>

## dc : <code>object</code>
The entire dc.js library is scoped under the **dc** name space. It does not introduce
anything else into the global name space.

Most `dc` functions are designed to allow function chaining, meaning they return the current chart
instance whenever it is appropriate.  The getter forms of functions do not participate in function
chaining because they return values that are not the chart, although some,
such as [.svg](#dc.baseMixin+svg) and [.xAxis](#dc.coordinateGridMixin+xAxis),
return values that are themselves chainable d3 objects.

**Kind**: global namespace  
**Version**: 3.1.4  
**Example**  
```js
// Example chaining
chart.width(300)
     .height(300)
     .filter('sunday');
```

* [dc](#dc) : <code>object</code>
    * [.logger](#dc.logger)
        * [new logger()](#new_dc.logger_new)
        * [.enableDebugLog](#dc.logger+enableDebugLog)
        * [.warn([msg])](#dc.logger+warn) ⇒ [<code>logger</code>](#dc.logger)
        * [.warnOnce([msg])](#dc.logger+warnOnce) ⇒ [<code>logger</code>](#dc.logger)
        * [.debug([msg])](#dc.logger+debug) ⇒ [<code>logger</code>](#dc.logger)
        * [.deprecate([fn], [msg])](#dc.logger+deprecate) ⇒ <code>function</code>
        * [.annotate([fn], [msg])](#dc.logger+annotate) ⇒ <code>function</code>
    * [.config](#dc.config)
        * [new config()](#new_dc.config_new)
        * [.defaultColors([colors])](#dc.config+defaultColors) ⇒ <code>Array</code> \| [<code>config</code>](#dc.config)
    * [.pieChart](#dc.pieChart)
        * [new pieChart(parent, [chartGroup])](#new_dc.pieChart_new)
        * [.slicesCap([cap])](#dc.pieChart+slicesCap) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.externalRadiusPadding([externalRadiusPadding])](#dc.pieChart+externalRadiusPadding) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.innerRadius([innerRadius])](#dc.pieChart+innerRadius) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.radius([radius])](#dc.pieChart+radius) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.cx([cx])](#dc.pieChart+cx) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.cy([cy])](#dc.pieChart+cy) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.minAngleForLabel([minAngleForLabel])](#dc.pieChart+minAngleForLabel) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.emptyTitle([title])](#dc.pieChart+emptyTitle) ⇒ <code>String</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.externalLabels([externalLabelRadius])](#dc.pieChart+externalLabels) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
        * [.drawPaths([drawPaths])](#dc.pieChart+drawPaths) ⇒ <code>Boolean</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.sunburstChart](#dc.sunburstChart)
        * [new sunburstChart(parent, [chartGroup])](#new_dc.sunburstChart_new)
        * [.innerRadius([innerRadius])](#dc.sunburstChart+innerRadius) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.radius([radius])](#dc.sunburstChart+radius) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.cx([cx])](#dc.sunburstChart+cx) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.cy([cy])](#dc.sunburstChart+cy) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.minAngleForLabel([minAngleForLabel])](#dc.sunburstChart+minAngleForLabel) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.emptyTitle([title])](#dc.sunburstChart+emptyTitle) ⇒ <code>String</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
        * [.externalLabels([externalLabelRadius])](#dc.sunburstChart+externalLabels) ⇒ <code>Number</code> \| [<code>sunburstChart</code>](#dc.sunburstChart)
    * [.barChart](#dc.barChart)
        * [new barChart(parent, [chartGroup])](#new_dc.barChart_new)
        * [.centerBar([centerBar])](#dc.barChart+centerBar) ⇒ <code>Boolean</code> \| [<code>barChart</code>](#dc.barChart)
        * [.barPadding([barPadding])](#dc.barChart+barPadding) ⇒ <code>Number</code> \| [<code>barChart</code>](#dc.barChart)
        * [.outerPadding([padding])](#dc.barChart+outerPadding) ⇒ <code>Number</code> \| [<code>barChart</code>](#dc.barChart)
        * [.gap([gap])](#dc.barChart+gap) ⇒ <code>Number</code> \| [<code>barChart</code>](#dc.barChart)
        * [.alwaysUseRounding([alwaysUseRounding])](#dc.barChart+alwaysUseRounding) ⇒ <code>Boolean</code> \| [<code>barChart</code>](#dc.barChart)
    * [.lineChart](#dc.lineChart)
        * [new lineChart(parent, [chartGroup])](#new_dc.lineChart_new)
        * [.curve([curve])](#dc.lineChart+curve) ⇒ <code>d3.curve</code> \| [<code>lineChart</code>](#dc.lineChart)
        * ~~[.interpolate([interpolate])](#dc.lineChart+interpolate) ⇒ <code>d3.curve</code> \| [<code>lineChart</code>](#dc.lineChart)~~
        * ~~[.tension([tension])](#dc.lineChart+tension) ⇒ <code>Number</code> \| [<code>lineChart</code>](#dc.lineChart)~~
        * [.defined([defined])](#dc.lineChart+defined) ⇒ <code>function</code> \| [<code>lineChart</code>](#dc.lineChart)
        * [.dashStyle([dashStyle])](#dc.lineChart+dashStyle) ⇒ <code>Array.&lt;Number&gt;</code> \| [<code>lineChart</code>](#dc.lineChart)
        * [.renderArea([renderArea])](#dc.lineChart+renderArea) ⇒ <code>Boolean</code> \| [<code>lineChart</code>](#dc.lineChart)
        * [.xyTipsOn([xyTipsOn])](#dc.lineChart+xyTipsOn) ⇒ <code>Boolean</code> \| [<code>lineChart</code>](#dc.lineChart)
        * [.dotRadius([dotRadius])](#dc.lineChart+dotRadius) ⇒ <code>Number</code> \| [<code>lineChart</code>](#dc.lineChart)
        * [.renderDataPoints([options])](#dc.lineChart+renderDataPoints) ⇒ <code>Object</code> \| [<code>lineChart</code>](#dc.lineChart)
    * [.dataCount](#dc.dataCount)
        * [new dataCount(parent, [chartGroup])](#new_dc.dataCount_new)
        * [.html([options])](#dc.dataCount+html) ⇒ <code>Object</code> \| [<code>dataCount</code>](#dc.dataCount)
        * [.formatNumber([formatter])](#dc.dataCount+formatNumber) ⇒ <code>function</code> \| [<code>dataCount</code>](#dc.dataCount)
    * [.dataTable](#dc.dataTable)
        * [new dataTable(parent, [chartGroup])](#new_dc.dataTable_new)
        * [.section(section)](#dc.dataTable+section) ⇒ <code>function</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.group(groupFunction)](#dc.dataTable+group) ⇒ <code>function</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.size([size])](#dc.dataTable+size) ⇒ <code>Number</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.beginSlice([beginSlice])](#dc.dataTable+beginSlice) ⇒ <code>Number</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.endSlice([endSlice])](#dc.dataTable+endSlice) ⇒ <code>Number</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.columns([columns])](#dc.dataTable+columns) ⇒ <code>Array.&lt;function()&gt;</code>
        * [.sortBy([sortBy])](#dc.dataTable+sortBy) ⇒ <code>function</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.order([order])](#dc.dataTable+order) ⇒ <code>function</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.showSections([showSections])](#dc.dataTable+showSections) ⇒ <code>Boolean</code> \| [<code>dataTable</code>](#dc.dataTable)
        * [.showGroups([showGroups])](#dc.dataTable+showGroups) ⇒ <code>Boolean</code> \| [<code>dataTable</code>](#dc.dataTable)
    * [.dataGrid](#dc.dataGrid)
        * [new dataGrid(parent, [chartGroup])](#new_dc.dataGrid_new)
        * [.section(section)](#dc.dataGrid+section) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.group(groupFunction)](#dc.dataGrid+group) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.beginSlice([beginSlice])](#dc.dataGrid+beginSlice) ⇒ <code>Number</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.endSlice([endSlice])](#dc.dataGrid+endSlice) ⇒ <code>Number</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.size([size])](#dc.dataGrid+size) ⇒ <code>Number</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.html([html])](#dc.dataGrid+html) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.htmlSection([htmlSection])](#dc.dataGrid+htmlSection) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.htmlGroup([htmlGroup])](#dc.dataGrid+htmlGroup) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.sortBy([sortByFunction])](#dc.dataGrid+sortBy) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
        * [.order([order])](#dc.dataGrid+order) ⇒ <code>function</code> \| [<code>dataGrid</code>](#dc.dataGrid)
    * [.bubbleChart](#dc.bubbleChart)
        * [new bubbleChart(parent, [chartGroup])](#new_dc.bubbleChart_new)
        * [.elasticRadius([elasticRadius])](#dc.bubbleChart+elasticRadius) ⇒ <code>Boolean</code> \| [<code>bubbleChart</code>](#dc.bubbleChart)
        * [.sortBubbleSize([sortBubbleSize])](#dc.bubbleChart+sortBubbleSize) ⇒ <code>Boolean</code> \| [<code>bubbleChart</code>](#dc.bubbleChart)
    * [.compositeChart](#dc.compositeChart)
        * [new compositeChart(parent, [chartGroup])](#new_dc.compositeChart_new)
        * [.useRightAxisGridLines([useRightAxisGridLines])](#dc.compositeChart+useRightAxisGridLines) ⇒ <code>Boolean</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.childOptions([childOptions])](#dc.compositeChart+childOptions) ⇒ <code>Object</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.rightYAxisLabel([rightYAxisLabel], [padding])](#dc.compositeChart+rightYAxisLabel) ⇒ <code>String</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.compose([subChartArray])](#dc.compositeChart+compose) ⇒ [<code>compositeChart</code>](#dc.compositeChart)
        * [.children()](#dc.compositeChart+children) ⇒ [<code>Array.&lt;baseMixin&gt;</code>](#dc.baseMixin)
        * [.shareColors([shareColors])](#dc.compositeChart+shareColors) ⇒ <code>Boolean</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.shareTitle([shareTitle])](#dc.compositeChart+shareTitle) ⇒ <code>Boolean</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.rightY([yScale])](#dc.compositeChart+rightY) ⇒ <code>d3.scale</code> \| [<code>compositeChart</code>](#dc.compositeChart)
        * [.alignYAxes([alignYAxes])](#dc.compositeChart+alignYAxes) ⇒ <code>Chart</code>
        * [.rightYAxis([rightYAxis])](#dc.compositeChart+rightYAxis) ⇒ <code>d3.axisRight</code> \| [<code>compositeChart</code>](#dc.compositeChart)
    * [.seriesChart](#dc.seriesChart)
        * [new seriesChart(parent, [chartGroup])](#new_dc.seriesChart_new)
        * [.chart([chartFunction])](#dc.seriesChart+chart) ⇒ <code>function</code> \| [<code>seriesChart</code>](#dc.seriesChart)
        * [.seriesAccessor([accessor])](#dc.seriesChart+seriesAccessor) ⇒ <code>function</code> \| [<code>seriesChart</code>](#dc.seriesChart)
        * [.seriesSort([sortFunction])](#dc.seriesChart+seriesSort) ⇒ <code>function</code> \| [<code>seriesChart</code>](#dc.seriesChart)
        * [.valueSort([sortFunction])](#dc.seriesChart+valueSort) ⇒ <code>function</code> \| [<code>seriesChart</code>](#dc.seriesChart)
    * [.geoChoroplethChart](#dc.geoChoroplethChart)
        * [new geoChoroplethChart(parent, [chartGroup])](#new_dc.geoChoroplethChart_new)
        * [.overlayGeoJson(json, name, keyAccessor)](#dc.geoChoroplethChart+overlayGeoJson) ⇒ [<code>geoChoroplethChart</code>](#dc.geoChoroplethChart)
        * [.projection([projection])](#dc.geoChoroplethChart+projection) ⇒ <code>d3.projection</code> \| [<code>geoChoroplethChart</code>](#dc.geoChoroplethChart)
        * [.geoJsons()](#dc.geoChoroplethChart+geoJsons) ⇒ <code>Array.&lt;{name:String, data: Object, accessor: function()}&gt;</code>
        * [.geoPath()](#dc.geoChoroplethChart+geoPath) ⇒ <code>d3.geoPath</code>
        * [.removeGeoJson(name)](#dc.geoChoroplethChart+removeGeoJson) ⇒ [<code>geoChoroplethChart</code>](#dc.geoChoroplethChart)
    * [.bubbleOverlay](#dc.bubbleOverlay)
        * [new bubbleOverlay(parent, [chartGroup])](#new_dc.bubbleOverlay_new)
        * [.svg([imageElement])](#dc.bubbleOverlay+svg) ⇒ [<code>bubbleOverlay</code>](#dc.bubbleOverlay)
        * [.point(name, x, y)](#dc.bubbleOverlay+point) ⇒ [<code>bubbleOverlay</code>](#dc.bubbleOverlay)
    * [.rowChart](#dc.rowChart)
        * [new rowChart(parent, [chartGroup])](#new_dc.rowChart_new)
        * [.x([scale])](#dc.rowChart+x) ⇒ <code>d3.scale</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.renderTitleLabel([renderTitleLabel])](#dc.rowChart+renderTitleLabel) ⇒ <code>Boolean</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.xAxis([xAxis])](#dc.rowChart+xAxis) ⇒ <code>d3.axis</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.fixedBarHeight([fixedBarHeight])](#dc.rowChart+fixedBarHeight) ⇒ <code>Boolean</code> \| <code>Number</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.gap([gap])](#dc.rowChart+gap) ⇒ <code>Number</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.elasticX([elasticX])](#dc.rowChart+elasticX) ⇒ <code>Boolean</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.labelOffsetX([labelOffsetX])](#dc.rowChart+labelOffsetX) ⇒ <code>Number</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.labelOffsetY([labelOffsety])](#dc.rowChart+labelOffsetY) ⇒ <code>Number</code> \| [<code>rowChart</code>](#dc.rowChart)
        * [.titleLabelOffsetX([titleLabelOffsetX])](#dc.rowChart+titleLabelOffsetX) ⇒ <code>Number</code> \| [<code>rowChart</code>](#dc.rowChart)
    * [.legend](#dc.legend)
        * [new legend()](#new_dc.legend_new)
        * [.x([x])](#dc.legend+x) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.y([y])](#dc.legend+y) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.gap([gap])](#dc.legend+gap) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.itemHeight([itemHeight])](#dc.legend+itemHeight) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.horizontal([horizontal])](#dc.legend+horizontal) ⇒ <code>Boolean</code> \| [<code>legend</code>](#dc.legend)
        * [.legendWidth([legendWidth])](#dc.legend+legendWidth) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.itemWidth([itemWidth])](#dc.legend+itemWidth) ⇒ <code>Number</code> \| [<code>legend</code>](#dc.legend)
        * [.autoItemWidth([autoItemWidth])](#dc.legend+autoItemWidth) ⇒ <code>Boolean</code> \| [<code>legend</code>](#dc.legend)
        * [.legendText([legendText])](#dc.legend+legendText) ⇒ <code>function</code> \| [<code>legend</code>](#dc.legend)
        * [.maxItems([maxItems])](#dc.legend+maxItems) ⇒ [<code>legend</code>](#dc.legend)
    * [.htmlLegend](#dc.htmlLegend)
        * [new htmlLegend()](#new_dc.htmlLegend_new)
        * [.container([container])](#dc.htmlLegend+container) ⇒ <code>String</code> \| [<code>htmlLegend</code>](#dc.htmlLegend)
        * [.legendItemClass([legendItemClass])](#dc.htmlLegend+legendItemClass) ⇒ <code>String</code> \| [<code>htmlLegend</code>](#dc.htmlLegend)
        * [.highlightSelected([highlightSelected])](#dc.htmlLegend+highlightSelected) ⇒ <code>String</code> \| [<code>htmlLegend</code>](#dc.htmlLegend)
        * [.horizontal([horizontal])](#dc.htmlLegend+horizontal) ⇒ <code>String</code> \| [<code>htmlLegend</code>](#dc.htmlLegend)
        * [.legendText([legendText])](#dc.htmlLegend+legendText) ⇒ <code>function</code> \| [<code>htmlLegend</code>](#dc.htmlLegend)
        * [.maxItems([maxItems])](#dc.htmlLegend+maxItems) ⇒ [<code>htmlLegend</code>](#dc.htmlLegend)
    * [.scatterPlot](#dc.scatterPlot)
        * [new scatterPlot(parent, [chartGroup])](#new_dc.scatterPlot_new)
        * [.emptyColor](#dc.scatterPlot+emptyColor) ⇒ <code>String</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.emptyOpacity](#dc.scatterPlot+emptyOpacity) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.nonemptyOpacity](#dc.scatterPlot+nonemptyOpacity) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.resetSvg()](#dc.scatterPlot+resetSvg) ⇒ <code>SVGElement</code>
        * [.useCanvas([useCanvas])](#dc.scatterPlot+useCanvas) ⇒ <code>Boolean</code> \| <code>d3.selection</code>
        * [.canvas([canvasElement])](#dc.scatterPlot+canvas) ⇒ <code>CanvasElement</code> \| <code>d3.selection</code>
        * [.context()](#dc.scatterPlot+context) ⇒ <code>CanvasContext</code>
        * [.existenceAccessor([accessor])](#dc.scatterPlot+existenceAccessor) ⇒ <code>function</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.symbol([type])](#dc.scatterPlot+symbol) ⇒ <code>function</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.customSymbol([customSymbol])](#dc.scatterPlot+customSymbol) ⇒ <code>String</code> \| <code>function</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.symbolSize([symbolSize])](#dc.scatterPlot+symbolSize) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.highlightedSize([highlightedSize])](#dc.scatterPlot+highlightedSize) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.excludedSize([excludedSize])](#dc.scatterPlot+excludedSize) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.excludedColor([excludedColor])](#dc.scatterPlot+excludedColor) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.excludedOpacity([excludedOpacity])](#dc.scatterPlot+excludedOpacity) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
        * [.emptySize([emptySize])](#dc.scatterPlot+emptySize) ⇒ <code>Number</code> \| [<code>scatterPlot</code>](#dc.scatterPlot)
    * [.numberDisplay](#dc.numberDisplay)
        * [new numberDisplay(parent, [chartGroup])](#new_dc.numberDisplay_new)
        * [.html([html])](#dc.numberDisplay+html) ⇒ <code>Object</code> \| [<code>numberDisplay</code>](#dc.numberDisplay)
        * [.value()](#dc.numberDisplay+value) ⇒ <code>Number</code>
        * [.formatNumber([formatter])](#dc.numberDisplay+formatNumber) ⇒ <code>function</code> \| [<code>numberDisplay</code>](#dc.numberDisplay)
    * [.heatMap](#dc.heatMap)
        * [new heatMap(parent, [chartGroup])](#new_dc.heatMap_new)
        * [.colsLabel([labelFunction])](#dc.heatMap+colsLabel) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.rowsLabel([labelFunction])](#dc.heatMap+rowsLabel) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.rows([rows])](#dc.heatMap+rows) ⇒ <code>Array.&lt;(String\|Number)&gt;</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.rowOrdering([rowOrdering])](#dc.heatMap+rowOrdering) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.cols([cols])](#dc.heatMap+cols) ⇒ <code>Array.&lt;(String\|Number)&gt;</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.colOrdering([colOrdering])](#dc.heatMap+colOrdering) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.boxOnClick([handler])](#dc.heatMap+boxOnClick) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.xAxisOnClick([handler])](#dc.heatMap+xAxisOnClick) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.yAxisOnClick([handler])](#dc.heatMap+yAxisOnClick) ⇒ <code>function</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.xBorderRadius([xBorderRadius])](#dc.heatMap+xBorderRadius) ⇒ <code>Number</code> \| [<code>heatMap</code>](#dc.heatMap)
        * [.yBorderRadius([yBorderRadius])](#dc.heatMap+yBorderRadius) ⇒ <code>Number</code> \| [<code>heatMap</code>](#dc.heatMap)
    * [.boxPlot](#dc.boxPlot)
        * [new boxPlot(parent, [chartGroup])](#new_dc.boxPlot_new)
        * [.boxPadding([padding])](#dc.boxPlot+boxPadding) ⇒ <code>Number</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.outerPadding([padding])](#dc.boxPlot+outerPadding) ⇒ <code>Number</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.boxWidth([boxWidth])](#dc.boxPlot+boxWidth) ⇒ <code>Number</code> \| <code>function</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.tickFormat([tickFormat])](#dc.boxPlot+tickFormat) ⇒ <code>Number</code> \| <code>function</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.yRangePadding([yRangePadding])](#dc.boxPlot+yRangePadding) ⇒ <code>Number</code> \| <code>function</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.renderDataPoints([show])](#dc.boxPlot+renderDataPoints) ⇒ <code>Boolean</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.dataOpacity([opacity])](#dc.boxPlot+dataOpacity) ⇒ <code>Number</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.dataWidthPortion([percentage])](#dc.boxPlot+dataWidthPortion) ⇒ <code>Number</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.showOutliers([show])](#dc.boxPlot+showOutliers) ⇒ <code>Boolean</code> \| [<code>boxPlot</code>](#dc.boxPlot)
        * [.boldOutlier([show])](#dc.boxPlot+boldOutlier) ⇒ <code>Boolean</code> \| [<code>boxPlot</code>](#dc.boxPlot)
    * [.selectMenu](#dc.selectMenu)
        * [new selectMenu(parent, [chartGroup])](#new_dc.selectMenu_new)
        * [.order([order])](#dc.selectMenu+order) ⇒ <code>function</code> \| [<code>selectMenu</code>](#dc.selectMenu)
        * [.promptText([promptText])](#dc.selectMenu+promptText) ⇒ <code>String</code> \| [<code>selectMenu</code>](#dc.selectMenu)
        * [.filterDisplayed([filterDisplayed])](#dc.selectMenu+filterDisplayed) ⇒ <code>function</code> \| [<code>selectMenu</code>](#dc.selectMenu)
        * [.multiple([multiple])](#dc.selectMenu+multiple) ⇒ <code>boolean</code> \| [<code>selectMenu</code>](#dc.selectMenu)
        * [.promptValue([promptValue])](#dc.selectMenu+promptValue) ⇒ <code>\*</code> \| [<code>selectMenu</code>](#dc.selectMenu)
        * [.numberItems([numberVisible])](#dc.selectMenu+numberItems) ⇒ <code>number</code> \| [<code>selectMenu</code>](#dc.selectMenu)
    * [.textFilterWidget](#dc.textFilterWidget)
        * [new textFilterWidget(parent, [chartGroup])](#new_dc.textFilterWidget_new)
        * [.normalize](#dc.textFilterWidget+normalize) ⇒ [<code>textFilterWidget</code>](#dc.textFilterWidget) \| <code>function</code>
        * [.placeHolder](#dc.textFilterWidget+placeHolder) ⇒ [<code>textFilterWidget</code>](#dc.textFilterWidget) \| <code>string</code>
        * [.filterFunctionFactory](#dc.textFilterWidget+filterFunctionFactory) ⇒ [<code>textFilterWidget</code>](#dc.textFilterWidget) \| <code>function</code>
    * [.cboxMenu](#dc.cboxMenu)
        * [new cboxMenu(parent, [chartGroup])](#new_dc.cboxMenu_new)
        * [.order([order])](#dc.cboxMenu+order) ⇒ <code>function</code> \| [<code>cboxMenu</code>](#dc.cboxMenu)
        * [.promptText([promptText])](#dc.cboxMenu+promptText) ⇒ <code>String</code> \| [<code>cboxMenu</code>](#dc.cboxMenu)
        * [.filterDisplayed([filterDisplayed])](#dc.cboxMenu+filterDisplayed) ⇒ <code>function</code> \| [<code>cboxMenu</code>](#dc.cboxMenu)
        * [.multiple([multiple])](#dc.cboxMenu+multiple) ⇒ <code>Boolean</code> \| [<code>cboxMenu</code>](#dc.cboxMenu)
        * [.promptValue([promptValue])](#dc.cboxMenu+promptValue) ⇒ <code>\*</code> \| [<code>cboxMenu</code>](#dc.cboxMenu)
    * [.baseMixin](#dc.baseMixin) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.height([height])](#dc.baseMixin+height) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.width([width])](#dc.baseMixin+width) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.minWidth([minWidth])](#dc.baseMixin+minWidth) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.minHeight([minHeight])](#dc.baseMixin+minHeight) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.useViewBoxResizing([useViewBoxResizing])](#dc.baseMixin+useViewBoxResizing) ⇒ <code>Boolean</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.dimension([dimension])](#dc.baseMixin+dimension) ⇒ <code>crossfilter.dimension</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.data([callback])](#dc.baseMixin+data) ⇒ <code>\*</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.group([group], [name])](#dc.baseMixin+group) ⇒ <code>crossfilter.group</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.ordering([orderFunction])](#dc.baseMixin+ordering) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.filterAll()](#dc.baseMixin+filterAll) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.select(sel)](#dc.baseMixin+select) ⇒ <code>d3.selection</code>
        * [.selectAll(sel)](#dc.baseMixin+selectAll) ⇒ <code>d3.selection</code>
        * [.anchor([parent], [chartGroup])](#dc.baseMixin+anchor) ⇒ <code>String</code> \| <code>node</code> \| <code>d3.selection</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.anchorName()](#dc.baseMixin+anchorName) ⇒ <code>String</code>
        * [.root([rootElement])](#dc.baseMixin+root) ⇒ <code>HTMLElement</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.svg([svgElement])](#dc.baseMixin+svg) ⇒ <code>SVGElement</code> \| <code>d3.selection</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.resetSvg()](#dc.baseMixin+resetSvg) ⇒ <code>SVGElement</code>
        * [.filterPrinter([filterPrinterFunction])](#dc.baseMixin+filterPrinter) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.controlsUseVisibility([controlsUseVisibility])](#dc.baseMixin+controlsUseVisibility) ⇒ <code>Boolean</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.turnOnControls()](#dc.baseMixin+turnOnControls) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.turnOffControls()](#dc.baseMixin+turnOffControls) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.transitionDuration([duration])](#dc.baseMixin+transitionDuration) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.transitionDelay([delay])](#dc.baseMixin+transitionDelay) ⇒ <code>Number</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.render()](#dc.baseMixin+render) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.redraw()](#dc.baseMixin+redraw) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.commitHandler(commitHandler)](#dc.baseMixin+commitHandler) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.redrawGroup()](#dc.baseMixin+redrawGroup) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.renderGroup()](#dc.baseMixin+renderGroup) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.hasFilterHandler([hasFilterHandler])](#dc.baseMixin+hasFilterHandler) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.hasFilter([filter])](#dc.baseMixin+hasFilter) ⇒ <code>Boolean</code>
        * [.removeFilterHandler([removeFilterHandler])](#dc.baseMixin+removeFilterHandler) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.addFilterHandler([addFilterHandler])](#dc.baseMixin+addFilterHandler) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.resetFilterHandler([resetFilterHandler])](#dc.baseMixin+resetFilterHandler) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.replaceFilter([filter])](#dc.baseMixin+replaceFilter) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.filter([filter])](#dc.baseMixin+filter) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.filters()](#dc.baseMixin+filters) ⇒ <code>Array.&lt;\*&gt;</code>
        * [.onClick(datum)](#dc.baseMixin+onClick) ⇒ <code>undefined</code>
        * [.filterHandler([filterHandler])](#dc.baseMixin+filterHandler) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.keyAccessor([keyAccessor])](#dc.baseMixin+keyAccessor) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.valueAccessor([valueAccessor])](#dc.baseMixin+valueAccessor) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.label([labelFunction], [enableLabels])](#dc.baseMixin+label) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.renderLabel([renderLabel])](#dc.baseMixin+renderLabel) ⇒ <code>Boolean</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.title([titleFunction])](#dc.baseMixin+title) ⇒ <code>function</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.renderTitle([renderTitle])](#dc.baseMixin+renderTitle) ⇒ <code>Boolean</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * ~~[.renderlet(renderletFunction)](#dc.baseMixin+renderlet) ⇒ [<code>baseMixin</code>](#dc.baseMixin)~~
        * [.chartGroup([chartGroup])](#dc.baseMixin+chartGroup) ⇒ <code>String</code> \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.expireCache()](#dc.baseMixin+expireCache) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.legend([legend])](#dc.baseMixin+legend) ⇒ [<code>legend</code>](#dc.legend) \| [<code>baseMixin</code>](#dc.baseMixin)
        * [.chartID()](#dc.baseMixin+chartID) ⇒ <code>String</code>
        * [.options(opts)](#dc.baseMixin+options) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
        * [.on(event, listener)](#dc.baseMixin+on) ⇒ [<code>baseMixin</code>](#dc.baseMixin)
    * [.marginMixin](#dc.marginMixin) ⇒ [<code>marginMixin</code>](#dc.marginMixin)
        * [.margins([margins])](#dc.marginMixin+margins) ⇒ <code>Object</code> \| [<code>marginMixin</code>](#dc.marginMixin)
    * [.colorMixin](#dc.colorMixin) ⇒ [<code>colorMixin</code>](#dc.colorMixin)
        * [.colors([colorScale])](#dc.colorMixin+colors) ⇒ <code>d3.scale</code> \| [<code>colorMixin</code>](#dc.colorMixin)
        * [.ordinalColors(r)](#dc.colorMixin+ordinalColors) ⇒ [<code>colorMixin</code>](#dc.colorMixin)
        * [.linearColors(r)](#dc.colorMixin+linearColors) ⇒ [<code>colorMixin</code>](#dc.colorMixin)
        * [.colorAccessor([colorAccessor])](#dc.colorMixin+colorAccessor) ⇒ <code>function</code> \| [<code>colorMixin</code>](#dc.colorMixin)
        * [.colorDomain([domain])](#dc.colorMixin+colorDomain) ⇒ <code>Array.&lt;String&gt;</code> \| [<code>colorMixin</code>](#dc.colorMixin)
        * [.calculateColorDomain()](#dc.colorMixin+calculateColorDomain) ⇒ [<code>colorMixin</code>](#dc.colorMixin)
        * [.getColor(d, [i])](#dc.colorMixin+getColor) ⇒ <code>String</code>
        * [.colorCalculator([colorCalculator])](#dc.colorMixin+colorCalculator) ⇒ <code>function</code> \| [<code>colorMixin</code>](#dc.colorMixin)
    * [.coordinateGridMixin](#dc.coordinateGridMixin) ⇒ [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.rescale()](#dc.coordinateGridMixin+rescale) ⇒ [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.rangeChart([rangeChart])](#dc.coordinateGridMixin+rangeChart) ⇒ [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.zoomScale([extent])](#dc.coordinateGridMixin+zoomScale) ⇒ <code>Array.&lt;(Number\|Date)&gt;</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.zoomOutRestrict([zoomOutRestrict])](#dc.coordinateGridMixin+zoomOutRestrict) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.g([gElement])](#dc.coordinateGridMixin+g) ⇒ <code>SVGElement</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.mouseZoomable([mouseZoomable])](#dc.coordinateGridMixin+mouseZoomable) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.chartBodyG([chartBodyG])](#dc.coordinateGridMixin+chartBodyG) ⇒ <code>SVGElement</code>
        * [.x([xScale])](#dc.coordinateGridMixin+x) ⇒ <code>d3.scale</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xUnits([xUnits])](#dc.coordinateGridMixin+xUnits) ⇒ <code>function</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xAxis([xAxis])](#dc.coordinateGridMixin+xAxis) ⇒ <code>d3.axis</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.elasticX([elasticX])](#dc.coordinateGridMixin+elasticX) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xAxisPadding([padding])](#dc.coordinateGridMixin+xAxisPadding) ⇒ <code>Number</code> \| <code>String</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xAxisPaddingUnit([unit])](#dc.coordinateGridMixin+xAxisPaddingUnit) ⇒ <code>String</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xUnitCount()](#dc.coordinateGridMixin+xUnitCount) ⇒ <code>Number</code>
        * [.useRightYAxis([useRightYAxis])](#dc.coordinateGridMixin+useRightYAxis) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.isOrdinal()](#dc.coordinateGridMixin+isOrdinal) ⇒ <code>Boolean</code>
        * [.xAxisLabel([labelText], [padding])](#dc.coordinateGridMixin+xAxisLabel) ⇒ <code>String</code>
        * [.yAxisLabel([labelText], [padding])](#dc.coordinateGridMixin+yAxisLabel) ⇒ <code>String</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.y([yScale])](#dc.coordinateGridMixin+y) ⇒ <code>d3.scale</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.yAxis([yAxis])](#dc.coordinateGridMixin+yAxis) ⇒ <code>d3.axisLeft</code> \| <code>d3.axisRight</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.elasticY([elasticY])](#dc.coordinateGridMixin+elasticY) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.renderHorizontalGridLines([renderHorizontalGridLines])](#dc.coordinateGridMixin+renderHorizontalGridLines) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.renderVerticalGridLines([renderVerticalGridLines])](#dc.coordinateGridMixin+renderVerticalGridLines) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.xAxisMin()](#dc.coordinateGridMixin+xAxisMin) ⇒ <code>\*</code>
        * [.xAxisMax()](#dc.coordinateGridMixin+xAxisMax) ⇒ <code>\*</code>
        * [.yAxisMin()](#dc.coordinateGridMixin+yAxisMin) ⇒ <code>\*</code>
        * [.yAxisMax()](#dc.coordinateGridMixin+yAxisMax) ⇒ <code>\*</code>
        * [.yAxisPadding([padding])](#dc.coordinateGridMixin+yAxisPadding) ⇒ <code>Number</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.round([round])](#dc.coordinateGridMixin+round) ⇒ <code>function</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.brush([_])](#dc.coordinateGridMixin+brush) ⇒ <code>d3.brush</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.clipPadding([padding])](#dc.coordinateGridMixin+clipPadding) ⇒ <code>Number</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.focus([range], [noRaiseEvents])](#dc.coordinateGridMixin+focus) ⇒ <code>undefined</code>
        * [.brushOn([brushOn])](#dc.coordinateGridMixin+brushOn) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
        * [.parentBrushOn([brushOn])](#dc.coordinateGridMixin+parentBrushOn) ⇒ <code>Boolean</code> \| [<code>coordinateGridMixin</code>](#dc.coordinateGridMixin)
    * [.stackMixin](#dc.stackMixin) ⇒ [<code>stackMixin</code>](#dc.stackMixin)
        * [.stack(group, [name], [accessor])](#dc.stackMixin+stack) ⇒ <code>Array.&lt;{group: crossfilter.group, name: String, accessor: function()}&gt;</code> \| [<code>stackMixin</code>](#dc.stackMixin)
        * [.hidableStacks([hidableStacks])](#dc.stackMixin+hidableStacks) ⇒ <code>Boolean</code> \| [<code>stackMixin</code>](#dc.stackMixin)
        * [.hideStack(stackName)](#dc.stackMixin+hideStack) ⇒ [<code>stackMixin</code>](#dc.stackMixin)
        * [.showStack(stackName)](#dc.stackMixin+showStack) ⇒ [<code>stackMixin</code>](#dc.stackMixin)
        * [.title([stackName], [titleAccessor])](#dc.stackMixin+title) ⇒ <code>String</code> \| [<code>stackMixin</code>](#dc.stackMixin)
        * [.stackLayout([stack])](#dc.stackMixin+stackLayout) ⇒ <code>function</code> \| [<code>stackMixin</code>](#dc.stackMixin)
        * [.evadeDomainFilter([evadeDomainFilter])](#dc.stackMixin+evadeDomainFilter) ⇒ <code>Boolean</code> \| [<code>stackMixin</code>](#dc.stackMixin)
    * [.capMixin](#dc.capMixin) ⇒ [<code>capMixin</code>](#dc.capMixin)
        * [.cap([count])](#dc.capMixin+cap) ⇒ <code>Number</code> \| [<code>capMixin</code>](#dc.capMixin)
        * [.takeFront([takeFront])](#dc.capMixin+takeFront) ⇒ <code>Boolean</code> \| [<code>capMixin</code>](#dc.capMixin)
        * [.othersLabel([label])](#dc.capMixin+othersLabel) ⇒ <code>String</code> \| [<code>capMixin</code>](#dc.capMixin)
        * [.othersGrouper([grouperFunction])](#dc.capMixin+othersGrouper) ⇒ <code>function</code> \| [<code>capMixin</code>](#dc.capMixin)
    * [.bubbleMixin](#dc.bubbleMixin) ⇒ [<code>bubbleMixin</code>](#dc.bubbleMixin)
        * [.r([bubbleRadiusScale])](#dc.bubbleMixin+r) ⇒ <code>d3.scale</code> \| [<code>bubbleMixin</code>](#dc.bubbleMixin)
        * [.radiusValueAccessor([radiusValueAccessor])](#dc.bubbleMixin+radiusValueAccessor) ⇒ <code>function</code> \| [<code>bubbleMixin</code>](#dc.bubbleMixin)
        * [.minRadius([radius])](#dc.bubbleMixin+minRadius) ⇒ <code>Number</code> \| [<code>bubbleMixin</code>](#dc.bubbleMixin)
        * [.minRadiusWithLabel([radius])](#dc.bubbleMixin+minRadiusWithLabel) ⇒ <code>Number</code> \| [<code>bubbleMixin</code>](#dc.bubbleMixin)
        * [.maxBubbleRelativeSize([relativeSize])](#dc.bubbleMixin+maxBubbleRelativeSize) ⇒ <code>Number</code> \| [<code>bubbleMixin</code>](#dc.bubbleMixin)
    * [.disableTransitions](#dc.disableTransitions) : <code>Boolean</code>
    * [.dateFormat](#dc.dateFormat) : <code>function</code>
    * [.chartRegistry](#dc.chartRegistry) : <code>object</code>
        * [.has(chart)](#dc.chartRegistry.has) ⇒ <code>Boolean</code>
        * [.register(chart, [group])](#dc.chartRegistry.register) ⇒ <code>undefined</code>
        * [.deregister(chart, [group])](#dc.chartRegistry.deregister) ⇒ <code>undefined</code>
        * [.clear(group)](#dc.chartRegistry.clear) ⇒ <code>undefined</code>
        * [.list([group])](#dc.chartRegistry.list) ⇒ <code>Array.&lt;Object&gt;</code>
    * [.units](#dc.units) : <code>object</code>
        * [.fp](#dc.units.fp) : <code>object</code>
            * [.precision(precision)](#dc.units.fp.precision) ⇒ <code>function</code>
        * [.integers(start, end)](#dc.units.integers) ⇒ <code>Number</code>
        * [.ordinal()](#dc.units.ordinal) ⇒ <code>uncallable</code>
    * [.printers](#dc.printers) : <code>object</code>
        * [.filters(filters)](#dc.printers.filters) ⇒ <code>String</code>
        * [.filter(filter)](#dc.printers.filter) ⇒ <code>String</code>
    * [.utils](#dc.utils) : <code>object</code>
        * [.printSingleValue(filter)](#dc.utils.printSingleValue) ⇒ <code>String</code>
        * [.add(l, r, [t])](#dc.utils.add) ⇒ <code>Date</code> \| <code>Number</code>
        * [.subtract(l, r, [t])](#dc.utils.subtract) ⇒ <code>Date</code> \| <code>Number</code>
        * [.isNumber(n)](#dc.utils.isNumber) ⇒ <code>Boolean</code>
        * [.isFloat(n)](#dc.utils.isFloat) ⇒ <code>Boolean</code>
        * [.isInteger(n)](#dc.utils.isInteger) ⇒ <code>Boolean</code>
        * [.isNegligible(n)](#dc.utils.isNegligible) ⇒ <code>Boolean</code>
        * [.clamp(val, min, max)](#dc.utils.clamp) ⇒ <code>any</code>
        * [.constant(x)](#dc.utils.constant) ⇒ <code>function</code>
        * [.uniqueId()](#dc.utils.uniqueId) ⇒ <code>Number</code>
        * [.nameToId(name)](#dc.utils.nameToId) ⇒ <code>String</code>
        * [.appendOrSelect(parent, selector, tag)](#dc.utils.appendOrSelect) ⇒ <code>d3.selection</code>
        * [.safeNumber(n)](#dc.utils.safeNumber) ⇒ <code>Number</code>
        * [.arraysEqual(a1, a2)](#dc.utils.arraysEqual) ⇒ <code>Boolean</code>
    * [.filters](#dc.filters) : <code>object</code>
        * [.RangedFilter](#dc.filters.RangedFilter)
            * [new RangedFilter(low, high)](#new_dc.filters.RangedFilter_new)
        * [.TwoDimensionalFilter](#dc.filters.TwoDimensionalFilter)
            * [new TwoDimensionalFilter(filter)](#new_dc.filters.TwoDimensionalFilter_new)
        * [.RangedTwoDimensionalFilter](#dc.filters.RangedTwoDimensionalFilter)
            * [new RangedTwoDimensionalFilter(filter)](#new_dc.filters.RangedTwoDimensionalFilter_new)
        * [.HierarchyFilter](#dc.filters.HierarchyFilter)
            * [new HierarchyFilter(path)](#new_dc.filters.HierarchyFilter_new)
    * [.registerChart(chart, [group])](#dc.registerChart) ⇒ <code>undefined</code>
    * [.deregisterChart(chart, [group])](#dc.deregisterChart) ⇒ <code>undefined</code>
    * [.hasChart(chart)](#dc.hasChart) ⇒ <code>Boolean</code>
    * [.deregisterAllCharts(group)](#dc.deregisterAllCharts) ⇒ <code>undefined</code>
    * [.filterAll([group])](#dc.filterAll) ⇒ <code>undefined</code>
    * [.refocusAll([group])](#dc.refocusAll) ⇒ <code>undefined</code>
    * [.renderAll([group])](#dc.renderAll) ⇒ <code>undefined</code>
    * [.redrawAll([group])](#dc.redrawAll) ⇒ <code>undefined</code>
    * [.transition(selection, [duration], [delay], [name])](#dc.transition) ⇒ <code>d3.transition</code> \| <code>d3.selection</code>
    * [.pluck(n, [f])](#dc.pluck) ⇒ <code>function</code>

<a name="dc.logger"></a>

### dc.logger
**Kind**: static class of [<code>dc</code>](#dc)  

* [.logger](#dc.logger)
    * [new logger()](#new_dc.logger_new)
    * [.enableDebugLog](#dc.logger+enableDebugLog)
    * [.warn([msg])](#dc.logger+warn) ⇒ [<code>logger</code>](#dc.logger)
    * [.warnOnce([msg])](#dc.logger+warnOnce) ⇒ [<code>logger</code>](#dc.logger)
    * [.debug([msg])](#dc.logger+debug) ⇒ [<code>logger</code>](#dc.logger)
    * [.deprecate([fn], [msg])](#dc.logger+deprecate) ⇒ <code>function</code>
    * [.annotate([fn], [msg])](#dc.logger+annotate) ⇒ <code>function</code>

<a name="new_dc.logger_new"></a>

#### new logger()
Provides basis logging and deprecation utilities

<a name="dc.logger+enableDebugLog"></a>

#### logger.enableDebugLog
Enable debug level logging. Set to `false` by default.

**Kind**: instance property of [<code>logger</code>](#dc.logger)  
<a name="dc.logger+warn"></a>

#### logger.warn([msg]) ⇒ [<code>logger</code>](#dc.logger)
Put a warning message to console

**Kind**: instance method of [<code>logger</code>](#dc.logger)  

| Param | Type |
| --- | --- |
| [msg] | <code>String</code> | 

**Example**  
```js
dc.logger.warn('Invalid use of .tension on CurveLinear');
```
<a name="dc.logger+warnOnce"></a>

#### logger.warnOnce([msg]) ⇒ [<code>logger</code>](#dc.logger)
Put a warning message to console. It will warn only on unique messages.

**Kind**: instance method of [<code>logger</code>](#dc.logger)  

| Param | Type |
| --- | --- |
| [msg] | <code>String</code> | 

**Example**  
```js
dc.logger.warnOnce('Invalid use of .tension on CurveLinear');
```
<a name="dc.logger+debug"></a>

#### logger.debug([msg]) ⇒ [<code>logger</code>](#dc.logger)
Put a debug message to console. It is controlled by `dc.logger.enableDebugLog`

**Kind**: instance method of [<code>logger</code>](#dc.logger)  

| Param | Type |
| --- | --- |
| [msg] | <code>String</code> | 

**Example**  
```js
dc.logger.debug('Total number of slices: ' + numSlices);
```
<a name="dc.logger+deprecate"></a>

#### logger.deprecate([fn], [msg]) ⇒ <code>function</code>
Used to deprecate a function. It will return a wrapped version of the function, which will
will issue a warning when invoked. The warning will be issued only once.

**Kind**: instance method of [<code>logger</code>](#dc.logger)  

| Param | Type |
| --- | --- |
| [fn] | <code>function</code> | 
| [msg] | <code>String</code> | 

**Example**  
```js
_chart.interpolate = dc.logger.deprecate(function (interpolate) {
   if (!arguments.length) {
       return _interpolate;
   }
   _interpolate = interpolate;
   return _chart;
}, 'dc.lineChart.interpolate has been deprecated since version 3.0 use dc.lineChart.curve instead');
```
<a name="dc.logger+annotate"></a>

#### logger.annotate([fn], [msg]) ⇒ <code>function</code>
Used to provide an informational message for a function. It will return a wrapped version of
the function, which will will issue a messsage with stack when invoked. The message will be
issued only once.

**Kind**: instance method of [<code>logger</code>](#dc.logger)  

| Param | Type |
| --- | --- |
| [fn] | <code>function</code> | 
| [msg] | <code>String</code> | 

**Example**  
```js
_chart.interpolate = dc.logger.annotate(function (interpolate) {
   if (!arguments.length) {
       return _interpolate;
   }
   _interpolate = interpolate;
   return _chart;
}, 'dc.lineChart.interpolate has been annotated since version 3.0 use dc.lineChart.curve instead');
```
<a name="dc.config"></a>

### dc.config
**Kind**: static class of [<code>dc</code>](#dc)  

* [.config](#dc.config)
    * [new config()](#new_dc.config_new)
    * [.defaultColors([colors])](#dc.config+defaultColors) ⇒ <code>Array</code> \| [<code>config</code>](#dc.config)

<a name="new_dc.config_new"></a>

#### new config()
General configuration

<a name="dc.config+defaultColors"></a>

#### config.defaultColors([colors]) ⇒ <code>Array</code> \| [<code>config</code>](#dc.config)
Set the default color scheme for ordinal charts. Changing it will impact all ordinal charts.

By default it is set to a copy of
`d3.schemeCategory20c` for backward compatibility. This color scheme has been
[removed from D3v5](https://github.com/d3/d3/blob/master/CHANGES.md#changes-in-d3-50).
In DC 3.1 release it will change to a more appropriate default.

**Kind**: instance method of [<code>config</code>](#dc.config)  

| Param | Type |
| --- | --- |
| [colors] | <code>Array</code> | 

**Example**  
```js
dc.config.defaultColors(d3.schemeSet1)
```
<a name="dc.pieChart"></a>

### dc.pieChart
**Kind**: static class of [<code>dc</code>](#dc)  
**Mixes**: [<code>capMixin</code>](#dc.capMixin), [<code>colorMixin</code>](#dc.colorMixin), [<code>baseMixin</code>](#dc.baseMixin)  

* [.pieChart](#dc.pieChart)
    * [new pieChart(parent, [chartGroup])](#new_dc.pieChart_new)
    * [.slicesCap([cap])](#dc.pieChart+slicesCap) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.externalRadiusPadding([externalRadiusPadding])](#dc.pieChart+externalRadiusPadding) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.innerRadius([innerRadius])](#dc.pieChart+innerRadius) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.radius([radius])](#dc.pieChart+radius) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.cx([cx])](#dc.pieChart+cx) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.cy([cy])](#dc.pieChart+cy) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.minAngleForLabel([minAngleForLabel])](#dc.pieChart+minAngleForLabel) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.emptyTitle([title])](#dc.pieChart+emptyTitle) ⇒ <code>String</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.externalLabels([externalLabelRadius])](#dc.pieChart+externalLabels) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
    * [.drawPaths([drawPaths])](#dc.pieChart+drawPaths) ⇒ <code>Boolean</code> \| [<code>pieChart</code>](#dc.pieChart)

<a name="new_dc.pieChart_new"></a>

#### new pieChart(parent, [chartGroup])
The pie chart implementation is usually used to visualize a small categorical distribution.  The pie
chart uses keyAccessor to determine the slices, and valueAccessor to calculate the size of each
slice relative to the sum of all values. Slices are ordered by [ordering](#dc.baseMixin+ordering)
which defaults to sorting by key.

Examples:
- [Nasdaq 100 Index](http://dc-js.github.com/dc.js/)


| Param | Type | Description |
| --- | --- | --- |
| parent | <code>String</code> \| <code>node</code> \| <code>d3.selection</code> | Any valid [d3 single selector](https://github.com/d3/d3-selection/blob/master/README.md#select) specifying a dom block element such as a div; or a dom element or d3 selection. |
| [chartGroup] | <code>String</code> | The name of the chart group this chart instance should be placed in. Interaction with a chart will only trigger events and redraws within the chart's group. |

**Example**  
```js
// create a pie chart under #chart-container1 element using the default global chart group
var chart1 = dc.pieChart('#chart-container1');
// create a pie chart under #chart-container2 element using chart group A
var chart2 = dc.pieChart('#chart-container2', 'chartGroupA');
```
<a name="dc.pieChart+slicesCap"></a>

#### pieChart.slicesCap([cap]) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
Get or set the maximum number of slices the pie chart will generate. The top slices are determined by
value from high to low. Other slices exeeding the cap will be rolled up into one single *Others* slice.

**Kind**: instance method of [<code>pieChart</code>](#dc.pieChart)  

| Param | Type |
| --- | --- |
| [cap] | <code>Number</code> | 

<a name="dc.pieChart+externalRadiusPadding"></a>

#### pieChart.externalRadiusPadding([externalRadiusPadding]) ⇒ <code>Number</code> \| [<code>pieChart</code>](#dc.pieChart)
Get or set