colmap pipeline (win version)

version 'executables windows' a adapter :

I use this for COLMAP + OpenMVS:
 
.\colmap\feature_extractor.exe --database_path .\output\database.db --image_path .\images\
.\colmap\exhaustive_matcher.exe --database_path .\output\database.db
.\colmap\mapper.exe --database_path .\output\database.db --image_path .\images\ --export_path .\output\
.\colmap\model_converter.exe --input_path .\output\0 --output_path .\output\model.nvm --output_type nvm
.\openmvs\InterfaceVisualSFM.exe -w .\images\ -i ..\output\model.nvm -o ..\output\model.mvs --output-image-folder ..\output -v 0
.\openmvs\DensifyPointCloud.exe -w .\images\ -i ..\output\model.mvs -o ..\output\model_dense.mvs -v 0
.\openmvs\ReconstructMesh.exe -w .\images\ -i ..\output\model_dense.mvs -o ..\output\model_dense_mesh.mvs -v 0
.\openmvs\RefineMesh.exe -w .\images\ -i ..\output\model_dense_mesh.mvs -o ..\output\model_dense_mesh_refine.mvs -v 0
.\openmvs\TextureMesh.exe -w .\images\ -i ..\output\model_dense_mesh_refine.mvs -o ..\output\model_dense_mesh_refine_texture.mvs --empty-color 0 -v 0
 
And this for COLMAP:
 
feature_extractor.exe --database_path output/database.db --image_path images
exhaustive_matcher.exe --database_path output/database.db
mapper.exe --database_path output/database.db --image_path images --export_path sparse
image_undistorter.exe --image_path images --input_path sparse/0 --output_path dense --output_type COLMAP --max_image_size 2000
dense_stereo.exe --workspace_path dense --workspace_format COLMAP --DenseStereo.geom_consistency true
dense_fuser.exe --workspace_path dense --workspace_format COLMAP --input_type geometric --output_path dense/fused.ply
dense_mesher.exe --input_path dense/fused.ply --output_path dense/meshed.ply
 
 
 

compilation de colmap utilisant CUDA

listes des dépendances :

- eigen : http://eigen.tuxfamily.org/
- ceres-solver : http://ceres-solver.org/installation.html
- glog : https://github.com/google/glog
- cuda : https://developer.nvidia.com/cuda-downloads

Compilation

- activer les depots non-free pour sa debian
- installer nvidia-cuda-toolkit (8.0)
- avant de configurer/compiler colmap spécifier d'utiliser gcc-4.9 :

export CC=/usr/local/bin/gcc

- configurer/compiler colmap
 

 

--------------------------------------------

A ce jour, problèmes de compilation de la version utilisant CUDA :
- en sachant que je veux aussi pouvoir utiliser OpenMVG et OpenMVS et qu'ils n'utilisent pas les mêmes options de compilations pour la lib Eigen (je crois, voir post précédent)
- CUDA est très lourd : plus d'1 Go (faire de la place sur son disque à priori n'est pas du luxe)
- des problèmes

 

ce que je fais :
- j'essaie de retrouver toutes les traces de sinstalls précédentes et de virer les fichiers
- compile eigen (no problemo), installé dans /usr/local/include/eigen3/
- compile glog (no problemo) installé dans /usr/local/lib/, /usr/local/include
- compile ceres (no problemo) installé dans /usr/local/lib/libceres.a

 

voir :
https://github.com/colmap/colmap/issues/248
pour avoir une explication sur l'erreur CUDACC_VER_MAJOR lors de l'update vers CUDA 9.1

après une recherche il se trouve que la mention CUDACC_VER... est présente dans le fichier :
./eigen/Eigen/Core
avec des lignes commentées...

 

Ou alors on peut configurer colmap sans les binaires de tests et là ça marche ! :
cmake .. -DTESTS_ENABLED=OFF

