Solides 3D en colimaçon

(gile) · le 23 décembre 2005

La question étant récurente, je me propose d'expliquer ici (je ne savais pas trop où poster çà) ma méthode pour créer des solides débillardés en colimaçon sur AutoCAD à l'aide de quelques LISP éparpillés çà et là sur le site.

Mise à jour, dernières versions des LISP utilisés :

M2S version 2007 : Version originale et Version sous-titrée en français

En téléchargement : Helicoide et Res_hel

Pour illustrer cette méthode, j'ai choisis l'exemple d'une main courante d'escalier en colimaçon autour d'un poteau.

Pour une hauteur totale de 2880 mm, l'escalier comporte 16 marches de 180 mm de hauteur sur 360° (pas à droite), l'emmarchement est de 1000 mm, le poteau d'un diamètre de 200 mm, le limon et la main courante ont 60 mm de large.

La première étape consiste, après avoir implanté l'escalier, à définir les arrêtes de la main courante (et du limon) à l'aide du LISP Helicoide.

On ne trace qu'un segment de 1/16 de tour

Commande: helicoide

Entrez le nombre de segments par spire : 16 ENTER

Entrez le nombre de spires ou [segments]: s ENTER

Entrez le nombre de segments à tracer: 1 ENTER

Indiquez le sens du pas (Droite/Gauche) : ENTER

Spécifiez la valeur du pas de l'hélice: 2880 ENTER

Spécifiez le rayon de l'hélice ou [Diamètre]: 1100 ENTER

Spécifiez le point à la base de l'axe: 0,0 ENTER

Même opération avec un rayon de 1160.

http://img422.imageshack.us/img422/9961/debillardage13gy.png

Copier (ils re-serviront pour les limons) les deux segments d'hélicoïde à la hauteur de la main courante.

Dans un SCU pivoté de 90° sur X, dessiner le profil (section verticale) de la main courante : un seul objet (ligne, arc, polyligne...) au dessus des arrêtes, un seul au dessous. Il ne doit pas y avoir de "fausse dépouille" de part et d'autre de la ligne des arrêtes pour que le "démoulage" se passe bien.

http://img353.imageshack.us/img353/1336/debillardage21wg.png

Copier et aligner le profil à l'autre extrémité des segments d'hélicoïde.

Après avoir paramétré SURFTAB1 et SURFTAB2, faire une surface gauche pour le dessus de la main courante et une autre pour le dessous.

http://img433.imageshack.us/img433/1972/debillardage31zd.png

Extruder les surfaces à l'aide de M2S

Commande: m2s

Sélectionnez une maille polygonale à solidifier:

Entrez l'épaisseur du solide sous le point le plus bas : 40 ENTER

Donner une épaisseur plus importante que la section du profil pour la maille supérieure et la même pour la maille inférieure.

http://img473.imageshack.us/img473/5139/debillardage42je.png

Soustraire le solide inférieur du solide supérieur.

Faire de même pour le limon (si sa section est rectangulaire, avec des surfaces réglées à la place des surfaces gauches).

Faire la première marche et 1 ou 2 balustres.

http://img284.imageshack.us/img284/7828/debillardage57zo.png

Mettre tous ces objets en réseau hélicoïdal avec RES_HEL

Texte modifié suite à des améliorations dans RES_HEL

Commande: RES_HEL

Choix des objets: 4 trouvé(s)

Choix des objets: ENTER

Entrez le nombre d'éléments du réseau: 16 ENTER

Spécifiez le décalage en hauteur: 180 ENTER

Spécifiez le centre du réseau: 0,0 ENTER

Précisez : angle décrit ou angle entre les éléments [Décrit/Elément] : ENTER

Entrez l'angle décrit ou : 360 ENTER

Spécifiez le sens de rotation [Horaire/Trigonométrique] : ENTER

Ne pas oublier le poteau !

http://img398.imageshack.us/img398/7806/debillardage64sa.png

On peut faire une union des tronçons de limon ou de main courante, mais il est plus sage d'en faire des blocs avant de lancer le réseau, le fichier sera moins d'autant moins lourd.

Ceci n'est qu'une méthode, il y en a sûrement beaucoup d'autres, et peut-être AutoCAD 2007 permettra-t-il l'extrusion le long de splines 3D ?

