Décalage de polyligne - 2 valeurs différentes

[zebulon_]

Bonjour,

 

Voir ici le lien vers un fichier dwg qui montre un exemple de décalage.

 

L'exemple montre une polyligne d'origine qui fait 4431.688 de long. On veut se décaler de 10 au départ et de 20 à la fin.

 

Je commence par calculer une sorte de pente (20-10)/4431.688 = 0.22565%

 

Cette polyligne est composée d'un alignement droit de 1004.988, d'une courbe de 1906.683, d'une autre courbe de 486.326 et d'un alignement droit de 1033.691.

 

A chaque sommet, on devrait obtenir un décalage de :

10

10 + 1004.988*0.22565% = 12.268

12.268 + 1906.683*0.22656% = 16.570

16.570 + 486.326*0.22565% = 17.668

17.668 + 1033.691*0.22565% = 20

 

J'ai aussi regardé ce que ça donnait au milieu de la première courbe :

12.268 + 953.341*0.22565% = 14.419

 

Je retrouve ces cotes sur mon dessin d'exemple. Le programme semble donc fonctionner, du moins comme je voulais qu'il fonctionne. Il n'empêche qu'il peut y avoir des cas où ça ne marche pas ou alors c'est le principe de l’algorithme qui est complètement foireux.

 

Amicalement

Vincent

[La Lozère]

Comme zebulon, je ne vois pas ce qui ne marche pas. J'ai regardé, et quelque soit l'endroit où on prenne la valeur du décalage, on a bien une valeur de décalage correspondant à la longueur depuis l'origine*le pourcentage.

Mais bien sur, plus la valeur de la corde est faible plus le résultat obtenu est juste.

 

Au début, j'ai fait un test avec une valeur de corde de 10cm, et je trouvais des erreurs comprises entre 0 à 10cm, puis avec une corde de 1cm, je trouve une erreur variant de 0 à 1cm.

 

Peux-tu nous en dire plus Didier sur ce que tu trouves comme incohérence dans le décalage?

 

Merci à vous.

[Olivier Eckmann]

Bonjour,

 

L'algorithme est conforme à ce qu'on lui demande, après, je pense que Didier est un peu inquiet car ce n'est pas forcément cette méthode de décalage qui serait utilisée si on devait le faire à la main.

Ci-joint un fichier qui peut présenter un résultat surprenant. En partant de la poly avec un arc tangent à 2 alignements, on obtient après décalage une courbe discrétisée qui n'est plus tangente aux alignements décalés.

A la main, on aurait d'abord décalé les 2 alignements, puis reconstruit la courbe tangente à ces alignements.

 

Comme lorsque l'on décale un axe qui comprend une enchainement Dr - Clo - Arc - Clo - Arc - Dr, on décale les 2 alignements et l'arc, puis on reconstruit les clo. Les points de tangence des clo après décalage ne sont pas exactement à la perpendiculaire des points de tangence sur l'axe original.

 

Maintenant, les valeurs de décalage sont en règle générale faibles (1m, 1.5m) pour des longueurs de 100m ou plus, donc l'approximation est suffisante pour faire passer un "bulldozer".

 

Olivier

[lecrabe]

Hello

Olivier >>> ... L'approximation est suffisante pour faire passer un "bulldozer" ...

SURTOUT avec un Bulldozer conduit par Olivier !?

Bye, lecrabe

[Olivier Eckmann]

Hello,

 

@LeCrabe : Comment ça, tu supposes que j'ai pas le permis "BULL".

 

J'ai parlé de bull car dernièrement un de mes projeteurs à découvert un bug dans la fonction décalage qui lui faisait perdre 4 dixième de millimètre dans le rayon de l'arc après décalage. Le problème existe quelque soit la version d'AutoCAD (y compris en petites coordonnées). Bug signalé => identifié et reproductible chez Autodesk.

Mais bon 4 dixième de millimètre pour tracer une route avec un finisher qui va suivre un piquet en bois implanté depuis une station relevée au GPS à +/- 3cm ça me fait un peu rigoler.

 

