How to match up scaleBand with scaleLinear in D3.js

Question

I have two series of scale, one is linear and the other is band, how can I make them to match up if there is some caps in the data.

Take a look at the example if necessary. Mouse over and you see the boxes are not matching with the breaks of line.

Answer 1

If you want your scaleBand to be scaled (widened) where data is missing, I don't think that the scaleBand is the proper method for this, but it is unclear if that is something you want. Band scales are intended to provide equal spacing for each data value and that all values are present - it is an ordinal scale.

---

Assuming you only want the band scale to be aligned with your data where it is present:

If you log the domains of each of your x scales (scaleBand and scaleLinear) we find that the scaleBand has a domain of:

[ "1", "2", "8", "9", "13", "14", "20", "22" ] // 8 elements

And the scaleLinear has a domain of:

[ 1, 22 ]  // a span of 22 'elements'

The scaleBand will need an equivalent domain to the scaleLinear. You can do this statically ( which I show mostly to demonstrate how d3.range will work):

let xBand = d3.scaleBand()
  .domain(d3.range(1,23))
  .rangeRound([0, width]);

This actually produces a domain that has 22 elements from 1 through 22.

or dynamically:

let xBand = d3.scaleBand()
   .domain(d3.range(d3.min(testData1, d => d[0],
                    d3.max(testData1, d => d[0]+1)))

You could do this other ways, but the d3.range() function is nice and easy.

However, there is still one issue that remains, this is aligning the ticks between the two scales. For the linear scale, the tick for the first value (1) is on the y axis, but the band gap scale starts (and is not centered) on the y axis and fills the gap between 1 and 2. In other words, the center point of the band does not align vertically with the vertices of the line graph.

This can be addressed by adding 0.5 to both the lower and upper bounds of the linear scale's domain:

let xDomain = [
  d3.min(testData1, d => d[0]-0.5),
  d3.max(testData1, d => d[0]+0.5)
];

I've udpated your codepen with the relevant changes: codepen.

And in the event that that disappears, here is a snippet (the mouse over does not work for me for some reason in the snippet, it does in the codepen )

let width = 1000;
let height = 300;

let svg = d3.select(".wrapper-area-simple").append("svg")
  .attr("width", width + 80)
  .attr("height", height + 80)
  .append('svg:g')
  .attr('transform', 'translate(40, 30)');

let testData1 = [
  [ 1, 10],
  [ 2, 30],
  [ 8, 34],
  [ 9, 26],
  [13, 37],
  [14, 12],
  [20, 23],
  [22, 16],
];

let xDomain = [
  d3.min(testData1, d => d[0]-0.5),
  d3.max(testData1, d => d[0]+0.5)
];



let x = d3.scaleLinear()
  .rangeRound([0, width])
  .domain(xDomain);

let y = d3.scaleLinear()
  .range([height, 0])
  .domain(d3.extent(testData1, d => d[1]));

let line = d3.line()
  .x(d => x(d[0]))
  .y(d => y(d[1]));

svg.append('svg:g')
  .datum(testData1)
  .append('svg:path')
  .attr('d', line)
  .attr('fill', 'none')
  .attr('stroke', '#000');

let xAxis = d3.axisBottom(x)
  .ticks(testData1.length);
svg.append('svg:g')
  .call(xAxis)
  .attr('transform', `translate(0, 300)`);
  
let xBand = d3.scaleBand()
   .domain(d3.range(d3.min(testData1, d => d[0]),
                    d3.max(testData1, d => d[0]+1)
                    ))
   .rangeRound([0, width]);

svg.append('svg:g')
  .selectAll('rect')
  .data(testData1)
  .enter()
  .append('svg:rect')
  .attr('x', d => xBand(d[0]))
  .attr('width', xBand.bandwidth())
  .attr('height', height)
  .attr('fill', '#000')
  .on('mouseover', function() {
    d3.select(this).classed('over', true);
  })
  .on('mouseout', function() {
    d3.select(this).classed('over', false);
  });

svg {
  border: 1px solid red;
}
rect {
  opacity: .1;
}
rect.over {
    opacity: .2;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.min.js"> </script>

<div class="wrapper-area-simple"></div>

Answer 2

Well, bad news for you: they will never match up (in your case). Let's see why.

This is your data:

let testData1 = [
    [1, 10],
    [2, 30],
    [8, 34],
    [9, 26],
    [13, 37],
    [14, 12],
    [20, 23],
    [22, 16],
];

As you can see, regarding the x coordinate, the line jumps from 1 to 2, but then from 2 to 8, from 8 to 9, and then from 9 to 13... That is, the x range intervals are not regular, evenly spaced. So far, so good.

However, when you pass the same data to the band scale, this is what it does: it divides the range ([0, width], which is basically the width) by testData1.length, that is, it divides the range by 8, and creates 8 equal intervals. Those are your bands, and that's the expected behaviour of the band scale. From the documentation:

Discrete output values are automatically computed by the scale by dividing the continuous range into uniform bands. (emphasis mine)

One solution here is simply using another linear scale:

let xBand = d3.scaleLinear()
    .domain(xDomain)
    .rangeRound([0, width]);

And this math to the width of the rectangles:

.attr('width', (d,i) => testData1[i+1] ? xBand(testData1[i+1][0]) - xBand(d[0]) : 0)

Here is your updated Codepen: http://codepen.io/anon/pen/MJdGyY?editors=0010