(sauf qu'ensuite colmap plante à la génération auto... Arf...)
 

 

 

 

photogrammetrie (et de trois)

Quelques nouveaux logiciels sur lesquels je suis tombé et qui méritent le détour :

Colmap

https://colmap.github.io/
https://colmap.github.io/install.html

Regards3D

http://www.regard3d.org/

MicMac

http://micmac.ensg.eu/index.php/Accueil
Interface CEREMA : https://github.com/micmacIGN/InterfaceCEREMA/tree/master/InterfaceCEREMA

A RETENIR :
ceres-solver ne se compile pas avec les mêmes options suivant que l'on veut l'utiliser avec OpenMVS ou Colmap...

#ceres-solver pour OpenMVS
sudo apt-get -y install libatlas-base-dev libsuitesparse-dev
git clone https://ceres-solver.googlesource.com/ceres-solver ceres-solver
mkdir ceres_build && cd ceres_build
cmake . ../ceres-solver/ -DMINIGLOG=ON -DBUILD_TESTING=OFF -DBUILD_EXAMPLES=OFF
make -j2 && sudo make install
cd ..

from : https://github.com/cdcseacave/openMVS/wiki/Building

#ceres-solver pour Colmap :
sudo apt-get install libatlas-base-dev libsuitesparse-dev
git clone https://ceres-solver.googlesource.com/ceres-solver
cd ceres-solver
mkdir build
cd build
cmake .. -DBUILD_TESTING=OFF -DBUILD_EXAMPLES=OFF
make
sudo make install

from  : https://colmap.github.io/install.html

(d'ailleurs quand on compile colmap sans avoir recompilé ceres-solver, cmake nous pose un petit warning comme ça :
Found Ceres compiled with miniglog substitute for glog, beware this will likely cause problems if glog is later linked.)

 

Sur ma Debian la version de GCC est trop récente pour le compilateur nvcc (apparemment...) donc une astuce du type :

CC="gcc-4.5" ./configure
CC="gcc-4.5" make

pourrait marcher...
from :
https://askubuntu.com/questions/26498/choose-gcc-and-g-version

dicom to 3d mesh

Dans la série "Photogrammetrie", on peut s'interesser aussi à la reconstruction 3d à partir de photos anatomiques provenant de la pratique médicale, ici un exemple de programme travaillant à partir d'images DICOM (scanner) pour en produire un maillage 3d :
https://github.com/AOT-AG/DicomToMesh

photogrammetrie (le retour)

Les 2 logiciels suivant nécessitent quand on veut les compiler, qu'on le fasse aussi avec toutes les bibliothèques nécessaire. Il y a donc de fortes chances pour que vous cloniez le dépôt git en utilisant l'option '--recursive' (du genre : git clone --recursive https://github.com/openMVG/openMVG.git)
Mattez bien la doc : elle est bien faite pour les 2 logiciels, et pour la compilation, si vous suivez bien la documentation, ça se fait sans aucun soucis.

OpenMVG
site : http://imagine.enpc.fr/~moulonp/openMVG/
code : https://github.com/openMVG/openMVG
doc : http://openmvg.readthedocs.io/en/latest/

OpenMVS
site : http://cdcseacave.github.io/openMVS/
code : https://github.com/cdcseacave/openMVS
doc : https://github.com/cdcseacave/openMVS/wiki


Pour une reconstruction simple, la suite de commandes ci dessous est tirée des documentation des logiciels respectifs :


python /data/Sources/OpenMVG/openMVG_Build/software/SfM/SfM_SequentialPipeline.py /input/images/folder/ /output/folder/
(éventuellement modifier le script pour qu'il y est plus de points trouvés :
openMVG_main_computeMatches -i images -o matches -r .8 -p 0.01 -s 1)

/data/Sources/OpenMVG/openMVG_Build/Linux-x86_64-RELEASE/openMVG_main_openMVG2openMVS -i sfm_data.bin -o scene.mvs


 


/usr/local/bin/OpenMVS/DensifyPointCloud scene.mvs

/usr/local/bin/OpenMVS/ReconstructMesh scene_dense.mvs

/usr/local/bin/OpenMVS/RefineMesh scene_dense_mesh.mvs

/usr/local/bin/OpenMVS/TextureMesh scene_dense_mesh.mvs

crédits illustration :
https://pfalkingham.wordpress.com/2016/09/14/trying-all-the-free-photogrammetry/

Photogrammetrie : Meshlab

Meshing Point Clouds

One of the most requested tasks when managing 3D scanning data is the conversion of point clouds into more practical triangular meshes. Here is a step-by-step guide for transforming a raw point cloud into a colored mesh.

http://meshlabstuff.blogspot.fr/2009/09/meshing-point-clouds.html

Photogrammetrie : Point Cloud Library

Un nouveau lien à propos de reconstruction 3D :

http://pointclouds.org/about/

PCL.png
On ne peut pas faire l'impasse sur cette librairie si l'on s'intéresse un petit à la reconstruction 3D.
Un truc qui me parait important au premier regard : PCL est compatible avec les caméras 3d genre kinect et autres... Cela fait une grosse différence avec OpenMVG et VisualSfM, j'image que les reconstruction faites à partir de caméras 3D sont plus rapides à faire et également plus précises...
A tester...

Bon, la je crois qu'entre VisualSfM, PointCloudLibrary et OpenMVG, j'ai pas mal de boulots de tests en perspective...
La suite bientôt...

Notes :
La bibliothèque sur laquelle est faite Meshlab :
http://vcg.isti.cnr.it/vcglib/
http://vcg.isti.cnr.it/

 

Reconstruction Poisson :
http://www.cs.jhu.edu/~misha/Code/PoissonRecon/Version7.0/

https://github.com/mkazhdan/PoissonRecon">

Photogrammetrie : UMVE

 

umve2_screenshot.png

en train de tester UMVE :
la c'est en train de compiler...

https://github.com/simonfuhrmann/mve

http://www.gris.informatik.tu-darmstadt.de/projects/multiview-environment/

Images et tests à suivre...

Photogrammetrie : openMVG

Par rapport à la solution avec VisualSFM, OpenMVG n'est pas graphique :
on l'utilise depuis la ligne de commande, et ça, c'est très cool :)

http://imagine.enpc.fr/~moulonp/openMVG/

https://github.com/openMVG/openMVG/

https://openmvg.readthedocs.org/en/latest/

 

Des images sont à venir, mais à première vue, openMVG semble très intéressant :

- moins dur à installer que VisualSFM
- fonctionne en ligne de commande (donc faisable sur un serveur)
- à l'air rapide pour traiter les photos et trouver les points (à vérifier mais les premiers tests semblent concluants...)
 

Photogrammétrie : VisualSFM

 

La photogrammétrie est une technique qui consiste à effectuer des mesures dans une scène, en utilisant la parallaxe obtenue entre des images acquises selon des points de vue différents. Recopiant la vision stéréoscopique humaine, elle a longtemps exploité celle-ci pour reconstituer le relief de la scène à partir de cette différence de points de vue. Actuellement, elle exploite de plus en plus les calculs de corrélation entre des images désormais numériques. Cette technique repose entièrement sur une modélisation rigoureuse de la géométrie des images et de leur acquisition afin de reconstituer une copie 3D exacte de la réalité.

Source : http://fr.wikipedia.org/wiki/Photogramm%C3%A9trie

 

Test avec VisualSFM, MeshLab, Blender.

 

Des photographies d'un pot de cactus, le but étant de faire le tour de l'objet en question, en gardant une lumière assez constante, une bonne netteté (penser à fermer le diaph), et à une distance et une profondeur de champ plus ou moins constante à l'objet :

Capture_du_2015-07-28_15_38_14.png

 

Après importation des photos dans ViualSFM, et suite à la reconstruction 3d, on obtient un nuage de points repérés, ainsi que l'emplacement des prises de vues :

Capture_du_2015-07-28_15_21_15.png

 

La suite avec Meshlab, qui va nous pemettre :
a) de générer une surface facetée (à partir des points) et
b) de générer la texture finale sous la forme d'une seule grande image à appliquer à notre surface


