Fonction Repeat ?

[>>NicoM]

Bonjour,

 

Je travail actuellement sur mon tout premier LISP qui me sert d'exercice en quelque sorte.

 

Voici le code actuel :

;mémorisation puis désactivation des accrochages objet
(setq old-osmode (getvar "osmode"))
(setvar "osmode" 0)

; définition des variables de base à saisir par l'utilisateur
(initget (+ 1 2 4))
(setq dim_x (getint "\nLongueur du poteau (X) ?\n")
     dim_y (getint "\nLargeur du poteau (Y) ?\n")
     )
(initget "Forcé Automatique")
(setq choix (getkword "\nNombre d'aciers sur la longueur (X) ? [Forcé/Automatique] : <Automatique>\n"))
(cond ((= choix "F") (setq nb_x (getint "\nNombre d'aciers forcé (X) ?\n")))
     (T (setq nb_x (/ dim_x 10)))
     )
(setq choix (getkword "\nNombre d'aciers sur la largeur (Y) ? [Forcé/Automatique] : <Automatique>\n"))
(cond ((= choix "F") (setq nb_y (getint "\nNombre d'aciers forcé (Y) ?\n")))
     (T (setq nb_y (/ dim_y 10)))
     )
(initget "6 8 10 12 14 16 20 25 32 40")
(setq choix (getkword "\nSection des aciers verticaux ? [6/8/10/12/14/16/20/25/32/40] : <14>\n"))
(cond ((= choix "6") (setq Sv 6 Svr 7 Rmv 3.0))
     ((= choix "8") (setq Sv 8 Svr 9 Rmv 4.0))
     ((= choix "10") (setq Sv 10 Svr 11 Rmv 5.0))
     ((= choix "12") (setq Sv 12 Svr 13 Rmv 6.0))
     ((= choix "16") (setq Sv 16 Svr 18 Rmv 8.0))
     ((= choix "20") (setq Sv 20 Svr 22 Rmv 10.0))
     ((= choix "25") (setq Sv 25 Svr 28 Rmv 12.0))
     ((= choix "32") (setq Sv 32 Svr 35 Rmv 16.0))
     ((= choix "40") (setq Sv 40 Svr 45 Rmv 20.0))
     (T (setq Sv 14 Svr 15 Rmv 7.0))
     )
(setq choix (getkword "\nSection des aciers transversaux ? [6/8/10/12/14/16/20/25/32/40] : <8>\n"))
(cond ((= choix "6") (setq St 6 Str 7 Rmt 1.5))
     ((= choix "10") (setq St 10 Str 11 Rmt 2.5))
     ((= choix "12") (setq St 12 Str 13 Rmt 3.0))
     ((= choix "14") (setq St 12 Str 13 Rmt 3.5))      
     ((= choix "16") (setq St 16 Str 18 Rmt 4.0))
     ((= choix "20") (setq St 20 Str 22 Rmt 5.0))
     ((= choix "25") (setq St 25 Str 28 Rmt 6.0))
     ((= choix "32") (setq St 32 Str 35 Rmt 8.0))
     ((= choix "40") (setq St 40 Str 45 Rmt 10.0))
     (T (setq St 8 Str 9 Rmt 2.0))
     )
(initget (+ 1 2 4))
(setq esp_1 (getint "\nEspacement des cadres ?\n")
     )
(initget 0)

; définition des coordonées des points de construction du poteau
(setq p10 (getpoint "\Point de base du poteau ?\n")
     p11 (list (+ (car p10) ev) (+ (cadr p10) ev))
     p12 (list (+ (car p11) Rmt) (+ (cadr p11) Rmt))
     p20 (list (car p10) (+ (cadr p10) dim_y))
     p21 (list (+ (car p20) ev) (- (cadr p20) ev))
     p22 (list (+ (car p21) Rmt) (- (cadr p21) Rmt))
     p30 (list (+ (car p10) dim_x) (+ (cadr p10) dim_y))
     p31 (list (- (car p30) ev) (- (cadr p30) ev))
     p32 (list (- (car p31) Rmt) (- (cadr p31) Rmt))
     p40 (list (+ (car p10) dim_x) (cadr p10))
     p41 (list (- (car p40) ev) (+ (cadr p40) ev))
     p42 (list (- (car p41) Rmt) (+ (cadr p41) Rmt))
     )

; dessin des rectangles
(command "_rectang" p10 p30 "")
(command "_rectang" p11 p31 "")
(command "_rectang" p12 p32 "")

; calcul des points intermédiaires
(setq d1242 (- (car p42) (car p12))
     esp_x (/ d1242 (- nb_x 1))
     nb_x_int (- nb_x 2))
