Ressort 3D

[gile]

Je ne suis pas sûr que ce soit d'une grande utilité, mais j'ai trouvé, pour ce cas, un moyen de contourner l'impossibilté d'extruder suivant un chemin non plan.

 

Code LISP :

 

;;; Redéfinition de *ERROR*

(defun res_err (msg)
 (if (not (= msg "Fonction annulée"))
   (princ (strcat "\nErreur: " msg))
 )
 (command)
 (command "_ucs" "_restore" "scu_init")
 (command "_ucs" "_del" "scu_init")
 (command "_undo" "_end")
 (REST_VAR)
 (setq	*error*	m:err
m:err nil
 )
 (princ)
)

;;; SAVE_VAR Enregistre la valeur initiale des variables système dans une liste associative

(defun SAVE_VAR (lst)
 (setq varlist (mapcar '(lambda (x) (cons x (getvar x))) lst))
)

;;; REST_VAR Restaure leurs valeurs initiales aux variables système de la liste SAVE_VAR

(defun REST_VAR ()
 (foreach pair	varlist
   (if	(/= (getvar (car pair)) (eval (cdr pair)))
     (setvar (car pair) (eval (cdr pair)))
   )
 )
 (setq varlist nil)
)

;;; ADD_Z Ajoute "val" à la coordonnée Z du point "pt" -accepte les points type (x y)

(defun ADD_Z (pt val)
 (setq pt (trans pt 0 0))
 (list (car pt) (cadr pt) (+ (caddr pt) val))
)

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

;;; CREAT_RESSORT Création du solide

(defun CREAT_RESSORT (sp seg diam bdn pas sens axe / v1	v2 r ang pt1 pt2 pt3 pointA point1 point2 point3 arc
	      cercle boudin)
 (setq	m:err	*error*
*error*	res_err
 )
 (SAVE_VAR '("cmdecho" "osmode"))
 (command "_undo" "_begin")
 (princ "Ressort")
 (setvar "cmdecho" 0)
 (command "_ucs" "_save" "scu_init")
 (setq	r      (- (/ diam 2) (/ bdn 2))
pt2    (polar axe 0 r)
pt1    (polar axe (/ (* 2 pi) seg) r)
ang    (atan (distance pt2 pt1) (/ pas seg))
axe    (ADD_Z axe (- (/ pas (* seg 2))))
boudin (ssadd)
 )
 (if (= sens "Gauche")
   (setq pas (- pas)
  seg (- seg)
   )
 )
 (setvar "osmode" 0)
 (repeat (* sp (abs seg))
   (setq pt1	 pt2
  axe	 (ADD_Z axe (/ pas seg))
  pt2	 (polar axe (+ (angle axe pt1) (/ (* 2 pi) seg)) r)
  pt2	 (ADD_Z pt2 (/ pas (* seg 2)))
  pt3	 (polar axe (+ (angle axe pt1) (/ pi seg)) r)
  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)				    ; Centre de l'ellipse
     (trans point3 0 1)				    ; Extrémité du petit axe
     (/ r (sin ang))				    ; Demie longueur du grand axe
     (trans point1 0 1)				    ; Départ de l'arc
     (trans point2 0 1)				    ; Fin de l'arc
   )
   (setq arc (entlast))
   (command "_ucs" "_new" "x" 90)
   (command "_circle"
     (trans point1 0 1)
     (/ bdn 2)
   )
   (setq cercle (entlast))
   (command "_extrude" cercle "" "_path" arc)
   (ssadd (entlast) boudin)
   (command "_erase" cercle arc "")
   (command "_ucs" "_restore" "scu_init")
 )
 (grtext -2 "Union des segments.")
 (command "union" boudin "")
 (command "_ucs" "_delete" "scu_init")
 (command "_undo" "_end")
 (REST_VAR)
 (setq	*error*	m:err
m:err nil
 )
)

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

;;; C:RESSORT Boite de dialogue

(defun c:ressort (/ dcl_id what_next sp pas sens diam bdn axe)
 (setq dcl_id (load_dialog "ressort.dcl"))
 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "ressort" dcl_id))
     (exit)
   )
   (if	(not *seg_res*)
     (setq *seg_res* 12)
   )
   (foreach n '("nb_seg" "sldr_seg")
     (set_tile n (itoa *seg_res*))
   )
   (if	sp
     (set_tile "nb_sp" (itoa sp))
   )
   (if	pas
     (set_tile "val_pas" (rtos pas))
   )
   (if	diam
     (set_tile "dia_ext" (rtos diam))
   )
   (if	bdn
     (set_tile "dia_bdn" (rtos bdn))
   )
   (if	sens
     (if (equal sens "Droite")
(set_tile "drte" "1")
(set_tile "gche" "1")
     )
   )
   (if	(not axe)
     (setq axe '(0 0 0))
   )
   (set_tile "x_coord" (rtos (car axe)))
   (set_tile "y_coord" (rtos (cadr axe)))
   (set_tile "z_coord" (rtos (caddr axe)))
   (action_tile					   
     "sldr_seg"					
     (strcat						   
"(if (or (= $reason 1) (= $reason 3))"		    
"(progn (set_tile \"nb_seg\" $value)"		 
"(setq *seg_res* (atoi $value))))"		    
     )							   
   )							    
   (action_tile					    
     "nb_seg"						    
     (strcat						    
"(if (or (= $reason 1) (= $reason 2))"		 
"(progn (set_tile \"sldr_seg\" $value)"		   
"(setq *seg_res* (atoi $value))))"		   

     )
   )
   (action_tile "nb_sp" "(setq sp (atoi $value))")	    
   (action_tile "val_pas" "(setq pas (atof $value))")
   (action_tile
     "drte"
     "(if (= (atoi $value) 1) (setq sens \"Droite\"))"
   )
   (action_tile
     "gche"
     "(if (= (atoi $value) 1) (setq sens \"Gauche\"))"
   )
   (action_tile "dia_ext" "(setq diam (atof $value))")
   (action_tile "dia_bdn" "(setq bdn (atof $value))")
   (action_tile
     "x_coord"
     "(setq axe (subst (atof $value) (car axe) axe))"
   )
   (action_tile
     "y_coord"
     "(setq axe (subst (atof $value) (cadr axe) axe))"
   )
   (action_tile
     "z_coord"
     "(setq axe (subst (atof $value) (caddr axe) axe))"
   )
   (action_tile "b_axe" "(done_dialog 3)")		   
   (action_tile
     "accept"
     (strcat
"(cond"						   
"((< *seg_res* 2)"
"(alert \"Le nombre de segments ne peut être inférieur à 2.\")"
"(mode_tile \"nb_seg\" 2))"
"((<= sp 0)"
"(alert \"Le nombre de spires doit être positif et non nul.\")"
"(mode_tile \"nb_sp\" 2))"
"((<= pas 0)"
"(alert \"La valeur du pas doit être positive et non nulle.\")"
"(mode_tile \"val_pas\" 2))"
"((<= diam 0)"
"(alert \"Le diamètre du ressort doit être positif et non nul.\")"
"(mode_tile \"dia_ext\" 2))"
"((<= bdn 0)"
"(alert \"Le diamètre du boudin doit être positif et non nul.\")"
"(mode_tile \"dia_bdn\" 2))"
"((<= diam (* 2 bdn))"
"(alert \"Le diamètre du boudin doit être inférieur au rayon du ressort.\"))"
"((< pas bdn)"
"(alert \"Le diamètre du boudin ne peut être supérieur au pas.\"))"
"(T (done_dialog 1)))"				   
      )
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 3)					    
      (initget 1)
      (setq axe
      (getpoint
	"\nSélectionnez le point à la base du ressort: "
      )
      )
     )
     ((= what_next 1)					  
      (CREAT_RESSORT sp *seg_res* diam bdn pas sens axe)
     )
   )
 )
 (unload_dialog dcl_id)
 (princ)
)

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

