COUPER ET SUPPRIMER

[Defman]

Bonjour,

 

Je voulais savoir, s'il existe une commande ou une routine pour :

 

ajuster, couper et effacer tout ce qu'il y a à l'exterieur d'une forme géométique ou d'une polyligne fermée.

 

Certain que ca existe et que d'autre se sont penché sur le sujet, merci de m'éclairer.

 

Et bon W-end!

[Tramber]

http://www.synapse-informatique.com/qbrick_fr.htm

 

!

[franckAMF]

Bonjour,

 

il me semble que la commande EXTRIM répond à tes critères.

[Defman]

Une foi de plus l'efficacitée est de mise!

 

Je test ca pour mon application et je vous donnerai les résulats.

 

Une fois de plus, un grand merci.

[Defman]

Voila, j'ai testé :

 

Tout d'abord la commande extrim n'existe plus sur lt2007.

 

Qbrick fonctionne parfaitement, mais pour mon application ce n'est pas exactement ce que je cherche.

 

Dans le forum, j'ai trouvé un sujet identique :

 

AutoCAD 2005 > commande dérivé de EXTRIM

 

Par contre, je n'ai pas la pratique pour changer le code.

 

Tu peux essayer ceci, en espérant que cela fonctionne pour toi.

 

Necessite un programme de Kamal Boutora nommé "QBRICK".

Modifier le code suivant la version de Qbrick utilisé

Voir ICI

 

