Part 1 · Fast frames, missing targets: a drone simulator on a laptop CPU1편 · 빠른 프레임, 사라진 타깃: 노트북 CPU로 드론 시뮬레이터 만들기第 1 篇 · 帧很快，目标却不见了：用笔记本 CPU 搭建无人机仿真

If I change only the words, will the drone fly somewhere else? Before I could even ask that, my simulator produced 1,000 frames that passed every automated check I had written, and a contact sheet showed the targets cut out of view. This post is about turning a CPU-only simulator into something that produces usable observations, and measuring what each recorded frame costs.

The first recording looked valid, and wasn’t

The setup is a laptop with no NVIDIA GPU: WSL2 + Ubuntu, PyBullet through gym-pybullet-drones, and a camera on the drone that records a 128 x 96 image every 0.2 simulated seconds.

My first 1,000-frame recording passed every check I had written: right count, right shape, no NaNs, no duplicate images, nothing blank. Then I laid 20 frames out as a contact sheet and looked at them. In most of them the targets were cut off at the bottom edge.

Hypothesis: the drone was flying too high to see objects on the floor. Check: it flew at about 1 m, and the targets sat about 1.2 m ahead at 0.15 m. Looking down at them takes atan(0.85 / 1.2) ≈ 35°, but the level camera’s 60° vertical field of view only reaches 30° below its centre line.

Fix and verification: fly at 0.4 to 0.6 m and record again. The new contact sheet shows both targets in view:

A frame of sky and floor is non-blank and unique, so none of the checks I had written could see this. Looking at the data did. I’ll come back to this lesson throughout the series. The guard that would catch it automatically is a target-visibility count from the segmentation mask.

The minimal simulator

Two choices matter for everything after this:

• Linux, outside OneDrive. The code runs in WSL2’s own filesystem. Later stages (ROS 2, PX4, a C++ core) are Linux-first, and I didn’t want a sync client or a folder name with spaces and Korean letters in the build path.
• A CPU renderer. PyBullet’s TinyRenderer draws the camera image in software, so the missing GPU never enters the picture.

Three clocks

• Physics, 240 Hz. The engine advances the world 1/240 s per step.
• Controller, 60 Hz. A PID controller turns “fly this way” into four motor speeds. It reacts to the current error, how that error has added up, and how fast it is changing.
• Camera and policy, 5 Hz. Every 0.2 s the drone takes a picture and the policy decides what to do next.

So one recorded frame is 48 physics steps and 12 controller updates. I started with the examples’ 48 Hz, but that puts 9.6 updates in a frame, so I switched to 60 Hz: my fixed-tick recording loop then runs exactly 12.

What the drone actually sees

To see what is in those pixels, I rendered one frame with PyBullet’s segmentation mask, which labels every pixel with the object it belongs to, and counted:

When so little of the image carries the answer, a small policy can latch onto an easier cue instead. Part 4 shows a policy doing exactly that.

The camera call is short (simplified; full code in dronevla/camera.py):

def render(self, pos, quat, client=0):
    """Return one frame as (height, width, 3) uint8, alpha dropped."""
    w, h, rgba, _, _ = p.getCameraImage(
        width=self.width, height=self.height,          # 128 x 96
        viewMatrix=self.view_matrix(pos, quat),        # where the drone is and where it looks
        projectionMatrix=self._projection,             # 60 deg vertical FOV, square pixels
        shadow=0,                                      # off: the default doubles render time
        flags=p.ER_NO_SEGMENTATION_MASK,               # off: the policy never sees it
        renderer=p.ER_TINY_RENDERER,                   # CPU software rasteriser, no GPU
        physicsClientId=client,
    )
    return np.asarray(rgba, dtype=np.uint8).reshape(h, w, 4)[:, :, :3]

Where one recorded frame spends its time

I timed every stage of producing a recorded frame over 1,000 frames, after 50 warm-up frames that were thrown away. I report medians (p50). I repeated the whole run in a second process, and throughput agreed within 1.7%.

Two findings changed decisions:

