Orientation d'une parcelle

chris_mtp · le 10 octobre 2011

Bonjour a tous

Je dois dans un lisp utiliser june fonction du type grread ou grdraw qui me permettrait de définir les orientations d'une parcelle.

Je m'explique :

Prenons un carre de 10 sur 10.

Une partie est oriente au Nord, une a L'est, au sud et a l'ouest.

Comment je peux faire une boucle (qui s'arreterait si l'utilisateur arrive sur le meme point de depart et d'arrivee) avec 4 entree par exemple avec la fonction getpoint pour dire que tel ou tel segment est au Nord, Sud Est ou Ouest ?

Je dois en fait creer pour chaque parcelle un fichier texte avec les coordonnées de chaque extrémités de tous les segments qui composent la polyligne 2D close..

Par exemple :

- Au Nord : pt1 x1 y1 pt2 x2 y2

- A l'Est : pt2 x2 y2 pt3 x3 y3

- Au Sud : pt3 x3 y3 pt4 x4 y4

- A l'Ouest : pt4 x4 y4 pt1 x1 y1

Je pense qu'il faudrait utiliser les fonctions grread, grtext ou grdraw mais ça dépasse de loin mes connaissances en visual lisp.

Car il faudrait qu'en sélectionnant la polyligne2d, la parcelle en fait que le lisp retrace par dessus une même polyligne qui permettrait a l'utilisateur de voir concrètement les orientations qu'il définit.

Avez vous des idées pour m'éclairer ?

Merci par avance de votre aide.

John

vincentp010 · le 10 octobre 2011

Salut,

je n'ai pas très bien compris les histoires d'orientation.

Pourrais tu être plus précis dans ton explication ?

VtKp · le 11 octobre 2011

Bonjour,

Voici un lisp explicite je pense de ma demande

A tester dans un dessin vierge

(defun c:pol1 (/ file pol ldxf_10 lseg)

;; Création d'une parcelle exemple
(setvar "CECOLOR" "1")
(command "_pline"
(list 125 125 0)
(list 135 120 0)
(list 150 130 0)
(list 150 150 0)
(list 135 145 0)
(list 125 158 0)
"c"
)
(setvar "CECOLOR" "DUCALQUE")

;; Zoom centré
(command "zoom" "et")

;; Création du fichier Export

(setq file (open "C:\\Export_poly.txt" "w"))
(setq pol (car (entsel "\nChoix de la parcelle à traiter : ")))
(setq ldxf_10 (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget pol))))
(setq lseg (GetPolySegs pol))
(setq pti (getpoint "\nSélectionner le point de départ : "))
(setq ptn (getpoint "\nIndiquer la fin du tronçon - Point suivant : "))

;; Début de la boucle à réaliser


;; L'utilisateur indique le premier point du tronçon Nord,
;; Avec la liste l_seg, on sauvegarde dans une liste le segment ou la continuite de deux segments correspondant au Nord.
;; Dans notre cas, on aurait une liste du type (que pour l'orientation Nord)

;; l_onr (("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0)))))

;; Ensuite sélection de la fin du tronçon Est, on aurait donc une liste du type

;; l_onr (
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0))))
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0)))
;; )

;; Ensuite sélection de la fin du tronçon Sud, on aurait donc une liste du type

;; l_onr (
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0))))
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0)))
;; ("Sud" (((125.0 125.0) 0.0 (135.0 120.0)) ((135.0 120.0) 0.0 (150.0 130.0))))
;; )

;; Et pour finir, sélection de la fin du tronçon Ouest et la boucle doit se terminer car le point sélectionné au départ et le même que celui d'arrivée

;; l_onr (
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0))))
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0)))
;; ("Sud" (((125.0 125.0) 0.0 (135.0 120.0)) ((135.0 120.0) 0.0 (150.0 130.0))))
;; ("Ouest" ((125.0 158.0) 0.0 (125.0 125.0)))
;; )


