An interactive tool for diagnosing UAV survey plans.

Read the glossary once before anything else. Every technical term below — pose, picking, sector, weight, visibility — has a plain-language definition, reproduced in section 09.

Five files, one world frame. +Z up, right-handed, metres, degrees. Nothing is ever recentred or rescaled, so geometry from any two files can be drawn together directly.

Surface targets are the measurement grid

They are 3D points spread evenly over the scanned surface, each carrying a normal — the direction sticking straight out of the surface. A camera can only usefully observe a target from the side its normal points towards. For every target, the package lists the viewpoints that can see it, with occlusion by the building already accounted for.

Each observing camera arrives with values you display, not compute

viewscope_core is a dependency, not a starting point. You never reimplement, modify or tune any of its mathematics. If you believe something in it is wrong, report it — do not fork it. Install with pip install -e as described in the Resources README.

What a full recompute for one new camera looks like

# 1 · refuse unsafe placements before doing any work
ok, reason = vc.check_placement(mesh, targets.positions, position)
if not ok:
    return Rejected(reason)          # show `reason` to the user verbatim

# 2 · pose, then visibility against a freshly rendered depth map
pose  = vc.camera_pose(position, yaw_deg, pitch_deg)
depth = renderer.render_depth(pose)          # separate process — pyrender needs its own GL
vis   = vc.camera_visibility(depth, targets.positions, targets.normals,
                             position, pose, plan.camera)

# 3 · score this camera against every target it can see
seen = np.flatnonzero(vis)
for t in seen:
    rho, theta = vc.observer_geometry(targets.positions[t], targets.normals[t],
                                       position[None, :])
    w, f_rho, f_theta = vc.weight_factors(rho, theta)
    s = vc.sector_indices(targets.positions[t], targets.normals[t],
                            position[None, :], sector_count)

# 4 · cache the result, then update every dependent view incrementally
cache.put(camera_id, vis, weights, sectors)
bus.emit("camera_changed", camera_id)

All constants live inside the library. You never type a numeric model parameter yourself — the values below are shown so you can read the panels, not so you can enter them.

How a target ends up with a score

Sixteen items, 80 % of the marks. The approach below is the suggested one — you may modify it, but you must be able to explain your approach clearly and credit any external sources used. Tick items off as you complete them; your progress is saved in this browser.

Work beyond the core. These are engineering extensions, not new mathematics — the marks awarded depend on the complexity of what you add. The items are independent of one another, and the animation and photography items may follow the raw viewpoint order.

Four rules the brief states outright. They are cheap to satisfy early and expensive to retrofit.

viewscope_app/
├─ io/          # loaders, validation, fail-closed errors
├─ scene/       # VTK actors: mesh, targets, frustums, axes, ground
├─ interact/    # picking, selection state, the selection bus
├─ analysis/    # scoring lookup, aggregation, cache, incremental update
├─ services/    # RenderService — one caller-agnostic rendering path
├─ ui/          # dockable panels, parameter panel, metrics
└─ workers/     # thread pool + renderer subprocess, clean shutdown

The application is not the whole submission.

Every term the brief uses, in plain language. Read it once before the brief.

Eighteen questions on the things that are easy to get wrong and expensive to discover late. Answer once per question; the explanation appears immediately.