résolu Transformer succession d'arc d'une même polyligne en ligne brisée paramétrable

Jaypee · le 10 mars 2023

Bien le bonjour,

Je sais que c'est un sujet qui apparait sous certaines formes assez régulièrement.

L'idée est que j'ai plusieurs arc joint en un polyligne, et que j'aimerais diviser cette polyligne en n segments éventuellement d'une longueur constante.

Il n'y a qu'une commande lisp à importer sur autocad qui peut le faire ?

bonuscad · le 10 mars 2023

Bonjour,

Voir cette réponse si elle convient?

Jaypee · le 13 mars 2023

Le sujet me permettait de savoir si on ne pouvait obtenir ce résultat qu'avec un lisp, ou si une suite de commande de base sur autocad pouvait produire le même résultat.

Eric · le 13 mars 2023

Bonjour,

Avec les fonctions de base, on peut faire ça.

Jaypee · le 13 mars 2023

Pas mal. On doit surement paramétré le nuagerev pour la longueur de segment

C'est ce genre d'astuce que je cherchais.

et je pense qu'il doit en exister d'autre encore.

merci

Eric · le 13 mars 2023

En mettant REVCLOUDARCVARIANCE sur 0, ça fait des arcs de longueurs identiques.

didier · le 13 mars 2023

Bonjour

C'est à se demander si les gens qui viennent poser les questions font des recherches avant de poster !
La demande, sans être récurrente, est tout de même fréquente, et chaque fois, je réponds la même chose.
Allez voir sur mon site... Sur cette page, je propose une façon alternative qui permet de faire le job,
mais en prenant la valeur de corde pour définir le nombre de segments.
Avec cette hypothèse de départ, il est plus aisé de respecter la géométrie sans créer des segments inutilement courts ou nombreux.

Je n'en dis pas plus ici, car il me semble que la page est explicative.

Amicalement

Jaypee · le 14 mars 2023

Il y a 16 heures, didier a dit :

C'est à se demander si les gens qui viennent poser les questions font des recherches avant de poster !
La demande, sans être récurrente, est tout de même fréquente, et chaque fois, je réponds la même chose.

Jaypee · le 14 mars 2023

Le 10/03/2023 à 14:11, Jaypee a dit :

Bien le bonjour,

Je sais que c'est un sujet qui apparait sous certaines formes assez régulièrement.

[...]Le sujet me permettait de savoir si on ne pouvait obtenir ce résultat qu'avec un lisp, ou si une suite de commande de base sur autocad pouvait produire le même résultat.

Merci pour ton partage, je m'attendais bien à cette réaction.

Bonne journée.

didier · le 14 mars 2023

Bonjour @Jaypee

Je détecte des indices d'ironie, voire de sarcasme, je ne vais pas renchérir cependant.
Est-ce que ce que j'ai proposé comme alternative te convient ou non ? Là est la vraie question.
Et, surtout, si ça ne convient pas, que faut-il y changer ?

Amicalement

JVC · le 27 mars 2023

Bonjour,

Pour rebondir sur ce sujet, parce que je me pose cette question aussi,

je trouve particulièrement désolant, voir plus..., qu'une fonction de ce type, convertir les ellipses en polylignes, qui existe pour les arcs et autres élements, n'existe ni sur AutoCAD classique , ni sur AutoCAD MAP ni sur Covadis, ni avec Express Tools ! et qu'il faille passer par des routines Lisps forts utiles faites par des passionnés !

