zebulon_

Bonjour, en quelques mots, serait-il possible de connaitre les grandes lignes de la solution pressentie ? Merci Amicalement Vincent

Bonjour, Voir ici le lien vers un fichier dwg qui montre un exemple de décalage. L'exemple montre une polyligne d'origine qui fait 4431.688 de long. On veut se décaler de 10 au départ et de 20 à la fin. Je commence par calculer une sorte de pente (20-10)/4431.688 = 0.22565% Cette polyligne est composée d'un alignement droit de 1004.988, d'une courbe de 1906.683, d'une autre courbe de 486.326 et d'un alignement droit de 1033.691. A chaque sommet, on devrait obtenir un décalage de : 10 10 + 1004.988*0.22565% = 12.268 12.268 + 1906.683*0.22656% = 16.570 16.570 + 486.326*0.22565% = 17.668 17.668 + 1033.691*0.22565% = 20 J'ai aussi regardé ce que ça donnait au milieu de la première courbe : 12.268 + 953.341*0.22565% = 14.419 Je retrouve ces cotes sur mon dessin d'exemple. Le programme semble donc fonctionner, du moins comme je voulais qu'il fonctionne. Il n'empêche qu'il peut y avoir des cas où ça ne marche pas ou alors c'est le principe de l’algorithme qui est complètement foireux. Amicalement Vincent

Bonjour, la critique constructive est toujours la bienvenue. Je n'ai aucune prétention dans le domaine du tracé routier, autre que celle d'en être un utilisateur. En effet, c'est conseillé de mettre le pont à l'intersection de deux routes. Je n'utilise donc qu'un produit fini pensé par un autre et n'ai jamais conçu un projet routier. Je suis d'accord avec lecrabe qui demandait, non pas de réécrire un lisp, mais de fournir un dwg avec un exemple de décalage incorrect. En expliquant où et pourquoi c'est faux, je pourrai certainement corriger le lisp. En quelques mots le principe du lisp (qui est peut être critiquable aussi) : pour chaque sommet, je crée un nouveau sommet obtenu par décalage perpendiculairement à l'original. La valeur du décalage est linéaire en fonction du pk de l'original. A chaque sommet, je ne prends en compte que le segment précédent pour faire la perpendiculaire. De ce fait, si les segments ne sont pas tangents, le résultat sera incohérent. Amicalement Vincent

c'est vrai que je préfère getdist uniquement parce qu'on peut saisir deux points et que le résultat est toujours positif (ou nul !). Quoique, si on tape un négatif à l'invite de getdist, getdist renvoie le négatif. Si ce n'est pas une distance mesurable graphiquement autant prendre getreal. Le programme est assez brut de décoffrage : il n'y a aucun test de validité : - est-ce que l'utilisateur saisit une polyligne, oui ou non ? - est-ce que l'utilisateur saisit des valeurs non nulles et positives ? - que se passe-t-il si le décalage est plus grand que le rayon du cercle, lorsqu'on se décale vers le centrre ? ce genre de choses Amicalement Vincent

En dessous de 70gr, ça devient des ouvrages qualifiés de "très biais" qui demandent des modélisations de calcul différentes. De plus, on imagine bien qu'un tablier qui a la forme d'un parallélogramme très "aplati" peut poser des problèmes de différents ordres : décollement des appuis en élastomère fretté, fragilité de l'angle aigu, ferraillage plus complexe (on ne peut plus ferrailler biais, il faut ferrailler droit et gérer les zones de variation dans les coins), culées, piles, joints de chaussée très longs etc. ça m'arrive. Quand je le fais c'est avec Autocad. En fait, quand je réalise des plans de coffrage des appuis, je rajoute presque toujours une isométrie sur le plan, afin que le maçon comprenne plus rapidement ce qu'on attend de lui. Du coup, une fois que les appuis sont modélisés, c'est facile de les rassembler dans un fichier et de rajouter le tablier. Par exemple ici ou là Amicalement Vincent

