d3.svg.axis = function() {

var scale = d3.scale.linear(),

orient = "bottom",

tickMajorSize = 6,

tickMinorSize = 6,

tickEndSize = 6,

tickPadding = 3,

tickArguments_ = [10],

tickValues = null,

tickFormat_,

tickSubdivide = 0;

function axis(g) {

g.each(function() {

var g = d3.select(this);

// Ticks, or domain values for ordinal scales.

var ticks = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments_) : scale.domain()) : tickValues,

tickFormat = tickFormat_ == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments_) : String) : tickFormat_;

// Minor ticks.

var subticks = d3_svg_axisSubdivide(scale, ticks, tickSubdivide),

subtick = g.selectAll(".minor").data(subticks, String),

subtickEnter = subtick.enter().insert("line", "g").attr("class", "tick minor").style("opacity", 1e-6),

subtickExit = d3.transition(subtick.exit()).style("opacity", 1e-6).remove(),

subtickUpdate = d3.transition(subtick).style("opacity", 1);

// Major ticks.

var tick = g.selectAll("g").data(ticks, String),

tickEnter = tick.enter().insert("g", "path").style("opacity", 1e-6),

tickExit = d3.transition(tick.exit()).style("opacity", 1e-6).remove(),

tickUpdate = d3.transition(tick).style("opacity", 1),

tickTransform;

// Domain.

var range = d3_scaleRange(scale),

path = g.selectAll(".domain").data([0]),

pathEnter = path.enter().append("path").attr("class", "domain"),

pathUpdate = d3.transition(path);

// Stash a snapshot of the new scale, and retrieve the old snapshot.

var scale1 = scale.copy(),

scale0 = this.__chart__ || scale1;

this.__chart__ = scale1;

tickEnter.append("line").attr("class", "tick");

tickEnter.append("text");

tickUpdate.select("text").text(tickFormat);

switch (orient) {

case "bottom": {

tickTransform = d3_svg_axisX;

subtickEnter.attr("y2", tickMinorSize);

subtickUpdate.attr("x2", 0).attr("y2", tickMinorSize);

tickEnter.select("line").attr("y2", tickMajorSize);

tickEnter.select("text").attr("y", Math.max(tickMajorSize, 0) + tickPadding);

tickUpdate.select("line").attr("x2", 0).attr("y2", tickMajorSize);

tickUpdate.select("text").attr("x", 0).attr("y", Math.max(tickMajorSize, 0) + tickPadding).attr("dy", ".71em").attr("text-anchor", "middle");

pathUpdate.attr("d", "M" + range[0] + "," + tickEndSize + "V0H" + range[1] + "V" + tickEndSize);

break;

}

case "top": {

tickTransform = d3_svg_axisX;

subtickEnter.attr("y2", -tickMinorSize);

subtickUpdate.attr("x2", 0).attr("y2", -tickMinorSize);

tickEnter.select("line").attr("y2", -tickMajorSize);

tickEnter.select("text").attr("y", -(Math.max(tickMajorSize, 0) + tickPadding));

tickUpdate.select("line").attr("x2", 0).attr("y2", -tickMajorSize);

tickUpdate.select("text").attr("x", 0).attr("y", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("dy", "0em").attr("text-anchor", "middle");

pathUpdate.attr("d", "M" + range[0] + "," + -tickEndSize + "V0H" + range[1] + "V" + -tickEndSize);

break;

}

case "left": {

tickTransform = d3_svg_axisY;

subtickEnter.attr("x2", -tickMinorSize);

subtickUpdate.attr("x2", -tickMinorSize).attr("y2", 0);

tickEnter.select("line").attr("x2", -tickMajorSize);

tickEnter.select("text").attr("x", -(Math.max(tickMajorSize, 0) + tickPadding));

tickUpdate.select("line").attr("x2", -tickMajorSize).attr("y2", 0);

tickUpdate.select("text").attr("x", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "end");

pathUpdate.attr("d", "M" + -tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + -tickEndSize);

break;

}

case "right": {

tickTransform = d3_svg_axisY;

subtickEnter.attr("x2", tickMinorSize);

subtickUpdate.attr("x2", tickMinorSize).attr("y2", 0);

tickEnter.select("line").attr("x2", tickMajorSize);

tickEnter.select("text").attr("x", Math.max(tickMajorSize, 0) + tickPadding);

tickUpdate.select("line").attr("x2", tickMajorSize).attr("y2", 0);

tickUpdate.select("text").attr("x", Math.max(tickMajorSize, 0) + tickPadding).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "start");

pathUpdate.attr("d", "M" + tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + tickEndSize);

break;

}

}

// For quantitative scales:

// - enter new ticks from the old scale

// - exit old ticks to the new scale

if (scale.ticks) {

tickEnter.call(tickTransform, scale0);

tickUpdate.call(tickTransform, scale1);

tickExit.call(tickTransform, scale1);

subtickEnter.call(tickTransform, scale0);

subtickUpdate.call(tickTransform, scale1);

subtickExit.call(tickTransform, scale1);

}

// For ordinal scales:

// - any entering ticks are undefined in the old scale

// - any exiting ticks are undefined in the new scale

// Therefore, we only need to transition updating ticks.

else {

var dx = scale1.rangeBand() / 2, x = function(d) { return scale1(d) + dx; };

tickEnter.call(tickTransform, x);

tickUpdate.call(tickTransform, x);

}

});

}

axis.scale = function(x) {

if (!arguments.length) return scale;

scale = x;

return axis;

};

axis.orient = function(x) {

if (!arguments.length) return orient;

orient = x;

return axis;

};

axis.ticks = function() {

if (!arguments.length) return tickArguments_;

tickArguments_ = arguments;

return axis;

};

axis.tickValues = function(x) {

if (!arguments.length) return tickValues;

tickValues = x;

return axis;

};

axis.tickFormat = function(x) {

if (!arguments.length) return tickFormat_;

tickFormat_ = x;

return axis;

};

axis.tickSize = function(x, y, z) {

if (!arguments.length) return tickMajorSize;

var n = arguments.length - 1;

tickMajorSize = +x;

tickMinorSize = n > 1 ? +y : tickMajorSize;

tickEndSize = n > 0 ? +arguments[n] : tickMajorSize;

return axis;

};

axis.tickPadding = function(x) {

if (!arguments.length) return tickPadding;

tickPadding = +x;

return axis;

};

axis.tickSubdivide = function(x) {

if (!arguments.length) return tickSubdivide;

tickSubdivide = +x;

return axis;

};

return axis;

};

function d3_svg_axisX(selection, x) {

selection.attr("transform", function(d) { return "translate(" + x(d) + ",0)"; });

}

function d3_svg_axisY(selection, y) {

selection.attr("transform", function(d) { return "translate(0," + y(d) + ")"; });

}

function d3_svg_axisSubdivide(scale, ticks, m) {

subticks = [];

if (m && ticks.length > 1) {

var extent = d3_scaleExtent(scale.domain()),

subticks,

i = -1,

n = ticks.length,

d = (ticks[1] - ticks[0]) / ++m,

j,

v;

while (++i < n) {

for (j = m; --j > 0;) {

if ((v = +ticks[i] - j * d) >= extent[0]) {

subticks.push(v);

}

}

}

for (--i, j = 0; ++j < m && (v = +ticks[i] + j * d) < extent[1];) {

subticks.push(v);

}

}

return subticks;

}