création d\'intersection et reconstitution de contour

doy · le 26 juin 2007

Bonjour à tous,

Je développe toujours mon programme de création des boîtes suivant une trajectoire.

j'ai réussi à sélectionner mes blocs et à les décomposer mais maintenant je bloque.

je me retouve avec mes blocs décomposés et mes limites de corridor,

ces deux éléments étant respectivement dans des calques différents.

je me pose la question de savoir si je dois reselectionner les divers éléments pour les mettre dans un même calque ou si je peux les laisser dans des calques différents,

le but tant à partir de ces entités " blocs" et "polyligne = limites corridor" de créer des boîtes.

ces boîtes doivent être des contours ( polylignes ) fermés que l'on pourra par la suite extraire séparément.

SEULEMENT je ne sais pas comment écrire tous ceci en langage lisp !!!!!!!

Par avance un grand merci à tous ceux qui m'ont aidé.

à + doy.

je joins le programme que j'ai déjà écris.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; ; CORRIDOR.LSP

;;; ;

;;; ; Création des boîtes le long de la Trajectoire de vol de l'hélicoptère.

;;; ; Ces boîtes correspondent aux limites du Perimètre du Corridor.

;;; ; Ces limites sont composées de boîtes juxtaposées toujours perpendiculaires à la trajectoire,

;;; ; dont les paramètres de longueur des boîtes et de largeur du corridor sont réglables,

;;; ; par une simple entrée au clavier dans la ligne de commande d'AutoCAD.

;;; ; Après chargement, l'exécution de la fonction "boite" est obtenu par :

;;; ; -> commande : (boite)

;;; ; selection polyligne, coordonnées des sommet & calcul longueur

;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Boite DCL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun c:corridor ()

(setq dcl_id (load_dialog "Boite de dialogue corridor.dcl"))

(if

(not (new_dialog "boite_de_dialogue_corridor" dcl_id))

(exit)

)

;si il n'y a pas de boite de dialogue alors on lance le programme sans elle

;image en .sld

(setq x1 (dimx_tile "img1") ;coordonnées x du coin inférieur droit de l'image nom de l'image que l'on donne dans la boite de dialogue

y1 (dimy_tile "img1")) ;coordonnées y du coin inférieur droit de l'image

(start_image "img1") ;Début du traitement d'un controle image

(fill_image 0 0 (dimx_tile "img1") (dimy_tile "img1") 0)

(slide_image 0 0 x1 y1 "corridor_image") ;centrage de la diapo

(end_image)

(action_tile "inverse0" "(setq inverse \"0\")"); affecte donc l'action inverse = 2 à évaluer lorsque nous sélectionnons la variable inverse2 .

(action_tile "inverse1" "(setq inverse \"1\")"); affecte donc l'action inverse = 3 à évaluer lorsque nous sélectionnons la variable inverse3 .

;j'établit la liste des blocs qui seront insérés dans les listes déroulantes