Olivier

[lecrabe]

Hello Olivier

 

SVP juste pour mon Info ...

 

Le Bug sur DECALER :

1) est il reproductible proche du 0,0 ?

2) est il specifique aux Arcs ?

 

Bye, lecrabe

[didier]

Coucou

 

Au temps pour moi

Je lâche temporairement l'affaire.

Je regarderai dès que j'en aurai la possibilité et si je trouve quelque chose je proposerai ma solution telle que je le la pressens.

Il est tout à fait possible que j'aie mal compris l'énoncé.

Je n'ai pas moyen de télécharger le fichier d'Olivier pour comprendre ce qu'il veut dire.

Le principal intéressé à l'air content et on s'arrêtera là.

 

Amicalement

[Olivier Eckmann]

Salut Pat,

 

Oui le problème est reproductible à l'infini quelque soit la version d'AutoCAD et quelques soient les coordonnées.

 

Fichier exemple : poly rouge issue du dessin depuis l'axe Covadis => 2 rayon de 300.0000m

Après décalage de 3.5m d'un côté ou de l'autre les rayons devraient faire 296.5 et 303.5, mais ce n'est pas "exactement" le cas.

 

Olivier

[zebulon_]

Coucou

 

Au temps pour moi

Je lâche temporairement l'affaire.

Je regarderai dès que j'en aurai la possibilité et si je trouve quelque chose je proposerai ma solution telle que je le la pressens.

Il est tout à fait possible que j'aie mal compris l'énoncé.

Je n'ai pas moyen de télécharger le fichier d'Olivier pour comprendre ce qu'il veut dire.

Le principal intéressé à l'air content et on s'arrêtera là.

 

Amicalement

 

Bonjour,

 

en quelques mots, serait-il possible de connaitre les grandes lignes de la solution pressentie ?

 

Merci

Amicalement

Vincent

[zebulon_]

Salut Pat,

 

Oui le problème est reproductible à l'infini quelque soit la version d'AutoCAD et quelques soient les coordonnées.

 

Fichier exemple : poly rouge issue du dessin depuis l'axe Covadis => 2 rayon de 300.0000m

Après décalage de 3.5m d'un côté ou de l'autre les rayons devraient faire 296.5 et 303.5, mais ce n'est pas "exactement" le cas.

 

Olivier

 

Bonjour Olivier,

C'est un comportement bizarre qu'on a du mal à reproduire avec des arcs ou des polylignes qu'on dessine directement dans autocad sans l'aide de covadis.

Amicalement

Vincent

[Olivier Eckmann]

Bonjour Vincent,

 

en fait le problème vient du dernier segment avant l'arc qui est court et quasi tangent à l'arc. Après décalage, ce segment est "zappé" par AutoCAD (considéré comme inutile) et le sommet de l'arc est déplacé sur le sommet précédent, mais comme le bulge n'est pas recalculé, le rayon issu du calcul des 2 points extrêmes modifiés et du bulge constant est faux.

 

Cette configuration est générée lorsqu'une clo est "approximée" sous forme de polyligne dans AutoCAD. Ce n'est pas systématique, mais assez fréquent. En dehors de ce cas de figure, je ne connais pas d'autre domaine où on utilise des polylignes comme cela. Peut-être dans les représentations des mouvements de robots autonomes où les trajectoires sont assez proches de ce que l'on fait en route : droite - courbe de transition (ou tractoire) - arc ...

 

Olivier

[didier]

Coucou

 

Bien des messages sans rapport avec la question initiale sont présents dans ce topic

Je souhaite que ma réponse ne passe pas à la trappe pour autant

 

Je me suis donc permis de critiquer la solution proposée car, à mes yeux, ce n'est pas vraiment un décalage

Je suis plus parti sur le principe du calcul d'un point décalé à chaque extrémité de vertex et ensuite en combinant ces points trouver l'intersection de ces derniers pour créer la polyligne résultante.

 

Je joins un croquis pour la clarté :

http://pix.toile-libre.org/upload/img/1507016928.png

 

