D3.js Set initial zoom level

I have several graphs set up to zoom on the container and it works great. However, on the initial load, the zoom level is way too close. Is there a method of setting the initial zoom level to avoid having to first zoom out? I am familiar with the .scale() method but have not had any luck implementing it. Is this the way to go or is there something I am missing?

Here is what I have thus far as pertaining to zoom:

var margin = {top: 20, right: 120, bottom: 20, left: 120},
    width = 50000 - margin.right - margin.left,
    height = 120000 - margin.top - margin.bottom;

var x = d3.scale.linear()
    .domain([0, width])
    .range([0, width]);

var y = d3.scale.linear()
    .domain([0, height])
    .range([height, 0]);

var tree = d3.layout.tree()
    .size([height, width])
    .separation(function(a, b) { return (a.parent == b.parent ? 1 : 2) / a.depth; });

var diagonal = d3.svg.diagonal()
    .projection(function(d) { return [d.x, d.y]; });

function zoom(d) {        
      "translate(" + d3.event.translate + ")"+ " scale(" + d3.event.scale + ")");

var svg = d3.select("body").append("svg")
    .attr("width", width + margin.right + margin.left)
    .attr("height", height + margin.top + margin.bottom)
    .attr("transform", "translate(" + margin.left + "," + margin.top + ")")
    .attr("pointer-events", "all")
        .on("zoom", zoom))

    .attr('width', width*5)
    .attr('height', height)
    .attr('border-radius', '20')
    .attr('fill', 'sienna');



I finally got this to work by setting both the initial transform and the zoom behavior to the same value.

var zoom = d3.behavior.zoom().translate([100,50]).scale(.5);

vis = svg.append("svg:svg")
     .attr("width", width)
     .attr("height", height)

D3v4 answer

If you are here looking for the same but with D3 v4,

var zoom = d3.zoom().on("zoom", zooming);

vis = svg.append("svg:svg")
     .attr("width", width)
     .attr("height", height)
     .call(zoom) // here
     .call(zoom.transform, d3.zoomIdentity.translate(100, 50).scale(0.5))
     .attr("transform","translate(100,50) scale(.5,.5)");

Adding this answer as an addendum to the accepted answer in case anyone is still having issues:

The thing that made this really easy to understand was looking here

That being said, I set three variables:

scale, zoomWidth and zoomHeight

scale is the initial scale you want the zoom to be, and then

zoomWidth and zoomHeight are defined as follows:

zoomWidth = (width-scale*width)/2
zoomHeight = (height-scale*height)/2

where width and height are the width and height of the "vis" svg element

the translate above is then amended to be:

.attr("transform", "translate("+zoomWidth+","+zoomHeight+") scale("+scale+")")

as well as the zoom function:


What this does is effectively ensures that your element is zoomed and centered when your visualization is loaded.

Let me know if this helps you! Cheers.


Applies to d3.js v4

This is similar to davcs86's answer, but it reuses an initial transform and implements the zoom function.

// Initial transform to apply
var transform = d3.zoomIdentity.translate(200, 0).scale(1);
var zoom = d3.zoom().on("zoom", handleZoom);

var svg = d3.select("body")
  .attr('width', 800)
  .attr('height', 300)
  .style("background", "red")
  .call(zoom)                       // Adds zoom functionality
  .call(zoom.transform, transform); // Calls/inits handleZoom

var zoomable = svg
  .attr("class", "zoomable")
  .attr("transform", transform);    // Applies initial transform

var circles = zoomable.append('circle')
  .attr("id", "circles")
  .attr("cx", 100)
  .attr("cy", 100)
  .attr('r', 20);

function handleZoom(){
  if (zoomable) {
    zoomable.attr("transform", d3.event.transform);

See it in action: jsbin link


I was using d3 with react and was very frustrated about the initial zoom not working.

I tried the solutions here and none of them worked, what worked instead was using an initial scale factor and positions and then updating the zoom function on the basis of those scale factor and positions

const initialScale = 3;
const initialTranslate = [
  width * (1 - initialScale) / 2,
  height * (1 - initialScale) / 2,

const container = svg
    `translate(${initialTranslate[0]}, ${initialTranslate[1]})scale(${initialScale})`

The zoom function would look something like this

  zoom().on('zoom', () => {
    const transformation = getEvent().transform;
    let {x, y, k} = transformation;
    x += initialTranslate[0];
    y += initialTranslate[1];
    k *= initialScale;

    container.attr('transform', `translate(${x}, ${y})scale(${k})`);

If you noticed the getEvent() as a function, it was because importing event from d3-selection was not working in my case. So I had to do

const getEvent = () => require('d3-selection').event;


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.