[Résolu] Remise à zéro de la largeur des polylignes

Karmelie · le 16 novembre 2011

Je débute en lsp et je me suis essayée à faire une nouvelle commande en me basant sur des .lsp que nous possédons déjà.

Habituellement, nos largeurs des lignes sont gérées par les calques (propriétés "DuCalque") et toutes les polylignes ont une largeur de segment de 0.0

J'ai une demande pour "voir" la vraie largeur des lignes à l'écran i.e. donner une largeur aux polylignes.

Nous avons déjà des fichiers .TXT (ListeCalques.txt) contenant les calques et leurs propriétés sous la forme:

Calque LT CO LW TR TXT HTXT

Ces fichiers sont lus par une commande (LECTURE) chargée dans le fichier .MNL d'un menu entreprise.

Les calques sont créés à demande par la commande (CREATION_CALQUE) elle aussi chargée dans le fichier .mnl

Ma nouvelle commande que j'ai nommée PLINE_LSEG trace un polyligne sur un calque spécifié ex: (pline_lseg "bordure") en assignant la valeur de l'épaisseur de trait (LW) du calque lue dans ListeCalques.txt à la largeur des segments du polyligne à tracer.

Le polyligne est tracé correctement, mais je n'arrive pas à remette la variable PLINEWID à 0 après avoir tracé le polyligne. J'ai essayé (commande…..) (setvar…..) Qu'est-ce qui cloche dans ma routine?

(defun PLINE_LSEG
		(		;Arguments:
	     CALQUE		;Nom du calque spécifié dans la commande
	     /		;Variables locales:
	     INFO		;Données extraites de la liste des calques
	     La_SEGM	;  Largeur du segment extraite de la liste des calques = Epaisseur du calque
	     PTDEP		;Début du polyligne
                         )		;fin arguments


 (setq INFO (assoc CALQUE ListeCalques))  ;; Recherche du calque dans la liste des calques 
 (setq La_SEGM (atof (nth 3 INFO)))   	;; Capte l'épaisseur du calque
 (setvar "plinewid" La_SEGM)              ;; Assigne l'épaisseur du calque à la largeur de segment du pline
 (CREATION_CALQUE)  		     ;; Création du calque 
 (setq PTDEP (GETPOINT "\nDébut de la ligne?..."))
 (command "_pline" PTDEP)             	;; Trace la pline
 (setvar "plinewid" 0)	              ;; Remise à zéro de la largeur des polylignes
 (princ)
)				     ;;fin du defun

Tramber · le 16 novembre 2011

(defun PLINE_LSEG
                       (               ;Arguments:
                        CALQUE         ;Nom du calque spécifié dans la commande
                        /              ;Variables locales:
                        INFO           ;Données extraites de la liste des calques
                        La_SEGM        ;  Largeur du segment extraite de la liste des calques = Epaisseur du calque
                        PTDEP          ;Début du polyligne
                         )             ;fin arguments


 (setq INFO (assoc CALQUE ListeCalques))  ;; Recherche du calque dans la liste des calques 
 (setq La_SEGM (atof (nth 3 INFO)))       ;; Capte l'épaisseur du calque
 (setq *plinewid*(getvar "plinewid"))
 (setvar "plinewid" La_SEGM)              ;; Assigne l'épaisseur du calque à la largeur de segment du pline
 (CREATION_CALQUE)                      ;; Création du calque 
 (setq PTDEP (GETPOINT "\nDébut de la ligne?..."))
 (command "_pline" PTDEP)                 ;; Trace la pline
 (setvar "plinewid" *plinewid*)                  ;; Remise à zéro de la largeur des polylignes
 (princ)
)

Eh voilà, une petite variable (à déclarer dans les locales....) permet ce petit passe-passe.

Nous avons l'habitude ici et là d'entourer le nom par 2 *, un nom de variable comme un autre.

Tuas vu c'est tout simple ?

Karmelie · le 16 novembre 2011

Merci!

(setq *plinewid*(getvar "plinewid"))

mais si la variable plinewid n'est pas à 0 avant l'exécution?

bryce · le 16 novembre 2011

Bonsoir,

(setvar "plinewid" 0)

