decaler multiples.....

[tazofparis]

bonjour à tous.

 

Je suis à la recherche d'une astuce ou d'un prog pour pouvoir faire des decaler multiples sous ADT2004 et 2006.

L'idée est de renter à l'avance toute une serie de côtes de selectionnner une ligne (ou un cercle) et un cote et que cet objet soit décalé par toutes les valeurs précedement rentrées.

Pour aller plus loin l'idéal serait de définir une direction par 2 pt et d'insérer (par le milieu) un segment perpendiculairement à cette direction suivant les cotes préalablement tapées.

 

Cordialement

 

Pierre

 

 

[bonuscad]

Bonjour,

 

J'ai essayé d'écrire rapidement quelques lignes.

 

Après avoir sélectionné l'entité a décaler, tu seras invité à saisir successivement des distances de décalage.

Par défaut c'est le mode "Interval" qui est actif. Cela veut dire que la distance sera appliqué au dernier objet décalé. Le mode "Cumul" ce fait toujours par rapport à l'objet initial sélectionné.

Dans ce dernier mode, il sera vérifié que la distance entrée est supérieure à la précédente.

 

Le message à la ligne de commande va s'enrichir des valeurs entrées.

Si la variable "SHORTCUTMNU" est à 11 (normalement défaut), tu pourras même réentrer une valeur précédemment saisie par un click-droit (menu contextuel)

 

Une fois toutes tes valeurs de décalage entrées, tu indiques de quel coté effectuer le décalage.

 

Une façon parmi tant d'autre! ;)

 