Si on cherche (ce que je n'ai pas fait), on doit trouver ce type de questions depuis 20 ans.... alors plutot que de nous sortir des pseudos mises à jour, parfois fort inutiles, les éditeurs de logiciels, payants par ailleurs, n'aurait ils pas pu sortir cette petite fonction , non ?

Sauf erreur de ma part, bien sur (et j'aimerais bien me tromper :))

Bonne journée à tous

Eric · le 27 mars 2023

Le problème des éditeurs aujourd'hui, c'est qu'ils ne communiquent plus avec les utilisateurs, mais plutôt avec les acheteurs.

Si on dit que la nouvelle version permet par un simple clic droit de convertir une polyligne ou une ellipse en plusieurs segments, l'acheteur ne comprend pas ce que cela signifie et va en conclure que ce n'est pas pour lui.

Par contre si on lui dit que la nouvelle version permet de travailler dans le cloud ou qu'il peut consulter ces plans sur son iPhone ou sur tablette, il va en conclure que c'est intéressant même si dans les faits, cela ne servira pas à grand monde alors qu'il y a plein d'autres choses qui pourraient être pratiques pour l'utilisateur, mais qui ne sont pas vendeur.

Dilack33 · le 27 mars 2023

Salut,

@JVC avec covadis tu peux transformer ellipse, et arc cercle en polyligne, certes c'est deux commandes différentes mais tu peux.

Je rejoins Eric, maintenant ce n'est plus les utilisateur qui on le dernier mots mais les acheteurs qui souvent même trop souvent n'ont aucune technique.

JVC · le 27 mars 2023

Salut à tous les deux,

oui mais ce " petit probleme" ne date vraiment pas d'hier, non ?

Ah bon, il est possible de faire cette manip sur covadis ?, mea culpa je ne savais pas, comment faut il proceder stp ?

Olivier Eckmann · le 27 mars 2023

Bonjour,

Avec Covadis, c'est COV 2D / Topologie / Suppression d'arc de polyligne (on paramètre la corde maxi)

Avec AutoCAD MAP, c'est dans la commande MAPCLEAN, il y a l'outil "Généraliser les polylignes" qui permet de rajouter des sommets en spécifiant la distance maxi entre sommets consécutifs et/ou l'angle de déviation.

Olivier

JVC · le 27 mars 2023

Bonjour,

Oui pour les arcs , mais pas pour les ellipses, non ?

Vincent P. · le 27 mars 2023

Il y a 3 heures, JVC a dit :

je trouve particulièrement désolant, voir plus..., qu'une fonction de ce type, convertir les ellipses en polylignes, qui existe pour les arcs et autres élements, n'existe ni sur AutoCAD classique , ni sur AutoCAD MAP ni sur Covadis, ni avec Express Tools ! et qu'il faille passer par des routines Lisps forts utiles faites par des passionnés

Bonjour,

Bah quand je sélectionne une Spline (ellipse par exemple), Clic Droit => Spline => Convertir en Polyligne
Je suis sous Autocad Map3D 2023 et Covadis 18.0, mais il me semble que ca existait déjà sur des versions antérieur de Autocad classique ...

lecrabe · le 27 mars 2023

Hello

1) CLIC sur une SPline , Bouton droit , Convertir en Polyligne est une Nouveaute d'AutoCAD 2010 !

2) Sinon apres pour convertir une Polyligne 2D contenant des Arcs, ou un Arc ou un Cercle en Polyligne 2D avec N segments

en CONSERVANT les eventuels ODs (Object Data de MAP /CIVIL) et/ou eventuels XDATAs d'AutoCAD,

il faut la superbe routine "ArcToSegMAP" de notre Grand Maitre Gilles ci apres ...

Pour MAP et/ou CIVIL : SVP ne pas oublier de charger AVANT la fameuse routine COPY_OD.lsp !

La Sante, Bonne semaine, Bye, lecrabe

 
;;; 
;;; ARC2SEGMAP par GC (pour Patrice B.) - 2009/03/06 - Special pour MAP & CIVIL 
;;; 
;;; Transforme les Arcs, Cercles et PolyArcs en Polylignes constituees de segments droits 
;;; 
;;; Les XDATAs sont copiees dans les nouveaux objets 
;;; 
;;; Ainsi que les donnees d'objet (OD) de MAP/CIVIL  SI ET SEULEMENT SI 
;;; !!!!!! "COPY_OD.lsp" est PREALABLEMENT CHARGE !!!!!!
;;;
 
(vl-load-com) 
 
(defun c:Arc2SegMAP (/ 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 modifiee (d'apres 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
    "\nSelectionner les objets a 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 (pol2pol elst seg org))
	  (progn
	    (entmake (pol2pol elst seg org))
	    (and
	      ade_odgettables
	      ade_odrecordqty
	      ade_oddelrecord
	      ade_odtabledefn
	      ade_odgetfield
	      ade_odaddrecord
              copy_data
	      (copy_data ent (entlast) nil)
	    )
	  )
	)
	(progn
	  (entmake (arc2pol elst seg org))
	  (and
	    ade_odgettables
	    ade_odrecordqty
	    ade_oddelrecord
	    ade_odtabledefn
	    ade_odgetfield
	    ade_odaddrecord
            copy_data
	    (copy_data ent (entlast) nil)
	  )
	  (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)))
  )
)

