45:["$","title",null,{"children":"Evenly-Spaced Streamlines | Lemon | Observable"}] 4d:T6e1,Plot.plot({ inset: 6, width: Math.min(width, 600), aspectRatio: 1, // axis: null, marks: [ PlotSampler(sampler, { stroke: "#eee", shape: "sword", random: (() => { const rg = makeRandomGenerator("plot sampler"); return () => rg.random(); })() }), Plot.dot( lines.slice(0, state.line + 1).map((line) => line.seedPoint), { x: "x", y: "y" } ), Plot.text( lines.slice(0, state.line + 1).map((line) => line.seedPoint), { x: "x", y: "y", dy: -8 } ), // PlotSampler(rotate(sampler), { stroke: "#eee" }), // Plot.line(trace(sampler, [0, 0.5], { scale: 0.01 }), { curve: "natural" }), Plot.line( lines .slice(0, state.line) .flatMap((line, index) => line.map((point) => ({ index, ...point }))), { x: "x", y: "y", z: "index", curve: "natural" } ), state.finish ? undefined : Plot.line( lines[state.line].slice( ...(state.grow > lines[state.line].length - state.seed ? [lines[state.line].length - state.grow] : [state.seed, state.seed + state.grow]) ), { x: "x", y: "y", curve: "natural", strokeWidth: 3 } ), Plot.tip( lines.slice(0, state.line + 1).map((line) => line.seedPoint), Plot.pointer({ x: "x", y: "y", title: (a, i) => `${i}` }) ), Plot.arrow( lines.slice(1, state.line + 1), Plot.pointer({ x1: (a) => a.seedPoint.originPoint.x, y1: (a) => a.seedPoint.originPoint.y, x2: (a) => a.seedPoint.x, y2: (a) => a.seedPoint.y, stroke: "#aaa" }) ) ] })4e:T1aa7,class Streamlines { static STATE_INIT = 0; static STATE_STREAMLINE = 1; static STATE_PROCESS_QUEUE = 2; static STATE_DONE = 3; static STATE_SEED_STREAMLINE = 4; constructor(protoOptions) { this.options = Object.create(null); if (!protoOptions) throw new Error("Configuration is required to compute streamlines"); if (!protoOptions.boundingBox) { console.warn( "No bounding box passed to streamline. Creating default one" ); this.options.boundingBox = { left: -5, top: -5, width: 10, height: 10 }; } else { this.options.boundingBox = protoOptions.boundingBox; } Streamlines.normalizeBoundingBox(this.options.boundingBox); this.boundingBox = this.options.boundingBox; this.options.vectorField = protoOptions.vectorField; this.options.onStreamlineAdded = protoOptions.onStreamlineAdded; this.options.onPointAdded = protoOptions.onPointAdded; this.options.forwardOnly = protoOptions.forwardOnly; this.options.seedDirection = protoOptions.seedDirection; this.options.fixVectorField = protoOptions.fixVectorField; this.options.seedStreamlinePolicy = protoOptions.seedStreamlinePolicy; if (!protoOptions.seed) { this.options.seed = new Vector( this.random() * this.boundingBox.width + this.boundingBox.left, this.random() * this.boundingBox.height + this.boundingBox.top ); } else if (Array.isArray(protoOptions.seed)) { var seed = protoOptions.seed.shift(); this.options.seed = new Vector(seed.x, seed.y); this.options.seedArray = protoOptions.seed; } else { this.options.seed = new Vector(protoOptions.seed.x, protoOptions.seed.y); } // Separation between streamlines. Naming according to the paper. this.options.dSep = protoOptions.dSep > 0 ? protoOptions.dSep : 1 / Math.max(this.boundingBox.width, this.boundingBox.height); // When should we stop integrating a streamline. this.options.dTest = protoOptions.dTest > 0 ? protoOptions.dTest : this.options.dSep * 0.5; // Lookup grid helps to quickly tell if there are points nearby this.grid = LookupGrid.create(this.boundingBox, this.options.dSep); // Integration time step. this.options.timeStep = protoOptions.timeStep > 0 ? protoOptions.timeStep : 0.01; this.options.stepsPerIteration = protoOptions.stepsPerIteration > 0 ? protoOptions.stepsPerIteration : 10; this.options.maxTimePerIteration = protoOptions.maxTimePerIteration > 0 ? protoOptions.maxTimePerIteration : 1000; this.stepsPerIteration = this.options.stepsPerIteration; this.resolve; this.state = Streamlines.STATE_INIT; this.finishedStreamlineIntegrators = []; this.streamlineIntegrator = StreamlineIntegrator.create( this.options.seed, this.grid, this.options ); this.disposed = false; this.running = false; this.nextTimeout; // It is asynchronous. If this is used in a browser we don't want to freeze the UI thread. // On the other hand, if you need this to be sync - we can extend the API. Just let me know. } getGrid() { return this.grid; } run() { if (this.running) return; this.running = true; this.nextTimeout = setTimeout(this.nextStep.bind(this), 0); return new Promise(this.assignResolve.bind(this)); } assignResolve(pResolve) { this.resolve = pResolve; } dispose() { this.disposed = true; clearTimeout(this.nextTimeout); } nextStep() { if (this.disposed) return; var maxTimePerIteration = this.options.maxTimePerIteration; var start = window.performance.now(); for (var i = 0; i < this.stepsPerIteration; ++i) { if (this.state === Streamlines.STATE_INIT) this.initProcessing(); if (this.state === Streamlines.STATE_STREAMLINE) this.continueStreamline(); if (this.state === Streamlines.STATE_PROCESS_QUEUE) this.processQueue(); if (this.state === Streamlines.STATE_SEED_STREAMLINE) this.seedStreamline(); if (window.performance.now() - start > maxTimePerIteration) break; if (this.state === Streamlines.STATE_DONE) { this.resolve(this.options); return; } } this.nextTimeout = setTimeout(this.nextStep.bind(this), 0); } initProcessing() { var streamLineCompleted = this.streamlineIntegrator.next(); if (streamLineCompleted) { this.addStreamLineToQueue(); this.state = Streamlines.STATE_PROCESS_QUEUE; } } seedStreamline() { var currentStreamLine = this.options.seedStreamlinePolicy === "dfs" ? this.finishedStreamlineIntegrators.slice(-1)[0] : this.finishedStreamlineIntegrators[0]; var validCandidate = currentStreamLine.getNextValidSeed(); if (validCandidate) { this.streamlineIntegrator = StreamlineIntegrator.create( validCandidate, this.grid, this.options ); this.state = Streamlines.STATE_STREAMLINE; } else { this.options.seedStreamlinePolicy === "dfs" ? this.finishedStreamlineIntegrators.pop() : this.finishedStreamlineIntegrators.shift(); this.state = Streamlines.STATE_PROCESS_QUEUE; } } processQueue() { if (this.finishedStreamlineIntegrators.length === 0) { this.state = Streamlines.STATE_DONE; } else { this.state = Streamlines.STATE_SEED_STREAMLINE; } } continueStreamline() { var isDone = this.streamlineIntegrator.next(); if (isDone) { this.addStreamLineToQueue(); this.state = Streamlines.STATE_SEED_STREAMLINE; } } addStreamLineToQueue() { var streamLinePoints = this.streamlineIntegrator.getStreamline(); if (streamLinePoints.length > 1) { this.finishedStreamlineIntegrators.push(this.streamlineIntegrator); if (this.options.onStreamlineAdded) this.options.onStreamlineAdded(streamLinePoints, this.options); } } random() { return (this.options.random || Math.random)(); } static normalizeBoundingBox(bbox) { var requiredBoxMessage = "Bounding box {left, top, width, height} is required"; if (!bbox) throw new Error(requiredBoxMessage); Streamlines.assertNumber(bbox.left, requiredBoxMessage); Streamlines.assertNumber(bbox.top, requiredBoxMessage); if (typeof bbox.size === "number") { bbox.width = bbox.size; bbox.height = bbox.size; } Streamlines.assertNumber(bbox.width, requiredBoxMessage); Streamlines.assertNumber(bbox.height, requiredBoxMessage); if (bbox.width <= 0 || bbox.height <= 0) throw new Error("Bounding box cannot be empty"); } static assertNumber(x, msg) { if (typeof x !== "number" || Number.isNaN(x)) throw new Error(msg); } }4f:Tb61,class LookupGrid { constructor(bbox, dSep) { this.bbox = bbox; this.dSep = dSep; this.bboxSize = Math.max(bbox.width, bbox.height); this.cellsCount = Math.ceil(this.bboxSize / dSep); this.cells = new Map(); } static create(bbox, dSep) { return new LookupGrid(bbox, dSep); } findNearest(x, y) { var cx = this.gridX(x); var cy = this.gridY(y); let minDistance = Infinity; for (var col = -1; col < 2; ++col) { var currentCellX = cx + col; if (currentCellX < 0 || currentCellX >= this.cellsCount) continue; var cellRow = this.cells.get(currentCellX); if (!cellRow) continue; for (var row = -1; row < 2; ++row) { var currentCellY = cy + row; if (currentCellY < 0 || currentCellY >= this.cellsCount) continue; var cellCol = cellRow.get(currentCellY); if (!cellCol) continue; let d = cellCol.getMinDistance(x, y); if (d < minDistance) minDistance = d; } } return minDistance; } isOutside(x, y) { return ( x < this.bbox.left || x > this.bbox.left + this.bbox.width || y < this.bbox.top || y > this.bbox.top + this.bbox.height ); } occupyCoordinates(point) { var x = point.x, y = point.y; this.getCellByCoordinates(x, y).occupy(point); } isTaken(x, y, checkCallback) { if (!this.cells) return false; var cx = this.gridX(x); var cy = this.gridY(y); for (var col = -1; col < 2; ++col) { var currentCellX = cx + col; if (currentCellX < 0 || currentCellX >= this.cellsCount) continue; var cellRow = this.cells.get(currentCellX); if (!cellRow) continue; for (var row = -1; row < 2; ++row) { var currentCellY = cy + row; if (currentCellY < 0 || currentCellY >= this.cellsCount) continue; var cellCol = cellRow.get(currentCellY); if (!cellCol) continue; if (cellCol.isTaken(x, y, checkCallback)) return true; } } return false; } getCellByCoordinates(x, y) { this.assertInBounds(x, y); var rowCoordinate = this.gridX(x); var row = this.cells.get(rowCoordinate); if (!row) { row = new Map(); this.cells.set(rowCoordinate, row); } var colCoordinate = this.gridY(y); var cell = row.get(colCoordinate); if (!cell) { cell = new Cell(); row.set(colCoordinate, cell); } return cell; } gridX(x) { return Math.floor((this.cellsCount * (x - this.bbox.left)) / this.bboxSize); } gridY(y) { return Math.floor((this.cellsCount * (y - this.bbox.top)) / this.bboxSize); } assertInBounds(x, y) { if (this.bbox.left > x || this.bbox.left + this.bboxSize < x) { throw new Error("x is out of bounds"); } if (this.bbox.top > y || this.bbox.top + this.bboxSize < y) { throw new Error("y is out of bounds"); } } } 50:T1c6a,class StreamlineIntegrator { static FORWARD = 1; static BACKWARD = 2; static DONE = 3; constructor(start, grid, config) { this.start = start; this.grid = grid; this.config = config; if (config.fixVectorField) { // fix vector for 1 line this.vectorField = config.vectorField; } this.points = [start]; this.points.seedPoint = this.start; this.pos = start; this.state = StreamlineIntegrator.FORWARD; this.candidate = null; this.lastCheckedSeed = -1; this.ownGrid = LookupGrid.create(config.boundingBox, config.timeStep * 0.9); } static create(start, grid, config) { return new StreamlineIntegrator(start, grid, config); } getStreamline() { return this.points; } mapSeedOrder(lastCheckedSeed) { if (this.config.seedDirection !== "center") { return lastCheckedSeed; } const seedIndex = this.points.indexOf(this.start); if (seedIndex * 2 < this.points.length) { if (lastCheckedSeed <= seedIndex * 2) { const offset = Math.ceil(lastCheckedSeed / 2); const direction = lastCheckedSeed % 2 ? 1 : -1; return seedIndex + direction * offset; } else { return lastCheckedSeed; } } else { const width = this.points.length - 1 - seedIndex; if (lastCheckedSeed <= width * 2) { const offset = Math.ceil(lastCheckedSeed / 2); const direction = lastCheckedSeed % 2 ? 1 : -1; return seedIndex + direction * offset; } else { return this.points.length - 1 - lastCheckedSeed; } } } getNextValidSeed() { while (this.lastCheckedSeed < this.points.length - 1) { this.lastCheckedSeed += 1; var p = this.points[this.mapSeedOrder(this.lastCheckedSeed)]; var v = this.normalizedVectorField(p); if (!v) continue; // Check one normal. We just set c = p + n, where n is orthogonal to v. // Since v is unit vector we can multiply it by scaler (config.dSep) to get to the // right point. It is also easy to find normal in 2d: normal to (x, y) is just (-y, x). // You can get it by applying 2d rotation matrix.) var cx = p.x - v.y * this.config.dSep; var cy = p.y + v.x * this.config.dSep; // if ( // Array.isArray(this.config.seedArray) && // this.config.seedArray.length > 0 // ) { // var seed = this.config.seedArray.shift(); // cx = seed.x; // cy = seed.y; // } if ( !this.grid.isOutside(cx, cy) && !this.grid.isTaken(cx, cy, this.checkDSep.bind(this)) ) { // this will let us check the other side. When we get back // into this method, the point `cx, cy` will be taken (by construction of another streamline) // And we will throw through to the next orthogonal check. this.lastCheckedSeed -= 1; const seedPoint = new Vector(cx, cy); seedPoint.originPoint = p; return seedPoint; } // Check orthogonal coordinates on the other side (o = p - n). var ox = p.x + v.y * this.config.dSep; var oy = p.y - v.x * this.config.dSep; if ( !this.grid.isOutside(ox, oy) && !this.grid.isTaken(ox, oy, this.checkDSep.bind(this)) ) { const seedPoint = new Vector(ox, oy); seedPoint.originPoint = p; return seedPoint; } } } checkDTest(distanceToCandidate) { if (StreamlineIntegrator.isSame(distanceToCandidate, this.config.dTest)) return false; return distanceToCandidate < this.config.dTest; } checkDSep(distanceToCandidate) { if (StreamlineIntegrator.isSame(distanceToCandidate, this.config.dSep)) return false; return distanceToCandidate < this.config.dSep; } next() { while (true) { this.candidate = null; if (this.state === StreamlineIntegrator.FORWARD) { var point = this.growForward(); if (point) { this.points.push(point); this.ownGrid.occupyCoordinates(point); this.pos = point; var shouldPause = this.notifyPointAdded(point); if (shouldPause) return; } else { // Reset position to start, and grow backwards: if (this.config.forwardOnly) { this.state = StreamlineIntegrator.DONE; } else { this.pos = this.start; this.state = StreamlineIntegrator.BACKWARD; } } } if (this.state === StreamlineIntegrator.BACKWARD) { var point = this.growBackward(); if (point) { this.points.unshift(point); this.pos = point; this.ownGrid.occupyCoordinates(point); var shouldPause = this.notifyPointAdded(point); if (shouldPause) return; } else { this.state = StreamlineIntegrator.DONE; } } if (this.state === StreamlineIntegrator.DONE) { this.points.forEach((p) => this.occupyPointInGrid(p)); return true; } } } occupyPointInGrid(p) { this.grid.occupyCoordinates(p); } growForward() { var velocity = rk4( this.pos, this.config.timeStep, this.normalizedVectorField.bind(this) ); if (!velocity) return; // Hit the singularity. return this.growByVelocity(this.pos, velocity); } growBackward() { var velocity = rk4( this.pos, -this.config.timeStep, this.normalizedVectorField.bind(this) ); if (!velocity) return; // Singularity // velocity = velocity.mulScalar(-1); return this.growByVelocity(this.pos, velocity); } growByVelocity(pos, velocity) { this.candidate = pos.add(velocity); if (this.grid.isOutside(this.candidate.x, this.candidate.y)) return; if ( this.grid.isTaken( this.candidate.x, this.candidate.y, this.checkDTest.bind(this) ) ) return; // did we hit any of our points? if ( this.ownGrid.isTaken( this.candidate.x, this.candidate.y, this.timeStepCheck.bind(this) ) ) return; // for (var i = 0; i < points.length; ++i) { // if (points[i].distanceTo(candidate) < config.timeStep * 0.9) return; // } return this.candidate; } timeStepCheck(distanceToCandidate) { return distanceToCandidate < this.config.timeStep * 0.9; } notifyPointAdded(point) { var shouldPause = false; if (this.config.onPointAdded) { shouldPause = this.config.onPointAdded( point, this.points[ this.state === StreamlineIntegrator.FORWARD ? this.points.length - 2 : 1 ], this.config ); } return shouldPause; } normalizedVectorField(p) { var p = (this.vectorField || this.config.vectorField)(p); if (!p) return; // Assume singularity if (Number.isNaN(p.x) || Number.isNaN(p.y)) return; // Not defined. e.g. Math.log(-1); var l = p.x * p.x + p.y * p.y; if (l === 0) return; // the same, singularity l = Math.sqrt(l); // We need normalized field. return new Vector(p.x / l, p.y / l); } static isSame(a, b) { // to avoid floating point error return Math.abs(a - b) < 1e-4; } }51:[] 49:{"id":"19591379aed69e3f","slug":"evenly-spaced-streamline","title":"Evenly-Spaced Streamlines","thumbnail":"f1ee0c09e43668c4aa8f6ee708ab1059e0f15f48c7fdde0c944ff358b92e3a09","access_level":"public","create_time":"$D2025-04-19T03:05:40.649Z","update_time":"$D2026-02-10T08:04:32.442Z","view_time":null,"first_public_time":"$D2025-04-20T12:07:30.935Z","has_unpublished_edits":null,"fork":false,"stars":1,"starred":false,"owner":{"type":"team","id":"4232e8ec4dc68e35","login":"citrus-lemon","name":"Lemon","avatar_url":"https://avatars-next.observableusercontent.com/963a1a7007fdcbefdf5f9b105d1373e1ca027efbbad182c2e5a6ef34236cb293","tier":"starter_2024","bio":"puts \"Hello, World\"","followed_by_you":false,"follows_you":false},"version":620,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"a6df9103aff7c068","login":"citrus-lemon","name":"Lemon","avatar_url":"https://avatars-next.observableusercontent.com/963a1a7007fdcbefdf5f9b105d1373e1ca027efbbad182c2e5a6ef34236cb293","tier":null,"bio":"puts \"Hello, World\"","followed_by_you":false,"follows_you":false}],"members":[{"type":"team","id":"4232e8ec4dc68e35","login":"citrus-lemon","name":"Lemon","avatar_url":"https://avatars-next.observableusercontent.com/963a1a7007fdcbefdf5f9b105d1373e1ca027efbbad182c2e5a6ef34236cb293","tier":"starter_2024","role":"editor"},{"type":"individual","id":"a6df9103aff7c068","login":"citrus-lemon","name":"Lemon","avatar_url":"https://avatars-next.observableusercontent.com/963a1a7007fdcbefdf5f9b105d1373e1ca027efbbad182c2e5a6ef34236cb293","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Evenly-Spaced Streamlines","cells":[{"id":0,"value":"# Evenly-Spaced Streamlines\n\n```js\nimport {computeStreamlines} from \"@citrus-lemon/evenly-spaced-streamline\"\n```\n\n- [Paper: Creating Evenly-Spaced Streamlines of Arbitrary Density](https://web.cs.ucdavis.edu/~ma/SIGGRAPH02/course23/notes/papers/Jobard.pdf)\n- [Matlab example](https://www.allnans.com/evenly_spaced_streamlines/even_stream_demo.html) - [code](https://github.com/keithfma/evenly_spaced_streamlines)\n- [anvaka/streamlines](https://github.com/anvaka/streamlines)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":526,"value":"viewof seed = PersistInput(\n \"seed\",\n Inputs.form({\n x: Inputs.range([0, 1], { value: 0.5, step: 0.01, label: \"Seed X\" }),\n y: Inputs.range([0, 1], { value: 0.5, step: 0.01, label: \"Seed Y\" })\n })\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":537,"value":"viewof options = PersistInput(\n \"options\",\n Inputs.form({\n dSep: Inputs.range([0, 1], {\n value: 0.1,\n step: 0.01,\n label: \"sep distance\"\n }),\n dTest: Inputs.range([0, 0.3], {\n value: 0.05,\n step: 0.005,\n label: \"test distance\"\n }),\n timeStep: Inputs.range([0, 0.1], {\n value: 0.01,\n step: 0.001,\n label: \"time step\"\n }),\n seedDirection: Inputs.radio([\"center\", \"flow\"], {\n label: \"Seeding Directions\",\n value: \"flow\"\n }),\n seedStreamlinePolicy: Inputs.radio([\"bfs\", \"dfs\"], {\n label: \"Seeding Streamline Order\",\n value: \"bfs\"\n }),\n fixVectorField: Inputs.toggle({ label: \"Fix Vector Field\", value: false })\n })\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":515,"value":"viewof switchingFields = PersistInput(\n \"switching\",\n Inputs.toggle({ label: \"Switching Fields\", value: false })\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":14,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":430,"value":"viewof state = Scrubber(animateState(lines), {\n initial: 100000000,\n loop: false,\n format: ({ line, grow, finish, seed }) =>\n finish ? \"Done\" : `Line: ${line}, Step: ${grow}`\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":422,"value":"function* animateState(lines) {\n const growSpeed = 1\n for (let line = 0; line < lines.length; ++line) {\n const seed = lines[line].indexOf(lines[line].seedPoint);\n for (let grow = 0; grow < lines[line].length + 1; grow += growSpeed) {\n yield { line, grow, seed };\n }\n }\n yield { line: lines.length, grow: 0, finish: true };\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":178,"value":"lines = {\n let e = [];\n let majorField = vectorWrap(sampler);\n let minorField = vectorWrap(rotate(sampler));\n majorField.tag = \"major\";\n minorField.tag = \"minor\";\n let majorGrid;\n let minorGrid;\n const csl = computeStreamlines({\n vectorField: majorField,\n boundingBox: { left: 0, top: 0, width: 1, height: 1 },\n ...options,\n onStreamlineAdded(points, config) {\n // console.log(config.vectorField.tag)\n e.push(points);\n if (switchingFields) {\n majorGrid = csl.grid.cells;\n minorGrid ||= new Map();\n [majorGrid, minorGrid] = [minorGrid, majorGrid];\n [majorField, minorField] = [minorField, majorField];\n config.vectorField = majorField;\n csl.grid.cells = majorGrid;\n }\n },\n seed\n });\n await csl.run();\n return e;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":199,"value":"rotate = (sampler) => (x,y) => {let [xx, yy] = sampler(x,y); return [-yy,xx];}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":175,"value":"function vectorWrap(sampler) {\n return function({x,y}) {\n const pp = sampler(x,y)\n return {x: pp[0], y: pp[1]}\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":22,"value":"sampler = PerlinVectorField.sampler","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"import {PlotSampler, PerlinVectorField} from \"@citrus-lemon/vector-fields\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":320,"value":"import {makeRandomGenerator} from \"@forresto/random-seed\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":425,"value":"import {Scrubber} from \"@mbostock/scrubber\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":556,"value":"import {PersistInput} from '@john-guerra/persist-input'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":270,"value":"## From `anvaka/streamlines`","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":304,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":154,"value":"function computeStreamlines(protoOptions) {\n return new Streamlines(protoOptions)\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":241,"value":"class Cell {\n constructor() {\n this.children = null;\n }\n occupy(point) {\n if (!this.children) this.children = [];\n this.children.push(point);\n }\n isTaken(x, y, checkCallback) {\n if (!this.children) return false;\n\n for (var i = 0; i < this.children.length; ++i) {\n var p = this.children[i];\n var dx = p.x - x,\n dy = p.y - y;\n var dist = Math.sqrt(dx * dx + dy * dy);\n if (checkCallback(dist, p)) return true;\n }\n\n return false;\n }\n getMinDistance(x, y) {\n let minDistance = Infinity;\n\n if (!this.children) return minDistance;\n\n for (var i = 0; i < this.children.length; ++i) {\n var p = this.children[i];\n var dx = p.x - x,\n dy = p.y - y;\n var dist = Math.sqrt(dx * dx + dy * dy);\n if (dist < minDistance) {\n minDistance = dist;\n }\n }\n\n return minDistance;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":239,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":237,"value":"function rk4(point, timeStep, getVelocity) {\n var k1 = getVelocity(point);\n if (!k1) return;\n var k2 = getVelocity(point.add(k1.mulScalar(timeStep * 0.5)));\n if (!k2) return;\n var k3 = getVelocity(point.add(k2.mulScalar(timeStep * 0.5)));\n if (!k3) return;\n var k4 = getVelocity(point.add(k3.mulScalar(timeStep)));\n if (!k4) return;\n\n var res = k1\n .mulScalar(timeStep / 6)\n .add(k2.mulScalar(timeStep / 3))\n .add(k3.mulScalar(timeStep / 3))\n .add(k4.mulScalar(timeStep / 6));\n return res;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":247,"value":"class Vector {\n constructor(x, y) {\n this.x = x;\n this.y = y;\n }\n equals(other) {\n return this.x === other.x && this.y === other.y;\n }\n add(other) {\n return new Vector(this.x + other.x, this.y + other.y);\n }\n mulScalar(scalar) {\n return new Vector(this.x * scalar, this.y * scalar);\n }\n length() {\n return Math.sqrt(this.x * this.x + this.y * this.y);\n }\n normalize() {\n var l = this.length();\n this.x /= l;\n this.y /= l;\n }\n distanceTo(other) {\n var dx = other.x - this.x;\n var dy = other.y - this.y;\n\n return Math.sqrt(dx * dx + dy * dy);\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":292,"value":"$50","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W51","stdlib":"1"}} 44:null