fait l'affaire pour remettre la largeur à 0, le problème doit venir d'ailleurs.

Je ne comprends pas comment la polyligne peut être tracée correctement en ne donnant qu'un point de départ...

(command "_pline" PTDEP)

:unsure:

Tramber · le 16 novembre 2011

mais si la variable plinewid n'est pas à 0 avant l'exécution?

Ton but n'est-il pas justement de l'enregistrer, de faire ta petite affaire et enfin de la restituer ?

*plinewid* enregistrera sa valeur et l'offrira à restituer à la finsauf si erreur (à ce stade).

Carboleum · le 17 novembre 2011

Comme l'a remarqué Bryce, le problème vient du fait que tu ne sors pas correctement de la commande "pline".


(setvar "plinewid" qqch)

(command "pline" (setq p (getpoint "\nFirst :")))
(while (setvar "cmdactive") (command (setq p (getpoint "\nNext :" p)))) ; tant que la commande pline est active, la routine attend un point
(command "") ; ici on sort de la commande pline

(setvar "plinewid" 0)

Après il y a la gestion des erreurs, mais ca c'est une autre histoire ;-)

Karmelie · le 17 novembre 2011

OK, je comprends de principe, mais si j'exécute uniquement:

(command "pline" (setq p (getpoint "\nFirst :")))
(while (setvar "cmdactive") (command (setq p (getpoint "\nNext :" p)))) ; tant que la commande pline est active, la routine attend un point
(command "") ; ici on sort de la commande pline

J'ai le message:

nil

; erreur: nombre d'arguments insuffisants :(

didier · le 17 novembre 2011

coucou

on dirait qu'il y a confusion dans les réponses

qu'est-ce que tu veux faire en finalité ?

que les polylignes présentes sur un calque s'épaississent

d'une valeur trouvée dans le nom du calque ?

ou bien, dessiner des polylignes d'une certaine

épaisseur en fonction du calque courant ?

merci de clarifier pour que les réponses soient en rapport.

amicalement

Carboleum · le 17 novembre 2011

OK, je comprends de principe, mais si j'exécute uniquement:
(command "pline" (setq p (getpoint "\nFirst :")))
(while (setvar "cmdactive") (command (setq p (getpoint "\nNext :" p)))) ; tant que la commande pline est active, la routine attend un point
(command "") ; ici on sort de la commande pline
J'ai le message:
nil
; erreur: nombre d'arguments insuffisants :(

ok au temps pour moi. remplaces setvar par getvar -> (getvar "cmdactive")

et comme t'es en français, ajoute un _ devant le pline -> (command "_pline")

Karmelie · le 17 novembre 2011

Bonjour Didier,

qu'est-ce que tu veux faire en finalité ?
que les polylignes présentes sur un calque s'épaississent
d'une valeur trouvée dans le nom du calque ?

ou bien, dessiner des polylignes d'une certaine
épaisseur en fonction du calque courant ?

En réalité, j'aurai à faire les deux!

Mais pour ce post, c'est uniquement pour dessiner des plines... tel que mentionné sur le premier post:

Ma nouvelle commande que j'ai nommée PLINE_LSEG trace un polyligne sur un calque spécifié ex: (pline_lseg "bordure") en assignant la valeur de l'épaisseur de trait (LW) du calque lue dans ListeCalques.txt à la largeur des segments du polyligne à tracer.

L'autre option sera pour plus tard. Avec mes habilités en lsp, il est préférable que je garde de focus. Merci à toi.

Carboleum: Merci, je teste

Karmelie · le 17 novembre 2011

Bonjour,

Maintenant le pline se trace sur le bon calque avec la bonne largeur mais:

1. Le bouton droit termine automatiquement la commande et j'ai le message

"erreur: type d'argument incorrect: point: nil"

2. Je n'ai pas accès au bouton droit pour les options du pline (arc... etc.)

3. La largeur du pline n'est toujours pas remise à zéro par

(setvar "plinewid" 0)