(repeat nb_x_int ;...???

; remise en état initial des accrochages objet
(setvar "osmode" old-osmode)
      

 

J'ai un point de blocage sur la fonction repeat... je ne sais pas du tout comment l'écrire.

Mon but est le suivant:

J'aimerais calculer et extraire les coordonnées d'un nombre de point variable et espacés régulièrement.

Voici un exemple ci-dessous:

 

Comment faire pour définir le bon nombre de variable (p101 p102 p10x ...) en incrémentant leur nom ?

Comment faire pour repartir des coordonnées du point précédemment calculé pour y ajouter la valeur "esp_x" ?

La fonction repeat est-elle la bonne solution ?

 

Je suis sur que vous avez une solution magique dans votre sac ! :D

[>>NicoM]

En essayant de trouver une solution je suis parti la dessus :

(cond ((= nb_x_int 1) (setq px1 (list (+ (car p12) esp_x) (cadr p12))))
     ((= nb_x_int 2) (setq px1 (list (+ (car p12) esp_x) (cadr p12))
		    px2 (list (+ (car px1) esp_x) (cadr p12))))
     ((= nb_x_int 3) (setq px1 (list (+ (car p12) esp_x) (cadr p12))
		    px2 (list (+ (car px1) esp_x) (cadr p12))
		    px3 (list (+ (car px2) esp_x) (cadr p12))))
     ((= nb_x_int 4) (setq px1 (list (+ (car p12) esp_x) (cadr p12))
		    px2 (list (+ (car px1) esp_x) (cadr p12))
		    px3 (list (+ (car px2) esp_x) (cadr p12))
		    px4 (list (+ (car px3) esp_x) (cadr p12))))
     ((= nb_x_int 5) (setq px1 (list (+ (car p12) esp_x) (cadr p12))
		    px2 (list (+ (car px1) esp_x) (cadr p12))
		    px3 (list (+ (car px2) esp_x) (cadr p12))
		    px4 (list (+ (car px3) esp_x) (cadr p12))
		    px5 (list (+ (car px4) esp_x) (cadr p12))))
     ((= nb_x_int 6) (setq px1 (list (+ (car p12) esp_x) (cadr p12))
		    px2 (list (+ (car px1) esp_x) (cadr p12))
		    px3 (list (+ (car px2) esp_x) (cadr p12))
		    px4 (list (+ (car px3) esp_x) (cadr p12))
		    px5 (list (+ (car px4) esp_x) (cadr p12))
		    px6 (list (+ (car px5) esp_x) (cadr p12))))
     )

 

Ca fonctionne mais niveau programmation je pense que c'est vraiment pas terrible comme façon de faire !

[didier]

Coucou

 

Pour un débutant tu as compris les car et les cdr...

Je te propose ceci dans le message suivant car ma mise en page ne supporte pas les codes.

 

L'esprit c'est

Choisir une droite

Demander le nombre de points

Calculer la longueur et la diviser par le nombre de points pour obtenir l'équidistance entre ces points

Il ne reste qu'à partir du point de départ et répéter autant de fois que le nombre de points choisi le dessin d'une entité POINT à une distance incrémentée dans la direction de la droite

 

Suis-je clair ?

Je reste à ta disposition pour éclaircissement...

Amicalement

[didier]

(defun c:Nicom ( / ent p1 p2 lon dir nbpt ecart n)
 (setq ent (car(entsel "\nChoix de la droite\n")))
 (setq p1 (cdr (assoc 10 (entget ent)))
       	p2 (cdr (assoc 11 (entget ent)))
       	lon (distance p1 p2)
  		dir (angle p1 p2))

(setq nbpt (getint "\nNombre de points\n"))(setq ecart (/ lon nbpt))
(setq n 1)
(repeat nbpt
  (command "_point" (polar p1 dir (* ecart n)))(setq n (1+ n)))
);fin de defun 

[>>NicoM]

Merci beaucoup !

C'est très clair oui, j'ai analysé le code et j'ai bien compris le fonctionnement.

 

Ca m'a permis de me rendre compte que je n'avais pas besoin de stocker les coordonnées de ces points intermédiaires, il suffit que j'applique toutes les commandes (le "point" dans ton exemple) dont j'ai besoin à l'intérieur de la fonction repeat.

 

Concrètement je cherche à insérer des blocs dynamiques à chacun de ces point, et si possible leur attribuer une valeur aux paramètres personnalisés.

 

Pour ce dernier point il est peut être préférable que je fasse un nouveau sujet. On s'éloigne un peu de l'idée de départ.

[didier]

Coucou

 

Je suis content d'avoir été utile.

 

Bonne continuation dans tes tests

Tu peux compter sur nous pour te dépatouiller

 

Amicalement

 

[>>NicoM]

Par contre je vais essayer d'utiliser d'ores et déjà la commande qui est plus programmatiquement correct, ENTMAKE, pour créer les entités.

J'ai chercher un peu sur ton site mais je n'ai pas réussi à trouver la liste des codes DXF permettant de cibler les paramètres à modifier.