How to determine the amount of back and side spin rotation of a ball given 2 dots on 2 2D images of the ball

AI says:

If you track two distinct dots (A and B) across both images, you can build a unique 3D coordinate system (a "triad") for each image.

Multiplying these coordinate systems gives you the exact 3x3 rotation matrix, including any spinning.

AI generated code example for 3D rotation

// Expects normalized 3D positions for two dots (A and B) in both image states
cv::Mat getFull3DRotation(cv::Point3f A1, cv::Point3f B1, cv::Point3f A2, cv::Point3f B2) {
// Helper lambda to construct an orthogonal 3D coordinate frame matrix [X | Y | Z]
auto buildFrame = [](cv::Point3f A, cv::Point3f B) {
cv::Point3f x_axis = A; // Use dot A as the primary anchor

cv::Point3f z_axis = A.cross(B); // Perpendicular to both dots
z_axis = z_axis * (1.0 / cv::norm(z_axis));

cv::Point3f y_axis = z_axis.cross(x_axis); // Completes the right-handed frame

cv::Mat M = (cv::Mat_<double>(3, 3) <<
x_axis.x, y_axis.x, z_axis.x,
x_axis.y, y_axis.y, z_axis.y,
x_axis.z, y_axis.z, z_axis.z);
return M;
};

// 1. Build the 3D frame for Image 1 and Image 2
cv::Mat M1 = buildFrame(A1, B1);
cv::Mat M2 = buildFrame(A2, B2);

// 2. Compute the final rotation matrix: R = M2 * Matrix_Transpose(M1)
cv::Mat R = M2 * M1.t();
return R;
}

How to read the resulting Matrix R

Once you have the 3x3 rotation matrix R, you can extract the exact human-readable breakdown of the movement:

Total Angular Travel:\(\text{Total\ Angle}=\arccos \left(\frac{\text{Trace}(R)-1}{2}\right)\)(In OpenCV: double angle = acos((cv::trace(R)[0] - 1.0) / 2.0);)

Euler Angles (Pitch, Roll, Yaw): You can convert R directly into degrees of rotation relative to your camera's viewport axes.

To help write the code that extracts the specific angles you need, tell me:Are you looking for a single total angle of movement or the specific pitch/yaw/roll values?

If you have more than 2 dots (a cloud of dots), would you like to see how to use Singular Value Decomposition (SVD) to filter out measurement noise?

AI says:

cpp

#include <iostream>
#include <cmath>
#include <Eigen/Dense>

// Structure to hold the calculated spins in Revolutions Per Minute (RPM)
struct GolfBallSpin {
double backspinRPM;
double sidespinRPM;
double riflespinRPM;
double totalSpinRPM;
};

