Decaler point de cotation en lisp

Topheur · le 5 juin 2018

Bonjour amis lispeurs :)

Comme d'habitude, j'ai besoin de vos connaissance pour un lisp...

J'ai réalisé un lisp qui me permet de faire des cotations aligné.

Mon problème et que j'aimerais rajouter une marge.

Pour ce faire j'ai deux possibilités :

- Faire une cotation aligné ex. 100, éditer la cotation et rajouter ma marge ex. 50 se qui me permet d'obtenir une cotation tracé de 100 mais qui affiche 150.

Cela fonctionne parfaitement mais peut induire en erreur vu que la cotation tracé n'est pas égale à la cotation inscrite.

La deuxième solution (mais je ne trouve pas le code) c'est de déplacer le point utilisateur (normalement cliqué à 100) et le positionner à 50 plus loin.

J'ai défini une variable pt0 et pt1 (pt0 étant l'origine et pt1 le point de cote utilisateur)

Lors de mes essais, je demande à Autocad de tracer une cotation alignée de pt0 à pt1 +50 cela ne fonctionne pas et dans le message d'erreur je pense comprendre que celui-ci attend une coordonnée...

Je sais qu'il y aurait une troisième solution en modifiant le style de cotation (par ex. rajouter à la cotation un signe +50) mais cela n'est pas ce que je veux obtenir visuellement parlant.

Je ne veux pas non plus modifier le style de cotation client en affectant un arrondi quelconque.

Merci de votre aide.

PS : comment passe t-on un sujet en résolu, il me semblait qu'il existé une petite ampoule pour passe le sujet en résolu mais je ne là vois plus B) (ou je suis très fatigué :D )

bonuscad · le 5 juin 2018

Bonjour,

J'avais fais ceci pour quelqu'un qui voulait coter des portes en retranchant les encadrements.

Peut être que cela convient, ou simplement l'adapter...

NB: Ce lisp dissocie les cotes des objets -> donc pas de mise à jour automatique!