;; Voici un début de boucle mais incomplet à mon sens, il doit manquer certaines conditions
;; et surtout je ne vois pas comment indiquer dans une boucle de ce type le choix entre une orientation Nord, Est, Sud et Ouest

;;(while (/= (distance (pti ptn)) 0))
(write-line "Au Nord : (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0)))" file)

(close file)

(command "_.shell" "start notepad C:\\Export_poly.txt")


(princ ldxf_10)
(prin1)
)

;;(cond
;;(x_alpha
;;(entmod (subst (cons 50 x_alpha) (assoc 50 dxf_txt) dxf_txt))
;;(princ "\n<Espace> ou [Click+gauche] pour tourner de 90°/<Entrée> ou [Click+droit] pour finir!.")
;;(while (and (not (member (setq key (grread nil 4 0)) '((2 13)))) (/= (car key) 25))
;;(setq x_alpha (+ (/ pi 2.0) x_alpha))
;;(entmod (subst (cons 50 x_alpha) (assoc 50 dxf_txt) dxf_txt))
;;)
;;(redraw)
;;)
;;)



(defun getPolySegs (ent / entl p1 pt bulge seg ptlst)
(cond (ent
(setq entl (entget ent))
;; save start point if polyline is closed
(if (= (logand (cdr (assoc 70 entl)) 1) 1)
(setq p1 (cdr (assoc 10 entl)))
)
;; run thru entity list to collect list of segments
(while (setq entl (member (assoc 10 entl) entl))
;; if segment then add to list
(if (and pt bulge)
(setq seg (list pt bulge))
)
;; save next point and bulge
(setq pt    (cdr (assoc 10 entl))
bulge (cdr (assoc 42 entl))
)
;; if segment is build then add last point to segment
;; and add segment to list
(if seg
(setq seg (append seg (list pt))
ptlst (cons seg ptlst))
)
;; reduce list and clear temporary segment
(setq entl  (cdr entl)
seg   nil
)
)
)
)
;; if polyline is closed then add closing segment to list
(if p1 (setq ptlst (cons (list pt bulge p1) ptlst)))
;; reverse and return list of segments
(reverse ptlst)
)


(defun getArcInfo (segment / a p1 bulge p2 c p3 p4 p r s result)
;; assigner variables avec les valeurs de l'argument
(mapcar 'set '(p1 bulge p2) segment)
(if (not (zerop bulge))
(progn
;; trouver la corde
(setq c (distance p1 p2))
;; trouver la flèche
(setq s (* (/ c 2.0) (abs bulge)))
;; trouver le rayon par Pythagore
(setq r (/ (+ (expt s 2.0) (expt (/ c 2.0) 2.0)) (* 2.0 s)))
;; distance au centre
(setq a (- r s))
;; coordonnées du milieu de p1 et P2
(setq P4 (polar P1 (angle P1 P2) (/ c 2.0)))
;; coordonnées du centre
(setq p
(if (>= bulge 0)
(polar p4 (+ (angle p1 p2) (/ pi 2.0)) a)
(polar p4 (- (angle p1 p2) (/ pi 2.0)) a)
)
)
;; coordonnées de P3
(setq p3
(if (>= bulge 0)
(polar p4 (- (angle p1 p2) (/ pi 2.0)) s)
(polar p4 (+ (angle p1 p2) (/ pi 2.0)) s)
)
)
(setq result (list p r c))
)
(setq result nil)
)
result
)





(defun clockwise-p (p1 p2 p3)
(< (sin (- (angle p1 p3) (angle p1 p2))) -1e-14)
)

(defun remove-doubles (lst / lst2)
(while (car lst)
(setq lst2   (cons (car lst) lst2)
lst (vl-remove (car lst) lst)
)
)
(reverse lst2)
)

(defun ang2d (p1 p2 p3 / base ang)
(setq base (getvar "ANGBASE"))
(setq ang (abs (- (angle p2 p1) (angle p2 p3))))
(if (< (+ pi 1e-9) ang)
(setq ang (- (* 2 pi) ang))
)
(if (zerop (getvar "ANGDIR"))
(+ base ang)
(- base ang)
)
)

(prin1)

VtKp · le 12 octobre 2011

Voici à peu près ce que j'aimerais faire

Bout de code à mettre à la suite de

(setq pti (getpoint "\nSélectionner le point de départ : "))

(setq l_onr nil)

(while 
(and
(or
(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Est"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest"))
(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest"))
)
(/= (distance pti ptn) 0)
)

;; Il faudrait là enregistrer les segments dans la liste l_onr et reprendre la définition des orientations depuis la dernière arreté et non pas depuis le début.
;; Par exemple si on clique sur le 3ième sommet de la parcelle, reprendre à la fin du Tronçon Sud et non pas au Nord
;; mais je patine avec le peu de connaissances que j'ai



(command "_pline" pti ptn "")
(setq ptn pti)
)

Merci par avance de votre aide

John

Tramber · le 12 octobre 2011

Salut !

Je ne comprends pas bien le but final mais je te livre ces bouts de code, cela devrait bien correspondre. On travaille dans le SCG.

    (setq pol (car (entsel "\nChoix de la parcelle à traiter : "))
  vpol(vlax-ename->vla-object pol)); vl objet
   (setq ldxf_10 (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget pol))))
   (if(not(zerop(logand 1 (cdr(assoc 70(entget pol))))))
     (setq ldxf_10(append ldxf_10 (list(car ldxf_10))))); si poly close, j'ajoute un point
   
   (setq boucle t)
   (setq param -1)
   (setq lismilieux(mapcar '(lambda(x)(vlax-curve-getPointAtParam vpol (+ 0.5(setq param(1+ param)))))ldxf_10)); recherche des milieux de segments
   (setq lismilieux(VL-REMOVE-IF 'null lismilieux))
   
   (while(and boucle (setq gr (grread T 12 0)))
     (redraw)
     (cond
((= (car gr) 5)
 (setq ind(car(vl-sort-i (mapcar '(lambda(x)(distance x(cadr gr))) lismilieux)'<)))
 (if(and(nth ind ldxf_10)(nth (1+ ind) ldxf_10))
   (grdraw (nth ind ldxf_10) (nth (1+ ind) ldxf_10) 1 ))
 (princ(strcat "\n" (VL-PRINC-TO-STRING (nth ind ldxf_10)) "\t"(VL-PRINC-TO-STRING (nth (1+ ind) ldxf_10))))
 )	
;; Clic gauche ou droit souris
((or(= (car gr) 3)(member (car gr) '(11 25)))
 (setq boucle nil)
 )
)      
     )

NB : petite note. En ma qualité de modo, je vais te proposer bientôt de déplacer le message.

On a bien dit que ce forum était pour poster des routines matures. C'est pour cela que j'ai demandé à être modo ! Déplacer les sujets débutants vers "débuter..." B)

VtKp · le 13 octobre 2011

Bonjour Tramber

Merci de ta réponse et désolé de "polluer" ce post ou ce forum.

Tu peux changer ce post de sous forum si tu le désires, pas de problème.

J'ai testé ton bout de code et je n'arrive pas à ce que je veux.

Le but est d'écrire dans un fichier texte suivant les différentes orientations choisies par l'utilisateur

les coordonnées des sommets d'un ou de plusieurs segments d'un tronçon Nord, Sud, ou encore Nord-Ouest

comme indiqué ici dans cet exemple

;; Début de la boucle à réaliser 


;; L'utilisateur indique le premier point du tronçon Nord, 
;; Avec la liste l_seg, on sauvegarde dans une liste le segment ou la continuite de deux segments correspondant au Nord. 
;; Dans notre cas, on aurait une liste du type (que pour l'orientation Nord) 

;; l_onr (("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0))))) 

;; Ensuite sélection de la fin du tronçon Est, on aurait donc une liste du type 

;; l_onr ( 
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0)))) 
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0))) 
;; ) 

;; Ensuite sélection de la fin du tronçon Sud, on aurait donc une liste du type 

;; l_onr ( 
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0)))) 
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0))) 
;; ("Sud" (((125.0 125.0) 0.0 (135.0 120.0)) ((135.0 120.0) 0.0 (150.0 130.0)))) 
;; ) 

