zebulon_

Salut Tramber, ok, mais il n'en reste pas moins que Néophyte, comme son nom l'indique, viens juste d'apprendre à marcher, et encore, il trébuche souvent. Et tu lui proposes d'emblée de piloter un avion de chasse... :) Amicalement Vincent

c'est un problème, a priori. Lequel des 2 objets générés on garde ? Par ailleurs, c'est bien trop compliqué pour un débutant, même si c'est sans doute une voie vers laquelle il faut aller, mais pas tout de suite ! J'ai pensé à encore plus simple en se débrouillant avec des (command ...) : - on duplique la polyligne courbe - on fait un ajuster de la copie de la polyligne jaune par rapport à la polyligne rouge mais je n'ai pas le temps d'approfondir Amicalement Vincent

Bonjour, voilà un objectif ambitieux que tu n'es pas prêt d'atteindre, à moins d'avoir une route à sens unique. Quand on a une route "normale", les voitures circulent dans un sens côté droit et dans l'autre sens côté gauche. Donc, pour un des côtés, le sens de la polyligne sera toujours inversé, cela me semble inévitable... Généralement, la polyligne qui représente l'axe routier est représentée dans le sens des pk croissants. La question ne serait-elle donc pas plutôt de savoir si tu veux étudier la voie montante (dans le sens des pk croissants) ou la voie descendante (dans le sens inverse des pk) ? Par ailleurs, en variante de la solution d'Olivier pour visualiser le sens d'une pline, j'ai fait ceci Amicalement Vincent

Salut Tramber, l'objectif est d'éviter de saucissonner la polyligne de base et mon idée de départ était de recréer un bout de polyligne en partant d'un point d'intersection, pour la finir à l'autre point d'intersection en créant au passage les segments (droit ou courbes) à partir de la polyligne de base. Mais cela me semblait un peu trop ardu pour un Néophyte que d'aller piocher dans les bulges et autres propriétés de polylignes et j'ai préféré passer par une solution de discrétisation qui me paraissait plus simple à appréhender et suffisante pour faire une hachure. Peut être à tort ? En fait, c'est assez simple si on a les outils qui vont bien : - j'ai une fonction qui récupère les segments d'une polyligne sous forme de liste ((pt1 bulge1 pt2) ... (ptdn bulgen ptfn)) (voir afralisp) - la fonction (vlax-curve-getParamAtPoint curve-obj point) peut s'avérer très utile pour déterminer sur quel segment de la polyligne curve-obj se situe le point. Le paramètre renvoyé s'il est par exemple 1.5, alors on sait que le point est au milieu du 2ème segment, s'il est 2.75 alors il est au 3/4 du 3ème segment... si le point est un sommet, on a une valeur entière. J'ai fait quelques essais sur une polyligne car je n'ai pas trouvé dans l'aide ce que signifie ce Param où on ne nous dit uniquement "A number representing a parameter..." ce qui n'est pas très parlant ! - on ne prend dans la liste de segments que ceux qui nous intéressent en raccourcissant le premier et le dernier - on crée une nouvelle pline à partir de cette liste puis on fait la hachure sur cette base voilà sur le principe Amicalement Vincent

j'ai oublié de rajouté (vl-load-com) au début du lisp Amicalement Vincent