(defun def_bub_pl (ls lb flag_closed / ls lb rad a l_new)
(if (not (zerop flag_closed)) (setq ls (append ls (list (car ls)))))
(while (cadr ls)
	(if (zerop (car lb))
		(setq l_new (append l_new (list (car ls))))
		(progn
			(setq
				rad (/ (distance (car ls) (cadr ls)) (sin (* 2.0 (atan (abs (car lb))))) 2.0)
				a (- (/ pi 2.0) (- pi (* 2.0 (atan (abs (car lb))))))
			)
			(if (< a 0.0) (setq a (- (* 2.0 pi) a)))
			(if (or (and (< (car lb) 0.0) (> (car lb) -1.0)) (> (car lb) 1.0))
				(setq l_new (append l_new (reverse (cdr (reverse (buble_pts (polar (car ls) (- (angle (car ls) (cadr ls)) a) rad) (car ls) (cadr ls) rad (car lb)))))))
				(setq l_new (append l_new (reverse (cdr (reverse (buble_pts (polar (car ls) (+ (angle (car ls) (cadr ls)) a) rad) (car ls) (cadr ls) rad (car lb)))))))
			)
		)
	)
	(setq ls (cdr ls) lb (cdr lb))
)
(append l_new (list (car ls)))
)
(defun buble_pts (pt_cen pt_begin pt_end rad sens / inc ang nm p1 p2 lst)
(setq
	inc (angle pt_cen (if (< sens 0.0) pt_end pt_begin))
	ang (+ (* 2.0 pi) (angle pt_cen (if (< sens 0.0) pt_begin pt_end)))
	nm (fix (/ (rem (- ang inc) (* 2.0 pi)) (/ (* pi 2.0) 72.0)))
)
(repeat nm
	(setq
		p1 (polar pt_cen inc rad)
		inc (+ inc (/ (* pi 2.0) 72.0))
		lst (append lst (list p1))
	)
)
(setq
	p2 (polar pt_cen ang rad)
	lst (append lst (list p2))
)
(if (< sens 0.0) (reverse lst) lst)
)
(defun make_fence ( / )
(cond
	((eq typent "LWPOLYLINE")
		(setq
			closed (boole 1 (cdr (assoc 70 dxf_ent)) 1)
			lst (mapcar '(lambda (x) (trans x (car ent) 1)) (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) dxf_ent)))
			l_bub (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 42)) dxf_ent))
			lst (def_bub_pl lst l_bub closed)
		)
	)
	((eq typent "POLYLINE")
		(setq
			closed (boole 1 (cdr (assoc 70 dxf_ent)) 1)
			e_next (entnext (car ent))
		)
		(while (= "VERTEX" (cdr (assoc 0 (setq dxf_next (entget e_next)))))
			(if (zerop (boole 1 223 (cdr (assoc 70 dxf_next))))
				(setq
					lst (cons (trans (cdr (assoc 10 dxf_next)) (car ent) 1) lst)
					l_bub (cons (cdr (assoc 42 dxf_next)) l_bub)
				)
			)
			(setq e_next (entnext e_next))
		)
		(setq
			lst (reverse lst)
			l_bub (reverse l_bub)
			lst (def_bub_pl lst l_bub closed)
		)
	)
	((eq typent "CIRCLE")
		(setq
			lst
				(buble_pts
					(trans (cdr (assoc 10 dxf_ent)) (car ent) 1)
					(polar (trans (cdr (assoc 10 dxf_ent)) (car ent) 1) 0.0 (cdr (assoc 40 dxf_ent)))
					(polar (trans (cdr (assoc 10 dxf_ent)) (car ent) 1) (- (* 2.0 pi) (/ (* pi 2.0) 36.0)) (cdr (assoc 40 dxf_ent)))
					(cdr (assoc 40 dxf_ent))
					1
				)
			lst (append lst (list (car lst)))
			closed 1
		)
	)
	(T (princ "\nN'est pas un Cercle ou une Polyligne!"))
)
)
(defun c:evider ( / ent dxf_ent typent closed lst l_bub e_next osmd n pt_g e_fence ss l_ent js_all ssb key tmp)
(while (null (setq ent (entsel "\nChoix du contour d'évidement: "))))
(setq typent (cdr (assoc 0 (setq dxf_ent (entget (car ent))))))
(make_fence)
(cond
	((and lst (not (zerop closed)))
		(if (equal (last lst) (car lst)) (setq lst (cdr lst)))
		(setq osmd (getvar "osmode"))
		(setvar "osmode" 0)
		(setvar "cmdecho" 0)
		(command "_.undo" "_group")
		(command "'_.zoom" "_window"
			(list (eval (cons min (mapcar 'car lst))) (eval (cons min (mapcar 'cadr lst))))
			(list (eval (cons max (mapcar 'car lst))) (eval (cons max (mapcar 'cadr lst))))
		)
		(setq n (float (length lst)))
		(setq pt_g (list (/ (apply '+ (mapcar 'car lst)) n) (/ (apply '+ (mapcar 'cadr lst)) n)))
		(command "_.offset" "0.25" ent (polar (cadr ent) (angle (cadr ent) pt_g) (distance (cadr ent) pt_g)) "")
		(setq e_fence (entlast))
		(if (not (member "qbrick2000.arx" (arx))) (arxload "qbrick2000.arx"))
		(command "_.qbrick" "_fence")
		(foreach n lst (command n))
		(command (car lst) "" "")
		(setq typent (cdr (assoc 0 (setq dxf_ent (entget e_fence)))))
		(make_fence)
		(setq ss (ssget "_CP" lst))
		(setq
			l_ent (if ss (ssnamex ss))
			js_all (ssget "_X")
		)
		(foreach n l_ent (if (eq (type (cadr n)) 'ENAME) (setq ssb (ssdel (cadr n) js_all))))
		(if (zerop (getvar "pickfirst")) (setvar "pickfirst" 1))
		(if (and ss ssb (= 0 (getvar "CMDACTIVE"))) 
			(progn
				(princ "\n pour inverser la sélection; /[Espace]/Click+droit pour finir!.")
				(while (and (not (member (setq key (grread T 4 2)) '((2 13) (2 32)))) (/= (car key) 25))
					(sssetfirst nil ss)
					(cond
						((eq (car key) 3)
							(setq tmp ss ss ssb ssb tmp)
						)
					)
				)
			)
		)
		(command "_.erase" ss "")
		(command "_.zoom" "_previous")
		(command "_.undo" "_end")
		(setvar "cmdecho" 1)
		(setvar "osmode" osmd)
	)
)
(prin1)
)

 

Par concéquent je cherche toujours la solution

[Bred]

Par contre, je n'ai pas la pratique pour changer le code.

Salut,

c'est du lisp.

tu es en lt.

ce n'est pas possible d'utiliser des lisp en lt.

(sauf si tu utilises ltextender, je te laisse regarder)

[Defman]

Pardon, j'ai pas tout compris.

 

Le Lisp c'est ok, j'ai Lt extender, mais je pensais qu'il fallait modifier le code " arx " et la je comprennait pas.

 

Je test de suite.

[bonuscad]

Le lisp est à modifier selon la version d'arx que tu vas utiliser.

 

Cela ce passe dans la ligne suivante...

 

(if (not (member "qbrick2000.arx" (arx))) (arxload "qbrick2000.arx"))

[Defman]

Aîe, SOS SVP.

 

j'ai compris " en gros" le system de ce lisp qui fait appel à la commande 'Qbrick' lancée avec LT Extender.

 

j'utilise QBRICK2007 donc j'ai modifié :

 

(if (not (member "qbrick2007.arx" (arx))) (arxload "qbrick2007.arx"))

 

Je lance la commande 'evider'

Je selectionne mon cadre et j'obtiens :

 

Commande: evider

Choix du contour d'évidement:

; error : bad argument type ; expected at [FUNCALL]

 

J'ai testé avec une polyligne et un cercle.

[bonuscad]

Il y a peut être des incompatibilité avec LT-Extender et l'arx fourni pour une 2007 pleine.

 

Je n'ai jamais utilisé LT-Extender, donc j'aurais beaucoup de mal à t'aider.

 

Ce que je comprend du message d'erreur, est qu'il y a une exception dans la fonction appelée (qbrick ?)

 

Pour voir; essayes directement en ligne de commande la ligne que tu as proposée:

 

(if (not (member "qbrick2007.arx" (arx))) (arxload "qbrick2007.arx"))

 

Si celle-ci ne retourne pas de message d'erreur et qu'elle retourne "qbrick2007.arx" essayes la suivante:

 

(command "_.qbrick" "_fence")

 

Si celle-ci te demande des points de trajet, c'est que le problème vient du lisp, autrement cela vient de l'arx qbrick. A ce moment essayes de voir avec l'auteur, s'il y a une solution possible...

[Defman]

Effectivement je pense qu'il y a un probleme avec cette ligne de commande :

 

(if (not (member "qbrick2007.arx" (arx))) (arxload "qbrick2007.arx"))

 

 

Pour :

 

(command "_.qbrick" "_fence")

 

ces 2 cmd fonctionnent.

 

J'ai la possibilité de le tester sur un autre poste qui tourne sur full2007.

je donnerai le résultat après l'essais.

 

Si cela fonctionne, ça doit etre imcompatible avec LT " se serait dommage! "

 

J'essais de trouver une manip avec les contours et le chanfrein, mais ce n'est pas concluant.

 

Attention : ce que je ne comprend pas, c'est que toute les fonctions " Qbrick " fonctionnent.

Par concéquent pourquoi serait t'il incompatible avec LT ?

[bonuscad]

Attention : ce que je ne comprend pas, c'est que toute les fonctions " Qbrick " fonctionnent.

Par concéquent pourquoi serait t'il incompatible avec LT ?

 

Je n'ai pas affirmé qu'il était incompatible, j'ai juste fait une supposition...

 

Un truc que je n'ai pas pensé à dire et que pour que la 1ere ligne fonctionne (arxload "...arx")

il FAUT que l'arx à charger soit dans un dossier de recherche connu d'autocad.

 

Donc soit déplacer l'arx dans le dossier voulu, ou rajouter un nouveau dossier de recherche.

 

Désolé pour l'oubli...

[Defman]

Merci pour l'info, et effectivement je n'avais pas placé le fichier support en recherche.

 

Mais ....

 

Cela ne fonctionne toujours pas.

 

L'erreur à légèrement changée :

 

Commande: EVIDER

Choix du contour d'évidement:

; error : bad argument type ; expected at [FUNCALL]

 

faudrait t'il lancer l'arx depuis lt extender. ce n'est qu'une supposition.

Donc on changerait l'appel de la fonction. Si c'est le cas, je vais me documenter sur

LT Extender, mais c'est pas gagné!

 

Merci encore, et le mieux après tout c'est de passer en full, mais c'est pas de mon ressort.

 

 

[bonuscad]

Je connais pas LT-Extender, mais d'après ce qu'il a pu ce dire dans le forum, c'est qu'il ne connait pas les fonction (vl-, vla- et vlax-)

 

Or dans ce lisp j'utilise juste la fonction (vl-remove-if

 

Pourrais tu essayer cette ligne de code en test sur une LWPOLYLINE

Si elle ne possède pas d'arc, tu devrais avoir en retour une liste de zéro (0.0 0.0 0.0 ....)

 

(mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 42)) (entget (car (entsel)))))

 

Si ça ne fonctionne pas il faudra réécrire cette fonction en lisp pur (Gille la peut être déjà fait pour cette fonction)

[Defman]

Pourrais tu essayer cette ligne de code en test sur une LWPOLYLINE

Si elle ne possède pas d'arc, tu devrais avoir en retour une liste de zéro (0.0 0.0 0.0 ....)

 

(mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 42)) (entget (car (entsel)))))

 

