From Shaky Squats to Perfect Form: Master Workout Analysis with Dynamic Time Warping (DTW)

So, you’ve been hitting your home workouts, but are you actually doing those squats correctly, or are you just "aggressively vibrating" in your living room?

In the world of fitness tracking and motion analysis, counting repetitions is easy. The real challenge—the "Holy Grail" for developers—is quality assessment. How do we know if a user's range of motion is deep enough? How do we detect a "lazy" pushup?

Today, we are diving deep into the world of Dynamic Time Warping (DTW), Core Motion, and Apple Watch data processing. We’ll learn how to take raw accelerometer and gyroscope data and turn it into a "Standardness Score."

Why Euclidean Distance Fails (and why DTW is King 👑)

When comparing two motion sequences (a "Gold Standard" squat vs. your actual squat), they are rarely the same length. One person might squat in 2 seconds; another might take 3. If you use simple Euclidean distance, the "time shift" makes the sequences look completely different.

Dynamic Time Warping (DTW) solves this by "stretching" or "compressing" the time axis to find the optimal alignment between two sequences. This makes it perfect for Human Activity Recognition (HAR).

The Architecture: From Wrist to Result

Before we get into the code, let's look at the data flow. We capture raw motion, clean it, and then run it through our DTW engine to compare it against a pre-recorded "perfect" rep.

graph TD

    A[Apple Watch: Core Motion] -->|Raw Accel/Gyro| B[Data Preprocessing]

    B -->|Noise Filter/Normalization| C[Feature Extraction]

    C -->|Motion Vector| D{DTW Algorithm}

    E[Standard 'Gold' Template] -->|Reference Vector| D

    D -->|Alignment Score| F[Form Quality Feedback]

    F -->|Output| G[Real-time UI: 'Go Deeper!']

Step 1: Capturing Motion with Swift & Core Motion

First, we need to extract high-frequency data from the Apple Watch. For workout analysis, a sampling rate of 50Hz - 100Hz is ideal.

import CoreMotion



class MotionManager {

    let motionManager = CMMotionManager()

    var motionDataLog: [[Double]] = []



    func startTracking() {

        guard motionManager.isDeviceMotionAvailable else { return }



        // We want high frequency for DTW precision

        motionManager.deviceMotionUpdateInterval = 1.0 / 50.0 



        motionManager.startDeviceMotionUpdates(to: .main) { (data, error) in

            guard let data = data else { return }



            // Extracting Gravity and User Acceleration

            let frame = [

                data.userAcceleration.x, 

                data.userAcceleration.y, 

                data.userAcceleration.z,

                data.rotationRate.x,

                data.rotationRate.y,

                data.rotationRate.z

            ]

            self.motionDataLog.append(frame)

        }

    }

}

Pro-tip: Don't just use raw accelerometer data. userAcceleration removes the constant 1g of gravity, making your signal much cleaner! 🚀

Step 2: The Logic - Comparing Sequences with FastDTW

Once we have our data, we need to compare it to our template. Since DTW can be computationally expensive ($O(N^2)$), we use FastDTW, which provides a linear $O(N)$ approximation.

In a production environment, you might send this data to a Python-based backend or use a C++ implementation wrapped in Swift. Here is how the logic looks using NumPy and FastDTW:

import numpy as np

from fastdtw import fastdtw

from scipy.spatial.distance import euclidean



def calculate_form_score(user_sequence, template_sequence):

    """

    user_sequence: Numpy array of shape (N, 6)

    template_sequence: Numpy array of shape (M, 6)

    """

    # 1. Normalize data (Z-score normalization)

    u_norm = (user_sequence - np.mean(user_sequence)) / np.std(user_sequence)

    t_norm = (template_sequence - np.mean(template_sequence)) / np.std(template_sequence)



    # 2. Run FastDTW

    distance, path = fastdtw(u_norm, t_norm, dist=euclidean)



    # 3. Convert distance to a 0-100 score

    # Lower distance = Higher similarity

    max_allowable_distance = 50.0 # Tuned based on your dataset

    score = max(0, 100 - (distance / len(path)) * 10)



    return score



# Example usage

perfect_squat = np.load("perfect_squat.npy")

current_rep = np.array([[...], [...]]) # Data from Watch

print(f"Form Accuracy: {calculate_form_score(current_rep, perfect_squat)}%")

Step 3: Going Production-Ready

Building a prototype is easy, but making it work for thousands of users with different body types is hard. For instance, how do you handle different arm lengths in a pushup?

If you're looking for more production-ready examples and advanced motion-processing patterns, I highly recommend checking out the technical deep-dives over at WellAlly Blog. They cover some incredible architectural patterns for scaling wearable data pipelines and using AI to refine human activity recognition beyond simple algorithms.

Key Considerations for Production:

1. Signal Windowing: Use a sliding window to detect the start and end of a rep before running DTW.


2. Coordinate Space: Always transform motion data into a "World Coordinate" system so that the orientation of the Watch doesn't break your algorithm.


3. Battery Life: Don't run DTW every millisecond. Batch your reps and process them after the set is complete or in small chunks.

Conclusion: The Future of Wearables is Qualitative

We are moving away from "How many?" to "How well?". By combining Core Motion for data collection and Dynamic Time Warping for sequence analysis, we can build apps that act like a digital personal trainer.

Whether you’re building the next big fitness app or just tinkering with your Apple Watch, mastering motion analysis is a superpower.

What are you building next? Let me know in the comments! 👇