Bonjour, Si ça captive, c'est que ça doit être utile ! A charge de revanche ! A ce sujet, je profite de cette tribune pour adresser une demande à l'ensemble des traceurs de routes : - évitez de mettre une clothoïde au droit d'un pont ; - quand vous concevez un rétablissement, mettez de préférence un arc centré sur la pile centrale de l'ouvrage. Cela n'a l'air de rien, mais ça donne des ouvrages symétriques avec 2 culées strictement identiques ; - quand vous pouvez, prévoyez les rétablissements à 100gr, sinon évitez autant que possible les biais inférieurs à 70gr. En gros, considérez que les ouvrages d'art sont une grosse contrainte supplémentaire dans votre projet, pas seulement en matière de gabarit, qui est le minimum syndical. Combien de fois on se complique la tâche en aval parce qu'on se l'est simplifiée en amont. Genre, on a le point haut du profil en long à 50cm (voire moins...) de l'axe de la pile et, de ce fait, deux culées différentes pour 5mm de nivellement. Ou une cloth qui commence à 5m avant la fin du viaduc. Ou des biais de 50gr etc. Mon expérience prouve qu'il arrive souvent que ces points soient négligés en avant projet et qu'on traine le boulet jusqu'en exécution. Merci Amicalement Vincent

oui j'ai oublié de changer la fonction : la première mouture demandait un nombre entier de divisions. Le getint est resté par erreur. Et comme pour le test j'ai tapé sur entrée pour prendre la valeur par défaut, je ne me suis pas rendu compte. Il faut donc changer la fonction comme l'indique très justement Olivier, au bémol près que je préfère utiliser getdist au lieu de getreal. J'ai corrigé le code ci-dessus et le code précédent aussi, car il présentait la même erreur. Amicalement Vincent

Bonsoir à tous, alors, qu'est ce que cette façon de procéder vous inspire ? Merci pour le retour Amicalement Vincent