JVC · le 27 mars 2023

Hello à tous les deux,

Oui pour les Splines, Arcs, Cercles etc... mais pas pour les Ellipses ....

didier · le 27 mars 2023

Bonjour @JVC

Pour faire ce que tu réclames, je vois deux solutions (simples) et une troisième en LSP (simple aussi).

À partir d'une ellipse existante :

Tu passes la valeur de la variable PELLIPSE à 1
Tu redessines sur l'ellipse existante en t'accrochant aux points "quadrant"
Le résultat est une POLYLIGNE.

Tu décales dans une direction l'ellipse d'une valeur (par exemple 1)
Tu redécales de la même valeur dans l'autre direction
Le résultat est une SPLINE

Pour la troisième solution LSP, je vais sans doute m'en servir d'exemple pour mon site ou mes formations.

À noter qu'il faut remettre PELLIPSE à 0 (zéro) pour obtenir des ELLIPSES mathématiquement exactes.

Amicalement

PS : il eût été judicieux d'ouvrir un nouveau message de forum, ta question n'ayant pas grand-chose à voir avec le message initial,
et de ce fait les réponses risquent de ne pas se retrouver en lançant des recherches sur le forum.

lecrabe · le 27 mars 2023

Hello @JVC

Voici une autre routine "EL2PL" et "PELL" de notre grand Maitre Gilles

-- "EL2PL" convertit en Polyligne une Ellipse ou Arc elliptique

ATTENTION : EL2PL ne traite pas les ODs de MAP/CIVIL NI les XDATAs d'AutoCAD !

NOTE : cela serait SYMPA de l ameliorer a "ce niveau" !? IDEM ce que fait la routine "ArcToSegMAP" ...

-- "PELL" dessine a la volee une Ellipse ou Arc elliptique ... ( J adore PELL ! )

Bye, lecrabe

 
;; 
;; http://cadxp.com/index.php?/topic/25364-ellipses-polylignes-2/page__pid__204830
;; 
;; J'ai trouvé, ici : http://www.paris-lavillette.archi.fr/d1301/cours_web_d1301/cours-lpu/courbes.pdf 
;; la méthode utilisée par AutoCAD pour les approximations d'ellipses 
;; en polylignes (succession d'arcs) quand PELLIPSE = 1 
;; 
;; Voilà donc une nouvelle version (plus rapide) des commandes : 
;; EL2PL : pour convertir une sélection d'ellipses ou arcs elliptiques en polylignes 
;; PELL  : pour dessiner "à la volée" des approximations d'ellipses ou d'arcs elliptiques(polylignes)
;; 
;; Ces commandes appellent la routine EllipseToPolyline qui implémente la méthode sus-citée. 
;; Les objets source sont supprimés ou conservés en fonction de la valeur de la variable DELOBJ. 
;; La routine fonctionne quel que soit le plan de construction de l'ellipse. 
;; La polyligne est créée sur le calque courant avec les propriétés courantes. 
;; Pour une compatibilité avec les version < 2007, j'ai évité d'utiliser vla-put-Coordinates.
;; 
;; !!! ATTENTION : les ODs de MAP/CIVIL et/ou les XDATAs d'AutOCAD ne sont pas conserves !!!
;; 

;; 
;; EllipseToPolyline (gile)
;; Retourne une polyline (vla-object) qui est une approximation de l'ellipse (ou de l'arc elliptique)
;; L'ellipse source est conservée ou supprimée en fonction de la valeur de DELOBJ
;;
;; Argument : une ellipse (vla-object)
;; 

