Faire un "A plat" d'une coupe.

[DenisHen]

Bonjour à la communauté.
Un ancien collègue m'a demandé si j'avais dans mes tiroirs une macro pour mettre à plat des coupes, et je n'ai rien là-dessus, mais il m'explique :
Il travaille maintenant pour une société de métallurgie et ses coupes représentes des profils avant pliages (l'essentiel de son travail).
La matière "première" est soit un rouleau d'aluminium (ou autre métal) soit des plaques.
Il dessine le profil avec une polyligne qui comporte des longueurs, des angles, des rayons...
Ce qu'il aimerait, c'est le développé du profil, une seule donnée est absente du développé : la largeur de la matière.

Dans l'image suivante (et le DWG joint), en bas : le profil, en haut : le développé.

Pour principe, son sens de lecture commence de droite à gauche et de bas en haut.
Donc, dans son sens de lecture, tout ce qui va à droite, est de signe positif, si non, de signe négatif.
Un peu comme si le SCU avait la même origine que le premier point et le sens des Y serait la direction du premier segment.

Dans cet exemple, le rayon est positif, mais s'il allait vers le haut, il serait négatif.
Je ne sais absolument pas utiliser les polylignes pour en connaitre leurs données, donc : 
Si quelqu'un aurait un truc dans ce genre, ou pas très éloigné, je pourrais peut-être retoucher le code pour faire ce qu'il me demande.

Par contre, je ne sais pas ce profil peut commencer par un rayon ou s'il peut finir par un rayon.

Bien à toi la communauté...

Denis...
 

MiseAPlat.dwg

[Luna]

Coucou @DenisHen,

Je ne maîtrise pas encore bien les créations d'objets donc je n'ai pas intégré les cotations et corrigé la position du texte, mais la forme est tracée en tous cas :

(defun c:CP2DV (/ foo polymake textmake name lst pt ep osm a p1 p2 p3 p4)
  (defun foo (name / bulge->radius entlist blst i d r lst)
    (defun bulge->radius (pt1 b pt2 / c s r)
      (setq
        c (distance pt1 pt2)
        s (* (/ c 2.0) (* -1 b))
        r (/ (+ (expt (/ c 2.0) 2) (expt s 2)) (* s 2.0))
      )
    )
    
    (and
      (setq entlist (entget name))
      (= "LWPOLYLINE" (cdr (assoc 0 entlist)))
      (setq blst (reverse (vl-remove-if-not '(lambda (x) (= (car x) 42)) entlist)))
      (setq blst (cdr (mapcar 'cdr blst)))
      (repeat (setq i (fix (vlax-curve-getEndParam name)))
        (setq
          d (vlax-curve-getDistAtParam name i)
          r
            (if (or (= i (1+ (fix (vlax-curve-getEndParam name)))) (= 0.0 (car blst)))
              0.0
              (bulge->radius (vlax-curve-getPointAtParam name i) (car blst) (vlax-curve-getPointAtParam name (1- i)))
            )
          i (1- i)
          blst (cdr blst)
          lst (cons (list d r) lst)
        )
      )
    )
    lst
  )
  (defun polymake (plist c)
    (entmakex
      (append
        (vl-remove
          nil
          (list
            '(0 . "LWPOLYLINE")
            '(100 . "AcDbEntity")
            '(100 . "AcDbPolyline")
            (cons 90 (length plist))
            (if c '(70 . 1))
          )
        )
        (mapcar '(lambda (p) (cons 10 p)) plist)
      )
    )
  )
  (defun textmake (pt str / txt)
    (setq txt
      (entmakex
        (list
          '(0 . "TEXT")
          '(100 . "AcDbEntity")
          '(100 . "AcDbText")
          (cons 10 pt)
          (cons 1 str)
          (cons 40 (getvar 'textsize))
          '(72 . 4)
          '(73 . 2)
        )
      )
    )
    (setq txt (vlax-ename->vla-object txt))
    (vla-move txt (vlax-3D-point (vlax-get txt 'InsertionPoint)) (vlax-3D-point pt))
  )

  (and
    (setq name (car (entsel "\nSélectionner une coupe : ")))
    (setq lst (foo name))
    (setq pt (getpoint "\nChoisir un point d'insertion : "))
    (setq ep (getdist pt "\nDéfinir une épaisseur : "))
    (setq osm (getvar 'osmode))
    (setvar 'osmode 0)
    (setq a (/ pi 2.))
    (setq p0 (polar pt a ep) p1 pt p2 p0)
    (mapcar
      '(lambda (x / d r)
        (setq
          d (car x)
          r (cadr x)
          p3 (polar p0 0.0 d)
          p4 (polar pt 0.0 d)
        )
        (polymake (list p1 p2 p3 p4) T)
        (if (not (zerop r))
          (progn
            (polymake (list p1 p3) nil)
            (polymake (list p2 p4) nil)
            (textmake (mapcar '(lambda (a b) (/ (+ a b) 2.)) p1 p3) (strcat "R: " (rtos r 2 2)))
          )
        )
        (setq
          p1 p4
          p2 p3
        )
       )
      lst
    )
    (setvar 'osmode osm)
  )
  (princ)
)

Désolée pour le rendu un peu brouillon >w<

Bisous,
Luna

[didier]

Bonjour @Luna

Je viens de m'y mettre et je vois que tu viens de répondre pile dans les clous, bravo et merci.
Du coup, je retourne tranquillement sur ce qui me préoccupe en ce moment, @DenisHen a d'ores et déjà sa solution.

Ce que j'ai commencé ressemble tellement à ta solution proposée qui fonctionne que je ne vois pas l'intérêt de poster.

Je souhaite que tout aille pour le mieux chez toi.

Amicalement
 

[DenisHen]

Oh la Vache ! ! !

@Luna : c'est impressionnant Que dire de plus, parfait ?
Mais mon problème, car il en réside un, c'est que ton code est beaucoup trop parfait pour moi...
Je ne pourrais jamais l'arranger pour les besoins de mon ami...
Mais quelle perfection, et dans la finalité, et dans le code, son écriture, sa syntaxe...
Tu m'impressionnes de jours en jours...
Plus tu réponds, plus je suis dénué devant tant de logique. Ton travail est toujours impeccable... C'est impressionnant (et énervant 😉 )...
Mais je vais tout de même tenter de le comprendre...
Je suis très loin d'avoir ton niveau... Mais qui ne tente rien...
@didier : je me doutais bien que tu allais être dans le coin... Et comme toi, je suis sans bras devant Luna... Qui est d'une aide tellement précieuse...

Bon, je regarde le code de Maîtresse Luna, dont je n'en comprends pas le quart, pour l'instant...
Mais je n'ai pas dis mon dernier mot...
Encore merci à vous...
Et heureusement que Maître (gile) n'a pas répondu, il aurait fait ça en 10 ou 15 lignes, et là, j'étais définitivement perdu à jamais ! ! !

Encore un grand merci à vous... Maintenant, j'ai plusieurs semaines pour comprendre le code...

Toute ma cordialité à la communauté.

Denis...

[didier]

Bonjour @DenisHen

Loin de moi l'idée de faire du mauvais esprit, mais franchement, depuis le temps que tu poses des questions et qu'on te répond, tu aurais dû être capable de sortir ces lignes.
Ce n'est qu'une question de logique que tu n'as pas vraiment cherchée. C'est tellement plus facile de poser la question.
C'est bien de féliciter ceux qui réussissent et qui répondent, rejoindre leur club est encore plus valorisant.

Amicalement
 

 

[Luna]

C'est très gentil mais franchement le rendu est loin d'être impeccable (en tous cas à mes yeux).
Pour la compréhension tu peux t'aider de ce site sur lequel je me suis moi-même appuyé pour la théorie mathématique par rapport au fameux code DXF 42 des polylignes (pour la prise en compte des rayons demandée par ton collègue) : https://www.afralisp.net/autolisp/tutorials/polyline-bulges-part-1.php
Pour le reste du programme, c'est de la géométrie à base de (polar) et pour la logique c'est uniquement basé sur la présence ou non d'arcs au sein de la polyligne donc il faut forcément prendre en compte ces "bulges" et donc étudier la polyligne sous forme de segments, et non sous forme de points. C'est pour cela que la fonction (foo), désolée pour le nom je n'avais pas d'inspi, permet de donner la distance d'un point par rapport au premier sommet et de donner l'info requise en cas de code DXF 42 différent de 0.0, soit le rayon de l'arc ainsi que son signe.

Le site est en anglais mais vraiment passionnant ! Et pour d'autres questions, surtout n'hésite pas, c'est toujours un plaisir d'aider :3

Bisous,
Luna

[DenisHen]

@didier : je suis désolé de te décevoir didier, (même après avoir progressé depuis le rien que je ne connaissais pas, depuis le début des années 90), en tant que débutant, puis du DIESEL, puis le Lisp et ensuite le DCL, j'ai toujours plus ou moins réussi à faire ce que je voulais : n'est-ce pas la, la finalité du truc ?
Mais, je demande souvent à ceux qui savent comment ils font... Je prends toujours connaissance des méthodes de mes maîtres (dont tu fais parti, et oui), avant de me faire ce que j'aimerais, désolé si c'est une mauvaise idée... Je pensais que c'étais une bonne méthode, un peu comme celle des compagnons...

Je comprends ton agacement (légitime), mais si je ne peut pas poser une question de Lisp ici... Où le ferais-je ?

Je ne suis pas fort dans la créations de codes (je l'ai maintes fois prouvé), j'ai des milliards d'idées de programmes, mais si je savais comment les développer, je roulerais en Bagnole de luxe...
Ton site (didier) est un support incontournable, que je ne peut oublier, je ne fais rien sans le consulter. Mais mon cerveau doit être limité, ou pas, je n'en sais rien, mais nous ne sommes pas tous égaux devant un code...
Je pensais que tu le savais, que tu t'en doutais, ou que tu le comprendrais...
Désolé de ne pas être à la hauteur... Mais je cherche à l'atteindre... 😉

@Luna : un super grand merci pour ce code... Je le lis dans tous les sens, et il reste une des énigmatiques énigmes avec laquelle j'ai toujours eu du mal (et je sais que je ne suis pas le seul) : les lambda et les mapcar...
Surtout avec ton : 
"(reverse (vl-remove-if-not '(lambda (x) (= (car x) 42)) entlist))"
Les lambda (comme les mapcar) resteront toujours pour moi un des grand secret inaccessible du Lips, à mes yeux...

En tous cas, merci à vous deux (comme aux autres membres) pour tout ce que vous avez fait, faites et feront probablement pour nous...

Très cordialement; amicalement, et comme pourrait dire "Maîtresse Luna" : Bisous, Chat va bien ce passer...

[didier]

Bonjour @DenisHen

Si tu fais ça pour rouler en voiture de luxe, tu te fourvoies.
Il faut le faire par plaisir, comme résoudre un bel exo de géométrie, ou une grille de mots croisés du défunt Laclos qui m'a fait passer bien des nuits blanches, mais aussi des sentiments de réussite absolue.
Dans la même veine, je me suis créé récemment un challenge personnel que je viens de résoudre en LSP et je suis fier de moi. Sans doute lentement, car je travaille lentement, mais ça fonctionne et je biche bien plus que si j'avais dû demander de l'aide.

Ce que je veux sire, c'est que si j'y arrive, tu dois y arriver, nous sommes tous (ceux que tu cites) partis du zéro absolu, le reste, c'est du travail.
@Luna ne déroge pas à la règle, son ascension est le fruit du travail, aujourd'hui, elle est une référence par ses travaux. Je la salue respectueusement.

(Traduisons en langage naturel : reverse (vl-remove-if-not '(lambda (x) (= (car x) 42)) entlist))

Retourner la liste de tous les codes qui comment par 42.
De droite à gauche (fonctionnement du lisp) entlist est la liste obtenue par entget, si le code est 42 le prendre, et à la fin, on renverse la liste. Et on a la liste de tous les segments courbes (bulge). Est-ce plus clair ?

Amicalement

[(gile)]

Il y a 20 heures, DenisHen a dit :

Les lambda (comme les mapcar) resteront toujours pour moi un des grand secret inaccessible du Lips, à mes yeux...

C'est assez général chez tous le débutants, parce qu'on a tous débuté en prenant les choses à l'envers : du particulier vers le général (le fondamental, les bases).

Quand on commence avec AutoLISP, on veut commander AutoCAD, donc les premiers codes qu'on écrit commencent par (defun c:... ). Autrement dit par une définition de fonction d'un type (très) particulier. Particulier parce qu'on peut appeler cette fonction comme une commande AutoCAD, donc hors contexte AutoLISP, mais surtout parce qu'il s'agit d'une fonction qui ne prend aucun argument et dont on ne soucie pas de la valeur de retour (généralement même, on masque cette valeur avec un (princ)).

Les premières interrogations viennent souvent les premières fois qu'on rencontre des définitions de fonction dont le nom n'est pas c:... et qui prennent des arguments, des fonctions classiques, quoi !... Qui, comme en mathématiques, servent à renvoyer une valeur en fonctions des arguments/paramètres qui leur sont passés. On se rend compte alors qu'il est possible de définir ses propres fonctions (pour étendre le langage ou mieux organiser son code) et les appeler comme on le fait avec les fonctions natives.
Là on commence à s'approcher des bases (par lesquelles il eut fallut commencer) : les définitions de fonction et les applications de fonction.

Définition d'une fonction nommée sqr qui prend en argument un nombre et renvoie le carré de ce nombre:

(defun sqr (x) (* x x))

Application de la fonction précédemment définie au nombre 4:

(sqr 4)

Une définition de fonction "nommée" a toujours la même structure : (defun symbol ([arg1 ...] [/ var1 ...]) body) où symbol est le nom de la fonction (sqr dans l'exemple), ([arg1 ...] [/ var1 ...]) la liste des éventuels arguments et variables locales ((x) dans l'exemple) et body est le corps de la fonction ((* x x) dans l'exemple).

Mais une fonction LISP n'est pas nécessairement "nommée", elle peut être "anonyme", c'est ce qu'on appelle une fonction lambda.
Une fonction lambda a exactement la même structure qu'une fonction "nommée" sans le "nom" (symbol) et en appelant lambda à la place de defun :
(lambda ([arg1 ...] [/ var1 ...]) body)

(lambda (x) (* x x))

Une fonction lambda est une définition de fonction, pas une application de fonction. Comme elle est "anonyme", pour l'utiliser dans une application de fonction, on utilise directement la définition de fonction, par exemple, on remplace sqr dans (sqr 4) par (lambda (x) (* x x)).

((lambda (x) (* x x)) 4)

En résumé, la fonction defun sert à lier une définition de fonction à un symbole (comme setq sert à lier le résultat de l'évaluation d'une expression à un symbole), mais on peut, avec lambda, utiliser directement une définition de fonction sans la lier à un symbole (comme on peut utiliser directement le résultat de l'évaluation d'une expression sans le lier à un symbole).
En pratique, quand une définition de fonction doit servir plusieurs fois, on préfère l'affecter à une symbole en utilisant defun mais si la définition ne sert qu'une seule fois, une fonction lambda permet d'avoir la définition à l'endroit même du code où elle est appelée.

 

[(gile)]

(... suite)

Les fonctions lambda sont largement utilisées avec les fonctions dite "d'ordre supérieur".
Les fonctions d'ordre supérieur sont des fonctions qui prennent en argument une (ou des) fonction(s) et/ou qui renvoient une fonction.

Avec AutoLISP plusieurs fonctions natives sont d'ordre supérieur : apply, mapcar, vl-sort, vl-remove-if, etc.

Dans le cas présent, la fonction lambda : lambda (x) (= (car x) 42)), utilisée avec vl-remove-if-not, pourrait être remplacée par une fonction "nommée".

(defun EstUnGroupe42 (x) (= (car x) 42))

(reverse (vl-remove-if-not 'EstUnGroupe42 entlist))

[DenisHen]

Bonjour à la communauté.
Désolé pour le temps de réponse, une période difficile pour nos foies ! ! !
@didier : on en avait déjà parlé il me semble, quand je parle d'idée et d'en profiter pour rouler en voiture de luxe, c'est bien évident que rouler en Porche ne m'intéresse absolument pas, ma petite Clio me convient très bien...
Et Ray Tomlinson est bien la symbolique du truc (inventeur/donateur), on ne dépose pas un brevet dans un domaine inconnu et "sans avenir" dans les états d'esprits de l'époque...
Pour ma part, j'avais déjà pensé au "Drive", au milieu des années 90... Au début d'internet, je me souviens de mon modem (un USRobotics, à 14.400 bauds, une révolution à l'époque).  Un petit logiciel fait sous VB6 qui permettrait de faire sa liste de course (avec mise à jour des pris via le NET), l'imprimer et faire ses courses avec...
Puis, quelques mois plus tard, faire une commande livrable (j'habitais Paris à l'époque, j'allais faire mes courses et je passais à une caisse "spéciale" qui m'emballait le contenu du caddie et me livrait peu de temps après... Quelques mois après, j'avais eu l'idée de ce qu'on nomme maintenant le "Drive"...
Quand je dis, si j'"avais su développer à l'époque" (comme un site WEB), c'est que mon idée était forcément bonne, car elle existe bien maintenant, et partout (mais je ne pensais pas créer Amazon 😉 )... Mais sans connaissance, je ne pouvais pas me rendre chez les grands distributeurs (Auchan, Leclerc...) pour leur dire : "Les gars, j'ai une idée qui va vous faire gagner des millions !" et ne leur présenter que l'idée...

@(gile) : je comprends tes explications sur Lambda de plus en plus vite, peut-être suis-je de plus en plus rapide 😄 !
Là où j'ai tout de suite pigé le truc, c'est la différence (que tu as très bien souligné) entre :
(defun sqr (x) (* x x)) et (lambda (x) (* x x)) 
Tes explications toujours très concises, et c'est, je pense, ce qui me perd parfois.
Et tu fais bien de parler de Mapcar, car elle est très souvent associée à Lambda...
Par contre, avec :
(defun EstUnGroupe42 (x) (= (car x) 42))
(reverse (vl-remove-if-not 'EstUnGroupe42 entlist))
Tu m'as perdu 🤕, mais je pense que c'est fait pour supprimer tout ce qui ne fait pas parti du groupe 42, et le reverse, c'est pour trier la liste par ordre alphanumérique ? ?

@Luna : je n'en démord pas, tu es d'une aide très précieuse, et très pédagogue. Tu es la digne héritière des grands de ce site, qui ont professés des années et qui le font encore (je pense aussi aux grands qui ne sont malheureusement plus là), et pour répondre à didier, tout le monde n'apprends pas à la même vitesse, et je fais parti de ceux qui restent en première 😅 ...

En tous cas, un grand, un énorme, un immense merci à vous tous...

Denis...

[(gile)]

Il y a 3 heures, DenisHen a dit :

Par contre, avec :
(defun EstUnGroupe42 (x) (= (car x) 42))
(reverse (vl-remove-if-not 'EstUnGroupe42 entlist))
Tu m'as perdu 🤕, mais je pense que c'est fait pour supprimer tout ce qui ne fait pas parti du groupe 42, et le reverse, c'est pour trier la liste par ordre alphanumérique ? ?

Non, reverse, c'est pour inverser la liste. Plutôt que d'essayer de deviner, consulte l'aide.

[DenisHen]

Oui, tu as une fois de plus raison.
Je pense avoir confondu avec vl-sort.

Du coup pourquoi inverser cette liste ?

Mais je ne te demande pas forcement une réponse, je vais la chercher, quelque part, et je la trouverais peut-être.
Et même si je ne trouve pas la réponse, j'aurais cherché... 😉

Encore merci...

[rebcao]

Bonjour à Toutes et à Tous,

Oui, c'est du beau boulot.

Mais je remarque que dans les très nombreux sources LISPs que je voie souvent passer, il manque toujours un petit quelque chose !  🙂

En effet, j'ai pris l'habitude de terminer tous mes LISPs par un petit ou plusieurs PROMPT pour indiquer la/les commandes à taper, exemple :

      (prompt "\nTaper   CP2DV   pour développer une coupe...")

      (prompt "\nTaper   XYZ...   pour...")

Christian

[DenisHen]

Bonjour Christian.
Effectivement, très judicieuse remarque.
Je vais adopter cette habitude...
Mille Mercis !
Denis...