/**
* Calculates the spin components of a golf ball.
*
* @param P1 3D points relative to the ball's center in Frame 1 (3 x N matrix)
* @param P2 3D points relative to the ball's center in Frame 2 (3 x N matrix)
* @param deltaTimeSec Time difference between Frame 1 and Frame 2 in seconds
* @return GolfBallSpin structure containing spin values in RPM
*/
GolfBallSpin calculateGolfBallSpin(const Eigen::Matrix3Xd& P1, const Eigen::Matrix3Xd& P2, double deltaTimeSec) {
// 1. Solve Orthogonal Procrustes problem to find the optimal rotation matrix R
// Matrix dimensions: P1 is (3 x N), P2 is (3 x N) -> H is (3 x 3)
Eigen::Matrix3d H = P1 * P2.transpose();

Eigen::JacobiSVD<Eigen::Matrix3d> svd(H, Eigen::ComputeFullU | Eigen::ComputeFullV);
Eigen::Matrix3d U = svd.matrixU();
Eigen::Matrix3d V = svd.matrixV();

Eigen::Matrix3d R = V * U.transpose();

// Handle potential reflection (det(R) == -1)
if (R.determinant() < 0) {
V.col(2) *= -1.0;
R = V * U.transpose();
}

// 2. Convert Rotation Matrix to Axis-Angle representation
Eigen::AngleAxisd angleAxis(R);
double angleRad = angleAxis.angle(); // Total rotation angle in radians
Eigen::Vector3d axis = angleAxis.axis(); // Unit vector of the rotation axis

// 3. Calculate Angular Velocity vector (radians per second)
Eigen::Vector3d angularVelocityRadSec = (angleRad / deltaTimeSec) * axis;

// Convert radians per second to RPM (1 rad/sec = 60 / (2 * pi) RPM)
const double radSecToRPM = 60.0 / (2.0 * M_PI);
Eigen::Vector3d angularVelocityRPM = angularVelocityRadSec * radSecToRPM;

// 4. Map to standard Launch Monitor Coordinate System:
// X = Right, Y = Forward (Target Line), Z = Up
GolfBallSpin spin;

// Backspin is typically modeled as rotation around the X-axis.
// In a right-handed system, a negative X-rotation rolls the top of the ball backward.
spin.backspinRPM = -angularVelocityRPM.x();

// Sidespin is rotation around the Z-axis (vertical axis).
spin.sidespinRPM = angularVelocityRPM.z();

// Rifle spin (axis of travel) is rotation around the Y-axis.
spin.riflespinRPM = angularVelocityRPM.y();

spin.totalSpinRPM = angularVelocityRPM.norm();

return spin;
}

int main() {
// Example Setup:
// High-speed camera frame rate = 10,000 FPS -> dt = 0.0001 seconds
double dt = 0.0001;

// Define 3 sample tracked surface features relative to the center of the ball
Eigen::Matrix3Xd frame1Points(3, 3);
frame1Points << 0.021, -0.010, 0.005, // Point 1 (X, Y, Z) in meters
0.000, 0.021, -0.015, // Point 2
0.011, 0.011, 0.018; // Point 3

// Simulate pure backspin (e.g., a 20-degree rotation around the negative X-axis)
double simAngle = -20.0 * M_PI / 180.0;
Eigen::Matrix3d simR;
simR = Eigen::AngleAxisd(simAngle, Eigen::Vector3d::UnitX());

Eigen::Matrix3Xd frame2Points = simR * frame1Points;

// Calculate Spin
GolfBallSpin result = calculateGolfBallSpin(frame1Points, frame2Points, dt);

// Display Results
std::cout << "--- Golf Ball Spin Estimation ---\n";
std::cout << "Backspin: " << result.backspinRPM << " RPM\n";
std::cout << "Sidespin: " << result.sidespinRPM << " RPM\n";
std::cout << "Riflespin: " << result.riflespinRPM << " RPM\n";
std::cout << "Total Spin: " << result.totalSpinRPM << " RPM\n";

return 0;
}

How to ask AI what the back and side spin rates are given the x,y shifts of a point on the ball between 2 frames

AI says:

cpp
#include <iostream>
#include <cmath>
#include <algorithm>

// Structure to hold 3D vector coordinates
struct Vector3D {
double x, y, z;
};

// Structure to hold the calculated spin values in RPM
struct GolfSpin {
double backspin; // Positive means backspin, negative means topspin
double sidespin; // Direction depends on camera placement (e.g., left/right)
double rifleSpin; // Gyroscopic spin around the camera's optical axis
double totalSpin; // Total magnitude of the spin
};

