(gile)

Pour info, contrairement à ce qui est dit dans l'aide, les fonctions vlax-curve fonctionnent aussi avec des arguments de type ENAME (elles s'exécutent même un peu plus rapidement). ((lambda (curve) (vlax-curve-getDistAtParam curve (vlax-curve-getEndParam curve))) (car (entsel)))

Pour la longueur des objets curviligne (excepté les droites et demi-droites bien sûr) utiliser : (vlax-curve-getDistAtParam curve (vlax-curve-getEndParam curve))

Salut, Pas d'arguments optionnels en AutoLISP / Visual LISP. Le seul moyen de contourner serait de passer comme argument une liste contenant les arguments. Mais je trouve ça lourdingue de tester la présence (et/ou le type) des arguments contenus dans la liste.

Le produit vectoriel de deux vecteurs non colinéaires renvoie le vecteur perpendiculaire au plan défini par ces deux vecteurs. Si on fait le produit vectoriel du vecteur AB et du vecteur v1 (0 0 1) on obtient le vecteur perpendiculaire au plan vertical contenant AB (axe). Si ensuite on fait le produit vectoriel de ce vecteur avec le vecteur AB on obtient le vecteur v2. ;; gc:CrossProduct ;; Retourne le produit vectoriel (vecteur) de deux vecteurs ;; Arguments ;; v1, v2 : deux vecteurs (defun gc:CrossProduct (v1 v2) (list (- (* (cadr v1) (caddr v2)) (* (caddr v1) (cadr v2))) (- (* (caddr v1) (car v2)) (* (car v1) (caddr v2))) (- (* (car v1) (cadr v2)) (* (cadr v1) (car v2))) ) ) (setq a (getpoint) b (getpoint a) vab (mapcar '- b a) v1 '(0. 0. 1.) axe (gc:CrossProduct vab v1) v2 (gc:CrossProduct axe vab) ) (entmake (list (cons 0 "LINE") (cons 10 a) (cons 11 (mapcar '+ a v2))))

Soit le segment AB appartenant à un plan vertical, il est représenté sur l'épure de gauche de façon à être parallèle à la ligne de terre* pour apparaître en vrai grandeur sur la projection verticale (A'B'). Sur l'épure de droite tous les vecteurs contenus dans le plan (P) perpendiculaire à AB (dont les traces sur les plans de projections sont en cyan) sont perpendiculaires au segment AB. Les segments BC, BD et BE figurent des exemples de ces vecteurs, BC appartenant au même plan vertical que AB, BD à un plan horizontal, BE est quelconque. *LT, la droite figurant la charnière entre les plans de projections vertical (au dessus) et horizontal (en dessous).

Salut, Je ne comprends pas ce que tu veux faire. Jusque là, OK soit deux points et le plan vertical qui les contient. Mais nomme les points ( A et B ) en les situant sur la diagonale, ça sera plus facile pour la suite C'est là que je ne pige plus. Quel est le premier point ? Quel est le second ? Et, comme deux points définissent un droite, un point est toujours aligné avec un autre. Là je suis perdu, on retombe dans la même problématique : il existe une infinité de vecteurs perpendiculaires à un autre (tous ceux contenus dans le plan perpendiculaire au premier). Un petit dessin serait bienvenu. Théoriquement deux vues orthogonales (face et dessus) judicieusement choisies devraient suffire à décrire de manière non équivoque ton problème (c'est le principe de la géométrie descriptive)

J'ai essayé de faire quelque chose de plus robuste en utilisant les objets géométriques dérivés de Curve2d pour comparer les segments plutôt que les sommets. Quelques méthodes d'extension dont certaines pourraient s'avérer utiles par ailleurs. using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Geometry; using System.Collections.Generic; using System.Linq; namespace OverlapedPolylines { public static class ExtensionMethods { /// <summary> /// Obtient le point au milieu d'un arc. /// </summary> public static Point2d MidPoint(this CircularArc2d arc) => arc.EvaluatePoint((arc.GetParameterOf(arc.StartPoint) + arc.GetParameterOf(arc.EndPoint)) / 2.0); /// <summary> /// Evalue si l'arc courant est entièrement superposé à celui passé en argument. /// </summary> public static bool IsOverlapedTo(this CircularArc2d arc1, CircularArc2d arc2) => arc2.IsOn(arc1.StartPoint) && arc2.IsOn(arc1.EndPoint) && arc2.IsOn(arc1.MidPoint()); /// <summary> /// Evalue si l'arc courant est entièrement superposé à une des courbes de la collection passée en argument. /// </summary> public static bool IsOverlapedTo(this CircularArc2d arc, IEnumerable<Curve2d> curves) => curves.OfType<CircularArc2d>().Any(c => arc.IsOverlapedTo(c)); /// <summary> /// Evalue si le segment linéaire courant est entièrement superposé à celui passé en argument. /// </summary> public static bool IsOverlapedTo(this LineSegment2d line1, LineSegment2d line2) => line2.IsOn(line1.StartPoint) && line2.IsOn(line1.EndPoint); /// <summary> /// Evalue si le segment linéaire est entièrement superposé à une des courbes de la collection passée en argument. /// </summary> public static bool IsOverlapedTo(this LineSegment2d line, IEnumerable<Curve2d> curves) => curves.OfType<LineSegment2d>().Any(c => line.IsOverlapedTo(c)); /// <summary> /// Evalue si la polyligne courante est entièrement superposée à celle passée en argument. /// </summary> public static bool IsOverlapedTo(this Polyline pline1, Polyline pline2) => new PlineCurve2d(pline1).IsOverlapedTo(new PlineCurve2d(pline2)); } } Une petite classe qui pourrait être étendues pour fournir d'autres fonctionnalités concernant la géométrie des segments de polyligne. using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Geometry; using System.Collections.Generic; using System.Linq; namespace OverlapedPolylines { /// <summary> /// Décrit les segments 2d d'une polyligne. /// </summary> class PlineCurve2d { private IEnumerable<Curve2d> curves; /// <summary> /// Crée une nouvelle instance à partir d'une polyligne. /// </summary> public PlineCurve2d(Polyline pline) { curves = GetCurves(pline); } /// <summary> /// Evalue si l'instance courante est entièrement superposé à celle passée en argument. /// </summary> public bool IsOverlapedTo(PlineCurve2d plineCurve2d) { var composite = plineCurve2d.GetSimplified(); return curves.OfType<LineSegment2d>().All(l => l.IsOverlapedTo(composite)) && curves.OfType<CircularArc2d>().All(a => a.IsOverlapedTo(composite)); } /// <summary> /// Obtient la collection des segments de la polyligne. /// </summary> private IEnumerable<Curve2d> GetCurves(Polyline pline) { for (int i = 0; i < pline.NumberOfVertices; i++) { switch (pline.GetSegmentType(i)) { case SegmentType.Line: yield return pline.GetLineSegment2dAt(i); break; case SegmentType.Arc: yield return pline.GetArcSegment2dAt(i); break; case SegmentType.Coincident: case SegmentType.Point: case SegmentType.Empty: default: break; } } } /// <summary> /// Obtient la collection des segments après fusion des segments colinéaires contigus. /// </summary> private IEnumerable<Curve2d> GetSimplified() { var input = curves.ToList(); while (input.Count > 0) { if (input.Count == 1) { yield return input[0]; break; } if (input[0] is LineSegment2d line1) { if (input[1] is LineSegment2d line2 && line1.IsColinearTo(line2)) { input.RemoveAt(0); input[0] = new LineSegment2d(line1.StartPoint, line2.EndPoint); } else { input.RemoveAt(0); yield return line1; } } else if (input[0] is CircularArc2d arc1) { if (input[1] is CircularArc2d arc2 && arc1.Center.IsEqualTo(arc2.Center) && arc1.IsClockWise == arc2.IsClockWise) { input.RemoveAt(0); input[0] = new CircularArc2d(arc1.StartPoint, arc1.EndPoint, arc2.EndPoint); } else { input.RemoveAt(0); yield return arc1; } } } } } }

Salut, Il est toujours préférable quand on appelle des commandes en LISP (tout comme dans les macros, scripts, etc.) d'utiliser les le nom "global" (international) de la commande à savoir, le nom anglais précédé d'un souligné ou underscore (_). Un plus et de mettre aussi un point (.) en préfixe pour s'assurer d'appeler la commande native au cas où celle-ci aurait été redéfinie avec les commandes NONDEF / REDEF (_UNDEFINE / _REDEFINE). (defun C:F() (command "_.fillet"))

Salut, De mon côté rien n'a changé, j'étais déjà en télé travail bien avant le début de l'épidémie.

Salut, Tu peux essayer ces méthodes d'extensions. pline1.IsOverlapedTo(pline2) renvoie true si pline1 est entièrement superposée à pline2 (les points de départ et de fin de pline1 peuvent être à l'intériaue de pline2). static class Extension { /// <summary> /// Evalue si le point se situe sur la courbe en utilisant la tolérance globale. /// </summary> /// <param name="curve">Courbe à laquelle s'applique la méthode.</param> /// <param name="point">point à évaluer.</param> /// <returns>true, si le point est sur la courbe ; false, sinon.</returns> public static bool IsPointOn(this Curve curve, Point3d point) => curve.GetClosestPointTo(point, false).IsEqualTo(point); /// <summary> /// Evalue si le point se situe sur la courbe en utilisant la tolérance spécifiée. /// </summary> /// <param name="curve">Courbe à laquelle s'applique la méthode.</param> /// <param name="point">point à évaluer.</param> /// <param name="tolerance">Tolérance à appliquer.</param> /// <returns>true, si le point est sur la courbe ; false, sinon.</returns> public static bool IsPointOn(this Curve curve, Point3d point, Tolerance tolerance) => curve.GetClosestPointTo(point, false).IsEqualTo(point, tolerance); /// <summary> /// Evalue si la polyligne est entièrement superposée à la polyligne spécifiée en utilisant la tolérance globale. /// </summary> /// <param name="pline1">Polyligne à laquelle s'applique la méthode.</param> /// <param name="pline2">Polyligne de base.</param> /// <returns>true, si la polyligne est superposée ; false, sinon.</returns> public static bool IsOverlapedTo(this Polyline pline1, Polyline pline2) { int nbSegments = pline1.NumberOfVertices - 1; if (pline1.Closed) nbSegments++; for (int i = 0; i < nbSegments; i++) { if (!pline2.IsPointOn(pline1.GetPoint3dAt(i))) return false; if (!pline2.IsPointOn(pline1.GetPointAtParameter(i + 0.5))) return false; } if (pline1.Closed && !pline2.IsPointOn(pline1.GetPointAtParameter(nbSegments))) return false; return true; } /// <summary> /// Evalue si la polyligne est entièrement superposée à la polyligne spécifiée en utilisant la tolérance spécifiée. /// </summary> /// <param name="pline1">Polyligne à laquelle s'applique la méthode.</param> /// <param name="pline2">Polyligne de base.</param> /// <param name="tolerance">Tolérance à appliquer.</param> /// <returns>true, si la polyligne est superposée ; false, sinon.</returns> public static bool IsOverlapedTo(this Polyline pline1, Polyline pline2, Tolerance tolerance) { int nbSegments = pline1.NumberOfVertices - 1; if (pline1.Closed) nbSegments++; for (int i = 0; i < nbSegments; i++) { if (!pline2.IsPointOn(pline1.GetPoint3dAt(i), tolerance)) return false; if (!pline2.IsPointOn(pline1.GetPointAtParameter(i + 0.5), tolerance)) return false; } if (pline1.Closed && !pline2.IsPointOn(pline1.GetPointAtParameter(nbSegments), tolerance)) return false; return true; } }

On ne peut les "voir" avec CMDACTIVE que depuis une commande définie avec ObjectARX (code 32). En LISP, tu lances une commande avec (command ...) et tu peux "voir" la commande en cours, classiquement avec: (while ( Mais pendant l'exécution d'une routine LISP il ne peut pas y avoir d'autres fonctions LISP que celle appelées par la routine qui s'exécutent (aucun traitement LISP asynchrone ou parallèle). Autrement dit, si le code 32 de CMDACTIVE fonctionnait en LISP (getvar 'cmdactive) renverrait toujours 32. De la même façon que dans une commande définie en ObjectARX ou (.NET) CMDACTIVE renvoie toujours au moins le bit 1.

Salut, (defun c:cmd () ...) ne crée par une vrai commande AutoCAD (seuls ObjectARX et .NET permettent de définir de véritables commandes). Il s'agit d'une fonction LISP qu'on peut appeler directement depuis la ligne de commande, mais si tu fais (command "cmd" ...) ça ne fonctionnera pas.

Ça semble fonctionner en faisant un boxed_row qui contient deux colonnes : radio_column uniquement avec les radio_button et column avec les text, popup_list et edit_box. (defun c:dcltestrb (/ listLay dcl wdcl listLayers dcl_id calq ebvalue done) (defun listLay (/ lay lst) (while (setq lay (tblnext "layer" (null lay))) (setq lst (cons (cdr (assoc 2 lay)) lst)) ) (reverse lst) ) (setq dcl (vl-filename-mktemp "tmp.dcl") wdcl (open dcl "w") ) (princ "dcltestrb:dialog{ label = \"Test\"; :boxed_row{ label = \"Calques\"; :radio_column{ key = \"rc\"; :radio_button{ key = \"rb0\"; label = \"Calque courant :\"; } :radio_button{ key = \"rb1\"; label = \"Choisir un calque\"; value = \"1\"; } :radio_button { key = \"rb2\"; label = \"Créer un calque\"; } } :column{ :text{ key = \"clayer\"; } :popup_list { key = \"list\"; value = \"0\"; edit_width = 29; } :edit_box { key = \"eb\"; label = \"Nom :\"; edit_width = 30; } } } spacer; ok_cancel; }" wdcl ) (close wdcl) (setq dcl_id (load_dialog dcl)) (if (new_dialog "dcltestrb" dcl_id) (progn (setq listLayers (listLay) calq "Test" ) (start_list "list") (mapcar 'add_list listLayers) (end_list) (set_tile "clayer" (getvar "clayer")) (set_tile "eb" "Test") (mode_tile "eb" 1) (mode_tile "list" 2) (action_tile "rc" (vl-prin1-to-string '(cond ((= $value "rb0") (mode_tile "eb" 1) (mode_tile "list" 1) (setq calq (getvar "clayer") flag 1 ) ) ((= $value "rb1") (mode_tile "eb" 1) (mode_tile "list" 0) ) ((= $value "rb2") (mode_tile "list" 1) (mode_tile "eb" 0) ) ) ) ) (action_tile "list" "(setq calq (nth (atoi $value) listLayers))") (action_tile "eb" "(setq calq $value)") (action_tile "accept" "(done_dialog 1)") (action_tile "cancel" "(done_dialog 0)") (setq done (start_dialog)) (unload_dialog dcl_id) (vl-file-delete dcl) (if (= done 1) (progn (if (null (tblsearch "LAYER" calq)) (command "_.layer" "n" calq "") ) (setvar "clayer" calq) ) ) ) ) (princ) )

Salut, Juste quelques remarques en passant. Pour gérer les contrôles de type radio_button il est souvent plus facile de gérer le contenant (boxed_radio_column ici) voir cet article. Je suis absolument d'accord avec zebulon_ pour les action_tile (on peut aussi utiliser vl-prin1-to-string pour éviter les \"). Le problème ici est dû au fait d'intercaler dans le même cluster (boxed_radio_column) un autre contrôle (popup_list) entre deux radio_button. Je ferais plutôt un boxed_radio_row avec uniquement les radio_button et, en dessous le popup_list et l'edit_box.

C'est juste que j'ai eu une question similaire il y a quelques jours.

J'ai fait quelques tests, pour une hachure toute simple (SOLID) dans une polyligne rectangulaire (pl) de (0,0) à (80,50) les codes DXF minimums semblent être : (entmake (list '(0 . "HATCH") '(100 . "AcDbEntity") '(100 . "AcDbHatch") '(10 0.0 0.0 0.0) '(210 0.0 0.0 1.0) '(2 . "SOLID") '(70 . 1) '(71 . 1) '(91 . 1) '(92 . 1) ;; données du contour '(93 . 4) '(72 . 1) '(10 0.0 0.0 0.0) '(11 80.0 0.0 0.0) '(72 . 1) '(10 80.0 0.0 0.0) '(11 80.0 50.0 0.0) '(72 . 1) '(10 80.0 50.0 0.0) '(11 0.0 50.0 0.0) '(72 . 1) '(10 0.0 50.0 0.0) '(11 0.0 0.0 0.0) '(97 . 1) (cons 330 pl) ;; données du motif '(75 . 1) '(76 . 1) '(98 . 1) '(10 0.0 0.0 0.0) ) ) pour une hachure ANSI31, c'est un petit peu plus compliqué: (entmake (list (0 . "HATCH") (100 . "AcDbEntity") (100 . "AcDbHatch") '(10 0.0 0.0 0.0) '(210 0.0 0.0 1.0) '(2 . "ANSI31") '(70 . 0) '(71 . 1) '(91 . 1) '(92 . 1) ;; données du contour '(93 . 4) '(72 . 1) '(10 0.0 0.0 0.0) '(11 80.0 0.0 0.0) '(72 . 1) '(10 80.0 0.0 0.0) '(11 80.0 50.0 0.0) '(72 . 1) '(10 80.0 50.0 0.0) '(11 0.0 50.0 0.0) '(72 . 1) '(10 0.0 50.0 0.0) '(11 0.0 0.0 0.0) '(97 . 1) (cons 330 pl) ;; données du motif '(75 . 1) '(76 . 1) '(52 . 0.0) '(41 . 1.0) '(77 . 0) '(78 . 1) '(53 . 0.785398) '(43 . 0.0) '(44 . 0.0) '(45 . -2.24506) '(46 . 2.24506) '(79 . 0) '(98 . 1) '(10 0.0 0.0 0.0) ) ) Il va sans dire que pour des contours moins basiques ou des gradiants, les choses se compliquent rapidement (sans parler d'ilots ou autres joyeusetés).

Salut, Je crois bien que StripMText utilise VBScript.Regexp qui ne supporte pas les caractères Unicode, or le support de ces caractères est une des nouveauté LISP apportées par cette version (CF ce sujet). Essaye de mettre la variable système LISPSYS à 0 (un redémarrage d'AutoCAD est peut-être nécessaire) pour redéfinir l'ancien IDE (VLIDE) et son environnement qui ne supportait pas Unicode.

Salut, Vouloir faire une hachure avec entmake, c'est mettre la barre très haut, CF les données DXF plus les données de contour et les données de motif. Si tu ne veux absolument pas utiliser (command ...) (ce que je ferais probablement si j'avais à le faire en LISP) et que tu vises pas AutoCAD MAC tu peux utiliser (vla-AddHatch ...) qui est beaucoup plus simple d'utilisation. Sinon, la STB LIB, un projet de Reini Urban, est très certainement la plus grosse mine de joyaux AutoLISP. Le projet s'est malheureusement heurté aux limites du LISP quand il s'agit de faire et surtout de maintenir une bibliothèque "universelle", collaborative et interdépendante (surtout à une époque où des outils comme GitHub n'existait pas).

Tu risques de pas supporter non plus celle VS Code (ni d'aucun autre IDE) si tu fais vraiment du débogage. Vous vous privez vraiment de la puissance d'un réel outil de développement.

Au moins, ça fait causer. :) Je ne m'étendrait pas plus sur l'utilisation de VS Code sans fonctions débogage, dans ce cas là on ne parle pas d'IDE (Environnement de Développement Intégré) mais juste d'éditeur de code (un traitement de texte spécialisé). Entre parenthèses, je n'ai jamais compris qu'on puisse programmer en AutoLISP dans AutoCAD en se privant des fonctions de débogage offertes par le VLIDE depuis la version 2000. On peut déboguer avec VS code à condition d'utiliser une extension qui lie VS Code à un interpréteur (ou à une console interactive -REPL-). Dans le cas d'AutoLISP on peut utiliser l'extension AutoCAD AutoLISP Extension avec AutoCAD 2021 ou ZwLisp avec ZWCAD 2019 SP2 et ultérieur. Dans tous les cas, c'est l'interpréteur d'AutoCAD ou de ZWCAD qui est utilisé, le dessin courant étant celui dans lequel AutoLISP est exécuté. Ceci fait on peut réellement faire du débogage comme dans le VLIDE (points d'arrêt, espions, utilisation de la console pour évaluer des expressions, etc.) le tout dans un environnement plus moderne. Il ne s'agit pas d'une question de paradigme de programmation (programmation orientée objet, fonctionnelle, impérative ou autre) mais d'une question de typage statique ou dynamique. Tant que le LISP sera un langage au typage dynamique (comme Python ou Ruby) il est impossible à l'IDE de savoir à quel type d'objet est lié un symbole (une variable) donc de contrôler, au moment de l'édition, la validité des fonctions employées et de leurs arguments ; les erreurs de typage n'adviennent qu'au moment de l'exécution. Le typage statique (utilisé dans C++, C#, Java, F#, etc.) permet ce qu'on appelle la liaison anticipée c'est à dire que le compilateur (et l'IDE) de connaître le type des variables et donc de contrôler, dès l'édition dans l'IDE la validité des arguments d'une méthode ou celle des propriétés d'un objet.

Pour moi, un éditeur de code sans débogage ne présente pas grand intérêt, et comme dit plus haut Notepad++ permet ce genre de personnalisations en beaucoup plus léger. Je ne veux pas dénigrer VS Code, mais ce qui fait la force du LISP c'est avant tout son intégration à AutoCAD et la possibilité de tester/déboguer directement dans AutoCAD et, pour ça, je ne suis pas sûr que VS Code soit plus pratique que le VLIDE même si ce dernier est beaucoup plus pauvre en fonctionnalités d'édition de texte et d'affichage.

Ceci n'est pas nécessaire avec AutoCAD 2021, l'extension "AutoCAD AutoLISP Extension" s'occupe de tout.

Les mauvaises nouvelles commencent à arriver... Les dictionnaires de données LISP (vlax-ldata) créés avec VS Code (LISPSYS à 1 ou 2) sont perdues quand on ouvre le dessin avac une version antérieure à 2021 (CF cette réponse).

Pour ce qui concerne l'édition de code certes, mais, pour moi, Notepad++ fait tout aussi bien l'affaire en bien plus léger. D'après les quelques tests que j'ai fait, ça sera toujours le cas. Tu pourras déboguer dans VS Code, mais comme dit plus haut, je trouve ça bien moins pratique que dans le VLIDE. C'est bien là où le bas blesse, je ne vois pas comment régler les problèmes de compatibilité entre deux encodage de texte différents (ASCII et Unicode) à part attendre que plus personne n'utilise de versions antérieures à 2021 (mais à ce moment là, ça ne sera plus mon problème).

Non, pas d'option pour colorer le rectangle de sélection. Pour ça, tu vas devoir passer par grread.