Skip to main content

Chapter 1: Physics Simulation Fundamentals

Learning Objectives​

By the end of this chapter, you will be able to:

  • Understand the principles of rigid body dynamics in simulation
  • Explain collision detection algorithms and their applications
  • Describe sensor simulation techniques
  • Apply physics simulation concepts to robotics applications
  • Evaluate trade-offs between simulation accuracy and performance

Introduction to Physics Simulation​

Physics simulation is the foundation of modern robotics development. It allows engineers to test algorithms, validate designs, and train AI systems in a safe, cost-effective virtual environment before deploying to real hardware.

Why Physics Simulation Matters​

Benefits:

  • Safety: Test dangerous scenarios without risk to hardware or people
  • Cost: Reduce hardware damage and development costs
  • Speed: Iterate faster than real-time testing
  • Reproducibility: Create consistent test environments
  • Scale: Simulate multiple robots and scenarios simultaneously

Applications:

  • Algorithm development and validation
  • Hardware design verification
  • AI training and reinforcement learning
  • System integration testing
  • Edge case exploration

Rigid Body Dynamics​

Rigid body dynamics describe how solid objects move and interact in a simulated environment.

Core Concepts​

Rigid Body: An object that doesn't deform under forces. Key properties include:

  • Mass: Resistance to linear acceleration
  • Inertia Tensor: Resistance to rotational acceleration
  • Center of Mass: Balance point of the object
  • Velocity: Linear and angular motion

Newton's Laws in Simulation​

# Pseudo-code for rigid body dynamics
class RigidBody:
    def __init__(self, mass, inertia, position, velocity):
        self.mass = mass
        self.inertia = inertia  # Inertia tensor (3x3 matrix)
        self.position = position
        self.velocity = velocity
        self.angular_velocity = [0, 0, 0]

    def apply_force(self, force, point):
        """Apply force at a point on the body"""
        # F = ma (Newton's second law)
        acceleration = force / self.mass
        self.velocity += acceleration * dt

        # Calculate torque: τ = r × F
        r = point - self.center_of_mass
        torque = cross_product(r, force)

        # Angular acceleration: α = I⁻¹τ
        angular_acceleration = inverse(self.inertia) @ torque
        self.angular_velocity += angular_acceleration * dt

    def update(self, dt):
        """Update position and rotation"""
        self.position += self.velocity * dt
        self.rotation += self.angular_velocity * dt

Integration Methods​

Simulators use numerical integration to update object states:

  1. Euler Integration (simplest, least accurate):

    v(t+Δt) = v(t) + a(t)·Δt
    x(t+Δt) = x(t) + v(t)·Δt

  2. Runge-Kutta (RK4) (more accurate, slower):

    • Uses multiple intermediate steps
    • Better energy conservation
    • Commonly used in high-fidelity simulators

  3. Semi-implicit Euler (good balance):

    v(t+Δt) = v(t) + a(t)·Δt
    x(t+Δt) = x(t) + v(t+Δt)·Δt

Collision Detection​

Collision detection determines when and where objects intersect in the simulation.

Collision Detection Pipeline​

Broad Phase Collision Detection​

Quickly eliminates pairs of objects that cannot possibly collide:

  • Bounding Volumes: Simple shapes that enclose complex objects

    • AABB (Axis-Aligned Bounding Box): Fastest, less tight fit
    • OBB (Oriented Bounding Box): Better fit, more expensive
    • Bounding Sphere: Fast distance checks, loose fit

  • Spatial Partitioning:

    • Grid: Divide space into cells
    • Octree: Hierarchical 3D grid
    • Sweep and Prune: Sort objects along axes

Narrow Phase Collision Detection​

Precise collision detection for pairs identified in broad phase:

  • Primitive Shapes:

    • Sphere-sphere: Distance check
    • Box-box: Separating axis theorem (SAT)
    • Capsule-capsule: Segment distance

  • Complex Meshes:

    • Triangle-triangle intersection
    • GJK algorithm (Gilbert-Johnson-Keerthi)
    • EPA algorithm (Expanding Polytope Algorithm)

Contact Generation​

Generate contact points with detailed information:

