【问题标题】:D3.js Synchronized Zoom Across Multiple GraphsD3.js 跨多个图同步缩放
【发布时间】:2019-02-19 00:32:42
【问题描述】:

我想制作一个折线图以与多个网页同步缩放/平移。

这些客户端具有相同的 Javascript 和 HTML 源代码。 用户在客户端 A 上进行缩放或平移,数据域的一天时间的消息被发送到另一个和发送者(上图中的蓝线),并且接收到的客户端的图形将同时更改。当然,其他客户端也可以这样做。 它类似于聊天应用程序。

缩放功能是:

 function zoomed() {
        let msg = [];
        let t = d3.event.transform; //1)

        msg[0] = t.rescaleX(x2).domain()[0].toString(); //2)
        msg[1] = t.rescaleX(x2).domain()[1].toString(); //2)

        sendMessage(msg); //3)
    }
  1. d3.event.transform 捕获鼠标事件。
  2. 转换为日期时间和字符串。
  3. 向服务器发送新的规模域。

服务器将接收到的数据发送给所有客户端:

function passiveZoom(rcv){
        let leftend;
        let rightend;
        leftend = new Date(rcv[0]);
        rightend = new Date(rcv[1]);

        x.domain([leftend, rightend]);

        svg.select(".line").attr("d", valueline);
        svg.select(".axis").call(xAxis);
    }
  1. 从服务器接收到包含新一天时间的消息。
  2. 设置新域,
  3. 更新折线图。

使用它可以缩放|平移所有折线图。

但是,它不能按要求工作。

如果我在客户端 A 中缩放|平移,客户端 B 和客户端 C 将被更改。没关系。

接下来,我在客户端 C 上缩放|平移(上图中的橙色线),所有图形都更改为初始比例和位置。为什么!?

我假设鼠标坐标没有发送给客户端,但是发送鼠标位置坐标时应该如何处理呢?

Zoom|Pan 进程是从 mbostock 的块中派生出来的:Brush & Zoom。发件人还使用t.rescalex (x2).domain() 更改X2 域的范围。 由于图中没有用到X2,所以我把X改成了x2,但是只能放大,看不懂X2的意思。

请告诉我如何同步所有客户端? 什么是 x2?

此代码适用于从 Simple line graph with v4 派生的客户端。

<!DOCTYPE html>
<meta charset="utf-8">
<style>
/* set the CSS */

body {
    font: 12px Arial;
}

path {
    stroke: steelblue;
    stroke-width: 2;
    fill: none;
}

.zoom {
    cursor: move;
    fill: none;
    pointer-events: all;
}

.axis path,
.axis line {
    fill: none;
    stroke: grey;
    stroke-width: 1;
    shape-rendering: crispEdges;
}
</style>

<body>
    <!-- load the d3.js library -->
    <script src="http://d3js.org/d3.v4.min.js"></script>
     <script src="socket.io.js"></script>
    <script>

        //--- Network----
    let rcvT;
    let socket = io.connect('http://localhost:3000'); 

    //Recive event from server
    socket.on("connect", function() {}); 
    socket.on("disconnect", function(client) {}); 
    socket.on("S_to_C_message", function(data) {
        rcvT = data.value;
        passiveZoom(rcvT);

    });
    socket.on("S_to_C_broadcast", function(data) {
        console.log("Rcv broadcast " + data.value);
        rcvT = data.value;
        passiveZoom(rcvT);
    });

    function sendMessage(msg) {
        socket.emit("C_to_S_message", { value: msg }); //send to server
    }

    function sendBroadcast(msg) {
        socket.emit("C_to_S_broadcast", { value: msg }); // send to server
    }

    // --------------------

    // Set the dimensions of the canvas / graph
    var margin = { top: 30, right: 20, bottom: 30, left: 50 },
        width = 600 - margin.left - margin.right,
        height = 270 - margin.top - margin.bottom;

    // Parse the date / time
    var parseDate = d3.timeParse("%d-%b-%y");

    // Set the ranges
    var x = d3.scaleTime().range([0, width]);
    var y = d3.scaleTime().range([height, 0]);
    var x2 = d3.scaleTime().range([0, width]);

    xAxis = d3.axisBottom(x)
        .tickFormat(d3.timeFormat('%d-%b-%y'))
        .ticks(5);

    // var yAxis = d3.svg.axis().scale(y)
    //     .orient("left").ticks(5);
    yAxis = d3.axisLeft(y);

    // Define the line
    var valueline = d3.line()
        .x(function(d) { return x(d.date); })
        .y(function(d) { return y(d.close); });

    // Adds the svg canvas
    var svg = d3.select("body")
        .append("svg")
        .attr("width", width + margin.left + margin.right)
        .attr("height", height + margin.top + margin.bottom)
        .append("g")
        .attr("transform",
            "translate(" + margin.left + "," + margin.top + ")");

    // Get the data
    d3.csv("data.csv", function(error, data) {
        data.forEach(function(d) {
            d.date = parseDate(d.date);
            d.close = +d.close;
        });

        // Scale the range of the data
        x.domain(d3.extent(data, function(d) { return d.date; }));
        x2.domain(x.domain());
        y.domain([0, d3.max(data, function(d) { return d.close; })]);

        // Add the valueline path.
        svg.append("path")
            .data([data])
            .attr("class", "line")
            .attr("d", valueline);

        // Add the X Axis
        svg.append("g")
            .attr("class", "x axis")
            .attr("transform", "translate(0," + height + ")")
            .call(xAxis);

        // Add the Y Axis
        svg.append("g")
            .attr("class", "y axis")
            .call(yAxis);

    });
    //follow is zoom method------------------
    zoom = d3.zoom()
        .scaleExtent([1, 45])
        .translateExtent([
            [0, 0],
            [width, height]
        ])
        .extent([
            [0, 0],
            [width, height]
        ])
        .on("zoom", zoomed);

    svg.append("rect")
        .attr("class", "zoom")
        .attr("width", width)
        .attr("height", height)
        .attr("transform", "translate(" + margin.left + "," + margin.top + ")")
        .call(zoom);

    function zoomed() {
        let msg = [];
        let t = d3.event.transform;

        msg[0] = t.rescaleX(x2).domain()[0].toString();
        msg[1] = t.rescaleX(x2).domain()[1].toString();

        sendMessage(msg);
    }

    function passiveZoom(rcv){
        let start;
        let end;
        start = new Date(rcv[0]);
        end = new Date(rcv[1]);

        x.domain([start, end]);

        svg.select(".line").attr("d", valueline);
        svg.select(".axis").call(xAxis);
    }



    </script>
