240 lines
No EOL
7.2 KiB
JavaScript
240 lines
No EOL
7.2 KiB
JavaScript
import * as d3 from "d3";
|
|
import { h, Fragment } from 'start-dom-jsx'
|
|
|
|
// const projection = d3.geoAitoff();
|
|
|
|
function degreesToRadians(degrees) {
|
|
return (degrees * Math.PI) / 180;
|
|
}
|
|
|
|
function latLonToOffsets(latitude, longitude, mapWidth, mapHeight) {
|
|
const FE = 180; // false easting
|
|
const radius = mapWidth / (2 * Math.PI);
|
|
|
|
const latRad = degreesToRadians(latitude);
|
|
const lonRad = degreesToRadians(longitude + FE);
|
|
|
|
const x = lonRad * radius;
|
|
|
|
const yFromEquator = radius * Math.log(Math.tan(Math.PI / 4 + latRad / 2));
|
|
const y = mapHeight / 2 - yFromEquator;
|
|
|
|
return { x, y };
|
|
}
|
|
|
|
export function viz(vizEl) {
|
|
console.log(d3)
|
|
// vizEl.appendChild(<h2>Hello</h2>);
|
|
|
|
fetch("data/parsed_requests.json")
|
|
.then((response) => response.json())
|
|
.then(start)
|
|
.catch((error) => {
|
|
console.error(error);
|
|
// alert("Data could not be loaded.")
|
|
});
|
|
|
|
// d3.queue()
|
|
// .defer(d3.json, "data/parsed_requests.json") // World shape
|
|
// .await(start)
|
|
}
|
|
|
|
function lerp(X, Y, t) {
|
|
return X * t + Y * (1 - t)
|
|
}
|
|
|
|
function inverse_lerp(a, b, x) {
|
|
return (x - a) / (b - a);
|
|
}
|
|
|
|
function start(parsed_requests) {
|
|
const nodes = parsed_requests.nodes;
|
|
const edges = parsed_requests.edges;
|
|
|
|
const svg = d3.select('svg');
|
|
const g_libraries = svg.append("g").attr("id", "libraries");
|
|
const g_movements = svg.append("g").attr("id", "movements");
|
|
const width = +svg.attr("width"),
|
|
height = +svg.attr("height");
|
|
|
|
// let libraries = {}
|
|
// console.log(nodes, edges)
|
|
const valid_nodes = nodes.filter((n) => n.lat && n.lon).map((node) => {
|
|
const { x: x1, y: y1 } = latLonToOffsets(node.lat, node.lon, 100000, 100000)
|
|
console.log(x1, y1)
|
|
const x2 = inverse_lerp(1358, 1380, x1);
|
|
const y2 = inverse_lerp(32862, 32900, y1);
|
|
|
|
const margin = 200;
|
|
const x = x2 * (width - 2 * margin) + margin;
|
|
const y = y2 * (height - 2 * margin) + margin;
|
|
// console.log(x2, y2)
|
|
// console.log(node)
|
|
|
|
node['x'] = x;
|
|
node['y'] = y;
|
|
return node
|
|
})
|
|
|
|
const nodeMap = Object.fromEntries(valid_nodes.map(d => [d['name'], d]));
|
|
|
|
const links = edges.filter(l => nodeMap[l['Owning Library Name']] && nodeMap[l['Pickup Location']]).map((l, idx) => {
|
|
l.source = nodeMap[l['Owning Library Name']];
|
|
l.target = nodeMap[l['Pickup Location']];
|
|
l.nr = idx;
|
|
return l;
|
|
});
|
|
// .filter((link, index, self) =>
|
|
// // remove incidental duplicates
|
|
// index === self.findIndex((l) => (
|
|
// l.source.id === link.source.id && l.target.id === link.target.id
|
|
// ))
|
|
// );
|
|
|
|
// Reformat the list of link. Note that columns in csv file are called long1, long2, lat1, lat2
|
|
// var link = []
|
|
// edges.forEach(function (row) {
|
|
// source = [+row.long1, +row.lat1]
|
|
// target = [+row.long2, +row.lat2]
|
|
// topush = { type: "LineString", coordinates: [source, target] }
|
|
// link.push(topush)
|
|
// })
|
|
|
|
// Add the path
|
|
const libraries = g_libraries.selectAll(".library");
|
|
libraries.data(valid_nodes, d => d.code)
|
|
.join((enter) => {
|
|
let group = enter.append("g")
|
|
// .attr("class", getClasses)
|
|
// .attr("id", (n) => getIdForTitle(n.fulltext));
|
|
.attr("id", (n) => n.code)
|
|
.attr("transform", (n) => `translate(${n.x}, ${n.y})`);
|
|
|
|
// group.on("click", (evt, n) => {
|
|
// evt.stopPropagation(); this.selectNode(n);
|
|
// });
|
|
// group.on("mouseover", (evt, n) => {
|
|
// this.hoverNode(evt, n);
|
|
// });
|
|
// group.on("mouseout", (evt, n) => {
|
|
// this.endHoverNode(n);
|
|
// });
|
|
group.append('circle').attr("r", 5 /*this.nodeSize*/);
|
|
// group.append('path')
|
|
// .attr('d', (n) => {
|
|
// return getSymbolForNode(n)(n);
|
|
// })
|
|
var nodeTitle = group.append('text').attr("class", "nodeTitle").attr("y", "4").attr('x', 5).text((n) => n.name);
|
|
return group
|
|
})
|
|
|
|
const movements_a = g_movements.selectAll(".movement");
|
|
const movements = movements_a
|
|
.data(links)
|
|
.join(
|
|
enter => {
|
|
let group = enter.append("g")
|
|
.attr("class", (l) => "link " /* TODO type of movement */)
|
|
.attr("id", (l) => `link${l.nr}`);
|
|
group.append("path")
|
|
// .attr("marker-end", "url(#arrowHead)")
|
|
.attr('id', (d, i) => 'linkpath_' + i)
|
|
// .on("mouseover", (ev, link) => {
|
|
// d3.select(ev.target).classed('hover', true);
|
|
// const nodes = document.getElementsByClassName('node');
|
|
// for (let n of nodes) {
|
|
// const d = d3.select(n).datum();
|
|
// if (d == link.target || d == link.source) {
|
|
// n.classList.add('linkHover');
|
|
// }
|
|
// }
|
|
|
|
// this.showRelationTooltip(link, ev);
|
|
// }).on("mouseout", (ev, link) => {
|
|
// this.hideTooltip();
|
|
// d3.select(ev.target).classed('hover', false);
|
|
// const nodes = document.getElementsByClassName('linkHover');
|
|
// while (nodes.length) {
|
|
// nodes[0].classList.remove('linkHover');
|
|
// }
|
|
// }).on("click", (ev, link) => {
|
|
// ev.stopPropagation();
|
|
// this.selectNode(link.source);
|
|
// })
|
|
;
|
|
// group.filter((l) => l.name != "City").append("text").attr("class", "labelText").text(function (l) {
|
|
// return l.name;
|
|
// });
|
|
// group.append("text")
|
|
// .attr("class", "labelText")
|
|
// .attr("dx", 20)
|
|
// .attr("dy", 0)
|
|
// .style("fill", "red")
|
|
// .append("textPath")
|
|
// .attr("xlink:href", function (d, i) { return "#linkid_" + i; })
|
|
// .attr("startOffset","50%")
|
|
// .text((d,i) => d.name );
|
|
return group;
|
|
}
|
|
)
|
|
;
|
|
|
|
movements.each(function (l) {
|
|
let sourceX, targetX, midX, dx, dy, angle;
|
|
|
|
// This mess makes the arrows exactly perfect.
|
|
// thanks to http://bl.ocks.org/curran/9b73eb564c1c8a3d8f3ab207de364bf4
|
|
if (l.source.x < l.target.x) {
|
|
sourceX = l.source.x;
|
|
targetX = l.target.x;
|
|
} else if (l.target.x < l.source.x) {
|
|
targetX = l.target.x;
|
|
sourceX = l.source.x;
|
|
} else if (l.target.isCircle) {
|
|
targetX = sourceX = l.target.x;
|
|
} else if (l.source.isCircle) {
|
|
targetX = sourceX = l.source.x;
|
|
} else {
|
|
midX = (l.source.x + l.target.x) / 2;
|
|
if (midX > l.target.x) {
|
|
midX = l.target.x;
|
|
} else if (midX > l.source.x) {
|
|
midX = l.source.x;
|
|
} else if (midX < l.target.x) {
|
|
midX = l.target.x;
|
|
} else if (midX < l.source.x) {
|
|
midX = l.source.x;
|
|
}
|
|
targetX = sourceX = midX;
|
|
}
|
|
|
|
dx = targetX - sourceX;
|
|
dy = l.target.y - l.source.y;
|
|
angle = Math.atan2(dx, dy);
|
|
|
|
var srcSize = 5; //_mapGraph.getSizeForNode(l.source);
|
|
var tgtSize = 5; //_mapGraph.getSizeForNode(l.target);
|
|
|
|
// Compute the line endpoint such that the arrow
|
|
// it not in the center, but rather slightly out of it
|
|
// use a small ofset for the angle to compensate roughly for the curve
|
|
l.sourceX = sourceX + Math.sin(angle+.5) * srcSize;
|
|
l.targetX = targetX - Math.sin(angle-.5) * tgtSize;
|
|
l.sourceY = l.source.y + Math.cos(angle+.5) * srcSize;
|
|
l.targetY = l.target.y - Math.cos(angle-.5) * tgtSize;
|
|
|
|
|
|
// find radius of arc based on distance between points
|
|
// add a jitter to spread out the lines when links are stacked
|
|
const dr = Math.sqrt(dx * dx + dy * dy) * (.7 + Math.random()*.6);
|
|
|
|
// "M" + d.source.x + "," + d.source.y + "A" + dr + "," + dr + " 0 0,1 " + d.target.x + "," + d.target.y
|
|
let rel = d3.select(this);
|
|
rel.select("path")
|
|
.attr('d', `M ${l.sourceX},${l.sourceY} A ${dr},${dr} 0 0,1 ${l.targetX},${l.targetY}`)
|
|
|
|
|
|
})
|
|
|
|
console.log(libraries)
|
|
} |