Bonjour, quand on fait une hachure, on a la possibilité de donner un point à l'intérieur d'une surface fermée pour obtenir une "inondation" de la hachure dans ladite surface. Dans le cas décrit par l'image jointe, cela risque de na pas marcher compte tenu de la présence d'éléments étrangers au projet (fond de plan...) qui risquent d'influer sur l'aspect de la hachure et, surtout, sur la durée de réalisation de la hachure. L'expérience montre que plus il y a d'éléments complexes à l'écran (blocs, xrefs etc...) plus la hachure par point met du temps à déterminer la zone à hachurer. J'en arrive à la conclusion qu'il faut abandonner l'idée de la hachure par ajout de point et faire une hachure par contour. Le schéma fait apparaitre une droite et une courbe. Le problème étant la courbe, on s'en doute ! En plus, comme il s'agit de tracé routier, ce bout de courbe peut aussi bien être un segment d'arc qu'une suite de segments droits formants une clothoïde. Je pense donc que le plus simple est de s'appuyer sur ces 2 polylignes pour tracer une surface polygonale fermée en plaçant des points tous les x mètres (en fonction de la précision voulue) le long de la courbe. La précision importe peu : ce n'est qu'une hachure ! Enfin, je pense ? un exemple : (defun c:hzone () (vl-load-com) (defun LM:intersections (ob1 ob2 mod / lst rtn) ;; Intersections - Lee Mac ;; Returns a list of all points of intersection between two objects ;; for the given intersection mode. ;; ob1,ob2 - [vla] VLA-Objects ;; mod - [int] acextendoption enum of intersectwith method (setq lst (vlax-invoke ob1 'intersectwith ob2 mod)) (repeat (/ (length lst) 3) (setq rtn (cons (list (car lst) (cadr lst) (caddr lst)) rtn) lst (cdddr lst) ) ) (reverse rtn) ) (defun do_hach_zone (p1 p2 / LSTPT PT1 PT2 pkPT1 pkPT2 nbpas PAS PLCONTOUR) ;; on suppose que p1 est courbe : arc ou succession de segments d'une clothoïde ;; et que p2 est une droite ;; on détermine les 2 points d'intersection entre p1 et p2 (setq p1 (vlax-ename->vla-object p1) p2 (vlax-ename->vla-object p2) ) (setq LSTPT (LM:intersections p1 p2 acextendnone)) (if (>= (length LSTPT) 2) (progn ;; si on a trouvé au moins 2 points d'intersection (setq PT1 (car LSTPT)) ;; le premier point d'intersection (setq PT2 (cadr LSTPT)) ;; le deuxième point d'intersection (setq pkPT1 (vlax-curve-getDistAtPoint p1 PT1)) ;; le pk du premier point (setq pkPT2 (vlax-curve-getDistAtPoint p1 PT2)) ;; le pk du deuxième (setq nbpas 20) ;; le nombre de pas fixé arbitrairement à 20, à augmenter si pas assez précis (setq PAS (/ (- pkPT2 pkPT1) nbpas)) ;; on calcule la valeur d'un pas ;; on trace la polyligne fermée de contour (command "_pline" "_non" (trans (vlax-curve-getPointAtDist p1 pkPT1) 0 1)) (repeat (- nbpas 1) (setq pkPT1 (+ pkPT1 PAS)) (command "_non" (trans (vlax-curve-getPointAtDist p1 pkPT1) 0 1)) ) (command "_non" (trans (vlax-curve-getPointAtDist p1 pkPT2) 0 1) "_c") (setq PLCONTOUR (entlast)) ;; et on fait la hachure avec ce contour ;; hachure "utilisateur" avec un angle de 45 et un espacement de 2.00 (command "_hatch" "_p" "_u" "45" "2.00" "_n" "_s" PLCONTOUR "") ;; si on veut effacer le contour... ;; (command "_erase" PLCONTOUR "") ) (alert "Pas assez de points d'intersection !") ) ) (setq Jaune (car (entsel "\nSélectionner la courbe jaune : "))) (setq Rouge (car (entsel "\nSélectionner la droite rouge : "))) (do_hach_zone Jaune Rouge) (princ) ) Amicalement Vincent

Bonjour, pour une fois qu'on peut en tirer quelque chose de positif... puisqu'il semblerait, compte tenu des messages que j'ai vu passer, qu'Autocad MAC ne soit pas spécialement génial. Amicalement Vincent

