31:[{"id":"2b26d8f26b42abbd5733716980c4e38dfaee17e6a949577815a11cbdb873ba58e918c0caac771aed8cca7bf4663a7b2b0e1e3efa95c5b645217a854482f99ed3","href":"https://static.observableusercontent.com/files/2b26d8f26b42abbd5733716980c4e38dfaee17e6a949577815a11cbdb873ba58e918c0caac771aed8cca7bf4663a7b2b0e1e3efa95c5b645217a854482f99ed3","name":"motor_encoder_test_5982rows.csv","type":"text/csv","lastModified":1653535345628.856,"size":91386},{"id":"57f77de53882f0a92e09d72b7020811a6e33df4759f530e3072b9a7312cc64c6853c08b66f881fda40c9b7c3d9c2de64f4d253c19e697fea48b7fcd63deccf5c","href":"https://static.observableusercontent.com/files/57f77de53882f0a92e09d72b7020811a6e33df4759f530e3072b9a7312cc64c6853c08b66f881fda40c9b7c3d9c2de64f4d253c19e697fea48b7fcd63deccf5c","name":"PXL_20220528_005344921.jpg","type":"image/jpeg","lastModified":1653802364231.106,"size":1890619},{"id":"f4a37d128f2b3b8e5b4abdefe6311531469f5b40d37313cde024fa5f9b2bab6f6ccf8cf07543f7a1780b08ccd113c710aa871959970dd7f5d904150967e7235b","href":"https://static.observableusercontent.com/files/f4a37d128f2b3b8e5b4abdefe6311531469f5b40d37313cde024fa5f9b2bab6f6ccf8cf07543f7a1780b08ccd113c710aa871959970dd7f5d904150967e7235b","name":"PXL_20220529_214740937 (1).jpg","type":"image/jpeg","lastModified":1653861190178.769,"size":120794}] 2f:{"title":"Adjusting for imperfect geometry in a sine-cosine encoder","cells":[{"id":0,"value":"# Adjusting for imperfect geometry in a sine-cosine encoder","pinned":false,"hidden":false,"mode":"md"},{"id":1079,"value":"In a [previous experiment](https://observablehq.com/@skybrian/a-sine-cosine-encoder-experiment) I looked at sensor data from turning a wheel. The angular velocity graph had some waves in it that I suspect is due to imperfect holes in the phototransistor holder. Here's what they look like:\n","pinned":false,"hidden":false,"mode":"md"},{"id":1318,"value":"

\n ${await FileAttachment(\"PXL_20220529_214740937 (1).jpg\").image()}\n","pinned":false,"hidden":false,"mode":"html"},{"id":1311,"value":"Light from the LEDs reaches the phototransistors through these holes. The shape of the holes determines how quickly the light on the sensors increases and decreases as the wheel's gratings sweep past it.\n\nI tried reprinting the part with a different design to try to get more circular output, but with no luck. The holes are quite tiny, and the precision of my 3D printer seems to be the limiting factor. So instead I'm going to try to adjust for it in software.\n\n## Experimental setup\n\nThis time I tried turning the wheel with a stepper motor from an older-generation Lego Mindstorms set, to see what the sensor output looks like at constant speed:","pinned":false,"hidden":false,"mode":"md"},{"id":1088,"value":"pxl_20220528_005344921 = FileAttachment(\"PXL_20220528_005344921.jpg\").image()","pinned":false,"hidden":false,"mode":"ojs"},{"id":1091,"value":"The Lego Mindstorms software for the NXT is a decade old and I didn't want to install it, so instead I wrote a [web app](https://nxt-controller.skybrian.com/) to control the motor.","pinned":false,"hidden":false,"mode":"md"},{"id":30,"value":"## Sensor data","pinned":false,"hidden":false,"mode":"md"},{"id":17,"value":"Plot.plot({\n width: width,\n height: 200,\n marks: [\n Plot.line(zoomed(xy), {x: \"t\", y: \"x\", stroke: \"blue\"}),\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":739,"value":"Plot.plot({\n width: width,\n height: 200,\n marks: [\n Plot.line(zoomed(xy), {x: \"t\", y: \"y\", stroke: \"green\"}),\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":103,"value":"viewof zoom = Inputs.range([70, xy.length], {step: 1, value: 500, label: \"Zoom\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":112,"value":"viewof pan = Inputs.range([0, xy.length - zoom], {step: 1, label: \"Pan\", value: 0})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1323,"value":" Sensor readings were recorded every 2 milliseconds as before. This recording is so long that it makes plotting slow down, so usually I just take the first 500 samples. You can increase it if you like.","pinned":false,"hidden":false,"mode":"md"},{"id":135,"value":"## XY plot","pinned":false,"hidden":false,"mode":"md"},{"id":137,"value":"Plot.plot({\n width: width/3,\n height: width/3-40,\n x: {\n nice: true,\n zero: true,\n },\n y: {\n nice: true,\n zero: true,\n ticks: 5,\n },\n marks: [\n Plot.dot(zoomed(xy), {x: \"x\", y: \"y\", r: 1}) \n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1337,"value":"It's using different holes, but the output looks about the same as last time. Top right corresponds to both sensors lit and the bottom left means they're both in shadow.","pinned":false,"hidden":false,"mode":"md"},{"id":179,"value":"## Converting (x,y) to a phase","pinned":false,"hidden":false,"mode":"md"},{"id":1099,"value":"\nOne way to think about this signal is that it's like a race car going around an oval track. The sensors measure the race car's location using two numbers (x and y) but we'd rather measure progress around the course using something more like an odometer reading, as a single number.\n\nAlthough it isn't a circle, the track is close enough that we can use an angle from a center point to indicate where the car is. Later, I'll convert that into a more accurate measurement of distance around the track.\n","pinned":false,"hidden":false,"mode":"md"},{"id":154,"value":"Plot.plot({\n width: width/3,\n height: width/3-40,\n x: {\n nice: true,\n zero: true,\n },\n y: {\n nice: true,\n zero: true,\n ticks: 5,\n },\n color: {\n legend: true,\n domain: [0, 360],\n ticks: [0, 90, 180, 270, 360],\n },\n marks: [\n Plot.ruleX([xCenter], {y1: yCenter - 50, y2: yCenter + 50}),\n Plot.ruleY([yCenter], {x1: xCenter - 50, x2: xCenter + 50}),\n Plot.dot(zoomed(xyTheta), {x: \"x\", y: \"y\", r: 1, stroke: \"theta\"}) \n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":157,"value":"viewof xCenter = Inputs.range([200, 400], {step: 1, label: \"X Center\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":161,"value":"viewof yCenter = Inputs.range([200, 400], {step: 1, label: \"Y Center\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1360,"value":"The crosshair in the above diagram shows the center point from which we measure the angle, with zero degrees to the right and increasing counterclockwise. You can move the center around if you like with the sliders, but I don't think it matters much, since we're just going to adjust it later.\n\nTo convert from (x,y) coordinates to an angle, we can use the [atan2 function](https://en.wikipedia.org/wiki/Atan2). Here is its output:","pinned":false,"hidden":false,"mode":"md"},{"id":1356,"value":"Plot.plot({\n width: width,\n height: 100,\n marks: [\n Plot.dotY(zoomed(xyTheta), {x: 't', y: 'theta', r: 1, stroke: 'theta'})\n ], \n })","pinned":false,"hidden":false,"mode":"ojs"},{"id":1104,"value":"\n\n(I'll refer to this number as the phase of the signal, since that's what it's called in signal processing, but's really just an angle.)\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":230,"value":"## Counting laps","pinned":false,"hidden":false,"mode":"md"},{"id":1110,"value":"The atan2 function tells us where the race car is on the track, but not how many laps it did. To fix that we need a lap counter. The output from atan2 jumps backwards by 360 degrees once every lap, so to fix this, whenever it jumps backwards by more than 180 degrees, we can add 360 degrees (one lap) to get rid of the jump.\n\nAlso, instead of measuring in degrees, we can divide by 360, which gives us an \"odometer\" that measures where we are in laps:\n","pinned":false,"hidden":false,"mode":"md"},{"id":244,"value":"Plot.plot({\n width: width,\n y: {\n label: \"laps\",\n nice: true,\n },\n marks: [\n Plot.ruleX(zoomed(rotations), {\n filter: d => d.lapChange != 0 && d.laps >= 0 && d.laps <= lapCount, x: \"t\", stroke: \"#ccc\"}),\n Plot.lineY(zoomed(rotations), {\n filter: d => d.laps >= 0 && (d.laps < lapCount || d.laps == lapCount && d.lapChange == 1),\n x: \"t\", y: \"rotations\", z: null, stroke: \"theta\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":294,"value":"viewof lapCount = Inputs.range([1, maxLaps - 1], {value: maxLaps, step: 1, label: \"Laps to include:\"});","pinned":false,"hidden":false,"mode":"ojs"},{"id":1124,"value":"I also trimmed the data to an integer number of laps, so we start and finish the \"race\" in the same place on the track. This is to avoid biasing the data when we do statistics about the shape of the track. You can adjust the length of the race with the slider.\n\n## Lap times\n\nNow that we know where the laps start and end, the original sensor data can be broken up by lap, resulting in some pretty graphs:","pinned":false,"hidden":false,"mode":"md"},{"id":702,"value":"Plot.plot({\n color: {\n legend: true,\n label: \"lap\",\n scheme: \"blues\",\n },\n y: {\n zero: true,\n },\n width: width,\n height: 200,\n marks: [\n Plot.lineY(trimmedRotations, {x: \"lapT\", y: \"x\", z: \"laps\", stroke: \"laps\"})\n ]\n})\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":729,"value":"Plot.plot({\ncolor: {\n legend: true,\n label: \"lap\",\n scheme: \"greens\",\n },\n y: {\n zero: true,\n },\n width: width,\n height: 200,\n marks: [\n Plot.lineY(trimmedRotations, {x: \"lapT\", y: \"y\", z: \"laps\", stroke: \"laps\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":763,"value":"You can see from the ends of these curves how some laps take more time than others, anywhere from about 34 to 40 samples. Apparently the stepper motor isn't turning the wheel as smoothly as I hoped?\n\nTo line up the curves, we can graph this data by phase (angle) instead of by time:","pinned":false,"hidden":false,"mode":"md"},{"id":772,"value":"Plot.plot({\n color: {\n scheme: \"blues\",\n },\n width: width,\n height: 200,\n x: {\n label: \"phase\",\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15),\n },\n y: {\n zero: true,\n ticks: 3,\n },\n marks: [\n Plot.lineY(trimmedRotations, {\n filter: d => d.lapTime,\n x: d => d.theta, y: \"x\", z: \"laps\", stroke: \"laps\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":775,"value":"Plot.plot({\n color: {\n scheme: \"greens\",\n },\n width: width,\n height: 200,\n x: {\n label: \"phase\",\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15),\n },\n y: {\n zero: true,\n ticks: 3,\n },\n marks: [\n Plot.lineY(trimmedRotations, {\n filter: d => d.lapTime,\n x: d => d.theta, y: \"y\", z: \"laps\", stroke: \"laps\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":821,"value":"These graphs show that the sensor readings are pretty consistent at each point on the track. That's useful because it will make adjustments easier.\n\n## Measuring angular velocity (speed around the track)\n\nAlthough the stepper motor turns the wheel at somewhat inconsistent speeds, it probably don't have anything to do with where the gratings are on the wheel. So, I'm going to *assume statistical independence*. Any consistent slowdowns on some parts of the track are probably due to the shape of the holes and not something else, like the stepper motor oscillating or electrical noise.\n\nThe simplest way to measure speeds is to subtract each sample's phase from the previous sample's phase. The output from atan2 (which is somewhat arbitrary) is treated as distance and the time is always 2 milliseconds because that's the time between samples. Here are all the samples plotted with their speeds:\n","pinned":false,"hidden":false,"mode":"md"},{"id":819,"value":"Plot.plot({\n color: {\n legend: true,\n scheme: \"reds\",\n },\n width: width,\n height: 300,\n x: {\n label: \"phase\",\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15),\n },\n y: {\n label: \"change in degrees / sample\",\n zero: true,\n nice: true,\n },\n marks: [\n Plot.ruleY(trimmedRotations, {\n filter: d => d.lapTime,\n x1: d => d.theta-d.delta, x2: \"theta\", y: \"delta\", z: \"laps\", stroke: \"laps\"}),\n Plot.dotY(trimmedRotations, {\n filter: d => d.lapTime,\n x: \"theta\", y: \"delta\", r: 2, z: \"laps\", stroke: \"laps\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1202,"value":"It's pretty easy to see that there are fairly consistent slowdowns on certain parts of the course.\n\nHere's another way to plot the data, showing how the speeds changed during each lap:","pinned":false,"hidden":false,"mode":"md"},{"id":590,"value":"Plot.plot({\n width: width,\n x: {\n label: \"phase\",\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15),\n },\n y: {\n label: \"change in degrees / sample\",\n nice: true,\n zero: true,\n },\n color: {\n scheme: \"reds\",\n },\n marks: [\n Plot.lineY(trimmedRotations, {x: \"theta\", y: \"delta\", z: \"laps\", stroke: \"laps\"}),\n ],\n })\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":305,"value":"## Finding average speeds by counting samples","pinned":false,"hidden":false,"mode":"md"},{"id":1207,"value":"The next step is to convert all these speeds into a single number for each location on the track. The idea is that if the car is seen more often at a certain location, it must be moving slower (on average) there.\n\nThe first thing I tried was just to divide the track into bins and count samples in those parts of the track:","pinned":false,"hidden":false,"mode":"md"},{"id":323,"value":"Plot.plot({\n width: width,\n marginLeft: 50,\n x: {\n ticks: Array(25).fill(0).map((_, i) => i * 15)\n },\n y: {\n domain: [0, 3.6 / binCount1],\n },\n marks: [\n (binCount1 > 500 ? Plot.ruleX : Plot.rectY)(trimmedRotations, Plot.binX({y: \"proportion\"}, {x: {interval: 360/binCount1, value: \"theta\"}, fill: \"grey\"})),\n Plot.ruleY([0])\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1279,"value":"viewof binCount1 = Inputs.range([10,360], {value: 10, step: 1, label: \"Bin count\", transform: Math.log})","pinned":false,"hidden":false,"mode":"ojs"},{"id":380,"value":"It looks okay at first, but the graph gets noisier as you increase the number of bins, so it has limited resolution. Here's a trick for fixing that:\n\n## Counting the time between samples\n\nCounting samples doesn't work very well when the car is moving fast. For example, suppose one sample is at 5 degrees and the next is at 10 degrees. The car must have passed through 6, 7, 8, and 9 degrees, but it's not counted as having been there at all. It's as if the car *teleported* from one sample to the next, instead of moving smoothly around the track.\n\nSince we don't have samples for the time spent in between, I divided up the sample time evenly over each interval, as if the car were moving at constant speed between each two samples:","pinned":false,"hidden":false,"mode":"md"},{"id":392,"value":"Plot.plot({\n width: width,\n x: {\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15)\n },\n y: {\n domain: [0, 3.6 / binCount],\n },\n marks: [\n Plot.rectY(timeAtAngle, {x1: \"theta\", x2: d => d.theta + 360.0/binCount, y: d => d.frequency, fill: \"grey\"})\n ]\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":382,"value":"viewof binCount = Inputs.range([10,1000], {value: 360, step: 10, label: \"Bin count\", transform: Math.log})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1223,"value":"If you adjust the bin count, you can see that more bins just gets smoother if we do it this way.","pinned":false,"hidden":false,"mode":"md"},{"id":1420,"value":"## Building the phase adjustment function\nThe next step is to make a function that converts the phase calculated using atan2 into an adjusted phase that matches our assumption that the car spends the same amount of time in every part of the track. To do this, the bins where it spends the most time (the \"mountains\" in the above graph) need to be expanded to cover a larger distance horizontally, while the valleys get crunched together to make room:","pinned":false,"hidden":false,"mode":"md"},{"id":1426,"value":"Plot.plot({\n width: width,\n x: {\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15)\n },\n marks: [\n Plot.tickX(phaseAdjust.concat([{\"adjusted\": 360}]), {x: \"adjusted\", stroke: \"grey\"})\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":468,"value":"For the width of each bin, we can just use height of the mountains and valleys in the previous graph. So building a lookup table is a matter of doing integration over the graph, summing all the previous entries:","pinned":false,"hidden":false,"mode":"md"},{"id":537,"value":"Plot.plot({\n width: width/3,\n height: width/3 - 40,\n x: {\n domain: [0, 360],\n ticks: Array(13).fill(0).map((_, i) => i * 30) \n },\n y: {\n domain: [0, 360],\n ticks: Array(13).fill(0).map((_, i) => i * 30) \n },\n marks: [\n Plot.line([0, 360], {x: d => d, y: d => d, stroke: \"#ccc\"}),\n Plot.lineY(phaseAdjust.concat([{theta: 360, adjusted: 360}]), {x: \"theta\", y: \"adjusted\"}),\n Plot.dotY(binCount >= 50 ? [] : phaseAdjust.concat([{theta: 360, adjusted: 360}]), {x: \"theta\", y: \"adjusted\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":850,"value":"After applying this adjustment to the phase at each sample, we can see that the bias goes away. There is still a lot of variation in speed, but each speed is equally likely at each point on the track:","pinned":false,"hidden":false,"mode":"md"},{"id":866,"value":"Plot.plot({\n color: {\n legend: true,\n scheme: \"reds\",\n },\n width: width,\n height: 300,\n x: {\n label: \"phase\",\n domain: [0, 360],\n ticks: Array(25).fill(0).map((_, i) => i * 15),\n },\n y: {\n label: \"change in degrees / sample\",\n zero: true,\n nice: true,\n },\n marks: [\n Plot.ruleY(adjustedRotations, {\n filter: d => d.lapTime,\n x1: d => d.theta - d.delta, x2: \"theta\",\n y: \"delta\", z: \"laps\", stroke: \"laps\"}),\n Plot.dotY(adjustedRotations, {\n filter: d => d.lapTime,\n x: \"theta\", y: \"delta\", z: \"laps\", r: 2, stroke: \"laps\"})\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1071,"value":"Here is what each lap looks like:","pinned":false,"hidden":false,"mode":"md"},{"id":613,"value":"Plot.plot({\n width: width,\n x: {\n label: \"percent\",\n nice: true,\n },\n y: {\n nice: true,\n zero: true,\n },\n color: {\n scheme: \"reds\",\n },\n marks: [\n Plot.lineY(adjustedRotations, {x: d => 100 * d.lapT / d.lapTime, y: \"delta\", z: \"laps\", stroke: \"laps\"}),\n ],\n })\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":1300,"value":"Just for fun, here's the XY plot after applying the adjustment:","pinned":false,"hidden":false,"mode":"md"},{"id":1286,"value":"Plot.plot({\n width: width/3,\n height: width/3-40,\n x: {\n nice: true,\n zero: true,\n },\n y: {\n nice: true,\n zero: true,\n ticks: 5,\n },\n color: {\n legend: true,\n domain: [0, 360],\n ticks: [0, 90, 180, 270, 360],\n },\n marks: [\n Plot.dot(adjustedRotations, {x: \"x\", y: \"y\", r: 1, stroke: \"theta\"}),\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1067,"value":"## Looking for other cycles\n\nWe got rid of the bias from the geometry, but what about other periodic slowdowns? The usual way to look for them is a Fourier transform, but dividing the graph into equal intervals will work too:","pinned":false,"hidden":false,"mode":"md"},{"id":993,"value":"Plot.plot({\n width: width,\n y: {\n nice: true,\n zero: true,\n },\n color: {\n scheme: \"reds\",\n },\n marks: [\n Plot.lineY(adjustedRotations, {x: d => d.t % period, y: \"delta\", z: d => Math.floor(d.t / period), stroke: \"laps\"}),\n ],\n })\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":1021,"value":"viewof period = Inputs.range([5,200], {value: 33, label: \"Period\", step: 1});","pinned":false,"hidden":false,"mode":"ojs"},{"id":1074,"value":"In the first 500 samples of the recording, there seems to be a cycle with a period of about 16.5 samples, so it shows up when moving the slider to 33. I don't know yet what causes it. Maybe it's the stepper motor? It goes away later in the recording.","pinned":false,"hidden":false,"mode":"md"},{"id":35,"value":"## Appendix","pinned":false,"hidden":false,"mode":"md"},{"id":3,"value":"csv = FileAttachment(\"motor_encoder_test_5982rows.csv\").csv({typed: true})","pinned":false,"hidden":false,"mode":"ojs"},{"id":9,"value":"xy = csv.slice(500).map((d, i) => ({t: i, x: d[\"Left V\"], y: d[\"Right V\"]}))","pinned":false,"hidden":false,"mode":"ojs"},{"id":169,"value":"xyTheta = xy.map(({t,x,y}) => {\n let theta = Math.atan2(y - yCenter, x - xCenter) * 360 / (2 * Math.PI);\n if (theta < 0) theta += 360;\n return { t: t, x: x, y: y, theta: theta };\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":238,"value":"rotations = {\n let out = Array(xyTheta.length);\n let lapTimes = [];\n\n let laps = -1;\n let lapStart = NaN;\n out[0] = {t: 0, theta: xyTheta[0].theta, laps: laps, rotations: -1 + xyTheta[0].theta/360};\n let prevTheta = xyTheta[0].theta;\n for (let i = 1; i < out.length; i++) {\n const {t, x, y, theta} = xyTheta[i]\n let delta = theta - prevTheta;\n let lapChange = 0;\n if (delta < -180) {\n lapChange = 1;\n delta += 360;\n } else if (delta > 180) {\n lapChange = -1;\n delta -= 360;\n }\n laps += lapChange;\n if (lapChange > 0) {\n if (laps >= 1) lapTimes.push(t - lapStart);\n lapStart = t;\n }\n out[i] = {t, x, y, theta, delta, laps, lapChange, lapT: t - lapStart, rotations: laps + theta/360};\n prevTheta = theta;\n }\n for (let d of out) {\n d.lapTime = (d.laps >= 0 && d.laps < lapTimes.length) ? lapTimes[d.laps] : NaN;\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":296,"value":"maxLaps = zoomed(rotations).reduce((prev, d) => Math.max(prev, d.laps), 0)","pinned":false,"hidden":false,"mode":"ojs"},{"id":292,"value":"trimmedRotations = {\n let out = [];\n for (let i = 1; i < rotations.length - 1; i++) {\n if (rotations[i + 1].laps >= 0 && rotations[i - 1].laps < lapCount) {\n out.push(rotations[i]);\n } \n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1030,"value":"lapTimes = trimmedRotations.filter(d => d.lapChange == 1).map(d => ({lap: d.laps + 1, lapTime: d.lapTime})).slice(0, lapCount)","pinned":false,"hidden":false,"mode":"ojs"},{"id":313,"value":"timeAtAngle = {\n const bins = Array(binCount).fill(0);\n let addedTime = 0;\n const addTime = (x, amount) => {\n if (x < 0 || x >= bins.length * lapCount) {\n return;\n }\n bins[Math.floor(x) % bins.length] += amount;\n addedTime += amount;\n };\n const binFor = (x) => Math.floor(x) % bins.length;\n let prevX = trimmedRotations[0].rotations * bins.length;\n for (let {rotations} of trimmedRotations.slice(1)) {\n const x = rotations * bins.length;\n if (x <= Math.ceil(prevX)) {\n // all in one bin\n addTime(prevX, 1);\n prevX = x;\n continue;\n }\n const scale = 1 / (x - prevX);\n addTime(prevX, scale * (Math.ceil(prevX) - prevX));\n addTime(x, scale * (x - Math.floor(x)));\n for (let i = Math.ceil(prevX); i < Math.floor(x); i++) {\n addTime(i, scale);\n }\n prevX = x;\n }\n return bins.map((d, i) => ({theta: i * 360 / binCount, frequency: d / addedTime}));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":529,"value":"phaseAdjust = {\n const weights = timeAtAngle.map(d => d.frequency);\n const f = Array(weights.length);\n let sum = 0;\n for (let i = 0; i < f.length; i++) {\n f[i] = sum;\n sum += weights[i];\n }\n return f.map((d,i) => ({theta: i * 360 / binCount, adjusted: d * 360}));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1433,"value":"phaseAdjustIntervals = {\n const out = Array(phaseAdjust.length);\n let left = phaseAdjust[0].adjusted;\n for (let i = 0; i < out.length; i++) {\n let right = phaseAdjust[(i + 1) % phaseAdjust.length].adjusted;\n if (right < left) right += 360;\n out[i] = {left, right};\n left = right;\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1436,"value":"phaseAdjustIntervals[359]","pinned":true,"hidden":false,"mode":"ojs"},{"id":909,"value":"adjustedRotations = trimmedRotations.map(d => {\n const rotations = adjustedRot(d.rotations);\n const delta = (rotations - adjustedRot(d.rotations - d.delta/360)) * 360;\n const theta = 360 * (rotations - Math.floor(rotations));\n const radius = Math.sqrt(Math.pow(d.x - xCenter, 2) + Math.pow(d.y - yCenter, 2));\n const x = xCenter + radius * Math.cos(theta * 2 * Math.PI / 360);\n const y = yCenter + radius * Math.sin(theta * 2 * Math.PI / 360);\n return {...d, x, y, rotations, delta, theta}; \n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":562,"value":"adjustedRot = (rot) => {\n if (isNaN(rot)) return NaN;\n const lapRot = rot - Math.floor(rot);\n const leftBin = Math.floor(lapRot * binCount) % binCount;\n const rightBin = Math.ceil(lapRot * binCount) % binCount;\n let adjusted = phaseAdjust[leftBin].adjusted / 360;\n if (leftBin != rightBin) {\n let rightAdjusted = phaseAdjust[rightBin].adjusted / 360;\n if (rightAdjusted < adjusted) {\n rightAdjusted += 1;\n }\n const leftWeight = 1 - (lapRot * binCount - Math.floor(lapRot * binCount));\n adjusted = adjusted * leftWeight + rightAdjusted * (1 - leftWeight);\n }\n return adjusted + Math.floor(rot);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":120,"value":"zoomed = (arr) => arr.slice(pan, pan + zoom)","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W31","stdlib":"1","titling":"auto"}