;;; C:-RESSORT Ligne de commande

(defun c:-ressort (/ seg sp pas sens diam bdn axe)
 (if (not *seg_res*)
   (setq *seg_res* 12)					    
 )
 (princ "\nEntrez le nombre de segments par spire <")
 (princ *seg_res*)
 (princ ">: ")
 (if (setq seg (getint))
   (setq *seg_res* seg)				   
   (setq seg *seg_res*)				    
 )
 (while (< seg 2)
   (alert
     "Le nombre de segments ne peut être inférieur à 2."
   )
   (setq seg	    (getint "\nEntrez un nouveau nombre de segments: ")
  *seg_res* seg
   )
 )
 (initget 7)
 (setq sp (getint "\nEntrez le nombre de spires: "))
 (initget 7)
 (setq pas (getdist "\nSpécifiez le pas du ressort: "))
 (initget "Droite Gauche")
 (if (not
(setq sens (getkword "\nIndiquez le sens du pas [Droite/Gauche] : "))
     )
   (setq sens "Droite")				   
 )
 (initget 7)
 (setq diam (getdist "\nSpécifiez le diamètre extérieur du ressort: "))
 (initget 7)
 (setq bdn (getdist "\nSpécifiez le diamètre du boudin: "))
 (cond
   ((<= diam (* 2 bdn))
    (alert
      "ERREUR :
      Le rayon du ressort doit être supérieur au diamètre du boudin.
      \nFONCTION ANNULÉE"
    )
    (exit)
   )
   ((< pas bdn)
    (alert
      "ERREUR :
      Le diamètre du boudin ne peut être supérieur au pas.
      \nFONCTION ANNULÉE"
    )
    (exit)
   )
 )
 (initget 1)
 (setq axe (getpoint "\nSpécifiez le point à la base l'axe: "))
 (CREAT_RESSORT sp seg diam bdn pas sens axe)		   
 (princ)
)

 