Bonjour, je ne connaissais pas ces nouvelles fonctions GetPropertyValue et SetPropertyValue qui sont apparues pour la 2012. Je n'ai pas fait l'essai (suis sur un ordi sans autocad pour le WE...), mais cela me semble plus qu'intéressant et simplifie beaucoup de choses ! Par contre, si j'ai bien compris, ce sont des fonctions purement lisp (pas vlisp). Faut-il donc que le E qui est injecté dans ces fonctions soit absolument de type ename ou alors cela peut être un vla-object ? Le seul point négatif est d'être obligé d'avoir 2012 ou plus. Merci Amicalement Vincent

Bonjour, la solution la plus simple est d'insérer le bloc sans renseigner les attributs (donc avec ATTREQ à 0), puis de modifier l'attribut du bloc qu'on vient d'insérer avec quelque chose de ce style (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) ) ) ) où E est le ENAME ou le VLA-OBJECT du bloc à modifier ETIQ l'étiquette et VALEUR, la valeur, on s'en doute... L'avantage est qu'on se passe de connaitre la position de l'attribut dans le bloc (modif_attrib MONBLOC "PRENOM" "Paul") Amicalement Vincent

Bonjour, Il y a de cela quelques années, nous avons parlé de ce sujet Afin de rendre à César ce qui est à César et à Jordan ce qui est à Jordan, je vous invite à consulter le théorème de Jordan Une proposition de code dont l'objectif est de savoir où est un point par rapport à une polyligne plane fermée. Le principe est simple : on trace une demi-droite à partir du point étudié et on compte le nombre d'intersections avec la polyligne. Si ce nombre est pair, on est à l'extérieur, sinon à l'intérieur. La difficulté est qu'il faut s'assurer que la demi-droite ne passe ni par un sommet de la polyligne, ni par un point de tangence s'il y a des segments courbes. (defun getpolySegs (ent / PTL I PTB SEG LSEG) ;; Afralisp ;; renvoie les segments d'une polyligne ;; sous la forme d'une liste ;; '(((x1 y1) bulge1 (x2 y2)) ... ((xn-1 yn-1) bulgen (xn yn))) (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) ;; Afralisp ;; renvoie les informations d"un segment courbe ;; sous la forme d'une liste '((xc yc) R) ;; ;; 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 randnum (/ modulus multiplier increment random) ;; afralisp ;; renvoie un nombre pseudo aléatoire entre 0 et 1 ;; (if (not seed) (setq seed (getvar "DATE")) ) (setq modulus 65536 multiplier 25173 increment 13849 seed (rem (+ (* multiplier seed) increment) modulus) random (/ seed modulus) ) ) (defun inout (pt ent / AcDoc Space RES LSEG LANGLE ArcInf D D1 ANG pttan1 pttan2 RAY NBPTS) ;; revoie 0 -> pt est sur ent ;; +1 -> pt à l'intérieur de ent ;; -1 -> pt à l'extérieur de ent ;; (setq AcDoc (vla-get-activeDocument (vlax-get-acad-object)) Space (if (= (getvar "CVPORT") 1) (vla-get-PaperSpace AcDoc) (vla-get-ModelSpace AcDoc) ) ) (if (equal (distance pt (vlax-curve-GetClosestPointTo ent pt)) 0.0 1e-10) ;; pt est sur le contour (setq RES 0) (progn (setq LSEG (getpolysegs ent)) (foreach X (mapcar 'car LSEG) ;; je collectionne tous les angles que fait pt avec chaque sommet (setq LANGLE (cons (angle PT X) LANGLE)) ) (foreach X (vl-remove-if '(lambda (x) (zerop (cadr x))) LSEG) ;; on ne garde que les segments qui ont une courbure (setq ArcInf (getarcinfo X)) (setq D (distance PT (car ArcInf))) (if (> D (cadr ArcInf)) ;; on ne cherche les tangentes que si le point est en dehors du cercle (progn (setq D1 (sqrt (- (expt D 2) (expt (cadr ArcInf) 2)))) (setq ANG (atan (/ (cadr ArcInf) D1))) (setq pttan1 (polar pt (+ (angle pt (car ArcInf)) ANG) D1)) (setq pttan2 (polar pt (- (angle pt (car ArcInf)) ANG) D1)) (setq LANGLE (cons (angle PT pttan1) LANGLE)) ;; je collecte les points de tangence que je garde (setq LANGLE (cons (angle PT pttan2) LANGLE)) ;; même s'ils ne sont pas forcément sur le contour de ent. ) ) ) ;; foreach ;; on cherche un angle pour tracer la demi-droite différent de ceux collectés ci-dessus ;; pour s'assurer que la demi-droite ne passera pas par un sommet ou un point de tangence (while (member (rtos (setq ANG (* (randnum) 2 pi)) 2 2) (mapcar '(lambda (x) (rtos x 2 2)) LANGLE)) ) (setq RAY (vla-addRay Space (vlax-3d-point pt) (vlax-3d-point (polar pt ang 1.00)))) ;; on trace une demi-droite (setq NBPTS (/ (length (vlax-invoke ent 'IntersectWith RAY acExtendNone)) 3)) ;; on regarde le nombre de point (vla-erase RAY) (cond ((= (rem NBPTS 2) 0) (setq RES -1)) ;; c'est pair donc c'est à l'extérieur (T (setq RES 1)) ;; c'est impair donc à l'intérieur ) ) ) RES ) ;; defun (defun c:test (/ ent pt RES) (and (setq ent (car (entsel "\nSélectionnez une polyligne: "))) (setq ent (vlax-ename->vla-object ent)) (= (vla-get-ObjectName ent) "AcDbPolyline") (= (vla-get-Closed ent) :vlax-true) (setq pt (trans (getpoint "\nSpécifiez un point: ") 1 0)) (setq RES (inout pt ent)) (cond ((zerop RES) (alert "Sur le contour")) ((minusp RES) (alert "Dehors")) (T (alert "Dedans")) ) ) (princ) ) Amicalement Vincent

