Création et controle d\'une Pline

[DenisHen]

Salut à tous... Me revoilà ! ! !

 

J'avais des tonnes de boulo et je m'entrainais (seul, pour une fois) au Lisp... J'avance lentement mais surement... Sauf là ;)

 

Voilà, j'aimerais controler le dessin d'un mur. Pour parfaire ma demande, imaginez-vous dessiner un hexagone ( 2 ou 3 mètre d'arrête suffisent) avec un sommet supprimé... On a donc une polyligne ouvert à 5 sommets...

 

Ensuite, on la décale de 20 cm. Comment faire pour dessiner un trait du premier sommet de la polyligne jusqu'au premier de la polyligne décalée... Et commant faire de-même avec le dernier sommet ? ?

 

J'ai trouvé une solution (peut-être) que je ne parviens pas à mettre en oeuvre, mes connaissances en Lisp ne me le permettent pas encore... La voici :

 

Tracer une suite de ligne en les ajoutant à un "(setq LineMur (ssadd))" par exemple.

  (setq p1 (getpoint "\nPremier point du mur : "))
 (setq LineMur (ssadd))
[surligneur] while not p1 (ou un truc dans ce genre, je n'y ai pas encore réfléchi...)[/surligneur] 
 (setq p2 (getpoint p1 "\nPoint suivant : "))
 (command "_.line" p1 p2)
 (setq p1 p2)
 (setq js (ssadd (entlast) LineMur))
[surligneur]Fin du While[/surligneur] 

 

Mais avant le (setq p1 p2) stoker les coordonnées du point dans une liste (ben quoi, c'est du Lisp ? ;) )

 

Puis, à la fin, utiliser les deux premières coordonnées pour en sortir l'angle afin de joindre les deux débuts des polylignes( comme (- (angle p1 p2) angledroit) ou (+ (angle p1 p2) angledroit) selon le coté du décalage).

 

Faire la même chose avec les deux dernières coordonnées pour les deux fins de ces mêmes polylignes...

 

Je n'ai aucune idée de savoir si tous le monde comprend mon brouaha...

 

Pour ceux qui ne cotoient pas les plans topo, il y a deux façons de dessiner un mur :

- toujours 2 traits parallèles symbolisant l'épaisseur

Entre ces deux traits, on peut avoir :

1. soit des hachures,

2. soit une polyligne symbolisant l'axe de ce mur (donc au milieu)...

 

Bon, je pense avoir tout dis...

 

Merci pour vos réponses éventuelles...

 

Denis...

[Bred]

Salut,

je ne pense pas avoir tous compris mais :

 

stoker les coordonnées du point dans une liste

(setq pt (getpoint))
(setq list-pt (append (list pt) list-pt))  

 

 

utiliser les deux premières coordonnées

Soit tu retournes la liste pour récupérer les 2 premières coordonnées qui sont les dernière de la liste :

 (setq lisp-p (reverse list-p))

puis

(setq p1 (car list-pt))
(setq p2 (cadr list-pt)) 

ou

(setq p1 (nth 0 list-pt)) (0 = 1er élément de la liste)
(setq p2 (nth 1 list-pt)) 

 

... soit tu comptes le nombre d'élément dans la liste

(setq nb (length list-pt))

puis tu les récupères :

(setq p1 (nth (- nb 1) list-pt))
(setq p2 (nth (- nb 2) list-pt)) 

ou directement

(setq p1 (nth (- (length list-pt) 1)))

 

(c'est taper à la volée, sans test, et je débutes aussi en lisp, tiens moi au courant si ça ne fonctionne pas)

 

 

 

 

 

 

 

 

[Edité le 29/7/2006 par Bred]

[bonuscad]

Une façon parmis tant d'autres. Celle-ci ferait partie des plus simple !

 

(defun c:mur ( / js pt_end width_wall pt_where)
(setq js (ssadd))
(setvar "cmdecho" 1)
(command "_.pline"
	(while (not (zerop (getvar "cmdactive")))
		(command pause)
	)
)
(setq js (ssadd (entlast) js) pt_end (getvar "lastpoint"))
(initget 3)
(setq width_wall (getreal "\nDonner l'épaisseur du mur '+ à gauche, '- à droite ?: "))
(if (> width_wall 0.0)
	(setq pt_where (polar pt_end (+ (getvar "lastangle") (/ pi 2)) (abs width_wall)))
	(setq pt_where (polar pt_end (- (getvar "lastangle") (/ pi 2)) (abs width_wall)))
)
(setvar "cmdecho" 0)
(command "_.offset" (abs width_wall) (entlast) "_none" pt_where "")
(setq js (ssadd (entlast) js))
(command "_.line" "_none" pt_end "_none" pt_where "")
(setq js (ssadd (entlast) js))
(command "_.pedit" js "_join" js "" "_close" "")
(setvar "cmdecho" 1)
(prin1)
)

 

Tu peux encore l"améliorer ou faire d'une façon différente.

NB: + à gauche par rapport au sens de parcours de la polyligne tracée.

[DenisHen]

Grand bravo à toi BonusCAD ! !

 

C'est quaziment ce qu'il me fallait ! ! !

 

Sauf que les deux petits traits qui relient la polyligne d'origine et le décallée doivent être dans un autre calques. Raison pour laquelle je pensais stocker les XY des points de la Polyligne.

 

Merci encore...

 

Quand à Bred, merci pour tes exemples de code, je ne sais pas gérer les listes ( Grave en LisP ) mais je vais potasser ton post...

 

Merci...

 

Denis...

[DenisHen]

Bon... J'e fouillé la somme de mes connaissances en Lisp (et c'est vite fais)... Puis, grace aux Cadxpiens... J'ai fais ça :

 

(defun c:phMur (Typ / p1 p2 p3 p4 p1b p4b rot1 rot2) ; Je ne pense pas en avoir oublié...
;;;Typ = Type de mur : B=Bahu (axe)    P=Plein (hachures)
 (setq jspoly (ssadd))
 (princ "\nDessinez le mur :")
 (command "_.pline"
          (while (not (zerop (getvar "cmdactive")))
            (command pause)
          ) ;_ Fin de while
 ) ;_ Fin de command
 (setq jspoly (ssadd (entlast) jspoly))
 (setq AcroObjet (getvar "OSMODE"))
 (setvar "OSMODE" 0)
 (setq ename (ssname jspoly 0))
 (getVertices ename)
 (setq Epais (atof (getstring "\nÉpaisseur du mur (avec signe) :")))
 (setq p1 (car return)
       p2 (cadr return)
       p3 (nth (- (length return) 2) return)
       p4 (last return)
 ) ;_ Fin de setq
 (setq p1b (polar p1 (- (angle p1 p2) (/ pi 2)) Epais))
 (setq p4b (polar p4 (- (angle p3 p4) (/ pi 2)) Epais))
 (if (<= (- 500 (* 200 (/ (angle p1 p2) pi))) 400)
   (- (- 500 (* 200 (/ (angle p1 p2) pi))) 400)
   (- 500 (* 200 (/ (angle p1 p2) pi)))
 ) ;_ Fin de if
 (if (<= (- 500 (* 200 (/ (angle p3 p4) pi))) 400)
   (- (- 500 (* 200 (/ (angle p3 p4) pi))) 400)
   (- 500 (* 200 (/ (angle p3 p4) pi)))
 ) ;_ Fin de if
 (if (equal Typ "B")
     (command "_.offset" (/ (abs Epais) 2) p1 p1b "")
 ) ;_ Fin de if  
 (command "_.offset" (abs Epais) jspoly p1b "")
 (setq jspoly (ssadd (entlast) jspoly))
 (command "_.line" p1 p1b "")
 (setq jspoly (ssadd (entlast) jspoly))
 (initget 1 "Oui Non")
 (setq Debut (getstring "Début du mur fermé ?"))
 (command "_.line" p4 p4b "")
 (setq jspoly (ssadd (entlast) jspoly))
 (initget 1 "Oui Non")
 (setq Fin (getstring "Fin du mur fermée ?"))
 (cond ((or (= Fin "n") (= Fin "N"))
        (command "_chprop" "d" "" "ca" "Titre Cache" "")
       )
 ) ;_ Fin de cond
 (if (equal Typ "P")
     (command "_.hatch" "ANSI31" "2" (+ rot1 50) jspoly "")
 ) ;_ Fin de if
 (setvar "OSMODE" AcroObjet)
 (princ)
)

 

 

(defun getVertices (ename / plineGet vertex vertexGet)
 (setq return nil)
 (cond
   ((or (/= (type ename) 'ENAME) (not (setq plineGet (entget ename)))) (setq return nil))
   ((= "POLYLINE" (cdr (assoc 0 plineGet)))
    (setq vertex (entnext ename))
    (while (= "VERTEX" (cdr (assoc 0 (setq vertexGet (entget vertex)))))
      (setq return (cons (cdr (assoc 10 vertexGet)) return))
      (setq vertex (entnext vertex))
    ) ;_ Fin de while
    (setq return (reverse return))
   )
   ((= "LWPOLYLINE" (cdr (assoc 0 plineGet)))
    (setq return (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) plineGet)))
   )
   (t (setq return nil))
 ) ;_ Fin de cond
) ;_ Fin de defun

 

Bon, faut vérifier les parenthèses, car j'ai enlevé destruc qui ne servent qu'à moi et qui poluraient la routines pour que d'autres l'utilisent...

 

On voit ici très bien que je ne "maitrise" pas encore le Lisp... Et encore moins les (getstring... et les (initget...

 

Merci à tous pour votre aide... Elle m'a été précieuse pour cette routine.

 

Tu as vu (gile) ? J'ai déclaré mes symboles... ;)

 

Denis...

[DenisHen]

Désolé ! !

 

remplacer :

(if (<= (- 500 (* 200 (/ (angle p1 p2) pi))) 400)

(- (- 500 (* 200 (/ (angle p1 p2) pi))) 400)

(- 500 (* 200 (/ (angle p1 p2) pi)))

) ;_ Fin de if

(if (<= (- 500 (* 200 (/ (angle p3 p4) pi))) 400)

(- (- 500 (* 200 (/ (angle p3 p4) pi))) 400)

(- 500 (* 200 (/ (angle p3 p4) pi)))

) ;_ Fin de if

 

par :

  (if (<= (- 500 (* 200 (/ (angle p1 p2) pi))) 400)
   (setq rot1 (- (- 500 (* 200 (/ (angle p1 p2) pi))) 400))
   (setq rot1 (- 500 (* 200 (/ (angle p1 p2) pi))))
 ) ;_ Fin de if
 (if (<= (- 500 (* 200 (/ (angle p3 p4) pi))) 400)
   (setq rot2 (- (- 500 (* 200 (/ (angle p3 p4) pi))) 400))
   (setq rot2 (- 500 (* 200 (/ (angle p3 p4) pi))))
 ) ;_ Fin de if

 

Mille excuses...

[(gile)]

Juste comme ça, en vitesse :

 

(setq Epais (atof (getstring "\nÉpaisseur du mur (avec signe) :")))

Plutôt que récupérer une chaine pour la transformer en réel, regarde du côté de getreal ou getdist

 

(initget 1 "Oui Non")

(setq Debut (getstring "Début du mur fermé ?"))

Si tu veux récupérer Oui ou Non, regarde du côté de getkword (l'utilisateur pourra répondre seulement O ou N)

 

(if (

(setq rot1 (- (- 500 (* 200 (/ (angle p1 p2) pi))) 400))

(setq rot1 (- 500 (* 200 (/ (angle p1 p2) pi))))

)

Ainsi, ta routine ne fonctionne que si l'utilisateur travaille en radians. Pour plus de polyvalence (je pense ne pas être le seul à utiliser les degrés), je pense qu'il est préférable de faire tous les calculs et comparaisons en radians, et de ne convertir dans l'unité angulaire courante que quand c'est nécessaire : lors de l'utilisation de (command ...).

La fonction angtos, qui transforme un angle en radians en une chaine dans l'unité courante (ou spécifiée) peut être utilisée puisque (command ...) accepte les arguments numéraires sous forme de chaine ou de nombre.

 

(if ((setq rot1 (- (- (* 2.5 pi) (angle p1 p2)) (* 2 pi)))
(setq rot1 (- (* 2.5 pi) (angle p1 p2)))
)
;; puis après
(command "_.hatch" "ANSI31" "2" [surligneur](angtos (+ rot1 (/ pi 2)))[/surligneur] jspoly "")

 

Pour l'utilisation de angtos tu peux (re)voir ici ou un peu plus loin là

 

 

[Edité le 19/10/2006 par (gile)]

[DenisHen]

J'ai déjà essayé avec (getreal... Mais il n'accepte pas de valeur négative...

Je regarde en ce moment un poste de (gile) (tu connais ? ;) qui en traite pour une autre routine que je fais en ce moment même ! ! :

(while (= (caddr p1) (caddr p1b))
 (if (not (setq p1b
                 (getpoint "\n Spécifiez le second point ou < distance >: "
                 ) ;_ Fin de getpoint
          ) ;_ Fin de setq
     ) ;_ Fin de not
   (setq dist (getdist p1 "\nSpécifiez la distance: ")
         p2  (list (car p1) (cadr p1) (+ (caddr p1) dist))
   ) ;_ Fin de setq
   (setq p2 (list (car p1) (cadr p1) (caddr p2))
   ) ;_ Fin de setq
 ) ;_ Fin de if
)

Pour le (initget 1 "Oui Non"), je suis en train de voir ça sérieusement en fouillant dans les forums... Car l'aide est en Anglais, et je pèche en thermes techniques...

 

Je commence à développer des routines avec des interventions de l'utilisateur...

 

Je travaille en grades (comme ts les géomètres)

 

Mais je crois que "(angle p1 p2)" est calculé par AutoCAD en radians

 

Puis je le converti en grades "(* 200 (/ (angle p1 p2) pi))"

 

et le (if... vérifie si l'angle est bien dans le cadrans, même si je pense que ça ne sert à rien...

 

au sujet d'(angtos... ce truc a eut raison de mon courage... malgrés toutes les lectures des forums en traitant, j'ai laissé tombé (angtos.... Je n'y arrive tous simplement pas...

 

Plustard, peut-être... (pour avis, je suis en grades, sens horaire, 0 zénithal)

 

Merci encore pour tout ! ! !

 

Eh, t'as vu, j'ai bien appris mes leçons, non ? ;)

 

Denis...

 

[(gile)]

J'ai déjà essayé avec (getreal... Mais il n'accepte pas de valeur négative...

 

Tu confonds avec getdist (une distance est toujours positve)

 

Pour angtos, encore une fois fais des essais à la console VisualLISP (ou à la ligne de commande)

 

(angtos pi) -> ?

(angtos (/ pi 2)) -> ?

(angtos (* pi 2)) -> ?

pour plus de précision (14 décimales)

dans l'unité angulaire courante :

(angtos pi (getvar "AUNITS") 14) -> ?

en degrés décimaux :

(angtos pi 0 14) -> ?

en grades :

(angtos pi 2 14) -> ?

 

 

[Edité le 19/10/2006 par (gile)]

[DenisHen]

Merci à toi (gile)...

 

Mais j'oublie toujours d'utiliser la console de cette façon...

 

Merci encore,

 

Denis...

[DenisHen]

Bon, ça fait une plombe que je me casse la tête avec les (angtos dans tous les sens...

 

Je clique 2 points, p1 et p2, respectivement x=1,y=1 et x=2,y=1.

 

Pourquoi, (angle p1 p2) me donne 0, alors que l'origine des y est au nord et que je tourne dans le sens horaire...

 

Si p3 (x=2, y=1) (angle p1 p3) me donne 90... C'est là qu'il devrait me dire 0 ! !

 

Pffffff.... I m'énerve ! ! ! ;)

 

SOS ! !

 

Denis...

 

 

[(gile)]

C'est pas angtos, c'est tes réglages de géomètre qui te fourvoient.

 

La fonction LISP angle ne tient pas compte des variables ANGBASE et ANGDIR, par contre angtos en tient compte.

 

Avec tes réglages :

 

(setq p1 '(0 0) p2 '(1 0) p3 '(0 1))

 

(angle p1 p2) -> 0.0

(angle p1 p3) -> 1.5708

(angtos (angle p1 p2)) -> "100.00g"

(angtos (angle p1 p3)) -> "0.00g"

 

Dans le même esprit getangle tient compte des variable ANGBASE et ANGDIR, getorient n'en tient pas compte.

[DenisHen]

Pfff, je ne m'en sort pas.... :( :(

 

J'ai ça, pour faire une rotation du plan en restant dans le SCU général :

........
;arrivé ici, je suis déjà dans mon système :
;origine des Y au nord, sens horaire et en grades
(setq p1 (getpoint "\nPoint de départ : "))
 (setq VOrtho (getvar "orthomode"))
 (setvar "orthomode" 0)
 (setq AngScu (getangle p1 (strcat "\nDirection des X :")))
 (princ "\nAngScu :")
 (princ AngScu)
 (princ "\nOrientation : ")
 (setq AngScu (angtof (angle p1 p2)))
 (setq p3 (polar p1 (- AngScu 100) 1000))
 (vlax-ldata-put "Phalene" "AngSCU" AngScu)
 (command "_ucs" "_z" p1 p3)
 (command "_plan" "courant")
 (command "_ucs" "_w")
........

Mais il n'y a rien qui marche ! ! :(

 

SMS ! ! (Save My Soul) ! !

 

Denis... ( qui va se coucher en pleurant :( )

[DenisHen]

Bon, de toutes façons, il faut que je refasse toutes mes routines... J'en ai de trop avec des phrases communes... comme :

(if (= (setq rot (getangle p2 (strcat "\nOrientation du texte :"))) nil)
   (progn (princ "\n * * * * * * * Orientation horizontale\n")
          (setq rot (vlax-ldata-get "Phalene" "AngSCU"))
   ) ;_ Fin de progn
   (progn (princ "\n * * * * * * * Orientation alignée :")
          [surligneur] (setq rot (atof (angtos rot 2 2)))[/surligneur]
   ) ;_ Fin de progn
 )

Que j'utilise dans 40% des mes routines...:casstet:

 

Mais il faut bien réfléchir...p2, dois être connu et rot dois retourner une valeur dans la routine d'appel...

 

Je croix que j'ai résolu mon [surligneur] problème d'angle...[/surligneur] ;)

 

J'ai du boulo ! ! ! :(

 

Denis...