💻 computer science

GeoFIK: A Fast and Reliable Geometric Solver for the IK of the Franka Arm based on Screw Theory Enabling Multiple Redundancy Parameters

This paper introduces GeoFIK, a fast and reliable analytical inverse kinematics solver for the 7-DOF Franka robot arm based on screw theory that effectively handles link offsets, identifies singularities, and enables flexible redundancy resolution through parameters like the swivel angle.

Original authors: Pablo C. Lopez-Custodio, Yuhe Gong, Luis F. C. Figueredo

Published 2026-03-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Pablo C. Lopez-Custodio, Yuhe Gong, Luis F. C. Figueredo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very sophisticated, 7-jointed robotic arm (like the Franka arm used in labs everywhere). Your goal is to tell this robot: "Move your hand to this specific spot in space, facing this specific direction."

This is the Inverse Kinematics (IK) problem. It's like asking, "If I want my hand to hold a cup of coffee here, how do I bend my elbow, shoulder, and wrist to get there?"

For a human, this is easy because we do it instinctively. For a robot, it's a massive math puzzle. Because the Franka arm has 7 joints (but we only need 6 to position a hand in space), it has one extra degree of freedom. This means there isn't just one way to reach the cup; there are infinitely many ways. You could reach over the cup, under it, or twist your body. The robot needs a "brain" to pick the best way.

The Problem: The "Franka" is a Tricky Puzzle

Most robotic arms are built like a standard human arm: a shoulder, an elbow, and a wrist that all rotate around a single point (a "spherical" joint). This makes the math easy.

The Franka arm, however, is a bit weird. It has offsets (like a wrist that is slightly bent or shifted) to make it safer and lighter. This breaks the symmetry.

The Old Way: Existing software tries to solve this by "locking" one joint (usually the last one, the wrist twist) and pretending the robot is a 6-jointed arm.
The Flaw: This is like trying to solve a Rubik's cube by taping one sticker down. It works sometimes, but if the robot gets into a tricky position (a "singularity"), the math breaks, the robot freezes, or it picks a solution that crashes into itself.

The Solution: Enter "GeoFIK"

The authors of this paper created GeoFIK (Geometric Franka Inverse Kinematics). Think of it as a new, super-smart navigation system for the robot.

Here is how it works, using simple analogies:

1. The "Screw Theory" Compass

Instead of just crunching numbers blindly, GeoFIK uses Screw Theory. Imagine the robot's joints aren't just hinges, but spirals (like a screw).

Old Solvers: Try to guess the angle of every screw one by one. If they guess wrong, they get stuck.
GeoFIK: It looks at the entire shape of the robot first. It maps out the "spiral paths" (axes) of all the joints before it even tries to calculate the angles. It's like looking at a map of a city before you start driving, rather than just turning the steering wheel and hoping you don't hit a wall.

2. The "Swivel" Trick

Because the robot has that extra joint, it can "swivel" its arm around the target.

Old Solvers: Usually force the robot to keep its wrist fixed in one direction. If that direction is blocked, the robot gives up.
GeoFIK: It treats the swivel angle (how the whole arm twists around the target) as a free variable. It's like telling a human, "You can twist your body however you want to reach that cup, as long as your hand ends up in the right spot." This allows the robot to find solutions that other software thinks are impossible.

3. The "Speedy Sidekick" (The Jacobian)

In robotics, there's a complex math tool called the Jacobian that tells the robot how fast it needs to move to reach a target smoothly.

Old Solvers: Calculate the angles first, then spend extra time calculating the Jacobian. It's like baking a cake and then separately calculating how much flour you used.
GeoFIK: Because it uses the "spiral map" (Screw Theory), the Jacobian comes out for free while it's solving the angles. It's like the recipe tells you the ingredients and the baking time in one go. This makes it incredibly fast.

Why Does This Matter? (The Real-World Test)

The authors tested GeoFIK against the current "champions" of robot software in a real lab with a real Franka robot.

The "Freeze" Test: In a tricky spot where the robot's arm gets "flat" (like a straight line), the old software froze or crashed. GeoFIK kept moving smoothly.
The "Chatter" Test: When the old software tried to fix itself, the robot's joints would jitter violently (like a car engine shaking). GeoFIK moved smoothly.
The "Speed" Test: GeoFIK was faster at calculating the moves, especially when it had to calculate the "speed map" (Jacobian) at the same time.

The Bottom Line

Imagine you are driving a car.

Old Solvers are like a GPS that only knows one route. If there's a roadblock, it says "Recalculating..." and then gets stuck.
GeoFIK is like a super-intelligent GPS that sees the whole city, knows you can take a detour through a park, and tells you the fastest way to get there without ever getting stuck.

This paper introduces a tool that makes the Franka robot faster, safer, and more reliable, allowing it to do complex tasks (like sweeping a floor or pushing an object) without freezing up or crashing. It turns a "tricky puzzle" robot into a truly flexible and robust worker.

1. Problem Statement

The paper addresses the challenge of solving the Inverse Kinematics (IK) for the Franka Research Robot, a 7-DOF manipulator widely used in robotics research.