</body>

如果你尝试这段代码,你应该在几个 bowser 窗口中执行,然后运行这个 node.js 脚本。

var http = require("http");
var socketio = require("socket.io");
var fs = require("fs");

console.log("reflector start");


var server = http.createServer(function(req, res) {
     res.writeHead(200, {"Content-Type":"text/html"});
     var output = fs.readFileSync("./index.html", "utf-8");
     res.end(output);
}).listen(process.env.VMC_APP_PORT || 3000);

var io = socketio.listen(server);

io.sockets.on("connection", function (socket) {

  // send message to all
  socket.on("C_to_S_message", function (data) {
    io.sockets.emit("S_to_C_message", {value:data.value});
       console.log("MSG "+data.value);
  });

  // boradcast send to all without sender
  socket.on("C_to_S_broadcast", function (data) {
    socket.broadcast.emit("S_to_C_broadcast", {value:data.value});
  });

  // disconnection
  socket.on("disconnect", function () {
  console.log("disconnect");
  });
});

【问题讨论】:

  • 与您的问题无关:为什么您打算这样做?这些客户端机器是由真实的人类用户控制的吗?如果“是”,我认为这似乎提供了一个糟糕的用户体验......(无论如何,+1 是一个写得很好的问题)
  • 对了,x2是画笔使用的时间刻度,也就是那个图表的下半部分,叫做“上下文”。你可以看到x2域永远不会改变(但x域会)。
  • 谢谢杰拉尔多。我想在一个网页中同时显示多个时间序列(日人口、日期 GDP 等)的数据。每个客户端都加载了
  • 哎呀错过类型。我更正了代码。 “ msg[0] = t.rescaleX(x).domain()[0].toString();” -> " msg[0] = t.rescaleX(x2).domain()[0].toString();"如果是“rescaleX(x)”,交互只是放大。
  • 进一步深入了解@Gerardo 启动的内容:为什么会出现服务器往返的麻烦?为什么不将其保留在客户端上,从而减少/避免延迟?不要误会我的意思,没有伤害的意思!只是想了解正在发生的事情,也许自己也学一点;-)

标签: javascript node.js d3.js zooming interaction


【解决方案1】:

假设我理解了问题,

(第一个)问题是您没有更新zoom 本身。

在使用d3.zoom 的地方,它通常只是跟踪当前的缩放状态,而不是直接在容器上应用变换。在画笔和缩放示例中,缩放是通过重新缩放数据来应用的,而不是通过对容器应用 SVG 变换。使用那个例子,我们可以看到,当我们刷机的时候,我们也调用了:

svg.select(".zoom").call(zoom.transform, someZoomTransform);

这个:

  • 更新由zoom 变量跟踪的缩放状态/身份
  • 发出一个缩放事件,该事件调用缩放函数(在画笔和缩放示例中,如果画笔触发它,则忽略该函数)

