Diviser avec des objets

[Titifonky]

Bonjour,

 

Es-ce que quelqu'un connait un petit programme Lisp qui permet de diviser un objet par un autre.

Exemple:

- Je selectionne un objet à couper, ligne, arc, cercle, polyligne

- Je selectionne les objets coupants, lignes, arcs, cercles, polylignes

- L'objet à couper est sectionné à chaques intersections entre l'objet à couper et les objets coupants

 

J'ai déjà essayé de faire un petit programme mais je rame un peu (je ne suis pas un pros des algorithmes).

J'ai determiné les equations pour trouver les intersections entre deux cercles, entre deux lignes,

mais je n'arrive pas à transformer une LWPOLYLINE en suite d'arcs et de lignes. C'est surtout les arcs qui me posent problème. Je n'ais pas de solution simple pour trouver le centre des arc.

Pour le moment je trouve le rayon et les deux positions possibles du centre de l'arc à partir des equations pour trouver les intersections entre deux cercles mais je n'arrive pas à choisir le centre de l'arc entre les deux points que je trouve.

Si quelqu'un aurait une solution moins compliqué cela m'arrangerait.

J'aurais également besoin d'un avis sur la structure général du programme. ;)

 

Merci

 

 

 

[zebulon_]

Salut,

 

va voir à cette adresse

 

http://www.afralisp.com/methods/lista/intersectwith_method.htm

 

en utilisant visual lisp, ça va devenir beaucoup plus simple.

[Titifonky]

Je te remercie pour l'adresse de ce site, il est très interessant.

J'ai essayé la commande VisualLisp "vla-IntersectWith" mais elle n'est pas detecté par ma version d'autocad, j'ai autocad 2000i. Dans l'editeur VisualLisp la fonction n'est pas en bleu mais reste en noir. :casstet:

Je ne sais pas d'ou ca vient mais dans tout les cas si je pouvais utiliser cette fonction cela arrangerais tout mes problèmes.

[didier]

Bonjour,

j'ai fait attention au forum,

mais je propose une alternative en VBA

c'est toujours bien de voir autre chose !

 

Sub InterObjets()

Dim ObjEntite1 As AcadEntity

Dim ObjEntite2 As AcadEntity

Dim PtInters As Variant

Dim I As Integer

Dim j As Integer

Dim Compteur As Integer

Compteur = 1

ThisDrawing.Utility.GetEntity ObjEntite1, pt, "Choix de la première Entité ..."

ThisDrawing.Utility.GetEntity ObjEntite2, pt, "Choix de la deuxième Entité ..."

PtInters = ObjEntite1.IntersectWith(ObjEntite2, acExtendNone)

 

Dim Message As String

If VarType(PtInters) vbEmpty Then

For I = LBound(PtInters) To UBound(PtInters)

Message = "Point d'intersection Numéro : " & Compteur & " -> " & PtInters(j) & "--" & PtInters(j + 1) '& "--" & PtInters(j + 2)

MsgBox Message, , "Coordonnées"

Message = ""

I = I + 2

j = j + 3

Compteur = Compteur + 1

Next

End If

End Sub

 

 

amicalement

 

[Titifonky]

Salut,

C'est sympa te reponse en VBA .

J'ai essayé de le faire également mais comme je suis pas un pro du VBA j'ai pas reussi.

Avec cette exemple je vais pouvoir commencer. En fait je me pose la question si le Lisp est vraiment interessant par rapport au VBA . J'ai remarqué que le langage est un peu plus complexe mais les possibilités sont énormes. Et en plus c'est toujours compatible parcqu'avec le Lisp c'est pas toujours facile entre les versions.

Merci

 

[Patrick_35]

Un petit cadeau, ça ne fonctionne que sur des lignes mais il est facilement adaptable. C’est un de mes premiers et quand je le regarde, je vois des améliorations à apporter mais bon, il marche bien

@+

 

;;;=================================================================
;;;
;;; COU.LSP V1.00
;;;
;;; Copyright (C) Patrick
;;;
;;;=================================================================

