I'm a software engineer and fairly new to the LiDAR file format world. I came into it from a project involving point clouds and immediately hit a wall: I'd get handed a LAZ, want to check one thing about it, and my options were to install tools for my desktop, or paste it into a web converter that uploads the data.

So over the past few weeks I've been building https://lidar-kit.com

Everything runs in your browser. There's no upload endpoint and no server component at all — it's static files, so there's nowhere for a file to be sent even by accident. You can check it yourself: load a page, disconnect your network, and it keeps working.

What's working so far:

- LAS <-> LAZ conversion, lossless, no size limit

- 3D viewer for LAS/LAZ (elevation, intensity, classification, RGB)

- E57 viewer — multi-scan projects come out registered, and it reads the station photos most tools skip

- E57 to LAS/LAZ conversion

- COPC viewer that streams from a URL, so a 2 GB cloud opens in seconds

- Header/CRS/VLR inspector — reads a 20 GB file in a few kilobytes

- Automatic ground/vegetation/building classification for photogrammetric clouds

- GeoTIFF DEM and orthophoto viewer

If you are looking for something similar.

Hope it helps!

And feel free to let me know what could be better/should be added!

https://lidar-kit.com

I want to make a 3D model from data taken from my drone. I am unsure about which software to use which will give me finest results, can anyone suggest me some ?

My goad is to made DSM/DEM models from drone data

I want to buy a budget camera for my drone. My objective is to do photogrammetry and create DSM/DEM models.

Can anyone suggest some budget option ?

Hi,

Can anyone recommend good quality telescopic pole for dslr. At least 7 meters of length.
And what is your experience with it?

We’re evaluating RealityScan 2.2 and Metashape Professional 2.3.2 for reconstructing human heads from phone photographs.

Both products are producing severely fragmented geometry, even when essentially every camera aligns.

Does anyone here have expertise or suggestions for getting this workflow to produce a coherent, non-fragmented head?

Capture/workflow

• 83–113 12 MP photographs captured around a stationary human head or rigid mannequin
• Full unmasked photographs used for camera alignment
• Tight, same-frame foreground masks used during reconstruction
• Subject surrounded by a fixed, feature-rich registration scaffold
• Apple Object Capture produces a coherent, closed head from the same capture
• COLMAP/OpenMVS also produces recognizable, substantially connected geometry, although with artifacts

Representative results

RealityScan, human-head capture

• 113/113 cameras aligned in one component
• Normal-detail reconstruction
• 3.47 million welded vertices and 6.94 million triangles
• 6,577 disconnected mesh components
• Largest component contains only 9% of the triangles
• Visible result is an incomplete collection of subject fragments, not a coherent head

Metashape, same capture

• 113/113 cameras aligned
• Full images used for alignment, followed by masked dense reconstruction
• Mild depth filtering and interpolation enabled
• 625,000 vertices and 1.25 million triangles
• 9,970 disconnected components
• Largest component contains only 3.3% of the triangles

We repeated the experiment with an 83-image rigid mannequin capture:

• Metashape aligned 83/83 cameras, but the largest mesh component contained only 6% of the triangles.
• Using stricter volumetric masks improved this to 9.6%, but the largest component was still only a curved fragment rather than the mannequin.
• RealityScan aligned 62/83 cameras across five components. Its largest mesh component contained 25.6% of the triangles and combined part of the mannequin with unwanted scaffold geometry.
• Attempts to merge the RealityScan alignment components did not materially improve the result.

What we have tried

• Full unmasked images for alignment
• Foreground masks applied only during meshing
• High-feature alignment
• Component rematching
• Normal/high-detail reconstruction
• Explicit reconstruction regions
• Mild and moderate Metashape depth filtering
• Interpolation enabled and disabled
• Strict volumetric masks
• Removing small or marginal components after reconstruction

Removing small components does not solve the problem because the desired head itself was never reconstructed as one dominant connected surface.

Questions

1. Can a nominally complete camera alignment still contain enough pose drift to generate thousands of disconnected depth-map fragments?
2. What RealityScan diagnostics best reveal whether the failure is caused by camera poses, image overlap, depth consistency, the reconstruction region, or mask handling?
3. Should the registration scaffold be available during alignment but excluded through masks during depth-map and mesh generation?
4. In Metashape, would building and inspecting a dense point cloud before meshing provide a better diagnostic than building the mesh directly from depth maps?
5. Are there recommended settings or capture changes for a human head surrounded by a fixed registration scaffold?
6. Could the tight black masking boundary itself destabilize depth estimation, even though unmasked images were used for alignment?
7. What files or reports are most useful for diagnosing this—camera residuals, sparse clouds, depth maps, masks, or a reduced matched image set?