J'ai bien la liste de zéro.

[bonuscad]

Ben j'ai pu trop d'idée pour identifier le problème.

 

Il te faut utiliser la fonction (trace) pour les sous-routines et faire un pas à pas pour la fonction principale pour essayer de trouver le bug

 

(trace def_bub_pl)

(trace buble_pts)

(trace make_fence)

 

et tu lance la fonction evider.

Si toutes les (trace) effectuées se passent bien c'est que le bug est dans la fonction principale.

 

Bien sur, si tu veux donner suite, car là ça demande un peu plus de temps.... pour identifier le bug

[Defman]

J'ai compris l'architecture du lisp mais je ne sais pas l'écrire ( pas encore ), donc pour moi c'est le début.

 

Pour les commandes test a insérer, je dois simplement supprimer les sous fonction et ajouté :

 

(trace def_bub_pl)

(trace buble_pts)

(trace make_fence)

 

Ou bien je dois les intégrer dans les sous fonctions.

 

Désolé pour mon inexpérience, mais fau bien commencer un jour, et à par ce forum, ben j'ai pas vraiment d'aide.

[bonuscad]

Non, non tu ne fais rien de spécial,

 

Si le lisp est chargé en mémoire, tu fais ces commandes directement en ligne de commande AVANT de lancer le lisp qui pose problème.

 