class Contact:
    def __init__(self, point, normal, penetration_depth, bodies):
        self.point = point  # Contact point in world space
        self.normal = normal  # Contact normal (from body1 to body2)
        self.penetration_depth = penetration_depth  # How deep objects overlap
        self.body1 = bodies[0]
        self.body2 = bodies[1]

    def resolve(self, dt):
        """Resolve collision using impulse-based method"""
        # Calculate relative velocity at contact point
        v1 = self.body1.get_velocity_at_point(self.point)
        v2 = self.body2.get_velocity_at_point(self.point)
        relative_velocity = v1 - v2

        # Velocity along normal
        velocity_along_normal = dot(relative_velocity, self.normal)

        # Don't resolve if objects are separating
        if velocity_along_normal > 0:
            return

        # Calculate impulse scalar
        restitution = min(self.body1.restitution, self.body2.restitution)
        impulse_scalar = -(1 + restitution) * velocity_along_normal
        impulse_scalar /= (1/self.body1.mass + 1/self.body2.mass)

        # Apply impulse
        impulse = impulse_scalar * self.normal
        self.body1.apply_impulse(impulse, self.point)
        self.body2.apply_impulse(-impulse, self.point)

Collision Response​

Impulse-Based: Apply instantaneous velocity changes

  • Fast and stable
  • Used in real-time simulators
  • May not conserve energy perfectly

Constraint-Based: Solve for forces that prevent penetration

  • More accurate
  • Can handle complex contact scenarios
  • Computationally expensive

Friction and Damping​

Friction Models​

Coulomb Friction:

F_friction ≤ μ × F_normal

Where:

  • μ is the coefficient of friction
  • F_normal is the normal force

Static vs Kinetic Friction:

  • Static friction (μ_s): Prevents motion from starting
  • Kinetic friction (μ_k): Opposes motion once started
  • Usually μ_s > μ_k

Damping​

Damping removes energy from the system to prevent unrealistic bouncing:

# Linear damping (air resistance)
force_damping = -damping_coefficient * velocity

# Angular damping (rotational resistance)
torque_damping = -angular_damping_coefficient * angular_velocity

Sensor Simulation​

Simulating sensors is crucial for testing perception algorithms.

Camera Simulation​

Ray Tracing: Physically accurate rendering

  • Traces light rays from camera through pixels
  • Accounts for reflections, refractions
  • Computationally expensive

Rasterization: Real-time rendering

  • Projects triangles onto image plane
  • Fast but less physically accurate
  • Used in most real-time simulators

Camera Models:

class PinholeCamera:
    def __init__(self, width, height, fov, position, orientation):
        self.width = width
        self.height = height
        self.fov = fov  # Field of view in degrees
        self.position = position
        self.orientation = orientation

        # Calculate focal length
        self.focal_length = (width / 2) / tan(fov / 2)

    def project_point(self, world_point):
        """Project 3D world point to 2D image coordinates"""
        # Transform to camera coordinates
        camera_point = self.world_to_camera(world_point)

        # Perspective projection
        if camera_point.z <= 0:
            return None  # Point behind camera

        u = self.focal_length * camera_point.x / camera_point.z + self.width / 2
        v = self.focal_length * camera_point.y / camera_point.z + self.height / 2

        return (u, v)

LiDAR Simulation​

Ray Casting: Simulate laser beams

  • Cast rays in defined pattern (e.g., 360° horizontal, 32 vertical channels)
  • Find first intersection with geometry
  • Return distance and intensity

Noise Models:

  • Gaussian noise: Random measurement error
  • Dropout: Missing measurements
  • Reflectivity: Material-dependent returns
class LiDARSensor:
    def __init__(self, range_max, angular_resolution, num_channels):
        self.range_max = range_max
        self.angular_resolution = angular_resolution  # degrees
        self.num_channels = num_channels

    def scan(self, world):
        """Perform LiDAR scan"""
        points = []

        for channel in range(self.num_channels):
            vertical_angle = self.get_vertical_angle(channel)

            for horizontal_angle in range(0, 360, self.angular_resolution):
                # Create ray direction
                direction = self.angle_to_direction(horizontal_angle, vertical_angle)

                # Cast ray
                hit = world.raycast(self.position, direction, self.range_max)

                if hit:
                    distance = hit.distance
                    intensity = self.calculate_intensity(hit.material, hit.angle)

                    # Add noise
                    distance += random.gauss(0, 0.01)  # 1cm standard deviation

                    points.append((direction, distance, intensity))

        return points

IMU Simulation​

Inertial Measurement Units measure acceleration and angular velocity:

class IMUSensor:
    def __init__(self, accel_noise, gyro_noise, accel_bias, gyro_bias):
        self.accel_noise_std = accel_noise
        self.gyro_noise_std = gyro_noise
        self.accel_bias = accel_bias
        self.gyro_bias = gyro_bias

    def measure(self, body):
        """Measure linear acceleration and angular velocity"""
        # Get true values from rigid body
        true_accel = body.get_linear_acceleration()
        true_gyro = body.get_angular_velocity()

        # Add bias and noise
        measured_accel = true_accel + self.accel_bias + random.gauss(0, self.accel_noise_std)
        measured_gyro = true_gyro + self.gyro_bias + random.gauss(0, self.gyro_noise_std)

        return {
            'linear_acceleration': measured_accel,
            'angular_velocity': measured_gyro
        }

Depth Camera Simulation​

Depth cameras (e.g., RealSense, Kinect) provide RGB and depth:

  • Structured Light: Project pattern, measure distortion
  • Time of Flight: Measure light travel time
  • Stereo Vision: Triangulate from two cameras

Simulation Approaches:

  1. Render depth buffer from graphics pipeline
  2. Add characteristic noise patterns
  3. Simulate missing data (e.g., reflective surfaces, sunlight interference)

Simulation Performance Optimization​

Level of Detail (LOD)​

Use simpler collision geometry than visual geometry:

  • Visual: High-poly mesh for rendering
  • Collision: Convex decomposition or primitive shapes

Timestep Selection​

Fixed Timestep: Consistent, deterministic

dt = 1.0 / 240.0  # 240 Hz physics update
while simulation_running:
    physics_update(dt)
    render()

Variable Timestep: Adaptive to computation load

  • Risk of instability
  • Harder to reproduce results

Parallelization​

  • Broad phase: Parallelize across object pairs
  • Islands: Simulate disconnected groups separately
  • Solver: Parallel constraint solving (advanced)

Common Pitfalls​

  1. Tunneling: Fast objects pass through thin obstacles

    • Solution: Continuous collision detection (CCD)

  2. Jitter: Objects vibrate unrealistically

    • Solution: Increase solver iterations, add damping

  3. Energy Drift: System gains/loses energy over time

    • Solution: Use symplectic integrators, add damping

  4. Scale Issues: Numerical precision problems with very large/small objects

    • Solution: Keep object sizes reasonable (0.01m to 100m)

Assessment Questions​

  1. What are the three main phases of collision detection?
  2. Explain the difference between static and kinetic friction.
  3. How does an IMU sensor differ from a LiDAR sensor?
  4. What is the purpose of using a fixed timestep in physics simulation?
  5. Describe one method to prevent fast-moving objects from tunneling through obstacles.

Knowledge Check​

  1. Multiple Choice: Which integration method provides the best balance between accuracy and performance?

    • A) Euler Integration
    • B) Semi-implicit Euler
    • C) Runge-Kutta 4
    • D) Verlet Integration

    Answer: B) Semi-implicit Euler - provides good stability and energy conservation with reasonable computational cost

  2. True/False: In collision detection, the broad phase generates precise contact points.

    • A) True
    • B) False

    Answer: B) False - The broad phase only identifies potential collisions; the narrow phase generates precise contact points

  3. Multiple Choice: What type of sensor uses ray casting to measure distance?

    • A) Camera
    • B) IMU
    • C) LiDAR
    • D) GPS

    Answer: C) LiDAR

  4. Short Answer: Why is it important to add noise to simulated sensor data?

    Answer: Adding noise makes simulated sensor data more realistic and helps algorithms generalize to real-world conditions where sensors always have measurement uncertainty

  5. Scenario: Your humanoid robot in simulation is vibrating when standing still. What are two possible causes and solutions?

    Answer: (1) Solver iterations too low - increase iterations in physics engine settings; (2) Contact forces fighting gravity - add damping or adjust contact parameters like stiffness and damping coefficients

References​

Next Steps​

In the next chapter, we'll apply these physics simulation concepts using Gazebo, setting up simulation environments for humanoid robots.