Bonjour, en même temps, ce lisp n'aura pas une très grande longévité en tant que tel, compte tenu que la version 2016 (que je n'ai pas encore installée chez moi...) apporte une amélioration importante de ces nuages de révision. Et l'amélioration va, à certains égards, bien plus loin que le lisp , compte tenu que ces nouveaux REVCLOUD sont, d'après ce que j'ai pu voir dans les commentaires ici et là sur la toile, conçus comme des objets étirables par le biais de poignées. Avec 2016, on peut (enfin...) étirer un REVCLOUD comme on étire un rectangle ou une polyligne. Le nuage conserve la géométrie de l'objet qui a servi à le construire et on peut modifier le nuage en modifiant cet objet de base. Pour donner une image, cela ressemble un peu au fonctionnement d'une polyligne qu'on a transformé en sPline via Pedit. Dès que j'aurai installé 2016, je me pencherai sur la question. Merci à ceux qui utilisent 2016 pour un éventuel retour d'expérience. Amicalement Vincent

Bonjour, Par le plus grand des hasards, j'ai déposé ceci aujourd'hui et qui peut être en rapport : nuage de révision Amicalement Vincent

Bonjour, le plus souvent, il suffirait de créer le nuage de révision à partir d'un rectangle (donc 2 points), ou d'un cercle (2 points aussi) ou d'une polyligne pas trop compliquée. De plus, les longueurs d'arc pourraient se déterminer automatiquement en fonction de la taille - de l'encombrement - du contour qui sert à générer le nuage. Par défaut, j'ai choisi le 10ème de l'encombrement du contour. Pour finir, ce serait bien que le nuage créé se mette sur un calque "REVCLOUD" (ou autre...) En fait, je n'aime pas trop le concept du trajet à main levée : faut que j'arrête l'alcool... Souvent, la souris s'égare ou alors j'ai du mal à fermer le contour et ça donne juste une m... et il faut recommencer. Au moins, avec à la base un rectangle, un cercle ou une polyligne (fermée ou non), c'est plus simple et, pendant le tracé d'une polyligne, on peut revenir en arrière si on s'est un peu égaré en cours de route. (defun c:recrev (/ AcDoc Space FORME FAC ST MSG PT1 R lelem cmdsave TEMP old_clayer mycmdrev fac_ent get_msg_recrev calque) (vl-load-com) (setq AcDoc (vla-get-activeDocument (vlax-get-acad-object)) Space (if (= (getvar "CVPORT") 1) (vla-get-PaperSpace AcDoc) (vla-get-ModelSpace AcDoc) ) ) ;;; ;;; lancer une commande autocad (defun mycmdrev (CMD PT / ETL LELEM RES OLDCMDECHO) (setq ETL (entlast)) (setq OLDCMDECHO (getvar "CMDECHO")) (setvar "CMDECHO" 1) (command CMD PT) (while (not (zerop (getvar "cmdactive"))) (command pause) ) (setvar "CMDECHO" OLDCMDECHO) (setq LELEM nil) (if (not ETL) (setq ETL (entnext)) (setq ETL (entnext ETL)) ) (while ETL (setq LELEM (cons ETL LELEM)) (setq ETL (entnext ETL)) ) (setq RES LELEM) ) (defun fac_ent (e / util obj minpoint maxpoint) (setq util (vla-get-utility (vla-get-activedocument (vlax-get-acad-object)))) (setq obj (vlax-ename->vla-object e)) (vla-GetBoundingBox obj 'minpoint 'maxpoint) (distance (vlax-safearray->list minpoint) (vlax-safearray->list maxpoint) ) );defun (defun get_msg_recrev (FORME) (cond ((= FORME "Rectangulaire") "\nSpécifiez le premier coin :" ) ((= FORME "Circulaire") "\nSpécifiez le centre :" ) ((= FORME "Polygonal") "\nSpécifiez le point de départ :" ) ) ) ;;; créer un calque (defun calque (NewLayer ColLayer TlLayer LwLayer / LtTable LayerTable aNewLayer) (if (not (tblsearch "LTYPE" TlLayer)) ;; charger le style de traits (progn (setq LtTable (vla-get-LineTypes AcDoc)) (vla-load LtTable TlLayer "acadiso.lin") ) ) (setq LayerTable (vla-get-layers AcDoc)) (if (not (tblsearch "LAYER" NewLayer)) (progn ;; créer le calque qui n'existe pas (setq aNewLayer (vla-add LayerTable NewLayer)) (vla-put-color aNewLayer ColLayer) (vla-put-LineType aNewLayer TlLayer) (vla-put-LineWeight aNewLayer LwLayer) ) (progn ;; le calque existe -> le rendre disponible (setq aNewLayer (vla-item LayerTable NewLayer)) (if (= (vla-get-Lock aNewLayer) ':vlax-true) (vla-put-Lock aNewLayer :vlax-false) ) (if (= (vla-get-Freeze aNewLayer) ':vlax-true) (progn (vla-put-Freeze aNewLayer :vlax-false) (vla-regen AcDoc acAllViewports) ) ) (if (= (vla-get-LayerOn aNewLayer) ':vlax-false) (vla-put-LayerOn aNewLayer :vlax-true) ) ) ) (setvar "CLAYER" NewLayer) ;; et le rendre actif ) (setq cmdsave (getvar "cmdecho")) (setvar "cmdecho" 0) (or (setq FORME (vlax-ldata-get "CADSYS" "FORME_RECREV")) (setq FORME "Rectangulaire") ) (or (setq FAC (vlax-ldata-get "CADSYS" "FAC_RECREV")) (setq FAC 0.1) ) (or (setq ST (vlax-ldata-get "CADSYS" "ST_RECREV")) (setq ST "Normal") ) (setq MSG (get_msg_recrev FORME)) (setq PT1 nil) (while (/= (type PT1) 'list) (prompt (strcat "\nForme du nuage : " FORME " Style : " ST "\nFacteur de densité : " (rtos FAC))) (initget "Rectangulaire Circulaire Polygonal Style Facteur") (or (setq PT1 (getpoint (strcat MSG " [Rectangulaire/Circulaire/Polygonal/Style/Facteur] <Facteur> : "))) (setq PT1 "Facteur") ) (cond ((= PT1 "Facteur") (initget 6) ;; pas de zéro ni de négatif (setq TEMP (getdist (strcat "\nNouveau facteur de densité (non nul et inférieur à 0.50) <" (rtos FAC) "> : "))) (if TEMP (setq FAC (min TEMP 0.50)) ) ) ((= PT1 "Style") (initget "Normal Calligraphie") (setq TEMP (getkword (strcat "\nSélectionner le style d'arc : [Normal Calligraphie] <" ST ">"))) (if TEMP (setq ST TEMP) ) ) ((member PT1 '("Rectangulaire" "Circulaire" "Polygonal")) (setq FORME PT1) (setq MSG (get_msg_recrev FORME)) ) ) ) (cond ((= FORME "Rectangulaire") (setq lelem (mycmdrev "_RECTANG" PT1)) ) ((= FORME "Circulaire") (setq lelem (mycmdrev "_CIRCLE" PT1)) ) ((= FORME "Polygonal") (setq lelem (mycmdrev "_PLINE" PT1)) ) ) (if lelem (progn (setq old_clayer (getvar "CLAYER")) (setq old_delobj (getvar "DELOBJ")) (setvar "DELOBJ" 3) ;; Supprime toute la géométrie de définition (calque "REVCLOUD" 7 "Continuous" 18) (setq R (* (fac_ent (car lelem)) FAC)) (command "_revcloud" "_s" (strcat "_" (substr ST 1 1)) "_a" R R "_o" (car lelem) "_n" ) ;; dessine le nuage (vlax-ldata-put "CADSYS" "FORME_RECREV" FORME) (vlax-ldata-put "CADSYS" "FAC_RECREV" FAC) (vlax-ldata-put "CADSYS" "ST_RECREV" ST) (setvar "CLAYER" old_clayer) (setvar "DELOBJ" old_delobj) ) (alert "Pas de contour créé") ) (setvar "cmdecho" cmdsave) (princ) ) Amicalement Vincent

Même parcours pour moi avec beaucoup moins de langages différents et seulement depuis 1985 pour la programmation et depuis Autocad R12 (après MicroStation) pour le dessin, MAIS j'essaye de ne pas oublier. Pour la petite histoire, mon premier ordi était un Thomson TO9... Amicalement Vincent

Comparer des réels est toujours dangereux. Comparer des listes de réels l'est encore plus. Je propose simplement quelque chose qui fait la même chose en plus sûr, avec l'option de ne pas s'assurer si on estime que ce n'est pas nécessaire en mettant le fuzz à nil. J'étais juste un peu étonné par la formulation de ta réponse où tu en fais un peu des tonnes. Ensuite, elle laisse sous-entendre que ma solution n'est pas fiable parce qu'elle n'a pas été écrite par Gilles. Peut être as-tu raison, je n'ai fait que reprendre quelque chose d'existant en essayant d'y rajouter ce qui me semblait manquer. Pour terminer, je m'étonne également qu'un problème aussi simple n'est pas à la portée de quelqu'un de ton expérience. Si un petit nouveau venait déposer sa requête comme tu l'as fait, il se serait fait envoyer sur les roses vite fait avec des commentaires du genre : "commence par faire quelque chose et après on te dira ce qui va et ce qui ne va pas" Amicalement Vincent

Oui, mais tu peux faire confiance aux autres également, à commencer par toi-même. Si quelqu'un propose une amélioration ou une généralisation de quelque chose qui a été inventé par quelqu'un d'autre, c'est dans un souci de progrès. Depuis Cro-Magnon, c'est quand même un état d'esprit assez fréquent. J'attends une critique de la méthode proposée (en bien ou en mal), pas qu'on me dise "je ne regarde même pas ce que tu proposes car c'est un problème qui ne me concerne qu'à la marge". Sans vouloir te vexer, je ne te trouve pas très constructif en l'occurrence. Amicalement Vincent

Bonjour, Noir et blanc pour moi également. Étant membre du club des nostalgiques du Rotring... Enfin, nostalgique pas vraiment ! On arrive très bien à se faire comprendre avec 4 plumes d'épaisseurs différentes. La seule "coquetterie" dont on disposait à l'époque de la planche à dessin était, pour certains, la densité des hachures. Dans mon métier où on ne traite que du béton, la hachure était uniquement en SOLIDE (ça allait plus vite que faire des hectares de hachures parallèles) et était réalisée au verso du calque avec un crayon rouge dont les traits étaient fondus avec une estompe cylindrique en papier buvard. Le but étant de matérialiser la section du béton sur les coupes. L'estompe de couleur rouge donnait une hachure pleine grisée au tirage à l'ammoniaque. Je reproduis cela aujourd'hui en utilisant les couleurs grises pour les hachures (solides ou parallèles). J'essaye de rester le plus simple possible également avec les motifs de hachures. Amicalement Vincent

Bonjour, j'aimerais proposer une généralisation de la fonction remove_doubles en intégrant une possibilité d'écart maximal. Il arrive quand même assez fréquemment que deux nombres ou deux listes semblent identiques mais peuvent différer très légèrement si différentes méthodes ont été utilisées pour les calculer. L'idée est de rajouter un paramètre supplémentaire fuzz et de remplacer vl-remove par vl-remove-if dont la fonction prédicat contiendra (equal expr1 expr2 fuzz) ;;; gc:remove_doubles (gile) (defun gc:remove_doubles (lst) (if lst (cons (car lst) (gc:remove_doubles (vl-remove (car lst) lst))) ) ) ;;; cs:remove_doubles_fuzz (defun cs:remove_doubles_fuzz (lst fuzz) (if lst (cons (car lst) (cs:remove_doubles_fuzz (if fuzz (vl-remove-if '(lambda (x) (equal x (car lst) fuzz)) lst) (vl-remove (car lst) lst) ) fuzz ) ) ) ) (defun c:removedbl () (setq l1 '(1 2 3 4 1 2 3 4 1.001 2.001 3.001 4.001)) (print (gc:remove_doubles l1)) (print (cs:remove_doubles_fuzz l1 0.01)) (print (cs:remove_doubles_fuzz l1 nil)) (setq l2 '((1 1 1) (1 1 1) (2 2 2) (2 2 2) (1.001 1.001 1.001) (2.001 2.001 2.001))) (print (gc:remove_doubles l2)) (print (cs:remove_doubles_fuzz l2 0.01)) (print (cs:remove_doubles_fuzz l2 nil)) (princ) ) Dommage qu'avec les fonctions lisp, on ne peut pas avoir de paramètre optionnel... Votre avis ? Amicalement Vincent

plus léger, dans le sens que c'est un seul objet. Si tu fais une hachure, il faut un contour. Cela en fait deux, le contour et la hachure. Le seul avantage qu'on pourrait avoir avec une hachure est qu'elle n'est pas forcément en solide, alors que le solide... Amicalement Vincent

Bonjour, symboliser une trémie dans un ouvrage BA en donnant 3 points d'une trémie rectangulaire. ;;; Clockwise-p ;;; Retourne T si les points p1 p2 et p3 tournent dans le sens horaire (defun clockwise-p (p1 p2 p3) (< (sin (- (angle p1 p3) (angle p1 p2))) -1e-14) ) (defun c:tremie (/ PT1 PT2 PT3 TEMP a1 d1 a2 d2 PT3bis PTI d P1 P2 P3 P4) (setq PT1 (getpoint "\nPremier point d'un côté : ") PT2 (getpoint PT1 "\nDeuxième point d'un côté : ") PT3 (getpoint "\nTroisième point perpendiculaire au côté : ") ) ;; on s'arrange pour que ça tourne toujours dans le sens horaire (or (clockwise-p PT1 PT2 PT3) (setq TEMP PT1 PT1 PT2 PT2 TEMP ) ) (setq a1 (angle PT1 PT2)) (setq d1 (distance PT1 PT2)) (setq a2 (+ a1 (* 3 (/ pi 2)))) (setq PT3bis (polar PT3 a2 1)) (setq PTI (inters PT1 PT2 PT3 PT3bis nil)) (setq d2 (distance PT3 PTI)) (setq PT3 (polar PT2 a2 d2)) (setq d (min d1 d2)) (setq P1 (polar pt1 (+ a1 (* 7 (/ pi 4))) (/ d 20))) (setq P2 (polar pt2 (+ a1 (* 5 (/ pi 4))) (/ d 20))) (setq P3 (polar pt3 (+ a1 (* 3 (/ pi 4))) (/ d 20))) (setq P4 (polar p2 (+ a1 (* 5 (/ pi 4))) (/ d 10))) (command "_solid" "_non" P1 "_non" P2 "_non" p4 "_non" p3 "") (princ) ) Amicalement Vincent