Je suis, bien sûr complètement à l'écoute de toute critque ou suggestion.

[Edité le 23/12/2005 par (gile)][Edité le 25/12/2005 par (gile)][Edité le 26/12/2005 par (gile)][Edité le 31/12/2005 par (gile)][Edité le 1/1/2006 par (gile)]

[Edité le 21/8/2006 par (gile)]

mikL44 · le 23 décembre 2005

Salut gile

Voila, ca marche nickel jusquau moment ou je veux utiliser m2s.lsp.

Comprends pas, sinon beau boulot.

http://img517.imageshack.us/img517/6540/m2s8in.jpg

mikL44 · le 23 décembre 2005

Bon c est repartis, ca marche, j ai changer de version de m2s.lsp, appload chargeais un qui marchait pas. J y retourne

mikL44 · le 23 décembre 2005

Ca y est jai fait la rampe, ca fonctionne impeccable, je finis pas l escalier, tu m'excuseras mais la je vais me pieuter :)

Tchaoooo

(gile) · le 24 décembre 2005

Merci Boris de faire le testeur.

La version de M2S dont je donne le lien ci-dessus fonctionne, et en prime, nous cause en français.

mikL44 · le 24 décembre 2005

Oui c est celle ci que j ai "apploader", je l avais deja en fait parceque tu me repondais dans ce post que tu indiques, mais je sais pas pourquoi autocad pointais vers l ancien, j avais du merder quelque part. Sinon nickel ton tutoriel.

Mais c est vrai que l extrusion le long d une spline 3d dans la 2007 simplifierait beaucoup les choses.

Tchaoooo

esbe · le 24 décembre 2005

juste un mot en passant ... gile !! chapeau !!!

et joyeuses fêtes de fin d 'année

:)

(gile) · le 25 décembre 2005

Erratum : dans le LISP Helicoide, l'option par défaut à l'invite de :

(setq sens (getkword "\nIndiquez le sens du pas [Droite/Gauche] [surligneur][/surligneur]: "))

a disparu au collage du message.

On peut remplacer la ligne du LISP par celle ci-dessus.

(gile) · le 31 décembre 2005

Petits changements dans le premier message suite à des améliorations apportées au LISP Réseau hélicoïdal

(gile) · le 3 janvier 2006

:present: Comme pour le réseau hélicoïdal, il est désormais possible de saisir les données pour l'hélicoïde dans une boite de dialogue :

http://img373.imageshack.us/img373/1224/helicoide8jx.png

Le code .DCL à enregistrer sous Helicoide.dcl dans un dossier du chemin de recherche d'AutoCAD :

//Helicoide.dcl -Gilles Chanteau- 08/11/04
//Boite de dialogue de la fonction Helicoide
//Modifié le 03/01/06

helicoide:dialog{
 label="Hélicoïde";
 initial_focus="nb_sp";
   :boxed_column{
   label="Spires";
   :row{
     :edit_box{
       label="Segments par spire :";
       key="nb_seg";
       edit_width=6;
     }
     :slider{
       key="sldr_seg";
       value="12";
       min_value=2;
       max_value=24;
       big_increment=1;
       small_increment=1;
       width=16;
       is_tab_stop=false;
     } 
   }
   spacer;
   :row{
     :popup_list{
       key="nbre";
       width= 22;
     }
     :edit_box{
       key="nb_sp";
       edit_width=6;
     }
     spacer;
   }
   spacer;
 }
 :boxed_column{
   label="Pas de l'hélicoïde";
   :row{
     :radio_button{
       label="Pas à droite";
       key="drte";
       value="1"; 
     }
     :radio_button{
       label="Pas à gauche";
       key="gche";
     }
   }
   :row{
     :popup_list{
       key="typ_pas";
       width= 22;
     }
     :edit_box{
       key="val_pas";
       edit_width=8;
     }
     spacer;
     :button{
       label=">>";
       key="pick_pas";
       height=2;
       alignment=right;
       fixed_width=true;
     }
   }
   spacer;
 }
 :boxed_column{
   label="Dimension";
   :row{
     :popup_list{
       key="dim";
       width= 22;
     }
     :edit_box{
       key="ray_ext";
       edit_width=8;
     }
     spacer;
     :button{
       label=">>";
       key="pick_ray";
       height=2;
       alignment=right;
       fixed_width=true;
     }
   }
   spacer;
 }
 :boxed_column{
   label="Base de l'axe";
   :row{
     :edit_box{
       label="X:";
       key="x_coord";
       edit_width=8;
     }
     :edit_box{
       label="Y:";
       key="y_coord";
       edit_width=8;
     }
     :edit_box{
       label="Z:";
       key="z_coord";
       edit_width=8;
     }
     spacer;
     :button{
       label=">>";
       key="b_axe";
       height=2;
       fixed_width=true;
       alignment=right;
     }
   }
   spacer;
 }
 spacer;
 ok_cancel;
}