(defun c:dim-n ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2)
 (if (not value)
   (progn
     (initget 2)
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2))
   )
 )
 (or
   (setq js (ssget "_I" '((0 . "DIMENSION"))))
   (setq js (ssget "_P" '((0 . "DIMENSION"))))
 )
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New")
     (if (eq (getkword "\nTraiter jeu de sélection [Existant/Nouveau] <Existant>: ") "New")
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
   )
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
 (cond
   (js
     (repeat (setq n (sslength js))
       (setq ent_dim (ssname js (setq n (1- n))))
       (setq dxf_ent (entget ent_dim))
       (cond
         ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
           (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
           (setq p_nw1 (polar p1 (angle p1 p2) (/ value 2.0)) p_nw2 (polar p2 (angle p2 p1) (/ value 2.0)))
           (setq dxf_ent (subst (cons 13 p_nw1) (assoc 13 dxf_ent) dxf_ent))
           (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
           (entmod dxf_ent)
         )
         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )
 (prin1)
)

Topheur · le 5 juin 2018

Bonjour,

J'avais fais ceci pour quelqu'un qui voulait coter des portes en retranchant les encadrements.

Peut être que cela convient, ou simplement l'adapter...

NB: Ce lisp dissocie les cotes des objets -> donc pas de mise à jour automatique!

(defun c:dim-n ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2)
 (if (not value)
   (progn
     (initget 2)
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2))
   )
 )
 (or
   (setq js (ssget "_I" '((0 . "DIMENSION"))))
   (setq js (ssget "_P" '((0 . "DIMENSION"))))
 )
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New")
     (if (eq (getkword "\nTraiter jeu de sélection [Existant/Nouveau] <Existant>: ") "New")
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
   )
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
 (cond
   (js
     (repeat (setq n (sslength js))
       (setq ent_dim (ssname js (setq n (1- n))))
       (setq dxf_ent (entget ent_dim))
       (cond
         ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
           (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
           (setq p_nw1 (polar p1 (angle p1 p2) (/ value 2.0)) p_nw2 (polar p2 (angle p2 p1) (/ value 2.0)))
           (setq dxf_ent (subst (cons 13 p_nw1) (assoc 13 dxf_ent) dxf_ent))
           (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
           (entmod dxf_ent)
         )
         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )
 (prin1)
)

Bonjour bonuscad,

C'est dans cette veine là.

Par contre 2 choses :

- Il faudrait ne pas avoir à sélectionner les cotes, mais le faire au même moment que l'on trace la cotation, dans l'ordre :

1. point d'origine pt0

2. point de cotation pt

3. point pour placer la cotation ptp

4. cotation aligné avec marge

- Il faudrait ajouter la marge uniquement du côté de pt (ton lisp retranche la cotation des deux cotés).

Une question(désagréable) de ma part (parce que je suis chiant :D ), pourquoi vous ne commentez pas vos lisps avec des ;

Ne le prends pas mal c'est juste que ton lisp est (pour moi) très complexe et je ne comprends pas la moitié des lignes <img src='http://cadxp.com/public/style_emoticons/<#EMO_DIR#>/laugh.gif' class='bbc_emoticon' alt=':(rires forts):' />

J'ai remarqué que les lispeurs ne commentent pas beaucoup leurs codes (à l'intérieur même des lisps pas lorsqu'on leur demande de plus ample infos), y a t-il une raison ?

Cela à t-il une incidence sur la rapidité du code ?

Merci de ton aide.

bonuscad · le 6 juin 2018

pourquoi vous ne commentez pas vos lisps avec des ;

Tout simplement par flemme, et puis par experience je me suis rendu compte que lors de la demande d'un lisp, dans la majorité des cas le demandeur n'a que faire des explications, pour lui l'essentiel est que ça fonctionne. Peu cherchent à s'investir et à adapter le lisp à son besoin: le plus souvent en retour on te demande de faire des modifications pour l'adapter.

Cela à t-il une incidence sur la rapidité du code ?

Aucunement, les lignes en commentaire ne sont pas interpretées.

Pour ma part je préfère un code source bien indenté que truffé de commentaires.

J'ai plus de facilité à lire le premier et à le comprendre (on voit les profondeurs d'appel du premier coup d'oeil), alors qu'un code source présenté en ligne, même avec commentaires sera imbuvable.

Mais si tu veux t'investir, alors je vais faire l'effort de commenter...

A ton tour de jouer!

(defun c:dim-n ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2) ;déclaration des variable locales
 (if (not value) ; value n'a pas été mis en variable locale, cette variable sera valide pendant toute la session du dessin. Cela veut dire que dès que value sera définie, il ne posera plus la question sur la valeur à lui affecter.
   (progn
     (initget 2) ; arme le bit d'entrée utilsateur: interdit la valeur zéro
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2)) ;si entrée utilisateur nulle alors valeur par défaut affectée à value
   )
 )
;si un jeu de sélection implicite OU précedent filtré sur les cotation existe
 (or
   (setq js (ssget "_I" '((0 . "DIMENSION"))))
   (setq js (ssget "_P" '((0 . "DIMENSION"))))
 )
;alors on le grip et pose la question de traiter celui-ci ou d'en créer un nouveau.
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New") ; arme le bit en mode français/international
     (if (eq (getkword "\nTraiter jeu de sélection [Existant/Nouveau] <Existant>: ") "New")
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
   )
;autrement on demande une selection filtrée sur les cotation
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
;on continu si un jeu de selection existe
 (cond
   (js
;on boucle sur le nombre d'entités contenu dans la sélection.
     (repeat (setq n (sslength js))
;on récupére le nom de l'entité par incrémentation, ici plus exactement par décrémentation (n-1)
       (setq ent_dim (ssname js (setq n (1- n))))
;on extrait les code dxf de celle-ci
       (setq dxf_ent (entget ent_dim))
       (cond
;on vérifie que la cotation appartient au type alignée, pivotée, horizontale ou verticale.
;on veut écarter des cotation de type radiale, coordonnée, angulaire où le type de traitement que l'on veut appliquer ne serait pas possible.
         ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
;on récupère les points de définitions des côtes: 13 et 14
           (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
;on applique à ces points la correction voulue
;le calcul se fait à l'aide (polar), c'est ici que tu doit adapter si tu ne veut faire que un seul côté...
           (setq p_nw1 (polar p1 (angle p1 p2) (/ value 2.0)) p_nw2 (polar p2 (angle p2 p1) (/ value 2.0)))
;on substitue les nouvelles valeurs aux anciennes.
           (setq dxf_ent (subst (cons 13 p_nw1) (assoc 13 dxf_ent) dxf_ent))
           (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
;on met à jour l'entité
           (entmod dxf_ent)
         )
         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )
 (prin1)
)

Topheur · le 6 juin 2018

Tout simplement par flemme, et puis par experience je me suis rendu compte que lors de la demande d'un lisp, dans la majorité des cas le demandeur n'a que faire des explications, pour lui l'essentiel est que ça fonctionne. Peu cherchent à s'investir et à adapter le lisp à son besoin: le plus souvent en retour on te demande de faire des modifications pour l'adapter.

Aucunement, les lignes en commentaire ne sont pas interpretées.

Pour ma part je préfère un code source bien indenté que truffé de commentaires.

J'ai plus de facilité à lire le premier et à le comprendre (on voit les profondeurs d'appel du premier coup d'oeil), alors qu'un code source présenté en ligne, même avec commentaires sera imbuvable.

Mais si tu veux t'investir, alors je vais faire l'effort de commenter...

A ton tour de jouer!

(defun c:dim-n ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2) ;déclaration des variable locales
 (if (not value) ; value n'a pas été mis en variable locale, cette variable sera valide pendant toute la session du dessin. Cela veut dire que dès que value sera définie, il ne posera plus la question sur la valeur à lui affecter.
   (progn
     (initget 2) ; arme le bit d'entrée utilsateur: interdit la valeur zéro
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2)) ;si entrée utilisateur nulle alors valeur par défaut affectée à value
   )
 )
;si un jeu de sélection implicite OU précedent filtré sur les cotation existe
 (or
   (setq js (ssget "_I" '((0 . "DIMENSION"))))
   (setq js (ssget "_P" '((0 . "DIMENSION"))))
 )
;alors on le grip et pose la question de traiter celui-ci ou d'en créer un nouveau.
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New") ; arme le bit en mode français/international
     (if (eq (getkword "\nTraiter jeu de sélection [Existant/Nouveau] <Existant>: ") "New")
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
   )
;autrement on demande une selection filtrée sur les cotation
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
;on continu si un jeu de selection existe
 (cond
   (js
;on boucle sur le nombre d'entités contenu dans la sélection.
     (repeat (setq n (sslength js))
;on récupére le nom de l'entité par incrémentation, ici plus exactement par décrémentation (n-1)
       (setq ent_dim (ssname js (setq n (1- n))))
;on extrait les code dxf de celle-ci
       (setq dxf_ent (entget ent_dim))
       (cond
;on vérifie que la cotation appartient au type alignée, pivotée, horizontale ou verticale.
;on veut écarter des cotation de type radiale, coordonnée, angulaire où le type de traitement que l'on veut appliquer ne serait pas possible.
         ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
;on récupère les points de définitions des côtes: 13 et 14
           (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
;on applique à ces points la correction voulue
;le calcul se fait à l'aide (polar), c'est ici que tu doit adapter si tu ne veut faire que un seul côté...
           (setq p_nw1 (polar p1 (angle p1 p2) (/ value 2.0)) p_nw2 (polar p2 (angle p2 p1) (/ value 2.0)))
;on substitue les nouvelles valeurs aux anciennes.
           (setq dxf_ent (subst (cons 13 p_nw1) (assoc 13 dxf_ent) dxf_ent))
           (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
;on met à jour l'entité
           (entmod dxf_ent)
         )
         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )
 (prin1)
)

Salut bonuscad

C'est vrai qu'avec les commentaires ça fait peur :(rires forts):

Mais l'avantage c'est que certaine partie du code peuvent servir pour d'autre lisp !

Je vais regarder ça à tête reposé quand j'aurais un peu plus de temps.

Il est vrai qu'un lisp tous fait est le bienvenue mais avec les coms on peut le modifier plus facilement.

Bon j'avoue que j'aurais probablement encore des questions mais je vais d'abord bricoler un peu ;)

Topheur · le 8 juin 2018

Bonjour,

J'avais fais ceci pour quelqu'un qui voulait coter des portes en retranchant les encadrements.

Peut être que cela convient, ou simplement l'adapter...

NB: Ce lisp dissocie les cotes des objets -> donc pas de mise à jour automatique!

(defun c:dim-n ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2)
 (if (not value)
   (progn
     (initget 2)
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2))
   )
 )
 (or
   (setq js (ssget "_I" '((0 . "DIMENSION"))))
   (setq js (ssget "_P" '((0 . "DIMENSION"))))
 )
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New")
     (if (eq (getkword "\nTraiter jeu de sélection [Existant/Nouveau] <Existant>: ") "New")
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
   )
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
 (cond
   (js
     (repeat (setq n (sslength js))
       (setq ent_dim (ssname js (setq n (1- n))))
       (setq dxf_ent (entget ent_dim))
       (cond
         ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
           (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
           (setq p_nw1 (polar p1 (angle p1 p2) (/ value 2.0)) p_nw2 (polar p2 (angle p2 p1) (/ value 2.0)))
           (setq dxf_ent (subst (cons 13 p_nw1) (assoc 13 dxf_ent) dxf_ent))
           (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
           (entmod dxf_ent)
         )
         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )
 (prin1)
)

Bonsoir,

Au secours bonuscad !

J'ai adapté le code, tous fonctionne mais je n'arrive pas à rajouter 50 à ma cote.

J'ai essayé

(setq p_nw2 (+ p_nw2 p_nw2))

(setq p_nw2 (polar p2 (angle p2 p1) (/ value 1.0)))

Sans succès :(

Merci de ton aide

bonuscad · le 8 juin 2018

Essayes comme ceci: change le second point (DXF 14)

      	((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
       	(setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
       	(setq p_nw2 (polar p2 (angle p1 p2) value))
       	(setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
       	(entmod dxf_ent)
     	)

lecrabe · le 8 juin 2018

Hello Mr Topheur

SVP tu peux "partager" avec nous ton code ?

Bon WE, Bye, lecrabe

Topheur · le 8 juin 2018

Essayes comme ceci: change le second point (DXF 14)

      	((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))        	(setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))        	(setq p_nw2 (polar p2 (angle p1 p2) value))        	(setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))        	(entmod dxf_ent)      	)

Merci bonuscad ! :(rires forts):

ça marche !

Tu es mon héro du jour :P

Par contre j'aurais jamais pu trouver le code tous seul :blink:

Hello Mr TopheurSVP tu peux "partager" avec nous ton code ?Bon WE, Bye, lecrabe

Merci :D

Bonsoir lecrabe,

Je ne partagerais pas mon code ce soir car il est en plusieurs morceaux (qui fonctionnent indépendamment).

J'assemble le tous (en espérant que ça marche) et je le mettrais en ligne d'ici peu avec plaisir (au plus tard le week end prochain).

Par contre il ne sera pas parfais.

Je fusionne des morceaux de codes donc c'est plutôt moche mais en règle générale ça marche et si d'autres personnes ont besoin de morceaux à adapter se sera ma contribution avec l'aide que j'ai reçu.

Mon lisp fera la chose suivante :

Pt d'origine (défini par l'utilisateur), cotations depuis ce point (boucle while), sélection des cotes et ajout de ces fameux 50 (lisp de bonuscad adapté).

Encore merci.

Topheur · le 9 juin 2018

Essayes comme ceci: change le second point (DXF 14)

      	((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))        	(setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))        	(setq p_nw2 (polar p2 (angle p1 p2) value))        	(setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))        	(entmod dxf_ent)      	)

Hello Mr TopheurSVP tu peux "partager" avec nous ton code ?Bon WE, Bye, lecrabe

Finalement, je vous propose mon code aujourd'hui :(rires forts):

Par contre j'aimerais éviter de demander à l'utilisateur de choisir la cotation, j'aimerais que le lisp récupère la cotation qui viens d'être tracé.

AU SECOURS bonuscad (ou lecrabe :D si tu as la réponse)

Par contre le code est peut être complexe pour les vraie lispeurs mais au moins je comprends mieux les étapes de ce dernier.

Par la suite je pense supprimer la question utilisateur sur la marge à ajouter car je pense que se sera toujours 50 (mais dans le code on le demande une fois, merci pour la commande car je ne la connaissais pas et je pense la réutiliser dans d'autres lisp)

J'ai également modifié le nom de la commande par DIM-P (P pour +)

(defun c:dim-p ( / js n ent_dim dxf_ent p1 p2 p_nw1 p_nw2) ;déclaration des variable locales
 (if (not value) ; value n'a pas été mis en variable locale, cette variable sera valide pendant toute la session du dessin. Cela veut dire que dès que value sera définie, il ne posera plus la question sur la valeur à lui affecter.
   (progn
     (initget 2) ; arme le bit d'entrée utilsateur: interdit la valeur zéro
     (setq value (getreal "\nValeur à retrancher à la côte sélectionnée <0.20>: "))
     (if (not value) (setq value 0.2)) ;si entrée utilisateur nulle alors valeur par défaut affectée à value
   )
 )

 (setq pdep (getpoint "\nSpécifiez le premier point: ")) ;; point de départ (centre de la pieuvre)


(while T  ;; t=true la boucle se répétera tant que l'on n'en sortira pas avec un echap

 (setq pfin (getpoint pdep "\nSpécifiez le deuxième point: "))


       (command "_dimaligned" pdep pfin pause) ;; dessine la côte

;alors on le grip et pose la question de traiter celui-ci ou d'en créer un nouveau.
 (cond
   (js
     (sssetfirst nil js)
     (initget "Existant Nouveau _Existent New") ; arme le bit en mode français/international
       (progn (sssetfirst nil nil) (setq js (ssadd) js (ssget '((0 . "DIMENSION")))))
     )
;autrement on demande une selection filtrée sur les cotation
   (T (setq js (ssget '((0 . "DIMENSION")))))
 )
;on continu si un jeu de selection existe
 (cond
   (js
;on boucle sur le nombre d'entités contenu dans la sélection.
     (repeat (setq n (sslength js))
;on récupére le nom de l'entité par incrémentation, ici plus exactement par décrémentation (n-1)
       (setq ent_dim (ssname js (setq n (1- n))))
;on extrait les code dxf de celle-ci
       (setq dxf_ent (entget ent_dim))
       (cond
;on vérifie que la cotation appartient au type alignée, pivotée, horizontale ou verticale.
;on veut écarter des cotation de type radiale, coordonnée, angulaire où le type de traitement que l'on veut appliquer ne serait pas possible.

       ((or (zerop (rem (cdr (assoc 70 dxf_ent)) 32)) (eq (rem (cdr (assoc 70 dxf_ent)) 32) 1))
;on récupère les points de définitions des côtes: 13 et 14
               (setq p1 (cdr (assoc 13 dxf_ent)) p2 (cdr (assoc 14 dxf_ent)))
;on applique à ces points la correction voulue
;le calcul se fait à l'aide (polar), c'est ici que tu doit adapter si tu ne veut faire que un seul côté...
               (setq p_nw2 (polar p2 (angle p1 p2) value))
;on substitue les nouvelles valeurs aux anciennes.
               (setq dxf_ent (subst (cons 14 p_nw2) (assoc 14 dxf_ent) dxf_ent))
;on met à jour l'entité
               (entmod dxf_ent)
       )

         (T
           (princ "\nN'est pas une côte alignée, pivotée, horizontale ou verticale.")
         )
       )
     )
   )
 )


) ;while
 (prin1)
)

J'espère encore avoir de vos nouvelles pour ma demande :

"éviter de demander à l'utilisateur de choisir la cotation, j'aimerais que le lisp récupère la cotation qui viens d'être tracé."

Merci à vous en tous cas :)

PHILPHIL · le 13 juin 2018

bonjour

si ca peut aider

correction des bugs

c'est pas aussi bien écrit que BONUSCAD mais c'est ma version

ca permet de replacer un point de cote a une distance donnée sur des cote déja existante a droite ou a gauche

distance positive = sur l'extérieur de la cote

distance négative = sur l'intérieur de la cote

bonne journée

Phil

(defun c:deplace_point_cote ()
 (setq scuna (getvar "ucsname"))
 (command-s "scu" "")
 (setvar "cmdecho" 0)
 (setvar "PICKSTYLE" 0)
 (setvar "CURSORSIZE" 10)
 (setq osm (getvar "osmode"))
 (setq decapointcote (atof (getcfg "APPDATA/decapointcote")))
 (setq tmp
        (getdist
          (strcat "\nENTRER LE DECALAGE DU POINT DE COTE L'EXTERIEUR ( SI NEGATIF LE DECALAGE SERA SUR L'INTERIEUR ) <"
                  (rtos decapointcote 2 8)
                  ">: "
          )
        )
 )
 (if tmp
   (setq decapointcote tmp)
 )
 (setcfg "APPDATA/decapointcote" (rtos decapointcote 2 8))
 (setvar "osmode" 0)
 (setvar "CURSORSIZE" 50)
 (prompt "\nCLIQUER SUR LE(S) COTE(S) A MODIFIER :")
 (setq entx nil)
 (while (null entx) (setq entx (ssget (list (cons -4 "<or") (cons 0 "DIMENSION") (cons -4 "or>")))))
 (setq compt 0)
 (setq com (sslength entx))
 (command-s "ANNULER" "M")
 (while (< compt com)
   (progn (setq sj2 (entget (ssname entx compt)))
          (setq point10  (cdr (assoc 10 sj2))
                point13  (cdr (assoc 13 sj2))
                point14  (cdr (assoc 14 sj2))
                angcote  (cdr (assoc 50 sj2))
                longcote (cdr (assoc 42 sj2))
                codempla (cdr (assoc 70 sj2))
          )
          (vlax-put-property (vlax-ename->vla-object (ssname entx compt)) 'textmovement 1)
          (command-s "scu" "z" point10 (polar point10 angcote 10))
          (if (> (car (trans point13 0 1)) (car (trans point10 0 1)))
            (progn (setq dist decapointcote)
                   (if (or (= codempla 33) (= codempla 161))
                     (progn (setq anglecote2 (angle point14 point13))
                            (setq newpoint (polar point14 anglecote2 (- dist)))
                            (setq sj2 (subst (cons 14 newpoint) (assoc 14 sj2) sj2))
                            (entmod sj2)
                     )
                   )
                   (if (or (= codempla 32) (= codempla 160))
                     (progn (setq newpoint (polar point14 angcote (- dist)))
                            (setq sj2 (subst (cons 14 newpoint) (assoc 14 sj2) sj2))
                            (entmod sj2)
                     )
                   )
            )
            (progn (setq dist decapointcote)
                   (if (or (= codempla 33) (= codempla 161))
                     (progn (setq anglecote2 (angle point13 point14))
                            (setq newpoint (polar point13 anglecote2 (- dist)))
                            (setq sj2 (subst (cons 13 newpoint) (assoc 13 sj2) sj2))
                            (entmod sj2)
                     )
                   )
                   (if (or (= codempla 32) (= codempla 160))
                     (progn (setq newpoint (polar point13 angcote (- dist)))
                            (setq sj2 (subst (cons 13 newpoint) (assoc 13 sj2) sj2))
                            (entmod sj2)
                     )
                   )
            )
          )
          (command-s "scu" "p")
   )
   (entmod sj2)
   (setq compt (1+ compt))
 )
 (initget "n N")
 (setq ans (getkword "\nEST CE QUE LE DECALAGE EST EFFECTUE DU BON COTE ? (O/N):"))
 (if (or (= ans "n") (= ans "N"))
   (progn (command-s "ANNULER" "R")
          (setq compt 0)
          (while (< compt com)
            (progn (setq sj2 (entget (ssname entx compt)))
                   (setq point10  (cdr (assoc 10 sj2))
                         point13  (cdr (assoc 13 sj2))
                         point14  (cdr (assoc 14 sj2))
                         angcote  (cdr (assoc 50 sj2))
                         longcote (cdr (assoc 42 sj2))
                         codempla (cdr (assoc 70 sj2))
                   )
                   (vlax-put-property (vlax-ename->vla-object (ssname entx compt)) 'textmovement 1)
                   (command-s "scu" "z" point10 (polar point10 angcote 10))
                   (if (> (car (trans point13 0 1)) (car (trans point10 0 1)))
                     (progn (setq dist decapointcote)
                            (if (or (= codempla 33) (= codempla 161))
                              (progn (setq anglecote2 (angle point14 point13))
                                     (setq newpoint (polar point13 anglecote2 dist))
                                     (setq sj2 (subst (cons 13 newpoint) (assoc 13 sj2) sj2))
                                     (entmod sj2)
                              )
                            )
                            (if (or (= codempla 32) (= codempla 160))
                              (progn (setq newpoint (polar point13 angcote dist))
                                     (setq sj2 (subst (cons 13 newpoint) (assoc 13 sj2) sj2))
                                     (entmod sj2)
                              )
                            )
                     )
                     (progn (setq dist decapointcote)
                            (if (or (= codempla 33) (= codempla 161))
                              (progn (setq anglecote2 (angle point13 point14))
                                     (setq newpoint (polar point14 anglecote2 dist))
                                     (setq sj2 (subst (cons 14 newpoint) (assoc 14 sj2) sj2))
                                     (entmod sj2)
                              )
                            )
                            (if (or (= codempla 32) (= codempla 160))
                              (progn (setq newpoint (polar point14 angcote dist))
                                     (setq sj2 (subst (cons 14 newpoint) (assoc 14 sj2) sj2))
                                     (entmod sj2)
                              )
                            )
                     )
                   )
                   (command-s "scu" "p")
            )
            (setq compt (1+ compt))
          )
   )
 )
 (command-s "scu" "p")
 (setvar "osmode" osm)
 (setvar "CURSORSIZE" 100)
 (princ)
)

Connexion

Decaler point de cotation en lisp

Messages recommandés

Topheur

bonuscad

Topheur

bonuscad

Topheur

Topheur

bonuscad

lecrabe

Topheur

Topheur

PHILPHIL

Forums

Naviguer

Activité

Information importante