(defun EllipseToPolyline (el    /  doc   cl    norm  cen   elv   pt0   pt1   pt2
                          pt3   pt4   ac0   ac4   a04   a02   a24   bsc1  bsc2
                          bsc3  bsc4  plst  blst  spt   spa   fspa  srat  ept
                          epa   fepa  erat  n
                         )

  (vl-load-com)

  (setq doc (vla-get-ActiveDocument (vlax-get-acad-object))
        spc (if (= 1 (getvar 'cvport))
              (vla-get-PaperSpace doc)
              (vla-get-ModelSpace doc)
            )
        cl   (and (= (vla-get-StartAngle el) 0.0)
                  (= (vla-get-EndAngle el) (* 2 pi))
             )
        norm (vlax-get el 'Normal)
        cen  (trans (vlax-get el 'Center) 0 norm)
        elv  (caddr cen)
        cen  (3dTo2dPt cen)
        pt0  (mapcar '+ (trans (vlax-get el 'MajorAxis) 0 norm) cen)
        ac0  (angle cen pt0)
        pt4  (mapcar '+ cen (trans (vlax-get el 'MinorAxis) 0 norm))
        pt2  (3dTo2dPt (trans (vlax-curve-getPointAtparam el (/ pi 4.)) 0 norm))
        ac4  (angle cen pt4)
        a04  (angle pt0 pt4)
        a02  (angle pt0 pt2)
        a24  (angle pt2 pt4)
        bsc1 (/ (ang<2pi (- a02 ac4)) 2.)
        bsc2 (/ (ang<2pi (- a04 a02)) 2.)
        bsc3 (/ (ang<2pi (- a24 a04)) 2.)
        bsc4 (/ (ang<2pi (- (+ ac0 pi) a24)) 2.)
        pt1  (inters pt0
                     (polar pt0 (+ ac0 (/ pi 2.) bsc1) 1.)
                     pt2
                     (polar pt2 (+ a02 bsc2) 1.)
                     nil
             )
        pt3  (inters pt2
                     (polar pt2 (+ a04 bsc3) 1.)
                     pt4
                     (polar pt4 (+ a24 bsc4) 1.)
                     nil
             )
        plst (list pt4 pt3 pt2 pt1 pt0)
        blst (mapcar '(lambda (B) (tan (/ b 2.)))
                     (list bsc4 bsc3 bsc2 bsc1)
             )
  )
  (repeat 2
    (foreach b blst
      (setq blst (cons b blst))
    )
  )
  (foreach p (cdr plst)
    (setq ang  (angle cen p)
          plst (cons
                 (polar cen (+ ang (* 2 (- ac4 ang))) (distance cen p))
                 plst
               )
    )
  )
  (foreach p (cdr plst)
    (setq ang  (angle cen p)
          plst (cons
                 (polar cen (+ ang (* 2 (- ac0 ang))) (distance cen p))
                 plst
               )
    )
  )
  (setq pl
         (vlax-invoke
           spc
           'AddLightWeightPolyline
           (apply 'append
                  (setq plst
                         (reverse (if cl
                                    (cdr plst)
                                    plst
                                  )
                         )
                  )
           )
         )
  )
  (vlax-put pl 'Normal norm)
  (vla-put-Elevation pl elv)
  (mapcar '(lambda (i v) (vla-SetBulge pl i v))
          '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
          blst
  )
  (if cl
    (vla-put-Closed pl :vlax-true)
    (progn
      (setq spt  (vlax-curve-getClosestPointTo pl (vlax-get el 'Startpoint))
            spa  (vlax-curve-getParamAtPoint pl spt)
            fspa (fix spa)
            ept  (vlax-curve-getClosestPointTo pl (vlax-get el 'Endpoint))
            epa  (vlax-curve-getParamAtPoint pl ept)
            fepa (fix epa)
            n    0
      )
      (cond
        ((equal spt (trans pt0 norm 0) 1e-9)
         (if (= epa fepa)
           (setq plst (sublist plst 0 (1+ fepa))
                 blst (sublist blst 0 (1+ fepa))
           )
           (setq erat (/ (- (vlax-curve-getDistAtParam pl epa)
                       (vlax-curve-getDistAtParam pl fepa)
                    )
                    (- (vlax-curve-getDistAtParam pl (1+ fepa))
                       (vlax-curve-getDistAtParam pl fepa)
                    )
                 )
                 plst (append (sublist plst 0 (1+ fepa))
                              (list (3dTo2dPt (trans ept 0 norm)))
                      )
                 blst (append (sublist blst 0 (1+ fepa))
                              (list (k*bulge (nth fepa blst) erat))
                      )
           )
         )
        )
        ((equal ept (trans pt0 norm 0) 1e-9)
         (if (= spa fspa)
           (setq plst (sublist plst fspa nil)
                 blst (sublist blst fspa nil)
           )
           (setq srat (/ (- (vlax-curve-getDistAtParam pl (1+ fspa))
                            (vlax-curve-getDistAtParam pl spa)
                         )
                         (- (vlax-curve-getDistAtParam pl (1+ fspa))
                            (vlax-curve-getDistAtParam pl fspa)
                         )
                      )
                 plst (cons (3dTo2dPt (trans spt 0 norm))
                            (sublist plst (1+ fspa) nil)
                      )
                 blst (cons (k*bulge (nth fspa blst) srat)
                            (sublist blst (1+ fspa) nil)
                      )
           )
         )
        )
        (T
         (setq srat (/ (- (vlax-curve-getDistAtParam pl (1+ fspa))
                            (vlax-curve-getDistAtParam pl spa)
                         )
                         (- (vlax-curve-getDistAtParam pl (1+ fspa))
                            (vlax-curve-getDistAtParam pl fspa)
                         )
                      )
               erat (/ (- (vlax-curve-getDistAtParam pl epa)
                       (vlax-curve-getDistAtParam pl fepa)
                    )
                    (- (vlax-curve-getDistAtParam pl (1+ fepa))
                       (vlax-curve-getDistAtParam pl fepa)
                    )
                 )
               )
         (if (< epa spa)
           (setq plst (append
                        (if (= spa fspa)
                          (sublist plst fspa nil)
                          (cons (3dTo2dPt (trans spt 0 norm))
                                (sublist plst (1+ fspa) nil)
                          )
                        )
                        (cdr (sublist plst 0 (1+ fepa)))
                        (if (/= epa fepa)
                          (list (3dTo2dPt (trans ept 0 norm)))
                        )
                      )
                 blst (append
                        (if (= spa fspa)
                          (sublist blst fspa nil)
                          (cons 
                            (k*bulge (nth fspa blst) srat)
                                (sublist blst (1+ fspa) nil)
                          )
                        )
                        (sublist blst 0 fepa)
                        (if (= epa fepa)
                          (list (nth fepa blst))
                          (list (k*bulge (nth fepa blst) erat))
                        )
                      )
           )
           (setq plst (append
                        (if (= spa fspa)
                          (sublist plst fspa (1+ (- fepa fspa)))
                          (cons (3dTo2dPt (trans spt 0 norm))
                                (sublist plst (1+ fspa) (- fepa fspa))
                          )
                        )
                        (list (3dTo2dPt (trans ept 0 norm)))
                      )
                 blst (append
                        (if (= spa fspa)
                          (sublist blst fspa (- fepa fspa))
                          (cons
                            (k*bulge (nth fspa blst) srat)
                                (sublist blst (1+ fspa) (- fepa fspa))
                          )
                        )
                        (if (= epa fepa)
                          (list (nth fepa blst))
                          (list (k*bulge (nth fepa blst) erat))
                        )
                      )
           )
         )
        )
      )
      (vla-delete pl)
      (setq pl (vlax-invoke spc 'AddLightWeightPolyline (apply 'append plst)))
      (vlax-put pl 'Normal norm)
      (vla-put-Elevation pl elv)
      (foreach b blst
        (vla-SetBulge pl n B)
        (setq n (1+ n))
      )
    )
  )
  (or (zerop (getvar 'delobj)) (vla-delete el))
  pl
)
 

;; 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)))
  )
)
 

;; 3dTo2dPt
;; Retourne le point 2d (x y) d'un point 3d (x y z)
(defun 3dTo2dPt (pt) (list (car pt) (cadr pt)))
 

;; Tan
;; Retourne la tangent de l'angle
(defun tan (a) (/ (sin a) (cos a)))
 

;;; SUBLIST Retourne une sous-liste
;;;
;;; Arguments
;;; lst : une liste
;;; start : l'index de départ de la sous liste (premier élément = 0)
;;; leng : la longueur (nombre d'éléments) de la sous-liste (ou nil)
(defun sublist (lst start leng / n r)
  (if (or (not leng) (< (- (length lst) start) leng))
    (setq leng (- (length lst) start))
  )
  (setq n (+ start leng))
  (while (< start n)
    (setq r (cons (nth (setq n (1- n)) lst) r))
  )
)
 

;; K*BULGE
;; Retourne le bulge proportionnel au bulge de référence
;; Arguments :
;; b : le bulge
;; k : le rapport de proportion (entre les angles ou les longueurs d'arcs)
(defun k*bulge (b k / a)
  (setq a (atan B))
  (/ (sin (* k a)) (cos (* k a)))
)
 


;; 
;; EL2PL (GC) 
;; Convertit ellipses et arcs elliptiques en polylignes
;; Les objets source sont conservés si la variable DELOBJ = 0,
;; supprimés sinon.
;; 

(defun c:el2pl (/ *error* fra acdoc ss)
  (vl-load-com)
  (defun *error* (msg)
    (if (and (/= msg "Fonction annulée")
             (/= msg "Function cancelled")
        )
      (princ (strcat (if (= "FRA" (getvar 'locale))
                       "\nErreur: "
                       "\Error: "
                     )
                     msg
             )
      )
    )
    (vla-endUndoMark acdoc)
    (princ)
  )
  (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object)))
  (if (ssget '((0 . "ELLIPSE")))
    (progn
      (vla-StartUndoMark acdoc)
      (vlax-for e (setq ss (vla-get-ActiveSelectionSet acdoc))
        (EllipseToPolyline e)
      )
      (vla-delete ss)
      (vla-EndUndoMark acdoc)
    )
  )
  (princ)
)
 

;; 
;; PELL (GC)
;; Dessine "à la volée" une approximation d'ellipse ou arc elliptique (polyligne) 
;; 

(defun c:pell (/ *error* ec pe do old ent)
  (vl-load-com)
  (defun *error* (msg)
    (if (and msg
             (/= msg "Fonction annulée")
             (/= msg "Function cancelled")
        )
      (princ (strcat (if (= "FRA" (getvar 'locale))
                       "\nErreur: "
                       "\Error: "
                     )
                     msg
             )
      )
    )
    (setvar 'cmdecho ec)
    (setvar 'pellipse pe)
    (setvar 'delobj do)
    (princ)
  )
  (setq ec  (getvar 'cmdecho)
        pe  (getvar 'pellipse)
        do  (getvar 'delobj)
        old (entlast)
  )
  (setvar 'cmdecho 1)
  (setvar 'pellipse 0)
  (command "_.ellipse")
  (while (/= 0 (getvar "cmdactive"))
    (command pause)
  )
  (if (not (eq old (setq ent (entlast))))
    (progn
      (setvar 'delobj 1)
    (EllipseToPolyline (vlax-ename->vla-object ent))
    )
  )
  (*error* nil)
)

Olivier Eckmann · le 27 mars 2023

Pour les Ellipses, enregistrer en DXF12, fermer puis réouvrir => polyligne 3D à traiter ensuite sous MapCLEAN selon besoin.

Olivier

Eric · le 27 mars 2023

Je viens de tomber sur la manière officielle de convertir des ellipses en polylignes.

https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Change-true-ellipse-into-polyline.html

Je sais que le 1er avril n'est pas loin, mais là, c'est limite une blague 😜

JVC · le 27 mars 2023

il y a 45 minutes, Eric a dit :

Je viens de tomber sur la manière officielle de convertir des ellipses en polylignes.

https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Change-true-ellipse-into-polyline.html

Je sais que le 1er avril n'est pas loin, mais là, c'est limite une blague 😜

Oui je l'avais vu , à s'arracher les cheveux...😁 Pas tres direct, ni fluide mais ca semble être la méthode "officielle" d'Autocad ... et Covadis ne semble pas faire mieux non plus.

Heureusement qu'il y a les fameuses routines LISP du forum !

En tout cas, merci de vos reponses

didier · le 27 mars 2023

Bonjour @Eric

Ben oui ! Il n'y a pas de commande native, ce que regrette @JVC

Entre ce que j'ai proposé et la "version" Autodesk; il n'y a que l'imagination de l'humain qui est devant le clavier.
Franchement, repasser l'ellipse avec PELLIPSE à 1 n'est pas insurmontable, si ?
S'il y a vraiment une grande quantité d'ellipses à traiter, je peux faire un LSP de traitement automatique.

À suivre...

Amicalement

Connexion

résolu Transformer succession d'arc d'une même polyligne en ligne brisée paramétrable

Messages recommandés

Jaypee

bonuscad

Jaypee

Eric

Jaypee

Eric

didier

Jaypee

Jaypee

didier

JVC

Eric

Dilack33

JVC

Olivier Eckmann

JVC

Vincent P.

lecrabe

JVC

didier

lecrabe

Olivier Eckmann

Eric

JVC

didier

Forums

Naviguer

Activité

Information importante