Skip to main content
Step 3 of the analysis pipeline compares the surgeon’s actual trajectory to an ideal straight-line path between the start and end points. This benchmarking reveals how closely the surgeon followed the most direct route.

​
Function Signature

def _paso3_benchmarking(df: pd.DataFrame) -> Dict:
    """
    Compares actual trajectory to ideal straight-line path.
    Returns average deviation and precision percentage.
    """

​
Concept

The benchmarking step evaluates spatial precision by measuring how much the actual path deviates from a theoretical perfect path:

​
Implementation

analysis_pipeline.py
def _paso3_benchmarking(df: pd.DataFrame) -> Dict:
    # Benchmarking simple: Desviación vs Línea Recta Ideal
    p_start = np.array([df["x"].iloc[0], df["y"].iloc[0], df["z"].iloc[0]])
    p_end = np.array([df["x"].iloc[-1], df["y"].iloc[-1], df["z"].iloc[-1]])
    
    def dist_to_line(p, a, b):
        if np.all(a == b): return np.linalg.norm(p-a)
        return np.linalg.norm(np.cross(b-a, a-p)) / np.linalg.norm(b-a)
    
    desviaciones = [dist_to_line(np.array([r.x, r.y, r.z]), p_start, p_end) for r in df.itertuples()]
    
    return {
        "desviacion_avg": np.mean(desviaciones),
        "precision": max(0, 100 - np.mean(desviaciones) * 10)
    }

​
Algorithm Breakdown

1

Define Ideal Line

The ideal path is a straight line from the first movement to the last.
p_start = np.array([df["x"].iloc[0], df["y"].iloc[0], df["z"].iloc[0]])
p_end = np.array([df["x"].iloc[-1], df["y"].iloc[-1], df["z"].iloc[-1]])
2

Calculate Point-to-Line Distance

For each point in the trajectory, compute perpendicular distance to the ideal line.The distance from point p to line defined by points a and b is:Formula: d=∣∣(b−a)×(a−p)∣∣∣∣b−a∣∣d = \frac{||(b-a) \times (a-p)||}{||b-a||}
def dist_to_line(p, a, b):
    if np.all(a == b): return np.linalg.norm(p-a)
    return np.linalg.norm(np.cross(b-a, a-p)) / np.linalg.norm(b-a)
The cross product gives a vector perpendicular to the line, whose magnitude equals the distance times the line length.
3

Aggregate Deviations

Calculate mean deviation across all trajectory points.
desviaciones = [dist_to_line(np.array([r.x, r.y, r.z]), p_start, p_end) 
               for r in df.itertuples()]
desviacion_avg = np.mean(desviaciones)
4

Convert to Precision Percentage

Transform average deviation into an intuitive precision score (0-100%).
precision = max(0, 100 - desviacion_avg * 10)
The scaling factor (10) is calibrated so that a deviation of 1 unit reduces precision by 10%.

​
Output Structure

The function returns a dictionary with two keys:
KeyTypeDescriptionRange
desviacion_avgfloatMean perpendicular distance from ideal line0 - ∞
precisionfloatPercentage score (100 = perfect)0 - 100

​
Example Output

{
  "desviacion_avg": 2.35,
  "precision": 76.5
}
This indicates:
  • Average deviation of 2.35 units from the ideal path
  • Precision score of 76.5% (good, but not excellent)

​
Visual Interpretation

Start ●━━━━━━━━━━━━━━━━━━━━━● End
      ●───────●────●──────●
Trajectory closely follows the ideal line.

​
Edge Cases

If the surgeon returns to the starting position, the ideal line has zero length. The function handles this by returning the distance from each point to the start:
if np.all(a == b): return np.linalg.norm(p-a)
If there’s only one movement, deviation and precision will both be 0 and 100 respectively, since there’s no deviation from a point.
The max(0, ...) ensures precision never goes negative, even if average deviation is very high.

​
Limitations

This benchmarking approach assumes the ideal path is a straight line. For complex surgeries where curved paths are necessary (e.g., avoiding critical structures), this may not reflect true performance.

​
Future Enhancements

Potential improvements to the benchmarking system:
  • Expert trajectory comparison: Compare against paths taken by expert surgeons
  • Anatomical constraints: Account for obstacle avoidance requirements
  • Task-specific ideals: Different ideal paths for different surgical procedures
  • Time-weighted deviations: Penalize deviations during critical moments more heavily

​
Clinical Significance

High precision (>85%) indicates:

Strong Spatial Planning

The surgeon planned the optimal path before executing

Steady Execution

Minimal hand tremor and good motor control

Efficient Movement

Direct paths reduce procedure time and tissue trauma

Consistent Skill

Reproducible performance across multiple attempts

​
Performance

The list comprehension iterates through all movements, but the distance calculation is fast:
  • Vector operations: NumPy cross product and norm are C-optimized
  • No nested loops: O(n) complexity
  • Minimal memory: Only stores deviation values
Typical performance: ~8ms for 5000 movements

​
Next Step

With precision quantified, the pipeline moves to risk analysis:

Risk Analysis

Identify critical events and dangerous spatial patterns

Build docs developers (and LLMs) love

Get started for freeTalk to us