如果我们删除这条线,通过刷子改变缩放状态不会更新缩放。刷到一个很小的域,然后放大看here

在您的代码中就是这种情况,当您使用zoomed 函数和d3.event.transform 更新图表时,您不会更新缩放状态。您正在更新秤 - 但 zoom 未更新。

下面我将演示如何使用一种缩放来更新另一种。 注意:如果每个缩放函数调用其他函数,我们将进入一个无限循环。使用画笔和缩放我们可以查看触发器是否是画笔以查看是否需要缩放功能,下面我使用 d3.event.sourceEvent.target 来查看其他缩放功能是否需要传播缩放

var svg = d3.select("svg");
var size = 100;
var zoom1 = d3.zoom().scaleExtent([0.25,4]).on("zoom", zoomed1);
var zoom2 = d3.zoom().scaleExtent([0.25,4]).on("zoom", zoomed2);

var rect1 = svg.append("rect")
  .attr("width", size)
  .attr("height", size)
  .attr("x", 10)
  .attr("y", 10)
  .call(zoom1);
var rect2 = svg.append("rect")
  .attr("width", size)
  .attr("height", size)
  .attr("x", 300)
  .attr("y", 10)
  .call(zoom2);

function zoomed1() {
  var t = d3.event.transform;
  var k = Math.sqrt(t.k);
  rect1.attr("width",size/k).attr("height",size*k);
  
  if(d3.event.sourceEvent.target == this) {
    rect2.call(zoom2.transform,t); 
  }
}
function zoomed2() {
  var t = d3.event.transform;
  var k = Math.sqrt(t.k);
  rect2.attr("width",size/k).attr("height",size*k);
   
  if(d3.event.sourceEvent.target == this) {
    rect1.call(zoom2.transform,t); 
  }
}
rect {
    cursor: pointer;
	stroke: #ccc;
	stroke-width: 10;
  }
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/5.7.0/d3.min.js"></script>
Zoom on one rectangle to update the other.
<svg width="600" height="300"></svg>

您可能想知道为什么我对尺寸进行硬编码,为什么不直接修改当前尺寸,而不是原始尺寸。答案是缩放变换比例是相对于原始状态的比例——而不是最后一个状态。例如,如果每次缩放时 scale 加倍,我们放大 2 倍,则 scale 为:k=1 → k=2 → k=4。如果我们将形状的当前大小乘以新的比例,我们得到 size=1 → size=2 → size=8,这是不正确的(在缩小到 k=2 时,我们将放大两倍而不是缩小)。变换是累积的已经,我们不想将它应用到已应用变换的值。

将转换应用于转换后的值,而不是原始值,即使在缩小时也会导致缩放增加 - 这可能是您在缩小时遇到问题的原因

所以,这让我想到了第二个问题,x2x2 是引用,原始值。是的,正如 Gerardo 所说,它也是您示例中画笔的比例,但更重要的是,他指出这个比例不会改变。因此,x2 非常适合用作参考比例,在给定缩放状态的情况下,我们可以使用它来转换 x

x.domain(t.rescaleX(x2).domain()); 

这里发生了什么? transform.rescaleX(x2) 不修改 x2,它“返回一个连续尺度 x 的副本,其域被变换 [给定缩放变换]。(docs)”。我们获取副本的域并将其分配给x 比例(范围当然保持不变),然后将变换应用到x 比例。 这与我上面的 sn-p 与正方形/矩形基本相同,我为形状的初始大小保留一个参考值,并将变换应用于该值。

让我们用一个带有比例而不是普通形状的基本图形/绘图来看看这个:

var svg = d3.select("svg");
var data = [[0,300],[1,20],[2,300]];

// Area generators:
var leftArea = d3.area().curve(d3.curveBasis)
  .x(function(d) { return leftX(d[0]); })
  
var rightArea = d3.area().curve(d3.curveBasis)
  .x(function(d) { return rightX(d[0]); })

// Scales
var leftX = d3.scaleLinear().domain([0,2]).range([0,250]);
var rightX = d3.scaleLinear().domain([0,2]).range([300,550]);

var leftX2 = leftX.copy();
var rightX2 = rightX.copy();

// Zooms
var leftZoom = d3.zoom().scaleExtent([0.25,4]).on("zoom", leftZoomed);
var rightZoom = d3.zoom().scaleExtent([0.25,4]).on("zoom", rightZoomed);

// Graphs
var leftGraph = svg.append("path")
  .attr("d", leftArea(data))
  .call(leftZoom);
  
var rightGraph = svg.append("path")
  .attr("d", rightArea(data))
  .call(rightZoom);
  