/**
* Calculates golf ball spin components in RPM from a tracked dot.
*
* @param x1, y1 Coordinates of the dot in Frame 1 (relative to ball center)
* @param x2, y2 Coordinates of the dot in Frame 2 (relative to ball center)
* @param radiusPlx Radius of the ball in pixels (e.g., 50.0)
* @param frameRate Camera frame rate in Hz (e.g., 1500.0)
* @return GolfSpin Calculated spin values in RPM
*/
GolfSpin calculateGolfSpin(double x1, double y1, double x2, double y2, double radiusPlx, double frameRate) {
GolfSpin spin = {0.0, 0.0, 0.0, 0.0};

// 1. Reconstruct Z coordinates on the sphere surface (assuming front hemisphere facing camera)
double z1_sq = radiusPlx * radiusPlx - x1 * x1 - y1 * y1;
double z2_sq = radiusPlx * radiusPlx - x2 * x2 - y2 * y2;

// Clamp to 0 to prevent negative values due to floating-point rounding errors near the edges
double z1 = std::sqrt(std::max(0.0, z1_sq));
double z2 = std::sqrt(std::max(0.0, z2_sq));

Vector3D v1 = {x1, y1, z1};
Vector3D v2 = {x2, y2, z2};

// 2. Calculate the cross product to find the perpendicular rotation axis
Vector3D cross = {
v1.y * v2.z - v1.z * v2.y,
v1.z * v2.x - v1.x * v2.z,
v1.x * v2.y - v1.y * v2.x
};

double crossNorm = std::sqrt(cross.x * cross.x + cross.y * cross.y + cross.z * cross.z);

// If the dot didn't move or moved perfectly linearly through the center (ambiguous), spin is 0
if (crossNorm < 1e-6) {
return spin;
}

// Normalize the axis of rotation
Vector3D axis = {cross.x / crossNorm, cross.y / crossNorm, cross.z / crossNorm};

// 3. Calculate the rotation angle (theta) using the dot product
double dot = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
double cosTheta = dot / (radiusPlx * radiusPlx);
cosTheta = std::max(-1.0, std::min(1.0, cosTheta)); // Clamp to avoid NaN in acos
double theta = std::acos(cosTheta); // Radians

// 4. Convert angular velocity to RPM (Revolutions Per Minute)
// RPM = (theta / dt) * (60 / 2*pi)
double dt = 1.0 / frameRate;
double radPerSec = theta / dt;
spin.totalSpin = radPerSec * (60.0 / (2.0 * M_PI));

// 5. Map rotation axis components to golf spin conventions
// - Rotation around X-axis creates vertical movement (Backspin/Topspin)
// - Rotation around Y-axis creates horizontal movement (Sidespin)
// - Rotation around Z-axis creates rifle/gyro spin

// Sign convention adjustment: Right-hand rule means a negative X axis rotation
// corresponds to the front face moving upward (true golf backspin)
spin.backspin = -axis.x * spin.totalSpin;
spin.sidespin = axis.y * spin.totalSpin;
spin.rifleSpin = axis.z * spin.totalSpin;

return spin;
}

int main() {
// Example usage:
// Dot shifts slightly right (+x) and up (+y) between frames
double x1 = 5.0, y1 = 10.0;
double x2 = 7.0, y2 = 12.0;
double radius = 50.0;
double fps = 1500.0;

GolfSpin result = calculateGolfSpin(x1, y1, x2, y2, radius, fps);

std::cout << "--- Golf Ball Spin Results ---" << std::endl;
std::cout << "Total Spin: " << result.totalSpin << " RPM" << std::endl;
std::cout << "Backspin: " << result.backspin << " RPM" << std::endl;
std::cout << "Sidespin: " << result.sidespin << " RPM" << std::endl;
std::cout << "Rifle Spin: " << result.rifleSpin << " RPM" << std::endl;

return 0;
}

How to calculate the back and side spin rates given the x,y shifts of a point on the ball between 2 frames with a downward facing camera

AI says:

cpp
#include <iostream>
#include <cmath>
#include <algorithm>

// Structure for 3D spatial vectors
struct Vector3D {
double x, y, z;
};

// Structure to hold golf ball spin metrics in RPM
struct GolfSpin {
double backspin; // Positive = true backspin, Negative = topspin
double sidespin; // Positive = clockwise (right), Negative = counter-clockwise (left)
double rifleSpin; // Gyroscopic spin around the vertical camera axis
double totalSpin; // Combined magnitude of all spin components
};