Parce que la commande pline ne se termine pas correctement? (post #6)

Mon code ressemble à ceci maintenant:

(defun PLINE_LSEG
		(		;Arguments:
		 CALQUE		;  Nom du calque spécifié dans la commande
		 /		;Variables locales:
		 INFO		;  Données extraites de la liste des calques
		 La_SEGM	;  Largeur du segment extraite de la liste des calques = Epaisseur du calque
		 PTDEP		;  Début du polyligne
                       )		;fin arguments

 (setq INFO (assoc CALQUE ListeCalques))  	;; Recherche du calque dans la liste des calques normalisés
 (setq La_SEGM (atof (nth 3 INFO)))       	;; Capte l'épaisseur du calque
 (setvar "plinewid" La_SEGM)              	;; Assigne l'épaisseur du calque à la largeur de segment du pline
 (CREATION_CALQUE)  			  	;; Création du calque 
 (command "_pline" (setq p (getpoint "\nDébut de la ligne: "))) 
 (while (getvar "cmdactive")
   (command (setq p (getpoint "\nPoint suivant :" p)))
 )						;; tant que la commande pline est active, la routine attend un point 
 (command "") 					;; ici on sort de la commande pline 
 (setvar "plinewid" 0)		     	 	;; Remise à zéro de la largeur des polylignes
 (princ)
)					   	;;fin du defun

didier · le 17 novembre 2011

coucou

c'est parce que tu ne sors pas du programme de façon "propre"

regarde la gestion des erreurs

je vois que tu y mets du tien, donc si ne trouves pas seule on viendra t'aider

une piste

*error*

amicalement

Karmelie · le 17 novembre 2011

Bonjour Didier,

La gestion des erreurs...! :wacko:

Je n'y échapperai pas. J'aimerais bien trouver une explication claire qui fasse en sorte que je comprenne le principe une fois pour toute.

Alors, je cherche....

avant de revenir vous supplier à genoux de me porter secours :(

bryce · le 17 novembre 2011

Bonsoir,

Tu peux essayer comme ceci, avec une gestion d'erreurs basique:

(defun PLINE_LSEG
                       (               ;Arguments:
                        CALQUE         ;  Nom du calque spécifié dans la commande
                        /              ;Variables locales:
                        INFO           ;  Données extraites de la liste des calques
                        La_SEGM        ;  Largeur du segment extraite de la liste des calques = Epaisseur du calque
                        PTDEP          ;  Début du polyligne
                        *error*
                       )               ;fin arguments
 (defun *error*(msg / )
   (setvar "plinewid" 0)
 )
 (setq INFO (assoc CALQUE ListeCalques))       ;; Recherche du calque dans la liste des calques normalisés
 (setq La_SEGM (atof (nth 3 INFO)))            ;; Capte l'épaisseur du calque
 (setvar "plinewid" La_SEGM)                   ;; Assigne l'épaisseur du calque à la largeur de segment du pline
 (CREATION_CALQUE)                             ;; Création du calque 
 (command "_pline" (setq p (getpoint "\nDébut de la ligne: "))) 
 (while (> (getvar "cmdactive") 0)
   (command pause)
 )                                            ;; tant que la commande pline est active, la routine attend une entrée de l'utilisateur 
 (setvar "plinewid" 0)                        ;; Remise à zéro de la largeur des polylignes
 (princ)
)

le setq p ne sert à rien a priori, je l'ai laissé car tu utilises peut-être la variable p ailleurs...

Carboleum · le 17 novembre 2011

Ben ca avance, non?! ;)

J'ai une bonne nouvelle pour toi:

si tu fais ceci, tu garderas les options de la commande pline

(setvar ...)
(command "pline")
(while (/= 0 (getvar "cmdactive")) (command pause))
(setvar ...)

à ce propos, il y avait une erreur dans mon code précédent:

(while (getvar "cmdactive") ...) ne s’arrête jamais car (getvar "cmdactive") renvoie soit 1 soit 0 et jamais nil!

pour les error, le principe est de redéfinir la fonction *error*. Cette fonction est appelée dès l'interpréteur Lisp rencontre une erreur. Il suffit de redéfinir la fonction *error* avec (setvat "épaisseur polyline" 0)

/!\ Il s'agit d'une erreur liée à ta fonction et DOIT être locale à ta fonction.

Le schéma est le suivant:

(defun ma_fonction (arg1 arg2 / var1 var2 *error*) ; /!\ *error* DOIT être locale /!\

  ; gestion des erreurs
  (defun *error* (msg) (setvar "épaisseur polyline" 0) (print msg))

  ; gestion de l'environnement de travail
  (setvar "épaisseur polyline" épaisseur_choisie)
  
  (command ....) ; la fonction proprement dite
  (while ....)

  ; retour à l'environnement initial
  (setvar "épaisseur polyline" 0)
)

Il existe des structures

(defun my_error ...)
(defun my_function ()
  (setq *olderror* *error* *error* my_error)
  .....
  (setq *error* *olderror*)
)

mais je trouve ca un peu lourd.

edit: Bryce a été plus rapide que moi ;-)