L'import dans Meshlab du modèle exporté depuis VisualSFM (.ply généré grace à CMVS) :

Capture_du_2015-07-28_15_12_37.png

 

La génération de la surface grace à l'algorythme "poisson"

Capture_du_2015-07-28_15_12_03.png

La surface maillée (facetée) finale obtenue avec Meshlab, il faudra exporter cette surface en .obj pour l'ouvrir facilement avec Blender (pensez aussi à exporter la texture) :

Capture_du_2015-07-28_15_12_43.png

L'import dans Blender de la surface, et application de la texture :

Capture_du_2015-07-28_15_27_02.png

Chaine de rendu (en résumé) :

 

VISUALSFM
- importer les images
- file > detect features
- bouton > compute missing matches
- bouton > CMVS

 

MESHLAB
- importer depuis le dossier CMVS exporté précédemment le fichier ***.out (pour avoir tout le projet, dont font partie toutes les images)
- supprimer le mesh, le remplacer par celui haute densité
- filter > clening and repairing > remove faces from non manifold edges
- parametrisation + texturing from registred rasters (cela donne une image de texture, composée de toutes les images précédemment ouvertes)
- filter > point set > surface reconstruction : poisson
- sauver le projet, exporter les meshs en .obj parce que cela sera facile pour blender de les importer

 

BLENDER
- importer le mesh .obj
- assigner comme texture notre image de texture
- passer en 'edit mode'
- splitter les vues, avoir une vue UV/Image editor, récupérer notre image de texture
 


Un OS Linux centré sur SFM :
http://nuxsfm.sourceforge.net/wiki/index.php/Main_Page

 

Multi View Environement :
http://www.gris.informatik.tu-darmstadt.de/projects/multiview-environment/

tutorial sur la génération d'objets 3d à partir d'une série de photographies :
http://combiencaporte.blogspot.fr/2012/07/la-photogrammetrie-visualsfm-et-meshlab.html

pas évident à compiler, je m'en suis sorti avec les explications du labomedia :
http://wiki.labomedia.org/index.php/Reconstruction_3D_avec_VisualSFM
et cette page qui rassemble pas mal d'instructions utiles :
http://www.10flow.com/2012/08/15/building-visualsfm-on-ubuntu-12-04-precise-pangolin-desktop-64-bit/
plus un petit package sorti à point nommé :
https://launchpad.net/~richi-paraeasy/+archive/ubuntu/ppa/+packages
et ce lien qui aide bien pour pour compiler CMVS :
https://github.com/pmoulon/CMVS-PMVS

Et aussi ce script qui est pas mal :
https://github.com/anders-dc/vsfm-linux-x86_64

NOTE : M'enfin, dans tous les cas, pour installer/compiler sous debian, va falloir régler quelques $PATHS...

 

 

Queques liens divers :
CloudCompare, a 3D point cloud and mesh processing software, Open Source Project :
http://www.danielgm.net/cc/

 

http://wedidstuff.heavyimage.com/index.php/2013/07/12/open-source-photogrammetry-workflow/
http://makezine.com/2013/08/21/diy-photogrammetry-open-source-alternatives-to-123d-catch/

 

Cumulonimbus.fr - 2015 - license cc by-nc-sa 3.0 fr
Dernière mise à jour : 2018-04-24 14:57:17