La solution proposée par zebulon_ ne donne pas le bon résultat,

par exemple lancée sur la même polyligne rouge que l'image précédente

le résultat diffère :

http://pix.toile-libre.org/upload/img/1507017075.png

 

Donc je laisse mon code que j'ai tapé VITE FAIT en demandant l'indulgence car :

je ne gère pas les arcs à discrétiser,

ils doivent être discrétisés AVANT le lancement

pour le moment je ne décale qu'à gauche le code est à peaufiner si le principe est retenu

pour moi c'est la piste de recherche, mais je suis à l'écoute de toute critique

 

Amicalement

(defun lst_pts(ent / lst nb pts)
 (and
(eq (type ent) 'ENAME)
(setq ent (vlax-ename->vla-object ent))
 )
 (setq nb 0)
 (while (not (vl-catch-all-error-p (setq pts (vl-catch-all-apply 'vla-get-coordinate (list ent nb)))))
(setq lst (cons (vlax-safearray->list (vlax-variant-value pts)) lst)
     	nb (1+ nb)
)
 )
 (reverse lst)
)

(defun c:da-decvar ( / ename nbsom lsom dec dec2 decdiff n nouvpol som1 som2 npol2)
 (setq ename (car (entsel))
nbsom (cdr (assoc 90 (entget ename)))
lsom (lst_pts ename)
dec (getreal "\ndécalage au départ\n")
dec2(getreal "\ndécalage à l'arrivée\n")
decdiff (- dec2 dec)
n 0
nouvpol '()
)

 (repeat (- nbsom 1)
(setq som1 (polar (nth 0 lsom) (+ (angle (nth 0 lsom) (nth 1 lsom)) (/ pi 2)) dec)
 	som2 (polar (nth 1 lsom) (+ (angle (nth 0 lsom) (nth 1 lsom)) (/ pi 2)) (setq dec (+ dec (/ decdiff (- nbsom 1)))))
 	nouvpol (append (list som2) (list som1) nouvpol)
 	lsom (cdr lsom)
 	)
)
(setq nouvpol (reverse nouvpol))
(setq npol2 '())
(setq npol2 (cons (car nouvpol) npol2))

(repeat (- nbsom 2)
 	(setq npol2 (cons(inters (nth 0 nouvpol) (nth 1 nouvpol) (nth 2 nouvpol) (nth 3 nouvpol) nil) npol2))
 	(setq nouvpol (cdr nouvpol))
 	(setq nouvpol (cdr nouvpol))
 	)

(setq npol2 (cons (nth 1 nouvpol) npol2))
(setq npol2 (reverse npol2))

(entmake
 	(append
(list
 	'(0 . "LWPOLYLINE")
 	'(100 . "AcDbEntity")
 	'(100 . "AcDbPolyline")
  	(cons 90 (length npol2))
 	'(70 . 0)
)
 	(mapcar '(lambda (p) (cons 10 p)) npol2)
 	)
)
)  

[zebulon_]

Bonjour,

 

Le décalage que je propose n'est valable que si les segments successifs sont +/- tangents, comme c'est le cas en tracé routier. C'était une condition posée depuis le départ de la discussion et rappelée à plusieurs reprises. C'est pour cette raison que je ne comprenais pas pourquoi tu disais que mon décalage était faux, compte tenu que dans le cas particulier qui nous occupe, il ne l'est pas (ou pas trop).

 

Pour avoir quelque chose de plus général, comme tu l'esquisses, je verrais bien de décaler segment par segment, qu'on viendrait raccorder dans un deuxième temps pour recréer la polyligne. Je ne sais pas si c'est une bonne idée, mais c'est la piste qu' a priori j'explorerais.

 

Amicalement

Vincent

[didier]

Coucou

 

Certes si on parle de tracé routier comme il est précisé on peut voir les autres différemment mais si on parle de décalage progressif je pense être dans le vrai pour le principe de la question initiale.

 

Dans la piste de recherche que tu évoques en réponse #63 je ne suis pas d'accord car les vertex vont être parallèles et du coup on ne parle plus de décalage progressif.

 

Maintenant je ne vais pas jouer à celui qui fait pipi plus loin, pas de ça chez moi, j'ai proposé ma vision des choses, tu as proposé la tienne soit!

 

Amicalement

[lecrabe]

Hello Didier

 

1) BRAVO l'Expat !

 

2) Pourquoi tu ne decales que A GAUCHE, tu n'es pas Droitier plutot !?

C'est une question a poser au depart (Gauche ou Droite) !

 

3) Tu ne traites pas les Arcs et alors ...

Avec la routine Arc2Seg v1.03 de Gilles que j'ai redonne au debut du sujet (Msg No 6), en principe ca devrait rouler !?

 

Bye, lecrabe "admiratif du savoir-faire des vieux Schnoks"

[bonuscad]

Maintenant je ne vais pas jouer à celui qui fait pipi plus loin, pas de ça chez moi,

 

T'es pas dans l'air du trump, heu du temps! :(rires forts):

 

http://www.humeurs.be/wp-content/uploads/2017/04/PAN20170421_TrumpKim-Couleur-1600-1024x570.jpg

 

Blague à part, je vais de mon côté, essayer de faire un clone de algorithme d'autodesk sur les largeurs variables pour avoir les bords en "dur".

C'est pas gagné car le chalenge risque d'être difficile. Peut être que je laisserai tomber... :(

[zebulon_]

Coucou

 

Certes si on parle de tracer routier comme il est précisé on peut voir les autres différemment mais si on parle de décalage progressif je pense être dans le vrai pour le principe de la question initiale.

 

Dans la piste de recherche que tu évoques en réponse #63 je ne suis pas d'accord car les vertex vont être parallèles et du coup on ne parle plus de décalage progressif.

 

Maintenant je ne vais pas jouer à celui qui fait pipi plus loin, pas de ça chez moi, j'ai proposé ma vision des choses, tu as proposé la tienne soit!

 

Amicalement

 

je n'ai pas été assez précis dans mon commentaire : je voulais dire décaler chaque segment de façon progressive, pas juste un offset, et je rejoins ta vision des choses pour généraliser la routine, mais en essayant d'intégrer les parties courbes, ce qui ne sera pas une mince affaire. Mon idée : faire un décalage progressif de chaque segment, droit ou courbe, puis de raccorder chaque segment ainsi obtenu pour créer une nouvelle polyligne.

 

Il n'est pas question ici de faire pipi plus loin qu'un autre. Chacun apporte sa pierre à l'édifice, en fonction de son temps, sa connaissance, son inspiration, son expérience, etc

S'il y a un peu d'émulation, puisque quelqu'un a parlé de challenge, pourquoi pas ? De là à parler de "faire pipi plus loin", je trouve que c'est exagéré.

 

Amicalement

Vincent

[didier]

Coucou

 

Quand je parle de faire pipi plus loin c'est juste parce que je n'ai rien à prouver à personne et que j'ai tendance à être cash

J'ai tellement subi de remarques par le passé sur des messages mal interprétés que je prends les devants en annonçant la couleur, pas toujours adroitement j'en conviens.

 

Pour réponde au décapode :

Merci de ton bravo, il me ravit et j'en rosis

Ce code n'est qu'une ébauche, j'ai écrit ça pour expliciter ma vision des choses.

Pour le sens de décalage c'est pas grand chose, un clic et un signe à changer.

Pour ce qui de la discrétisation des arcs (on ne parle pas de polygonation) là aussi j'ai une façon de voir les choses différente que ce qui est habituellement exprimé, j'y ai travaillé par ailleurs mais c'est hors-sujet.

Je ne l'ai pas traité entre-autres pour cette raison.

 

La plus pure action à réaliser est clairement en partant d'une polyligne d'épaisseurs variables mais le code va être compliqué sans compter que ce qu'on obtient une fois le décalage réalisé est bien souvent de la spline et de l'ellipse et du coup on perd en qualité de travail, par contre c'est mathématiquement exact.

 

Une façon très simple pourrait être de faire un décalage classique puis une rotation de la polyligne décalée, on perd le point d'arrivée mais c'est globalement assez juste.

 

Amicalement

 

[Olivier Eckmann]

Bonjour,

 

dans le cas d'un décalage segment par segment puis raccord entre eux, il faudrait tenir compte de la variable OFFSETGAPTYPE pour savoir si on prolonge ou si on raccorde en arc. Cette dernière option (valeur 1 pour la variable) me paraît plus exacte que le prolongement.

 

Olivier

[zebulon_]

Bonjour,

 

dans le cas d'un décalage segment par segment puis raccord entre eux, il faudrait tenir compte de la variable OFFSETGAPTYPE pour savoir si on prolonge ou si on raccorde en arc. Cette dernière option (valeur 1 pour la variable) me paraît plus exacte que le prolongement.

 

Olivier

oui, et il y a aussi le problème évoqué plus haut qui est celui de segments très courts qui peuvent disparaitre du fait du décalage et pour lesquels je ne sais pas trop comment faire.

 

Une façon très simple pourrait être de faire un décalage classique puis une rotation de la polyligne décalée, on perd le point d'arrivée mais c'est globalement assez juste.

En effet, c'est très simple à mettre en oeuvre et a l'avantage de conserver les parties courbes comme de vraies courbes, même si on perd en précision au niveau des points d'extrémité des segments. On ne peut pas tout avoir, n'est-ce pas ?

 

Amicalement

Vincent

[bonuscad]

Je vais essayer de faire un clone de l'algorithme d'autodesk sur les largeurs variables pour avoir les bords en "dur".

C'est pas gagné car le chalenge risque d'être difficile. Peut être que je laisserai tomber... :(

 

Comme je le pensais, ça a été un peu casse-tête...

Je vous livre un 1er jus de ce que j'avais décris: avoir comme des largeurs dégressives mais avec des bords en "dur" (on peut s'y accrocher).

Il y a certainement des bugs ou imperfections à améliorer, mais je pense que c'est un bon début.

 

(vl-load-com)
(defun q_dir (p1 p2 p3 / v1 v2 v_or)
 (setq
   v1 (mapcar '- p2 p1)
   v2 (mapcar '- p1 p3)
   v_or
   (apply '(lambda (x1 y1 z1 x2 y2 z2) (- (* x1 y2) (* y1 x2)))
     (append v1 v2)
   )
 )
)
(defun c:Progressive_Offset ( / js AcDoc Space th_start th_end ent obj param_curve perim_curve nb_vtx lst_pt lst_pl1 lst_pl2 deriv-1 det-or n-1 p_start p_end deriv dir_tg bulg rad p_cen alpha alpha_inc nw_pt op1 op2 d tmp_pt1 tmp_pt2 nw_pl)
 (princ "\nSélectionner la polyligne: ")
 (while (not (setq js (ssget "_+.:E:S" '((0 . "*POLYLINE") (-4 . "<NOT") (-4 . "&") (70 . 126) (-4 . "NOT>")))))
   (princ "\nPas d'objets valable ou sélection vide!")
 )
 (setq
   AcDoc (vla-get-ActiveDocument (vlax-get-acad-object))
   Space
   (if (= 1 (getvar "CVPORT"))
     (vla-get-PaperSpace AcDoc)
     (vla-get-ModelSpace AcDoc)
   )
 )
 (vla-startundomark AcDoc)
 (setq
   ent (ssname js 0)
   obj (vlax-ename->vla-object ent)
   param_curve (vlax-curve-getEndParam obj)
   perim_curve (vlax-curve-getDistAtParam obj param_curve)
   nb_vtx -1
   lst_pt nil
   lst_pl1 nil
   lst_pl2 nil
   deriv-1 nil
   det_or nil
   n-1 nil
 )
 (initget 5)
 (setq th_start (getdist (trans (vlax-curve-getPointAtParam obj 0) 0 1) "\nDemi-Largeur de départ: "))
 (initget 4)
 (setq th_end (getdist (trans (vlax-curve-getPointAtParam obj param_curve) 0 1) (strcat "\nDemi-Largeur de fin <" (rtos (* 0.5 (/ (/ th_start perim_curve) (/ (1+ (sqrt 5)) 2)))) ">: ")))
 (if (not th_end) (setq th_end (* 0.5 (/ (/ th_start perim_curve) (/ (1+ (sqrt 5)) 2)))))
 (repeat (1+ (fix param_curve))
   (setq
     nb_vtx (1+ nb_vtx)
     p_start (vlax-curve-getPointAtParam obj nb_vtx)
     p_end (vlax-curve-getPointAtParam obj (1+ nb_vtx))
     deriv (vlax-curve-getFirstDeriv obj nb_vtx)
     deriv-1
     (if (not deriv-1)
       (if (and (zerop nb_vtx) (eq (vla-Get-Closed obj) ':vlax-true))
         (vlax-curve-getFirstDeriv obj (fix param_curve))
         deriv
       )
       (if (and (eq nb_vtx (fix param_curve)) (eq (vla-Get-Closed obj) ':vlax-true))
         (vlax-curve-getFirstDeriv obj 0)
         deriv-1
       )
     )
     lst_pt
     (cons
       (list
         p_start
         (setq dir_tg
           (* 0.5
             (+
               (atan (cadr deriv) (car deriv))
               (atan (cadr deriv-1) (car deriv-1))
             )
           )
         )
         (- (atan (cadr deriv) (car deriv)) dir_tg)
         (if (and (eq nb_vtx (fix param_curve)) (eq (vla-Get-Closed obj) ':vlax-true))
           th_end
           (+ th_start (* (/ (- th_end th_start) perim_curve) (vlax-curve-getDistAtParam obj nb_vtx)))
         )
       )
       lst_pt
     )
     deriv-1 deriv
   )
   (cond
     ((and p_end (not (zerop (setq bulg (vla-GetBulge obj nb_vtx)))))
       (setq
         rad (/ (distance (trans p_start 0 ent) (trans p_end 0 ent)) (sin (* 2.0 (atan bulg))) 2.0)
         p_cen
         (trans
           (polar
             (trans p_start 0 ent)
             (+ (angle (trans p_start 0 ent) (trans p_end 0 ent)) (- (* 0.5 pi) (* 2.0 (atan bulg))))
             rad
           )
         ent 0
         )
         alpha (angle (trans p_cen 0 ent) (if (< bulg 0.0) (trans p_end 0 ent) (trans p_start 0 ent)))
         alpha_inc (angle (trans p_cen 0 ent) (trans p_start 0 ent))
       )
       (repeat (fix (/ (rem (- (+ (* 2.0 pi) (angle (trans p_cen 0 ent) (if (< bulg 0.0) (trans p_start 0 ent) (trans p_end 0 ent)))) alpha) (* 2.0 pi)) (/ pi (/ 100.0 pi))))
         (setq
           alpha_inc (if (< bulg 0.0) (- alpha_inc (/ pi (/ 100.0 pi))) (+ alpha_inc (/ pi (/ 100.0 pi))))
           nw_pt (trans (polar (trans p_cen 0 ent) alpha_inc (abs rad)) ent 0)
           deriv (vlax-curve-getFirstDeriv obj (vlax-curve-getParamAtPoint obj nw_pt))
           lst_pt
           (cons
             (list
               nw_pt
               (atan (cadr deriv) (car deriv))
               0.0
               (+ th_start (* (/ (- th_end th_start) perim_curve) (vlax-curve-getDistAtPoint obj nw_pt)))
             )
             lst_pt
           )
           deriv-1 deriv
         )
       )
     )
   )
 )
 (setq
   det_or (q_dir (caar lst_pt) (caadr lst_pt) (trans (polar (caar lst_pt) (+ (cadar lst_pt) (* 0.5 pi)) (caddar lst_pt)) 0 ent))
   op1 (if (> det_or 0.0) '+ '-)
   op2 (if (> det_or 0.0) '- '+)
 )
 (foreach n lst_pt
   (setq d (/ (cadddr n) (cos (caddr n))))
   (if n-1
     (setq
       det_or (q_dir (car n) n-1 (polar (car n) (+ (cadr n) (* 0.5 pi)) d))
       op1 (if (> det_or 0.0) '+ '-)
       op2 (if (> det_or 0.0) '- '+)
       tmp_pt1 (trans (polar (car n) ((eval op1) (cadr n) (* 0.5 pi)) d) 0 ent)
       tmp_pt2 (trans (polar (car n) ((eval op2) (cadr n) (* 0.5 pi)) d) 0 ent)
       lst_pl1 (cons tmp_pt1 lst_pl1)
       lst_pl2 (cons tmp_pt2 lst_pl2)
       n-1 (car n)
     )
     (setq
       tmp_pt1 (trans (polar (car n) ((eval op1) (cadr n) (* 0.5 pi)) d) 0 ent)
       tmp_pt2 (trans (polar (car n) ((eval op2) (cadr n) (* 0.5 pi)) d) 0 ent)
       lst_pl1 (cons tmp_pt1 lst_pl1)
       lst_pl2 (cons tmp_pt2 lst_pl2)
       n-1 (car n)
     )
   )
 )
 (setq nw_pl (vlax-invoke Space 'AddLightWeightPolyline (apply 'append (mapcar 'list (mapcar 'car lst_pl1) (mapcar 'cadr lst_pl1)))))
 (if (eq (vla-Get-Closed obj) ':vlax-true) (vla-put-Closed nw_pl 1))
 (vla-put-Normal nw_pl (vla-get-Normal obj))
 (vla-put-Elevation nw_pl (vla-get-Elevation obj))
 (setq nw_pl (vlax-invoke Space 'AddLightWeightPolyline (apply 'append (mapcar 'list (mapcar 'car lst_pl2) (mapcar 'cadr lst_pl2)))))
 (if (eq (vla-Get-Closed obj) ':vlax-true) (vla-put-Closed nw_pl 1))
 (vla-put-Normal nw_pl (vla-get-Normal obj))
 (vla-put-Elevation nw_pl (vla-get-Elevation obj))
 (vla-endundomark AcDoc)
 (prin1)
)

Modifié le 6 octobre 2017 par bonuscad

[didier]

Coucou

 

Un grand BRAVO pour ce travail

Un deuxième pour le partage

Les limites étant faites pour être reculées celles du sublime viennent de s'éloigner

Je ne suis pas assez féru en Vla pour être capable d'écrire la même chose, chapeau c'est beau.

 

Quelques soucis de tangence non respectée subsistent c'est pour cette raison que je pense qu'il est nécessaire de lancer le programme sur des arcs discrétisés.

 

Encore bravo

 

Amicalement

[La Lozère]

Hello,

Merci à tous pour s’être pris au jeu de ma demande.

 

BonusCad, juste une remarque. La demande d'origine était de faire un décalage d'une polyligne. Avec une valeur à l'origine, et une valeur à la fin.

Du coup, dans ton prog, il y a un double décalage symétrique, dont la valeur de départ est comprise entre les deux nouvelles polylignes. Idem pour le point de fin.

Donc, ça marche bien, mais il faut penser à doubler les valeur de décalage voulue, et à supprimer la polyligne superflue.

 

En tout cas BRAVO et encore MERCI

[didier]

Coucou

 

Oh lui !!!

Il demande une voiturette, on lui livre une Rolls et il demande à ce qu'on lui vide le cendrier !!!!

 

Je te blague bien sûr

Que ce soit celle de zebulon_, la mienne ou celle de Môsieur BonusCad (Cinq-Étoiles) c'est du travail "fait main", c'est perfectible à l'envi

 

Amicalement

[lecrabe]

Hello Bruno

 

1) WAOUH je suis impressionne !

 

2) Notre Ardechois a decide de "battre" notre Expat !?

 

3) Waiting for "The Marseillais" (gile) ...

 

MERCI, Bye, lecrabe