et pour un tracé de ligne TGV, on a des rayons encore plus grands, j'imagine ! Très bonne idée de prendre la valeur de la flèche pour conditionner le découpage des arcs. J'ai approximé quelque chose en simplifiant, car comme la flèche est petite, le carré de la flèche est négligeable. (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 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:decvar () ;; 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 (getdist (strcat "\nValeur approximative de la flèche de polygonisation 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)) ;; le premier point (setq SEG (car Lsegs)) (mapcar 'set '(P1 BULGE P2) SEG) (if (zerop BULGE) (setq LPT (list (getptsegd SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment droit (setq LPT (list (getptsegc SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment courbe ) ;; les points suivants (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 PT (getptsegd SEG P2)) (setq LPT (cons PT LPT)) ) (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 PAS)) (repeat NBPAS (setq LPT (cons (getptsegc SEG (vlax-curve-GetPointAtDist obj PKcourant)) LPT)) ;; un point à chaque pas (setq PKcourant (+ PKcourant PAS)) ) ;; repeat ) ;; progn ) ;; if ) ;; while (setq LPT (reverse LPT)) (command "_pline") (while LPT (setq PT (car LPT)) (setq LPT (cdr LPT)) (command "_non" (trans PT 0 1)) ) (command "") (princ) ) à voir si à l'usage c'est mieux. Amicalement Vincent

Bonjour, l'idée est donc de déterminer la longueur du segment comme une proportion de la valeur du rayon ? Je ne suis pas un spécialiste du tracé routier, mais j'imagine que les rayons utilisés sont tous du même ordre de grandeur. Alors est-ce que c'est utile de paramétrer en fonction du rayon, compte tenu que les valeurs de rayons restent, je pense, voisines ? Si oui, la question qu'on pourrait se poser c'est : - pour un arc de R=500m, je veux un segment de quelle longueur ? - pour un arc de R=5000m ? Si on prend comme valeur une longueur de segment de 0.0002xR cela vous semblerait raisonnable, dans le but de densifier les arcs de petit rayon et alléger les arcs de grand rayon ? Amicalement Vincent

Disons que la première solution divisait chaque segment courbe en n parties. n étant toujours le même quelle que soit la longueur développée du segment d'arc. Ce qui entraine que les segments d'arc de petite longueur développée sont définis avec plus de précision que les segments à grande longueur développée. La deuxième solution induit une précision du même ordre quelle que soit la longueur développée du segment courbe. Je pense que cette solution doit être plus pratique (et plus compréhensible) pour l'utilisateur, en gardant en mémoire que ça ne fonctionne que pour du tracé routier où on a des rayons très grands et des segments tangents les uns après les autres. On peut aussi progresser tous les 1/36 2pi. Amicalement Vincent

Bonjour, l'idée est séduisante. D'ailleurs, un peu plus tôt dans le fil de discussion, il semblerait que Aleck Ultimate ait proposé quelque chose de similaire. C'est rageant que ce ne soit que visuel, sinon ce serait effectivement et sans aucun doute la solution la plus simple à mettre en oeuvre. Amicalement Vincent

Super, content que ça réponde à ta demande. Par contre, je pense que les routines qui consistent à s'amuser avec les segments de polylignes ne sont pas vraiment à mettre dans la rubrique "débuter en lisp" Par ailleurs, si on applique cette routine à une polyligne où les segments successifs ne sont pas +/- tangents, ça ne donnera pas grand chose (d'où ma question préliminaire). Dans ce cas de figure il faudrait pousser la réflexion un peu plus loin. Amicalement Le Bas-Rhin

voilà j'ai changé le code ci-dessus pour entrer non plus un nombre de divisions mais une longueur de corde, ce qui semble plus "naturel", effectivement. Amicalement vincent

bonjour, C'est sûr que si vous enlevez les segments courbes, ça devient facile. Mais ça marche aussi pour ce cas de figure. Mais, je pense que vous interprétez mal le paramètre de précision. Ce que j'ai paramétré est le nombre de fois que je divise le segment d'arc. Forcément, ça ne peut pas être inférieur à 1. Et si vous mettez la valeur 1, ça va couper les arcs en 1 segment, ce qui n'est pas très précis... Il faudrait plutôt mettre 50 ou 100. Si vous voulez, je peux changer le lisp en demandant de donner une longueur approximative de segment droit plutôt qu'un nombre de division. Ce serait peut être plus parlant et, d'autre part, évite de couper les petits segments courbes en autant de parties qu'un grand segment courbe. Je vais faire ça et publier le lisp modifié. Le plus simple serait de partager un exemple en dwg que je pourrai faire passer dans la moulinette et voir comment ça marche sur un cas concret. Et on pourrait comparer nos résultats. Amicalement Vincent

(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 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:decvar () ;; 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.50)) (setq tmp (getdist (strcat "\nLongueur approximative d'un pas de polygonisation 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)) ;; le premier point (setq SEG (car Lsegs)) (mapcar 'set '(P1 BULGE P2) SEG) (if (zerop BULGE) (setq LPT (list (getptsegd SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment droit (setq LPT (list (getptsegc SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment courbe ) ;; les points suivants (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 PT (getptsegd SEG P2)) (setq LPT (cons PT LPT)) ) (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 NBPAS (fix (/ Larc PREC_COURBE))) (setq PAS (/ Larc NBPAS)) ;; je coupe les courbes en NBPAS segments droits de longueur environ PREC_COURBE (setq PKcourant (+ PKdebut PAS)) (repeat NBPAS (setq LPT (cons (getptsegc SEG (vlax-curve-GetPointAtDist obj PKcourant)) LPT)) ;; un point à chaque pas (setq PKcourant (+ PKcourant PAS)) ) ;; repeat ) ;; progn ) ;; if ) ;; while (setq LPT (reverse LPT)) (command "_pline") (while LPT (setq PT (car LPT)) (setq LPT (cdr LPT)) (command "_non" (trans PT 0 1)) ) (command "") (princ) ) à tester Amicalement Vincent

chaque segment est tangent avec les segments adjacents ? J'imagine que oui, puisqu'on parle de tracé routier. Dans les parties courbes, le résultat serait une suite de segments droits, avec une longueur assez petite pour que cela reste acceptable. On paramètre cette longueur de précision en début de lisp et on permet à l'utilisateur de la changer. Je pense que c'est faisable et je regarderai lundi, à moins que quelqu'un d'autre se soit penché sur le sujet entre temps :) Amicalement Vincent

finalement, avec la date des messages j'ai retrouvé : https://www.dropbox.com/sh/ijhqgfavceqdm3x/AAAGpazrI6hvN_tYzDYtb2h5a?dl=0 si je ne me suis pas trompé Amicalement Vincent

Bonjour, en principe je ne jette rien. Mais si tu me dis comment s'appelle le fichier lsp cela m'aiderait à le retrouver Amicalement Vincent

Bonjour, personnellement, j'évite les images insérées en objet OLE qui entrainent un alourdissement du fichier qu'on n'a pas, par définition, avec des références externes. Cela me gène toujours de voir la taille de mon fichier multiplié par 5 après avoir ajouté le cartouche ! Puis, pour délimiter une image, on peut utiliser la commande DELIMIMAGE. La variable IMAGEFRAME, quant à elle, permet de contrôler la visibilité du contour de délimitation. Amicalement Vincent

Bonjour, L'ami Tramber n'a pas que programmé dans son coin. Il parait que les enfants ça occupe, surtout quand ils sont petits ! Perso, mon premier lisp a consisté à dessiner un béton de propreté sous une semelle, avec l'épaisseur et les petits débords qui vont bien. Ce qui me fait plaisir, c'est que je m'en sers toujours. Ce qui est moins bien, c'est que je serai incapable de le transcrire en .NET Amicalement Vincent

Il faudrait garder le résultat du getkword. Le plus simple, c'est d'utiliser une variable générale (donc non déclarée dans le (/ ...) du defun). Cette variable, dont on essaiera de choisir un nom suffisament spécifique pour ne pas risquer qu'il soit utilisé par un autre lisp, conservera sa valeur tant que le fichier est ouvert. Au début du lisp, on vérifie si cette variable est nil. Si oui, on définit une valeur par défaut, sinon on prend la valeur qu'elle contient. On peut aussi enregistrer des données dans le fichier dwg, pour retrouver la valeur d'une variable même après fermeture/ouverture d'une fichier, avec les vlax-ldata-put et vlax-ldata-get. Amicalement Vincent

moi, ça me coûte un ticket de bus pour voir la même chose. Euh, non, les bus ça sait pas encore voler... :P Ce qui est amusant c'est d'avoir pu revoir sous un autre angle mon ancien lieu de travail, rue du Maréchal Foch. C'est dans ce qu'on appelle la "Neustadt", autour de la place de la République. Une "Nouvelle ville" construite par les allemands entre 1870 et 1918. On y trouve le palais impérial, la préfecture, la trésorerie générale, la bibliothèque et l'ancien parlement d'Alsace et de Lorraine, transformé en théâtre. Une grande avenue vous emmène jusqu'à l'université en passant devant l'ancienne église de garnison protestante. Le pouvoir d'un côté, le savoir de l'autre et la religion au milieu. Les étudiants allemands en architecture viennent à Strasbourg pour voir ce qu'est l'architecture allemande (qu'on qualifie je crois de wilhelmienne) de la fin du 19ème, début 20ème. En Allemagne même, cette architecture a beaucoup souffert des bombardements alliés, alors qu'à Strasbourg beaucoup moins. Seuls le parlement a vu sa partie arrière disparaitre, ainsi qu'une petite partie du palais impérial. La façade la plus curieuse de Strasbourg est sans aucun doute celle-ci. Surprenant non ? Amicalement Vincent

J'ai fait mon service militaire au 1er régiment de génie, ça doit venir de là mon côté génial, sans doute ! Je plaisante... J'étais bien au 1er RG mais en tant que VFI, donc mis à disposition du ministère du travail, de l'emploi et de la formation professionnelle, qui m'a ensuite mis à disposition du ministère de l'agriculture, plus particulièrement d'un lycée agricole. C'était génial, je n'allais à la caserne que pour toucher la solde de 444 francs... J'ouvre une parenthèse : c'était un peu un service civique avant l'heure et je profite de la tribune pour encourager tous les jeunes de 16 à 25 ans à se lancer pour effectuer une mission au service de l'intérêt général. Rien à voir avec le lisp ? Si, c'est au cours de cette mission que j'ai découvert ce langage de programmation et son génial inventeur. Je referme la parenthèse. Amicalement Vincent

à la place de (setq ent (entlast)) on peut mettre (setq ent (car (entsel))) la fonction (entsel) retourne une liste dont le premier élément est le nom de l'entité choisie et dont le second élément est la liste des coordonnées du point utilisé pour la sélection. D'où l'utilisation de la fonction (car...), qui retourne le premier élément d'une liste, compte tenu que c'est le nom de l'entité qui nous intéresse. A noter qu'avec (entsel), on peut aussi "personnaliser" le message affiché (entsel "\nVeuillez choisir une polyligne : ") Amicalement Vincent