Image raster en rond

[Jedeash]

Alors voila encore une question

Savez vous comment delimiter une image en cercle ?

Je m'explique : je veux, dans une présentation, le détail d'une photo dans un cercle.

 

 

Je peux la mettre en Espace objet et faire une fenêtre circulaire (ça marche)

Mais si je veux avoir un bloc cartouche avec l'image circulaire il faudrait que je puisse la mettre en espace papier... et là je ne peux delimiter que soit en rectangle soit en polygone :casstet:

 

Si quelqu'un a une idée...

 

P-S (A part faire mon image en rond dans photoshop ou faire un polygone à 10000 cotés pour faire croire à un rond ;) )

[Eric]

Bonjour

 

Il y a la commande [surligneur] clipit[/surligneur] du menu express qui permet de faire cela sur les images, les blocs et les xref

 

Tu sélectionnes d'abord le cercle puis l'image

 

A plus

 

Eric

 

[Jedeash]

ok merci pour la réponse... vitesse de la lumière parfait

mais donc sans express pas de cercle...

 

D'ailleurs il me semble que clipit fait un polygone à partir de la forme choisie

mais c'est parfait !

 

[Edité le 30/9/2005 par Jedeash]

[Eric]

mais donc sans express pas de cercle...

 

Pas aussi facilement

 

D'ailleurs il me semble que clipit fait un polygone à partir de la forme choisie

mais c'est parfait !

 

Effectivement il fait un polygone mais on peut régler la précision

 

 

[(gile)]

Salut,

 

Tu peux insérer ton image dans l'espace objet, et dans ta présentation, faire une fenêtre circulaire (Convertir objet en fenêtre) puis faire apparaître dans cette fenêtre la partie de l'image qui t'intéresse.

 

Illustration avec une ellipse :

 

http://img305.imageshack.us/img305/7798/chaise3ri.jpg

 

[Edité le 30/9/2005 par (gile)]

[bonuscad]

mais donc sans express pas de cercle...

 

Une routine similaire au express avec un cercle ou polyligne comme contour.

(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:Clip_image ( / ent dxf_ent typent closed lst l_bub e_next osmd)
(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" 1)
		(command "_.undo" "_group")
		(command "_.imageclip" pause "_new" "_polygonal")
		(foreach n lst (command n))
		(command (car lst) "" "")
		(command "_.undo" "_end")
		(setvar "cmdecho" 1)
		(setvar "osmode" osmd)
	)
)
(prin1)
)

 

Si ta délimitation est une spline/ellipse fermée.

Tu peux convertir celle-ci en polyligne au préalable avec la routine suivante..

(defun C:S-E2PL ( / ent typent dxf_ent obj_vlax param_start param_end perim_obj pt_start pt_end res_track flag_ucs last_e old_osmd old_pdmd l_pt)
(while (null (setq ent (entsel "\nChoix de la Spline ou Ellipse à convertir en polyligne: "))))
(setq typent (cdr (assoc 0 (setq dxf_ent (entget (car ent))))))
(cond
	((or (eq typent "SPLINE") (eq typent "ELLIPSE"))
		(vl-load-com)
		(setq
			obj_vlax (vlax-ename->vla-object (car ent))
			param_start (vlax-curve-getStartParam obj_vlax)
			param_end (vlax-curve-getEndParam obj_vlax)
			perim_obj (vlax-curve-getDistAtParam obj_vlax (+ param_start param_end))
			pt_start (vlax-curve-getStartPoint obj_vlax)
			pt_end (vlax-curve-getEndPoint obj_vlax)
		)
		(initget 6)
		(setq
			res_track (getdist (cadr ent) (strcat "\nDistance de résolution<" (rtos (/ perim_obj 100.0)) ">: "))
			last_e (entlast)
			old_osmd (getvar "osmode")
			old_pdmd (getvar "pdmode")
		)
		(if (not res_track) (setq res_track (/ perim_obj 100.0)))
		(initget "Oui Non _Yes No")
		(if (eq (getkword "\nVoulez vous faire une projection sur le SCU courant? [Oui/Non]: ") "Yes")
			(setq flag_ucs nil)
			(progn
				(command "_.ucs" "_entity" (car ent))
				(setq flag_ucs T)
			)
		)
		(cond
			((and (eq typent "SPLINE") (not (zerop (boole 1 1 (cdr (assoc 70 dxf_ent))))))
				(setq l_pt '("_close"))
			)
			((and (eq typent "ELLIPSE") (zerop (cdr (assoc 41 dxf_ent))) (eq (cdr (assoc 42 dxf_ent)) (* 2 pi)))
				(setq l_pt '("_close"))
			)
			(T
				(setq l_pt (cons (trans pt_end 0 1) '("")))
			)
		)
		(setvar "osmode" 0)
		(setvar "pdmode" 1)
		(setvar "cmdecho" 0)
		(command "_.measure" (car ent) res_track)
		(while
			(and
				(= (cdr (assoc 0 (setq dxf_ent (entget (entlast))))) "POINT")
				(not (equal (entlast) last_e))
			)
			(setq l_pt (cons (trans (cdr (assoc 10 dxf_ent)) 0 1) l_pt))
			(entdel (entlast))
		)
		(command "_.pline" (mapcar 'command (cons (trans pt_start 0 1) l_pt)))
		(if flag_ucs (command "_.ucs" "_previous"))
		(initget "Oui Non _Yes No")
		(if (not (eq (getkword "\nEffacer l'entité source [Oui/Non] : ") "No"))
			(entdel (car ent))
		)
		(setvar "osmode" old_osmd)
		(setvar "pdmode" old_pdmd)
		(setvar "cmdecho" 1)
	)
	(T (princ "\nN'est pas une Spline ou Ellipse!"))
)
(prin1)
)
(princ "\nS-E2PL.LSP chargé. Tapez S-E2PL pour convertir SPLINE ou ELLIPSE en POLYLIGNE.")
(prin1)

 

Avec ceci tu pourras faire de belles délimitations d'images dans l'espace objet.