Bonjour, c'est vrai qu'elles mériteraient quelques améliorations, mais globalement c'est mieux foutu que les lignes de repère de cotation. Les points qui mériteraient d'être améliorés dans les mleader : - le masque d'arrière plan n'est pas dans la définition du style de mleader - la cotation des tolérances géométriques est absente dans mleader et il faut reprendre les anciennes lrepere pour cela. - d'autres points, certainement... Amicalement Vincent

Bonjour, est-ce que la flèche doit être absolument de cette forme ? Sinon, si une flèche plus classique est possible, je crois que cela serait beaucoup plus simple à gérer avec une ligne de repère multiple à laquelle on associe un bloc avec attribut. Du coup, on peut rajouter/enlever des flèches. Pour la rotation, c'est plus délicat. La ligne de repère multiple n'a un paramètre de rotation du texte que lorsqu'il s'agit d'une ligne de repère multiple avec un texte. Si c'est une ligne de repère multiple avec un bloc, ce paramètre n'existe pas. A priori, il faudra faire une rotation de toute la ligne de repère, y compris les flèches. Avec des lignes de repère lrepere (du menu cotation), on arrive à faire tourner plus facilement les blocs associés aux flèches. Mais cela reste un ensemble de 2 objets, une flèche et un bloc qui lui est associé. Si on bouge le bloc, la flèche se modifie. Par contre, si on modifie (ou on supprime) la flèche, le bloc ne bougera pas. Dans le fichier, il y a les 2 cas : ligne de repère multiple (que je préfère) et ligne de repère Amicalement Vincent TestLrep.zip

...c'est encore plus court et ça correspond à la première solution proposée par Lee Mac dans le sujet référencé. Amicalement Vincent

(defun vl-pat2(ele lst) (setq i -1) (vl-remove nil (mapcar '(lambda(x)(setq i (1+ i))(if (eq x ele) i nil)) lst)) ) le nil dans le sinon du if n'est pas forcément nécessaire. Si on ne met rien, le sinon revoie de toute manière nil, pas besoin de le préciser explicitement. (defun vl-pat2(ele lst) (setq i -1) (vl-remove nil (mapcar '(lambda(x)(setq i (1+ i))(if (eq x ele) i)) lst)) ) Du coup, c'est encore plus court :) Amicalement Vincent

Au lieu de numéroter bêtement chaque élément, tu ne numérotes que les représentants de la clé recherchée. Les autres éléments héritent d'un nil que tu enlèves facilement de la liste. Bien vu ! Amicalement Vincent