Karmelie · le 17 novembre 2011

Bonjour,

En effet, les nouvelles sont bonnes. Merci à tous les 2.

J'ai trouvé un post de VDH_Bruno sur la gestion des erreurs suffisamment bien expliqué pour que je me risque à en faire un. C'était presque terminé lorsque les 2 derniers posts sont arrivés.

Je crois que j'en était à faire ça compliqué pour rien....mais peut-être pas tant que ça!

Je "digère" les nouvelles informations et je vous reviendrai. (avec des questions ou qqchose de "fini").

Carboleum · le 17 novembre 2011

J'ai trouvé un post de VDH_Bruno

Peux-tu mettre un lien d'ici vers ce post ?

Karmelie · le 17 novembre 2011

Bonjour,

Il est ici

Et voici ce que j'ai fait:

;;; Gestion des erreurs 

defun C:UN_var (/ U_cmdecho U_osmode U_clayer U_polar N_cecolor N_celtype N_celw N_plinewid N_Transp U_svar N_svar Rest_var *error*) 


 ;; Sauvegarde variables Usager  
  (defun U_svar ()
      (setq  
          U_cmdecho (setvar "cmdecho" 0) 
          U_osmode  (getvar "osmode")
   U_clayer  (getvar "clayer")
   U_polar   (getvar "polarmode")
); setq
    ) ;defun

 ;; Sauvegarde variables Normalisées
  (defun N_svar ()
      (setq
          N_cecolor   (setvar "cecolor" "bylayer")
   N_celtype   (setvar "celtype" "bylayer")
   N_celw      (setvar "celweight" -1)
   N_plinewid  (setvar "plinewid" 0)
   N_Transp    (setvar "Cetransparency" -1)
     ) ; setq
  ) ; defun



;; Restauration variables Usager et Normalisées

 (defun Rest_var () 
     
   (setvar "cmdecho" U_cmdecho) 
   (setvar "osmode" U_osmode)
   (setvar "clayer" U_clayer)
   (setvar "polarmode" U_polar)
   (setvar "cecolor" N_cecolor) 
   (setvar "celtype" N_celtype)
   (setvar "celweight" N_celw)
   (setvar "plinewid" N_plinewid)
   (setvar "Transparency" U_Transp)
 ) 


 ;; Redéfinition de la fonction *error* 

 (defun *error* (msg) 
    (princ (strcat "\nErreur: " msg))   ; renvoie un msg d'erreur 
    (Rest_var)                          ; Restore les variables Usagers et Normalisées  
    (princ)                             ; Quitte silencieusement 
 ) ;defun

Maintenant, si je place tout ceci dans mon fichier .MNL, ça pourrait servir pour toutes les commandes?

Est-ce que me suis dans l'erreur (sans jeux de mots) si je place (u_svar) et (n_svar) au début de mon programme et (Rest_var) à la fin, juste avant le (princ)? Qu'est-ce que je fais alors avec la "redéfinition de la fonction *error*"?

Merci et à demain!

bryce · le 17 novembre 2011

(setq U_cmdecho (setvar "cmdecho" 0))

En faisant ça tu ne sauvegardes pas la valeur de CMDECHO, mais tu mets CMDECHO à 0 avant de stocker cette valeur dans U_cmdecho.

Quand tu vas la restaurer, CMDECHO sera du coup toujours à 0... ;)

Pareil dans N_svar pour CECOLOR & Co.

