mirror of
https://github.com/spoopyghosty0/frameport.git
synced 2026-10-24 18:02:05 +02:00
spoopyghosty0
b65abb4b95
The owner's tuned room-scan cleanup (2026-10-18) ported to C, pass for pass: plane offsets re-estimated from the scan, one-sided structural bands, flat wall/floor/ceiling panels (or snap), near clearing, erase spheres, the walked volume from the recording's head path, furniture tops, clipping with the unseen-edge allowance, islands, thin floating pieces, Taubin smoothing; label rules on the scanner's volumes (merged/nested/outside boxes removed, shape relabelling, SCREEN flatness from the raw mesh, door/closet suggestions in scan.json). room.txt + room-mesh.bin are now refined (ceiling re-estimated); the unrefined output stays as room-raw.txt + room-mesh-raw.bin with the same UUIDs; scan.json holds heads, settings, report, labels, suggestions. The scan path refines its raw files as read back, so --refine-only on them reproduces the scan byte for byte; --refine 0 writes the old output. The fusion grid is freed before the refinement (peak memory unchanged).
109 lines
3.8 KiB
C
109 lines
3.8 KiB
C
/* SPDX-License-Identifier: GPL-3.0-only */
|
|
#ifndef FP_ROOMSCAN_H
|
|
#define FP_ROOMSCAN_H
|
|
#include "platform.h"
|
|
|
|
/* Resource limits are independent of dump length. Two passes avoid retaining frames. */
|
|
#define MAX_FRAME_VERTICES 1000000u
|
|
#define MAX_FRAME_INDICES 3000000u
|
|
#define MAX_CELLS 4200000u
|
|
#define MAX_SAMPLES 32768
|
|
#define MAX_PLANES 32
|
|
#define MAX_OUTLINE 96
|
|
#define MAX_VOLUMES 128
|
|
#define MAX_TRIANGLES 200000
|
|
#define MAX_MESH_VERTICES 600000
|
|
#define MAX_HEADS 2000
|
|
#define MAX_ERASE 64
|
|
#define PI 3.14159265358979323846f
|
|
|
|
typedef struct { float x, y, z; } Vec;
|
|
typedef struct { float x, z; } Pt;
|
|
typedef struct {
|
|
Vec p, n;
|
|
float weight, sdf, sw;
|
|
int mark;
|
|
unsigned views, last_frame;
|
|
} Cell;
|
|
typedef struct {
|
|
Vec n;
|
|
float d, lo, hi, bottom, top, area;
|
|
int used;
|
|
} Plane;
|
|
typedef struct { Vec p; float yaw, w, d, h; const char *label; } Volume;
|
|
typedef struct { float x, y, z, r; } Sphere;
|
|
/* Refinement + label rules (refine.c, rules.c); defaults = the owner's tuned settings (2026-10-18). */
|
|
typedef struct {
|
|
int refine, walls, protect, label_rules, smooth, nerase; /* walls: 0 off, 1 snap, 2 panels */
|
|
float band, facing_deg, band_in, floor_in, ceil_in, top_strip, near, clip, clip_open, island, tops;
|
|
float tubes, tube_thick, walked;
|
|
Sphere erase[MAX_ERASE];
|
|
} Refine;
|
|
typedef struct {
|
|
const char *input, *out, *hint, *refine_only;
|
|
Refine rf;
|
|
u64 universe;
|
|
float voxel, ceiling_default, truncation, max_edge, grazing, range, depth_jump, depth_ratio, min_views;
|
|
float patch_residual;
|
|
float plane_distance, min_plane_area, wall_height, snap_degrees;
|
|
float floor_band, ceiling_min, min_volume, cluster_gap, gap, horizontal;
|
|
} Options;
|
|
typedef struct {
|
|
Options opt;
|
|
Cell *cells;
|
|
int nx, ny, nz, count;
|
|
Vec origin;
|
|
Vec samples[MAX_SAMPLES];
|
|
int nsamples;
|
|
u64 seen, accepted, rejected, clipped, far_vertices, discontinuities;
|
|
unsigned frames, skipped_frames, fuse_frame;
|
|
Plane planes[MAX_PLANES];
|
|
int nplanes;
|
|
Pt outline[MAX_OUTLINE];
|
|
int invisible[MAX_OUTLINE], noutline;
|
|
Volume volumes[MAX_VOLUMES];
|
|
int nvolumes;
|
|
float floor, ceiling, coverage;
|
|
const char *warnings[24];
|
|
int nwarnings, hint_used;
|
|
u32 rng;
|
|
Vec heads[MAX_HEADS]; /* head path of tracked frames; the stride doubles whenever the buffer is full */
|
|
int nheads;
|
|
unsigned head_stride, head_frames;
|
|
Vec *vertices;
|
|
u32 *indices;
|
|
int nv, ni;
|
|
i64 t0, tread, tfuse, tmodel, tmesh, trefine;
|
|
} Scan;
|
|
|
|
static inline float ab(float x) { return x < 0 ? -x : x; }
|
|
static inline float mn(float a, float b) { return a < b ? a : b; }
|
|
static inline float mx(float a, float b) { return a > b ? a : b; }
|
|
static inline float clamp(float x, float a, float b) { return mn(mx(x, a), b); }
|
|
static inline Vec vec(float x, float y, float z) { return (Vec){x,y,z}; }
|
|
static inline Vec add(Vec a, Vec b) { return vec(a.x+b.x,a.y+b.y,a.z+b.z); }
|
|
static inline Vec sub(Vec a, Vec b) { return vec(a.x-b.x,a.y-b.y,a.z-b.z); }
|
|
static inline Vec mul(Vec a, float b) { return vec(a.x*b,a.y*b,a.z*b); }
|
|
static inline float dot(Vec a, Vec b) { return a.x*b.x+a.y*b.y+a.z*b.z; }
|
|
static inline Vec cross(Vec a, Vec b) { return vec(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x); }
|
|
static inline int finite(float x) { return x == x && ab(x) < 1e20f; }
|
|
float root(float x);
|
|
float sine(float x);
|
|
float cosine(float x);
|
|
float angle(float y, float x);
|
|
Vec unit(Vec p);
|
|
int flo(float x);
|
|
u32 random_next(Scan *s);
|
|
void warn(Scan *s, const char *message);
|
|
int cell_index(Scan *s, Vec p);
|
|
Vec grid_point(Scan *s, int x, int y, int z);
|
|
const char *read_dump(Scan *s, int fuse);
|
|
const char *init_grid(Scan *s);
|
|
void finish_fusion(Scan *s);
|
|
const char *make_model(Scan *s);
|
|
const char *make_mesh(Scan *s);
|
|
int same(const char *a, const char *b);
|
|
int parse_number(char **cursor, float *value);
|
|
|
|
#endif
|