(defun c:cou(/ cmd h s)

 (defun *errcoup* (msg)
   (if (/= msg "Function cancelled")
     (if (= msg "quit / exit abort")
       (princ)
       (princ (strcat "\nErreur : " msg))
     )
     (princ)
   )
   (setq *error* s)
   (setvar "pickadd" h)
   (setvar "cmdecho" cmd)
   (princ)
 )

 (defun couper_ligne(/ a b c d e f g n o p1 p2 q)

   (defun trie_liste(o / b c d f i k n l)
     (setq b e)
     (setq l 0)
     (while (/= (car b) nil)
       (setq i (car b))
       (cond
         ((or (= o "DG") (= o "GD"))
           (foreach n b
             (if (< (car n) (car i))
               (setq i n)
             )
           )
         )
       )
       (cond
         ((or (= o "HB") (= o "BH"))
           (foreach n b
             (if (< (cadr n) (cadr i))
               (setq i n)
             )
           )
         )
       )
       (cond
         ((or (= o "BGH") (= o "HDB"))
           (foreach n b
             (if (< (car n) (car i))
               (setq i n)
             )
           )
           (foreach n b
             (if (and (= (car n) (car i)) (< (cadr n) (cadr i)))
               (setq i n)
             )
           )
         )
         ((or (= o "HGB") (= o "BDH"))
           (foreach n b
             (if (< (car n) (car i))
               (setq i n)
             )
           )
           (foreach n b
             (if (and (= (car n) (car i)) (> (cadr n) (cadr i)))
               (setq i n)
             )
           )
         )
       )
       (setq d (append (list i) d))
       (setq c nil)
       (foreach n b
         (if (/= n i)
           (setq c (append (list n) c))
         )
       )
       (setq b c)
       (setq l (1+ l))
     )
     (if (or (= o "GD") (= o "BH") (= o "BGH") (= o "BGD") (= o "HGB") (= o "BDG"))
       (setq e (reverse d))
       (setq e d)
     )
   )

   (princ "\nSélectionnez la ligne à couper.")
   (setq e nil)
   (setvar "pickadd" 0)
   (setq a (ssget))
   (if a
     (progn
       (setq n 0)
       (while (ssname a n)
         (if (= (cdr (assoc 0 (entget (ssname a n)))) "LINE")
           (setq b n)
         )
         (setq n (1+ n))
       )
       (if b
         (progn
           (princ "\nSélectionnez les intersections.")
           (setvar "pickadd" 1)
           (setq c (ssget))
           (if c
             (progn
               (setq n 0)
               (setq d nil)
               (while (ssname c n)
                 (if (= (cdr (assoc 0 (entget (ssname c n)))) "LINE")
                   (setq d n)
                 )
                 (setq n (1+ n))
               )
               (if d
                 (progn
                   (setq n 0)
                   (setq i 0)
                   (setq b (entget (ssname a b)))
                   (while (ssname c n)
                     (setq d (entget (ssname c n)))
                     (if (= (cdr (assoc 0 d)) "LINE")
                       (progn
                         (setq f (inters (list (cadr (assoc 10 b)) (caddr (assoc 10 b)))
                                         (list (cadr (assoc 11 b)) (caddr (assoc 11 b)))
                                         (list (cadr (assoc 10 d)) (caddr (assoc 10 d)))
                                         (list (cadr (assoc 11 d)) (caddr (assoc 11 d)))))
                         (if f
                           (progn
                             (setq i (1+ i))
                             (setq e (append (list f) e))
                           )
                         )
                       )
                     )
                     (setq n (1+ n))
                   )
                   (if e
                     (progn
                       (cond
                         ((= (cadr (assoc 10 b)) (cadr (assoc 11 b)))
                           (if (> (caddr (assoc 10 b)) (caddr (assoc 11 b)))
                             (setq o "HB")
                             (setq o "BH")
                           )
                         )
                         ((= (caddr (assoc 10 b)) (caddr (assoc 11 b)))
                           (if (> (cadr (assoc 10 b)) (cadr (assoc 11 b)))
                             (setq o "DG")
                             (setq o "GD")
                           )
                         )
                         ((> (cadr (assoc 10 b)) (cadr (assoc 11 b)))
                           (if (> (caddr (assoc 10 b)) (caddr (assoc 11 b)))
                             (setq o "HDB")
                             (setq o "BGH")
                           )
                         )
                         ((< (cadr (assoc 10 b)) (cadr (assoc 11 b)))
                           (if (> (caddr (assoc 10 b)) (caddr (assoc 11 b)))
                             (setq o "HGB")
                             (setq o "BDH")
                           )
                         )
                       )
                       (trie_liste o)
                       (if (or (= o "BDH") (= o "BGH"))
                         (progn
                           (setq e (reverse e))
                           (setq k (angle (list (cadr (assoc 11 b)) (caddr (assoc 11 b)))
                                          (list (cadr (assoc 10 b)) (caddr (assoc 10 b)))))
                         )
                         (setq k (angle (list (cadr (assoc 10 b)) (caddr (assoc 10 b)))
                                        (list (cadr (assoc 11 b)) (caddr (assoc 11 b)))))
                       )
                       (setq g (getreal (strcat "\nValeur du décalage <" (rtos g_lign) "> : ")))
                       (if g
                         (setq g_lign g)
                       )
                       (setq n 0)
                       (while (nth n e)
                         (setq p1 (polar (nth n e) k g_lign))
                         (setq p2 (polar (nth n e) k (- g_lign)))
                         (command "_.break" (cdr (assoc -1 b)) p1 p2)
                         (setq q (entget (ssname (ssget "_l") 0)))
                         (if (/= (cdr (assoc -1 b)) (cdr (assoc -1 q)))
                           (setq b q)
                           (setq b (entget (cdr (assoc -1 b))))
                         )
                         (setq n (1+ n))
                       )
                     )
                     (princ "\nPas d'intersection.")
                   )
                 )
                 (princ "\nAucune ligne de sélectionnée.")
               )
             )
             (princ "\nAucune Sélection.")
           )
         )
         (princ "\nAucune ligne de sélectionnée.")
       )
     )
     (princ "\nAucune Sélection.")
   )
   (princ)
 )

 (setq s *error*)
 (setq *error* *errcoup*)
 (setq cmd (getvar "cmdecho"))
 (setq h (getvar "pickadd"))
 (setvar "cmdecho" 0)
 (command "_.undo" "_group")
 (if (not g_lign)
   (setq g_lign 1.0)
 )
 (couper_ligne)
 (command "_.undo" "_end")
 (setq *error* s)
 (setvar "pickadd" h)
 (setvar "cmdecho" cmd)
 (princ)
)