Complexity: Unlike standard 7-DOF arms with spherical wrists and shoulders, the Franka arm features link offsets at the wrist and elbow. This unconventional topology breaks the symmetry exploited by traditional solvers, making analytical solutions difficult.
Redundancy: With 7 degrees of freedom (DOFs) and a 6-DOF task space, the robot has 1 DOF of redundancy, leading to infinitely many solutions (a self-motion manifold).
Limitations of Existing Solvers:
- Current analytical solvers (e.g., HeLiu) typically lock the last joint ( $q_7$ ) to resolve redundancy, limiting the solution space and robustness.
- General algebraic solvers (e.g., IKFast) lack geometric insight, are slower, and struggle with singularities.
- Existing methods often fail in singular configurations (e.g., flat shoulder or shoulder-on-S7) or fail to provide the Jacobian matrix without additional computational cost.
- There is a lack of solvers that allow alternative free parameters (like the swivel angle) to better control robot posture.

2. Methodology: GeoFIK

The authors propose GeoFIK (Geometric Franka IK), a novel analytical solver based on Screw Theory.

Geometric Approach: Instead of relying purely on algebraic formulations, GeoFIK describes the robot's entire geometry using screw axes ( $\mathcal{S}_i$ ).
Algorithm Flow:
1. Screw Axis Determination: The solver first computes the screw axes for all joints. Crucially, the Jacobian matrix is computed prior to determining the joint angles, as a byproduct of the screw axes.
2. Redundancy Resolution: The method supports multiple free parameters to resolve redundancy, not just $q_7$ $q_{7}$ . It provides specific analytical solutions for:
  - Locking joint $q_7$ .
  - Locking joint $q_6$ .
  - Locking joint $q_4$ .
  - Swivel Angle ( $\theta$ ): A geometric parameter defining the "arm plane" orientation, allowing for more natural posture control.
3. Angle Calculation: Joint angles are derived systematically using the exponential and logarithmic maps of the Special Orthogonal group, $SO(3)$, by comparing current screw axes to a home configuration.
4. Singularity Handling: The solver explicitly identifies kinematic singularities (e.g., flat shoulder, shoulder-on-S7) and algorithmic singularities. It employs a tolerance threshold (SING_TOL) to handle near-singular cases numerically and can switch free variables (e.g., from $q_6$ to $q_7$ ) automatically when a singularity is detected.

3. Key Contributions

First Screw-Theory Based IK for Franka: This is the first analytical IK solution for the Franka arm utilizing screw theory, offering a geometric perspective that traditional algebraic methods lack.
Multi-Parameter Redundancy Resolution: Unlike existing solvers that are restricted to locking $q_7$ , GeoFIK allows users to lock $q_4$ , $q_6$ , or use the swivel angle as the free variable. This enables finding valid configurations that other solvers miss.
Free Jacobian Computation: The Jacobian matrix is returned as a natural byproduct of the geometric calculation, incurring no extra computational cost compared to calculating joint angles alone.
Robust Singularity Handling: The solver handles extreme singular poses where other methods fail, ensuring a solution is found if one exists.
Complete Solution Set: The method systematically explores the geometry to find up to 8 distinct geometrically valid solutions (covering elbow-up/down and shoulder configurations), whereas competitors often return fewer or invalid solutions.

4. Experimental Results

The authors validated GeoFIK against three state-of-the-art solvers: HeLiu (specialized for Franka), IKFast (general algebraic), and IKGeo (6-DOF solver adapted for Franka).

Quantitative Benchmarks (2000 random poses):
- Speed: GeoFIK was the fastest for computing joint angles when locking $q_6$ or $q_4$ . When computing the Jacobian, GeoFIK was significantly faster than all competitors (often 10x-100x faster) because the Jacobian is intrinsic to the method.
- Reliability: GeoFIK found valid solutions in 100% of test cases where a solution existed. In contrast, HeLiu and IKGeo produced incorrect solutions (violating joint limits or having >1cm end-effector error) in singular configurations.
- Accuracy: GeoFIK demonstrated superior end-effector position and rotation accuracy compared to IKFast and IKGeo.
Singularity Performance:
- In "Flat Shoulder" and "Shoulder-on-S7" singularities, HeLiu and IKFast often failed or returned repeated/invalid solutions. GeoFIK successfully detected the singularity, switched strategies, and returned valid solutions.
Real-World Experiments:
- Trajectory Tracking: In a real-world test on a Franka robot, HeLiu and $q_7$ -locked GeoFIK failed after ~10 seconds, causing the robot to halt. The swivel-angle-based GeoFIK maintained continuous, smooth tracking without failure.
- Whole-Body Control: In tasks requiring manipulability ellipsoid tracking (sweeping/pushing), GeoFIK provided consistent joint trajectories and Jacobians, whereas IKFast frequently produced invalid configurations causing the robot to flip or stop.

5. Significance

Enabling Advanced Control: By providing fast, reliable Jacobians and supporting alternative redundancy parameters (like the swivel angle), GeoFIK enables advanced control strategies such as lazy-planning, dynamic trajectory optimization, and whole-body manipulation that were previously difficult or impossible with the Franka arm.
Safety and Robustness: The ability to handle singularities gracefully and find valid solutions in the middle of the workspace prevents robot halts and abrupt movements, which is critical for safety in human-robot interaction.
Open Source: The C++ implementation is publicly available, filling a critical gap in the robotics community for a high-performance, geometrically intuitive solver for the most popular research manipulator.

In conclusion, GeoFIK represents a significant leap forward in analytical IK for redundant manipulators with complex topologies, offering a solution that is faster, more robust, and more flexible than existing state-of-the-art methods.