Aller au contenu
Problème de lien d'inscription (résolu ?) ×

Solides 3D en colimaçon

(gile)

Par (gile)
dans Bâtiment

 Partager

Messages recommandés

(gile) Proficient

(gile)

Posté(e)
Posté(e)

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)]

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites
mikL44 Newbie

mikL44

Posté(e)
Posté(e)

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

Lien vers le commentaire
Partager sur d’autres sites
(gile) Proficient

(gile)

Posté(e)
  • Auteur
Posté(e)

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.

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites
(gile) Proficient

(gile)

Posté(e)
  • Auteur
Posté(e)

: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)]

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites
(gile) Proficient

(gile)

Posté(e)
  • Auteur
Posté(e)

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)]

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites
  • 2 mois après...
  • 8 mois après...
(gile) Proficient

(gile)

Posté(e)
  • Auteur
Posté(e)

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.

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites
  • 1 mois après...
  • 4 ans après...
bryce Newbie

bryce

Posté(e)
Posté(e)

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. ;)

Brice, formateur AutoCAD - Inventor - SolidWorks - ZWCad - DraftSight - SketchUp indépendant

Lien vers le commentaire
Partager sur d’autres sites

Créer un compte ou se connecter pour commenter

Vous devez être membre afin de pouvoir déposer un commentaire

Créer un compte

Créez un compte sur notre communauté. C’est facile !

Créer un nouveau compte

Se connecter

Vous avez déjà un compte ? Connectez-vous ici.

Connectez-vous maintenant
 Partager
Aller sur la liste des sujets
×
×
  • Créer...

Information importante

Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer. Politique de confidentialité