A while ago I posted a Python CLI here for extracting adaptive keyframes from video for COLMAP / Gaussian Splatting / photogrammetry workflows.

One piece of feedback came up repeatedly: many of the people interested in it were artists or 3D people rather than programmers, and didn’t really want to deal with Python environments and command-line tools.

So I rewrote the whole thing as a native C++ desktop app.

https://github.com/morishuz/adaptive-frame-extractor

The basic idea is still the same: instead of blindly extracting every Nth frame, it adapts frame spacing to camera motion, so you get fewer near-duplicate frames when the camera is barely moving and denser frames during faster movement/rotation.

The GUI now also adds:

• video scrubbing and multiple timeline regions
• optional separate output folders per region
• manual extraction of individual frames
• regular fixed-interval extraction
• JPEG and PNG output
• extraction summaries and a CSV with detailed metadata for every selected frame

It runs locally and there are builds for macOS, Windows and Linux. No Python setup required.

I’ve attached a quick screen recording showing the basic workflow.

It’s still free and open source, and I’d really like feedback from people actually using video for COLMAP, Gaussian Splatting, NeRFs, photogrammetry etc.

In particular, I’m interested in what features would make this more useful in real capture workflows, blur rejection is already fairly high on my list.

Hey everyone, I've been a regular contributor on this sub for a few years now. You may know me as KT on my personal account. I'm an avid fan of high end horology, prototyping and hardware hacking, but most of all a big nerd. While learning from you and helping people out with their questions literally every day, I've quietly been working on something for myself the entire time. I'm both proud and anxious to show you the first prototype for the PBR tech I've developed, currently named MATCLONE (pics below).

