insertion de bloc au centre du cercle

[Fraid]

Bonjour,

 

Je dois inserer un bloc dans chaque cercle present dans le dessin

 

(defun c:cpo ( / ent p1)

 

(setq ent (ssget "x" (list (cons 0 "circle"))))

(setq p1 (cdr (assoc 10 (entget ent))))

(if ent

(command "_-insert" "pol" p1 "" "" ""))

(princ "\npas de cercle")

(princ)

)

 

sa marche pah :(

 

 

[lecrabe]

 

Hello

 

Ceci marchera mieux !

 

Le Decapode

 

 


;;; Routine pour dessiner un Bloc sur des cercles / points graphiques
;;; Version 2 corrigee pour ne traiter que des cercles ou des points
;;; Commande:  C2B ou P2B
;;;
;;;--------------------------------------------------------------------;
;;; PNT2BLK.LSP -  July 2001 - Original Routine 
;;; Place a block object in the location of selected point objects.
;;;--------------------------------------------------------------------;
;;; Function: PNT2BLK --> C2B / P2B
;;; function to convert point objects to blocks.
;;; block must be defined in the current drawing
;;; blocks including attdefs will not address the attributes
;;; if the block references attdefs with default or constant values, 
;;; these will be populated.
;;;*********************************************************************


(defun c:c2b (/ ss ct len e eb bname pt attreqhold echohold)
;(defun c:p2b (/ ss ct len e eb bname pt attreqhold echohold)

;;;get command echo setting and store it
(setq echohold (getvar "CMDECHO"))

;;;set command echo off
(setvar "CMDECHO" 0)

;;;get attribute request setting and store it
(setq attreqhold (getvar "ATTREQ"))

;;;set attribute request off
(setvar "ATTREQ" 0)

;;;get name of block to insert
(setq bname (getstring "\nBlock name: "))

;;;check that the block is defined in the current drawing
(if (tblsearch "block" bname)
(progn

;;;prompt for point selection
(princ "\nSelect point objects:")

;;; --- if point OR circle objects were selected ---

(if (setq ss (ssget '((0 . "CIRCLE"))))
;(if (setq ss (ssget '((0 . "POINT"))))

(progn

;;;walk through point objects
(setq len (sslength ss))
(setq ct 0)
(while (
;;;for each point
(setq e (ssname ss ct))
(setq ct (+ ct 1))
(setq eb (entget e))
;;;get insert point
(setq pt (cdr (assoc 10 eb)))
;;;insert block
(command "_insert" bname pt "" "" "")
)
)
(princ "\nNo circle objects selected.")
;(princ "\nNo point  objects selected.")
)
)
(princ "\nInvalid, block not defined in drawing.")
)

;;;restore command echo setting to stored value
(setvar "CMDECHO" echohold)

;;;restore attribute request setting to stored value
(setvar "ATTREQ" 0)

(princ)
) 

 

 

 

[Fraid]

Merci le crabe

 

mais je voudrais savoir pourquoi ma routine ne fonctionne pas

etant en phase eternel d'apprentissage :P

 

 

[Tramber]

(defun c:cpo ( / sent ent p1)
 (if(setq compt 0 sent (ssget "x" (list (cons 0 "circle"))))
   (repeat(sslength sent)
     (setq ent(ssname sent compt))
     (setq p1 (cdr (assoc 10 (entget ent))))
     (command "_-insert" "pol" p1 "" "" ""))
   (princ "\npas de cercle")
   )
 (princ)
 ) 

 

Fraid, tu fais des confusions entre jeu de selection et entité à extraire de ce jeu (ssname).

[Fraid]

merci

 

je vais potasser le ssname

 

et tout ce que ma fournis le crabe

 

c'est dommage que mon apprentissage soit sporadique

 

je profite de coup de mou pour m'y mettre

 

je ne sais pas comment je ferai sans vous :D

[Tramber]

J'ai complétement oublié l'incrément du compteur COMPT !

 

Je te laisse gérer ? Il faut faire +1 à la fin de chaque boucle.

 

Fastoche.

[(gile)]

Salut Fraid,

 

Si tu es pressé, tu peux utiliser le code donné par lecrabe, si tu as un peu de temps et de courage, on va essayer de comprendre pourquoi ça ne marche pas.

 

Quand tu fais :

(setq ent (ssget "x" (list (cons 0 "circle"))))

l'expression attribue à la variable ent le résultat de :

(ssget "x" (list (cons 0 "circle")))

à savoir un jeu de sélection (type PICKSET en LISP) ou nil s'il n'y a aucun cercle dans le dessin.

Un jeu de sélection est une sorte de collection qui contient une ou plusieurs entités ou, plus précisément noms d'entités (type ENAME en LISP).

Il faut donc parcourir cette "collection" pour traiter chacune des entités. On utilise pour ça une boucle qu'on peut faire avec la fonction repeat ou while.

 

Petite parenthèse, si le choix des symboles utilisés pour les noms de variables (tant qu'ils sont valides) n'influe aucunement sur l'exécution du code, il est préférable, pour une meilleure lisibilité du code, d'utiliser des symboles qui décrivent tant soit peu leur contenu ; surtout quand ce contenu est largement utilisé.

Par exemple, ent est le plus couramment utilisé pour une variable qui contient une entité (ENAME), pour un jeu de sélection, on retrouvera plus souvent : ss, sset, selset, ou leurs formes francophones js, jsel, jeusel.

Loin de moi l'idée de vouloir imposer quoi que ce soit, mais pour la suite du propos, je voudrais pouvoir utiliser ent pour symboliser une entité, donc je vais appeler, dans les exemples suivants, le jeu de sélection ss.

 

Revenons à nos moutons, . On affecte donc à la variable ss un jeu de sélection qui contient tous les cercles de la base de donnée du dessin :

(setq ent (ssget "x" (list (cons 0 "circle"))))

Comme tu l'as fait, il est prudent de vérifier si le jeu de sélection existe, autrement dit s'il n'est pas nil (= la base de données ne contient aucun cercle). Et en conséquence, on va parcourir ce jeu de collection ou retourner un message.

Quelle que soit la méthode utilisée (while ou repeat), nous allons avoir besoin d'un compteur pour pointer successivement sur chacune des entités contenues dans ss.

Ce compteur sera utilisé avec la fonction ssname pour retourner l'entité à l'indice spécifié. Il faudra donc incrémenter ce compteur à chaque itération.

 

Exemple avec while :

(if ss
 (progn
   (setq n 0)
   (while (setq ent (ssname ss n))               ; tant qu'il existe une entité à l'indince n dans ss
     (setq p1 (cdr (assoc 10 (entget ent)))      ; affecter à p1 les coordonnées du centre
           n  (1+ n)                             ; incrémenter n
     )
     (command "_.insert" "pol" "_non" p1 "" "" "") ; insérer le bloc
   )
 )
 (princ "\npas de cercle")
)

 

avec repeat, on peut initialise le compteur avec le nombre d'entités contenues dans le jeu de sélection en utilisant sslength et décrémenter le compteur, le jeu de sélection est alors parcouru à partir du desnier élément. Attention, il faut décrémenter avant d'utiliser n : l'indice du premier élément est toujours 0.

(if ss
 (progn
   (setq n (sslength ss))                        ; initialiser n avec le nombre d'entités contenues dans ss
   (repeat n                                     ; répéter n fois
     (setq n   (1- n)                            ; décrémenter n
           ent (ssname ss n)                     ; affecter à ent l'entité à l'indince n dans ss
           p1  (cdr (assoc 10 (entget ent)))     ; affecter à p1 les coordonnées du centre
     )
     (command "_.insert" "pol" "_non" p1 "" "" "") ; insérer le bloc
   )
 )
 (princ "\npas de cercle")
)

 

Avec la pratique, on pourra imbriquer les expressions ce qui donne un code plus concis et moins de variables déclarées.

(if (setq ss (ssget "_X" '((0 . "CIRCLE"))))
 (repeat (setq n (sslength ss))
   (setq p1 (cdr (assoc 10 (entget (ssname ss (setq n (1- n)))))))
   (command "_.insert" "pol" "_non" p1 "" "" "")
 )
 (princ "\npas de cercle")
)

 

PS : j'ai ajouter "_non" avant p1 dans l'expression (command ...) pour éviter des accrobj intempestifs.

 

[lecrabe]

 

Hello Gilles & Tramber

 

Merci pour les explications ! :)

 

Comme Fraid, il faudrait que je mette "serieusement" au Lisp ... :P

 

Bon WE a tous, Le Decapode

 

[Fraid]

terrible le _non

 

en plus c'est utilisable n'importe quand

 

Genial

 

mais je ne vois pas pourquoi l'accrochage serai "embettant" alors que l'on utilise des coordonnées precises ?

 

et merci Gile pour ce cours ;)

[(gile)]

mais je ne vois pas pourquoi l'accrochage serai "embettant" alors que l'on utilise des coordonnées precises ?

 

Quand on utilise command et qu'il y a des accrochages au objets actifs, ils prennent le dessus sur les coordonnées spécifiées.

désactiver tous les accrochage (osmode = 0) ou utiliser "_non" (ou "auc") garanti que ce seront les coordonnées spécifiées qui seront prises en compte.

[Tramber]

_non est le raccourci de _none :cool:

puisque auc est le raccourci de aucun