[Tramber]

J'ai plusieurs éléments de réponse à te donner :

 

Conseils :

 

1, si tu traites tout ca avec des (command...), n'oublie pas les zooms, car le prog peut refuser de fonctionner si l'on ne voit pas tes entités.

 

2. pour chercher des intersections, utilise (osnap pt mode) aussi souvent que possible

 

Je n'ais pas de solution simple pour trouver le centre des arc.

(cdr(assoc 10 (entget nomentite))), c'est la réponse

 

mais je n'arrive pas à transformer une LWPOLYLINE en suite d'arcs et de lignes

 

Si tu en as vraiment besoin :

 

il y a un an, j'étais assez débutant, regarde ce que Didier m'a enseigné et que la force soit avec toi ici.

 

Sinon, la fonction la + utile pour toi est IntersectWith mais il faut écrire en VLA, ce qui n'est pas facile si tu es débutant en lisp.

 

 

 

 

[Titifonky]

En fait mon probleme maintenant est de trouver le centre d'un arc à partir des données contenus dans une LWPOLYLINE, c'est à dire:

 

-le point de depart,

-le point d'arrivé,

-la tangente du quart de l'angle de l'arc en radian, quand il est négatif l'arc tourne dans le sens inverse des aiguilles d'une montre quand il est positif dans le sens trigonométrique

 

