TraffiSim 0.1.0__py3-none-any.whl

traffisim/models.py

@@ -0,0 +1,296 @@
+"""
+models.py
+---------
+Vehicle model and default vehicle parameters.
+Implements IDM & MOBIL logic.
+"""
+
+import random
+import math
+from .utils import dist, define_exit_point
+
+# Default vehicle parameters
+DEFAULT_VEHICLE_TYPES = {
+    'car': {
+        'desired_speed': 20,
+        'max_acceleration': 2.5,
+        'comfortable_deceleration': 2.5,
+        'minimum_gap': 2.5,
+        'lane_change_aggressiveness': 0.7,
+        'length': 4.5
+    },
+    'truck': {
+        'desired_speed': 15,
+        'max_acceleration': 1.5,
+        'comfortable_deceleration': 1.5,
+        'minimum_gap': 3.5,
+        'lane_change_aggressiveness': 0.5,
+        'length': 10.0
+    },
+    'bus': {
+        'desired_speed': 15,
+        'max_acceleration': 1.5,
+        'comfortable_deceleration': 1.5,
+        'minimum_gap': 4.0,
+        'lane_change_aggressiveness': 0.5,
+        'length': 12.0
+    },
+    'scooter': {
+        'desired_speed': 18,
+        'max_acceleration': 3.0,
+        'comfortable_deceleration': 3.0,
+        'minimum_gap': 1.2,
+        'lane_change_aggressiveness': 0.8,
+        'length': 2.0
+    },
+    'motorcycle': {
+        'desired_speed': 22,
+        'max_acceleration': 3.5,
+        'comfortable_deceleration': 3.5,
+        'minimum_gap': 1.0,
+        'lane_change_aggressiveness': 0.9,
+        'length': 2.2
+    }
+}
+
+# Colors for different vehicle types (for rendering usage)
+VEHICLE_COLORS = {
+    'car':        (200, 200, 0),
+    'truck':      (180, 100, 50),
+    'bus':        (120, 40, 150),
+    'scooter':    (40, 220, 220),
+    'motorcycle': (255, 100, 100),
+}
+
+class Vehicle:
+    """
+    Represents a single vehicle, using IDM for longitudinal and MOBIL for lane changing.
+    Also includes India Mode logic for side-by-side queue placement (if enabled).
+    """
+    def __init__(self, arrival_time, direction, vehicle_type=None,
+                 simulate_full_route=True,
+                 SCREEN_WIDTH=1000, SCREEN_HEIGHT=800):
+        self.arrival_time = arrival_time
+        self.direction = direction  # 'N', 'S', 'E', 'W'
+        
+        # Random turn choice
+        self.turn_direction = random.choices(
+            ['left', 'straight', 'right'],
+            weights=[0.34, 0.33, 0.33]
+        )[0]
+
+        # Vehicle type logic
+        if vehicle_type is None:
+            vehicle_type = random.choice(list(DEFAULT_VEHICLE_TYPES.keys()))
+        self.vehicle_type = vehicle_type
+        params = DEFAULT_VEHICLE_TYPES[self.vehicle_type]
+
+        # Basic physical parameters
+        self.length = params['length']
+        self.lane_change_aggressiveness = params['lane_change_aggressiveness']
+
+        self.state = 'queueing'  # 'queueing', 'crossing', 'finished'
+        self.start_cross_time = None
+        self.finish_time = None
+
+        # Position & movement
+        self.x = 0.0
+        self.y = 0.0
+        self.current_speed = 0.0
+        self.distance_covered = 0.0
+
+        # Route details
+        self.start_position = None
+        self.center_position = None
+        self.exit_position = None
+        self.route_distance = 0.0
+        self.simulate_full_route = simulate_full_route
+        self.SCREEN_WIDTH = SCREEN_WIDTH
+        self.SCREEN_HEIGHT = SCREEN_HEIGHT
+
+        # Reaction time
+        self.reaction_time = random.uniform(0.8, 1.5)
+
+        # IDM parameters
+        self.idm_a0 = 2.0   
+        self.idm_b  = 2.5   
+        self.idm_v0 = params['desired_speed'] 
+        self.idm_T  = 1.5   
+        self.idm_s0 = 2.0   
+        self.idm_delta = 4.0
+
+        # Politeness factor for MOBIL
+        self.politeness = 0.2
+        self.delta_a_threshold = 0.2
+
+        # Additional indexing for queue positioning
+        self.lane_index = None
+        self.row_index = None
+        self.col_index = None
+
+        # Assign a driver profile to add variety
+        self.assign_driver_profile()
+
+    @property
+    def wait_time(self):
+        if self.start_cross_time is None:
+            return None
+        return self.start_cross_time - self.arrival_time
+
+    def assign_driver_profile(self):
+        """
+        Randomly assigns an 'aggressive', 'normal', or 'cautious' profile
+        to create variability in driving style.
+        """
+        profile_type = random.choices(
+            ["aggressive", "normal", "cautious"],
+            weights=[0.3, 0.5, 0.2]
+        )[0]
+
+        if profile_type == "aggressive":
+            self.idm_a0 = random.uniform(2.5, 3.0)
+            self.idm_b  = 2.0
+            self.idm_T  = 1.0
+            self.idm_v0 *= 1.3  # bump up desired speed ~30% for effect
+            self.politeness = 0.1
+            self.reaction_time = random.uniform(0.6, 1.0)
+        elif profile_type == "cautious":
+            self.idm_a0 = random.uniform(1.0, 1.5)
+            self.idm_b  = 2.5
+            self.idm_T  = 1.8
+            self.idm_v0 *= 0.9  # reduce desired speed
+            self.politeness = 0.3
+            self.reaction_time = random.uniform(1.5, 2.0)
+        else:
+            # 'normal' -> keep defaults
+            pass
+
+    def init_route(self, cx, cy):
+        """
+        Called once vehicle starts crossing. We define start/center/exit, compute route distance.
+        """
+        self.start_position = (self.x, self.y)
+        self.center_position = (cx, cy)
+        if self.simulate_full_route:
+            # Real exit point
+            self.exit_position = define_exit_point(
+                cx, cy, self.direction, self.turn_direction,
+                self.SCREEN_WIDTH, self.SCREEN_HEIGHT
+            )
+            d1 = dist(self.start_position, self.center_position)
+            d2 = dist(self.center_position, self.exit_position)
+            self.route_distance = d1 + d2
+        else:
+            # Vanish at center
+            self.exit_position = self.center_position
+            self.route_distance = dist(self.start_position, self.center_position)
+
+        self.distance_covered = 0.0
+
+    def compute_idm_acceleration(self, lead_vehicle):
+        """
+        Calculate acceleration using IDM, given the lead vehicle in the same lane (if any).
+        """
+        if lead_vehicle is None:
+            s = 1e9
+            delta_v = 0.0
+        else:
+            # gap = distance between centers - half lengths
+            s = dist((self.x, self.y), (lead_vehicle.x, lead_vehicle.y)) \
+                - 0.5*self.length - 0.5*lead_vehicle.length
+            delta_v = self.current_speed - lead_vehicle.current_speed
+            if s < 0.1:
+                s = 0.1
+
+        s_star = self.idm_s0 + max(
+            0, self.current_speed * self.idm_T +
+            (self.current_speed*delta_v)/(2*math.sqrt(self.idm_a0*self.idm_b))
+        )
+
+        alpha_free = 1 - pow((self.current_speed / self.idm_v0), self.idm_delta)
+        alpha_int  = - pow((s_star / s), 2)
+        a = self.idm_a0 * (alpha_free + alpha_int)
+        return a
+
+    def check_mobil_lane_change(self, sim, current_lane, target_lane,
+                                lead_current, lead_target,
+                                rear_current, rear_target):
+        """
+        Decide if lane change is beneficial by MOBIL:
+          (a_new_self - a_old_self) + p * (a_new_rear - a_old_rear) > delta_a_threshold
+        """
+        a_old_self = self.compute_idm_acceleration(lead_current)
+        a_new_self = self.compute_idm_acceleration(lead_target)
+
+        a_old_rear, a_new_rear = 0.0, 0.0
+        if rear_current:
+            lead_for_rear_current = sim.get_lead_vehicle_in_lane(current_lane, rear_current)
+            a_old_rear = rear_current.compute_idm_acceleration(lead_for_rear_current)
+        if rear_target:
+            lead_for_rear_target = sim.get_lead_vehicle_in_lane(target_lane, rear_target)
+            a_new_rear = rear_target.compute_idm_acceleration(lead_for_rear_target)
+
+        lhs = (a_new_self - a_old_self) + self.politeness * (a_new_rear - a_old_rear)
+        if lhs > self.delta_a_threshold:
+            # check safety
+            if self.is_safe_to_change_lane(lead_target, rear_target):
+                return True
+        return False
+
+    def is_safe_to_change_lane(self, lead_vehicle, rear_vehicle):
+        """
+        Very simple check: ensure gap front and gap rear are > 3.0m (adjust as desired).
+        """
+        safe_gap = 3.0
+        if lead_vehicle:
+            gap_front = dist((self.x, self.y), (lead_vehicle.x, lead_vehicle.y)) \
+                        - 0.5*self.length - 0.5*lead_vehicle.length
+            if gap_front < safe_gap:
+                return False
+        if rear_vehicle:
+            gap_rear = dist((self.x, self.y), (rear_vehicle.x, rear_vehicle.y)) \
+                       - 0.5*self.length - 0.5*rear_vehicle.length
+            if gap_rear < safe_gap:
+                return False
+        return True
+
+    def update_position(self, dt=1.0, lead_vehicle=None):
+        """
+        Update speed via IDM acceleration and move the vehicle along its route.
+        Returns True if vehicle has completed its route.
+        """
+        a = self.compute_idm_acceleration(lead_vehicle)
+        self.current_speed += a * dt
+        if self.current_speed < 0.0:
+            self.current_speed = 0.0
+
+        dist_step = self.current_speed * dt
+        self.distance_covered += dist_step
+
+        if self.route_distance < 0.1:
+            return True  # edge case if start == center
+
+        frac = self.distance_covered / self.route_distance
+        if frac >= 1.0:
+            frac = 1.0
+
+        d1 = dist(self.start_position, self.center_position)
+        route_total = self.route_distance
+        if frac < d1 / route_total:
+            # in the segment start->center
+            sub_frac = frac / (d1 / route_total)
+            sx, sy = self.start_position
+            cx, cy = self.center_position
+            self.x = sx + (cx - sx)*sub_frac
+            self.y = sy + (cy - sy)*sub_frac
+        else:
+            # in the center->exit segment
+            ratio_remaining = frac - (d1/route_total)
+            segment_len = 1.0 - (d1/route_total)
+            sub_frac = ratio_remaining / segment_len if segment_len > 1e-6 else 1.0
+            cx, cy = self.center_position
+            ex, ey = self.exit_position
+            self.x = cx + (ex - cx)*sub_frac
+            self.y = cy + (ey - cy)*sub_frac
+
+        return (frac >= 1.0)