(defun c:repeat_offset ( / ent vn lst_vn tmp side_offset)
(setq ent (entsel "\nSélectionnez l'objet à décaler plusieurs fois ou < sortir > : "))
(cond
	(ent
		(initget 70 "Cumul Interval")
		(setq vn (getdist (cadr ent) "\nSpécifiez une distance de décalage ou [Cumul/Interval] < I > : "))
		(cond
			((eq vn "Cumul")
				(setq lst_vn nil)
				(princ "\nSpécifiez une distance de décalage: ")
				(initget 70)
				(while (setq vn (getdist (cadr ent)))
					(princ "\nSpécifiez une distance de décalage [")
					(if (> vn (car lst_vn))
						(setq lst_vn (cons vn lst_vn))
						(princ "\n*Incorrect* La valeur doit être > à la précédente.\nSpécifiez une distance de décalage [")
					)
					(foreach n (reverse lst_vn) (princ (rtos n)) (princ "/"))
					(princ "]: ")
					(initget 70)
				)
			)
			(T
				(if (or (eq vn "Interval") (not v_n))
					(progn
						(setq lst_vn nil)
						(princ "\nSpécifiez une distance de décalage: ")
					)
					(progn
						(setq lst_vn (list vn))
						(princ (strcat "\nSpécifiez une distance de décalage [" (rtos vn) "/]: "))
					)
				)
				(initget 70)
				(while (setq vn (getdist (cadr ent)))
					(princ "\nSpécifiez une distance de décalage [")
					(setq lst_vn (cons vn lst_vn))
					(foreach n (reverse lst_vn) (princ (rtos n)) (princ "/"))
					(princ "]: ")
					(initget 70)
				)
				(setq tmp nil)
				(while lst_vn
					(setq tmp (cons (apply '+ lst_vn) tmp))
					(setq lst_vn (cdr lst_vn))
				)
				(setq lst_vn (reverse tmp))
			)
		)
		(initget 1)
		(setq side_offset (getpoint "\nSpécifiez un point sur le côté à décaler: "))
		(setvar "cmdecho" 0)
		(command "_.undo" "_group")
		(foreach n lst_vn (command "_.offset" n ent side_offset ""))
		(command "_.undo" "_group")
		(setvar "cmdecho" 1)
	)
)
(prin1)
)

[Edité le 13/1/2006 par bonuscad]

 

[Edité le 13/1/2006 par bonuscad]

[tazofparis]

un ENORME merci pour ta réponse si rapide..

A priori tu es même aller au dela des mes attentes....

 

Par contre je ne sais pas comment "charger ces lignes...." ......

Je ne suis qu'un utilisateur de base et mes connaissances sont plus que limitées....

 

Pierre.

[tazofparis]

je viens de réussir à charger TON FABULEUX LSP .....

 

comme quoi le vendredi 13 .......

 

encore merci ........

 

 

@++++

[bonuscad]

Pour simplement l'essayer, tu peux faire un copier-coller du listing du code sur la ligne de commande d'AutoCAD.

Après un éventuel "Entrée" après la dernière paranthèse pour valider le code, tu devrais voir apparaitre :

C:REPEAT_OFFSET

Commande:

 

Tu n'as plus qu'a taper le nom de la commande retournée sans le "C:", ici "REPEAT_OFFSET".

 

Si tu veux le conserver, tu le colle dans le bloc note et tu le sauvegarde sous le nom repeat_offset.LSP (penses à l'extension)

NB: tu peux changer le nom du fichier et le nom de la commande; après (defun c:

 

Tu peux utiliser la commande "APPLOAD" d'AutoCAD pour le charger.

Mais il il y a d'autres manière de charger un prog, faire une recherche sur le forum si tu veux connaitre les différents moyens.

 

 

[tazofparis]

c'est exactement ce que j'ai fait .....

 

Par contre le mode par default "interval" ne marche pas car quand on valide on a ce retour sur la ligne de commande:

; erreur: type d'argument incorrect: numberp: nil

 

peut etre une variable à définir ???

 

[bonuscad]

Oui un oubli de ma part

 

(if (eq vn "Interval")

devient

(if (or (eq vn "Interval") (not v_n))

 

J'ai eu cet oubli parce ce que, je tiens à préciser, que le mode "Interval" est AUSSI le mode implicite.

C'est à dire que vous n'avez pas besoin de le spécifiez, vous pouvez directement entrer vos distances.

 

Merci de ta remarque, je corrige le précédent post car l'action de valider le mode "Interval" par une entrèe nulle doit être valide

 

Cela fera quand même mieux ;)

[siro]

Terrible !!!

merci Bonuscad

de nbreux clics en moins grace à ce Lisp

 

je subodore le Taz d'excercer la même profession ke la mienne

car en + de ce fabuleux "décaler multiples", l'idéal serait entre certains de ces "décalés" consécutifs (par paire dc), de voir se dessiner 1 nouveau trait au mileu de ceux ci ....

 

euh en pratique et en + clair, ce lisp me sert auj à créer par cotes cumulées des traits représentants les montants de portes en enfilade dans 1 couloir par exple, ces nouveaux traits tant désiré s;)) marqueraient automatiquement les axes de ces portes.

Jusk'à présent je me coltine ces axes avec des cercles en 2 points.... grrr

 

Bref merci encore ....

j'ose croire en la cerise sur le gateau hein ?? ;))

[bonuscad]

Je ne sais pas si la cerise sera a ton goût, ou si celle ci est véreuse. ;)

 

J'ai remanié le code pour créer l'option "Median" (entre les valeurs entrées, précedente et suivante)

La présentation est un peu différente mais le concept est le même.

(defun c:repeat_offset ( / ent mode vn lst_vn tmp side_offset)
(setq ent "Interval" mode nil)
(initget "Cumul Interval")
(while (or (eq 	(setq ent (entsel (strcat "\nSélectionnez l'objet à décaler plusieurs fois ou Mode d'action [Cumul/Interval] <" ent ">: "))) "Interval") (eq ent "Cumul") (not ent))
	(if (not ent) (setq ent (if mode "Cumul" "Interval")))
	(if (eq ent "Cumul") (setq mode T) (setq mode nil))
	(initget "Cumul Interval")
)
(cond
	(ent
		(setq lst_vn nil)
		(initget 70 "Median")
		(princ  "\nSpécifiez une distance de décalage ou [Median]: ")
		(while (setq vn (getdist (cadr ent)))
			(princ "\nSpécifiez une distance de décalage ou [Median] [")
			(cond
				((eq vn "Median")
					(if (and (car lst_vn) (< (car lst_vn) 0.0))
						(princ " *Déja en mode MEDIAN* ")
						(progn
							(foreach n (reverse lst_vn) (princ (rtos n)) (princ "/"))
							(setq lst_vn (cons -1.0 lst_vn))
						)
					)
					(princ "]: ")
				)
				(T
					(cond
						(mode
							(if (eq (car lst_vn) -1.0)
								(if (cadr lst_vn)
									(setq lst_vn (cons vn (cons (+ (cadr lst_vn) (/ (- vn (cadr lst_vn)) 2.0)) (cdr lst_vn))))
									(setq lst_vn (cons vn (cons (+ (/ vn 2.0)) (cdr lst_vn))))
								)
								(if (> vn (car lst_vn))
									(setq lst_vn (cons vn lst_vn))
									(princ "\n*Incorrect* La valeur doit être > à la précédente.\nSpécifiez une distance de décalage [")
								)
							)
							(foreach n (reverse lst_vn) (princ (rtos n)) (princ "/"))
						)
						(T
							(if (eq (car lst_vn) -1.0)
								(setq lst_vn (cons (/ vn 2.0) (cons (/ vn 2.0) (cdr lst_vn))))
								(setq lst_vn (cons vn lst_vn))
							)
							(foreach n (reverse lst_vn) (princ (rtos n)) (princ "/"))
						)
					)
					(princ "]: ")
				)
			)
			(initget 70 "Median")
		)
		(if (member -1.0 lst_vn) (setq lst_vn (vl-remove -1.0 lst_vn)))
		(if (not mode)
			(progn
				(setq tmp nil)
				(while lst_vn
					(setq tmp (cons (apply '+ lst_vn) tmp))
					(setq lst_vn (cdr lst_vn))
				)
				(setq lst_vn (reverse tmp))
			)
		)
		(cond
			(lst_vn
				(initget 1)
				(setq side_offset (getpoint "\nSpécifiez un point sur le côté à décaler: "))
				(setvar "cmdecho" 0)
				(command "_.undo" "_group")
				(foreach n lst_vn (command "_.offset" n ent side_offset ""))
				(command "_.undo" "_group")
				(setvar "cmdecho" 1)
			)
		)
	)
)
(prin1)
)

 

Possible qu'il reste des bugs, malgré les tests rapides que j'ai pu faire.

[tazofparis]

Que dire de plus si n'est MERCI.

 

La demande de Siro a magnifiquement complétée ce petit lisp.

 

Un grand merci à Bonuscad pour sa réactivité et sa disponibilité...

 

 

@++

 

 

[siro]

.... le bonheur en quelques lignes ;)

 

no bugs, d'une efficacité redoutable !!!

les géomètres vont s'arracher ce truc s'ils le trouvent ....

 

1 gd merci, si si !!!