(setq liste_bloc '("b600" "b600 1" "li3" "lib"))

;; initialiser les variables

;;;(if (not largeur_corridor) (setq largeur_corridor "1500")).

;;;;;;(if (not cas) (setq cas "cas0"))

;;;(if (not position_liste) (setq position_liste "0")).

;;;

;;;;; initialiser la boite de dialogue.

;;;(set_tile "larg_corridor" largeur_corridor).

;;;(set_tile "cas" cas).

;;;(set_tile "bloc" position_liste).

;largeur du corridor.

(action_tile "larg_corridor" "(setq largeur_corridor $value)")

; " action_tile " affecte l'action " larg_corridor " à évaluer lorsque nous sélectionnons le composant " largeur_corridor ".

;largeur des boites.

(action_tile "cas0" "(setq cas \"0\")"); affecte donc l'action cas = 0 à évaluer lorsque nous sélectionnons la variable cas0 .

(action_tile "cas1" "(setq cas \"1\")"); affecte donc l'action cas = 1 à évaluer lorsque nous sélectionnons la variable cas1 .

(start_list "bloc"); lance la création d'une liste " bloc " dans la zone de liste.

(mapcar 'add_list liste_bloc); mapcar renvoie la liste " liste_bloc " en résultat de l'execution de la fonction " add_list ".

; la fonction " add_list "ajoute et modifie dans la liste de la boîte de dialogue les éléments de " liste_bloc ".

(end_list); met fin au traitement de la liste de la boîte de dialogue courante.

(action_tile "bloc" "(setq position_liste $value)"); affecte l'action " cas " à évaluer lorsque nous sélectionnons le composant " cas ".

(action_tile "accept" "(done_dialog 1)") ;1 pour OK ;

(action_tile "cancel" "(done_dialog 0)") ;o pour Cancel ;

(setq what_next (start_dialog)); démarre la boîte de dialogue.

(unload_dialog dcl_id)

(if

(= what_next 1) ;; ok

(progn

(setq bloc_largeur (nth (atoi position_liste) liste_bloc)); " atoi " convertit la chaîne de caractère " position_liste " en un nombre entier.

;;;(alert (strcat "Largeur corridor : " largeur_corridor))

;;;(alert (strcat "Cas : " (itoa cas)))

;;;(alert (strcat "Largeur bloc : " bloc_largeur))

)

(boite) ; on lance le programme boite

(princ)

)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun boite ()

(setvar "attdia" 0) ;Détermine si la commande INSERT utilise une boîte de dialogue

;pour la saisie de la valeur d'attribut. Voir la section "INSERT, ligne de commande",.

;Variables système

;0 Affiche les messages sur la ligne de commande

;1 Utilise une boîte de dialogue

(setvar "osmode" 0) ;gère l'accrochage aux objets ici mode 0 donc désactivé.

(setvar "cmdecho" 0) ;gère le mode d'écho des commandes dans l'environnement d'AutoCAD, ici mode 0 donc désactivé.

(setq largeur_corridor (atoi largeur_corridor)); " atoi " convertit la chaîne de caractère " largeur_corridor " en un nombre entier.

(setq cas (atoi cas))

(setq inverse (atoi inverse))

(command "-calque" "e" "LIMITE" "co" "bleu" "LIMITE" ""); définit les paramètres du calque " LIMITE ".

(command "-calque" "e" "pk" "co" "magenta" "pk" "ch" "pk" ""); définit les paramètres du calque " Pk ".

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;inversion du sens de la trajectoire fonction reverse LWPOLYLINE"

(if

(= inverse 3)

(progn

;;; R_PLINE Fonction d'appel

;;; (defun r_pline (/ ent)

(while (not (setq ent (car (entsel)))))

(if

(or (= (cdr (assoc 0 (entget ent))) "LWPOLYLINE")

(and (= (cdr (assoc 0 (entget ent))) "POLYLINE")

(zerop (logand 240 (cdr (assoc 70 (entget ent)))))

)

(reverse_pline ent)

(prompt "\nEntité non valide")

)

(princ)

;;; )

(defun reverse_pline (ent / e_lst vtx v_lst p_lst l_vtx)

(setq e_lst (entget ent))

(cond

((= (cdr (assoc 0 e_lst)) "POLYLINE")

(setq vtx (entnext ent))

(while (= (cdr (assoc 0 (entget vtx))) "VERTEX")

(setq v_lst (cons (entget vtx) v_lst)

vtx (entnext vtx)

)

((= (cdr (assoc 0 e_lst)) "LWPOLYLINE")

(setq p_lst (vl-remove-if-not

'(lambda (x)

(member (car x) '(10 40 41 42))

)

e_lst

)

e_lst (vl-remove-if

'(lambda (x)

(member x p_lst)

)

e_lst

)

(while p_lst

(setq v_lst (cons

(list (car p_lst) (cadr p_lst) (caddr p_lst) (cadddr p_lst))

v_lst

)

p_lst (member (assoc 10 (cdr p_lst)) (cdr p_lst))

)

(setq l_vtx (last v_lst)

l_vtx (subst (cons 40 (cdr (assoc 41 (car v_lst))))

(assoc 40 l_vtx)

l_vtx

)

l_vtx (subst (cons 41 (cdr (assoc 40 (car v_lst))))

(assoc 41 l_vtx)

l_vtx

)

l_vtx (subst (cons 42 (- (cdr (assoc 42 (car v_lst)))))

(assoc 42 l_vtx)

l_vtx

)

(setq v_lst

(mapcar

'(lambda (x y)

(setq x (subst (cons 40 (cdr (assoc 41 y))) (assoc 40 x) x)

x (subst (cons 41 (cdr (assoc 40 y))) (assoc 41 x) x)

x (subst (cons 42 (- (cdr (assoc 42 y)))) (assoc 42 x) x)

)

v_lst

(cdr v_lst)

)

(if (= (logand 1 (cdr (assoc 70 e_lst))) 1)

(setq v_lst (append (list l_vtx) v_lst))

(setq v_lst (append v_lst (list l_vtx)))

)

(cond

((= (cdr (assoc 0 e_lst)) "POLYLINE")

(mapcar 'entmake

(append (list e_lst) v_lst (list (entget vtx)))

)

(entdel ent)

)

((= (cdr (assoc 0 e_lst)) "LWPOLYLINE")

(setq e_lst (append e_lst (apply 'append v_lst)))

(entmod e_lst)

)

(command "-calque" "ch" "LIMITE" ""); Choix du calque " LIMITE ".

; double décalage à gauche et à droite.

;(attribut du double décalage (ddllpp) (/ Vdist entité1 pt1 pt2 entitépoints anglepl PtGauche PtDroite)

; la largeur du corridor = distance de decalage.

(setq

trajectoire (entget

(car (entsel "Selectionner la ligne ou la polyligne représentant la trajectoire:")); demande de sélectionner l'objet " trajectoire "

; en spécifiant un point.

)

(if

(eq (cdr (assoc 0 trajectoire)) "LINE"); " assoc " recherche l'élément " trajectoire " dans la liste d'association " LINE " ou " entitétrajectoire "

; et renvoie l'entrée correspondante.

;;; determine si l'objet est ligne ou polyligne.

(progn (Setq P1 (cdr (assoc 10 trajectoire)))

(setq P2 (cdr (assoc 11 trajectoire)))

)

(progn (setq entitétrajectoire

(mapcar 'cdr

(vl-remove-if-not '(lambda (x) (= (car x) 10)) trajectoire)

); " mapcar " permet l'application de la fonction " lambda " [ qui elle même définis une fonction sans nom

; ( pour éviter d'encombrer la mémoire ) et lambda retourne la valeur de sa dernière expression " entitétrajectoire "]

; aux éléments successifs de la liste " trajectoire " de " P1 " à " P2 " qu'elle fournies comme arguments à la fonction " lambda ".

)

(progn (progn (setq P1 (car entitétrajectoire))); " car " renvoie le premier élément de la liste " entitétrajectoire ".

(progn (setq P2 (cadr entitétrajectoire))); " cadr " renvoie le deuxième élément de la liste " entitétrajectoire ".

)

(setq anglepl (angle P1 P2)); définis l'angle entre les points P1 et p2.

(setq PtGauche (polar P1 (+ anglepl (/ pi 2)) largeur_corridor)); détermine le coté gauche de décalage par rapport à la trajectoire par le ptGauche.

(setq PtDroite (polar P1 (- anglepl (/ pi 2)) largeur_corridor)); détermine le coté droit de décalage par rapport à la trajectoire par le ptDroite.

;;; commande appelant la fonction " decaler ".

(command "_offset" (/ largeur_corridor 2) P1 PtGauche ""); commande de décalage à gauche de la polyligne par rapport à la polyligne trajectoire.

(command "_.chprop" (entlast) "" "_layer" "LIMITE" "_color" "_blue" ""); définition des paramètres du calque de destination de la polyligne décalée.

(command "_offset" (/ largeur_corridor 2) P1 PtDroite ""); commande de décalage à droite de la polyligne par rapport à la polyligne trajectoire.

(command "_.chprop" (entlast) "" "_layer" "LIMITE" "_color" "_blue" ""); définition des paramètres du calque de destination de la polyligne décalée.

;;; (princ)

; fin de la fonction de double décalage.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; selection des limites.

;;; (setq e (entget (car (entsel)))) ;......................................... obtenir la liste de l'entité

(setq len (length trajectoire)) ;.................................................... longueur de la liste

(setq n 0)

(setq liste nil) ;......................................................... compteur à zero

(repeat len ;.............................................................. repeter pour chaque element de la liste

(setq e1 (car (nth n trajectoire))) ;.............................................. prendre chaque element de la liste et en retirer le code (1 er item)

(if (= e1 10) ;.......................................................... tester le code 10

(progn ;............................................................... si c'est le groupe 10 alors faire

(terpri) ;........................................................... nouvelle ligne

(princ (cdr (nth n trajectoire)))

(setq liste (cons (cdr (nth n trajectoire)) liste))

;........................................................................... ecriture des coordonnées

;(princ (cadr (nth n e)));.................................................. ecrit les valeurs de X

;(princ (caddr (nth n e)));................................................. ecrit les valeurs de Y

;........................................................................... (nth n e) : sort l'element n de la liste e (n=0,1,2,...)

) ;.................................................................... fin de progn

) ;...................................................................... fin de if

(setq n (+ n 1)) ;......................................................... incrementer le compteur

) ;........................................................................ fin repeat

(setq nbsommets (length liste))

(setq long 0)

(repeat (- nbsommets 1)

(setq P1 (car liste))

(setq P2 (cadr liste))

(setq D (distance P1 P2))

(setq long (+ D long))

(setq liste (cdr liste))

)

(prin1 long)

(princ)

(command "-calque" "ch" "pk" "")

(setq point_fin_trajectoire (car (reverse entitétrajectoire)))

;;;(setq point_fin (car liste1))

(cond

((= cas 0) (command "mesurer" pause "b" bloc_largeur "o" 1000 ""))

((= cas 1) (command "mesurer" pause "b" bloc_largeur "o" 5000 ""))

)

(setq

limite1 (entget

(car (entsel "Selectionner la polyligne de la limite du corridor:"))

)

(if

(eq (cdr (assoc 0 entitélimite1)) "LINE")

;;; determine si l'objet est ligne ou polyligne

(progn (Setq P3 (cdr (assoc 10 limite1)))

(setq P4 (cdr (assoc 11 limite1)))

)

(progn (setq entitélimite1

(mapcar 'cdr

(vl-remove-if-not '(lambda (x) (= (car x) 10)) limite1)

)

(progn (progn (setq P3 (car entitélimite1)))

(progn (setq P4 (cadr entitélimite1)))

)

(setq point_fin_limite1 (car (reverse entitélimite1)))

(setq

limite2 (entget

(car (entsel "Selectionner la polyligne de l'autre limite du corridor:"))

)

(if

(eq (cdr (assoc 0 entitélimite2)) "LINE")

;;; determine si l'objet est ligne ou polyligne

(progn (Setq P5 (cdr (assoc 10 limite2)))

(setq P6 (cdr (assoc 11 limite2)))

)

(progn (setq entitélimite2

(mapcar 'cdr

(vl-remove-if-not '(lambda (x) (= (car x) 10)) limite2)

)

(progn (progn (setq P5 (car entitélimite2)))

(progn (setq P6 (cadr entitélimite2)))

)

(setq point_fin_limite2 (car (reverse entitélimite2)))

(setq angle_debut (angle P2 P3))

(setq angle_fin (angle point_fin_trajectoire point_fin_limite1))

(command "ligne" P3 P5 "")

(command "ligne" point_fin_limite2 point_fin_limite1 "")

; (nom de la commande / retour à covadis / b pour bloc / position orthogonale / grandeur numérique de la longueur de la boîte.

(princ)

) ;Fin si OUI

(progn

(command "-calque" "ch" "LIMITE" ""); Choix du calque " LIMITE ".

; double décalage à gauche et à droite.

;(attribut du double décalage (ddllpp) (/ Vdist entité1 pt1 pt2 entitépoints anglepl PtGauche PtDroite)

; la largeur du corridor = distance de decalage.

(setq

trajectoire (entget

(car (entsel "Selectionner la trajectoire:")); demande de sélectionner l'objet " trajectoire "