Décalage de polyligne - 2 valeurs différentes

[La Lozère]

Bonjour,

Est-ce que quelqu'un aurait dans ça boite à lisp, un bout de code qui permettrait de décaler une polyligne d'une valeur x de décalage à une extrémité et d'une valeur y à l'autre extrémité. Ce qui entrainerait un décalage linéaire le long de la polyligne.

Pour une droite, c'est facile à construire, mais pour une courbe, ou même une polyligne composée de n éléments, c'est une autre histoire.

 

Je ne sais pas si je me suis bien fait comprendre, alors n'hésitez pas à le dire.

 

Merci.

[Patrick_35]

Salut

 

Si j'ai bien compris, voici un exemple

(setq ent (vlax-ename->vla-object (car (entsel)))) ; Sélection de la poly
(vlax-invoke ent 'offset 30.0)  ; Décalage d'un coté
(vlax-invoke ent 'offset -30.0) ; Puis de l'autre

 

@+

[La Lozère]

Salut Patrick,

Bon, je me suis mal expliqué.

 

Voici une image de ce que je voudrais:

 

Imaginons le fonctionnement de la commande:

- 1, je sélectionne la polyligne de base

- 2, j'indique la valeur de décalage de l'origine de la polyligne. Ici 5.00

- 3, j'indique la valeur de décalage de la fin de la polyligne. Ici 3.00

- 4, j'obtiens la polyligne résultante

 

Alors pour une droite, c'est simple, mais pour un arc, ou une polyligne à plusieurs éléments....

 

Pour une courbe, la polyligne résultante serait une sorte de clothoïde, et pour une polyligne à plusieurs éléments (arc ou éléments droits) ce serait un mixte.

 

Merci

[Aleck_Ultimate]

Salut.

 

C'est une idée en l'aire, mais serait il possible d’associer un style de trait de deux lignes parallèles et une largeur du trais non uniforme ? je crois bien avoir lue quelque part qu'avec un LISP ou une MACROS on pouvait faire des lignes dont le début et la fin n'avaient pas le même facteur de largeur, applicable à des courbes.

 

Cordialy.

[La Lozère]

Bonjour Alek,

 

Le truc c'est que moi il faut que ce soit de vrai polyligne. Car ensuite, j'ai plusieurs choses à construire avec, notamment les transformer en poly 3D.

[lecrabe]

Hello

 

Est ce que ta Polyligne de base est seulement 2D ?

Et tu veux traiter les 2D Polylignes "Legeres" seulement ou aussi les "Lourdes" (splinees par exemple)

 

Donc il te faut une transition "douce" du 1er Vertex au Dernier Vertex !?

Que la Polyligne soit de UN SEUL segment/arc OU N segments + N Arcs ...

 

C pas si simple !!

 

Bye, lecrabe

[La Lozère]

Hello,

Non, je ne veux traiter que des polylignes "légères".

Je ne sais pas trop ce que tu appels un Vertex, mais effectivement, il faut une transition progressive pour partir de la 1ière valeur de décalage en début de polyligne, et arrivé à la 2ième valeur de décalage en fin de polyligne.

 

La polyligne peux être formée de N segments et N arcs.

 

Effectivement je pense que ce n'est pas simple. Mais justement, je demandais ça juste pour savoir si quelqu'un avait ça de coté.

 

Merci.

[thierry.garré]

Juste comme ca pourquoi ne pas utiliser autopiste ?

[La Lozère]

Bonjour Thierry,

Justement pour l'instant je me débrouille avec Autopiste. Mais quand on fait de la conception à la chaine rapide et uniquement en 2d pour dégrossir le travaille, une "petite" fonction comme ça serait pas mal.

Merci.

[zebulon_]

La polyligne peux être formée de N segments et N arcs.

chaque segment est tangent avec les segments adjacents ? J'imagine que oui, puisqu'on parle de tracé routier.

 

Dans les parties courbes, le résultat serait une suite de segments droits, avec une longueur assez petite pour que cela reste acceptable. On paramètre cette longueur de précision en début de lisp et on permet à l'utilisateur de la changer.

 

Je pense que c'est faisable et je regarderai lundi, à moins que quelqu'un d'autre se soit penché sur le sujet entre temps :)

 

Amicalement

Vincent

[La Lozère]

Salut Zebulon,

Effectivement, chaque segments est tangent ou quasi. Et oui, pour les arc une succession de segments droit assez petits conviendraient.

 

Merci.

[lecrabe]

Hello

 

Pour aider voici une routine "Arc2Seg" (OK sur version 2018 et precedentes) de Gilles que j'utilise depuis longtemps !

Ce sera plus facile de decaler subtilement et progressivement des Segments !!

 

Elle "elimine" les Arcs (par exemple dans les LW Polylignes - NON Splines / NON Arcs) en les simulant par des Segments (Nombre de Segments parametrable) ...

 

Bye, Bon Dimanche

 

 

;;
;; Generation de Polygones Reguliers sur les Arcs , Cercles et Arcs dans Polylignes 
;;
;; Amelioration: Les XDatas sont copiees sur la nouvelle polyligne.
;;
;; Routine:  ARC2SEG  vers 1.03 par GC le 10 Nov 2008 (Pour Patrice) 
;; Transforme les arcs, cercles et polyarcs en polylignes constituees de segments droits
;;
;; 1 - Correction du bug sur les arcs > 180 degres
;; 2 - Pour les XDatas, soit je copie tout dans la nouvelle entite soit, 
;; dans le cas des polylignes avec suppression, je ne fais que modifier les sommets de la polyligne. 
;; 3 - J'ai peaufine le traitement des largeurs, si la largeur de depart et la largeur de fin different,
;; celle des segments changera aussi proportionnellement.
;; 4 - Generation soit sur le calque courant, soit sur le calque d'origine des objets (vs 1.03)
;;

(vl-load-com) 

(defun c:Arc2Seg (/ arc2pol pol2pol seg del org ss n ent elst)

 ;; Retourne la liste dxf de la polyligne (d'après un arc ou un cercle)
 (defun arc2pol
 (elst seg org / closed alpha delta cen elv rad lay nlst)
   (and (= (cdr (assoc 0 elst)) "CIRCLE") (setq closed T))
   (setq alpha	(if closed
	  (* pi 2)
	  (cdr (assoc 51 elst))
	)
  delta	(if closed
	  (/ alpha seg)
	  (/ (ang<2pi (- alpha (cdr (assoc 50 elst)))) seg)
	)
  cen	(cdr (assoc 10 elst))
  elv	(caddr cen)
  cen	(list (car cen) (cadr cen))
  rad	(cdr (assoc 40 elst))
  lay	(if org
	  (assoc 8 elst)
	  (cons 8 (getvar "CLAYER"))
	)
  nlst	(vl-remove-if-not
	  (function (lambda (x) (member (car x) '(210 -3))))
	  elst
	)
  nlst	(cons (cons 10 (polar cen alpha rad)) nlst)
   )
   (repeat (if	closed
      (1- seg)
      seg
    )
     (setq
nlst (cons (cons 10
		 (polar cen (setq alpha (- alpha delta)) rad)
	   )
	   nlst
     )
     )
   )
   (setq nlst
   (cons '(0 . "LWPOLYLINE")
	 (cons '(100 . "AcDbEntity")
	       (cons (cons 410 (getvar "CTAB"))
		     (cons lay
			   (cons '(100 . "AcDbPolyline")
				 (cons (cons 90
					     (if closed
					       seg
					       (1+ seg)
					     )
				       )
				       (cons (cons 70
						   (if closed
						     1
						     0
						   )
					     )
					     (cons (cons 38 elv) nlst)
				       )
				 )
			   )
		     )
	       )
	 )
   )
   )
 )

 ;; Retourne la liste dxf de la polyligne modifiée (d'après une polyligne)
 (defun pol2pol (elst	seg   org   /	  cnt	closed	    nlst  p0
	  p1	p2    bu    larg  inc	bdata delta cen	  rad
	  alpha	n
	 )
   (setq closed (logand 1 (cdr (assoc 70 elst)))
  cnt	 0
   )
   (and (= closed 1) (setq p0 (cdr (assoc 10 elst))))
   (while elst
     (if (= (caar elst) 10)
(progn
  (setq	p1 (cdar elst)
	p2 (cdr (assoc 10 (cdr elst)))
	bu (cdr (assoc 42 elst))
  )
  (if (or (= 0 bu)
	  (and (zerop closed) (null p2))
      )
    (setq nlst (cons (cadddr elst)
		     (cons (caddr elst)
			   (cons (cadr elst)
				 (cons (car elst) nlst)
			   )
		     )
	       )
	  elst (cddddr elst)
    )
    (progn
      (and (not p2) (= closed 1) (setq p2 p0))
      (setq larg  (cdr (assoc 40 elst))
	    inc	  (/ (- (cdr (assoc 41 elst)) larg) seg)
	    bdata (BulgeData bu p1 p2)
	    delta (/ (car bdata) seg)
	    rad	  (abs (cadr bdata))
	    cen	  (caddr bdata)
	    alpha (angle cen p1)
	    n	  0
	    cnt	  (+ cnt seg -1)
      )
      (while (< n seg)
	(setq nlst (cons
		     (cons 10
			   (polar cen
				  (+ alpha (* delta n))
				  rad
			   )
		     )
		     nlst
		   )
	      nlst (cons (cons 40 larg) nlst)
	      nlst (cons (cons 41 (setq larg (+ larg inc))) nlst)
	      nlst (cons '(42 . 0.0) nlst)
	      n	   (1+ n)
	)
      )
      (setq elst (cddddr elst))
    )
  )
)
(setq nlst (cons (car elst) nlst)
      elst (cdr elst)
)
     )
   )
   (or	org
(setq nlst (subst (cons 8 (getvar "CLAYER")) (assoc 8 nlst) nlst))
   )
   ((lambda (dxf90)
      (subst (cons 90 (+ (cdr dxf90) cnt))
      dxf90
      (reverse (subst '(42 . 0.0) (assoc 42 nlst) nlst))
      )
    )
     (assoc 90 nlst)
   )
 )

 ;; Fonction principale

 (or (getenv "SegmentsNumberPerCircle")
     (setenv "SegmentsNumberPerCircle" "64")
 )
 (initget 6)
 (if
   (setq seg (getint
	(strcat	"\nNombre de segments par arc <"
		(getenv "SegmentsNumberPerCircle")
		">: "
	)
      )
   )
    (setenv "SegmentsNumberPerCircle" (itoa seg))
    (setq seg (atoi (getenv "SegmentsNumberPerCircle")))
 )
 (initget "Oui Non")
 (if (= "Oui"
 (getkword "\nEffacer les objets source [Oui/Non] ? <N>: ")
     )
   (setq del T)
 )
 (initget "Courant Origine")
 (if (= "Origine"
 (getkword
   "\nCalque des nouveaux objets [Courant/Origine] ? <C>: "
 )
     )
   (setq org T)
 )
 (prompt
   "\nSélectionner les objets à traiter ou <tous>."
 )
 (and
   (or	(setq ss (ssget '((0 . "ARC,CIRCLE,LWPOLYLINE"))))
(setq ss (ssget "_X" '((0 . "ARC,CIRCLE,LWPOLYLINE"))))
   )
   (setq n 0)
   (while (setq ent (ssname ss n))
     (setq elst (entget ent '("*")))
     (if (= (cdr (assoc 0 elst)) "LWPOLYLINE")
((if del
   entmod
   entmake
 )	   (pol2pol elst seg org)
)
(progn
  (entmake (arc2pol elst seg org))
  (and del (entdel ent))
)
     )
     (setq n (1+ n))
   )
 )
 (princ)
)


;; BulgeData
;; Retourne les données d'un polyarc (angle rayon centre)
(defun BulgeData (bu p1 p2 / alpha rad cen)
 (setq	alpha (* 2 (atan bu))
rad   (/ (distance p1 p2)
	 (* 2 (sin alpha))
      )
cen   (polar p1
	     (+ (angle p1 p2) (- (/ pi 2) alpha))
	     rad
      )
 )
 (list (* alpha 2.0) rad cen)
)


;;; Ang<2pi
;;; Retourne l'angle, à 2*k*pi près, compris entre 0 et 2*pi

(defun ang<2pi (ang)
 (if (and (<= 0 ang) (< ang (* 2 pi)))
   ang
   (ang<2pi (rem (+ ang (* 2 pi)) (* 2 pi)))
 )
) 

[zebulon_]

Salut Zebulon,

Effectivement, chaque segments est tangent ou quasi. Et oui, pour les arc une succession de segments droit assez petits conviendraient.

 

Merci.

 

(defun PTaDroiteObj (obj pt / PTN PM fder PT1DERIV)
 (if (= (type Obj) 'ENAME)
   (setq Obj (vlax-ename->vla-object Obj))
 )
 (setq PTN (vlax-curve-GetClosestPointTo obj PT))
 (setq PM (vlax-curve-GetParamAtPoint obj PTN))
 (setq fder (vlax-curve-getfirstderiv obj PM))
 (setq PT1DERIV (mapcar '+ PTN fder))
 (< (sin (- (angle PTN PT) (angle PTN PT1DERIV))) -1e-14)
)

(defun getpolySegs (ent / PTL I PTB SEG LSEG)
 (if (= (type ent) 'ENAME)
   (setq ent (vlax-ename->vla-object ent))
 )
 ;; collecter la liste des point sous la forme (x1 y1 x2 y2 ... xn yn)
 (setq PTL (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates ENT))))
 ;; collecter la liste des bulges
 (setq I 0) 
 (repeat (/ (length PTL) 2)
   (setq PTB (cons (vla-GetBulge ent I) PTB))
   (setq I (1+ I))
 )
 (setq PTB (reverse PTB))
 ;; polyligne fermée -> rajouter le premier point à la liste de points
 (if (= (vla-get-closed ent) :vlax-true)
   (setq PTL (append PTL (list (car PTL) (cadr PTL))))
 )
 ;; transformer en liste de segments
 (setq I 0)
 (repeat (- (/ (length PTL) 2) 1)
   (setq SEG
     (list
       (list (nth I PTL) (nth (+ I 1) PTL))
       (nth (/ I 2) PTB)
       (list (nth (+ I 2) PTL) (nth (+ I 3) PTL))
     )
   )
   (setq LSEG (cons SEG LSEG))
   (setq I (+ I 2))
 )
 (reverse LSEG)
)

(defun getArcInfo (segment / a p1 bulge p2 c p3 p4 p r s result)
 ;; assigner variables avec les valeurs de l'argument
 (mapcar 'set '(p1 bulge p2) segment)
 (if (not (zerop bulge))
   (progn
     ;; trouver la corde
     (setq c (distance p1 p2))
     ;; trouver la flèche
     (setq s (* (/ c 2.0) (abs bulge)))
     ;; trouver le rayon par Pythagore
     (setq r (/ (+ (expt s 2.0) (expt (/ c 2.0) 2.0)) (* 2.0 s)))
     ;; distance au centre
     (setq a (- r s))
     ;; coordonnées du milieu de p1 et P2
     (setq P4 (polar P1 (angle P1 P2) (/ c 2.0)))
     ;; coordonnées du centre
     (setq p
       (if (>= bulge 0)
         (polar p4 (+ (angle p1 p2) (/ pi 2.0)) a)
         (polar p4 (- (angle p1 p2) (/ pi 2.0)) a)
       )  
     )
     ;; coordonnées de P3
     (setq p3
       (if (>= bulge 0)
         (polar p4 (- (angle p1 p2) (/ pi 2.0)) s)
         (polar p4 (+ (angle p1 p2) (/ pi 2.0)) s)
       )  
     )
     (setq result (list p r))
   )
   (setq result nil)
 )
 result
)

(defun getptsegd (SEG PT)
   (mapcar 'set '(P1 BULGE P2) SEG)
   (if adroite 
      (setq ANG (* 3 (/ pi 2)))
      (setq ANG (/ pi 2))
   )
   (polar PT (+ (angle P1 P2) ANG) (+ decd (* (- decf decd) (/ (vlax-curve-getDistAtpoint obj PT) LongObj))))
)

(defun getptsegc (SEG PT)
   (mapcar 'set '(P1 BULGE P2) SEG)
   (setq PTC (car (getarcinfo SEG)))
   (if adroite 
      (setq ANG pi)
      (setq ANG 0)
   )
   (if (> BULGE 0)
     (setq ANG (+ (angle PT PTC) ANG))
     (setq ANG (+ (angle PTC PT) ANG))
   )
   (polar PT ANG (+ decd (* (- decf decd) (/ (vlax-curve-getDistAtpoint obj PT) LongObj))))
)


(defun c:decvar ()

 ;; valeur de décalage au départ
 (if (not decd) (setq decd 0.20))
 (setq tmp (getdist (strcat "\nSpécifier la distance de décalage à l'origine  <" (rtos decd) "> : ")))
 (if tmp (setq decd tmp))

 ;; valeur de décalage à la fin
 (if (not decf) (setq decf 0.50))
 (setq tmp (getdist (strcat "\nSpécifier la distance de décalage à la fin  <" (rtos decf) "> : " )))
 (if tmp (setq decf tmp))

 (setq e (car (entsel "\nSélectionner la polyligne à décaler : ")))
 (setq pt (getpoint "\n Spécifiez un point sur le côté à décaler : "))

 ;; précision des parties courbes
 (if (not PREC_COURBE) (setq PREC_COURBE 0.50))
 (setq tmp (getdist (strcat "\nLongueur approximative d'un pas de polygonisation des parties courbes  <" (rtos PREC_COURBE) "> : ")))
 (if tmp (setq PREC_COURBE tmp))
 
 (setq obj (vlax-ename->vla-object e))
 (setq LongObj (vla-get-length obj))

 (setq adroite (PTaDroiteObj obj (trans PT 1 0)))

 (setq Lsegs (getPolySegs obj))
 ;; le premier point
 (setq SEG (car Lsegs))
 (mapcar 'set '(P1 BULGE P2) SEG)
 (if (zerop BULGE)
   (setq LPT (list (getptsegd SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment droit
   (setq LPT (list (getptsegc SEG (vlax-curve-getPointAtDist obj 0.0)))) ;; c'est un segment courbe
 )
 ;; les points suivants
 (while Lsegs
   (setq SEG (car Lsegs))
   (setq lsegs (cdr Lsegs))
   (mapcar 'set '(P1 BULGE P2) SEG)
   (if (zerop BULGE) ;; c'est un segment droit
     (progn
       (setq PT (getptsegd SEG P2))
       (setq LPT (cons  PT LPT))
     )
     (progn  ;; c'est un segment courbe
       (setq PKdebut (vlax-curve-GetDistAtPoint obj P1))
       (setq PKfin (vlax-curve-GetDistAtPoint obj P2))
       (setq Larc (- PKfin PKdebut))
       (setq NBPAS (fix (/ Larc PREC_COURBE)))
       (setq PAS (/ Larc NBPAS))  ;; je coupe les courbes en NBPAS segments droits de longueur environ PREC_COURBE
       (setq PKcourant (+ PKdebut PAS))
       (repeat NBPAS
         (setq LPT (cons (getptsegc SEG (vlax-curve-GetPointAtDist obj PKcourant)) LPT))  ;; un point à chaque pas
         (setq PKcourant (+ PKcourant PAS))
       ) ;; repeat
     ) ;; progn
   ) ;; if
 ) ;; while       
 (setq LPT (reverse LPT))

 (command "_pline")
 (while LPT
   (setq PT (car LPT))
   (setq LPT (cdr LPT))
   (command "_non" (trans PT 0 1))
 )
 (command "")

 (princ)
)

 

à tester

 

Amicalement

Vincent

Modifié le 28 septembre 2017 par zebulon_

[La Lozère]

Salut Vincent,

Je viens de tester, et apparemment il y a un problème avec les arcs. Quelque soit la longueur d'arc 30-40m ou même 10000m, il me créait un élément droit entre l'origine de l'arc et la fin de l'arc.

Ensuite, il faudrait pouvoir mettre des valeurs inférieur à 1 pour la précision des courbes.

 

En tout cas merci.

[lecrabe]

Hello

 

Et si tu fais passer la routine Arc2Seg de Gilles avant ?!

 

La routine de Zebulon_ est elle OK ?

 

Bien, lecrabe

[La Lozère]

Effectivement, avec Arc2Seg avant, plus de problèmes. Ca marche nickel.

Merci à vous deux et à (gile).

 

En combinant les 2 dans un seul lisp, ça sera parfait.

 

Encore merci et A plus.

[zebulon_]

Effectivement, avec Arc2Seg avant, plus de problèmes. Ca marche nickel.

Merci à vous deux et à (gile).

 

En combinant les 2 dans un seul lisp, ça sera parfait.

 

Encore merci et A plus.

 

bonjour,

 

C'est sûr que si vous enlevez les segments courbes, ça devient facile. Mais ça marche aussi pour ce cas de figure.

 

Mais, je pense que vous interprétez mal le paramètre de précision. Ce que j'ai paramétré est le nombre de fois que je divise le segment d'arc. Forcément, ça ne peut pas être inférieur à 1. Et si vous mettez la valeur 1, ça va couper les arcs en 1 segment, ce qui n'est pas très précis... Il faudrait plutôt mettre 50 ou 100.

 

Si vous voulez, je peux changer le lisp en demandant de donner une longueur approximative de segment droit plutôt qu'un nombre de division. Ce serait peut être plus parlant et, d'autre part, évite de couper les petits segments courbes en autant de parties qu'un grand segment courbe. Je vais faire ça et publier le lisp modifié.

 

Le plus simple serait de partager un exemple en dwg que je pourrai faire passer dans la moulinette et voir comment ça marche sur un cas concret. Et on pourrait comparer nos résultats.

 

Amicalement

Vincent

[La Lozère]

Arf... Effectivement, j'avais mal compris le terme "précision". Autant pour moi.

Du coup, ça marche nickel.

 

Je te remercie.

[zebulon_]

Arf... Effectivement, j'avais mal compris le terme "précision". Autant pour moi.

Du coup, ça marche nickel.

 

Je te remercie.

 

voilà j'ai changé le code ci-dessus pour entrer non plus un nombre de divisions mais une longueur de corde, ce qui semble plus "naturel", effectivement.

 

Amicalement

vincent

[La Lozère]

Parfait, t'es un chef. c'est exactement ce qu'il me faut. Merci.

 

A plus.

[zebulon_]

Parfait, t'es un chef. c'est exactement ce qu'il me faut. Merci.

 

A plus.

 

Super, content que ça réponde à ta demande. Par contre, je pense que les routines qui consistent à s'amuser avec les segments de polylignes ne sont pas vraiment à mettre dans la rubrique "débuter en lisp"

Par ailleurs, si on applique cette routine à une polyligne où les segments successifs ne sont pas +/- tangents, ça ne donnera pas grand chose (d'où ma question préliminaire). Dans ce cas de figure il faudrait pousser la réflexion un peu plus loin.

 

Amicalement

Le Bas-Rhin

[bonuscad]

Autrement un résultat plus facile à mettre en œuvre, mais seulement visuel; on ne peut pas s'accrocher aux bords des représentations faites.

Cela utilise simplement les largeurs de départ et fin d'une polyligne.

 

(vl-load-com)
(defun c:Effile_Poly ( / js th_start th_end n ent obj flag_close param_curve perim_curve nb_vtx w_end w_start)
 (princ "\nSélectionner les polylignes: ")
 (while (not (setq js (ssget '((0 . "*POLYLINE") (-4 . "<NOT") (-4 . "&") (70 . 126) (-4 . "NOT>")))))
   (princ "\nPas d'objets valable ou sélection vide!")
 )
 (initget 5)
 (setq th_start (getdist "\nLargeur de départ: "))
 (initget 5)
 (setq th_end (getdist "\nLargeur de fin: "))
 (repeat (setq n (sslength js))
   (setq
     ent (ssname js (setq n (1- n)))
     obj (vlax-ename->vla-object ent)
   )
   (cond
     ((eq (setq flag_close (vla-Get-Closed obj)) ':vlax-true)
       (vla-Put-Closed obj ':vlax-false)
     )
   )
   (setq
     param_curve (vlax-curve-getEndParam obj)
     perim_curve (vlax-curve-getDistAtParam obj param_curve)
     w_end th_end
   )
   (vla-SetWidth
     obj
     param_curve
     w_end
     th_end
   )
   (repeat (setq nb_vtx (1- (fix param_curve)))
     (vla-SetWidth
       obj
       nb_vtx
       (setq w_start (+ th_start (* (/ (- th_end th_start) perim_curve) (vlax-curve-getDistAtParam obj nb_vtx))))
       w_end
     )
     (setq w_end w_start nb_vtx (1- nb_vtx))
   )
   (vla-SetWidth
     obj
     nb_vtx
     th_start
     w_end
   )
   (vla-Put-Closed obj flag_close)
 )
 (prin1)
)

[La Lozère]

Oui, j'avais pensé à un truc comme ça, mais le truc, c'est que dans ce cas, on a une sorte de décalage symétrique de chaque coté de la polyligne. Mais ce n'est pas le but recherché.

[zebulon_]

Bonjour,

 

Autrement un résultat plus facile à mettre en œuvre, mais seulement visuel; on ne peut pas s'accrocher aux bords des représentations faites.

Cela utilise simplement les largeurs de départ et fin d'une polyligne.

 

l'idée est séduisante. D'ailleurs, un peu plus tôt dans le fil de discussion, il semblerait que Aleck Ultimate ait proposé quelque chose de similaire. C'est rageant que ce ne soit que visuel, sinon ce serait effectivement et sans aucun doute la solution la plus simple à mettre en oeuvre.

 

Amicalement

Vincent

[VDH-Bruno]

Autrement un résultat plus facile à mettre en œuvre, mais seulement visuel; on ne peut pas s'accrocher aux bords des représentations faites.

 

Bonjour,

 

Peut être avec une impression DXB ou un export WMF...

 

A+ Bruno