reprendre les derniers objets copiés

[x_all]

Bonjour

 

j'ai un petit ensemble de fonction qui me permettent de recopier des objets verticalement ou horizontalement. Par exemple quand je place mes niveaux alignés tous les 20m, si je sélectionne une trémie au rdc la recopier 20m au dessus me permet de voir ou elle tombe au R+1.

En plus de copier les objets, la fonction fait un PAN pour placer la vue 20m au dessus comme ça je voie tout de suite ou j'en suis.

 

J'aimerai améliorer ma commande pour avoir la possibilité de sélectionner automatiquement les objets que je vien de copier au R+1 pour les placer au R+2 sans avoir à les re sélectionner.

 

Je pose ici une des fonctions que je voudrais modifier car je sèche un peu..

(USERR1 est une variable globale définie avec une autre fonction)

 

(defun c:2 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (if (= 0.0 tmp)
(princ
 	"\nPour définir un décalage des déplacements taper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list 0 (* -1 (getvar "USERR1"))))
 	(setq sel (ssget))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

[Patrick_35]

Salut

 

Tu fais un (setq der (entlast)) avant la commande copier afin de connaitre le dernier objet.

Tu fais tes commandes et ensuite, les entnext depuis la variable mémorisé (der) indiquent les objets ajoutés

 

@+

[x_all]

cool je vais tester..

 

Hou lala c'est un peu obscur, mais je vais essayé cette idée..

du coup je doit faire un (while , pour construire le jeu de sélection, mais je l' arrête comment ce while ?

[vincentp010]

Jusqu’à ce qu'il soit à nil

 

(setq ss (ssadd))
(setq der (entlast))

(setq ent (entnext der))
(while (not (null ent))
   (ssadd ent ss)
   (setq der ent)
   (setq ent (entnext der))
)

[GEGEMATIC]

Salut,

Tu fais un (setq der (entlast)) avant la commande copier afin de connaitre le dernier objet.

Tu fais tes commandes et ensuite, les entnext depuis la variable mémorisé (der) indiquent les objets ajoutés

J'ajouterai que dans certains cas, il faut faire des tests supplémentaires:

dans le cas de blocs avec attributs, (entlast) ne retourne pas la vraie dernière entité:

Ci joint une petite routine pour être vraiment sur de son coup :

;*************************************************************************
;;§/SELECTIONS/retourne le vrai dernier element, dans le cas ou entlast retourne un element complexe/none
;;rajouté un test sur SEQEND : en effet, si 3dpolyligne = entlast, le entnext du sequend retourne au début
;; du dessin !

(defun pw_real_entlast ( / ent tmp ok eg tp)
(setq ok T)
(if (setq ent (entlast))
 (while (and (setq tmp (entnext ent)) ok)
  (setq eg (entget ent))
  (setq tp (cdr (assoc 0 eg)))
  (if (= "SEQEND" tp)
    (setq ok nil)
  )
  (setq ent tmp)
 )
)
ent
)

 

pour être complet, je rajoute mes selections par pointage selbefore et selafter sans lesquelles je suis perdu !

;;*************************************************************************
;;§/SELECTIONS/ crée un jeu de selection des entités suivant un element/none
(defun c:selafter ( / sel dep )
  (setq dep (car (entsel "\nEntité limite")))
  (setq sel (pw_selafter dep))
(sssetfirst sel sel )
)
;;*************************************************************************
;;§/SELECTIONS/ selectionne les entités anterieures à l'entité dep/none
;
(defun c:selbefore ( / dep sel ent )
(setq dep (car (entsel "\nEntité limite")))
  (setq sel (pw_selbefore dep))
(sssetfirst sel sel )
)
;;*************************************************************************
;;§/SELECTIONS/ selectionne les entités anterieur à l'entité dep/dep
;; ne marche pas !
(defun pw_selbefore ( dep / ent sel etyp )

(setq ent (entnext))
(setq sel (ssadd ent))
(while (and (/= nil (setq ent (entnext ent)))(not (eq ent dep)))
 (setq etyp (cdr (assoc 0  (entget ent))))
 (if (not (member etyp '("ATTRIB" "VERTEX" "SEQEND")))
  (setq sel (ssadd ent sel))
 )

  
)
sel
)
;;*************************************************************************
;;§/SELECTIONS/  crée un jeu de selection des entités suivant un element/ent
;;fonction ralentie par la 2006, qui n'axepte pas les sequend
;;donc necessité de faire un entget pour chaque entité
;;
(defun pw_selafter (ent / sel etyp)
 ;;si le dessin etait vierge, ent = nil
 (if ent
   (setq sel (ssadd))
   (if	(setq ent (entnext))
     (progn (setq sel (ssadd))
     (setq sel (ssadd ent sel))
     )
   )
 )
 (if ent
   (progn
     (while (setq ent (entnext ent))
(setq etyp (cdr (assoc 0 (entget ent))))
(if (not (member etyp '("ATTRIB" "VERTEX" "SEQEND")))
  (setq sel (ssadd ent sel))
)
     )
     (if (> (sslength sel) 0)
      sel
nil
     )
   )
   nil
 )
)



;;*************************************************************************
;;§/SELECTIONS/  retourne le entnext qui n'est pas un sous élement/ent
;;
(defun pw_real_entnext (ent / sel etyp go ent res)
 (setq go T)
 (if ent
     (while (and (setq ent (entnext ent)) go)
(setq etyp (cdr (assoc 0 (entget ent))))
(if (not (member etyp '("ATTRIB" "VERTEX" "SEQEND")))
  (setq go nil res ent)
)
     )
   )
res
)

[Tramber]

Merci GEGE,

Ce matin même, de telles fonctions m'auraient bien manquées avant que je n'acheve mon boulot !

 

J'ai cherché et trouvé un vieux message dont je me souvenais vaguement, pour m'amuser :

http://cadxp.com/topic/2041-diviser-et-mesurer/page__p__7421__hl__%2B+%2B%28entlast%29__fromsearch__1#entry7421

x_all me plonge des années en arrière...

On y voit le Tramber, tout tremblant et débutant en lisp et le Didier clairvoyant et bienveillant sans oublier d'avoir été marrant B)

[x_all]

Et bien merci tout le monde

 

ça marche plutot bien, mais comme je me sert de 2 4 8 6 pour copier suivant les direction du pavé, si je fait 8 espace espace ça me fait le PAN seul, ce qui est bien pratique pour changer de vue de l'étage

 

j'ai donc rajouter 22 44 88 et 66 qui vont copier les gaine deja copiée

 

je met le code si ça peu service à qq1car quand on bosse avec des étages, si on prend la précaution d'aligner ses étages avec un pas régulier c'est de la balle.

il y a aussi qqs fonctions adaptée de vue pavé de (gile) histoire d'exploiter tout le pavé numérique

 

je voie bien que le code est un peu laborieux et mériterai une optimisation mais... ça marche...

 

;| enchaine une copie et un pan auteur joch04
5 fonctions définies (+ 4 autres)
2 4 8 6 copie la sélection dans la direction cardinale désignée
5 invite à définir un pas pour la fonction
si rien n'est sélectionné, pan seul
cinq autres fonctions pour la 3d,
0 1 3 7 9 Qui restaurent des vues autocad (qu'il faut avoir créées) mais quand on fait de la 3d ça vaut le coup
enfin, 22 44 88 et 66 qui copie le résultat de 2 4 8 6  si on veux encore monter un étage avec les éléments copiés
|;

(defun c:5 (/ pas test)

;;;fonction de changement de pas de déplacement
 (setq test 0)
 (setq dir 0)
 (princ "\nPas du décalage des niveaux enregistré: ")
 (princ (getvar "USERR1"))

 (or (setq pas (getreal "\nChanger cette valeur ou entrée "))
 	(progn
(setq pas (getvar "USERR1"))
(setq test 1)
(princ "\n pas de changement : ")
 	)
 )
 (if (= test 0)
(setvar "USERR1" pas)
 )
 (princ "\n nouveau pas de décalage : ")
 (princ (getvar "USERR1"))
 (princ)
)

;;;fonction de changement de pas de déplacement

(defun c:2 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (setq *derent (pw_real_entlast))
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list 0 (* -1 (getvar "USERR1"))))
 	(setq sel (ssget))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

(defun c:4 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (setq *derent (pw_real_entlast))
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list (* -1 (getvar "USERR1")) 0))
 	(setq sel (ssget))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

(defun c:8 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (setq *derent (pw_real_entlast))
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list 0 (getvar "USERR1")))
 	(setq sel (ssget))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

(defun c:6 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (setq *derent (pw_real_entlast))
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list (getvar "USERR1") 0))
 	(setq sel (ssget))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)


;; fonction qui renvoie la dernière entité et une autre pour récupérer les derniers objets créer par 2 4 8 ou 6
;; voir ici pourquoi enlast ne suffit pas http://cadxp.com/topic/42928-reprendre-les-derniers-objets-copies/page__view__findpost__p__244244
;; merci GEGEMATIC Vincent et tous les autres


(defun pw_real_entlast ( / ent tmp ok eg tp)
(setq ok T)
(if (setq ent (entlast))
 (while (and (setq tmp (entnext ent)) ok)
  (setq eg (entget ent))
  (setq tp (cdr (assoc 0 eg)))
  (if (= "SEQEND" tp)
	(setq ok nil)
  )
  (setq ent tmp)
 )
)
ent
)

(defun der-ent-copie (/ ent sel)
 (setq ent (entnext *derent))
 (setq sel (ssadd))
 (while (not (null ent))
(ssadd ent sel)
(setq *derent ent)
(setq ent (entnext *derent))
 )
 sel
)

;;; Vue prédéfinies depuis le pavé numérique (gile)
;;; adaptation pitoyable de vues-pave de (gile)


(mapcar
 '(lambda (f v)
	(eval (list 'defun-q
	 f
	 nil
	 (list 'command "_.view" "_restore" v)
	 '(princ)
   )
	)
  )
 '(c:0 c:1 c:3 c:7 c:9)
 '("vue0" "vue1" "vue3" "vue7"	"vue9")
)


;; fonctions 22 44 88 66
;; idem 2 4 8 6 mais en reprenant les derniers objets copié pour les placer sur un autre étage


(defun c:22 (/ tmp P1 P0 ent sel)
 (setq tmp (getvar "USERR1"))
 (princ tmp)

 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list 0 (* -1 (getvar "USERR1"))))

 	(setq sel (der-ent-copie))

 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)



(defun c:44 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list (* -1 (getvar "USERR1")) 0))
 	(setq sel (der-ent-copie))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

(defun c:88 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list 0 (getvar "USERR1")))
 	(setq sel (der-ent-copie))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)

(defun c:66 (/ tmp P1 P0)
 (setq tmp (getvar "USERR1"))
 (princ tmp)
 (if (= 0.0 tmp)
(princ
 	"\nPour deffinir un décalage des déplacements tapper 5 puis entrée"
)
(progn
 	(setq P0 (list 0 0))
 	(setq P1 (list (getvar "USERR1") 0))
 	(setq sel (der-ent-copie))
 	(command "_.copy" sel "" "_none" P0 P1)
 	(command "-pan" P1 P0)
)
 )
 (princ)
)