function leftZoomed() {
  var t = d3.event.transform;
  leftX.domain(t.rescaleX(leftX2).domain());
  leftGraph.attr("d",leftArea(data));
        
  if(d3.event.sourceEvent.target == this) {
    rightGraph.call(rightZoom.transform,t); 
  }
}
function rightZoomed() {
  var t = d3.event.transform;
  rightX.domain(t.rescaleX(rightX2).domain());
  rightGraph.attr("d",rightArea(data));
        
  if(d3.event.sourceEvent.target == this) {
    leftGraph.call(leftZoom.transform,t); 
  }
}
path {
  cursor: pointer;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/5.7.0/d3.min.js"></script>
    Zoom on one plot to update the other (zoom on the path area itself)
    <svg width="600" height="300"></svg>

简单地说,要在一页或跨客户端同步多个可缩放的缩放图,您应该:

  • 使用selection.call(zoom.transform,transform) 更新每个缩放
  • 使用当前变换和参考比例重新调整每个比例。

我还没有尝试使用多个客户端和套接字进行此操作。但是,以上内容应该有助于解释如何解决问题。但是,对于多个客户端,您可能需要修改我如何停止缩放事件的无限循环,在转换对象中使用或设置属性可能是最简单的。此外,正如 rioV8 所指出的,您可能应该传递缩放参数(或者更好的是 d3.event 本身),而不是域,尽管可以使用仅域选项。

使用套接字时,我在发送对象时确实遇到了一些麻烦——我不熟悉 socket.io,也没有花大量时间寻找,但我让它与缩放和被动缩放功能一起使用,如下所示:

function zoomed() {
    let t = d3.event.transform;

    // 1. update the scale, same as in brush and zoom:
    x.domain(t.rescaleX(x2).domain());

    // 2. redraw the graph and axis, same as in brush and zoom:
    path.attr("d", area);  // where path is the graph
    svg.select(".xaxis").call(xAxis);

    // 3. Send the transform, if needed:
    if(t.alreadySent == undefined) {
      t.alreadySent = true; // custom property.
      sendMessage([t.k,t.x,t.y,t.alreadySent]);
    }
}

function passiveZoom(rcv){
    // build a transform object (since I was unable to successfully transmit the transform)
    var t = d3.zoomIdentity;
    t.k = rcv[0];
    t.x = rcv[1];
    t.y = rcv[2];
    t.alreadySent = rcv[3];
    //trigger a zoom event (invoke zoomed function with new transform data).
    rect.call(zoom.transform,t);  // where rect is the selection that zoom is called on.
}

我没有发送事件,而是(仅)发送转换参数和一个标志,以注意被动缩放功能触发的缩放事件不需要再次向前传递。这原则上完全基于上述 sn-ps。

没有修改服务器端脚本。这是我使用的client side - 它比您的代码更基本,因为我去掉了 y 刻度、y 轴、csv 数据源等。

【讨论】:

  • 嗯,我对这个答案还不是很满意:1)我想你使用的是 Firefox,对吧? Event.originalTarget 仅由该浏览器[支持](developer.mozilla.org/en-US/docs/Web/API/Event/originalTarget)。使用 Chrome 时,sn-ps 无法按预期工作;您一次看到一个矩形的缩放,但没有同步。修复很简单,当然,改用Event.target。 2) 引用的行,具体来说是zoom.transform(),没有
  • 触发缩放事件。 3)这更多的是风格问题(这里开始吹毛求疵)但我个人不喜欢someZoomIdentity,因为缩放身份通常用于指代身份转换d3.zoomIdentity()
  • @altocumulus 昨晚根本没想过要跨平台测试,通过在变换中添加一个属性来修改它以检查何时传播缩放(稍后会看一下缩放目标,只是去上班)。第二,我从技术角度没有考虑过这一点,我想可以公平地说zoom.transform 发出缩放事件(如文档中所述)?第三点,我对那里的语言进行了空白,更新了,感谢您的评论,我对第一点感到非常尴尬-尽管其他点也是很好的批评。
  • 您发现自己在第二点上至少和在第一点上一样尴尬 ;-) 我完全忽略了提到 zoom.transform() 的事件的文档。然而,我建议不要在内部对象上引入新属性。而不是d3.event.sourceEvent.originalTarget == this,只需使用d3.event.sourceEvent.target == this
  • 啊,zoom.transform() 事件很容易错过。我已经合并了 sourceEvent.target 选项,你说得对,弄乱了内部结构。我不明白为什么这种方法也不适用于套接字 - 每个浏览器中的缩放元素可能相同,但目标对象引用会不同。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2022-10-24
  • 1970-01-01
  • 2012-06-22
  • 1970-01-01
相关资源
最近更新 更多