Couper polylignes rectangle

[chris_mtp]

Bonjour à tous,

 

J'ai plusieurs polylignes 2D ou 3D qui sont à l'intérieur d'un rectangle et d'autres dans un contour matérialisé par une poly2D fermé..

 

Est il possible de sélectionner toutes les lwpolylignes et polylignes à l'intérieur de ce rectangle puis de les couper (en utilisant l'option du premier point de la commande couper) aux intersections du rectangle ou du contour en question ?

 

Merci par avance de votre aide.

John.

[chris_mtp]

Rebonjour,

 

Je ne sais pas comment couper les polylignes 2D et 3D qui sont à l'intérieur de mon rectangle au point d'intersection de celui ci sans effacer les polylignes qui sont en dehors de celui-ci.

Quand je parle de rectangle, c'est en fait une polyligne 2D fermée.

Merci par avance de votre aide sur ce sujet.

John.

[Tupolev]

:)

Hé bien cher chris c'est pas compliqué tu utilises la ajuster ensuite tu fais une séléction rectangulaire du côté du rectangle où tu souhaites supprimer les objets (soit à l'intérieur soit à l'extérieur du rectangle. Dans ton cas, il te faudra faire une sélection en dehors de ton rectangle, mais qui passe par l'ensemble des traits que tu souhaites couper. Et là tous les traits que ta sélection rectangulaire aura rencontré s'effaceront.

Une autre solution assez similaire consite à utiliser l'option trajet de 'ajuster', ça permet d'effectuer des découpes plus complexe polygonale par exemple. Mais sous 2007, ils ont simplifié la manip avant, il fallait toujours utiliser 'trajet' ou 'côté' de la fonction 'ajuster'. Le gain de temps est notoire.

Bon week-end

[chris_mtp]

A mon avis mahr.francois tu ne dois pas très bien comprendre ma demande ou te ne sais pas lire.

 

J'ai bien dit

sans effacer les polylignes qui sont en dehors de celui-ci

.

De plus, si dans le titre de ce post, il y a le mot COUPER ce n'est pas pour rien

 

J'ai essayé de récupérer un bout de lisp de bonuscad d'un autre post pour insérer un point à chaque intersection du rectangle et des polylignes mais après pour intégrer la commande COUPER je bloque

 

Voici le lisp origine.

 