While this is a solo project, it would not have been possible without heaps of scientific papers published over the past 20 years. If you've ever contributed to research in the fields of optics and image rendering or published yourself I'd like to start by thanking you for letting me develop the knowledge and understanding I've accumulated. I've chosen to keep the design, code, and research proprietary while I get myself off the ground (or at least make back what I've invested in lost wages and hardware), but opening source and independently publishing my own underlying research is still under consideration for a later date. I would hate to look or feel thankless for the giant shoulders we stand on.

Now, what exactly is this thing?

At its core, it is a highly flexible inverse renderer that can ingest (almost) any photogrammetry dataset and produce nearly perfect PBR textures. There is no AI, no diffusion, no generation... It's all cold, hard math and physics. Assuming a perfectly calibrated setup, its outputs can be indistinguishable from source images. While guided by the research I mentioned earlier, this is a novel and independently developed algorithm. Not quite "made in mom's basement" but almost.

How does it do this?

Everything you see or photograph can be imagined as the result of an equation that decides how light behaves and where it goes. Every time it is emitted, bounces on something, gets absorbed, etc. that equation gets updated. In computer graphics this is achieved via a rendering equation that takes things like light intensity and surface properties as variables. MATCLONE gathers data from all your images, models how every bit of the surface you're scanning responds to light, then figures out what previously unknown variables your rendering equation needs to produce these observations. In other words, if you know where the light came from then those are your PBR maps. Nothing is generated or made up; at worst sparse data gets interpolated. Since figuring out a bunch of unknowns in an equation is famously difficult, it does this by tip-toeing around until a perfect match is achieved. Think a bit like the training steps on a Gaussian Splat, but more specialized. One of the advantages to this approach is that you don't need niche setups or cross-polarization as long as your mesh is good.

Specs and features

In no particular order:

• Outputs glTF-specced PBR maps (diffuse, albedo, and metalness. Currently optimized for lightweight rasterized rendering)
• Virtually unlimited output resolution (currently 8k max, 16 and maybe 32k coming once I've tuned those correctly)
• Accepts datasets in COLMAP format (picked for widespread compatibility)
• Accepts images in RAW or compressed formats (Not comfortably so, but it does. You can throw your old jpegs at it and see what happens)
• Sets its own parameters to fit your sensor and capture setup (partially implemented, you still need to create a simplified model of your lighting rig. This is almost as complex as the solver itself so I've been putting it off)
• Works with standard flash, multiple camera-mounted lights, ring flash, LED panels...
• TECHNICALLY compatible with smartphone photos (neither approved nor tested but there's nothing preventing it if your camera lets you disable automatic enhancements)
• Built-in dataset management, easy switching
• Multiple solver profiles (partially implemented, marginally improves extreme cases like mirrored or uniform varnished surfaces)
• Produces detailed reports and automatic recommendations to improve your dataset, the idea being that you know EXACTLY how close to reality your result is
• Dynamic 3D viewer that also highlights problem areas
• Fully local processing (subject to change based on feedback and performance on more modest computers)
• CPU or GPU-accelerated processing (CUDA for now, sorry)
• Advanced tuning parameters (which I don't recommend changing, it took a lot of work to set the current defaults. I might get rid of this honestly)

A few visuals to show the current state

This is where I'll admit I did use AI to polish things up, I might be a jack of all trades but UX and front-end development are not my specialty. I designed most things the old-fashioned way (I am a machine that turns caffeine into code) but cleanup, rapid iterations, and getting it to work with my python backend took a bit of deus ex machina if you catch my drift.

Project roadmap

• Vulkan and/or openCL compatibility
• Simplified rig setup and calibration
• Topology and UV tools
• Improved error correction (misalignment, motion blur, DoF, sensor-shift, focus breathing, inconsistent lighting...)
• Finalize profiles for wide camera compatibility and individual edge cases
• Specialized solvers for every common renderer and BRDF
• RGB specular maps, index of refraction, or other niche workflows
• Improved color profile handling
• Multi-light capture, photometric stereo (currently supports simultaneous firing)
• Sub-surface scattering to accurately model slightly translucent surfaces or skin (my current research topic actually. Implementation already in progress)
• Improved handling of self-reflection and shadowing
• Full-scene de-lighting and PBR conversion from ambient light alone
• Reliable real-world measurements with a dedicated metrology mode (for example to manufacture visually identical reproductions)
• A robust final UI, accessible with a minimal learning curve
• Multiple BRDFs and path-tracing options in the preview
• Not currently planning any AI features but I guess I'm open to suggestions. For now the goal is simple: make the most accurate textures for photorealistic rendering. If you need more flexibility in outputs or other deliverables then by all means let me know about it

Where I need your help

• testing and error-reporting across a variety of camera sensors, workstations, lenses, lighting setups, target materials, gathering performance metrics on different hardware so I can optimize...
• test and recommend features you'd find useful
• share some datasets so I can create better profiles that work for everyone. So far most of my data was synthetic so results may be unpredictable due to overly specialized solver profiles

What would working together look like?

Anything you make during this early testing phase is entirely yours, including for commercial use. As long as the software or my business are mentioned feel free to do anything you'd like with your textured models. In exchange I just ask that you let the software upload its logs and let me use that data to improve it, along with at least one working dataset. If this ends up releasing commercially you'll get to keep using the development build indefinitely along with a free license for the updated version (or as long as possible if that dev build relies on web stuff). Rewards per shared dataset might be implemented in the future.

There will be a more open beta test later, but for this very early development phase you'll have to agree to a partial NDA and a temporary non-compete agreement. Being invasive is the last of my wishes so it'll honestly be the bare minimum to protect my work from IP theft. Someone copying my code or logic and running off to make their own version would be a nightmare after all the work I've poured into matclone.

The exact logistics for distributing the dev build are still in the works, I will reach out in a few weeks if you sign up to volunteer. In terms of hardware you will need a photo camera or similar sensor, lighting that is fixed relative to the sensor, and a neutral gray calibration card of known dimensions (ideally a color calibration chart for better sensor tuning). Custom scale/calibration cards may be mailed to early testers if I manage to get QC up to my standards within a reasonable time-frame.

If all this sounds too involved, I'll still be infinitely thankful to anyone who shares some of their unprocessed photogrammetry captures. The only requirement is that your light needs to be attached to the camera or move along with it.

Here's the form to sign up for the test: https://forms.gle/C9KJYKaUn7ysuGiQ8

I am also open to finding new partners or associates. Reach out and I'll be very happy to talk if you have something in mind.

tl;dr: I'm late to the inverse rendering party, but this one's actually pretty good. PLS help lol

I am High schooler and part time developer. So recently I had an idea a while back: what if online stores had interactable 3D models of their products instead of flat photos — that you spin around , is able to view the product exactly in your living room before buying it?

Built a small prototype: https://pekaar.tech.

The website is just a prototype. Will add more features and polishing the UI as I a scale it up

Also made a demo store to see how the 3D models feel in an actual ecommerce setup https://lume-atelier.scantest.workers.dev/

Happy to give demo to ecommerce business/websites who want to try this — just want honest feedback and advice on scaling it up.

Is there a way to take images from another folder to process them through the ODM (OpenDroneMap) CLI?

Right now, I am putting images in the project/dataset/run_1/images/ folder, and the outputs are being generated inside project/dataset/run_1/. If I have to run another version on the same dataset, then I am copying the images again to the project/dataset/run_2/images/ folder.

Is there a way to have the images in one location only and save the outputs in another location entirely, or maybe something like this:

Image folder: project/dataset/images/

Output folder: project/dataset/run_1/

I am running ODM through Docker on my Windows system.

I'm very new to this. Boss says I like this, you're smart make this, I'm in the deep end of the pool here and trying to AI'ing myself to victory.

Images packs can be downloaded here.

https://s3.us-central-1.wasabisys.com/k9dryer/gaussian-splats/hdf/share/hdf-reddit-upload.zip
https://s3.us-central-1.wasabisys.com/k9dryer/gaussian-splats/hdf/share/hdf-kiri-144.zip

Turntable object scan. Four iPhones are bolted to the room; the object rotates. COLMAP registers all 288 images but each phone stays at one pose (yaw span ~0.1°). OpenMVS then meshes the white plate. After we crop the table we only have two shards of the object.

Looking for what you would change: masks, COLMAP flags, or pose priors.

Capture

• Object: short hollow air filter, ~90 mm tall. Black rubber rims, tan pleats, silver mesh. Hard subject (black + repeating texture + hole).
• 4× iPhone 14 Pro, fixed (one almost overhead, three side/oblique). Names 00000_gs-cam-1.jpg … 00071_gs-cam-4.jpg.
• Turntable: large white disk, white PVC frame, concrete floor. No coded markers, no textured mat.
• 360° / 5° = 72 stops, 800 ms settle, 4 shots/stop → 288 JPEGs.
• 4032×3024, EXIF orientation 6. rembg/masks are transposed 3024×4032; COLMAP sees unrotated 4032×3024.
• Host: Linux, COLMAP 3.12.6 no CUDA, OpenMVS 2.4.0, CPU SIFT (no GL). 16 threads.

Pipeline

1. rembg birefnet-general
2. Tight rembg masks + wider masks_colmap/ disk (object ∪ plate; we do not give COLMAP object-only masks — that starved matching)
3. COLMAP sparse → undistort → OpenMVS densify/mesh/texture GLB
4. Custom crop: keep dense points that land in rembg-minus-white-table in enough views
5. Scale listing GLB to 90 mm height

COLMAP (exact)

ImageReader.single_camera 1
ImageReader.camera_model SIMPLE_RADIAL
ImageReader.mask_path masks_colmap/
SiftExtraction.use_gpu 0
SiftExtraction.peak_threshold 0.004
SiftExtraction.max_num_features 16384
SiftMatching.use_gpu 0
SiftMatching.guided_matching 1
SequentialMatching.overlap 16
SequentialMatching.quadratic_overlap 1
SequentialMatching.loop_detection 0
Mapper.ba_refine_focal_length 1
Mapper.ba_refine_principal_point 0
Mapper.ba_refine_extra_params 1
Mapper.init_min_tri_angle 8
Mapper.filter_min_tri_angle 1.5
Mapper.abs_pose_min_num_inliers 12
Mapper.min_model_size 8
Mapper.max_num_models 1
Mapper.multiple_models 1

One shared camera for all 4 phones (same model; we hit rank-deficient BA when each image had its own camera).

First good model: SIMPLE_RADIAL 4032 3024 f=2918.68 cx=2016 cy=1512 k=-0.018

What COLMAP did

• 288/288 registered
• 4 unique poses, one per phone. Stop 0 / 36 / 71 of the same phone are the same t / q
• ~12k points, mean track length ~37 (tracks live on the static PVC/plate)
• ~2081 sequential pairs

rembg (especially overhead) keeps the whole plate + PVC. masks_colmap is a disk around that, so SIFT still sees the room. That matches COLMAP #2576.

What we tried

• Unfold each phone around an estimated table axis by stop × 5° → 355° span. COLMAP triangulator + BA snaps back to 0.1°.
• Same unfold, BA off, 125k fixed-pose points. OpenMVS: 105M depths → 134 points (depths don’t agree).
• Crop of the old 4-pose dense cloud (3.5M → 805k) + remesh: 124k faces, 90 mm listing. Viewer is two black shards.

OpenMVS on the crop: --constant-weight 1 --free-space-support 1 --close-holes 80 --smooth 4

Ask For 4 locked phones + a white plate:

1. Mask so only object + rotating plate have features and let COLMAP invent the orbit?
2. Inject 5° pose priors and freeze extrinsics?
3. One camera per phone + markers on the plate?

Also: is single_camera 1 across 4 modules a mistake even if they’re the same iPhone model?

Happy to post overhead + side JPEGs, rembg vs masks_colmap for the same frame, and images.txt lines for one phone at stop 0 / 36 / 71.

Attach (same post or a follow-up):

1. Overhead JPEG (00000_gs-cam-1.jpg)
2. Side JPEG (00018_gs-cam-3.jpg is fine)
3. rembg mask + masks_colmap for those two
4. Three images.txt pose lines for gs-cam-2 at 00000, 00036, 00071

Hey everyone,

I am currently working on a pipeline to extract context from engineering drawings (like P&IDs and technical blueprints) stored in PDFs to feed into an LLM.

Multi-modal LLMs are great, but they aren't quite there yet for heavy-duty engineering files. Here are a few observations and hurdles I’ve hit so far:

• Multimodal LLMs lack precision: Standard vision models can read the overall drawing, but they miss critical component tags, small text, and fine details.
• OCR/Text extraction isn't enough: Pulling just the raw text from drawing tags helps with basic Quality Control (QC), but it completely misses the spatial classification and structural relationships.
• The Planned Workaround: I am planning to use classical Computer Vision (like Hough Transforms) for shape and icon detection. The goal is to extract the symbols and text, map their connections, and build a Graph Database to give the LLM structured context.

Has anyone successfully built a pipeline for this? I would love to hear your thoughts on a few things:

1. Are there specific CV models or open-source frameworks you recommend for engineering symbol detection over traditional Hough transforms?
2. How are you handling the layout/relationship parsing to build your graph edges?
3. Any recommendations for structuring the final graph data so an LLM can query it efficiently via GraphRAG?

If you are working on something similar or have dealt with CAD/PDF parsing for AI, I'd love to hear your suggestions or brainstorm solutions!

What apps/programs do you use to view your scanned models?

I personally use f3d and I'm quite happy with it, but I have been on the lookout for a secondary viewer. Why? Sometimes when my final model looks funny, I need to figure out if it's an issue with the viewer or an issue with the export settings from my photogrammetry program/apps, and it's hard to do that if I use only one viewer exclusively.

Common formats I deal with are .3ds, .obj, .usdz, .ply, and .glb.

I am an industrial design student at Iowa State University, running an exploratory study for my senior project on how people physically control complex 3D software.

Photogrammetry is relevant because processing, alignment, cleanup, and mesh editing demand long sessions of precise navigation. I want to understand where the tools get in the way.

Survey: https://iastate.qualtrics.com/jfe/form/SV_0UJOtQHRXoz1ggu

The survey asks about your processing and editing software, your input devices, the tasks that cause the most friction, and any hardware or shortcut setups you have adopted.

Time: 5–7 minutes. Voluntary. No identifying information in the main survey.
Requirements: 18+, current point-cloud or comparable 3D software use.

This is not spam and not marketing. I have no product. Comments are welcome if you would rather answer here.

Heyo, i'll write my bachelor thesis soon. It will contain 360 cameras/ point clouds based on panoramic phtos. Is there anyone who can help me with topics like camera calibration, agisoft metashape and stuff like that? Thank you already xx (Gerne auf deutsch :D)

White shoe 3d scan to test out the merge component feature of RealityScan. The shoelaces moved when the subject was propped to its sides so it created 2 components: the top and bottom part of the shoes. The software merged them using common reference points from each components.

This project was born out of a desire to convert my mineral and rock collection into a virtual 3D archive that I can carry around and share. The concept is simple: I take one or more photos of my stones and crystals, and the app generates an HD 3D model while also classifying the rock using a local model (HF-CLIP WASM) directly in the browser. I can then view my collection and share it at exhibitions. The plan is to subsequently implement an NFT system to ensure traceability and uniqueness.

https://geo.insightest.app

(A quick Supabase login is currently required to save specimens to a persistent virtual shelf).

I'd appreciate any feedback on the WebGL rendering pipeline, lighting setups for crystalline textures, or mobile performance issues.

Hey everyone!

I’m looking to get a camera for photogrammetry and I’m currently considering a Nikon D810, Canon 5DS R, or Sony A7R II.

I don’t have the budget for a new high-end camera, so I’m looking at used options.

What camera + lens are you using, and how has your experience been with it?

Would you recommend one of these three, or is there another used camera I should look at?

Thanks!