Engineering Dynamics Company
Recon Toolkit™
Accident Reconstruction Tools for Blender
Engineering Dynamics Company
Recon Toolkit™
Accident Reconstruction Tools for Blender
Data-driven animation and analysis for accident reconstruction in Blender.
This guide walks through installing the add-on, finding its panels, and completing the common tasks step by step.
Recon Toolkit turns recorded crash data — EDR reports, motion tables, survey points — into animated Blender scenes, and adds the measurement and visualization tools reconstructionists need to present motion clearly.
| Tool | What it does |
|---|---|
| EDR Data Importer / Entry | Animate an object from Time, Speed, Yaw Rate or Time, Speed, Steering Wheel Angle data, or follow an existing path using a Time, Speed profile |
| Motion Data Importer | Animate an object from Time, X, Y, Z, Roll, Pitch, Yaw rows |
| Point Importer | Place numbered, labelled markers from a survey coordinate list, connected into polylines |
| Motion Path Tools | Generate, remove, toggle, and convert Blender motion paths to editable 3D curves |
| Timed Location Markers | Drop triangle markers (with optional time labels) at a fixed time interval along an animated object's motion |
| Scale Objects | Scale an object so two selected vertices match a known real-world distance |
| Speed + Acceleration | Bake speed and acceleration from an animated object to animated custom properties, on the object itself or on a helper empty |
| Data Display Box | Show imported data (or any standalone CSV) as a live, HVE-style on-screen text box, grouped by vehicle and data kind |
The add-on targets Blender 4.x and uses only Blender's bundled Python modules — no extra installation.
ReconToolkit-<version>.zip file.The add-on's preferences let you rename the sidebar tab — set it to an existing tab's name to share a tab with other add-ons.
On Blender 4.2+ the same zip also installs as an extension (Preferences → Get Extensions → Install from Disk), and updates automatically when added from the EDC Software repository.
If you only use part of the toolkit, you can hide the rest. Open Edit → Preferences → Add-ons, expand Recon Toolkit, and use the Features checkboxes:
| Feature | Hides |
|---|---|
| EDR Data Importer / Entry | The EDR panel (yaw-rate, steering-angle, and path-follow modes) |
| Motion Data Importer | The Time, X, Y, Z, Roll, Pitch, Yaw importer |
| Point Importer | The survey-point / polyline importer |
| Motion Path Tools | Motion path generation and curve conversion |
| Timed Location Markers | The interval triangle markers |
| Scale Objects | The two-vertex known-distance scaler |
| Speed + Acceleration | The speed / acceleration bake |
| Data Display Box | The live on-screen readout of imported data |
| Imported Data | The list of imported files, the object each animates, and its Time Zero |
All nine are on by default. Unchecking one removes its panel from the sidebar immediately — no restart needed. Documentation always stays visible, so the user guide remains reachable.
Nothing is uninstalled: the tools are only hidden, and re-checking a box brings the panel back with its settings intact.
Click Save Preferences (or enable Auto-Save Preferences) so your choices persist the next time you open Blender.
Every importer reads CSV files the same forgiving way:
t, time; spd, speed; yaw rate, yawrate).s, mph, deg/s). The detected rows are listed in the panel where each row has a checkbox to ignore it and a dropdown to re-assign its role — including marking a misread row as Data so the import starts there.A row counts as a header when most of its cells are text, not merely when it contains some. Data rows carry text of their own — a Brake column reading On/Off, an N/A, or a clock timestamp such as 19:18.5 in the first column — and a looser test silently eats the first rows of data. The row count in the panel is worth a glance against the file: rows quietly dropped as header show up there and as a late start on the timeline. Prefix and units flow into the column dropdowns (Honda Fit: Speed (mph)) and are saved with the imported data, so a Data Display Box scan pre-fills the group prefix and units automatically.
Load a file first, then confirm or adjust the column mapping before importing.
Use EDR Data Importer / Entry to drive a vehicle from event-data-recorder output. You can import a CSV or hand-enter rows.
The panel is laid out in the order you work through it: Source → Timing → Import CSV → Entries → Animate.
Time, Speed, Yaw Rate rows.Time, Speed, Steering Wheel Angle; set the wheelbase and steering-gear ratio so the bicycle model can derive yaw.Time, Speed profile.A file with no header row stops after mapping instead, because positional guessing is exactly the case worth a human glance. Check the columns, then Import With These Columns.
Correcting the mapping. The detected columns are summarised on one line — Time: t Speed: Vel Yaw: YawRate. Click the triangle to open the dropdowns. Import With These Columns appears only once you have changed something, so it means "apply this" rather than being a step to remember.
Editing rows by hand. The Entries section is folded away with a row count; open it to edit, add or remove rows. A CDR export runs to hundreds of rows, which is why it does not unroll by default. After a hand edit, press Animate Object to re-key.
Speeds are read as mph in Imperial scenes and m/s in Metric scenes (see Units and scale). Imported rows are stored on the animated object.
Time Zero Frame places the data's t = 0 somewhere other than frame 0 — set it to 300 and the first row lands on frame 300, with everything after it following at the frame rate above. Use it to line data up against footage, or to stage several datasets against each other.
The value in the panel is the starting point for the *next* import. Once imported, that dataset owns its own time zero and can be re-timed on its own from Imported Data — see Re-time and re-import a dataset.
Use Motion Data Importer when you already have a full pose per timestamp (Time, X, Y, Z, Roll, Pitch, Yaw).
Imported rows are stored on the animated object.
Use Point Importer to bring a survey coordinate list into the scene.
Every EDR and motion import is listed in Imported Data. Each row names its source file, the object it animates, and the timeline frame its t = 0 sits on. A row whose object has been deleted says so rather than sitting there looking normal.
Select a row and edit Time Zero to slide that dataset along the timeline. Only that dataset moves: an EDR export and a motion table rarely begin at the same instant, so each carries its own offset rather than sharing one.
Everything that reads the dataset follows. One edit moves:
t = 0 and updates as soon as you change it;You no longer have to mirror the offset by hand in the box's Time Zero Frame. That field is still there, and is now a manual adjustment applied *on top of* the import's own offset — leave it at 0 unless you want the readout to disagree with the animation on purpose.
The Time row has no single object behind it. With one import in the scene it follows that import; with several it stays neutral and the box's Time Zero Frame decides, since two datasets at different offsets have no shared answer.
Diagnosing a value that looks stuck. The magnifier beside Export CSV in the display box reports, for every checked row, what it is bound to and whether it actually changes over the scene's frame range. A row reading a constant looks exactly like a row reading correctly from flat data, and this says which it is — and names the object and key it is reading, so a row bound to something that no longer exists stops looking like a value of zero. For a row that is flat it also gives the reason: how many samples the data holds (or what frames its keys span) against the frames actually being indexed, since a mesh attribute clamps at its ends and an F-Curve extrapolates flat, and neither says so on its own.
What Time Zero Frame does and does not move. It sets which frame reads
t = 0on the Time row, and it slides *imported datasets* against the timeline — an EDR or CSV table is stored in its own time base, and lining it up with the animation is exactly what the field is for. A Speed + Acceleration bake is the opposite: it was measured *off* the timeline, so the speed at frame 60 is the speed at frame 60 whatever frame you callt = 0. Bakes are therefore left where they are. Sliding them reported some other moment's speed — and because a data mesh clamps at its ends, a box with a large Time Zero Frame showed one number that never changed.
Which channels follow their import. Re-timing an import physically moves keyframes, so anything stored as keyframes — including a Speed + Acceleration bake written onto the object itself — has already moved and is read straight off the timeline. Data stored as a table of times (EDR and motion tables) or as a
Data:mesh is not moved; those are looked up relative to the import'st = 0instead. Either way the readout follows the animation. The box's own Time Zero Frame applies to every channel on top of that.A Speed + Acceleration bake is registered to the same import as the object it was measured from, whichever target it was written to, so re-timing that import moves the speed with the motion it describes. Bear in mind this also means Clear on that import removes the bake along with the animation — re-run the bake afterwards.
| Button | What it does |
|---|---|
| Load Into Importer | Points the matching importer at this dataset's object, source file and time zero, ready to change settings and import again over it |
| Select | Selects the object this dataset animates |
| Clear | Removes the animation this import created and drops the row — the object itself is kept, since it existed beforehand |
| Forget | Drops the row only; the animation stays exactly as it is |
Re-importing is safe. Importing again onto the same object replaces that object's row rather than adding another, so the list keeps one entry per animated object however many passes it takes to get the settings right.
Use Scale Objects to bring imported geometry to real-world scale.
Which way does Forward Yaw Offset turn? Positive is counter-clockwise seen from above — the same sense as a positive Z rotation in Blender — and it is *added* to the forward direction's heading. So a forward that already points 3° off +X needs −3 to bring it onto +X, not +3.
You should not have to work that out. The panel reports the heading your current settings produce (
Forward points +3.0° from +X), so nudge the offset and watch it move. If the axis you picked points straight up, it says that too — forward is measured in the horizontal plane, so a vertical axis falls back to world +Y on every frame.
Use Speed + Acceleration to read motion off an animated object for HUD-style readouts or analysis.
Bakes already in the scene are listed at the top of the panel, the same way Object Distance lists its measurements: each row names the object and the unit its channels are in, and says whether acceleration was baked too. Select This Object picks it in the viewport; the X strips its speed channels and leaves the object itself alone, because a bake can be written straight onto a vehicle. There is no New button here — a speed bake takes its source from the selection, so selecting another object already is starting a new one.
Bakes are found by the channels an object carries, not by name, so all three Bake To targets appear in the list.
SpeedData_<object> empty. Leaves the source object's own action untouched. Parent Helper to Source appears only in this mode, since there is nothing to parent otherwise.Object, No Keyframes stores one value per frame as a mesh attribute rather than an F-curve. The Data Display Box reads it exactly as it reads an imported CSV — this is the same container those use — so the channels appear in the scan as usual. What you lose is the Graph Editor: there is no curve to plot or hand-edit. Bake to Source Object or Helper Empty when you want to see the trace as a curve.
Baking onto the source object adds five custom properties and their F-curves to that object's existing action. Replace Existing Curves only ever removes those five; a vehicle's location and rotation animation is not touched.
Settings are remembered per object. What "forward" means, and how much yaw to add to it, is a fact about the object — a camera solved from footage and an HVE vehicle do not agree, and neither do two HVE vehicles. So when a bake succeeds, the settings that produced it are stored on that object; pick it again, from the Source Object field or by clicking it in the viewport, and they come back. The panel says Settings remembered for this object when what you are looking at came from the object rather than from the last thing you baked, with an ✕ to forget them.
An object with nothing remembered leaves the panel exactly as it is, so clicking around a scene never blanks a setup you have just typed. The settings are stored on the object itself, so they survive saving, and travel with it if it is appended into another file.
Scenes baked before this option existed have their channels on
SpeedData_*empties. Those keep working — the Data Display Box scans every object for animated custom properties rather than looking for helpers by name — so existing display profiles do not need rebuilding. Switch to Helper Empty if you want new bakes to match them.
Units are chosen automatically from the scene, or can be forced.
The averaging window at the ends of the range. Speed is measured over a window of frames centred on each frame. Where the window runs past the start or end of the scene range it shrinks, keeping its centre on the frame it belongs to; the very first and last frame fall back to a single-interval difference. Values near the ends are therefore noisier than the middle — there is genuinely less data to average — but they describe the right instant.
Before version 1.0.8 the window slid along instead of shrinking. That kept the width but moved the centre, so on a 0.8 g braking run with an 11-frame window the reported speed was up to 2.9 mph out at each end, and the acceleration read exactly 0 g across the first and last five frames — every frame in that span shared one window and therefore one velocity. Re-bake anything measured with an earlier version; the numbers near the range ends will change, and the new ones are correct.
Forward axis. Forward is measured in the horizontal plane, so an axis that ends up pointing straight up or down carries no heading. Picking +Z or -Z on an upright object does exactly that, and forward and lateral acceleration then fall back to world +Y. The bake now warns when this happens instead of reporting confident nonsense.
XY-only flattens Z before measuring, so vertical acceleration could only ever be zero. It is no longer baked in that mode, rather than appearing in a display box as a reading of 0.000 g.
Use Object Distance to answer "how far apart were these two, and when were they closest" across the whole animation. The result is a set of channels the Data Display Box picks up like any other, so it scrubs with the timeline, renders in the box, and goes out with the CSV export.
The channels land on an empty named Distance: <A> - <B>, which also carries the closest approach — the distance and the frame it happened on — shown back in the panel.
Horizontal Separation is not a rounding of the 3D number. On a graded road or a hill, two vehicles level with each other still differ in Z, and that difference inflates the 3D distance without saying anything about how close they are on the ground.
Closest approach is quoted as a frame. It is the nearest *sampled* frame, with no interpolation between frames — a parabola through the neighbouring samples would read to a finer time than the animation was sampled at, and this is a number that gets quoted. The seconds stamped alongside it count from the start of the scene frame range, which is not necessarily what the display box's Time row reads at that frame: that row counts from the box's own Time Zero Frame.
A bake is a snapshot. Move either object afterwards and the channels describe a scene that no longer exists. The panel shows the frame range the bake covered and flags it when the scene range has changed since — but it cannot see an object that moved, so re-bake after any repositioning.
Add Live Distance gives a reading that follows the two objects instead of a snapshot. Drag either one, at any frame, and the number in the display box changes with it — nothing to re-bake and nothing to go stale. Use it while you are still positioning.
The catch is the other half of the trade: a live reading only ever knows the frame the playhead is standing on. Everything else in the display box is worked out from a frame *number*, which is what lets the CSV export walk the whole range without scrubbing the timeline; two objects' positions are only knowable by evaluating the scene at that frame. So:
| Live | Baked | |
|---|---|---|
| Separation, horizontal, X / Y / Z | yes | yes |
| Closing speed | — | yes |
| Closest approach | — | yes |
| Survives moving an object | yes | re-bake |
| On the timeline / in the graph editor | — | yes |
Closing speed and closest approach cannot be live. A rate needs more than one instant, and closest approach needs the whole run. They are left out rather than shown reading zero, which would look like a measurement instead of an omission.
Both can exist for the same pair at once — they land on separately named helpers (Live Distance: A - B and Distance: A - B) — so you can position against the live reading and bake once you are happy with it.
Exporting a live row to CSV works, and costs a pass. Because a live value has no frame to be asked about, the export fills those columns by actually visiting each frame once, then puts your playhead back. That is the only thing that makes an export slower, and only when a live row is in the profile — a file of baked and imported channels still writes without evaluating the scene at all.
Every measurement in the scene — live and baked alike — is listed at the top of the Object Distance panel, above the settings that make the next one. Until now the only way to reach one was to re-select the two objects it was made from, which meant knowing which pair a given helper described and finding both halves in the outliner.
The list comes first on purpose. With the settings first, the panel opened on From and To already holding the last pair measured, so changing them to measure something else looked like editing the measurement you already had — and the apparent way to start a new one was to delete or overwrite an old one. New Measurement clears the pair and nothing else; the method, units, window and components are how you work, not part of any one measurement.
Each row names the pair and says which kind it is, and flags one whose object has since been deleted. Selecting a row shows what it is: the method it measures with, the live reading or the baked frame range and closest approach, and whether the scene's frame range has moved since the bake.
From there:
A baked measurement's method is changed by baking it again. Its numbers were computed with the method it was baked under, so switching the label alone would leave it describing one thing and its keyframes another. Use This Pair, change Measure above, then re-bake.
The list is read straight off the scene rather than kept alongside it, so deleting a helper in the outliner removes the row on the next redraw with nothing to refresh.
Why there is no "bake onto the source object". The Speed + Acceleration panel offers that because its channels describe one object. These describe a *pair*, and hanging them on half of it would make them look like a property of that object. For the same reason nothing here is registered with an import's Time Zero: the two objects may come from different imports with different Time Zeros, so there is no single import whose clock this belongs to, and scene frames are the only honest index.
Use Data Display Box to render imported data as live text inside a HVE-style box (label column, divider, value column) that updates every frame.
The short version. The panel's sections aren't in the order you use them — the channel list is long, so it sits at the bottom, *below* the button that builds the box. Work in this order instead:
| Step | Do this | Where |
|---|---|---|
| 1 | Import Data CSV, or Scan Imported Data | top of the panel |
| 2 | Tick the channels you want shown | Channels, at the bottom |
| 3 | Create / Update Display Box | Display Boxes & Cameras |
| 4 | Select a camera, then click the 🔗 link button beside the box | Display Boxes & Cameras |
The panel tracks where you are and shows the next step as a numbered line near the top (*"Step 2 of 4: Check channels to show"*). Click that line and it opens the section the step is talking about; hover it for the full instruction. Once a box is built and attached to a camera the line goes away. Everything after step 4 — labels, units, decimals, colours, size, placement — is tuning, and each of those edits updates the box in place while Auto Update is on.
The rest of this section is the detail behind those four steps.
time_s beats a clock-string timestamp_local; with no time-named column at all, the first numeric column is used. A Time Column dropdown in the file browser's sidebar overrides the pick when the file's naming defeats it. Every numeric column is resampled to the scene frame rate and stored as a hidden Data: mesh whose channels appear in the scan below, grouped under the dataset name. If the same column names repeat once per data block (for example a multi-vehicle export with identical X/Y/Z columns for each vehicle), the repeats are automatically disambiguated using whichever header row actually differs between them (typically the vehicle/event ID), so every vehicle's data is kept instead of the last block silently overwriting the others. The dataset is registered in Imported Data like any other import, so it carries a Time Zero you can move later to line it up against other data. Re-timing one of these moves the readout without touching the stored values — the box samples it relative to its Time Zero.SpeedData properties, imported data CSVs, and any other animated custom properties. A Time channel is always offered. If the CSV carried prefix/units header rows (see CSV import basics), the group prefix and units are pre-filled from them.Each row also has detach and ✕ remove (to delete just that box). Camera Distance, Screen Width Fraction, Screen Anchor, and the offsets all update attached boxes live as you drag or change them — no re-attach or rebuild needed. Both perspective and orthographic cameras are supported — orthographic framing is computed from the camera's Orthographic Scale rather than its field of view, so the box sizes and positions correctly either way. An attached box automatically re-anchors itself to its corner every time the box rebuilds — including when you check or uncheck channels afterward — so it never needs re-attaching just because its row count changed.
Removing a box also removes its profile, unless another box still shares it — at least one profile is always kept around to edit.
Once attached, a box's on-screen *size* is set by Screen Width Fraction, not by Box Width — Box Width only controls the box's internal layout (divider position, column widths), so changing it afterward resizes the box on screen without also inflating or shrinking the text. That calibration is captured the moment you click the attach button, so click it again on an already-attached box any time you want to recalibrate its on-screen size to the current Box Width.
An On Camera group closes the section, holding everything that only applies once a box is attached to a camera:
0.1 is a tenth of the frame, positive is right and up. Being fractions means a box nudged clear of a timestamp stays clear of it when the camera moves or the lens changes.The whole group stays greyed out until a box using the profile you're editing is attached to a camera: every control in it only ever repositions an attached box, so before that there is nothing for them to move.
Honda Fit, V Tot (mph)) without editing each variable — and a Zero Frame Offset — an extra frame shift added on top of the box's own Time Zero Frame, applied only to that subgroup's channels. Use it to re-sync one dataset that's drifted a fixed number of frames out of step with the others (for example two CSV imports checked into the same box) without affecting anything else in the box. Both fields are shared across every box profile.The offset steps in whole frames, which is every ordinary use of it, but it is not limited to them: type a fraction and it reads between samples. A dataset sampled at 100 Hz against video at 29.97 fps lands between frames as a rule, and 0.25 genuinely reads a quarter of the way from one sample to the next.
Profiles. A profile is one set of checked channels and their styling; a display box is an object in the scene that renders one. Several boxes can share a profile and stay in step. With more than one profile the panel lists them, showing how many boxes each drives — including none, which is the case Create / Update Display Box exists for.
Picking a profile filters the box list to the boxes it drives, so the choice has a visible effect rather than only changing the channel ticks further down the panel. The header says how many of the total are showing and Show all brings the rest back — nothing is hidden silently. Remove is scoped to what is listed and reads *Remove These Boxes* when the list is filtered.
If both the Recon and HVE toolkits are installed, each manages its own display boxes independently (scanning or rebuilding in one never touches the other's boxes); when the scene also contains boxes from the other toolkit, the panel notes how many so it's clear why they aren't listed here.
Values are sampled from the underlying animation data (keyframed custom properties, per-frame data attributes, or time-interpolated table rows), so the box works during playback and in final renders. Re-scanning keeps your checked channels and edits.
Export CSV, beside Import Data CSV in the Data Display Box panel, writes every channel in the active profile to a file — one row per frame, one column per row of the box, plus a Time column.
It exports what the box shows. The same sampling path, the same Time Zero Frame, the same per-group offsets and the same time offset, so a value in the file and the same value in a render always agree. That matters more than it sounds: a discrepancy between a report table and a rendered overlay is very hard to adjudicate after the fact.
The dialog names the profile it will write. That matters when a scene has more than one box: each is bound to its own profile, and the export takes the one currently selected in the panel — which is not necessarily the box you were just looking at.
This is also how baked speed and acceleration leave Blender, whichever Bake To mode produced them — the export reads through the display, so keyframes, a data mesh and a helper empty all come out the same way.
The playhead is not moved. Export samples each frame directly, so it costs no scene evaluation and leaves you on the frame you were on.
Recon Toolkit respects the scene's Unit System (Scene Properties → Units):
The Distance Units dropdown in Object Distance and Speed + Acceleration overrides this per bake: Auto follows the scene, Feet and Meters state it outright. Speeds follow the lengths — feet with mph, metres with km/h — so a display box never mixes the two systems.
The unit is part of each channel's name (separation_m, closing_speed_kph), which is what lets a number carry its unit into the display box, the CSV export and the report. Changing the unit therefore renames the channels; re-measure and any display box row showing one follows the rename automatically, keeping its label, decimals and position.
Set your unit system before importing so speeds and distances are interpreted correctly. Use Scale Objects to match imported geometry to real-world dimensions.
Example CSVs for trying each importer ship inside the add-on. Click Open Example Files in the Documentation panel (next to Open User Guide) and they open in your file manager — no download needed. In a repository checkout they live in examples/.
| File | Use with |
|---|---|
EDR_YawRate_Example.csv | EDR importer, Yaw Rate mode |
EDR_SteeringAngle_Example.csv | EDR importer, Steering Wheel Angle mode |
EDR_Combined_Example.csv | EDR importer, column mapping (all four columns) |
XYZRPY_Example.csv | Motion Data Importer |
XYZ_Points_Example.csv | Point Importer |
Separation (ft) next to Separation (m). Re-measure and the old one is removed; before 1.3.0 it stayed behind, frozen at its last value.Recon Toolkit™ is a trademark of Engineering Dynamics Company (Anthony Cornetto). The source code is GPL v2 or later. Recon Toolkit is a reconstruction and visualization aid, not a substitute for professional engineering judgment — independently validate every result. See the bundled LICENSE file for licensing and the full disclaimer.
Official builds, updates, and support are provided by Engineering Dynamics Company; visit edccorp.com or contact EDC support.