1. The controller costs more than the physics. Twelve calls to the pure-Python PID controller take 9.5 ms. The 12 environment steps they steer, 48 physics steps inside, take 3.5 ms. Every policy I evaluate later pays this cost, so it is a fixed part of every experiment’s time budget.
2. Defaults matter. The library’s built-in camera renders shadows and a segmentation mask. Neither is useful here, and together they double the render stage, from 12.8 to 26.5 ms per image. That is why the project has its own camera.

The timing loop puts a stopwatch around each stage (simplified; full code):

for i in range(n_frames):
    t_physics, t_control = 0.0, 0.0
    for _ in range(ctrl_per_frame):                  # 12 controller periods per frame
        t0 = time.perf_counter()
        obs, *_ = env.step(action)                   # 4 physics steps each
        t_physics += time.perf_counter() - t0
        t0 = time.perf_counter()
        action[0], *_ = ctrl.computeControlFromState(...)
        t_control += time.perf_counter() - t0

    t0 = time.perf_counter(); rgb = cam.render(pos, quat); t_render = time.perf_counter() - t0
    t0 = time.perf_counter(); png = encode_png(rgb);       t_encode = time.perf_counter() - t0
    t0 = time.perf_counter(); path.write_bytes(png);       t_write  = time.perf_counter() - t0

Can I afford the dataset?

The plan assumed 6 to 15 KB per frame, stored as JPEG. Measured:

For these 128 x 96 frames of flat colour, lossless PNG is the smallest option: 1.4 KB, against 2.7 to 3.9 KB for JPEG. At the measured rate, the planned 200,000 frames would take about 1.6 hours and 0.3 GB, or 2.4 hours if I keep the plan’s 1.5x safety margin. These numbers extrapolate the measured rate; that dataset doesn’t exist yet.

What this part does not show

• The scene is a floor plus two plain shapes. Richer scenes render slower and compress worse.
• The laptop was busy during the runs, with an editor and a browser open. A quiet machine could land on either side of these numbers.
• Everything here is simulation. Nothing has flown a real drone.

Next

A fast simulator is not yet a believable one. Part 2 takes a real drone’s spec sheet and asks what a 27 g simulated quadrotor can honestly borrow from it, then fixes the task and how it is scored, before any model is trained.

Appendix

git clone https://github.com/Ckck12/Drone_VLA_Simulation.git dronevla && cd dronevla
git checkout --detach 98490502e80c0cf50a65765619e6d72f03ee88b0
SHA=$(sed -n 's/.*gym-pybullet-drones\.git@\([0-9a-f]\{40\}\).*/\1/p' env-lock-candidate.txt)
git clone https://github.com/learnsyslab/gym-pybullet-drones.git third_party/gym-pybullet-drones
git -C third_party/gym-pybullet-drones checkout --detach "$SHA"

python3.12 -m venv .venv && source .venv/bin/activate
pip install --upgrade pip setuptools wheel
pip install "$(grep '^numpy==' env-lock-candidate.txt)"          # before pybullet
pip install --no-build-isolation "$(grep '^pybullet==' env-lock-candidate.txt)"
pip install "$(grep '^torch==' env-lock-candidate.txt)" --index-url https://download.pytorch.org/whl/cpu
grep -v -e '^-e ' -e '^torch==' env-lock-candidate.txt > /tmp/req.txt
pip install -r /tmp/req.txt
pip install --no-deps -e third_party/gym-pybullet-drones
pip check

python -m dronevla.profile_env --frames 1000 --renderer tiny --out reports/env.json
python scripts/figures/blog01_environment.py      # every figure in this post

References: what I took from each

• gym-pybullet-drones provides a quadrotor model and a PID controller on top of PyBullet. → I pinned it by commit and kept its controller, but replaced its camera, whose defaults cost twice the render time.
• PyBullet Quickstart Guide documents getCameraImage and its CPU TinyRenderer. → On a laptop without a GPU, that path takes the GPU out of the question entirely.
• pip: build system interface explains that builds run in an isolated environment by default. → Good for reproducibility, but it hid numpy from pybullet’s compiler, so I turn isolation off for that one package and assert the result.

Summary (STAR)