Pour le moment j'arrive à trouver par des moyens mathématiques le rayon (c'est dur mais on y arrive), je trouve les deux centres possibles de l'arc de cercle par intersection de deux cercle, mais je n'arrive pas à determiner quel point est le centre du cercle. Dans tout les cas il existe une solution mathématique au problème, il ne reste plus qu'a la trouver.

 

Pour la commande (osnap), j'essaye de ne pas l'utiliser parcque j'ai peur qu'elle ne trouve pas tout le temps les intersections. Quand je dessine, j'ai quelques fois des problèmes avec les accrochages au objets. Par exemple, je n'arrive pas à accrocher le centre d'un arc de cercle sur un polyligne, je ne sais pas d'ou cela peut venir mais j'espere que ça n'influence pas également la commande (osnap), c'est pour ça que j'evite de l'utiliser pour une meilleur compatibilité.

 

La solution pour transformer une polyligne en suite de lignes et d'arc serait peut-être de decomposer la polyligne au début du programme et de la recomposer à la fin mais je n'ai pas encore essayé.

 

Pour le moment, mon programme me permet de diviser un arc, un cercle ou une ligne par ces memes objets. C'est pour ça que j'essaye de decomposer une polyligne en arc et en ligne, cela me permet d'utiliser les mêmes routines.

 

Pour ce qui est du VLA, j'ai du mal à trouver des informations sur les différentes commandes qui existent et la commande IntersectWith n'est pas reconu sous AutoCAD 2000i, pas de chance je travail avec cette version.

 

J'ai eu quelques aperçu par Didier du VBA sous AutoCAD et je pense que c'est un langage un peut plus compliqué quand on est pas habitué au langage orienté objet mais les possibilités sont énormes. Je ne sais pas ce que vous en pensé mais je me pose la question sur l'interêt de programmer en Lisp ou en VisualLisp vue que le VBA est universel.

 

Sinon à pars ça tout va bien et Cadxp c'est super :D

[Tramber]

Pour ce qui est du VLA, j'ai du mal à trouver des informations sur les différentes commandes qui existent et la commande IntersectWith n'est pas reconu sous AutoCAD 2000i, pas de chance je travail avec cette version.

 

Il faut faire un (vl-load-com) au préalable sur 2000 et 2000i, et tu verras, c'est reconnu.

 

Je fais une remarque :

 

dans une polyligne, il y a les points (cdr(assoc 10 et 11, et la courbure (cdr(assoc 42

Sachant que cette dernière a un signe, tu peux trouver le "côté" du centre.

 

Mais je t'ai envoyé vers un lien ou le lisp te permet de récupérer les entités d'une poly et là, les codes 10, 40, 50 et 51 te donnent tout.

 

Sinon, à propos de OSNAP, tu peux avoir le centre d'un arc sous conditions de dézoom suffisant.

 

 

 

 

[Titifonky]

Ca y est, avec du temps on arrive à tout.

 

J'ai pu faire un petit programme qui me renvoie une liste contenant une suite de ligne et d'arc après avoir selectionné une polyligne.

 

Je n'ai utilisé que des moyens mathématique, je trouve ça plus sur et plus rationel.

J'ai regardé un peu la commande Mesurer mais suivant les cas il faut diviser la polyligne en un nombre impressionant de segment, en fonction du plus petit objet appartenant à la polyligne.

 

Si cette routine interesse quelqu'un je l'ai mise à disposition sur le forum Routines Lisp, la routine est un peu longue et je n'ai pas fait beaucoup de commentaire.

 

J'ai essayé la commande IntersectWith mais je ne comprend pas comment je peux extraire les données d'un objet type Variant à partir du Lisp.

Si quelqu'un peut m'expliquer ca pourrait me permettre de faire un Lisp plus court.

 

A+

 

 

[Tramber]

un lien

 

Bravo à lui (Kamal Boutora), et à Serge !