/**
* Calculates golf ball spin metrics from a top-down camera perspective.
*
* @param x1, y1 Dot coordinates in Frame 1 (relative to ball center: +X right, +Y forward)
* @param x2, y2 Dot coordinates in Frame 2 (relative to ball center: +X right, +Y forward)
* @param radiusPlx Radius of the ball image in pixels (50.0)
* @param frameRate Camera frame rate in Hz (1500.0)
* @return GolfSpin Calculated spin values in RPM
*/
GolfSpin calculateTopDownGolfSpin(double x1, double y1, double x2, double y2, double radiusPlx, double frameRate) {
GolfSpin spin = {0.0, 0.0, 0.0, 0.0};

// 1. Reconstruct Z (height/depth) on the upper sphere surface facing the camera
double z1_sq = radiusPlx * radiusPlx - x1 * x1 - y1 * y1;
double z2_sq = radiusPlx * radiusPlx - x2 * x2 - y2 * y2;

// Clamp to 0 to prevent negative sqrt due to floating-point rounding near edges
double z1 = std::sqrt(std::max(0.0, z1_sq));
double z2 = std::sqrt(std::max(0.0, z2_sq));

Vector3D v1 = {x1, y1, z1};
Vector3D v2 = {x2, y2, z2};

// 2. Find the perpendicular rotation axis via cross product (v1 x v2)
Vector3D cross = {
v1.y * v2.z - v1.z * v2.y,
v1.z * v2.x - v1.x * v2.z,
v1.x * v2.y - v1.y * v2.x
};

double crossNorm = std::sqrt(cross.x * cross.x + cross.y * cross.y + cross.z * cross.z);

// Guard against edge cases where the dot didn't move or tracking failed
if (crossNorm < 1e-6) {
return spin;
}

// Normalize the rotation vector axis
Vector3D axis = {cross.x / crossNorm, cross.y / crossNorm, cross.z / crossNorm};

// 3. Compute angular rotation (theta) between frames using dot product
double dot = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
double cosTheta = dot / (radiusPlx * radiusPlx);
cosTheta = std::max(-1.0, std::min(1.0, cosTheta)); // Clamp to valid acos domain
double theta = std::acos(cosTheta); // Radians

// 4. Convert angular displacement to RPM (Revolutions Per Minute)
double dt = 1.0 / frameRate;
double radPerSec = theta / dt;
spin.totalSpin = radPerSec * (60.0 / (2.0 * M_PI));

// 5. Map 3D rotation axis to top-down golf spin definitions
// Under standard Right-Hand Rule (+X right, +Y forward, +Z up):
// - A positive rotation around +X moves +Y down toward -Z (Topspin).
// Therefore, true backspin requires a negative X axis component.
spin.backspin = -axis.x * spin.totalSpin;

// - A positive rotation around +Y moves +Z toward +X (Clockwise sidespin from above).
spin.sidespin = axis.y * spin.totalSpin;

// - A positive rotation around +Z moves +X toward +Y (Rifle spin).
spin.rifleSpin = axis.z * spin.totalSpin;

return spin;
}

int main() {
// Example: Frame 1 to Frame 2 shift
double x1 = -10.0, y1 = 5.0;
double x2 = -8.0, y2 = 2.0;
double radius = 50.0;
double fps = 1500.0;

GolfSpin result = calculateTopDownGolfSpin(x1, y1, x2, y2, radius, fps);

std::cout << "--- Top-Down Camera Golf Spin ---" << std::endl;
std::cout << "Total Spin: " << result.totalSpin << " RPM" << std::endl;
std::cout << "Backspin: " << result.backspin << " RPM" << std::endl;
std::cout << "Sidespin: " << result.sidespin << " RPM" << std::endl;
std::cout << "Rifle Spin: " << result.rifleSpin << " RPM" << std::endl;

return 0;
}

How to Calculate ball VLA and HLA when using a stereo camera system

Note: the current CP method of VLA and HLA calculation already uses this same method as suggested by AI

AI says:

Complete C++ ImplementationThis function takes the world-space coordinates of the ball from two distinct frames and outputs the launch angles in degrees.cpp#include <iostream>
#include <cmath>