Si dans la même session tu veux arrêter le traçage d'une fonction tu fais (untrace nom_de_la_fonction)

 

En fait cela sert surtout pour la mise au point de lisp, comme ici ;)

 

Pour un debug plus efficace (vu que l'editeur vlisp n'est pas disponible sous LT), il peut être intéressant de mettre les variable en remarque.

Exemple

 

(defun ma_fonction (arg1 arg2 arg3 .... / var1 var2 var3 ....)

 

à modifier temporairement en:

(defun ma_fonction (arg1 arg2 arg3 .... / ) ;;; var1 var2 var3 ....)

 

En faisant ceci tu pourra interroger les variables en ligne de commande en faisant: !var1

Ceci te retournera la valeur de var1

si la valeur retournée est nil , il y a de forte chance pour que le programme ce soit crashé avant son calcul, donc il plus facile d'identifier l'endroit dans le code ou cela pêche...

 

Voilà pour un succin cours de débugage de façon manuel, je ne sais pas si LT-Extender offre des outils qui aident à faire ceci ?!?!

[Defman]

LT EXTENDER EST LIMITER DANS CE DOMAINE.

 

CE LISP FONCTIONNE PARFAITEMENT SUR UN AUTRE POSTE AVEC AUTOCAD COMPLET.

 

JE TIENS A TE REMERCIER POUR TON AIDE, MAIS CELA M'A L'AIR BIEN TROP COMPLIQUER DE LE FAIRE TOURNER SUR LT. JE MANQUE DE TEMPS ACTUELLEMENT POUR APPROFONDIR LE DEBUGAGE.

 

ENCORE MERCI. :)