Code DCL de la boite de dialogue à enregistrer sous "Ressort.dcl" dans le Dossier Support d'ACAD par exemple :

 

//Ressort.dcl
//Boite de dialogue de la fonction Ressort

ressort:dialog{
 label="Ressort";
 initial_focus="nb_sp";
 :column{
   :boxed_column{
     label="Spires";
     :row{
       :edit_box{
         label="Segments par spire :";
         key="nb_seg";
         edit_width=4;
         allow_accept=true;
       }
       :slider{
         key="sldr_seg";
         min_value=2;
         max_value=24;
         big_increment=1;
         small_increment=1;
         width=16;
         is_tab_stop=false;
       } 
     }
     :edit_box{
       label="Nombre de spires (nombre entier) :";
       key="nb_sp";
       edit_width=4;
       allow_accept=true;
     }
   }
   :boxed_row{
     label="Pas du ressort";
     :radio_column{
       :radio_button{
         label="Pas à droite";
         key="drte";
         value="1";
       }
       :radio_button{
         label="Pas à gauche";
         key="gche";
       }
     }
     :edit_box{
       label="Valeur du pas:";
       key="val_pas";
       edit_width=8;
       fixed_width=true;
       allow_accept=true;
     }
   }
   :boxed_column{
     label="Dimensions";
     :edit_box{
       label="Diamètre extérieur du ressort:";
       key="dia_ext";
       edit_width=8;
       allow_accept=true;
     }
     :edit_box{
       label="Diamètre du boudin:";
       key="dia_bdn";
       edit_width=8;
       allow_accept=true;
     }
   }
   :boxed_row{
     label="Base de l'axe";
       :row{
         :retirement_button{
           label="Choisir le point <";
           key="b_axe";
           fixed_width=true;
           alignment=centered;
         }
       }
       :column{
         :edit_box{
           label="X:";
           key="x_coord";
           edit_width=10;
           allow_accept=true;
         }
         :edit_box{
           label="Y:";
           key="y_coord";
           edit_width=10;
           allow_accept=true;
         }
         :edit_box{
           label="Z:";
           key="z_coord";
           edit_width=10;
           allow_accept=true;
         }
       }
     }
   }
   ok_cancel;
 }

 

Et une image pour décrire la fonction.

[Tramber]

tu t'es amusé en programmant ;)

 

L'originalité, c'est de créer des boudins solides.

 

Applause