// Structure for 3D coordinates transformed to the hitting mat world frame
struct WorldPoint3D {
double x; // Left (-) / Right (+) relative to target line
double y; // Height above the ground
double z; // Distance downrange toward target
};

struct LaunchAngles {
double vla_deg; // Vertical Launch Angle in degrees
double hla_deg; // Horizontal Launch Angle in degrees
};

/**
* Calculates VLA and HLA from two consecutive world-coordinate points.
*/
LaunchAngles calculateLaunchAngles(const WorldPoint3D& p1, const WorldPoint3D& p2) {
// 1. Calculate direction vector components
double dx = p2.x - p1.x;
double dy = p2.y - p1.y;
double dz = p2.z - p1.z;

// Constants for radian-to-degree conversion
const double rad_to_deg = 180.0 / M_PI;

LaunchAngles angles;

// 2. Calculate Vertical Launch Angle (VLA)
// Horizontal ground distance traveled: sqrt(dx^2 + dz^2)
double ground_distance = std::sqrt(dx * dx + dz * dz);
angles.vla_deg = std::atan2(dy, ground_distance) * rad_to_deg;

// 3. Calculate Horizontal Launch Angle (HLA)
// Measures deviation along the X axis relative to the Z target line
angles.hla_deg = std::atan2(dx, dz) * rad_to_deg;

return angles;
}

int main() {
// Example: Ball launches from tee at (0, 0, 0)
WorldPoint3D frame1 = {0.0, 0.0, 0.0};

// Frame 2: Ball travels downrange (Z), climbs upward (Y), and pushes slightly right (X)
WorldPoint3D frame2 = {0.12, 0.45, 1.8};

LaunchAngles results = calculateLaunchAngles(frame1, frame2);

std::cout << "Vertical Launch Angle (VLA): " << results.vla_deg << " degrees" << std::endl;
std::cout << "Horizontal Launch Angle (HLA): " << results.hla_deg << " degrees" << std::endl;
std::cout << " (Positive HLA = Push/Right, Negative HLA = Pull/Left)" << std::endl;

return 0;
}

How to calculate ball speed from a stereo camera system

AI says:

cpp#include <iostream>
#include <cmath>

// Structure to hold 3D coordinates in feet
struct Point3D {
double x; // Left/Right displacement
double y; // Up/Down displacement (relative to camera height)
double z; // Depth/Distance away from the camera plane
};

/**
* Calculates golf ball speed from two stereo frames.
*
* @param left_u1, left_v1 : Ball pixel coordinates in Left Camera (Frame 1)
* @param right_u1 : Ball X pixel coordinate in Right Camera (Frame 1)
* @param left_u2, left_v2 : Ball pixel coordinates in Left Camera (Frame 2)
* @param right_u2 : Ball X pixel coordinate in Right Camera (Frame 2)
* @param fx, fy : Focal lengths in pixels (from camera calibration)
* @param cx, cy : Optical center pixel coordinates (from camera calibration)
* @param baseline_ft : Distance between cameras in feet (2.0)
* @param fps : Camera frame rate (1500.0)
* @return : Speed in Miles per Hour (MPH)
*/
double calculateGolfBallSpeedMPH(
double left_u1, double left_v1, double right_u1,
double left_u2, double left_v2, double right_u2,
double fx, double fy, double cx, double cy,
double baseline_ft = 2.0, double fps = 1500.0)
{
// ----------------------------------------------------
// FRAME 1: Triangulate 3D Position
// ----------------------------------------------------
double disparity1 = left_u1 - right_u1;
if (disparity1 <= 0) return 0.0; // Avoid division by zero or negative depth

Point3D p1;
p1.z = (fx * baseline_ft) / disparity1;
p1.x = ((left_u1 - cx) * p1.z) / fx;
p1.y = ((left_v1 - cy) * p1.z) / fy;

// ----------------------------------------------------
// FRAME 2: Triangulate 3D Position
// ----------------------------------------------------
double disparity2 = left_u2 - right_u2;
if (disparity2 <= 0) return 0.0;

Point3D p2;
p2.z = (fx * baseline_ft) / disparity2;
p2.x = ((left_u2 - cx) * p2.z) / fx;
p2.y = ((left_v2 - cy) * p2.z) / fy;

// ----------------------------------------------------
// SPEED CALCULATION
// ----------------------------------------------------
// 1. Compute 3D Euclidian straight-line distance (feet)
double distance_ft = std::sqrt(
std::pow(p2.x - p1.x, 2) +
std::pow(p2.y - p1.y, 2) +
std::pow(p2.z - p1.z, 2)
);

// 2. Compute time difference between consecutive frames (seconds)
double delta_t = 1.0 / fps;

// 3. Compute speed in Feet per Second
double speed_fps = distance_ft / delta_t;

// 4. Convert Feet per Second to Miles per Hour (1 FPS = 0.681818 MPH)
double speed_mph = speed_fps * 0.681818;

return speed_mph;
}

