entsel hachures

[tyrese69_]

Bonsoir,

 

La der de la semaine !

 

Comment modifier cette ligne pour pouvoir sélectioner plusieures polyligne?

 

(command "_-hatch" "s" (setq p1(car(entsel "\nSélectionner une polyligne ! "))) "" "")

 

Daniel OLIVES

[(gile)]

Salut,

 

(prompt "\nSélectionner des polylignes ! ")
(if (setq ss (ssget '((0 . "LWPOLYLINE") (-4 . "&") (70 . 1))))
(command "_-hatch" "_solid" ss "") 
)

 

((0 . "LWPOLYLINE") (-4 . "&") (70 . 1)) est un filtre de sélection pour ne sélectionner que des polylignes fermées.

 

PS : il est préférable de mettre aussi les options de commande en "international" : _s ou _solid plutôt que s.

J'ai rajouté un test (if ...)) pour ne lancer le (command ...) que si le jeu de sélection existe.

 

 

[Edité le 8/9/2006 par (gile)]

[tyrese69_]

 

Bonjour,

Voici le résultat !

 

(Je suis électricien et ) j'ai besoin de calpiner des luminaires

dans un contour correspondant à un local, équipé d'un

plafond 600x600.

Ce petit lisp est une première approche, il reste des cas

complexes à traiter selon les projets.

J'ai mis ce bout de code dans AutoCAD.lsp

 
; Hachures intelligentes
; pas de 600 x 600 mm avec motif  centré 
;
(defun c:hspe(/ ccourante ss)
; hachures "solid"  NET 0.192 soit 600x600 mm 
                     ; pour échelle 1 U = 1 m, angle 0° puis Cr
(command "_-hatch" "p" "NET" "0.193" "0" "")
 ; Créer des hachures Associatives? [Oui/Non] 	Non puis Cr Cr
(command "_-hatch" "A" "A" "N" "" "")
 ; Créer des hachures séparées? [Oui/Non] 	Non puis Cr Cr
(command "_-hatch" "A" "H" "N" "" "")
; Origine soit: O, "utilise par Défaut l'étendue des contour" soit: D , 
; "Centre" soit: C, stocker en tant qu'origine par défaut ? O/N soit: N puis Cr
(command "_-hatch" "o" "d" "c" "o" "")
(princ "hachure")
; puis sélection du contour !
(setq ccourante (getvar "CLAYER"))
(command "_-layer" "e" "ZZ_const" "")
  	(prompt "\nSélectionner des polylignes ! ")
(if (setq ss (ssget '((0 . "LWPOLYLINE") (-4 . "&") (70 . 1))))
	(command "_-hatch" "_s" (ssadd (entlast) ss) "" "") 
)
(command "_-layer" "e" ccourante "")
)

[zebulon_]

Ami électricien bonjour,

 

à la place de

; hachures "solid" NET 0.192 soit 600x600 mm

; pour échelle 1 U = 1 m, angle 0° puis Cr

(command "_-hatch" "p" "NET" "0.193" "0" "")

 

je préfère utiliser les antiques hachures "définies par l'utilisateur" en prenant une distance de 0.60 et en cochant l'option "double".

 

du genre...

 
(command "-fhach" "P" "_u" "0" "0.60" "o" "A" "A" "o" "" "S" e "" "")

 

Sinon, j'ai fait quelque chose de similaire pour le même usage.

 

le fichier Fxplaf.dcl

 

 
dcl_settings : default_dcl_settings { audit_level = 0 ;}

Fxplaf : dialog {
        label = "Faux Plafond";
        initial_focus = "fx_choix";
        : row {
          : column {
            : boxed_radio_column {
              label = "Type : ";
              key = "fx_typ";
              : radio_button {
                label = "Gyptone";
                key = "fx_typ1";
              }
              : radio_button {
                label = "Dune";
                key = "fx_typ2";
              }
            }
            : boxed_column {
              fixed_height = true;
              label = "Contour";
              : button {
                label = "Choix contour <";
                key = "fx_choix";
              }
              : button {
                label = "Créer avec bpoly <";
                key = "fx_bpoly";
              }
              : button {
                label = "Créer avec points <";
                key = "fx_poly";
              }
            }
          }
          : column {
            : boxed_column {
              label = "Origine SCU";
              : button {
                label = "Automatique <";
                key = "fx_auto";
              }
              : button {
                label = "Angle dalle <";
                key = "fx_angle";
              }
              : button {
                label = "Centre dalle <";
                key = "fx_centre";
              }
              : text {
                key = "fx_methode";
              }
              : text {
                key = "fx_xscg";
              }
              : text {
                key = "fx_yscg";
              }
            }
          }
        }
        spacer_1;
        ok_cancel;
}

 

 

Le fichier Fxplaf.lsp

 

;;;
;;; créer un calque
(defun calque (NewLayer ColLayer TlLayer)
 (if (not (tblsearch "LTYPE" TlLayer))
   (command "typeligne" "CH" TlLayer "acadiso" "")
 )
 (if (not (tblsearch "LAYER" NewLayer))
     (command "_layer" "_M" NewLayer "_CO" ColLayer "" "_LT" TlLayer "" "")
     (command "_LAYER" "L" NewLayer "AC" NewLayer "_S" NewLayer "")
 )
)


;;;
;;; lancer une commande autocad

(defun mycmd (LCMD / CMD ETL LELEM RES OLDCMDECHO)
 (setq ETL (entlast))
 (setq OLDCMDECHO (getvar "CMDECHO"))
 (setvar "CMDECHO" 1)
 (foreach CMD LCMD
   (command CMD)
 )
 (while (not (zerop (getvar "cmdactive")))
   (command pause)
 )
 (setvar "CMDECHO" OLDCMDECHO)
 (setq LELEM nil)
 (if (not ETL) 
   (setq ETL (entnext))
   (setq ETL (entnext ETL))
 )
 (while ETL
   (setq LELEM (cons ETL LELEM))
   (setq ETL (entnext ETL))
 )
 (setq RES LELEM)
)



(defun text_fx_methode (fx_methode)
 (cond
   ((= FX_METHODE 0) "Méthode : Non définie")
   ((= FX_METHODE 1) "Méthode : Automatique")
   ((= FX_METHODE 2) "Méthode : Angle")
   ((= FX_METHODE 3) "Méthode : Centre")
 )
)


(defun test_poly_fermee (e / a TYPent TYPlw RES)
 (if e
   (progn
     (setq a (entget e))
     (setq TYPent (cdr (assoc 0 a)))
     (redraw e 3)
     (princ)
     (if (= TYPent "LWPOLYLINE")
       (progn
         (setq TYPlw (cdr (assoc 70 a)))
         (if (= TYPlw 0)
           (progn
             (alert "La polyligne n'est pas fermée !\nElle le sera")
             (command "_pedit" e "_c" "")
             (redraw e 3)
             (princ)
           )
         )
       )
       (progn     ; sinon
         (alert "Ce n'est pas une polyligne !")
         (redraw e 4)
         (princ)
         (setq e nil)
       )
     )
   )
 )
 (setq RES e)
)


(defun do_accept_fxplaf ()
 (if e
   (done_dialog 2)
   (alert "Aucune polyligne sélectionnée !!!")
 )
)

(defun do_fx_auto ()
 (if E
   (progn
     (setq A (entget E))
     (setq LL (length A))
     (setq LSOM nil)
     (repeat LL
       (setq ELEM (car A))
       (setq A (cdr A))
       (if (= (car ELEM) 10)
         (setq LSOM (append LSOM (list (trans (cdr ELEM) 0 1))))
       )
     )
     (setq XMIN (car (car LSOM)))
     (setq YMIN (cadr (car LSOM)))
     (setq XMAX XMIN)
     (setq YMAX YMIN)
     (foreach SOM LSOM
       (if (< (car SOM) XMIN)
          (setq XMIN (car SOM))
       )
       (if (> (car SOM) XMAX)
          (setq XMAX (car SOM))
       )
       (if (< (cadr SOM) YMIN)
          (setq YMIN (cadr SOM))
       )
       (if (> (cadr SOM) YMAX)
          (setq YMAX (cadr SOM))
       )
     )
     (setq DELTAX (- XMAX XMIN))
     (setq NBPAS (fix (/ DELTAX 0.60)))
     (setq RABX (/ (- DELTAX (* NBPAS 0.60)) 2))
     (if (and (not (zerop RABX)) (< RABX 0.10))
       (setq RABX (/ (- DELTAX (* (- NBPAS 1) 0.60)) 2))      
     )
     (setq DELTAY (- YMAX YMIN))
     (setq NBPAS (fix (/ DELTAY 0.60)))
     (setq RABY (/ (- DELTAY (* NBPAS 0.60)) 2))
     (if (and (not (zerop RABY)) (< RABY 0.10))
       (setq RABY (/ (- DELTAY (* (- NBPAS 1) 0.60)) 2))      
     )
     (setq OSCU (list (+ XMIN RABX) (+ YMIN RABY)))
     (setq FX_METHODE 1)
     (setq FX_XSCG (strcat "Xscg = " (rtos (car (trans OSCU 1 0)) 2 3)))
     (setq FX_YSCG (strcat "Yscg = " (rtos (cadr (trans OSCU 1 0)) 2 3)))
     (set_tile "fx_methode" (text_fx_methode FX_METHODE))
     (set_tile "fx_xscg" FX_XSCG)
     (set_tile "fx_yscg" FX_YSCG)
   )
 )
)

(defun main_fxplaf ()
 (setq e nil)

 (if (not FX_TYP) (setq FX_TYP "fx_typ1"))

 (setq FX_METHODE 0)
 (setq FX_XSCG "Xscg = ")
 (setq FX_YSCG "Yscg = ")

 (setq OSCU '(0 0))

 ;ouverture de la boîte de dialogue
 (setq What_next 5)
 (setq dcl_id (load_dialog "fxplaf.dcl"))
 (While (> What_next 2)

   (if (not (new_dialog "Fxplaf" dcl_id)) (exit))
   (set_tile "fx_typ" FX_TYP)
   (set_tile "fx_methode" (text_fx_methode FX_METHODE))
   (set_tile "fx_xscg" FX_XSCG)
   (set_tile "fx_yscg" FX_YSCG)
   
   (if e
     (mode_tile "fx_auto" 0)
     (mode_tile "fx_auto" 1)
   )

   (action_tile "fx_typ" "(setq FX_TYP $value)")

   (action_tile "fx_auto" "(do_fx_auto)")
   (action_tile "fx_poly" "(done_dialog 7)")
   (action_tile "fx_centre" "(done_dialog 6)")
   (action_tile "fx_angle" "(done_dialog 5)")

   (action_tile "fx_bpoly" "(done_dialog 4)")
   (action_tile "fx_choix" "(done_dialog 3)")
   (action_tile "accept" "(do_accept_fxplaf)")
   (action_tile "cancel" "(done_dialog 0)")
   (setq What_next (start_dialog))


   (if (= What_next 5)   ;;; fx_angle
     (progn
        (setq PTEMP (getpoint "\nAngle de dalle : "))
        (if PTEMP
          (progn
            (setq OSCU PTEMP)
            (setq FX_METHODE 2)
            (setq FX_XSCG (strcat "Xscg = " (rtos (car (trans OSCU 1 0)) 2 3)))
            (setq FX_YSCG (strcat "Yscg = " (rtos (cadr (trans OSCU 1 0)) 2 3)))
          )
        )
     )
   )

   (if (= What_next 6)   ;;; fx_centre
     (progn
       (setq PTEMP (getpoint "\nCentre de dalle : "))
       (if PTEMP
         (progn
           (setq OSCU (list (+ (car PTEMP) 0.30) (+ (cadr PTEMP) 0.30)))
           (setq FX_METHODE 3)
           (setq FX_XSCG (strcat "Xscg = " (rtos (car (trans OSCU 1 0)) 2 3)))
           (setq FX_YSCG (strcat "Yscg = " (rtos (cadr (trans OSCU 1 0)) 2 3)))
         )
       )
     )
   )

   (if (= What_next 7) ;;; fx_poly
     (progn
       (if e (redraw e 4))
       (calque "0" "7" "continuous")
       (setq LELEM (mycmd '("_.pline")))
       (if LELEM
         (progn
           (setq e (car LELEM))
           (test_poly_fermee e)
           (if (or (= FX_METHODE 0) (= FX_METHODE 1))
             (do_fx_auto)
           )
         )
       )
     )
   )


   (if (= What_next 3) ;;; fx_choix
     (progn
       (setq eTEMP (car (entsel "\Sélectionner un polyligne fermée : ")))
       (if (test_poly_fermee eTEMP)
         (progn
           (if e
             (progn
               (redraw e 4)
               (princ)
             )
           )
           (setq e eTEMP)
           (if (or (= FX_METHODE 0) (= FX_METHODE 1))
             (do_fx_auto)
           )
         )
       )
     )
   )

   (if (= What_next 4)  ;;; bpoly
     (progn
       (setq PTemp (getpoint "\nPoint intérieur : "))
       (calque "0" "7" "continuous")
       (setq eTEMP (bpoly PTemp))
       (if (not eTEMP)
         (alert "Point hors du contours !")
         (progn
           (if e (redraw e 4))
           (setq e eTEMP)
           (redraw e 3)
           (princ)
           (if (or (= FX_METHODE 0) (= FX_METHODE 1))
             (do_fx_auto)
           )
         )
       )
     )
   )
 )  ; fin du while

 (unload_dialog dcl_id)

 (if (= What_next 2)
   (progn
     (setq OLDOS (getvar "OSMODE"))
     (setvar "OSMODE" 0)
     (command "_ucs" "_o" OSCU)
     (if (= FX_TYP "fx_typ1")
       (calque "Fau$gyptone_vu" "10" "continuous")
       (calque "Fau$dune_vu" "70" "continuous")
     )  
     (command "-fhach" "P" "_u" "0" "0.60" "o" "A" "A" "o" "" "S" e "" "")

     (if (= FX_TYP "fx_typ1")
       (calque "Fau$zonegyptone_ha" "9" "continuous")
       (calque "Fau$zonedune_ha" "9" "continuous")
     )  
     (command "_.change" e "" "_properties" "_layer" (getvar "CLAYER") "")
     (command "_ucs" "_o" (trans PTORI 0 1))
     (setvar "OSMODE" OLDOS)
   )  ; fin du alors
 )

 (if e
   (redraw e 4)  ; enlever la surbrillance
 )

)

(defun C:fxplaf ()
 (setq OLD_ATT (getvar "attdia"))
 (setvar "attdia" 0)
 (setq OLD_CMD (getvar "cmdecho"))
 (setvar "cmdecho" 0)
 (setq CLAY (getvar "CLAYER"))
 (setvar "MEASUREMENT" 1)
 (setq PTORI (trans '(0 0) 1 0))

 (main_fxplaf)

 (setvar "CLAYER" CLAY)
 (setvar "cmdecho" OLD_CMD)
 (setvar "attdia" OLD_ATT)
 (princ)
) 

 

 

si ça peut t'inspirer...

 

Amicalement

 

Zebulon_

[tyrese69_]

Bonsoir,

 

Merci Zebulon_ pour ton aide et pour ce lisp trés fourni !

 

Je vais regarder celà de plus prés.

Je me permettrait de te demander de l'aide sur les différentes options de sélection de ta boite

de dialogue. Car ce que je cherche à obtenir c'est un décalage d'offset de la trame de 0.3,0.3 afin de pouvoir

dans certains cas centrer les hachures sur le contour d'une dalle et non pas par son centre.

 

J'espère avoir été assez clair dans ma demande. @+

 

Dans la finalité de mon approche, les réseaux de luminaires s'auto adapteront au contour selon

un module de base prédéfini.

 

Daniel OLIVES

[zebulon_]

Bonjour,

 

Sur la boîte de dialogue, il y a trois zones.

 

La première :

- Type (de faux plafond) : en fonction du choix (gyptone ou dune), le lisp mettra la hachure et le contour sur un calque spécifique

 

La deuxième :

- Contour :

-> choix contour : permet de sélectionner une polyligne existante pour y coller la hachure de faux plafond

-> Créer avec Bpoly : permet de cliquer une point dans une zone fermée pour créer un contour grâce à la commande _bpoly (ou fpoly)

-> Créer avec points : permet de lancer la commande _pline pour définir un contour point par point

 

La troisième :

- Origine SCU

-> Automatique : les dalles de 0.60x0.60 seront centrées par rapport au contour

-> Angle dalle : on peut cliquer un point par lequel passera les hachures de 0.60x0.60

-> Centre dalle : on peut cliquer un point qui sera le centre d'une dalle de 0.60x0.60 et on aura donc un décalage de 0.30x0.30 par rapport à ce point. (Pratique quand on a des couloirs, ou deux couloirs qui se croisent)

 

Voilà...

 

Après, pour placer les luminaires, qui sont des blocs, j'utilise la commande reseau. Puis je place d'autres blocs au droit des portes pour matérialiser les interrupteurs VV et SA et BP.

 

Puis je lance un autre lisp qui met des petits arcs entre les interrupteurs et chaque loupiotte sélectionnée, pour matérialiser le réseau électrique (quel interrupteur avec quel spot etc...)

Mais ça c'est une autre histoire...

 

Amicalement

 

Zebulon_

 

[tyrese69_]

Bonjour,

 

Merci pour ces explications, il faut que je fouille cela !

 

Je suis moins à l'aise avec le lisp qu'avec le VBA mais, rien n'est possible

l'un sans l'autre.

Je me suis donc mis également au lisp / vlisp.

 

Daniel OLIVES