Program Filtering

Once the robot has been calibrated, we have different ways to use the robot calibration:

oFilter existing programs: all the robot targets inside a program are modified to improve the accuracy of the robot. It can be done manually or using the API.

oUse RoboDK for Offline Programming to generate accurate programs (generated programs are already filtered, including programs generated using the API).

To filter an existing program manually: drag & drop the robot program file into RoboDK’s main screen (or select FileOpen) and select Filter only. The program will be filtered and saved in the same folder. The filter summary will mention if there were any problems using the filtering algorithm. We also have the option to import a program if we want to simulate it inside RoboDK. If the program has any dependencies (tool frame or base frame definitions, subprograms, ...) they must be located in the same directory where the first program is imported.

Robot Calibration LaserTracker - Image 34

Robot Calibration LaserTracker - Image 35

Once we import the program inside RoboDK we can regenerate it with or without absolute accuracy. In the main accuracy settings of RoboDK (ToolsOptionsAccuracy) we can decide if we want to always generate the programs using accurate kinematics, if we want to ask every time or if we want to use the current robot kinematics. The current robot kinematics can be changed by right clicking the robot and activating/deactivating the “Use accurate kinematics” tag. If it is active we will see a green dot, if it is not active, we will see a red dot.

Robot Calibration LaserTracker - Image 36

Robot Calibration LaserTracker - Image 37

Filter Programs using the API

It is possible to filter a complete program using RoboDK given a calibrated robot and the robot program using the FilterProgram call:


A macro example called FilterProgram is available in the Macros section of the library. The following code is an example Python script that uses the RoboDK API to filter a program.

from robolink import*# API to communicate with RoboDK

from robodk import*# basic matrix operations

import os                 # Path operations

# Get the current working directory

CWD = os.path.dirname(os.path.realpath(__file__))

# Start RoboDK if it is not running and link to the API

RDK = Robolink()

# optional: provide the following arguments to run behind the scenes

#RDK = Robolink(args='/NOSPLASH /NOSHOW /HIDDEN')

# Get the calibrated station (.rdk file) or robot file (.robot):

# Tip: after calibration, right click a robot and select "Save as .robot"

calibration_file = CWD +'/KUKA-KR6.rdk'

# Get the program file:

file_program = CWD +'/Prog1.src'

# Load the RDK file or the robot file:

calib_item = RDK.AddFile(calibration_file)

ifnot calib_item.Valid():

raise Exception("Something went wrong loading "+ calibration_file)

# Retrieve the robot (no popup if there is only one robot):

robot = RDK.ItemUserPick('Select a robot to filter', ITEM_TYPE_ROBOT)

ifnot robot.Valid():

raise Exception("Robot not selected or not available")

# Activate accuracy


# Filter program: this will automatically save a program copy

# with a renamed file depending on the robot brand

status, summary = robot.FilterProgram(file_program)

if status ==0:

print("Program filtering succeeded")





print("Program filtering failed! Error code: %i"% status)



Filter Targets using the API

The following code is an example Python script that uses the RoboDK API to filter a target (pose target or joint target), using the FilterTarget command:

pose_filt, joints = robot.FilterTarget(nominal_pose, estimated_joints)

This example is useful if a 3rd party application (other than RoboDK) generates the robot program using pose targets.

from robolink import*# API to communicate with RoboDK

from robodk import*# basic matrix operations


return KUKA_2_Pose(xyzwpr) # Convert X,Y,Z,A,B,C to a pose


return Pose_2_KUKA(pose) # Convert a pose to X,Y,Z,A,B,C

# Start the RoboDK API and retrieve the robot:

RDK = Robolink()

robot = RDK.Item('', ITEM_TYPE_ROBOT)

ifnot robot.Valid():

raise Exception("Robot not available")

pose_tcp = XYZWPR_2_Pose([0,0,200,0,0,0]) # Define the TCP

pose_ref = XYZWPR_2_Pose([400,0,0,0,0,0]) # Define the Ref Frame

# Update the robot TCP and reference frame



# Very important for SolveFK and SolveIK (Forward/Inverse kinematics)

robot.setAccuracyActive(False)# Accuracy can be ON or OFF

# Define a nominal target in the joint space:

joints =[0,0,90,0,90,0]

# Calculate the nominal robot position for the joint target:

pose_rob = robot.SolveFK(joints) # robot flange wrt the robot base

# Calculate pose_target: the TCP with respect to the reference frame

pose_target = invH(pose_ref)*pose_rob*pose_tcp

print('Target not filtered:')


joints_approx = joints # joints_approx must be within 20 deg

pose_target_filt, real_joints = robot.FilterTarget(pose_target, joints)

print('Target filtered:')