;; Et pour finir, sélection de la fin du tronçon Ouest et la boucle doit se terminer car le point sélectionné au départ et le même que celui d'arrivée 

;; l_onr ( 
;; ("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0)))) 
;; ("Est" ((150.0 130.0) 0.0 (150.0 150.0))) 
;; ("Sud" (((125.0 125.0) 0.0 (135.0 120.0)) ((135.0 120.0) 0.0 (150.0 130.0)))) 
;; ("Ouest" ((125.0 158.0) 0.0 (125.0 125.0))) 
;; )

Et en utilisant si possible cette méthode de saisie

(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) 
(setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest"))

En récapitulant après la saisie du point de départ, l'utilisateur doit indiquer la fin du tronçon Nord et toutes les coordonnées des sommets du tronçon Nord doivent être ajoutés à la liste l_onr,

Ensuite le lisp continue avec la saisie de la fin du tronçon Est,

toutes les coordonnées des sommets du tronçon Est doivent être ajoutés à la liste l_onr,

... ETC jusqu'à arrivé au tronçon Nord-Ouest

La boucle s'arrête si l'utilisateur sélectionne un point d'arrivée qui est le même que le point de départ défini comme pti

Après la sélection de la fin d'un tronçon (par exemple Nord) , mon problème vient du fait que je ne sais comment proposer à l'utilisateur de reprendre la sélection avec la fin du tronçon Est par exemple et non pas de reprendre la boucle depuis le début. Je pense qu'il faut utiliser les fonctions grread et grdraw mais j'ai du mal à les comprendre.

J'espère que mes explications t'auront éclairé.

Merci encore de ton aide.

John

les coor

Tramber · le 13 octobre 2011

Coucou !

Je déplace le message. Aucun problème de pollution. C'est juste que le titre du sous-forum parle explicitement de lieu de publication.

Mais, j'avoue que j'ai du mal à comprendre ton voeux, je croyais t'avoir décoincé !

Je veux bien le relire tantôt :(rires forts):

Mais pense à mettre des images parce que ton histoire de tronçon Nord, je pige pas :P

VtKp · le 14 octobre 2011

oK Pas de problème pour le message.

Pour mon problème, le tronçon Nord correspond à un ou plusieurs segments de la polyligne 2D fermée orienté au Nord quand tu mets le curseur Autocad au centre de la parcelle.

Tu prends le cas d'un carré par exemple, tu as bien si tu mets ton curseur au centre de ce carré en tournant dans le sens horaire 4 orientations, une au Nord, une à l'est, une au Sud et une à l'Ouest.

Dans mon cas si tu prends ce même carré, je voudrais faire une boucle qui à partir d'un point sélectionné (point en haut à gauche dans cet exemple) le lisp demande à l'utilisateur la fin du tronçon Nord (l'utilisateur sélectionnerait le point haut droit et on aurait une liste l_onr du type

Nord - (les coordonnées du point haut gauche) (coordonnées des points intermédiaires s'il y en a) (coordonnées du point haut droit)

, puis on continue avec la fin du tronçon Est,

Est - (les coordonnées du point haut droit) (coordonnées des points intermédiaires s'il y en a) (coordonnées du point bas droit)

, puis on continue avec la fin du tronçon Sud,

Sud - (les coordonnées du point bas droit) (coordonnées des points intermédiaires s'il y en a) (coordonnées du point bas gauche)

, puis on continue avec la fin du tronçon Ouest,

Ouest - (les coordonnées du point bas gauche) (coordonnées des points intermédiaires s'il y en a) (coordonnées du point haut gauche)

Et comme le point de fin du tronçon Ouest correspond au point de début du tronçon Nord, la boucle s'arrête.

D'ou la necessité de sélectionner un point de départ et de terminer la boucle sur ce même point départ quand l'utlisation clique le même point.

La liste l_onr contiendrait ainsi 4 tronçons avec tous les coordonnées des sommets chaque orientation.

Par contre, si au lieu des coordonnées des points de début, intermédiaires et de fin de chaque tronçon on pourrait stocker les listes des segments obtenues avec la fonction getPolySegs, c'est mieux sinon avec les coordonnées, je pourrais m'en sortir.

Et de même si on pourrait intégrer dans le choix de sélection des tronçons des intermédiaires comme Nord-Ouest, Nord-Est, Sud-Ouest, Sud-Est ce serait super mais bon je verrais cela après ....

Merci encore de ton aide.

John

didier · le 14 octobre 2011

coucou

ça m'intéresse de savoir la finalité

j'ai commencé à travailler dessus et si

je trouve du temps ce week-end je te livre quelque chose lundi.

mais à quoi ça peut bien servir de savoir ça ?

ces listes de coordonnées vont devenir quoi ?

amicalement

bonuscad · le 14 octobre 2011

Bonjour,

Je ne sais pas si ça sera d'une utilité.

J'avais crée ça pour déterminer la position d'une ligne de rappel (depuis le centre de la vue,suivant les 4 quadrants trigo)

Pour tester coller entièrement le code directement en ligne de commande.

((lambda ( / pt1 pt2 d_x d_y)
 (setq pt1 (getvar "VIEWCTR") pt2 pt1 d_x (* (getvar "viewsize") 0.3) d_y (* (getvar "viewsize") 0.3))
 (while (equal pt2 pt1)
   (setq pt2
     ((lambda ( / key pt p1 p2 p3 p4 alpha)
       (princ "\nBloc position ")
       (while (and (setq key (grread T 4 0)) (/= (car key) 3))
         (cond
           ((eq (car key) 5)
             (redraw)
             (setq pt (cadr key))
             (setq alpha (angle pt1 pt))
             (cond
               ((and (>= alpha 0.0) (< alpha (* pi 0.5)))
                 (setq
                   p1 pt
                   p2 (list (+ (car pt) d_x) (cadr pt))
                   p3 (list (+ (car pt) d_x) (+ (cadr pt) d_y))
                   p4 (list (car pt) (+ (cadr pt) d_y))
                 )
               )
               ((and (>= alpha (* pi 0.5)) (< alpha pi))
                 (setq
                   p1 pt
                   p2 (list (car pt) (+ (cadr pt) d_y))
                   p3 (list (- (car pt) d_x) (+ (cadr pt) d_y))
                   p4 (list (- (car pt) d_x) (cadr pt))
                 )
               )
               ((and (>= alpha pi) (< alpha (* pi 1.5)))
                 (setq
                   p1 pt
                   p2 (list (- (car pt) d_x) (cadr pt))
                   p3 (list (- (car pt) d_x) (- (cadr pt) d_y))
                   p4 (list (car pt) (- (cadr pt) d_y))
                 )
               )
               (T
                 (setq
                   p1 pt
                   p2 (list (car pt) (- (cadr pt) d_y))
                   p3 (list (+ (car pt) d_x) (- (cadr pt) d_y))
                   p4 (list (+ (car pt) d_x) (cadr pt))
                 )
               )
             )
             (if (> (abs (apply '- (mapcar 'car (list pt1 pt)))) (abs (apply '- (mapcar 'cadr (list pt1 pt)))))
               (progn
                 (grdraw pt1 (list (car p1) (cadr pt1)) 1)
                 (grdraw (list (car p1) (cadr pt1)) (list (car p1) (cadr pt)) 1)
               )
               (progn
                 (grdraw pt1 (list (car pt1) (cadr p1)) 1)
                 (grdraw (list (car pt1) (cadr p1)) (list (car p1) (cadr pt)) 1)
               )
             )
             (grdraw p1 p2 7)
             (grdraw p2 p3 7)
             (grdraw p3 p4 7)
             (grdraw p4 p1 7)
           )
         )
       )
       (redraw)
       (cadr key)
     ))
   )
 )
))

VtKp · le 14 octobre 2011

Bonjour Didier, Bonuscad

Didier, il s'agit en fait d'identifier des points communs sur une limite mitoyenne entre deux parcelles.

dans le cadre d'un document d'arpentage sur Mayotte.

Bonuscad, je ne vois pas bien l'interêt d'une telle commande si ce n'est enfin pour ma part l'utilisation de grdraw.

Merci encore pour votre aide.

John

didier · le 14 octobre 2011

coucou

dire que j'ai passé plus d'un an à Mayotte

que j'ai failli m'y faire embaucher (souvenirs)

aujourd'hui ce serait moi qui serait demandeur

mais non impossible,

je refuse définitivement de travailler pour des G.E.

amicalement

VtKp · le 15 octobre 2011

Bonjour à tous,

Avec un peu de mal et de maux de têtes, voici le lisp qui correspond à ce que je veux faire (à tester dans un dessin vierge et pensez à créer un répertoire intitulé TMP sous C: avant de lancer le lisp)

(defun c:mitoy (/ pol ldxf_10 file pti ptd ptn i nb_d nb_f leng pt_ints pt_ind d)

(command "_pline"
(list 320.36 89.3179)
(list 343.404 74.7689)
(list 332.727 57.856)
(list 314.1233 69.6008)
(list 312.485 76.8448)
"_c"
)

(command "zoom" "et")

(setvar "OSMODE" 65)

(setq pol (car (entsel "\nChoix de la parcelle à traiter : ")))
(setq ldxf_10 (remove-doubles (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget pol)))))

(if (not (zerop (logand 1 (cdr (assoc 70 (entget pol))))))
(setq ldxf_10 (append ldxf_10 (list (car ldxf_10))))
); si poly close, j'ajoute un point

(setq file (open "C:/TMP/lim_mitoyenne.txt" "w"))

(setq pti (getpoint "\nSélectionner le point de départ : "))
(setq ptd pti)
(setq ptn (list (1+ (car pti)) (cadr pti) 0.0))

(setq i 1)

(while 
(and
(/= (distance pti ptn) 0)

(cond

((= i 1)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 2)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 3)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 4)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 5)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 6)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

((= i 7)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)


((= i 8)
(or
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Ouest")) (setq i 8))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord")) (setq i 1))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Nord-Est")) (setq i 2))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Est")) (setq i 3))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Est")) (setq i 4))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud")) (setq i 5))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Sud-Ouest")) (setq i 6))
(and (setq ptn (getpoint "\nIndiquer la fin du tronçon Ouest")) (setq i 7))
(and (progn (prompt "\nSaisie non valide") (exit)))
)
)

)
)