Le LISP qui va avec :

;;; 04/12/04 Fonction Hélicoïde
;;; Crée une succession d'arcs elliptiques jointifs figurant une hélicoïde.
;;; Le nombre d'arcs décrivant la longueur d'une spire est défini par l'utilisateur.
;;; Le départ de l'hélicoïde se situe sur l'axe des X positifs par rapport au point de base.
;;; La fonction C:HELICOIDE commande la boite de dialogue "helicoide.dcl" pour la saisie des données.
;;; La fontion C:-HELICOIDE permet la saisie des données sur la ligne de commande.
;;; Ces deux fonctions appellent la sous-fonction CREAT_HELICOIDE qui crée le solide.

;;; Modifié le 03/01/06

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

[color=#CC0000];;; HEL_ERR Redéfinition de *ERROR*

(defun HEL_ERR (msg)
 (if (/= msg "Fonction annulée")
   (princ (strcat "\nErreur: " msg))
 )
 (command)
 (command "_ucs" "_restore" "scu_init")
 (command "_ucs" "_del" "scu_init")
 (command "_undo" "_end")
 (setvar "cmdecho" v1)
 (setvar "osmode" v2)
 (setq	*error*	m:err
m:err nil
 )
 (princ)
)

;;; ADD_Z Ajoute "val" à la coordonnée Z du point "pt"

(defun ADD_Z (pt val)
 (list (car pt) (cadr pt) (+ (caddr pt) val))
)

;;; CREAT_HELICOIDE Création de l'hélicoïde

(defun CREAT_HELICOIDE (sp     seg    ray    pas    sens   axe
		/      v1     v2     ang    pt1	   pt2
		pt3    pointA point1 point2 point3 arc
	       )
 (setq	m:err	*error*
*error*	hel_err
v1	(getvar "cmdecho")
v2	(getvar "osmode")
 )
 (command "_undo" "_begin")
 (setvar "cmdecho" 0)
 (command "_ucs" "_save" "scu_init")
 (if (equal sens "Gauche")
   (setq pas (- pas)
  seg (- seg)
   )
 )
 (setq	pt2 (polar axe 0 ray)
pt1 (polar axe (+ (angle axe pt2) (/ (* 2 pi) seg)) ray)
ang (atan (distance pt2 pt1) (/ pas seg))
axe (ADD_Z axe (- (/ pas (* seg 2))))
 )
 (setvar "osmode" 0)
 (repeat sp
   (setq pt1	 pt2
  axe	 (ADD_Z axe (/ pas seg))
  pt2	 (polar axe (+ (angle axe pt1) (/ (* 2 pi) seg)) ray)
  pt2	 (ADD_Z pt2 (/ pas (* seg 2)))
  pt3	 (polar axe (+ (angle axe pt1) (/ pi seg)) ray)
  pointA (trans axe 1 0)
  point1 (trans pt1 1 0)
  point2 (trans pt2 1 0)
  point3 (trans pt3 1 0)
   )
   (command "_ucs" "_new" "3" axe pt1 pt3)
   (command "_ellipse"
     "_arc"
     "c"
     (trans pointA 0 1)
     (trans point3 0 1)
     (/ ray (sin ang))
     (trans point1 0 1)
     (trans point2 0 1)
   )
   (command "_ucs" "_restore" "scu_init")
 )
 (command "_ucs" "_delete" "scu_init")
 (command "_undo" "_end")
 (setvar "cmdecho" v1)
 (setvar "osmode" v2)
 (setq	*error*	m:err
m:err nil
 )
)[/color]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; C:HELICOIDE Boite de dialogue

(defun c:helicoide
	   (/ dcl_id what_next ray sp pas)
 (if (not (member "geomcal.arx" (arx)))
   (arxload "geomcal")
 )
 (setq dcl_id (load_dialog "helicoide.dcl"))
 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "helicoide" dcl_id))
     (exit)
   )
   (start_list "nbre")
   (mapcar 'add_list
    '("Nombre de spires" "Nombre de segments")
   )
   (end_list)
   (start_list "dim")
   (mapcar 'add_list
    '("Rayon" "Diamètre")
   )
   (end_list)
   (start_list "typ_pas")
   (mapcar 'add_list
    '("Valeur du pas" "Avance par segment")
   )
   (end_list)
   (if	(null *seg_hel*)
     (setq *seg_hel* 12)
   )
   (if	(null *axe_hel*)
     (setq *axe_hel* '(0 0 0))
   )
   (if	(not *dim_hel*)
     (setq *dim_hel* 0)
   )
   (if	(not *nbre_hel*)
     (setq *nbre_hel* 0)
   )
   (if	(not *typ_pas*)
     (setq *typ_pas* 0)
   )
   (if	(not *sens_hel*)
     (setq *sens_hel* "Droite")
   )
   (if	(not *sp_hel*)
     (setq sp 1)
     (setq sp *sp_hel*)
   )
   (if	(not *ray_hel*)
     (setq ray 1.0)
     (setq ray *ray_hel*)
   )
   (if	(not *pas_hel*)
     (setq pas 1.0)
     (setq pas *pas_hel*)
   )
   (foreach n '("nb_seg" "sldr_seg")
     (set_tile n (itoa *seg_hel*))
   )
   (set_tile "dim" (itoa *dim_hel*))
   (set_tile "nbre" (itoa *nbre_hel*))
   (set_tile "typ_pas" (itoa *typ_pas*))
   (set_tile "nb_sp" (itoa sp))
   (set_tile "val_pas" (rtos pas))
   (set_tile "ray_ext" (rtos ray))
   (if	(equal *sens_hel* "Droite")
     (set_tile "drte" "1")
     (set_tile "gche" "1")
   )
   (set_tile "x_coord" (rtos (car *axe_hel*)))
   (set_tile "y_coord" (rtos (cadr *axe_hel*)))
   (set_tile "z_coord" (rtos (caddr *axe_hel*)))
   (action_tile
     "sldr_seg"
     (strcat
"(if (or (= $reason 1) (= $reason 3))"
"(progn (set_tile \"nb_seg\" $value)"
"(setq *seg_hel* (atoi $value))))"
     )
   )
   (action_tile
     "nb_seg"
     (strcat
"(if (or (= $reason 1) (= $reason 2))"
"(progn (set_tile \"sldr_seg\" $value)"
"(setq *seg_hel* (atoi $value))))"
     )
   )
   (action_tile
     "dim"
     (strcat
"(if (= $value \"0\")"
"(setq *dim_hel* 0)"
"(setq *dim_hel* 1))"
     )
   )
   (action_tile
     "nbre"
     (strcat
"(if (= $value \"0\")"
"(setq *nbre_hel* 0)"
"(setq *nbre_hel* 1))"
     )
   )
   (action_tile
     "typ_pas"
     (strcat
"(if (= $value \"0\")"
"(setq *typ_pas* 0)"
"(setq *typ_pas* 1))"
     )
   )
   (action_tile
     "nb_sp"
     (strcat
"(if (cal $value)"
"(progn (setq sp (cal $value))"
"(setq *sp_hel* sp)"
"(set_tile \"nb_sp\" (itoa sp)))"
"(progn (alert \"Entrée non valide\")"
"(mode_tile \"nb_sp\" 2)))"
      )
   )
   (action_tile
     "val_pas"
     (strcat
"(if (cal $value)"
"(progn (setq pas (float (cal $value)))"
"(setq *pas_hel* pas)"
"(set_tile \"val_pas\" (rtos pas)))"
"(progn (alert \"Entrée non valide\")"
"(mode_tile \"val_pas\" 2)))"
      )
   )
   (action_tile
     "drte"
     "(if (= (atoi $value) 1) (setq *sens_hel* \"Droite\"))"
   )
   (action_tile
     "gche"
     "(if (= (atoi $value) 1) (setq *sens_hel* \"Gauche\"))"
   )
   (action_tile
     "ray_ext"
     (strcat
"(if (cal $value)"
"(progn (setq ray (float (cal $value)))"
"(setq *ray_hel* ray)"
"(set_tile \"ray_ext\" (rtos ray)))"
"(progn (alert \"Entrée non valide\")"
"(mode_tile \"ray_ext\" 2)))"
      )
   )
   (action_tile
     "x_coord"
     (strcat
"(progn"
"(setq *axe_hel* (subst (atof $value) (car *axe_hel*) *axe_hel*))"
"(set_tile \"x_coord\" (rtos (car *axe_hel*))))"
     )
   )
   (action_tile
     "y_coord"
     (strcat
"(progn"
"(setq *axe_hel* (subst (atof $value) (cadr *axe_hel*) *axe_hel*))"
"(set_tile \"y_coord\" (rtos (cadr *axe_hel*))))"
     )
   )
   (action_tile
     "z_coord"
     (strcat
"(progn"
"(setq *axe_hel* (subst (atof $value) (caddr *axe_hel*) *axe_hel*))"
"(set_tile \"z_coord\" (rtos (caddr *axe_hel*))))"
     )
   )
   (action_tile "b_axe" "(done_dialog 3)")
   (action_tile "pick_pas" "(done_dialog 4)")
   (action_tile "pick_ray" "(done_dialog 5)")
   (action_tile
     "accept"
     (strcat
"(cond"
"((	"(alert \"Le nombre de segments ne peut être inférieur à 2.\")"
"(mode_tile \"nb_seg\" 2))"
"((	"(alert \"Le nombre de spires doit être positif et non nul.\")"
"(mode_tile \"nb_sp\" 2))"
"((	"(alert \"La valeur du pas doit être positive et non nulle.\")"
"(mode_tile \"val_pas\" 2))"
"((	"(alert \"Le rayon de l'hélicoïde doit être positif et non nul.\")"
"(mode_tile \"ray_ext\" 2))"
"(T (done_dialog 1)))"
      )
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 3)
      (setq
 *axe_hel*
  (getpoint
    "\nSélectionnez le point à la base de l'hélicoïde: "
  )
      )
     )
     ((= what_next 4)
      (setq pas       (getdist "\nSpécifiez la valeur du pas: ")
     *pas_hel* pas
      )
     )
     ((= what_next 5)
      (setq ray       (getdist "\nSpécifiez le rayon de l'hélicoïde: ")
     *ray_hel* ray
      )
     )
     ((= what_next 1)
      (if (= *dim_hel* 1)
 (setq ray (/ ray 2))
      )
      (if (= *nbre_hel* 0)
 (setq sp (* sp *seg_hel*))
      )
      (if (= *typ_pas* 1)
 (setq pas (* pas *seg_hel*))
      )
      [color=#CC0000](CREAT_HELICOIDE
 sp *seg_hel* ray pas *sens_hel* *axe_hel*)[/color]
     )
   )
 )
 (unload_dialog dcl_id)
 (princ)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; C:-HELICOIDE Ligne de commande

(defun c:-helicoide (/ seg pas sens sp ray axe)
 (if (not (numberp *seg_hel*))
   (setq *seg_hel* 12)
 )
 (if
   (setq seg (getint
	(strcat	"\nEntrez le nombre de segments par spire 			(itoa *seg_hel*)
		">: "
	)
      )
   )
    (setq *seg_hel* seg)
    (setq seg *seg_hel*)
 )
 (while (    (alert
     "Le nombre de segments par spire ne peut être inférieur à 2."
   )
   (setq seg	    (getint "\nEntrez le nombre de segments par spire: ")
  *seg_hel* seg
   )
 )
 (initget "Segments" 7)
 (if (= (setq sp (getint "\nEntrez le nombre de spires ou [segments]: "))
 "Segments"
     )
   (progn (initget 7)
   (setq sp (getint "\nEntrez le nombre de segments à tracer: "))
   )
   (setq sp (* sp seg))
 )
 (initget "Droite Gauche")
 (if (not
(setq sens
       (getkword "\nIndiquez le sens du pas [Droite/Gauche] : "
       )
)
     )
   (setq sens "Droite")
 )
 (initget 7 "Par_segment")
 (if
   (= (setq pas
      (getdist
	"\nSpécifiez la valeur du pas de l'hélice ou [Par_segment]: "
      )
      )
      "segment"
   )
    (progn
      (initget 7)
      (setq pas
      (* (getdist "\nSpécifiez la valeur de l'avance par segment: "
	 )
	 seg
      )
      )
    )
 )
 (initget "Diamètre" 7)
 (if
   (= (setq ray
      (getdist "\nSpécifiez le rayon de l'hélice ou [Diamètre]: ")
      )
      "Diamètre"
   )
    (progn
      (initget 7)
      (setq ray (/ (getdist "Spécifiez le diamètre de l'hélice: ") 2))
    )
 )
 (if (not (and *axe_hel* (listp *axe_hel*)))
   (setq *axe_hel* '(0.0 0.0 0.0))
 )
 (if
   (setq axe (getpoint	(strcat
		  "\nSpécifiez le point à la base de l'axe 			  (rtos (car *axe_hel*))
		  ","
		  (rtos (cadr *axe_hel*))
		  ","
		  (rtos (caddr *axe_hel*))
		  ">: "
		)
      )
   )
    (setq *axe_hel* axe)
    (setq axe *axe_hel*)
 )
 [color=#CC0000](CREAT_HELICOIDE sp seg ray pas sens axe)[/color]
 (princ)
)

[Edité le 3/1/2006 par (gile)][Edité le 5/1/2006 par (gile)]

[Edité le 5/1/2006 par (gile)]

(gile) · le 5 janvier 2006

On peut remplacer les sous-routines CREAT_HELICOIDE, HEL_ERR et ADD_Z par VL-CREAT_HEL, l'exécution de la commande sera plus rapide (environ 10 fois), ce qui peut être sensible pour des hélicoïdes ayant de nombreux segment et/ou de nombreuses spires.

Dans ce cas, il faut remplacer les lignes :

(CREAT_HELICOIDE

sp *seg_hel* ray pas *sens_hel* *axe_hel*)

et

(CREAT_HELICOIDE sp seg ray pas sens axe)

par :

(VL-CREAT_HEL
sp *seg_hel* ray pas *sens_hel* *axe_hel*)

et

(VL-CREAT_HEL sp seg ray pas sens axe)

La nouvelle fonction VL-CREAT_HEL :

(defun VL-CREAT_HEL (seg     long    sens    pas     ray     cen
	     /	     AcDoc   ModSp   dist1   dist2   AngRot
	     AngArc  MinAx   MajAx   ucszdir arc
	    )
 (vl-load-com)
 (setq	AcDoc (vla-get-ActiveDocument (vlax-get-acad-object))
ModSp (vla-get-ModelSpace AcDoc)
 )
 (vla-StartUndoMark AcDoc)
 ;; Définition des points et des angles de l'ellipse dans le SCU
 (if (equal sens "Gauche")
   (setq pas (- pas)
  seg (- seg)
   )
 )
 (setq	dist1  (distance (polar cen 0.0 ray)
		 (polar cen (/ (* 2 pi) seg) ray)
       )
AngRot (atan dist1 (/ pas seg))
dist2  (* ray (cos (/ pi seg)))
AngArc (atan (/ dist1 (* 2 (sin AngRot))) dist2)
cen    (list (car cen)
	     (cadr cen)
	     (+ (caddr cen) (/ pas (* seg 2)))
       )
minax  (polar cen (/ pi seg) ray)
majax  (polar cen (+ (/ pi seg) (/ pi 2)) (/ ray (sin AngRot)))
 )
 ;; Conversion des points dans le SCG
 (setq	ucszdir	(trans '(0 0 1) 1 0 T)
Cen	(trans cen 1 0)
MinAx	(trans minax 1 0)
MajAx	(mapcar '- (trans majax 1 0) Cen)
 )
 ;; Tracé d'un segment de l'hélicoïde
 (setq	arc (vla-addEllipse
      ModSp
      (vlax-3d-point Cen)
      (vlax-3d-point MajAx)
      (sin AngRot)
    )
 )
 (vla-put-StartAngle arc (- (/ pi -2) AngArc))
 (vla-put-EndAngle arc (+ (/ pi -2) AngArc))
 (vla-Rotate3d
   arc
   (vlax-3d-point Cen)
   (vlax-3d-point MinAx)
   (if	(= sens "Gauche")
     (+ (/ pi 2) AngRot)
     (- (/ pi 2) AngRot)
   )
 )
 ;; Création des autres segments
 (if (    (repeat (1- long)
     (vla-Copy arc)
     (vla-Rotate arc (vlax-3d-point Cen) (/ (* 2 pi) seg))
     (vla-Move	arc
	(vlax-3d-point '(0 0))
	(vlax-3d-point (trans (list 0 0 (/ pas seg)) ucszdir 0))
     )
   )
 )
 (vla-EndUndoMark AcDoc)
)

[Edité le 5/1/2006 par (gile)]

(gile) · le 26 mars 2006

Il est possibble de télécharger l'application au format VLX (un seul fichier compilé) et les codes source LSP et DCLdepuis les téléchargements proposés par les membres.

zinc73 · le 8 décembre 2006

Bonsoir,

Question con, comment on fait la surface gauche ?

Désolé je sors de l'école donc je sais rien faire...

Merci,

A+

(gile) · le 8 décembre 2006

Salut,

Pense à utiliser l'aide d'AutoCAD : tu lances la commande et tu tapes F1, l'aide s'ouvre à la page de la commande concernée.

http://img46.imageshack.us/img46/399/surfgauqe1.png

Avant de lancer la commande SURFGAU (_EDGESURF) il faut pramétrer les variables systèmes SURFTAB1 et SURFTAB2 qui définissent respectivement le nombre de mailles sur M et N.

zinc73 · le 15 décembre 2006

Bonjour,

Merci, ça marche :)

http://img100.imageshack.us/img100/1993/escalierum3.th.jpg

Bonne continuation à tous.

Jeanmimi2 · le 14 février 2007

La vie est a de nouveau belle depuis que je vous ai trouvé... MERCI pour toutes ces précieuses explications.

Jeanmimi2 · le 14 février 2007

Je souhaite obtenir des conseils concernant la modélisation d'un escalier un peu plus compliqúe en se basant sur les techniques énoncées mais je n'arrive pas à ajouter la capture d'écran au message...

zapou78 · le 3 janvier 2012

Hello, et merci pour ce fabuleux site!

Je voulais m'exercer à faire un escalier en colimaçon sur Autocad 2012.

Qqn pourrait m'aider à le réaliser?

Merci et bonne soirée!

Esteban

zapou78 · le 3 janvier 2012

Haaa oui j'oubliais, étant débutant sur autocad, je voulais savoir si les LISP crées pour les versions précédentes sont toujours valable sur autocad 2012, ou si de nouvelles fonctions facilitent la création de tels dessins?

bryce · le 3 janvier 2012

Bonsoir,

Sur les versions "récentes" (2007 et +), pas besoin de lisp pour faire une hélicoïde, il y a une commande native pour ça.

Et la commande balayage ensuite pour faire une extrusion le long de la trajectoire hélicoïdale. ;)

(gile) · le 4 janvier 2012

Salut,

Effectivement les LISP Helicoide et M2S sont devenus obsolètes depuis l'apparition des commandes HELICE, BALAYAGE et LISSAGE, mais Res_Hel est toujours d'actualité (pour les marches, contremarches, balustres).

zapou78 · le 4 janvier 2012

Donc il faudrait en premier temps créer une balustre, une marche, contre-marche et balayer le tout autour du noyau. Je finirais par la main courante pour bien faire?

Qqn aurait-il une vidéo qui explique comment faire?

Merci

Connexion

Solides 3D en colimaçon

Messages recommandés

(gile)

mikL44

mikL44

mikL44

(gile)

mikL44

esbe

(gile)

(gile)

(gile)

(gile)

(gile)

zinc73

(gile)

zinc73

Jeanmimi2

Jeanmimi2

zapou78

zapou78

bryce

(gile)

zapou78

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante