zebulon_

(vl-load-com) (defun modif_attrib (E ETIQ VALEUR / LATT ATT) (if (= (type E) 'ENAME) (setq E (vlax-ename->vla-object E)) ) (setq LATT (vlax-invoke E 'getAttributes)) (foreach ATT LATT (if (= (strcase (vla-get-TagString ATT)) (strcase ETIQ)) (vla-put-TextString ATT VALEUR) ) ) ) (defun indtxt (enam) (vla-get-TextString (vlax-ename->vla-object enam)) ) (defun c:txt2att () (setq Des (car (entsel "\nTexte Désignation : "))) (setq Num (car (entsel "\nTexte Numéro : "))) (setq Sur (car (entsel "\nTexte Surface : "))) (setq Blo (car (entsel "\nBloc de destination : "))) (modif_attrib Blo "DÉSIGNATION" (indtxt Des)) (modif_attrib Blo "NUMERO" (indtxt Num)) (modif_attrib Blo "SURFACE" (indtxt Sur)) (princ) ) Amicalement Vincent

dropbox + lien Amicalement Vincent

Bonjour, un exemple illustré serait le bienvenu, car j'ai du mal à comprendre. En effet, "Info_local" c'est tantôt un bloc, tantôt un attribut. "Un bon croquis vaut mieux qu'un long discours." Napoléon Bonaparte Amicalement Vincent

le poison a été programmé !

merci, j'essaye d'apporter une plus-value pour me démarquer :) Amicalement Vincent

Merci je suis plutôt de culture programmation impérative Amicalement Vincent

Bonsoir une modélisation d'un ouvrage en 3D. un autre avec quelques plans 2D Amicalement Vincent

Bonjour, En effet, je parle pour ma chapelle, à savoir les ponts. C'est vrai, mais il y a encore du chemin à faire pour avoir un seul modèle 3D dont sont issus tous les plans. Pour l'instant, les plans de coffrage issus d'un modèle 3D sont encore assez dégueulasses, mais il y a du progrès. Et quand on dit tous les plans, c'est y compris les plans de ferraillage et les nomenclatures ? En effet, un pont BA ou BP en exécution prend plus de temps à ferrailler et à câbler qu'à coffrer. La question est de savoir jusqu'à quel niveau de détail on peut pousser la modélisation. Si on dessine chaque ferraille en 3D, le modèle va vite devenir inexploitable, d'une part parce que c'est trop lourd, d'autre part parce que, graphiquement, ça devient vite un paquet de nouilles. Amicalement Vincent

Bonjour, Je suis convaincu de l'utilité de modéliser un ouvrage d'art en 3D. Par contre, l'utilité d'une BIM est-elle justifiée ? En général, un ouvrage d'art, c'est 98% de béton armé, éventuellement précontraint. C'est beaucoup plus simple qu'un bâtiment : on a 2 culées, n piles et un tablier. Les seuls équipements sont, en général, les joints de chaussée, les appareils d'appuis et les garde-corps ou barrières de sécurité, éventuellement une corniche. Je peux vous dire d'expérience que, lorsqu'on change un joint de chaussée, c'est au bout de 20 ou 30 ans et je n'ai jamais remis le même que celui qui est en place. Le modèle n'existe plus ! Quant aux appareils d'appuis, lorsqu'on les change, on ne met pas les mêmes modèles non plus, compte tenu que l'environnement normatif a largement évolué depuis les années 1960/1980. Et, sans être prophète, on peut dire qu'il n'y a aucune raison que les normes d'aujourd'hui soient toujours les normes de demain. Reste les garde-corps et les barrières de sécurité, pour lesquels les normes évoluent également. Je ne vois pas bien comment, dans 20 ou 30 ans, on pourra réutiliser un modèle numérique qu'on aura conçu aujourd'hui, pour autant qu'on le retrouve et que le format de fichier soit encore compatible avec les ordinateurs ou systèmes du futur. Bon, on retrouve bien des dossiers de récolement papier et on arrive bien à ouvrir des fichiers Autocad V12, alors, oui, mettons qu'on arrivera à retrouver et à exploiter ces modèles numériques dans 30 ans. Mais il faudra au minimum les adapter au nouvel environnement normatif, que ce soient les normes de construction ou les normes informatiques. C'est certain que, lorsqu'on répare un ouvrage, la phase de saisie des plans de récolement est loin d'être négligeable. Concernant les dimensions des ouvrages, je vous rassure, les ouvrages courants ne sont pas si grands que ça. Si on est limité à un cube de 100m de côté, cela sera suffisant pour la majorité de ces ouvrages là. Bien sûr, les viaducs demandent des outils plus spécifiques. Ce qu'il ne faut pas perdre de vue, c'est que l'objectif reste de fournir des plans exploitables par le chantier (vues en plan, coupes, élévations) avec les cotes qui vont bien. Si le maçon dispose d'un modèle 3D, c'est mieux pour la compréhension des plans 2D, mais la 3D, ce n'est pas forcément nécessaire au chantier. Cela ne l'a pas été jusqu'à présent et les maçons d'aujourd'hui ne sont pas moins bons que ceux d'hier. Ce sera différent, le jour où on arrivera à faire une imprimante 3D qui saura faire du béton armé et/ou précontraint, ou un autre matériau plus performant. Amicalement, Vincent

Je n'avais pas remarqué l'impossibilité du rétrécissement. Mais la possibilité d'agrandissement est déjà un progrès par rapport à getfiled pour lequel la taille de la boite de dialogue semble immuable. Merci pour la précision Amicalement Vincent

(acet-ui-getfile title deffile defext dialogname flags) donne une liste déroulante plus importante que getfiled (acet-ui-getfile "Mon dialogue" "" "" "" 8)

(command "_.pline" (while (not (zerop (getvar "cmdactive"))) (command pause) ) ) pour utiliser la commande _pline avec toutes ses possibilités, pas simplement entrer le point suivant... je suggère l'utilisation d'un champ Amicalement Vincent

Tu es le bienvenu ! Amicalement Vincent

par ailleurs, il faut être prudent avec les "command" car elles restent sensibles aux accrochages aux objets. Par exemple : (command "ligne" A B "") peut donner n'importe quoi s'il y a un sommet à proximité et qu'on a activé l'accrochage aux objets extrémité. Il vaut donc mieux désactiver les accrochages aux objets soit globalement en jouant avec la variable OSMODE, soit localement (ce que je préfère) en ajoutant un "_non" avant l'appel d'un point (et uniquement d'un point) dans une commande (command "ligne" "_non" A "_non" B "") Enfin, toujours au sujet de "command", c'est mieux d'utiliser les commandes internationales plutôt que françaises. Le lisp est plus facile à traduire, le cas échéant et, surtout, on ne subit pas les éventuels changement de traduction d'une commande d'une version à l'autre, qui rendrait le lisp inopérant (command "_line" "_non" A "_non" B "") Amicalement Vincent

Bonjour, il faudrait revoir la syntaxe du cond. Ce n'est pas bon au niveau des parenthèses (cond ((= Rep "Fixe")(Fixe)) ((= Rep "Mobile")(Mobile)) ) Amicalement Vincent

Bonsoir, beau travail qui va servir à tout ceux qui veulent franchir le pas. Personnellement, j'ai toujours conservé les bouquins LISP fournis avec Autocad 12. Cela a la forme d'un livre et j'aime bien le papier (mon côté ancien combattant, sans doute) et c'est en français et j'aime bien aussi. Amicalement Vincent

ok merci, je vais tester cela, parce que ça me simplifierait grandement le problème si je peux refiler le raccordement entre les différents segments à une commande native. Amicalement Vincent

Bonjour, disons que la partie qui décale segment par segment, ça marche assez bien. Mais alors pour trouver les intersections et couper les bons côtés des segments, c'est beaucoup plus difficile. J'ai essayé d'utiliser la commande native _fillet pour raccorder les différents segments sans trop me fatiguer, mais si on utilise _fillet en lisp, on ne maitrise pas le côté qu'on conserve et j'ai l'impression qu'autocad conserve toujours le plus grand côté résiduel. Mais rassure-moi, sur des figures simples ça marche ? De toute façon, je ne vais pas pousser plus loin, compte tenu que j'atteins mes limites également Amicalement Vincent

C'est sûr que ce cher (même très cher) otto y gagnerait :P Une proposition en décalant segment par segment, bien entendu proportionnellement. Le lisp recherche l'intersection des segments adjacents et supprime ou rajoute les vertex pour que ça se raccorde bien. Il reste toujours le problème des très petits segments qui peuvent disparaitre entièrement du fait du décalage et qui provoque des erreurs. (defun PTaDroiteObj (obj pt / PTN PM fder PT1DERIV) (if (= (type Obj) 'ENAME) (setq Obj (vlax-ename->vla-object Obj)) ) (setq PTN (vlax-curve-GetClosestPointTo obj PT)) (setq PM (vlax-curve-GetParamAtPoint obj PTN)) (setq fder (vlax-curve-getfirstderiv obj PM)) (setq PT1DERIV (mapcar '+ PTN fder)) (< (sin (- (angle PTN PT) (angle PTN PT1DERIV))) -1e-14) ) (defun getpolySegs (ent / PTL I PTB SEG LSEG) (if (= (type ent) 'ENAME) (setq ent (vlax-ename->vla-object ent)) ) ;; collecter la liste des point sous la forme (x1 y1 x2 y2 ... xn yn) (setq PTL (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates ENT)))) ;; collecter la liste des bulges (setq I 0) (repeat (/ (length PTL) 2) (setq PTB (cons (vla-GetBulge ent I) PTB)) (setq I (1+ I)) ) (setq PTB (reverse PTB)) ;; polyligne fermée -> rajouter le premier point à la liste de points (if (= (vla-get-closed ent) :vlax-true) (setq PTL (append PTL (list (car PTL) (cadr PTL)))) ) ;; transformer en liste de segments (setq I 0) (repeat (- (/ (length PTL) 2) 1) (setq SEG (list (list (nth I PTL) (nth (+ I 1) PTL)) (nth (/ I 2) PTB) (list (nth (+ I 2) PTL) (nth (+ I 3) PTL)) ) ) (setq LSEG (cons SEG LSEG)) (setq I (+ I 2)) ) (reverse LSEG) ) (defun getArcInfo (segment / a p1 bulge p2 c p3 p4 p r s result) ;; assigner variables avec les valeurs de l'argument (mapcar 'set '(p1 bulge p2) segment) (if (not (zerop bulge)) (progn ;; trouver la corde (setq c (distance p1 p2)) ;; trouver la flèche (setq s (* (/ c 2.0) (abs bulge))) ;; trouver le rayon par Pythagore (setq r (/ (+ (expt s 2.0) (expt (/ c 2.0) 2.0)) (* 2.0 s))) ;; distance au centre (setq a (- r s)) ;; coordonnées du milieu de p1 et P2 (setq P4 (polar P1 (angle P1 P2) (/ c 2.0))) ;; coordonnées du centre (setq p (if (>= bulge 0) (polar p4 (+ (angle p1 p2) (/ pi 2.0)) a) (polar p4 (- (angle p1 p2) (/ pi 2.0)) a) ) ) ;; coordonnées de P3 (setq p3 (if (>= bulge 0) (polar p4 (- (angle p1 p2) (/ pi 2.0)) s) (polar p4 (+ (angle p1 p2) (/ pi 2.0)) s) ) ) (setq result (list p r)) ) (setq result nil) ) result ) (defun vlax-list->3D-point (lst / nlst) (while lst (setq nlst (cons (list (car lst) (cadr lst) (caddr lst)) nlst)) (setq lst (cdddr lst)) ) (reverse nlst) ) (defun list->variantArray (ptsList / arraySpace sArray) ; allocate space for an array of 2d points stored as doubles (setq arraySpace (vlax-make-safearray vlax-vbdouble ; element type (cons 0 (- (length ptsList) 1) ) ; array dimension ) ) (setq sArray (vlax-safearray-fill arraySpace ptsList)) ; return array variant (vlax-make-variant sArray) ) (defun getptsegd (SEG PT) (mapcar 'set '(P1 BULGE P2) SEG) (if adroite (setq ANG (* 3 (/ pi 2))) (setq ANG (/ pi 2)) ) (polar PT (+ (angle P1 P2) ANG) (+ decd (* (- decf decd) (/ (vlax-curve-getDistAtpoint obj PT) LongObj)))) ) (defun getptsegc (SEG PT) (mapcar 'set '(P1 BULGE P2) SEG) (setq PTC (car (getarcinfo SEG))) (if adroite (setq ANG pi) (setq ANG 0) ) (if (> BULGE 0) (setq ANG (+ (angle PT PTC) ANG)) (setq ANG (+ (angle PTC PT) ANG)) ) (polar PT ANG (+ decd (* (- decf decd) (/ (vlax-curve-getDistAtpoint obj PT) LongObj)))) ) (defun c:decvarg () ;; valeur de décalage au départ (if (not decd) (setq decd 0.20)) (setq tmp (getdist (strcat "\nSpécifier la distance de décalage à l'origine <" (rtos decd) "> : "))) (if tmp (setq decd tmp)) ;; valeur de décalage à la fin (if (not decf) (setq decf 0.50)) (setq tmp (getdist (strcat "\nSpécifier la distance de décalage à la fin <" (rtos decf) "> : " ))) (if tmp (setq decf tmp)) (setq e (car (entsel "\nSélectionner la polyligne à décaler : "))) (setq pt (getpoint "\n Spécifiez un point sur le côté à décaler : ")) ;; précision des parties courbes (if (not PREC_COURBE) (setq PREC_COURBE 0.1)) (setq tmp (getreal (strcat "\nValeur approximative de la flèche de discrétisation des parties courbes <" (rtos PREC_COURBE) "> : "))) (if tmp (setq PREC_COURBE tmp)) (setq obj (vlax-ename->vla-object e)) (setq LongObj (vla-get-length obj)) (setq adroite (PTaDroiteObj obj (trans PT 1 0))) (setq Lsegs (getPolySegs obj)) (setq Lename nil) (While LSegs (setq SEG (car Lsegs)) (setq lsegs (cdr Lsegs)) (mapcar 'set '(P1 BULGE P2) SEG) (if (zerop BULGE) ;; c'est un segment droit (progn (setq PT1 (getptsegd SEG P1)) (setq PT2 (getptsegd SEG P2)) (command "_pline" "_non" (trans PT1 0 1) "_non" (trans PT2 0 1) "") (setq Lename (cons (entlast) Lename)) ) ;;progn (progn ;; c'est un segment courbe (setq PKdebut (vlax-curve-GetDistAtPoint obj P1)) (setq PKfin (vlax-curve-GetDistAtPoint obj P2)) (setq Larc (- PKfin PKdebut)) (setq R (cadr (getarcinfo SEG))) (setq X (* 2 (sqrt (* 2 R PREC_COURBE)))) ;; estimation corde (setq NBPAS (fix (/ Larc X))) (setq PAS (/ Larc NBPAS)) ;; je coupe les courbes en NBPAS segments droits de longueur environ X (setq PKcourant PKdebut) (command "_pline" "_non" (trans (getptsegc SEG (vlax-curve-GetPointAtDist obj PKcourant)) 0 1)) (repeat NBPAS (setq PKcourant (+ PKcourant PAS)) (command "_non" (trans (getptsegc SEG (vlax-curve-GetPointAtDist obj PKcourant)) 0 1)) ) ;; repeat (command "") (setq Lename (cons (entlast) Lename)) ) ;; progn );; if ) ;; while (setq Lename (reverse Lename)) ;; trouver les intersections (setq a 0) (repeat (- (length lename) 1) (setq e1 (vlax-ename->vla-object (nth a lename))) (setq e2 (vlax-ename->vla-object (nth (+ a 1) lename))) (setq PTLISTe1 (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates e1)))) (setq PTLISTe2 (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates e2)))) (setq PTProche (vlax-curve-getPointAtDist e2 0)) (setq LPTINT (vlax-list->3D-point (vlax-invoke e1 'IntersectWith e2 acExtendNone))) (if LPTINT (progn ;; les segments se croisent (setq RES (car LPTINT)) (setq DMIN (distance PTPROCHE RES)) (foreach PTINT LPTINT (if (< (distance PTProche PTINT) DMIN) (setq RES PTINT) ) ) ;; sur quel segment on se situe sur e1 et e2 ? (setq numseg1 (fix (vlax-curve-getParamAtPoint e1 RES))) (setq numseg2 (fix (vlax-curve-getParamAtPoint e2 RES))) ;; modifier PTLISTe1 ;; supprimer les n dernières entrées de la liste (setq PTLISTe1 (reverse PTLISTe1)) (repeat (* (- (fix (vlax-curve-getEndParam e1)) numseg1) 2) (setq PTLISTe1 (cdr PTLISTe1)) ) ;; rajouter x et y de l'intersection au début de la liste (setq PTLISTe1 (cons (car RES) PTLISTe1)) (setq PTLISTe1 (cons (cadr RES) PTLISTe1)) (setq PTLISTe1 (reverse PTLISTe1)) (vla-put-Coordinates e1 (list->variantArray PTLISTe1)) ;; modifier PTLISTe2 ;; supprimer les n premières entrées de la liste (repeat (* (+ numseg2 1) 2) (setq PTLISTe2 (cdr PTLISTe2)) ) ;; rajouter x et y de l'intersection au début de la liste (setq PTLISTe2 (cons (cadr RES) PTLISTe2)) (setq PTLISTe2 (cons (car RES) PTLISTe2)) (vla-put-Coordinates e2 (list->variantArray PTLISTe2)) ) (progn ;; les segments ne se croisent pas (setq LPTINT (vlax-list->3D-point (vlax-invoke e1 'IntersectWith e2 acExtendBoth))) (setq RES (car LPTINT)) (setq DMIN (distance PTPROCHE RES)) (foreach PTINT LPTINT (if (< (distance PTProche PTINT) DMIN) (setq RES PTINT) ) ) ;; on rajoute un vertex à la fin de e1 (vla-addvertex e1 (/ (length PTLISTe1) 2) (list->variantArray (list (car RES) (cadr RES)))) ;; on rajoute un vertex au début de e2 (vla-addvertex e2 0 (list->variantArray (list (car RES) (cadr RES)))) ) ) (setq a (+ a 1)) ) ;; mettre toutes les pline ensemble (command "_pedit" (car lename) "_j") (setq lename (cdr lename)) (foreach E lename (command E) ) (command "" "") (princ) ) Amicalement Vincent

oui, et il y a aussi le problème évoqué plus haut qui est celui de segments très courts qui peuvent disparaitre du fait du décalage et pour lesquels je ne sais pas trop comment faire. En effet, c'est très simple à mettre en oeuvre et a l'avantage de conserver les parties courbes comme de vraies courbes, même si on perd en précision au niveau des points d'extrémité des segments. On ne peut pas tout avoir, n'est-ce pas ? Amicalement Vincent

je n'ai pas été assez précis dans mon commentaire : je voulais dire décaler chaque segment de façon progressive, pas juste un offset, et je rejoins ta vision des choses pour généraliser la routine, mais en essayant d'intégrer les parties courbes, ce qui ne sera pas une mince affaire. Mon idée : faire un décalage progressif de chaque segment, droit ou courbe, puis de raccorder chaque segment ainsi obtenu pour créer une nouvelle polyligne. Il n'est pas question ici de faire pipi plus loin qu'un autre. Chacun apporte sa pierre à l'édifice, en fonction de son temps, sa connaissance, son inspiration, son expérience, etc S'il y a un peu d'émulation, puisque quelqu'un a parlé de challenge, pourquoi pas ? De là à parler de "faire pipi plus loin", je trouve que c'est exagéré. Amicalement Vincent

peut être en changeant l'option de acExtend ? Amicalement Vincent

Bonjour, Le décalage que je propose n'est valable que si les segments successifs sont +/- tangents, comme c'est le cas en tracé routier. C'était une condition posée depuis le départ de la discussion et rappelée à plusieurs reprises. C'est pour cette raison que je ne comprenais pas pourquoi tu disais que mon décalage était faux, compte tenu que dans le cas particulier qui nous occupe, il ne l'est pas (ou pas trop). Pour avoir quelque chose de plus général, comme tu l'esquisses, je verrais bien de décaler segment par segment, qu'on viendrait raccorder dans un deuxième temps pour recréer la polyligne. Je ne sais pas si c'est une bonne idée, mais c'est la piste qu' a priori j'explorerais. Amicalement Vincent

(vlax-safearray->list (vlax-variant-value rep)) qui doit retourner une liste (x1 y1 z1 x2 y2 z2 ...) à noter que si on écrit la fonction sous cette forme (setq rep (vlax-invoke spol 'IntersectWith sfac acExtendNone)) on obtient directement une liste sans passer par des safearray et variant. Ce n'est pas directement une liste de points, mais une liste de coordonnées du même type que celle ci-dessus. après, il faut encore transformer (x1 y1 z1 x2 y2 z2...) en ((x1 y1 z1) (x2 y2 z2) ...) amicalement Vincent

Bonjour Olivier, C'est un comportement bizarre qu'on a du mal à reproduire avec des arcs ou des polylignes qu'on dessine directement dans autocad sans l'aide de covadis. Amicalement Vincent