Existe-t-il une commande ou une méthode automatique dans AutoCAD pour afficher la distance minimale et maximale entre deux polylignes ?
Pour obtenir la distance minimale et maximale entre deux polylignes dans AutoCAD, il n’existe pas de commande unique et automatique qui génère une cotation directe comme pour une distance simple. Cependant, vous pouvez utiliser une combinaison de commandes et de méthodes pour obtenir cette information.
Voici la démarche experte :
Méthode 1 : Utilisation de la commande DIST et de l’accrochage objet
Cette méthode est la plus directe pour obtenir des mesures ponctuelles.
- Activer l’accrochage objet (OSNAP) : Assurez-vous que l’accrochage objet est activé (F3) et que les options ‹ Extrémité › (Endpoint), ‹ Point le plus proche › (Nearest) et éventuellement ‹ Point milieu › (Midpoint) sont cochées dans les paramètres de l’accrochage objet.
- Lancer la commande DIST : Tapez
DISTdans la ligne de commande et appuyez sur Entrée. - Sélectionner les points :
- Pour la distance minimale : Cliquez sur le point le plus proche sur la première polyligne qui semble être le plus près de la seconde polyligne. Ensuite, cliquez sur le point le plus proche sur la seconde polyligne qui correspond à ce point de la première.
- Pour la distance maximale : Procédez de manière similaire, en cherchant les points les plus éloignés entre les deux polylignes.
- Analyser le résultat : La distance s’affiche dans la ligne de commande. Il faut répéter l’opération en plusieurs points pour s’assurer d’avoir trouvé les distances min et max, surtout si les polylignes sont complexes ou ne sont pas parallèles.
Méthode 2 : Utilisation de la commande MESUREGEOM (Mesure Géométrique)
Cette commande offre des options plus avancées pour mesurer des distances.
- Lancer la commande MESUREGEOM : Tapez
MESUREGEOMdans la ligne de commande et appuyez sur Entrée. - Choisir l’option ‹ Distance › : Sélectionnez l’option ‹ Distance › dans le menu qui apparaît ou tapez
D. - Sélectionner les points : Comme avec la commande DIST, sélectionnez les points d’extrémité ou les points les plus proches sur chaque polyligne pour mesurer la distance. Répétez l’opération pour trouver les valeurs minimales et maximales.
Méthode 3 : Utilisation d’un LISP personnalisé (pour une automatisation avancée)
Pour une solution véritablement automatique et répétitive, la création ou l’utilisation d’une routine LISP est la voie à privilégier. Voici un script LISP complet qui calcule les distances perpendiculaires entre polylignes (méthode géométriquement correcte) :
Principe de calcul :
Ce script utilise la méthode des distances perpendiculaires :
- Depuis chaque sommet de la polyligne 1, calcule la distance perpendiculaire vers le segment le plus proche de la polyligne 2
- Depuis chaque sommet de la polyligne 2, calcule la distance perpendiculaire vers le segment le plus proche de la polyligne 1
- Identifie les distances minimale et maximale parmi toutes ces perpendiculaires
Note : Cette approche est géométriquement plus correcte que le calcul direct entre sommets, car elle représente les vraies distances entre les polylignes.
;; ================================================================
;; MinMaxPlineDist.lsp (Version 1.1 - Corrigée)
;; ---------------------------------------------------------------
;; Commande AutoCAD: MinMaxPlineDist
;; Objectif: Trouver et coter les distances minimale et maximale
;; entre deux polylignes (LWPOLYLINE).
;;
;; Version 1.1: Remplacement de 'IntersectWith' par un algorithme
;; LISP 2D robuste pour éviter les erreurs ActiveX
;; liées à la non-coplanarité.
;; ================================================================
(vl-load-com)
(defun c:MinMaxPlineDist (/ *error* adoc oldcmdecho oldosmode
sel1 sel2 e1 e2 vla1 vla2
verts1 verts2 closed1 closed2 segs1 segs2
min_dist max_dist min_pt1 min_pt2 max_pt1 max_pt2
ans res dcur p1c p2c p q
polylines-intersect-p ; Déclaration de la fonction locale
)
;; --- Gestion d'erreurs et initialisation système ---
(defun *error* (msg)
(if oldcmdecho (setvar 'CMDECHO oldcmdecho))
(if oldosmode (setvar 'OSMODE oldosmode))
(if (and msg (not (wcmatch (strcase msg) "*CANCEL*,*EXIT*")))
(princ (strcat "\nErreur: " msg))
)
(princ)
)
(setq oldcmdecho (getvar 'CMDECHO) oldosmode (getvar 'OSMODE))
(setvar 'CMDECHO 0)
(setvar 'OSMODE 0)
;; --- Fonctions utilitaires ---
(defun toUCS (p) (trans p 0 1))
;; Retourne l'orientation de (p, q, r) : 0=colinéaire, 1=horaire, 2=anti-horaire
(defun orientation (p q r / val)
(setq val (- (* (- (cadr q) (cadr p)) (- (car r) (car q)))
(* (- (car q) (car p)) (- (cadr r) (cadr q)))))
(cond ((< (abs val) 1e-9) 0) ; Colinéaire
((> val 0) 1) ; Horaire
(t 2) ; Anti-horaire
)
)
;; Vérifie si le point q est sur le segment pr
(defun on-segment (p q r)
(and (<= (car q) (max (car p) (car r))) (>= (car q) (min (car p) (car r)))
(<= (cadr q) (max (cadr p) (cadr r))) (>= (cadr q) (min (cadr p) (cadr r))))
)
;; Teste l'intersection de segment 'p1q1' et 'p2q2'
(defun segments-intersect-p (p1 q1 p2 q2 / o1 o2 o3 o4)
(setq o1 (orientation p1 q1 p2)
o2 (orientation p1 q1 q2)
o3 (orientation p2 q2 p1)
o4 (orientation p2 q2 q1))
(cond ((and (/= o1 o2) (/= o3 o4)) T)
((and (= o1 0) (on-segment p1 p2 q1)) T)
((and (= o2 0) (on-segment p1 q2 q1)) T)
((and (= o3 0) (on-segment p2 p1 q2)) T)
((and (= o4 0) (on-segment p2 q1 q2)) T)
(t nil)
)
)
;; Fonction principale de vérification d'intersection de polylignes
(defun polylines-intersect-p (segs1 segs2 / intersect-found)
(setq intersect-found nil)
(foreach s1 segs1
(if (not intersect-found)
(foreach s2 segs2
(if (segments-intersect-p (car s1) (cadr s1) (car s2) (cadr s2))
(setq intersect-found T)
)
)
)
)
intersect-found
)
;; Récupère tous les points 3D d'une LWPOLYLINE
(defun get-pline-verts (vla-pline / coords elev)
(setq coords (vlax-get vla-pline 'Coordinates)
elev (vlax-get vla-pline 'Elevation))
(mapcar '(lambda (x y) (list x y elev))
(vl-remove-if-not 'numberp (mapcar 'car coords))
(vl-remove-if-not 'numberp (mapcar 'cadr coords)))
)
(defun get-all-pline-verts (vla-obj / lst i endp)
;; Pour une LWPOLYLINE, les entiers 0..endParam correspondent aux sommets
(setq endp (fix (vlax-curve-getEndParam vla-obj))
lst '()
i 0)
(while (<= i endp)
(setq lst (cons (vlax-curve-getPointAtParam vla-obj i) lst)
i (1+ i)))
(reverse lst)
)
;; Crée la liste de segments [[p1 p2] [p2 p3] ...]
(defun make-segments (pts closed / res)
(if (> (length pts) 1)
(progn
(setq res (mapcar 'list pts (cdr pts)))
(if closed (setq res (append res (list (list (car (last pts)) (car pts)))))
)
)
res
)
;; --- Début du script principal ---
(princ "\nInitialisation de MinMaxPlineDist...")
;; 1. Sélection et validation
(setq sel1 (entsel "\nSélectionnez la première polyligne : "))
(if (null sel1) (progn (*error* "Sélection annulée.") (exit)))
(setq sel2 (entsel "\nSélectionnez la seconde polyligne : "))
(if (null sel2) (progn (*error* "Sélection annulée.") (exit)))
(if (or (not (= (cdr (assoc 0 (entget (car sel1)))) "LWPOLYLINE"))
(not (= (cdr (assoc 0 (entget (car sel2)))) "LWPOLYLINE")))
(progn (*error* "Les deux objets doivent être des polylignes (LWPOLYLINE).") (exit))
)
(setq e1 (car sel1) e2 (car sel2)
vla1 (vlax-ename->vla-object e1)
vla2 (vlax-ename->vla-object e2))
;; Extraction des sommets et création des segments pour le test d'intersection
(setq verts1 (get-all-pline-verts vla1)
verts2 (get-all-pline-verts vla2)
closed1 (= :vlax-true (vlax-get vla1 'Closed))
closed2 (= :vlax-true (vlax-get vla2 'Closed))
segs1 (make-segments verts1 closed1)
segs2 (make-segments verts2 closed2))
(if (or (null segs1) (null segs2))
(progn (*error* "Une des polylignes est invalide (moins de 2 sommets).") (exit))
)
;; 2. Vérification d'intersection (Méthode LISP robuste)
(princ "\nVérification d'intersection...")
(if (polylines-intersect-p segs1 segs2)
(progn
(princ "\nLes polylignes se croisent. Distance minimale = 0.0")
(*error* nil) ; Sortie propre
)
(princ " Aucune intersection trouvée.")
)
;; 3. Initialisation et feedback
(princ "\nCalcul des distances en cours, veuillez patienter...")
(setq min_dist 1e20
max_dist 0.0)
;; 4. Calcul des distances (Sommets -> Courbe opposée)
;; C'est la méthode la plus fiable pour les LWPOLYLINE avec arcs (bulges)
(foreach p verts1
(setq q (vlax-curve-getClosestPointTo vla2 p))
(setq dcur (distance p q))
(if (< dcur min_dist)
(setq min_dist dcur min_pt1 p min_pt2 q)
)
(if (> dcur max_dist)
(setq max_dist dcur max_pt1 p max_pt2 q)
)
)
(foreach p verts2
(setq q (vlax-curve-getClosestPointTo vla1 p))
(setq dcur (distance p q))
(if (< dcur min_dist)
(setq min_dist dcur min_pt1 q min_pt2 p)
)
(if (> dcur max_dist)
(setq max_dist dcur max_pt1 q max_pt2 p)
)
)
;; La distance maximale est contrainte à un couple (sommet -> point le plus proche sur l'autre polyligne)
;; donc pas de boucle sommet-sommet ici.
;; 5. Affichage des résultats
(princ "\r \r") ; Nettoyage ligne
(princ (strcat "\nDistance minimale trouvée : " (rtos min_dist)))
(princ (strcat "\nDistance maximale trouvée : " (rtos max_dist)))
;; 6. Placement optionnel des cotes
(initget "Oui Non")
(setq ans (getkword "\nVoulez-vous placer la cote de distance minimale ? [Oui/Non] <Oui>: "))
(if (and (or (null ans) (= ans "Oui")) min_pt1 min_pt2)
(command "_.DIMALIGNED" (toUCS min_pt1) (toUCS min_pt2) pause)
)
(initget "Oui Non")
(setq ans (getkword "\nVoulez-vous placer la cote de distance maximale ? [Oui/Non] <Oui>: "))
(if (and (or (null ans) (= ans "Oui")) max_pt1 max_pt2)
(command "_.DIMALIGNED" (toUCS max_pt1) (toUCS max_pt2) pause)
)
;; Restauration et sortie propre
(*error* nil)
)
(princ "\nCommande 'MinMaxPlineDist' chargée. Lancez-la en tapant son nom.")
(princ)
Utilisation du script :
- Chargement : Copiez le code dans un fichier
.lspet chargez-le viaAPPLOAD - Exécution : Tapez
MinMaxPlineDistdans la ligne de commande - Sélection : Sélectionnez successivement les deux polylignes à analyser
- Résultats : Le script affiche les distances min/max
- Cotation : Option pour placer automatiquement les cotes alignées
Fonctionnalités du script :
- Détection automatique d’intersection (distance min = 0)
- Calcul précis avec support des arcs (bulges)
- Placement optionnel des cotes alignées
- Gestion des erreurs et cas particuliers
- Restauration propre des paramètres système
Bien qu’il n’y ait pas de commande native ‹ Distance Min/Max entre deux objets ›, les commandes DIST et MESUREGEOM combinées à une bonne utilisation de l’accrochage objet permettent d’obtenir cette information manuellement. Pour un usage fréquent, ce script LISP représente la solution la plus efficace et complète.
J’espère que ces explications vous seront utiles !