(defun c:rec_inters3d ( / ent dxf_ent ldxf_10 js n ename l_pt3D l_pt2D l_int2D)
 (defun l-coor2l-pt (lst flag / )
   (if lst
     (cons (list (car lst) (cadr lst) (if flag (caddr lst) 0.0))
       (l-coor2l-pt (if flag (cdddr lst) (cddr lst)) flag)
     )
   )
 )
 (princ "\nChoisir la polyligne contour")
 (while (null (setq ent (entsel))))
 (setq dxf_ent (entget (car ent)))
 (cond
   ((eq (cdr (assoc 0 dxf_ent)) "LWPOLYLINE")
     (setq ldxf_10 (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) dxf_ent)))
     (setq js (ssget "_F" ldxf_10 '((0 . "POLYLINE") (-4 . "&") (70 . 8))))
     (cond
       (js
         (setq n -1)
         (vl-load-com)
         (repeat (sslength js)
           (setq
             ename (vlax-ename->vla-object (ssname js (setq n (1+ n))))
             l_pt3D nil
             l_pt3D (append (l-coor2l-pt (vlax-get ename 'Coordinates) T) l_pt3D)
             l_pt2D (mapcar 'list (mapcar 'car l_pt3D) (mapcar 'cadr l_pt3D))
           )
           (foreach n (mapcar 'list ldxf_10 (cdr ldxf_10))
             (setq l_int2D
               (vl-remove nil
                 (mapcar
                   '(lambda (p3 p4)
                     (setq pt_int (inters (car n) (cadr n) p3 p4 T))
                   )
                   l_pt2D (append (cdr l_pt2d) (list (last l_pt2d)))
                 )
               )
             )
             (if (not (null l_int2d))
               (progn
                 (setq l_int3D
                   (vl-remove nil
                     (mapcar
                       '(lambda (p3 p4)
                         (setq pt_int
                           (inters
                             (list (caar l_int2d) (cadar l_int2d) 0.0)
                             (list (caar l_int2d) (cadar l_int2d) 100.0)
                             p3 p4
                             nil
                           )
                         )
                       )
                       l_pt3d (append (cdr l_pt3d) (list (last l_pt3d)))
                     )
                   )
                 )
                 (command "_.point" "_none" (car l_int3d))
               )
             )
           )
         )
       )
     )
   )
 )
 (prin1)
) 

 

En fait mon probleme est principalement de choisir la polyligne qui coupe le rectangle.

Attention ce bout de code n'est valable que pour les polylignes 3D.

 

Merci par avance de votre aide.

John.

[Tupolev]

"ou te ne sais pas lire", merci pour le dernier commentaire, c'est sympa, C'est vrai que je n'étais pas très bien réveillé et j'ai confondu coupure et ajuster. D'ailleurs comme tu m'as mis d'humeur chipoteuse, je pourrais te reprocher de ne pas avoir employer le bon terme car couper est une fonction à employer avec des solides et pas avec des polylignes. De plus si c'est un code lisp que tu cherches, ce qui n'était pas précisé dans ta demande, tu pourras sûrement trouver ton bonheur auprès des, lispeur fous à la bonne rubrique. Mais nonobstant la peur de ne rien apprendre à ton grand esprit je tente quand même une réponse partielle car mes souvenirs en lisp sont assez lointains :

J'essaierai d'abord un getsel pour le jeu de polylignes à couper, puis un entget pour le rectangle. Ensuite avec un compteur incrémentiel je traiterai mes entités polyligners une par une en réutilisant un bout du code de Crabe pour choper l'intersection entre la polyligne à traiter et le rectangle, à la fin de chaque passe du compteur tu n'as plus qu'à lancer coupure sur la polyligne en recrachant le point que tu auras mémorisé une ligne plus haut. A priori ça devrait marcher quelque soit l'altitude de ta polyligne 3d par rapport au rectangle. Là où le bas blesse c'est que je serai infichu de te traduire ça en code...Désolé, Bon courage et sans rancune !

 

 

[chris_mtp]

Merci pour ta réponse Tupolev ou mahr.francois mais je ne vois pas comment faire cela d'une seule manip sans lisp bien codé. Surtout si le rectangle ou le contour comprend un nombre de polylignes conséquent.

Je ne vais pas non plus taillader ton esprit vocabulaire à priori hors norme mais ta réponse serait mieux adapté si il y aurait au moins le code du Crabe joint à ta réponse.

Je pourrais essayer de l'adapter à mes besoins.

IL faudrait à mon avis seulement intégrer la commande couper au bout de code ci dessus en déterminant le point crée comme point de coupure.

 

 J'essaierai d'abord un getsel pour le jeu de polylignes à couper, puis un entget pour le rectangle

Inutile le code le fait déjà.

Par contre, pour l'incrémentation des polylignes d'accord.

 

John.

 

 

[(gile)]

Salut,

 

Un truc comme ça ?

 

EDIT : j'ai ajouté quelques commentaires.

 

;;; CUTONPLINE (gile)
;;; Coupe toutes les polylignes aux intersections avec le polygone sélectionné

(defun c:CutOnPline (/ capt elst ptlst ss n vla-capt objlst first int)
 (vl-load-com)
 
 ;; Sélection et traitement du polygone de capture
 (if
   (and
     (setq
capt (car (entsel "\nSélectionner le polygone de capture: "))
     )
     (setq elst (entget capt))
     (= (cdr (assoc 0 elst)) "LWPOLYLINE")
     (setq ptlst (mapcar '(lambda (pt)
		     (trans (cdr pt) capt 1)
		   )
		  (vl-remove-if-not
		    '(lambda (x) (= (car x) 10))
		    elst
		  )
	  )
     )
     (if (= 1 (logand 1 (cdr (assoc 70 elst))))
(setq ptlst (append ptlst (list (car ptlst))))
     )
   )

    ;; Sélection par trajet à l'aide du polygone de capture
    (if (and (setq ss (ssget "_F" ptlst '((0 . "*POLYLINE"))))
      (ssdel capt ss)
      (	 )
      (progn
 (setq capt (vlax-ename->vla-object capt))
 
 ;; Conversion du jeu de sélection en liste de VLA-OBJECT
 (repeat (setq n (sslength ss))
   (setq objlst	(cons (vlax-ename->vla-object
			(ssname ss (setq n (1- n)))
		      )
		      objlst
		)
   )
 )

 ;; Traiement de la liste
 (while	objlst

   ;; On traite le premier objet qu'on supprime de la liste
   (setq first	(car objlst)
	 objlst	(cdr objlst)
   )

   ;; S'il ya intersection entr l'objet et le polygone
   ;; (autre que les extrémités de l'objet)
   (if (setq int
	      (vl-remove-if
		'(lambda (p)
		   (or
		     (equal p
			    (vlax-curve-getStartPoint first)
			    1e-9
		     )
		     (equal p
			    (vlax-curve-getEndPoint first)
			    1e-9
		     )
		   )
		 )
		(3d-coord->pt-lst
		  (vlax-invoke
		    capt
		    'IntersectWith
		    first
		    acExtendNone
		  )
		)
	      )
       )

     ;; On coupe l'objet au point et on ajoute les 2 nouveaux objets à la liste
     (setq
       objlst (append (CutPolyAtPoint first (car int)) objlst)
     )
   )
 )
      )
    )
 )
 (princ) ; aucun retour sur la ligne de commande
)

;;; 3d-coord->pt-lst (gile)
;;; Convertit une liste de coordonnées 3D en liste de points
;;; (3d-coord->pt-lst '(1.0 2.0 3.0 4.0 5.0 6.0)) -> ((1.0 2.0 3.0) (4.0 5.0 6.0))

(defun 3d-coord->pt-lst	(lst)
 (if lst
   (cons (list (car lst) (cadr lst) (caddr lst))
  (3d-coord->pt-lst (cdddr lst))
   )
 )
)

;;; CutPolyAtPoint (gile)
;;; Coupe la polyligne (lw, 2d, 3d) au point et retourne la liste des deux
;;; entités résultantes (ENAME ou VLA-OBJECT suivant le type de l'argument)
;;;
;;; Arguments
;;; pl : une polyligne (ENAME ou VLA-OBJECT)
;;; pt : un point (coordonnées SCG)


(defun CutPolyAtPoint (pl pt / ec vl lst)
 (vl-load-com)
 (and (= (type pl) 'VLA-OBJECT)
      (setq pl	(vlax-vla-object->ename pl)
     vl	T
      )
 )
 (cond
   ((equal pt (vlax-curve-getEndPoint pl) 1e-9)
    (setq lst (list pl nil))
   )
   ((equal pt (vlax-curve-getStartPoint pl) 1e-9)
    (setq lst (list nil pl))
   )
   ((null (vlax-curve-getParamAtPoint pl pt))
    (setq lst (list pl nil))
   )
   (T
    (setq ec (getvar "cmdecho")
   el (entlast)
    )
    (setvar "cmdecho" 0)
    (vl-cmdf "_.break" pl "_non" (trans pt 0 1) "_non" "@")
    (setvar "cmdecho" ec)
    (if (= (cdr (assoc 0 (entget pl))) "LWPOLYLINE")
      (setq lst (list pl (entlast)))
      (progn
 (while (setq el (entnext el)) (setq lst (cons el lst)))
 (setq lst
	(vl-remove-if-not
	  '(lambda (x) (= "POLYLINE" (cdr (assoc 0 (entget x)))))
	  lst
	)
 )
      )
    )
   )
 )
 (if vl
   (mapcar '(lambda (x)
       (if x
	 (vlax-ename->vla-object x)
       )
     )
    lst
   )
   lst
 )
)

[chris_mtp]

Bonjour Gile

 

Désolé de n'avoir pu te répondre avant mais je viens juste de rentrer de déplacement.

Pour le lisp, lors de la sélection du polygone de capture, j'ai le retour suivant.

 

 Sélectionner le polygone de capture: nil

 

Pourtant mon contour est bien une polyligne 2D fermé.

 

J'ai essayé de voir un peu ton code pour essayer de trouver moi même l'erreur mais je vois pas.

Merci par avance de ton aide.

John.

 

[bonuscad]

J'ai essayé de voir un peu ton code pour essayer de trouver moi même l'erreur mais je vois pas.

 

Il n'y a pas d'erreurs: le lisp de (gile) ne travaille seulement qu'avec les VRAIS intersections !

 

D'après ce que j'ai compris du veux les intersections PROJETES sur tes polylignes 3D, ce que ne résous pas la fonction :

 

(vlax-invoke capt 'IntersectWith first acExtendNone)

 

Ta demande complique les choses, bien que je pense que celle-ci ne se limite qu'aux plans parallèles au SCG.

 

Un fichier exemple en + ?

 

[chris_mtp]

 D'après ce que j'ai compris du veux les intersections PROJETES sur tes polylignes 3D,

Je ne veux pas spécialement les intersections projetés

En fait, ca marche avec les poly2D mais pas avec les poly3D.

Car même avec des poly2D, il les coupe mais retourne le même message nil pour les 3D.

Merci par avance de votre aide.

John.

[(gile)]

Salut,

 

Comme le dit bonuscad, les polylignes (lw, 2d ou 3d) sont coupées uniquement s'il y a une réelle intersection avec la polyligne de capture.

 

Pour que ça fonctionne avec les intersections projetées c'est plus complexe, il faudrait projeter sur un plan parallèle au plan de la vue courante la poly de capture et toutes les poly capturées pour trouver les intersections puis traduire les points d'intersection trouvés sur les polylignes.

[chris_mtp]

Tres bien, dans ce cas, on peut projeter les entités qui sont contenus dans le polygone de capture à z=0 puis les découper ensuite avec le lisp de gile.

Ou peut même sélectionner grossièrement les entités à décaler à z=0 de manière à ne pas aplanir la totalité du plan puis d'utiliser le lisp.

 

J'ai essayé avec un rectangle coupé par une polyligne 2D ou 3D à Z=0

Ca coupe bien aux intersections par contre, j'ai toujours le retour nil mais ca marche.

 

Merci quand même de votre aide.

John.

[(gile)]

par contre, j'ai toujours le retour nil mais ca marche.

 

Il suffit de mettre un (princ) -ou (prin1)- à la fin de CutOnPline pour une "sortie silencieuse".

J'ai modifié le code.