int main() {
// --- Mock Calibration Data ---
// Example: A 1080p sensor where a 12mm lens yields fx/fy around 3600 pixels
double fx = 3600.0;
double fy = 3600.0;
double cx = 960.0; // Center X for 1920 width
double cy = 540.0; // Center Y for 1080 height

// --- Mock Tracking Data (Consecutive frames at 1500 FPS) ---
// Frame 1
double lu1 = 960.0, lv1 = 540.0;
double ru1 = 780.0; // Disparity = 180 pixels -> Depth = (3600*2)/180 = 40 feet

// Frame 2 (Ball moved slightly forward and to the right)
double lu2 = 980.0, lv2 = 535.0;
double ru2 = 798.5; // Disparity = 181.5 pixels -> Depth changes slightly

double speed = calculateGolfBallSpeedMPH(lu1, lv1, ru1, lu2, lv2, ru2, fx, fy, cx, cy);

std::cout << "Calculated Ball Speed: " << speed << " MPH" << std::endl;

return 0;
}

Critical C++ Architecture ConsiderationsSub-pixel Accuracy:

When tracking at \(1500\text{ FPS}\), the distance the ball travels between two single frames is tiny (a matter of inches).

If you only track the center of the ball to the nearest whole integer pixel, your speed calculation will violently jitter due to rounding errors.

Use an algorithm like Centroid Detection via Connected Components or Hough Circles to yield sub-pixel double floating-point coordinates. 

Transforming to Ground Coordinates: The \[Y\] coordinate computed above is relative to the camera lenses (\(9\text{ ft}\) high).

If your camera array is tilted downward to face the hitting mat, you will need to multiply your Point3D coordinates by an Extrinsic Rotation Matrix (R) obtained

during your stereo setup calibration to align the \[Y\]-axis perfectly perpendicular to the floor. 

Multi-Frame Smoothing: Relying on just two frames can introduce noise.

For production code, track the ball across 5 to 10 frames, compute the 3D position for each, and fit a 3D linear or parabolic regression line using a library like Eigen to calculate a highly accurate velocity vector.

 Do you have your camera matrices/focal length in pixels already saved from an OpenCV calibration file, or do you need help writing the OpenCV code to load your XML/YML calibration file? 

#include <iostream>
#include <cmath>
#include <vector>
#include <opencv2/opencv.hpp>

// Constants based on the user's physical setup
const double FPS = 1500.0;
const double DT = 1.0 / FPS; // Time between frames in seconds
const double BASELINE = 2.0; // 2 feet separation

struct Point3D {
double x, y, z;
};

struct BallMetrics {
double speed_fps; // Feet per second
double speed_mph; // Miles per hour
double vla_deg; // Vertical Launch Angle in degrees
double hla_deg; // Horizontal Launch Angle in degrees
};