(setq nb_d (vl-position (reverse (cdr (reverse ptd))) ldxf_10))
(setq nb_f (vl-position (reverse (cdr (reverse ptn))) ldxf_10))
(setq leng (- nb_f nb_d))
(setq pt_ints (sublst ldxf_10 (1+ nb_d) (1+ leng)))

(cond

((= i 1)
(write-line "Tronçon Nord : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 2)
(write-line "Tronçon Nord-Est : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 3)
(write-line "Tronçon Est : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 4)
(write-line "Tronçon Sud-Est : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 5)
(write-line "Tronçon Sud : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 6)
(write-line "Tronçon Sud-Ouest : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 7)
(write-line "Tronçon Ouest : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

((= i 8)
(write-line "Tronçon Nord-Ouest : " file)

(setq d 0)
(repeat (length pt_ints)
(setq pt_ind (nth d pt_ints))
(write-line (strcat "Point " (itoa (1+ (vl-position pt_ind ldxf_10))) "\t" "-" "\t" (rtos (car pt_ind) 2 2) "\t" (rtos (cadr pt_ind) 2 2)) file)
(setq d (1+ d))
)
)

)

(write-line "\n" file)

(setq ptd ptn)
(setq i (1+ i))
)



(close file)

(if (= (distance pti ptn) 0)
(command "_.shell" "start notepad C:\\TMP\\lim_mitoyenne.txt")
)

(prin1)
)

(defun remove-doubles (lst / lst2)
(while (car lst)
(setq lst2   (cons (car lst) lst2)
lst (vl-remove (car lst) lst)
)
)
(reverse lst2)
)

(defun sublst (lst start leng / rslt)
(if (not (<= 1 leng (- (length lst) start)))
(setq leng (- (length lst) (1- start)))
)
(repeat leng
(setq rslt	(cons (nth (1- start) lst) rslt)
start	(1+ start)
)
)
(reverse rslt)
)

le cond qui permet la sélection de fin de chaque tronçon correspond à la partie que je souhaiterais simplifier car elle me semble trop longue et pas adéquat.

Si vous avez des idées sinon c'est pas grave.

Merci encore de votre aide.

John

pierrevigneux · le 16 octobre 2011

Bonsoir Vtkp!

J'ai suivi de loin l'évolution de ton lisp, pourrais-tu me montrer un exemple, car cela m'intéresse?

Merci!

chris_mtp · le 16 octobre 2011

Teste le au moins tout y est dedans

didier · le 16 octobre 2011

Coucou

voici ce que je te propose

j'ai travaillé un peu à l'aveugle

car je n'ai pas réussi à faire fonctionner ton programme.

ma façon de fonctionner :

une polyligne existante

tu lances le programme,

il te propose le choix des segments

je me suis basé arbitrairement comme choix initial au Nord

tu cliques sur les segments concernés

ils se surlignent en rouge

quand tu as terminé cette orientation

tu fais un clic droit, tu passes à l'Est

et ainsi de suite..

les couleurs sont arbitraires et peuvent être changées

sélectionner des orientations supplémentaires n'est pas un souci, c'est une boucle

ce que je ne sais pas encore c'est la forme de la liste attendue

tu donnes ça en exemple :

("Nord" (((150.0 150.0) 0.0 (135.0 145.0)) ((135.0 145.0) 0.0 (125.0 158.0))))

mais c'est mal formaté, tu peux en dire plus ?

je te mets un lien vers une capture d'écran,

tu regardes et me tiens au courant s'il te plaît.

VIDEO sur dlfree

amicalement

didier · le 16 octobre 2011

coucou

je vais encore insister mais

ce que tu dis dans la réponse n°11

n'est pas très explicatif.

à quoi ça peut bien servir d'avoir (sous forme de liste en plus)

ces renseignements?

est-ce pour injecter dans un programme externe ?

sinon je ne vois pas ce qu'on peut en faire

mais ce n'est que de la curiosité.

amicalement

VtKp · le 17 octobre 2011

Bonjour Didier,

Merci pour ta réponse, j'ai testé mon lisp sous acad2004, 2008 et 2010. Ca marche très bien

Ouvre un nouveau dessin dans Autocad, fais glisser le lisp et lance la commande mitoy

et tout se fera normalement si tout va bien.

La seule partie de mon code qu'il faudrait je pense modifier correspond à la partie du cond qui permet la sélection de fin de chaque tronçon. Au final, ce sont des coordonnées que je veux comme le fait mon lisp.

Le but c'est de comparer des listing de coordonnées sous un autre programme après, voilà tout

Merci encore de votre aide.

John

didier · le 17 octobre 2011

Coucou

c'est gentil à toi de m'expliquer comment lancer un lisp :huh:

il est sans doute un peu trop "personnel" pour fonctionner partout

est-ce que tu as regardé ma vidéo?

tu n'en parles pas, je ne me vexe pas pour autant

mais j'ai "travaillé" quelque peu

amicalement

didier · le 17 octobre 2011

coucou

j'ai regardé d'un peu plus près :unsure:

c'est le nom de fichier qui pose souci

pour être "transportable",

il faut utiliser quelque chose de plus générique.

c'est pas grand-chose, mais ça plante si le chemin n'existe pas

on verra plus tard les fonctions pour écrire dans des fichiers temporaires.

pour l'instant il faut se mettre d'accord sur le mode de sélection des segments

et la mise en forme de la liste des points obtenus.

amicalement

didier · le 17 octobre 2011

coucou

je viens de m'apercevoir d'autre chose

qui est demandeur ?

deux pseudos se confondent dans les questions.

chris_mtp est l'auteur du premier message

puis vient : VtKp qui dit :

voici le lisp qui correspond à ce que je veux faire

amicalement

chris_mtp · le 17 octobre 2011

Bonjour Didier

Pour répondre a tes questions,

Oui j'ai vu ta vidéo, pas mal mais le mode de sélection ne convient pas imagine une parcelle avec 60 segments pour un tronçon, selectionner les 60 segments les uns après les autres serait une source d'erreur et fastidieux D'ou Je pense la simplicite de selectionner Que la fin de chaque troncon

Chris-mtp et Vtkp correspond a la meme personne, j'utilise 2 pseudo car J'ai DES soucis pour me connecter a partir de plusieurs non pas en meme temps Mais a partir de mon bureau ou chez moi

Quant au format des donnees, il faut exporter les Coordonnees comme mon lisp example

Je pense Que la function grtext ou grread peut simplifier Le mode de selection Mais la ca depasse mes connaissances

J'ai modifie Le chemin d'export des donnees, ca devrait marcher maintenant sans problem.

Merci pour ton aide, en Esperant t'avoir eclaire

John

didier · le 17 octobre 2011

coucou

merci de ta réponse

le coup des deux pseudos est déroutant

s'ils étaient similaires au moins on comprendrait.

du style chris_mtp01 et chris_mtp02 ...

je vais donc changer mon fusil d'épaule pour tes sommets

je suis désolé que cela ne te convienne pas, j'y croyais bien.

ta demande est vraiment particulière.

en revanche, je manque de temps, il faudra attendre le week-end.

amicalement

VtKp · le 17 octobre 2011

Pas de problème Didier

Merci

bonuscad · le 20 octobre 2011

Juste une suggestion vite fait pour déterminer automatiquement les points cardinaux d'une parcelle, sans les désigner, en s'appuyant sur la BoundingBox d'une LWPOLYLINE.

((lambda ( / js pt_lst ename ll ur north_east south_west south_east north_west)
(defun more_near (pt lst / lst_d)
	(setq lst_d (mapcar '(lambda (x) (distance x pt)) lst))
	(nth (- (length lst_d) (length (member (apply 'min lst_d) lst_d))) lst)
)
(while (not (setq js (ssget "_+.:E:S" '((0 . "LWPOLYLINE"))))))
(setq pt_lst (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget (ssname js 0)))))
(setq ename (vlax-ename->vla-object (ssname js 0)))
(vla-GetBoundingBox ename 'll 'ur)
(setq
	ll (safearray-value ll)
	ur (safearray-value ur)
)
(setq north_east (more_near ur pt_lst))
(setq south_west (more_near ll pt_lst))
(setq south_east (more_near (list (car ur) (cadr ll) 0.0) pt_lst))
(setq north_west (more_near (list (car ll) (cadr ur) 0.0) pt_lst))
(command "_.line" "_none" south_west "_none" north_east "")
(command "_.line" "_none" south_east "_none" north_west "")
))

les instructions _.line en fin de code sont juste là pour te montrer les points déterminés par la routine

Connexion

Orientation d'une parcelle

Messages recommandés

chris_mtp

vincentp010

VtKp

VtKp

Tramber

VtKp

Tramber

VtKp

didier

bonuscad

VtKp

didier

VtKp

pierrevigneux

chris_mtp

didier

didier

VtKp

didier

didier

didier

chris_mtp

didier

VtKp

bonuscad

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante