Equivalent Lisp en VB

steelbe · le 29 juillet 2012

Boujour à tous,

J'espère que je ne vous derange pas trop.

Cela sera l'un de mes dernier sujet.

Y aurait-il une ame charitable pour me traduire se code Lisp en Visual Basic en tant que sous routine si et seulement si cela est possible.

(if ddiag1
 (progn

(setq bpt (getpoint "\nGet base point of section 3D : "))
(setq S1 (polar bpt Pi (/ b 2)))
(setq S2 (polar S1 (/ Pi 2) tf))
(setq S3 (polar S2 0 (- (/ (- b tw) 2) r)))
(Setq PP1 (polar S3 0 r))
(setq S4 (polar PP1 (/ Pi 2) r))
(Setq S5 (polar S4 (/ Pi 2) (- h (* (+ tf r) 2))))
(setq S6 (polar S3 (/ Pi 2) (- h (* tf 2))))
(Setq S7 (list (car S1) (cadr S6)))
(Setq S8 (list (car S1) (+ (cadr S1) h)))
(setq S9 (polar S8 0 B))
(Setq S10 (list (car S9) (cadr S7)))
(Setq S11 (list (+ (car S6) (+ (* r 2) tw)) (cadr S10)))
(Setq S12 (polar S5 0 tw))
(Setq S13 (polar S4 0 tw))
(Setq S14 (list (+ (car S3) (+ (* r 2) tw)) (cadr S2)))
(Setq S15 (list (car S10) (cadr S14)))
(setq S16 (list (car S15) (cadr S1)))




(Command "_.pline"     S1     S2     S3	    "ARC"  S4	  "LI"	 S5
 "ARC"	S6     "LI"   S7     S8	    S9	   S10	  S11	 "ARC"
 S12	"LI"   S13    "ARC"  S14    "LI"   S15	  S16	 S1
 ""
)




;;Creation of a 3DSolid

(Command "_.extrude" "D" "" lgd)
)
 )

J'ai beaucoup entendu parlé de VB et j'essais de mettre le pied à l'étrier

Merci d'avance à tous ;)

(gile) · le 30 juillet 2012

Salut,

Tout d'abord, de quel VB parles-tu : VBA ou VB.NET ?

Dans les deux cas, ce que tu demandes est possible, mais...

S'il s'agit de VBA, je dois dire que je ne comprends l'intérêt de migrer un code écrit en AutoLISP dans un langage dont Autodesk nous promet l'abandon depuis la version 2010 (et qui fonctionne très mal sur les systèmes 32 bits). AutoLISP devrait continuer à être supporté par AutoCAD pendant encore de très nombreuses années.

Si c'est de .NET dont tu veux parler, il semblerait que l'avenir soit plus prometteur pour cette plateforme, mais il s'agit là de programmation beaucoup plus exigeante qu'avec AutoLISP, et sans vouloir te décourager, à lire ton code LISP il me semble que tu as encore de la marge et des progrès à faire avant d'atteindre les limites du LISP et d'avoir besoin de recourir à une technologie plus puissante.

Quand à la traduction que tu demandes, j'aurais pu te la faire en VB.NET (même si je préfère C#) si le code LISP était correctement structuré (quid des variables b, tf, tw, r, h, lgd ?).

steelbe · le 30 juillet 2012

Salut,

Il est vrai que je n'ai pas encore exploiter puissance de la programmation lisp

car beaucoup plus peu être fait avec ce langage de programmation.

J'ai décidé d'apprendre Visual Basic pas VBA pour réaliser ce programme.

Pour la petit histoire, j'ai récupéré un code lisp sur internet (lisp synchronisation).

Quand l'utilisateur selectionne un élement de la premiere liste la deuxieme se mait à jour.

Tres intéressant comme concept je n'y avais pas pensé.

J'aurais rassemblé cinq codes lisp en un via une seul boite de dialogue d'ou l'un des sujets

que j'avais posté precedement; pour comprendre comment faire pour que le programme puisse comprendre

comment exécuter le code ;;;action_tile ..............

N'obtenant pas de réponse j'ai décidé de me lancer dans l'apprentissage de VB qui pour moi ne serais pas plus facile à apprendre mais me permettra de réaliser se programme.

1) creation d'une boite de dialogue list_box, combo_box (récuperant la valeur h pour certain b pour d'autre dans

la base de données, text_box (pour definir une dimension, text_box en (readonly pour la lecture de certain données), image et bouton (ok cancel)(-->fait)

2) création d'une base de données -->(fait)

3) création de trois sous-routines -->(en cours de creation)d'ou se sujet

4) Manipulation de conditions (selon la selection de la list_box certain combo_box seront grisés)si cela est possible.

Concernant les valeurs (h b tw tf r) elles seront récupérées dans la base de données.

"lgd" sera la valeur d'un text_box (decimal) qui definira une dimension que le programme utilisera.

(gile) · le 31 juillet 2012

Voilà un exemple de traduction.

Mais encore une fois, je ne suis pas sûr que ce soit un bonne chose que de te donner un code tout fait si tu n'est pas capable d'en comprendre toutes les subtilités.

Il y a un immense fossé entre une routine LISP qui utilise les commandes natives et une méthode .NET qui doit décrire dans les moindres détails toutes les étapes de la création et de l'ajout d'un solide 3d à l'espace courant...

L'apprentissage de .NET est est une tache longue et parfois ingrate qui est loin de se limiter à l'apprentissage d'une syntaxe (que ce soit celle VB ou C#). Cela suppose de comprendre au moins les fondements de l'architecture .NET, de l'utilisation de Visual Studio et la Programmation Orientée Objet ; de maîtriser les bases de .NET en programmation Windows avant de s'attaquer à la programmation d'AutoCAD ; et enfin, de comprendre l'API .NET d'AutoCAD et les "couches supplémentaires" qui n'existent pas dans d'autres environnements de programmation comme AutoLISP, Visual LISP ou VBA (Database, Editor, Transaction, etc.) ainsi que la gestion de la mémoire dans certains cas.

Le code en C#

        private void Extrusion(double b, double tf, double tw, double r, double h, double lgd)
       {
           Document doc = AcAp.DocumentManager.MdiActiveDocument;
           Database db = doc.Database;
           Editor ed = doc.Editor;
           PromptPointResult ppr = ed.GetPoint("\nGet base point of section 3D : ");
           if (ppr.Status != PromptStatus.OK)
               return;

           Point3d bpt3d = ppr.Value;
           Point2d bpt = new Point2d(bpt3d.X, bpt3d.Y);

           // Calcul des points
           Point2d s1 = Polar2d(bpt, Math.PI, b / 2.0);
           Point2d s2 = Polar2d(s1, Math.PI / 2.0, tf);
           Point2d s3 = Polar2d(s2, 0.0, (b - tw) / 2.0 - r);
           Point2d pp1 = Polar2d(s3, 0.0, r);
           Point2d s4 = Polar2d(pp1, Math.PI / 2.0, r);
           Point2d s5 = Polar2d(s4, Math.PI / 2.0, h - (tf + r) * 2.0);
           Point2d s6 = Polar2d(s3, Math.PI / 2.0, h - tf * 2.0);
           Point2d s7 = new Point2d(s1.X, s6.Y);
           Point2d s8 = new Point2d(s1.X, s1.Y + h);
           Point2d s9 = Polar2d(s8, 0.0, B);
           Point2d s10 = new Point2d(s9.X, s7.Y);
           Point2d s11 = new Point2d(s6.X + (r * 2.0 + tw), s10.Y);
           Point2d s12 = Polar2d(s5, 0.0, tw);
           Point2d s13 = Polar2d(s4, 0.0, tw);
           Point2d s14 = new Point2d(s3.X + (r * 2.0 + tw), s2.Y);
           Point2d s15 = new Point2d(s10.X, s14.Y);
           Point2d s16 = new Point2d(s15.X, s1.Y);
           try
           {
               // Démarrage d'une transaction
               using (Transaction tr = db.TransactionManager.StartTransaction())
               {
                   // Instance de l'espace courant ouverte en écriture
                   BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);

                   // Création de la polyligne;
                   using (Polyline pline = new Polyline())
                   {
                       pline.AddVertexAt(0, s1, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(1, s2, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(2, s3, Math.Tan(Math.PI / 8.0), 0.0, 0.0);
                       pline.AddVertexAt(3, s4, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(4, s5, Math.Tan(Math.PI / 8.0), 0.0, 0.0);
                       pline.AddVertexAt(5, s6, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(6, s7, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(7, s8, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(8, s9, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(9, s10, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(10, s11, Math.Tan(Math.PI / 8.0), 0.0, 0.0);
                       pline.AddVertexAt(11, s12, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(12, s13, Math.Tan(Math.PI / 8.0), 0.0, 0.0);
                       pline.AddVertexAt(13, s14, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(14, s15, 0.0, 0.0, 0.0);
                       pline.AddVertexAt(15, s16, 0.0, 0.0, 0.0);
                       pline.Closed = true;
                       // transformation de la polyligne suivant le SCU courant et attribution de l'élévation
                       Matrix3d ucs = ed.CurrentUserCoordinateSystem;
                       pline.TransformBy(ucs);
                       pline.Elevation = bpt3d
                           .TransformBy(ucs)
                           .TransformBy(Matrix3d.WorldToPlane(new Plane(Point3d.Origin, pline.Normal)))
                           .Z;

                       // Ajout de la polyligne à la base de donnée si DELOBJ = 0
                       if ((short)Application.GetSystemVariable("DELOBJ") == 0)
                       {
                           btr.AppendEntity(pline);
                           tr.AddNewlyCreatedDBObject(pline, true);
                       }

                       // Création d'une région qui n'est pas ajoutée à la base de données (indispensable pour extruder un solide)
                       DBObjectCollection curves = new DBObjectCollection { pline };
                       using (DBObjectCollection regions = Region.CreateFromCurves(curves))
                       {
                           // Création d'un solide 3d ajouté à la base de données
                           using (Solid3d solid = new Solid3d())
                           {
                               solid.Extrude((Region)regions[0], lgd, 0.0);
                               btr.AppendEntity(solid);
                               tr.AddNewlyCreatedDBObject(solid, true);
                           }
                           regions[0].Dispose();
                       }
                   }
                   tr.Commit();
               }
           }
           catch (System.Exception ex)
           {
               ed.WriteMessage("\n{0}\n{1}", ex.Message, ex.StackTrace);
           }
       }

       private Point2d Polar2d(Point2d org, double angle, double distance)
       {
           return new Point2d(
               org.X + (distance * Math.Cos(angle)),
               org.Y + (distance * Math.Sin(angle)));
       }

Le code en VB

        Private Sub Extrusion(b As Double, tf As Double, tw As Double, r As Double, h As Double, lgd As Double)
           Dim doc As Document = Application.DocumentManager.MdiActiveDocument
           Dim db As Database = doc.Database
           Dim ed As Editor = doc.Editor
           Dim ppr As PromptPointResult = ed.GetPoint(vbLf & "Get base point of section 3D : ")
           If ppr.Status <> PromptStatus.OK Then
               Return
           End If

           Dim bpt3d As Point3d = ppr.Value
           Dim bpt As New Point2d(bpt3d.X, bpt3d.Y)

           ' Calcul des points
           Dim s1 As Point2d = Polar2d(bpt, Math.PI, b / 2.0)
           Dim s2 As Point2d = Polar2d(s1, Math.PI / 2.0, tf)
           Dim s3 As Point2d = Polar2d(s2, 0.0, (b - tw) / 2.0 - r)
           Dim pp1 As Point2d = Polar2d(s3, 0.0, r)
           Dim s4 As Point2d = Polar2d(pp1, Math.PI / 2.0, r)
           Dim s5 As Point2d = Polar2d(s4, Math.PI / 2.0, h - (tf + r) * 2.0)
           Dim s6 As Point2d = Polar2d(s3, Math.PI / 2.0, h - tf * 2.0)
           Dim s7 As New Point2d(s1.X, s6.Y)
           Dim s8 As New Point2d(s1.X, s1.Y + h)
           Dim s9 As Point2d = Polar2d(s8, 0.0, B)
           Dim s10 As New Point2d(s9.X, s7.Y)
           Dim s11 As New Point2d(s6.X + (r * 2.0 + tw), s10.Y)
           Dim s12 As Point2d = Polar2d(s5, 0.0, tw)
           Dim s13 As Point2d = Polar2d(s4, 0.0, tw)
           Dim s14 As New Point2d(s3.X + (r * 2.0 + tw), s2.Y)
           Dim s15 As New Point2d(s10.X, s14.Y)
           Dim s16 As New Point2d(s15.X, s1.Y)
           Try
               ' Démarrage d'une transaction
               Using tr As Transaction = db.TransactionManager.StartTransaction()
                   ' Instance de l'espace courant ouverte en écriture
                   Dim btr As BlockTableRecord = DirectCast(tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite), BlockTableRecord)

                   ' Création de la polyligne;
                   Using pline As New Polyline()
                       pline.AddVertexAt(0, s1, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(1, s2, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(2, s3, Math.Tan(Math.PI / 8.0), 0.0, 0.0)
                       pline.AddVertexAt(3, s4, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(4, s5, Math.Tan(Math.PI / 8.0), 0.0, 0.0)
                       pline.AddVertexAt(5, s6, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(6, s7, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(7, s8, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(8, s9, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(9, s10, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(10, s11, Math.Tan(Math.PI / 8.0), 0.0, 0.0)
                       pline.AddVertexAt(11, s12, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(12, s13, Math.Tan(Math.PI / 8.0), 0.0, 0.0)
                       pline.AddVertexAt(13, s14, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(14, s15, 0.0, 0.0, 0.0)
                       pline.AddVertexAt(15, s16, 0.0, 0.0, 0.0)
                       pline.Closed = True
                       ' transformation de la polyligne suivant le SCU courant et attribution de l'élévation
                       Dim ucs As Matrix3d = ed.CurrentUserCoordinateSystem
                       pline.TransformBy(ucs)
                       pline.Elevation = bpt3d.TransformBy(ucs).TransformBy(Matrix3d.WorldToPlane(New Plane(Point3d.Origin, pline.Normal))).Z

                       ' Ajout de la polyligne à la base de donnée si DELOBJ = 0
                       If CShort(Application.GetSystemVariable("DELOBJ")) = 0 Then
                           btr.AppendEntity(pline)
                           tr.AddNewlyCreatedDBObject(pline, True)
                       End If

                       ' Création d'une région qui n'est pas ajoutée à la base de données (indispensable pour extruder un solide)
                       Dim curves As New DBObjectCollection()
                       curves.Add(pline)
                       Using regions As DBObjectCollection = Region.CreateFromCurves(curves)
                           ' Création d'un solide 3d ajouté à la base de données
                           Using solid As New Solid3d()
                               solid.Extrude(DirectCast(regions(0), Region), lgd, 0.0)
                               btr.AppendEntity(solid)
                               tr.AddNewlyCreatedDBObject(solid, True)
                           End Using
                           regions(0).Dispose()
                       End Using
                   End Using
                   tr.Commit()
               End Using
           Catch ex As System.Exception
               ed.WriteMessage(vbLf & ex.Message & vbLf & ex.StackTrace)
           End Try
       End Sub

       Private Function Polar2d(org As Point2d, angle As Double, distance As Double) As Point2d
           Return New Point2d(org.X + (distance * Math.Cos(angle)), org.Y + (distance * Math.Sin(angle)))
       End Function

Exemple d'appel de ma méthode Extrusion :

Extrusion(46.0, 5.2, 3.8, 5.0, 80.0, 3000.0)

steelbe · le 1 août 2012

Salut

Merci pour la traduction que tu as faite pour moi.

Je prendrai le temps de le décoder avant de vraiment utiliser.

Concernant, les remarques tu as à emis sur la Programmation Orientée Objet

c'est le sujet que j'étudis en ce moment.

Aussi je tiendrai compte des remarques concernant les différents points que tu as soulevé.

Il est vrai que la courbe d'apprentissage est différentes du Lisp et bien souvent on passe beaucoup de temps à écrir du code :angry: pour parfois un résultat minimal.

Mais quand le programme est terminé le voir fonctionner procure une certain satistaction B)

Merci Gile

(gile) · le 1 août 2012

Mais quand le programme est terminé le voir fonctionner procure une certain satistaction

Ça reste vrai quelle que soit l'interface de programmation (LISP, .NET ou autre) et ça l'est d'autant plus qu'on l'a écrit soi-même (tu devrais être plus satisfait par un programme LISP simple que tu as écrit entièrement que par un programme complexe en .NET constitué d'un patchwork de bouts de codes écrits par d'autres).

Connexion

Equivalent Lisp en VB

Messages recommandés

steelbe

(gile)

steelbe

(gile)

steelbe

(gile)

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante