Intersection de lignes !!!

[PPI]

Bonjour à tous,

 

Je voudrais savoir comment on trouve toutes les intersection d'une sélection de lignes pour pouvoir y insérer (aux intersections) un bloc !!! Et avant d'y insérer mon bloc je voudrais que mon SCU soit orienté suivant les deux lignes qui font l'intersection.

 

1) Sélection des lignes

2) Recherche des intersections

3) List des intersections (points)

4) SCU parrallele aux 2 lignes de l'intersection trouvée

5) Insertion de mon bloc à cette intersection

6) Retour à 2)

 

je sèche grave ....

Ca fait vraiment trop longtemps que je n'ai plus fait de Lisp, j'ai beau chercher des bouts de progs dans tout vos messages, j'ai vraiment du mal à m'y remetre ...

 

merci à vous pour votre aide ...

[(gile)]

Saut,

 

Je te donnes quelques lignes de code et te laisse le soin de les assembler à ta convenance.

 

Je ne change pas le SCU, mais calcule la Normale du plan défini par 3 points (intersection et extrémité de chacune des lignes) avec la routine Norm-3Pts et le bloc est inséré avec cette direction d'extrusion (code DXF 210).

 

Création du jeu de sélection (filtre uniquement les lignes) et d'une liste (plus facile à traiter en LISP) de toutes les entités du jeu de sélection.

 

(setq ss (ssget '((0 . "LINE"))))
(setq lst (vl-remove-if 'listp (mapcar 'cadr (ssnamex ss)))) 

 

Dans une boucle le premier élément de la liste est comparé successivement aux suivants pour y checher une intersection. si l'intersection existe le bloc "Bloc" est inséré dans le plan défini par les deux lignes. Cette boucle est imbriquée dans une autre qui supprimr le premier élément de la liste.

 

(repeat	(1- (length lst))

 ;; récupère le premier élément de la liste et le supprime de celle-ci.
 (setq	l1   (car lst)
lst (cdr lst)
 )
 
 (repeat (length lst)

   ;; recheche d'une intersection
   (if	(setq int (inters (cdr (assoc 10 (entget l1)))
		  (cdr (assoc 11 (entget l1)))
		  (cdr (assoc 10 (entget (car lst))))
		  (cdr (assoc 11 (entget (car lst))))
		  T
	  )
)

     ;; si elle existe :
     (progn

;; calcul de la Normale du plan
(setq norm (norm_3pts int
		      (cdr (assoc 11 (entget l1)))
		      (cdr (assoc 11 (entget (car lst))))
	   )
)

;; insertion du bloc
(entmake (list
	   '(0 . "INSERT")
	   '(100 . "AcDbEntity")
	   '(100 . "AcDbBlockReference")
	   '(2 . "Bloc")
	   (cons 10 (trans int 0 norm))
	   (cons 210 norm)
	 )
)
     )
   )

   ;; fait passer le premier élément de la liste à la fin
   (setq lst (append (cdr lst) (list (car lst))))
 )
) 

 

et la routine Norm-3Pts :

 

;;; NORM_3PTS retourne le vecteur normal du plan défini par 3 points

(defun norm_3pts (org xdir ydir)
 ((lambda (n)
    (if (inters org xdir org ydir)
      (mapcar
 '(lambda (x) (/ x (distance '(0 0 0) n)))
 n
      )
    )
  )
   ((lambda (x y)
      (list (-	(* (cadr x) (caddr y))
	(* (caddr x) (cadr y))
     )
     (-	(* (caddr x) (car y))
	(* (car x) (caddr y))
     )
     (-	(* (car x) (cadr y))
	(* (cadr x) (car y))
     )
      )
    )
     (mapcar '- xdir org)
     (mapcar '- ydir org)
   )
 )
) 

 

PS : Comme on ne choisit pas le sens de la normale du plan le bloc peut-être inséré "à l'envers". Je te donne donc une petite routine pour inverser le sens de la normale d'objets 2d (blocs, textes ...)

 

;;; INV-NOR Inverse le sens de la normale de l'objet sélectionné en conservant son origine

(defun c:inv-nor (/ obj elst nor1 nor2)
 (and
   (setq obj (car (entsel)))
   (setq elst (entget obj))
   (setq nor1 (cdr (assoc 210 elst)))
   (setq nor2 (mapcar '- nor1))
   (entmod
     (subst (cons 10 (trans (cdr (assoc 10 elst)) nor1 nor2))
     (assoc 10 elst)
     (subst (cons 210 nor2)
	    (assoc 210 elst)
	    elst
     )
     )
   )
 )
 (princ)
)