traffisim/rendering.py

@@ -0,0 +1,225 @@
+"""
+rendering.py
+------------
+Optional Pygame renderer for TraffiSim.
+"""
+
+import pygame
+from .models import VEHICLE_COLORS
+from .intersection import SCREEN_WIDTH, SCREEN_HEIGHT, LANE_WIDTH, ROAD_WIDTH, ROAD_MARGIN
+from .intersection import QUEUE_OFFSET, CAR_SPACING
+
+class TrafficRenderer:
+    """
+    Class responsible for rendering the traffic simulation using Pygame.
+    """
+    COLOR_BG = (30, 30, 30)
+    COLOR_ROAD = (70, 70, 70)
+    COLOR_TEXT = (255, 255, 255)
+    LINE_COLOR = (140, 140, 140)
+
+    TRAFFIC_LIGHT_COLORS = {
+        "red":    (255,  40,  40),
+        "yellow": (255, 255,   0),
+        "green":  ( 40, 255,  40),
+    }
+
+    def __init__(self, sim):
+        """
+        Initialize the TrafficRenderer with a simulation instance.
+        
+        Args:
+            sim (IntersectionSim): The simulation instance to render.
+        """
+        self.sim = sim
+        pygame.init()
+        pygame.display.set_caption(f"TraffiSim (type={sim.junction_type}, MLights={sim.multiple_lights})")
+        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+        self.clock = pygame.time.Clock()
+        self.font = pygame.font.SysFont(None, 22)
+
+        self.cx = SCREEN_WIDTH // 2
+        self.cy = SCREEN_HEIGHT // 2
+
+    def render(self):
+        """
+        Render the current state of the simulation.
+        """
+        self.screen.fill(self.COLOR_BG)
+        self.draw_roads()
+        self.draw_lane_barriers()
+        self.draw_traffic_lights()
+        self.draw_vehicles()
+        self.draw_ui_panel()
+        pygame.display.flip()
+
+    def draw_roads(self):
+        """
+        Draw the intersection roads as rectangles.
+        """
+        if self.sim.junction_type == '4way':
+            rect_h = pygame.Rect(0, self.cy - ROAD_WIDTH//2, SCREEN_WIDTH, ROAD_WIDTH)
+            pygame.draw.rect(self.screen, self.COLOR_ROAD, rect_h)
+            rect_v = pygame.Rect(self.cx - ROAD_WIDTH//2, 0, ROAD_WIDTH, SCREEN_HEIGHT)
+            pygame.draw.rect(self.screen, self.COLOR_ROAD, rect_v)
+        else:
+            rect_h = pygame.Rect(0, self.cy - ROAD_WIDTH//2, SCREEN_WIDTH, ROAD_WIDTH)
+            pygame.draw.rect(self.screen, self.COLOR_ROAD, rect_h)
+            rect_v = pygame.Rect(self.cx - ROAD_WIDTH//2, 0, ROAD_WIDTH, self.cy + ROAD_WIDTH//2)
+            pygame.draw.rect(self.screen, self.COLOR_ROAD, rect_v)
+
+    def draw_lane_barriers(self):
+        """
+        Draw dashed lane lines.
+        """
+        dash_len = 10
+        gap_len = 6
+
+        top_road = self.cy - (ROAD_WIDTH//2)
+        bottom_road = self.cy + (ROAD_WIDTH//2)
+        left_road = self.cx - (ROAD_WIDTH//2)
+        right_road = self.cx + (ROAD_WIDTH//2)
+
+        lane_count_est = int(ROAD_WIDTH / LANE_WIDTH)
+        for i in range(1, lane_count_est):
+            x_line = left_road + i*LANE_WIDTH
+            y = 0
+            while y < SCREEN_HEIGHT:
+                pygame.draw.line(self.screen, self.LINE_COLOR,
+                                 (x_line, y), (x_line, min(y+dash_len, SCREEN_HEIGHT)), 2)
+                y += dash_len + gap_len
+
+        lane_count_est_v = int(ROAD_WIDTH / LANE_WIDTH)
+        for i in range(1, lane_count_est_v):
+            y_line = top_road + i*LANE_WIDTH
+            x = 0
+            while x < SCREEN_WIDTH:
+                pygame.draw.line(self.screen, self.LINE_COLOR,
+                                 (x, y_line), (min(x+dash_len, SCREEN_WIDTH), y_line), 2)
+                x += dash_len + gap_len
+
+    def draw_traffic_lights(self):
+        """
+        Draw traffic lights at the intersection.
+        """
+        offsets = {
+            'N': (0, -60),
+            'S': (0, 60),
+            'E': (60, 0),
+            'W': (-60, 0)
+        }
+        r = 9
+        for d in self.sim.directions:
+            if self.sim.adaptive_signals:
+                if self.sim.current_green == d and self.sim.signal_state == "green":
+                    st = "green"
+                elif self.sim.current_green == d and self.sim.signal_state == "yellow":
+                    st = "yellow"
+                else:
+                    st = "red"
+            else:
+                st = self.sim.get_signal_state(d, self.sim.sim_time)
+
+            color = self.TRAFFIC_LIGHT_COLORS[st]
+            ox, oy = offsets.get(d, (0,0))
+            cx = self.cx + ox
+            cy = self.cy + oy
+
+            pygame.draw.circle(self.screen, (0,0,0), (cx, cy), r+2)
+            pygame.draw.circle(self.screen, color, (cx, cy), r)
+
+    def draw_vehicles(self):
+        """
+        Draw all vehicles in the simulation.
+        """
+        for d in self.sim.directions:
+            if self.sim.multiple_lanes:
+                for lane in self.sim.queues[d]:
+                    for v in lane:
+                        self.draw_single_vehicle(v)
+            else:
+                for v in self.sim.queues[d]:
+                    self.draw_single_vehicle(v)
+        for v in self.sim.crossing_vehicles:
+            self.draw_single_vehicle(v)
+
+    def draw_single_vehicle(self, v):
+        """
+        Draw a single vehicle.
+        
+        Args:
+            v (Vehicle): The vehicle to draw.
+        """
+        color = VEHICLE_COLORS.get(v.vehicle_type, (200,200,200))
+        shadow_color = (color[0]//4, color[1]//4, color[2]//4)
+
+        if v.vehicle_type in ['car', 'truck', 'bus']:
+            self.draw_rect_vehicle(v, color, shadow_color)
+        else:
+            self.draw_circle_vehicle(v, color, shadow_color)
+
+    def draw_rect_vehicle(self, v, color, shadow):
+        """
+        Draw a rectangular vehicle (car, truck, bus).
+        
+        Args:
+            v (Vehicle): The vehicle to draw.
+            color (tuple): The color of the vehicle.
+            shadow (tuple): The shadow color of the vehicle.
+        """
+        if v.vehicle_type == 'car':
+            w, h = 12, 20
+        elif v.vehicle_type == 'truck':
+            w, h = 14, 35
+        else:
+            w, h = 14, 40  # bus
+
+        rect = pygame.Rect(0, 0, w, h)
+        rect.center = (int(v.x), int(v.y))
+        shadow_rect = rect.copy()
+        shadow_rect.x += 2
+        shadow_rect.y += 2
+
+        pygame.draw.rect(self.screen, shadow, shadow_rect, border_radius=3)
+        pygame.draw.rect(self.screen, color, rect, border_radius=3)
+
+    def draw_circle_vehicle(self, v, color, shadow):
+        """
+        Draw a circular vehicle (scooter, motorcycle).
+        
+        Args:
+            v (Vehicle): The vehicle to draw.
+            color (tuple): The color of the vehicle.
+            shadow (tuple): The shadow color of the vehicle.
+        """
+        r = 5 if v.vehicle_type=='scooter' else 6
+        center = (int(v.x), int(v.y))
+        shadow_c = (center[0]+2, center[1]+2)
+
+        pygame.draw.circle(self.screen, shadow, shadow_c, r)
+        pygame.draw.circle(self.screen, color, center, r)
+
+    def draw_ui_panel(self):
+        """
+        Draw the UI panel with simulation information.
+        """
+        if self.sim.adaptive_signals:
+            sig_text = f"Signal: {self.sim.signal_state.upper()} for {self.sim.current_green} (timer: {self.sim.state_timer})"
+        else:
+            sig_text = ""
+        lines = [
+            f"Time= {self.sim.sim_time}/{self.sim.total_time}",
+            f"Speed= {self.sim.simulation_speed} steps/sec",
+            f"JunctionType= {self.sim.junction_type}, MultiLights= {self.sim.multiple_lights}",
+            f"MultiLanes= {self.sim.multiple_lanes}, LaneCount= {self.sim.lane_count}",
+            f"IndiaMode= {self.sim.india_mode}",
+            f"SimulateFullRoute= {self.sim.simulate_full_route}",
+            sig_text,
+            "Close window or press Ctrl+C to quit."
+        ]
+        x = 10
+        y = 10
+        for txt in lines:
+            surf = self.font.render(txt, True, (255,255,255))
+            self.screen.blit(surf, (x, y))
+            y += 20

traffisim/run.py

@@ -0,0 +1,173 @@
+"""
+run.py
+------
+Functions to run multiple simulations, collect data, and optionally 
+provide a CLI entry point.
+"""
+
+import os
+import csv
+
+from .intersection import IntersectionSim, ARRIVAL_RATES
+from .models import DEFAULT_VEHICLE_TYPES
+from .rendering import TrafficRenderer
+
+def run_multiple_simulations(
+    N_runs=1,
+    csv_filename="simulation_results.csv",
+    junction_type="4way",
+    multiple_lights=False,
+    total_time=300,
+    simulation_speed=30,
+    save_to_files=True,
+    output_folder="simulation_outputs",
+    multiple_lanes=False,
+    lane_count=2,
+    yellow_duration=5,
+    all_red_duration=2,
+    vehicle_distribution=None,
+    india_mode=False,
+    show_visuals=True,
+    simulate_full_route=True,
+    adaptive_signals=True
+):
+    directions = ['N','E','S','W'] if junction_type=='4way' else ['N','E','W']
+
+    summary_fieldnames = [
+        "SimulationRun",
+        "JunctionType",
+        "MultipleLights",
+        "MultipleLanes",
+        "LaneCount",
+        "TotalVehiclesProcessed",
+        "OverallAvgWait",
+        "SimulateFullRoute",
+    ]
+    for d in directions:
+        summary_fieldnames.append(f"RedEmpty{d}")
+    for vt in DEFAULT_VEHICLE_TYPES.keys():
+        summary_fieldnames.append(f"Count{vt.capitalize()}")
+
+    if save_to_files:
+        os.makedirs(output_folder, exist_ok=True)
+    summary_csv_path = os.path.join(output_folder, csv_filename) if save_to_files else None
+    file_exists = (save_to_files and os.path.isfile(summary_csv_path))
+
+    all_results = []
+    for run_idx in range(1, N_runs+1):
+        print(f"\n=== Starting Simulation Run {run_idx}/{N_runs} ===\n")
+        renderer_class = TrafficRenderer if show_visuals else None
+
+        sim = IntersectionSim(
+            junction_type=junction_type,
+            multiple_lights=multiple_lights,
+            total_time=total_time,
+            simulation_speed=simulation_speed,
+            multiple_lanes=multiple_lanes,
+            lane_count=lane_count,
+            yellow_duration=yellow_duration,
+            all_red_duration=all_red_duration,
+            vehicle_distribution=vehicle_distribution,
+            india_mode=india_mode,
+            show_visuals=show_visuals,
+            renderer_class=renderer_class,
+            simulate_full_route=simulate_full_route,
+            adaptive_signals=adaptive_signals
+        )
+        sim.run()
+        sim.print_statistics()
+
+        if save_to_files:
+            run_csv = os.path.join(output_folder, f"run_{run_idx}.csv")
+            if sim.per_timestep_data:
+                fields = list(sim.per_timestep_data[0].keys())
+            else:
+                fields = ["TimeStep"]
+
+            with open(run_csv, 'w', newline='') as f:
+                writer = csv.DictWriter(f, fieldnames=fields)
+                writer.writeheader()
+                for row in sim.per_timestep_data:
+                    writer.writerow(row)
+
+            summary_row = sim.get_results_dict()
+            summary_row["SimulationRun"] = run_idx
+            with open(summary_csv_path, 'a', newline='') as f:
+                writer = csv.DictWriter(f, fieldnames=summary_fieldnames)
+                if (not file_exists) and run_idx == 1:
+                    writer.writeheader()
+                writer.writerow(summary_row)
+                file_exists = True
+
+        all_results.append(sim.get_results_dict())
+
+    if save_to_files and len(all_results) > 0:
+        avg_row = compute_average_row(all_results, directions)
+        avg_row["SimulationRun"] = "Average"
+        with open(summary_csv_path, 'a', newline='') as f:
+            writer = csv.DictWriter(f, fieldnames=summary_fieldnames)
+            writer.writerow(avg_row)
+        print("Average row appended to summary CSV.")
+
+def compute_average_row(all_results, directions):
+    n = len(all_results)
+    if n == 0:
+        return {}
+    sum_tvp = 0
+    sum_wait = 0
+    sum_red = {d: 0 for d in directions}
+    sum_counts = {vt: 0 for vt in DEFAULT_VEHICLE_TYPES.keys()}
+
+    # We'll copy some fields from the last result (assuming they are all same config).
+    jt = all_results[-1]["JunctionType"]
+    ml = all_results[-1]["MultipleLights"]
+    mls = all_results[-1]["MultipleLanes"]
+    lc = all_results[-1]["LaneCount"]
+    sfr = all_results[-1]["SimulateFullRoute"]
+
+    for r in all_results:
+        sum_tvp += r["TotalVehiclesProcessed"]
+        sum_wait += r["OverallAvgWait"]
+        for d in directions:
+            sum_red[d] += r[f"RedEmpty{d}"]
+        for vt in DEFAULT_VEHICLE_TYPES.keys():
+            key = "Count" + vt.capitalize()
+            sum_counts[vt] += r[key]
+
+    avg_row = {
+        "JunctionType": jt,
+        "MultipleLights": ml,
+        "MultipleLanes": mls,
+        "LaneCount": lc,
+        "SimulateFullRoute": sfr,
+        "TotalVehiclesProcessed": sum_tvp / n,
+        "OverallAvgWait": sum_wait / n
+    }
+    for d in directions:
+        avg_row[f"RedEmpty{d}"] = sum_red[d] / n
+    for vt in DEFAULT_VEHICLE_TYPES.keys():
+        key = "Count" + vt.capitalize()
+        avg_row[key] = sum_counts[vt] / n
+    return avg_row
+
+def main_cli():
+    """
+    Very minimal CLI for demonstration.
+    You can expand with argparse to parse arguments from the command line.
+    """
+    print("Running a default simulation from CLI for demonstration...")
+    run_multiple_simulations(
+        N_runs=1,
+        csv_filename="cli_results.csv",
+        junction_type="4way",
+        multiple_lights=False,
+        total_time=300,
+        simulation_speed=10,
+        save_to_files=False,
+        multiple_lanes=True,
+        lane_count=3,
+        india_mode=False,
+        show_visuals=False,
+        simulate_full_route=True,
+        adaptive_signals=True
+    )