sonar-vision 0.1.0__tar.gz

sonar_vision-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SuperInstance Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sonar_vision-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: sonar-vision
+Version: 0.1.0
+Summary: Pure-Python sonar ping/echo simulation, signal processing, multi-object tracking, and spatial mapping toolkit
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file

sonar_vision-0.1.0/README.md

@@ -0,0 +1,172 @@
+# sonar-vision
+
+Pure-Python toolkit for simulating active sonar pings and echoes, processing signals, tracking objects, and building 2-D occupancy maps.
+
+> **Documentation:** [`PLUG_AND_PLAY.md`](./PLUG_AND_PLAY.md) · [`GETTING_STARTED.md`](./GETTING_STARTED.md) · [`ARCHITECTURE.md`](./ARCHITECTURE.md) · [`API_REFERENCE.md`](./API_REFERENCE.md) · [`LOW_LEVEL.md`](./LOW_LEVEL.md)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](./LICENSE)
+[![Python](https://img.shields.io/badge/Python-%3E%3D3.10-blue?style=flat-square)](https://www.python.org/)
+
+## Quickstart
+
+Install from source into a virtual environment:
+
+```bash
+git clone https://github.com/purplepincher/sonar-vision.git
+cd sonar-vision
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+Run the tests:
+
+```bash
+pytest tests/
+```
+
+## Usage
+
+### Simulate a sonar ping
+
+```python
+from sonar_vision import Sonar
+
+sonar = Sonar(frequency=50000, max_range=500)
+result = sonar.ping(distance=100)
+print(f"Distance: {result.distance:.1f}m, SNR: {result.snr_db:.1f} dB")
+```
+
+Output:
+
+```text
+Distance: 99.1m, SNR: 38.0 dB
+```
+
+### Track objects across detections
+
+```python
+from sonar_vision import ObjectTracker, Detection
+
+tracker = ObjectTracker()
+tracker.update([Detection(x=10, y=20)])
+tracker.update([Detection(x=12, y=22)])
+tracker.update([Detection(x=14, y=19)])
+
+print(f"Tracks: {len(tracker.tracks)}")
+for t in tracker.tracks:
+    print(f"  track {t.track_id}: ({t.x}, {t.y}), "
+          f"speed {tracker.speed(t.track_id):.2f} m/s")
+```
+
+Output:
+
+```text
+Tracks: 1
+  track 1: (14, 19), speed 5.13 m/s
+```
+
+### Generate and analyse a signal
+
+```python
+from sonar_vision import Signal
+
+chirp = Signal.chirp(f0=1000, f1=5000, duration=0.01, sample_rate=44100)
+print(f"Chirp samples: {chirp.n_samples}, "
+      f"dominant freq: {chirp.dominant_frequency():.0f} Hz")
+```
+
+Output:
+
+```text
+Chirp samples: 441, dominant freq: 2950 Hz
+```
+
+### Build an occupancy map
+
+```python
+from sonar_vision import SpatialMap, Obstacle
+
+m = SpatialMap(width=20, height=20, resolution=1.0)
+m.add_obstacle(Obstacle(x=5, y=5, radius=1.0))
+print(f"Occupied at (5,5): {m.is_occupied(5, 5)}")
+print(f"Coverage: {m.coverage():.2%}")
+```
+
+Output:
+
+```text
+Occupied at (5,5): True
+Coverage: 1.00%
+```
+
+## How it works
+
+- **`Sonar`** models a single-beam active sonar. It computes round-trip time, applies two-way spreading and configurable absorption loss, adds target strength, and converts the resulting SNR into a detection probability and a noisy distance estimate.
+- **`Signal`** provides discrete-time signal primitives: sine, noise, chirp, resampling, moving-average lowpass/highpass/bandpass filtering, thresholding, envelope, RMS/peak/energy metrics, and a naïve DFT magnitude.
+- **`ObjectTracker`** uses greedy nearest-neighbour association with a constant-velocity prediction gate. Each track stores position and exponentially smoothed velocity; tracks time out after a configurable interval without updates.
+- **`SpatialMap`** maintains a 2-D occupancy grid centred at the origin. Obstacles mark cells as occupied, free-space rays can mark cells as free, and ray casting returns the first occupied cell along a bearing.
+
+## Configuration and options
+
+### `Sonar`
+
+```python
+Sonar(
+    sound_speed=1500.0,   # m/s
+    frequency=50000.0,    # Hz
+    pulse_duration=0.001, # seconds
+    max_range=1000.0,     # meters
+    beam_width=30.0,      # degrees
+    source_level=200.0,   # arbitrary dB
+    noise_level=60.0,     # arbitrary dB
+)
+```
+
+Key methods: `ping(distance, target_strength=-20.0)`, `ping_return_signal(...)`, `round_trip_time(distance)`, `spreading_loss(distance)`, `absorption_loss(distance, absorption_db_km=10.0)`, `in_beam(bearing_offset_deg)`.
+
+### `ObjectTracker`
+
+```python
+ObjectTracker(
+    association_gate=5.0,  # meters
+    max_velocity=10.0,     # m/s
+    lost_timeout=5.0,      # seconds
+)
+```
+
+Key methods: `update(detections)`, `predict(track_id, dt)`, `active_tracks()`, `prune_lost()`, `speed(track_id)`, `heading(track_id)`.
+
+### `SpatialMap`
+
+```python
+SpatialMap(
+    width=100.0,    # meters
+    height=100.0,   # meters
+    resolution=1.0, # meters per cell
+)
+```
+
+Key methods: `add_obstacle(Obstacle(...))`, `get_cell(x, y)`, `set_cell(x, y, state)`, `ray_cast(ox, oy, angle_deg, max_dist)`, `mark_free_ray(...)`, `occupancy_count()`, `coverage()`.
+
+See [`API_REFERENCE.md`](./API_REFERENCE.md) for the full API.
+
+## Limitations
+
+- **Simulation only.** No hydrophone, audio device, or NMEA interface support.
+- **Single-beam sonar.** No beamforming, phased arrays, or multi-beam reconstruction.
+- **Simplified acoustics.** Propagation uses geometric spreading plus a constant dB/km absorption term; it is not a full ocean-acoustics solver.
+- **No image or video processing.** The toolkit works with 1-D signals and 2-D positions, not camera frames.
+- **Not on PyPI.** Install from source for now.
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+The suite covers unit tests (`tests/test_all.py`) and end-to-end simulation scenarios (`tests/test_simulation_scenarios.py`); all pass under Python 3.10+.
+
+## License
+
+MIT. See [`LICENSE`](./LICENSE).

sonar_vision-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sonar-vision"
+version = "0.1.0"
+description = "Pure-Python sonar ping/echo simulation, signal processing, multi-object tracking, and spatial mapping toolkit"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[tool.setuptools.packages.find]
+include = ["sonar_vision*"]

sonar_vision-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sonar_vision-0.1.0/sonar_vision/__init__.py

@@ -0,0 +1,22 @@
+"""Sonar Vision — signal processing and spatial awareness for agents."""
+
+from sonar_vision.signal import Signal
+from sonar_vision.sonar import Sonar, PingResult, SOUND_SPEED_WATER
+from sonar_vision.map import SpatialMap, Obstacle, CellState
+from sonar_vision.tracker import ObjectTracker, Track, Detection
+from sonar_vision.display import SonarDisplay
+
+__all__ = [
+    "Signal",
+    "Sonar",
+    "PingResult",
+    "SOUND_SPEED_WATER",
+    "SpatialMap",
+    "Obstacle",
+    "CellState",
+    "ObjectTracker",
+    "Track",
+    "Detection",
+    "SonarDisplay",
+]
+__version__ = "0.1.0"

sonar_vision-0.1.0/sonar_vision/display.py

@@ -0,0 +1,165 @@
+"""SonarDisplay — ASCII radar rendering for sonar data."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional
+
+from sonar_vision.map import SpatialMap, CellState, Obstacle
+from sonar_vision.tracker import ObjectTracker, Track
+
+
+# ASCII intensity ramp for signal strength / proximity
+_RAMP = " .:-=+*#%@"
+_RAMP_LEN = len(_RAMP)
+
+
+@dataclass
+class SonarDisplay:
+    """ASCII-based sonar radar display.
+
+    Renders a top-down polar or Cartesian view using characters.
+
+    Attributes:
+        width: Display width in characters.
+        height: Display height in characters.
+        range_m: Maximum display range in meters.
+    """
+
+    width: int = 41
+    height: int = 21
+    range_m: float = 50.0
+
+    # ── radar sweep ───────────────────────────────────────────────
+
+    def render_sweep(
+        self,
+        bearing_angles: list[float],
+        distances: list[float],
+        max_range: float | None = None,
+    ) -> str:
+        """Render a radar sweep from bearing/distance readings.
+
+        Each (bearing, distance) pair places a blip on the display.
+        """
+        rng = max_range or self.range_m
+        grid: list[list[str]] = [
+            [" " for _ in range(self.width)] for _ in range(self.height)
+        ]
+        cx = self.width // 2
+        cy = self.height // 2
+
+        # Draw crosshairs
+        for x in range(self.width):
+            grid[cy][x] = "·" if grid[cy][x] == " " else grid[cy][x]
+        for y in range(self.height):
+            grid[y][cx] = "·" if grid[y][cx] == " " else grid[y][cx]
+
+        # Range rings (25%, 50%, 75%)
+        for frac in (0.25, 0.5, 0.75):
+            r_cells = int(frac * min(cx, cy))
+            for angle_deg in range(0, 360, 5):
+                ar = math.radians(angle_deg)
+                px = cx + int(r_cells * math.cos(ar))
+                py = cy - int(r_cells * math.sin(ar))
+                if 0 <= px < self.width and 0 <= py < self.height:
+                    grid[py][px] = "·"
+
+        # Centre marker (draw after range rings to avoid overwrite)
+        grid[cy][cx] = "+"
+
+        # Plot detections
+        for bearing, dist in zip(bearing_angles, distances):
+            if dist > rng or dist <= 0:
+                continue
+            ar = math.radians(bearing)
+            r_norm = dist / rng
+            px = cx + int(r_norm * cx * math.cos(ar))
+            py = cy - int(r_norm * cy * math.sin(ar))
+            if 0 <= px < self.width and 0 <= py < self.height:
+                intensity = int((1.0 - r_norm) * (_RAMP_LEN - 1))
+                intensity = max(0, min(_RAMP_LEN - 1, intensity))
+                grid[py][px] = _RAMP[intensity]
+
+        lines = ["".join(row) for row in grid]
+        return "\n".join(lines)
+
+    # ── occupancy map ─────────────────────────────────────────────
+
+    def render_map(self, smap: SpatialMap) -> str:
+        """Render a SpatialMap as ASCII."""
+        symbols = {CellState.UNKNOWN: " ", CellState.FREE: ".", CellState.OCCUPIED: "#"}
+        # Downsample map to display size
+        row_scale = smap.rows / self.height
+        col_scale = smap.cols / self.width
+
+        lines: list[str] = []
+        for dr in range(self.height):
+            row_start = int(dr * row_scale)
+            row_end = min(smap.rows, int((dr + 1) * row_scale))
+            line_chars: list[str] = []
+            for dc in range(self.width):
+                col_start = int(dc * col_scale)
+                col_end = min(smap.cols, int((dc + 1) * col_scale))
+                # Pick most interesting cell in block
+                cell = CellState.UNKNOWN
+                for r in range(row_start, row_end):
+                    for c in range(col_start, col_end):
+                        s = smap._grid[r][c]
+                        if s == CellState.OCCUPIED:
+                            cell = s
+                        elif s == CellState.FREE and cell == CellState.UNKNOWN:
+                            cell = s
+                line_chars.append(symbols[cell])
+            lines.append("".join(line_chars))
+        return "\n".join(lines)
+
+    # ── tracker overlay ───────────────────────────────────────────
+
+    def render_tracks(
+        self,
+        tracker: ObjectTracker,
+        cx_m: float = 0.0,
+        cy_m: float = 0.0,
+        now: float | None = None,
+    ) -> str:
+        """Render active tracks relative to a centre point."""
+        grid: list[list[str]] = [
+            [" " for _ in range(self.width)] for _ in range(self.height)
+        ]
+        cx = self.width // 2
+        cy = self.height // 2
+
+        # Crosshairs
+        for x in range(self.width):
+            grid[cy][x] = "·"
+        for y in range(self.height):
+            grid[y][cx] = "·"
+        grid[cy][cx] = "+"
+
+        active = tracker.active_tracks(now)
+        for t in active:
+            dx = t.x - cx_m
+            dy = t.y - cy_m
+            px = cx + int(dx / self.range_m * cx)
+            py = cy - int(dy / self.range_m * cy)
+            if 0 <= px < self.width and 0 <= py < self.height:
+                # Draw track marker and velocity vector
+                marker = str(t.track_id % 10) if t.track_id < 10 else "*"
+                grid[py][px] = marker
+                # Velocity indicator
+                vscale = self.range_m / (tracker.max_velocity or 1.0) * 2
+                vx_px = int(t.vx * vscale / self.range_m * cx)
+                vy_px = int(t.vy * vscale / self.range_m * cy)
+                ex = px + vx_px
+                ey = py - vy_px
+                # Simple line
+                steps = max(abs(ex - px), abs(ey - py), 1)
+                for i in range(1, steps + 1):
+                    lx = px + (ex - px) * i // steps
+                    ly = py + (ey - py) * i // steps
+                    if 0 <= lx < self.width and 0 <= ly < self.height and grid[ly][lx] == " ":
+                        grid[ly][lx] = "~"
+
+        return "\n".join("".join(row) for row in grid)

sonar_vision-0.1.0/sonar_vision/map.py

@@ -0,0 +1,230 @@
+"""SpatialMap — obstacle detection, mapping, and spatial queries."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class CellState(Enum):
+    """State of a grid cell."""
+    UNKNOWN = 0
+    FREE = 1
+    OCCUPIED = 2
+
+
+@dataclass
+class Obstacle:
+    """Detected obstacle.
+
+    Attributes:
+        x: X-coordinate in meters.
+        y: Y-coordinate in meters.
+        radius: Approximate radius in meters (0 for point obstacles).
+        confidence: Detection confidence (0–1).
+        label: Optional label.
+    """
+
+    x: float
+    y: float
+    radius: float = 0.0
+    confidence: float = 1.0
+    label: str = ""
+
+
+@dataclass
+class SpatialMap:
+    """2-D occupancy grid map with obstacle management.
+
+    The map covers a rectangular region centred at the origin.
+
+    Attributes:
+        width: Map width in meters.
+        height: Map height in meters.
+        resolution: Cell size in meters.
+    """
+
+    width: float = 100.0
+    height: float = 100.0
+    resolution: float = 1.0
+    _obstacles: list[Obstacle] = field(default_factory=list)
+    _grid: list[list[CellState]] = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        cols = max(1, int(self.width / self.resolution))
+        rows = max(1, int(self.height / self.resolution))
+        self._grid = [[CellState.UNKNOWN for _ in range(cols)] for _ in range(rows)]
+
+    # ── grid helpers ──────────────────────────────────────────────
+
+    @property
+    def cols(self) -> int:
+        return len(self._grid[0]) if self._grid else 0
+
+    @property
+    def rows(self) -> int:
+        return len(self._grid)
+
+    def _world_to_cell(self, x: float, y: float) -> tuple[int, int]:
+        """Convert world coords to cell (row, col)."""
+        col = int((x + self.width / 2.0) / self.resolution)
+        row = int((y + self.height / 2.0) / self.resolution)
+        return row, col
+
+    def _cell_to_world(self, row: int, col: int) -> tuple[float, float]:
+        """Convert cell (row, col) to world coords (centre of cell)."""
+        x = (col + 0.5) * self.resolution - self.width / 2.0
+        y = (row + 0.5) * self.resolution - self.height / 2.0
+        return x, y
+
+    def _in_bounds(self, row: int, col: int) -> bool:
+        return 0 <= row < self.rows and 0 <= col < self.cols
+
+    # ── cell access ───────────────────────────────────────────────
+
+    def get_cell(self, x: float, y: float) -> CellState:
+        """Get the state of the cell at world coordinates (x, y)."""
+        row, col = self._world_to_cell(x, y)
+        if not self._in_bounds(row, col):
+            return CellState.UNKNOWN
+        return self._grid[row][col]
+
+    def set_cell(self, x: float, y: float, state: CellState) -> None:
+        """Set the state of the cell at world coordinates (x, y)."""
+        row, col = self._world_to_cell(x, y)
+        if self._in_bounds(row, col):
+            self._grid[row][col] = state
+
+    # ── obstacles ─────────────────────────────────────────────────
+
+    def add_obstacle(self, obstacle: Obstacle) -> None:
+        """Add an obstacle and mark its cells as occupied."""
+        self._obstacles.append(obstacle)
+        # Mark cells within the obstacle radius (at least the center cell)
+        cx, cy = obstacle.x, obstacle.y
+        r_cells = max(1, int(math.ceil(obstacle.radius / self.resolution))) if obstacle.radius > 0 else 0
+        center_row, center_col = self._world_to_cell(cx, cy)
+        # Always mark the center cell
+        if self._in_bounds(center_row, center_col):
+            self._grid[center_row][center_col] = CellState.OCCUPIED
+        for dr in range(-r_cells, r_cells + 1):
+            for dc in range(-r_cells, r_cells + 1):
+                nr, nc = center_row + dr, center_col + dc
+                if self._in_bounds(nr, nc):
+                    wx, wy = self._cell_to_world(nr, nc)
+                    if obstacle.radius <= 0 or math.hypot(wx - cx, wy - cy) <= obstacle.radius:
+                        self._grid[nr][nc] = CellState.OCCUPIED
+
+    def remove_obstacle(self, index: int) -> None:
+        """Remove obstacle by index and clear its cells."""
+        if 0 <= index < len(self._obstacles):
+            obs = self._obstacles.pop(index)
+            self._mark_area_free(obs)
+
+    def _mark_area_free(self, obs: Obstacle) -> None:
+        r_cells = max(1, int(math.ceil(obs.radius / self.resolution))) if obs.radius > 0 else 1
+        center_row, center_col = self._world_to_cell(obs.x, obs.y)
+        for dr in range(-r_cells, r_cells + 1):
+            for dc in range(-r_cells, r_cells + 1):
+                nr, nc = center_row + dr, center_col + dc
+                if self._in_bounds(nr, nc):
+                    wx, wy = self._cell_to_world(nr, nc)
+                    if obs.radius <= 0 or math.hypot(wx - obs.x, wy - obs.y) <= obs.radius:
+                        self._grid[nr][nc] = CellState.FREE
+
+    @property
+    def obstacles(self) -> list[Obstacle]:
+        return list(self._obstacles)
+
+    def clear(self) -> None:
+        """Clear all obstacles and reset grid."""
+        self._obstacles.clear()
+        for r in range(self.rows):
+            for c in range(self.cols):
+                self._grid[r][c] = CellState.UNKNOWN
+
+    # ── queries ───────────────────────────────────────────────────
+
+    def is_occupied(self, x: float, y: float) -> bool:
+        """Check if position (x, y) is occupied."""
+        return self.get_cell(x, y) == CellState.OCCUPIED
+
+    def is_free(self, x: float, y: float) -> bool:
+        """Check if position (x, y) is known free."""
+        return self.get_cell(x, y) == CellState.FREE
+
+    def nearest_obstacle(self, x: float, y: float) -> Optional[Obstacle]:
+        """Return the nearest obstacle to (x, y), or None."""
+        if not self._obstacles:
+            return None
+        return min(self._obstacles, key=lambda o: math.hypot(o.x - x, o.y - y))
+
+    def obstacles_in_radius(self, x: float, y: float, radius: float) -> list[Obstacle]:
+        """Return obstacles within *radius* meters of (x, y)."""
+        return [o for o in self._obstacles if math.hypot(o.x - x, o.y - y) <= radius]
+
+    def distance_to_nearest(self, x: float, y: float) -> float:
+        """Distance to the nearest occupied cell or obstacle."""
+        obs = self.nearest_obstacle(x, y)
+        if obs is None:
+            return float("inf")
+        return math.hypot(obs.x - x, obs.y - y)
+
+    # ── ray casting ───────────────────────────────────────────────
+
+    def ray_cast(self, ox: float, oy: float, angle_deg: float, max_dist: float) -> Optional[tuple[float, float]]:
+        """Cast a ray from (ox, oy) at *angle_deg* and return first hit (x, y) or None.
+
+        Uses DDA-style stepping at cell resolution.
+        """
+        angle_rad = math.radians(angle_deg)
+        dx = math.cos(angle_rad) * self.resolution * 0.5
+        dy = math.sin(angle_rad) * self.resolution * 0.5
+        steps = int(max_dist / (self.resolution * 0.5))
+        cx, cy = ox, oy
+        for _ in range(steps):
+            if self.is_occupied(cx, cy):
+                return (cx, cy)
+            # Also check out of bounds
+            row, col = self._world_to_cell(cx, cy)
+            if not self._in_bounds(row, col):
+                return None
+            cx += dx
+            cy += dy
+        return None
+
+    # ── statistics ────────────────────────────────────────────────
+
+    def occupancy_count(self) -> dict[CellState, int]:
+        """Count cells by state."""
+        counts = {s: 0 for s in CellState}
+        for row in self._grid:
+            for cell in row:
+                counts[cell] += 1
+        return counts
+
+    def coverage(self) -> float:
+        """Fraction of map that is explored (FREE + OCCUPIED)."""
+        total = self.rows * self.cols
+        if total == 0:
+            return 0.0
+        counts = self.occupancy_count()
+        explored = counts[CellState.FREE] + counts[CellState.OCCUPIED]
+        return explored / total
+
+    # ── mark free from sonar sweep ────────────────────────────────
+
+    def mark_free_ray(self, ox: float, oy: float, angle_deg: float, distance: float) -> None:
+        """Mark cells along a ray as FREE up to *distance* meters."""
+        angle_rad = math.radians(angle_deg)
+        steps = max(1, int(distance / self.resolution))
+        for i in range(steps):
+            t = (i + 0.5) * self.resolution
+            if t > distance:
+                break
+            wx = ox + t * math.cos(angle_rad)
+            wy = oy + t * math.sin(angle_rad)
+            if self.get_cell(wx, wy) != CellState.OCCUPIED:
+                self.set_cell(wx, wy, CellState.FREE)