// Function to calculate tracking metrics from two sequential 3D points
BallMetrics calculateGolfBallMetrics(const Point3D& p1, const Point3D& p2) {
double dx = p2.x - p1.x;
double dy = p2.y - p1.y;
double dz = p2.z - p1.z; // dz is negative if the ball goes UP (closer to ceiling)

// 3D Distance traveled
double distance = std::sqrt(dx*dx + dy*dy + dz*dz);

BallMetrics metrics;
metrics.speed_fps = distance / DT;
metrics.speed_mph = metrics.speed_fps * 0.681818; // Convert ft/s to mph

// Horizontal Launch Angle (relative to forward Y axis)
// Positive = Right, Negative = Left
metrics.hla_deg = std::atan2(dx, dy) * (180.0 / M_PI);

// Vertical Launch Angle (relative to the ground plane)
// We negate dz because a rising ball decreases its distance from the ceiling camera
double horizontal_dist = std::sqrt(dx*dx + dy*dy);
metrics.vla_deg = std::atan2(-dz, horizontal_dist) * (180.0 / M_PI);

return metrics;
}

int main() {
// 1. Stereo Calibration Setup (Replace placeholders with actual calibration values)
// Focal length 'f' must be in pixels (derived from calibration)
double f_pixel = 1500.0;
double cx = 640.0; // Principal point X
double cy = 480.0; // Principal point Y

// Projection matrices for Left and Right camera after stereoRectify()
cv::Mat P1 = (cv::Mat_<double>(3, 4) << f_pixel, 0, cx, 0,
0, f_pixel, cy, 0,
0, 0, 1, 0);

// Right camera is shifted by BASELINE (2.0 ft) along the X axis
cv::Mat P2 = (cv::Mat_<double>(3, 4) << f_pixel, 0, cx, -f_pixel * BASELINE,
0, f_pixel, cy, 0,
0, 0, 1, 0);

// 2. Simulated Ball Tracking Coordinates (2D Centroids from Left and Right frame matching)
// Frame T1
cv::Point2f left_pixel_t1(650.0f, 500.0f);
cv::Point2f right_pixel_t1(500.0f, 500.0f); // Disparity = 150

// Frame T2 (1/1500th of a second later)
cv::Point2f left_pixel_t2(665.0f, 485.0f);
cv::Point2f right_pixel_t2(520.0f, 485.0f); // Disparity = 145

// Container for triangulation
std::vector<cv::Point2f> left_pts = {left_pixel_t1, left_pixel_t2};
std::vector<cv::Point2f> right_pts = {right_pixel_t1, right_pixel_t2};
cv::Mat points4D;

// 3. Triangulate points to find 3D coordinates
cv::triangulatePoints(P1, P2, left_pts, right_pts, points4D);

// Extract Homogeneous coordinates back to 3D Cartesian coordinates
std::vector<Point3D> points3D(2);
for (int i = 0; i < 2; ++i) {
double w = points4D.at<float>(3, i);
points3D[i].x = points4D.at<float>(0, i) / w;
points3D[i].y = points4D.at<float>(1, i) / w;
points3D[i].z = points4D.at<float>(2, i) / w;
}

// 4. Calculate Final Launch Parameters
BallMetrics ball = calculateGolfBallMetrics(points3D[0], points3D[1]);

// Output Results
std::cout << "--- Golf Ball Launch Monitor Results ---" << std::endl;
std::cout << "Ball Speed: " << ball.speed_fps << " ft/s (" << ball.speed_mph << " mph)" << std::endl;
std::cout << "Vertical Launch Angle (VLA): " << ball.vla_deg << " degrees" << std::endl;
std::cout << "Horizontal Launch Angle (HLA): " << ball.hla_deg << " degrees" << std::endl;

return 0;
}

How to calibrate the cameras using OpenCV

Note: the current CP method of camera calibration uses a tried and tested calibration table that seems to work just fine,

so I'll have to compare it with the AI method to see if it is worth updating.

AI says:

To perform camera calibration in OpenCV, you must capture multiple images of a known pattern

(typically a chessboard or an asymmetric circle grid) from different angles.

OpenCV uses these images to solve for the camera's intrinsic parameters (focal length, optical center) and distortion coefficients (radial and tangential lens distortion).