distance entre polylignes ??

[Invité spartacuss]

bonjour

 

est ce qu'il y a une possibilité de calculer la distance entre des polylignes sans passé par le calcule des distances entre les sommets des polylignes ??

 

cordialement

[Fraid]

Bonjour,

 

A mon avis non,

 

mais je suis loin de tout connaitre ;)

[Invité spartacuss]

re

 

 

malheureusement , car je travaille sur le même sujet d'avant et j'ai pas trouvé de solution (car gille m'a dit que même si je calcule la distance entre les sommets de mes polylignes ,ces distances ne donnent pas effectivement la distance entre les polylignes)

merci en tout cas .

 

cordialement

 

 

[Carboleum]

 

Oui, il faut d'abord définir ce qu'est une distance entre deux polylines: moyenne/minimun des distances entre les sommets/centres des segments.

 

Tu peux aller voir dans les vlax-curves*, il y a peut-être quelque chose qui existe déjà. (De toutes façon ces fonctions sont toujours bonnes à prendre)

 

Bonne recherche!

 

[Invité spartacuss]

re

 

merci je vais essayé .

[didier]

coucou

 

ce qui serait intéressant serait de savoir ce que tu appelles

distance entre polyligne...

le concept est flou

 

à la vue de celui-ci, nous tenterons de te répondre

ou du moins de te diriger vers la solution

 

amicalement

[Invité spartacuss]

re

 

 

donc je vais reformuller mon problème

_plusieurs polylignes P et Q ,T ......., des 2D,

_la polyligne P a pour sommets P1,P2,P3.....P(n-1),Pn.

_la polyligne Q a pour sommets Q1,Q2,Q3.....Qn-1),Qn.

_avec P1(Xp1,Yp1) et Q1(xq1,Yq1)......Pn(Xpn,Ypn,Zpn) et Qn(Xqn,Yqn).

 

je veux récupérer la distance minimal entre chaque deux polylignes .

 

 

 

cordialement

[didier]

coucou

 

ça me semble simple si les polylignes ont le même nombre de sommets

auquel cas il suffit de faire une liste des sommets

de calculer la distance par paires

et de filtrer la plus petite.

 

mais si les polylignes n'ont pas le même nombre de sommets

ou bien possèdent des segments en arc

c'est tout de suite moins simple.

 

amicalement

 

[Invité spartacuss]

re

 

oui tout a fait raison j'ai fait ça mais ne donne pas ce que je veux !!

 

[code (defun get_dwgnam ()
(if (= (getvar 'dwgtitled) 1)
(setq xy(vl-filename-base (getvar 'dwgname)))
)
(setq draww(strcat xy "_LST.txt"))
)
(defun c:lwp (/ n center dist1 dist2 dist3 r k q nam entg a b c dist p1 p2 cord j ent m cor allc)
(setq in (list (cons 0 "INSERT")))
(setq ins(ssget "x" in));selection
(setq len (sslength ins));le nombre des element dans ins
(setq nmblock(cdr (assoc 2 (entget (ssname ins 0)))))
(setq y(entget (cdr( assoc -2 (tblsearch "block" nmblock)))))

(setq le (length y))
;==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

(setq ent(tblobjname "BLOCK" "ld"))

(setq nam (list))
(while
(setq ent (entnext ent))

(if (eq "LWPOLYLINE" (cdr (assoc 0 (entget ent))))
(progn
(setq nam(append nam (list(cdr (assoc -1 (entget ent))))))
)))

(setq cord (list))
(setq c -1)

(while (< (setq c (1+ c)) (length nam))
(setq entg (entget (nth c nam)))
(setq li (list))
(setq n 0)
(repeat (length entg)
(setq z (car (nth n entg)))
(if (= z 10)
(progn
(setq li (append li (list (cdr (nth n entg)))))

)
)
(setq n (1+ n))
)
(setq cord (append cord (list li)) )
)

;==°_°====°_°====°_°====°_°=== la boucle pour calculler la distance ==°_°====°_°====°_°====°_°====°_°====°_°==



(setq
i 1
i1 4
j 0
j1 0
dist2 nil
dist3 nil
a (length cord)
)

(while (< i a)

(while (< i1 a)

(setq b (length (nth i cord)))
(setq dist1 nil)

(while (< j b)

(setq c (length (nth i1 cord)))
;(setq dist1 nil)

(while (< j1 c)

;(setq p1 (nth j(nth i cord)))

;(setq p2 (nth j1 (nth i1 cord)))

(setq dist (distance (nth j (nth i cord)) (nth j1 (nth i1 cord))))

;(if ( < dist 100)

;(progn

;(alert " ooooops ooooops erreur")

;(command "_.line" p1 p2 "")
;)
;)

(setq dist1 (append dist1 (list dist)))

(setq j1 (1+ j1))
)

(setq j (1+ j))

)

(setq dist2 (append dist2 (list dist1)))

(setq i1 (1+ i1))

)

(setq dist3 (append dist3 (list dist2)))

(setq i (1+ i))
)

; (princ dist3)

;==°_°====°_°====°_°====°_°====°_°====°_°====°_°==le fichier listing ==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

(progn
(vl-load-com)
(setq shell (vla-getInterfaceObject (vlax-get-acad-object) "Shell.Application"))
(vlax-invoke-method shell 'ShellExecute
(strcat "C:\\Documents and Settings\\nemotek\\Application Data\\Autodesk\\AutoCAD 2009\\R17.2\\fra\\Support\\DR-check\\"(get_dwgnam))
nil
nil
nil
nil
)
(vlax-release-object shell)
)
(setq hui (strcat "C:/Documents and Settings/nemotek/Application Data/Autodesk/AutoCAD 2009/R17.2/fra/Support/DR-check/"(get_dwgnam)))
(setq fil (open hui "w"))
(princ cord fil)
(princ "\n\n"fil)
(princ dist2 fil)
(close fil)
(princ)
)
] [/code]

 

si vous pouvez m'aidez et surtout au niveau de la boucle

merci d'avance

[Tramber]

Un code un peu brutal :

 

 (defun foo (lst)
   (if lst
     (cons (list (car lst) (cadr lst)) (foo (cddr lst)))
   )
 )

(setq p1(vlax-ename->vla-object(car(entsel)))
     p2(vlax-ename->vla-object(car(entsel))))

(setq cp1(foo (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates p1))))
     cp2(foo (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates p2)))))

(setq listedesdistances(apply 'append (mapcar '(lambda(y)(mapcar '(lambda(x) (distance x y))cp2)) cp1)))

(eval (append (list 'MIN)listedesdistances)) 

 

Bcp de choses à expliquer :

Selectionner 2 polylignes

cp1 et cp2 sont les extractions des points sous forme de listes pour chacune des polys.

(le traitement de foo est 2D, il n'y a pas de Z dans une polyligne)

Le double MAPCAR permet de créer une liste de liste de distances, soit les distances de points à points.

Le APPLY ne fait que condenser le tout dans une seule liste de distances.

(eval (append permet d'utiliser l'expression MIN en construisant la liste contenant l'instruction, MIN est une fonction à n arguments. Ce qui est spécial.

 

En Autolisp traditionnel, il faut, en effet, créer une double boucle. Je n'ai pris le temps de lire ton code, désolé. En même temps, le traitement avec MAPCAR n'est pas si difficile....

 

 

[Edité le 6/6/2011 par Tramber]

[Invité spartacuss]

re

 

merci pour le temps que vous avez consacré a ce sujet mais dans mon dessin j'ai des polyligne dans des blocs ,et la sélection doit être automatique c à d je veux calculer la distance entre chaque polylignes et tout les autres polylignes , mon programme je pense qu'il fait ça mais le seul problème que j'ai, c'est au niveau de la boucle je sait pas pourquoi ça marche pas comme prévue !!!!!!

 

merci

[Invité spartacuss]

re2

 

voila mon dessin:

http://img219.imageshack.us/img219/8813/exeple.png

 

[(gile)]

La demande est toujours aussi peu claire, mais j'ai essayé un truc qui m'amusait.

Je n'ai pas testé en profondeur, mais ça semble marcher.

 

La routine gc:PlineMinDistt retourne une liste dont le premier élément est la distance minimum entre deux polylignes compte tenu d'une tolérance, les deux éléments suivant sont un point sur chaque polyligne à l'endroit de cette distance.

 

Nouvelle version

 

;; gc:PlineMinDist
;; Retourne une liste contenant la distance minimum entre deux polylignes et
;; un point sur chaque polyligne à cette distance
;;
;; Arguments
;; pl1 et pl2 : deux polylignes (ENAME ou VLA-OBJECT)
;; tol        : la tolérance pour la ditance minimum

(defun gc:PlineMinDist (pl1 pl2 tol / poly-pts minDist lst1 lst2)
 (vl-load-com)

 ;; Retourne la liste des sommets (points 3d WCS) d'une polyligne
 (defun poly-pts (pl / n p l)
   (setq n (fix (vlax-curve-getEndParam pl)))
   (or (vlax-curve-IsClosed pl) (setq n (1+ n)))
   (while (setq p (vlax-curve-getPointAtParam pl (setq n (1- n))))
     (setq l (cons p l))
   )
 )

 ;; Retourne une la distance minimum entre deux polylignes
 (defun minDist (pt pl1 pl2 tol / dist)
   (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl2 pt))))
   (while (not
     (equal dist
	    (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl1 pt))))
	    tol
     )
   )
     (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl2 pt))))
   )
   (list dist pt (vlax-curve-getClosestPointTo pl2 pt))
 )

 (setq	lst1
 (car
   (vl-sort
     (mapcar
       '(lambda (p) (mindist p pl1 pl2 tol))
       (poly-pts pl1)
     )
     '(lambda (l1 l2) (	   )
 )
lst2
     (car
       (vl-sort
	 (mapcar
	   '(lambda (p) (mindist p pl2 pl1 tol))
	   (poly-pts pl2)
	 )
	 '(lambda (l1 l2) (	       )
     )
 )
 (if (    lst1
   lst2
 )
)

 

La commande qui m'a servi aux tests :

 

(defun c:toto (/ pl1 pl2 dist)
 (and
   (setq pl1 (car (nentsel "\nSélctionnez la première polyligne: ")))
   (setq pl2 (car (nentsel "\nSélctionnez la seconde polyligne: ")))
   (setq dist (gc:PlineMinDist pl1 pl2 1e-6))
   (entmake
     (list
'(0 . "LINE")
(cons 10 (cadr dist))
(cons 11 (caddr dist))
     )
   )
   (entmake
     (list
'(0 . "TEXT")
(cons 10 (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2.)) (cadr dist) (caddr dist)))
(cons 40 (getvar 'textsize))
(cons 1 (rtos (car dist)))
     )
   )
 )
 (princ)
)

[Invité spartacuss]

re

 

merci a tout le monde , ce programme ça marche bien mais le problème que donc mon bloc j'ai presque 43 polylignes , donc je peut pas sélectionné deux par deux (car les polyligne sont dans un seul bloc) je veux que mon programme calcule la distance entre chaque polylignes et les touts les autres polylignes :

je donne un exemple j'ai 5 polylignes : p1 ,p2 p3 p4 et p5 donc les distances a calculer sont ( dist11(entre p1 etp2 ) dist12 (entre p1 et p3) dist13 (entre p1 et p4 ) dist14 (entre p1 et p5) )ensuite (dist21 (entre p2 et p3) dist22 (entre p2 etP4) dist23 (entre pp2 etp5) ensuite (et ainsi de suite ))

pour avoir toutes les distances possible dans mon bloc .

je c'est pas si je suis assez claire, merci d'avance

 

cordialement

[(gile)]

Ça se dés-obscurcit un petit peu, mais c'est difficile si tu donnes les informations au compte goute (et dans plusieurs sujets).

 

Si tu veux faire de la programmation, il faut d'abord que tu arrives à exposer très clairement et exhaustivement toutes les données d'un problème et le type de résultat que tu veux obtenir.

Si des humains ont du mal à comprendre, comment veux-tu qu'une machine y arrive...

 

Une nouvelle fonction gc:MultiPlineMinDist qui appelle gc:PlineMinDist pour traiter une liste de polylignes :

 

(defun gc:MultiPlineMinDist (lst / pl rslt)
 (while (cdr lst)
   (setq pl  (car lst)
  lst (cdr lst)
   )
   (foreach p lst
     (setq rslt (cons (gc:PlineMinDist pl p 1e-8) rslt))
   )
 )
)

 

Si tes polylignes sont dans un bloc il faut soit décomposer le bloc soit récupérer les polylignes dans la définition de bloc.

Un exemple avec une commande de test qui demande à l'utilisateur de sélectionner une référence de bloc, parcourt la définition du bloc pour faire une liste des polylignes et crée une cote alignée pour chaque distance minimale sur la référence sélectionnée (il faut déplacer chaque point du point de base (0 0 0) au point d'insertion de la référence).

 

(defun c:test (/ ref elst def net lst vec)
 (if (and
(setq ref (car (entsel "\nSélectionnez un bloc: ")))
(setq elst (entget ref))
(= (cdr (assoc 0 elst)) "INSERT")
     )
   (progn

     ;; constitution de la liste des polylignes contenues dans la référence de bloc
     (setq def	(tblsearch "BLOCK" (cdr (assoc 2 elst)))
    ent	(cdr (assoc -2 def))
     )
     (while ent
(if (= (cdr (assoc 0 (entget ent))) "LWPOLYLINE")
  (setq lst (cons ent lst))
)
(setq ent (entnext ent))
     )

     ;; déplacement du point de base au point d'insertion
     (setq vec (cdr (assoc 10 elst)))

     ;; pour chaque liste retournée par gc:MultiPlineMinDist, une cote alignée est crée
     ;; après déplacement des points
     (foreach l (gc:MultiPlineMinDist lst)
(command "_dimaligned"
	 "_non"
	 (mapcar '+ (cadr l) vec)
	 "_non"
	 (mapcar '+ (caddr l) vec)
	 "_non"
	 (mapcar '+ (caddr l) vec)
)
     )
   )
 )
 (princ)
)

[Invité spartacuss]

re

 

 

oui c'est vrai,,je suis très dessolé pour l’ambiguïté de mon sujet ,je vais être le plus claire possible la prochaine fois ,merci beaucoup pour ton effort ,maintenant je vais modifier un petit peut ton programme pour retourner les distances et les extrémités des distances minimum sans tracer les ligne entre les polylignes .

merci infiniment une autre fois .

 

cordialement

[(gile)]

retourner les distances et les extrémités des distances minimum sans tracer les ligne entre les polylignes

C'est ce que fait gc:PlineMinDist sous forme de liste : (distance point1 point2) et gc:MultiPlineMinDist sous forme de liste de sous-liste de la première forme.

 

Les commandes n'étaient données que pour tester, tu peux récupérer dans c:test la méthode pour récupérer la listes des polylignes dans une définition de bloc.

[Invité spartacuss]

re

 

oui ça marche bien , je trouve pas les mots pour vous remerciez tu m'a aider beaucoup dans mon projet j'ai été bloqué pendant une semaine .

je pose la question pourquoi vous n'avez pas de livres je que vous êtes le meilleur au lisp avec tout mes respects au autres membres du forums.

 

cordialement

[Invité spartacuss]

bonjour

 

salut tout le monde , j'ai modifier un petit peut le programme de Mr.gile , car j'ai plusieurs blocs qui se répètent et je veux que le travaille effectué sur un soit effectué sur touts les autres , donc il faut avoir une sélection automatique de tous le dessin ,eh! bien j'ai fait ça dans le programme suivant :

 

    (defun translate (ptins coordinate / ) ; translate from WSC to OCS  
   (mapcar'+ ptins coordinate)
   )  

;==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

(defun get_dwgnam ()
       (if (= (getvar 'dwgtitled) 1)
       (setq xy(vl-filename-base (getvar 'dwgname)))
       )	
 	    (setq draww(strcat xy "_LST.txt"))
   )
;==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

;; gc:PlineMinDist
;; Retourne une liste contenant la distance minimum entre deux polylignes et
;; un point sur chaque polyligne à cette distance
;;
;; Arguments
;; pl1 et pl2 : deux polylignes (ENAME ou VLA-OBJECT)
;; tol        : la tolérance pour la ditance minimum

(defun gc:PlineMinDist (pl1 pl2 tol / poly-pts minDist lst1 lst2)

 (vl-load-com)

 ;; Retourne la liste des sommets (points 3d WCS) d'une polyligne

 (defun poly-pts (pl / n p l)
   (setq n (fix (vlax-curve-getEndParam pl)))
   (or (vlax-curve-IsClosed pl) (setq n (1+ n)))
   (while (setq p (vlax-curve-getPointAtParam pl (setq n (1- n))))
     (setq l (cons p l))
   )
 )
 ;; Retourne une la distance minimum entre deux polylignes
 (defun minDist (pt pl1 pl2 tol / dist)
   (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl2 pt))))
   (while (not
     (equal dist
	    (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl1 pt))))
	    tol
    )
   )
     (setq dist (distance pt (setq pt (vlax-curve-getClosestPointTo pl2 pt))))
   )
   (list dist pt (vlax-curve-getClosestPointTo pl2 pt))
 )



 (setq	lst1

 (car

   (vl-sort

     (mapcar

       '(lambda (p) (mindist p pl1 pl2 tol))

       (poly-pts pl1)

     )

     '(lambda (l1 l2) (< (car l1) (car l2)))

   )

 )

lst2

     (car

       (vl-sort

	 (mapcar

	   '(lambda (p) (mindist p pl2 pl1 tol))

	   (poly-pts pl2)

	 )

	 '(lambda (l1 l2) (< (car l1) (car l2)))

       )

     )

 )

 (if (< (car lst1) (car lst2))

   lst1

   lst2

 )

)

;==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

(defun gc:MultiPlineMinDist (lst / pl ins len rslt)
 (while (cdr lst)
   (setq pl (car lst)
  lst (cdr lst)
   )
   (foreach p lst
     (setq rslt (cons (gc:PlineMinDist pl p 1e-8) rslt))
   )
 )
;==================================point d'insertion ======================================================
(setq
   ins (ssget)
   len (sslength ins)
   i 0
   j 0
   insname(list)
   ptins (list)
 )
 (while (< i len)
   (setq
     insname (append insname (list(ssname ins i)))
     i (1+ i)
   )
 )
 (while (< j len)
   (setq
     ptins (append ptins (list(cdr (assoc 10 (entget (nth j insname ))))))      
     j (1+ j)
   )
 )
;=====================================translate ====================================================
(setq
   lcord (length rslt)
   lins (length ptins)
   sname1 (list)
   sname2 (list)
   sname3 (list)
   sname4 (list)
   distinter1 (list)
   distinter2 (list)
   k -1
 )
 (while (< (setq k (1+ k)) Lins)
   (setq
     s -1
     
   )
   (while (< (setq s (1+ s)) Lcord)
(setq i -1)
sname2 nil
(while (< (setq i(1+ i)) 2)

     (setq
       sname1 (translate (nth k ptins)(nth i (cdr (rslt))))
       sname2 (append sname2 (list sname1))
     )
)
(setq sname3 (append sname3 (list sname2)))
   )
   (setq sname4 (append sname4 (list sname3)))
 )
   (princ sname4)
;========================================================================================
   (setq a (length rslt))
(setq i 0)
(while(< i a)
    (setq t1 (cadr (nth i rslt)))
	(setq t2 (caddr(nth i rslt)))
    (if (< (car(nth i rslt)) 70.0)
	    (progn
		    (alert "distance ironnée")
			(command "_line" t1 t2 "")
		)
	)
	(setq i(1+ i))
)				
 ;(princ rslt)
   (progn
                   (vl-load-com)
                   (setq shell (vla-getInterfaceObject (vlax-get-acad-object) "Shell.Application"))
                   (vlax-invoke-method shell 'ShellExecute
                                    (strcat "C:\\Documents and Settings\\nemotek\\Application Data\\Autodesk\\AutoCAD 2009\\R17.2\\fra\\Support\\DR-check\\"(get_dwgnam))
                                       nil
                                       nil
                                       nil
                                       nil
                   )
                   (vlax-release-object shell)
   )
   (setq hui (strcat "C:/Documents and Settings/nemotek/Application Data/Autodesk/AutoCAD 2009/R17.2/fra/Support/DR-check/"(get_dwgnam))) 
    (setq fil (open hui "w"))
	(princ rslt fil)
	(princ "\n\n"fil)		
	(close fil)
)
;==°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°====°_°==

(defun c:test (/ ref elst ent ini ins def net lst vec)
  ; (if (and
   ; (setq ref (car (entsel "\nSélectionnez un bloc: ")))
    (setq ini (list (cons 0 "INSERT")))
       (setq ins(ssget "x" ini))
    (setq elst (entget ins))
    (= (cdr (assoc 0 elst)) "INSERT")
   ;    )
  ; (progn
     ;; constitution de la liste des polylignes contenues dans la référence de bloc
     (setq def	(tblsearch "BLOCK" (cdr (assoc 2 elst)))
    ent	(cdr (assoc -2 def))
     )
       (while ent
    (if (= (cdr (assoc 0 (entget ent))) "LWPOLYLINE")
    (setq lst (cons ent lst))
    )
    (setq ent (entnext ent))
       )
     ;; déplacement du point de base au point d'insertion
     (setq vec (cdr (assoc 10 elst)))
     ;; pour chaque liste retournée par gc:MultiPlineMinDist, une cote alignée est crée
     ;; après déplacement des points
;=======================================================================
   
   	  
     (foreach l (gc:MultiPlineMinDist lst)
     )
   )
 )  
   (princ)
)

 

mais il me retourne un erreur :type d'argument incorrect: lentityp .

je sait pas ou je trompe ?? ou si j'ai oublié quelque chose ??

 

cordialement

[(gile)]

Je pense que ça vient de là :

   ; (if (and
   ; (setq ref (car (entsel "\nSélectionnez un bloc: ")))
    (setq ini (list (cons 0 "INSERT")))
       (setq ins(ssget "x" ini))
    (setq elst (entget ins))
    (= (cdr (assoc 0 elst)) "INSERT")
   ;    )

 

Tu as mis en commentaire des lignes de codes qui fonctionnaient pour les remplacer par d'autres qui ne peuvent pas fonctionner :

(setq elst (entget ins))

 

ins est un jeu de sélection (type PICKSET) et entget requiert un nom d'entité (type ENAME).

C'est ce que te dit le message d'erreur...

 

On ne peut pas faire de programmation uniquement en collant des bouts de code piochés ici ou là, il faut comprendre un minimum ce que ces codes font...