231
modifications
Modifications
aucun résumé de modification
{{Projet
|status= Prototype|image=Horse.profil.jpg
|name=Movie2Gcode
|description=copier un film avec une imprimante 3D
|license= CC-by-sa-3.0|Creative Commons Attribution CC-by-sa-3.0 France
|contributeurs=Cedric
|materiauxingrédients=PLA
}}
Ce résultat a une caractéristique amusante : je construit un objet 3D sans jamais avoir de maillage global de l'objet, mais j'obtiens quand même un objet réel.
==maquette du programme en bash==
Comme la chaîne de conversion utilise de nombreux programmes, j'ai réalisé un premier programme en bash :
===extraction des images fixes===
avec ffmpeg :
<code lang=bash>fmpeg -i RaceHorseMuybridge.flv images/image-%3d.bmp</code>
le reste des transformations se réalisent en boucle pour chaque image
===boucle de traitement===
<code lang=bash>
function demon(){
echo "traitement de toutes les images image-$1*.bmp";
for i in image-$1*.bmp;
do
if [ -f ${i} ]
then
echo "_________________________________________________________${i}";
potrace -o ${i%bmp}eps -k 0.6 -t 50 -B-0.25 -e ${i};
#potrace -o ${i%bmp}eps -k 0.43 --tight -M -0.41 -e ${i};
pstoedit -dt -f dxf:-polyaslines ${i%bmp}eps ${i%bmp}dxf;
rm ${i%bmp}eps
#ecrit le fichier openscad
echo "intersection(){
translate([-4,0,-5])cube([96,63,10]);scale([15,15,1])linear_extrude(height = 0.15, center = false, convexity = 10) import (file = \"${i%bmp}dxf\");}translate([-4,0,0])cube(0.05);
translate([91.95,62.95,0])cube([0.05,0.05,0.14]);" > ${i%bmp}scad;
echo "calcul du ${i%bmp}STL";
/home/cedric/soft/openscad/openscad -o ../stl/${i%bmp}stl ${i%bmp}scad;
rm ${i%bmp}scad;
rm ${i%bmp}dxf;
echo "_______________________________________${i%bmp}STL ok";
else
echo ${i} existe -----------------pas;
fi
done
}</code>
====vectorisation====
Pour définir du plein et du vide à partir d'images en valeurs de lumière, je vectorise les images avec [http://potrace.sourceforge.net/ potrace]
<code lang=bash>potrace -o ${i%bmp}eps -k 0.6 -t 50 -B-0.25 -e ${i};</code>
openSCAD n'accepte que le format DXF, et potrace en produit, mais une variante non lisible par openSCAD
Je suis donc passé par le format EPS, transformé ensuite en DXF via [http://www.pstoedit.net/ pstoedit]
<code lang=bash>pstoedit -dt -f dxf:-polyaslines ${i%bmp}eps ${i%bmp}dxf;</code>
====création du STL====
pour chaque image, je construit un STL à l'aide d'[http://www.openscad.org/ openscad] :
<code lang=C>intersection(){
translate([-4,0,-5])cube([96,63,10]);
scale([15,15,1])
linear_extrude(height = 0.15, center = false, convexity = 10)
import (file = "${i%bmp}dxf");
}translate([-4,0,0])cube(0.05);
translate([91.95,62.95,0])
cube([0.05,0.05,0.14]);</code>
le fichier est alors rendu pour produire le STL
<code lang=bash>openscad -o ../stl/${i%bmp}stl ${i%bmp}scad;</code>
===multithread quick and dirty===
Openscad est assez long à calculer les STL (avec le cheval de muybridge, environ 20sec/image), de plus il n'est pas optimisé pour les multicoeurs.
Pour profiter quand même de toutes les capacités des mon ordinateur et réduire le temps de calcul, j'ai réalisé une fonction multitâche , simplement grâce à l'option "&" des commandes consoles.
<code lang=bash>for z in {0..4}
do
echo ${z}1;
##lance trois demons sur différentes parties des images
demon ${z}0&
demon ${z}1&
demon ${z}2&
demon ${z}3;
echo "premiere fournee finie====================================================="
demon ${z}4 &
demon ${z}5&
demon ${z}6;
echo "seconde fournee finie====================================================="
demon ${z}7 &
demon ${z}8&
demon ${z}9;
echo "troisieme fournee finie====================================================="
done</code>
cette boucle traite jusqu'à 500 images avec un ordinateur 4 coeurs
et permet donc de diviser par 4 le temps de calcul global.
===calcul des Gcodes===
ils sont réalisés avec [http://slic3r.org/ Slic3r]
comme ce dernier est multicoeur, je n'ai pas intégré ce traitement dans la boucle principale
<code lang=bash>for i in image-*.stl;
do
#calcul slicer
slic3r --load ../config.25.plein.ini -o ../gcodes/${i%stl}gcode ${i}
echo ${i};
done
python mixGcode.py</code>
La dernière commande (mixGcode.py) appelle un script qui compile tous les Gcodes ensemble, en conservant que l'ente et le pied du premier, en ajoutant un ofset correspondant à l'épaisseur des couches.
les fichiers sont là [[fichier:Movie2gode.draft.zip]]
==Résultat==
J'ai testé le programme avec le cheval de Muybridge.
[[image:Muybridge_race_horse_animated.gif]][[image:Horse.gcode.jpg|300px]][[image:Horse.pers.jpg|300px]]
Le résultat est plutôt probant.
quelques défaut apparaissent :
comme il n'existe pas de STL à l'origine du GCODE, Slic3r ne calcule pas de supports : il faut donc prévoir cela dans les images
(avec cette vidéo, je l'ai passée dans slomovidéo pour réduire les différences d'images afin qu'elles soient plus proches les unes des autres)
Je vais essayer de réaliser une interface graphique pour rendre la transformation plus généralisable, car pour l'instant, les réglages fins de vectorisation et de mise en page doivent être fais à la main.
==interface graphique==
Je démare donc la programmation de l'interface graphique pour pouvoir :
* choisir les images sources
* régler et ajuster la vectorisation
* définir la taille réelle de l'objet final
* régler les options de remplissage/gcode
* lancer le calcul
J'utilise wxpython comme librairie d'interface
http://wiki.wxpython.org/wxPython%20by%20Example
Finalement, je suis entrain de réécrire tout le programme en python, pour simplifier les futures évolutions du programme.
j'ai bien avancé mais je n'ai pas encore eu le temps de finir l'intégration de toute la chaîne.
[[image:Movie2Gcode.png|800px]]
J'ai cependant appris de nombreuses choses, comme par exemple :
* créer une interface graphique avec wxpython
* appeler des programmes externes et afficher les résultats dans le programme python
* faire du multithread (la boucle de traitement existe mais est pour l'instant vide)
voici le programme dans son état actuel :[[Fichier:Movie2gcode.zip]]
[[Catégorie:FabAcademy]]