Je ne vois pas trop l'intérêt non plus de faire de UN_var une commande (avec C:).

Karmelie · le 18 novembre 2011

Bonjour,

Et voilà, tout fonctionne. J'y suis allée au plus simple.

Merci à tous.

(defun PLINE_LSEG
		(		;Arguments:
		 CALQUE		;  Nom du calque spécifié dans la commande
		 /		;Variables locales:
		 INFO		;  Données extraites de la liste des calques
		 La_SEGM	;  Largeur du segment extraite de la liste des calques = Epaisseur du calque
		 PTDEP		;  Début du polyligne
		 *error*	;  Gestion des erreurs
                       )		;  fin arguments
;Gestion des erreurs
(defun *error* (msg) (setvar "plinewid" 0) (print msg))

 (setq INFO (assoc CALQUE ListeCalques))  	;; Recherche du calque dans la liste des calques normalisés
 (setq La_SEGM (atof (nth 3 INFO)))       	;; Capte l'épaisseur du calque
 (setvar "plinewid" La_SEGM)              	;; Assigne l'épaisseur du calque à la largeur de segment du pline
 (CREATION_CALQUE)  			  	;; Création du calque
 (command "_pline") 
 (while (/= 0 (getvar "cmdactive")) (command pause))
 (setvar "plinewid" 0)				;; Remise à zéro de la largeur des polylignes
 (princ)
)

Est-ce que je dois rappeler *error* quelquepart?

Pour ce qui est de la gestion des erreurs plus avancée, je reviendrai dans un autre post.

Merci encore :)

Karmelie · le 18 novembre 2011

Bonjour,

Je ne sais pas comment indiqué que le sujet est "résolu"

didier · le 18 novembre 2011

Coucou

pour marquer résolu

il faut modifier (bouton en bas au milieu à droite)

de ton premier message

il faut aussi que tu en sois l'auteur

mais c'est le cas

toujours est-il que les modérateurs ont aussi cette possibilité

et je m'en suis servi.

content que tu t'en soit sortie.

amicalement

VDH-Bruno · le 18 novembre 2011

Bonsoir Karmelie,

Ton lien ne fonctionne pas mais je pense que tu faisais référence à ce post : Fonctionne malgrès l\'erreur

Est-ce que je dois rappeler *error* quelquepart?

Non la fonction *error* à la particularité d’être systématiquement évalué en cas d’interruption de ta routine et elle est sensé reprendre les actions que ton programme n’a pu mener à terme.. (comme rétablir l’environnement initial et éventuellement annuler certaine actions de dessin).

Comme bryce et en raison de ce qui est précisé précédemment, je ne vois pas trop l'intérêt de faire de UN_var une commande (avec C:) dans le cadre d’une gestion d’erreur.

Par contre tu peux tout à fait créer un LISP pour paramétrer (ou sauvegarder) tes variables AutoCAD, et ainsi restituer rapidement ton environnement de travail sur ton poste de travail ou celui d’un de tes collègues mais là on ne parle plus de gestion d’erreur.

Pour ce qui est de la gestion des erreurs plus avancée, je reviendrai dans un autre post.

En ce qui concerne ce thème j’ai un peu évolué depuis le post que tu cites surtout au niveau de la sauvegarde et la restitution des variables, bien que je me sois bien pris la tête sur la question voir ici. J’ai fini par me convertir à l’utilisation de la routine ai_sysvar (routine que (gile) m’a fait découvrir) définie dans acad20XXdoc.lsp (donc automatiquement chargée dans chaque document).

Cordialement

Bruno

philsogood · le 12 juin 2012

hello Karmélie,

merci le petit bout de code que tu as fait,

je suis loin d'avoir tout utilisé (mes besoins sont plus basiques) mais tu m'as franchement bien aidé

++

Phil

Connexion

[Résolu] Remise à zéro de la largeur des polylignes

Messages recommandés

Karmelie

Tramber

Karmelie

bryce

Tramber

Carboleum

Karmelie

didier

Carboleum

Karmelie

Karmelie

didier

Karmelie

bryce

Carboleum

Karmelie

Carboleum

Karmelie

bryce

Karmelie

Karmelie

didier

VDH-Bruno

philsogood

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante