Autocad <-> Python <-> L' infini et au-delà

[Fraid]

Bonjour,

Il est impossible d'être exhaustif au sujet des interactions Autocad/Python.

Des possibilités infini dans Autocad un peu comme VBA.

Au-delà d'Autocad, comme tout les langages de programmations avancés.

Si Python est devenu le langage le plus utilisé, ce n'est pas le cas pour les "Autocadiens".

Pourquoi ?

A vous de me répondre.

En attendant voici comment en profiter.

Prérequis

- Etre administrateur de son poste ou si vous pouvez prendre un ticket au près de votre service informatique qui vous configure votre poste.

- Windows 10 ou 11

- Un Autocad d'installé. (full 64 bit qu'importe la version, testé sur 2015 à 2024, non testé avec LT, CIVIL ou MAP : à explorer)

- Un EDI comme Visual Studio Code

- Avoir des notions de base de Python. C'est peut être le langage le plus facile à apprendre. Je parle bien de la base, car c'est un langage modulaire et que l'utilisation de certain modules n'est pas si simple. Il y a des cours gratuit sur le net, il suffit de demander à votre moteur de recherche préféré. Si vous connaissez déjà un autre langage, l'apprentissage va très vite.

- Si vous connaissez l'Autolisp c'est le top, il communique très bien avec Python. De plus, comme Python est présenté comme multi- paradigme, vous pouvez coder en fonctionnel. Je dit bien présenté, car en fait, il est purement orienté objet. Si dans Autolisp tout est liste, tout est objet dans python, même une fonction ou une variable. 

 

Installation

- Télécharger la dernière version stable de Python 

- Installer Python. Normalement il n'y a rien à changer dans les options d'installation, mais vérifier quand même que Modifier PATH soit coché et que PIP (utilitaire de téléchargement des Modules) soit installé avec.

- Selon l'utilisation il y auras des modules à installer. Cela se fait en ligne de commande Windows avec l'utilitaire PIP.

   Pour le Module Pyautocad  qui permet d'agir dans le Domaine d'Autocad on tape ceci dans l'invite de commande Windows: pip install pyautocad

- Et c'est tout, rien à faire dans Autocad, il s'en fout totalement et l'ignore.

 

Voila, je reviendrais avec des exemples.

 

 

[Fraid]

Python dans Autocad 

En fait, ce n'est pas l'aspect le plus attrayant de cette collaboration.

Car, je vous le concède, il y a déjà un certain nombre de langages utilisables.

Mais sa facilité de mise en place (aucune dans Autocad) et d'écriture, ainsi que son accès à de nombreux Domaines grace à ces modules, vous permet d'attaquer les dwg par l'extérieur.

Pour que python puisse agir dans Autocad, nous pouvons utiliser Pyautocad, mais ce n'est pas obligatoire, si vous fouiller dans le code de Pyautocad, vous trouvez sa solution par exemple et si vous cherchez, vous en trouverez d'autres (si vous connaissez le chinois, le russe ou le tchèque c'est un plus).

Il faut savoir aussi qu'on peut aussi éditer les dwg sans Autocad sur le poste gratuitement, mais ça, je ne suis pas sure d'avoir le droit de vous le révéler. Si quelqu'un à un avis sur le sujet.

Pour tester votre installation, créer un nouveau fichier Python dans votre EDI.

# coding: utf-8

from pyautocad import Autocad, APoint

acad = Autocad(create_if_not_exists=True)

acad.prompt("Coucou, c'est Python\n")

Exécuter le fichier, Autocad démarre si il ne l'est pas, et le message est affiché.

Comme vous pouvez le constater, Autocad c'est laissé faire. Si aucun message n'est affiché, l'action de Python ne laisse aucune trace.

C'est une énorme faille de sécurité, un gouffre sans fond, un abysse technologique. 

Juste pour info, vous trouverez souvent au début des codes Python ceci : #!/usr/bin/env python . C'est pour linux, cela remplace la variable d'environnement PATH de Windows. Ici, nous causons pas le linuxiens, pour les utilisateurs de Mac, il se débrouille, puisque le pognon rend intelligent (la preuve au gouvernement).

à suivre ...

 

[(gile)]

Salut,

Pour Python avec AutoCAD, tu devrais aussi regarder du côté de PyRx, c'est 'wrapper' d'ObjectARX pour Python développé par Daniel (un pilier de TheSwamp aussi auteur de SqLite for AutoLISP, une bibliothèque de fonctions LISP pour travailler avec les bases de données SQLite).

Blog : https://pyarx.blogspot.com/

Forum de discussion : https://www.theswamp.org/index.php?board=76.0

[didier]

Bonjour @Fraid

C'est sans doute l'avenir, ce qui existe aujourd'hui est déjà hyper performant, je ne parle pas de VBA qui sans être obsolète est quand même un peu confidentiel, Autolisp et VisualLisp sont fournis AVEC AutoCAD, Tout ce qui est écrit avec est transparent pour AutoCAD.

Python l'est un peu moins certainement, ça ne retire rien de ses qualités , je ne veux insulter personne.

Par exemple, comment lancer le programme que tu proposes ? tu parles d'EDI sans rien citer, du coup, j'ai pris un éditeur en ligne qui propose d'exécuter du code Python et le résultat est celui que j'attendais... RIEN ne se passe.

Merci de faire un peu de vulgarisation pour qu'on puisse te suivre.

Amicalement

[Fraid]

Bonjour Gile,

Effectivement celui la, je ne l'avais pas vu, c'est ce que je disais plus haut, il existe de nombreuse façon d'accéder à Autocad.

Didiers

il y a 2 minutes, didier a dit :

Merci de faire un peu de vulgarisation pour qu'on puisse te suivre.

C'est exactement ce que j'essaye de faire. Apparemment ce n'est pas mon fort, j'en suis désolé.

L'EDI que j'utilise est Visual Studio Code  qui est gratuit et multi langage.

Tu n'auras qu'a cliquer sur la flèche en haut à droite pour l'exécuter.

[didier]

Bonjour @Fraid

Je ne pense pas avoir fait correctement, mais tu en dis tellement peu aussi.

J'ai lancé Visual Studio Code, créé un nouveau fichier python, enregistré le fichier et lancé par F5, car je ne vois aucune flèche.

Et le résultat est toujours rien.

Il faut installer quelque chose sans doute ?

J'aimerais bien le voir fonctionner, je suis friand de nouveautés.

Amicalement

 

[Fraid]

il y a 2 minutes, didier a dit :

tu en dis tellement peu aussi

c'est qu'il n'y a pas grand chose à dire de plus.

Je ne comprend pas ton F5, chez moi c'est pour sélectionner le debugger

A tu une version récente de Visual ?

A tu un message d'erreur dans la console (en bas)?

 

[didier]

Bonjour @Fraid

Je n'ai pas vu de message d'erreur et comme tout est désormais éteint je ne sais pas t'en dire plus.

C'est qu'il n'y a pas grand-chose à dire de plus.

Bien sûr que si !

Je m'en rends compte en ce moment, car je m'entraine à tourner des vidéos de formation AutoLisp et il y a tellement de truc que je fais machinalement que quand je me mets à la place d'un débutant, je ne ne comprends rien à mes explications, du coup, je m'oblige à ne RIEN passer sous silence même si ça va sans dire dès que tu as quitté le niveau débutant.

Par exemple, pour le python, il faut installer un plugin ou autre chose ? les machines ne sont pas nativement en mesure de traiter ce langage, si ?

Et AutoCAD il faut lui donner des chemins de recherche ou c'est transparent ?

Comme je le disais, j'aimerais le voir marcher ce bout de code pour m'esbaudir de concert.

Amicalement

 

[didier]

Ah ! il me dit

ModuleNotFoundError: No module named 'pyautocad'

j'ai recommencé, car je suis têtu et je veux que ça fonctionne

avec ce message, tu sais me guider ?

Amicalement

[Fraid]

On dirais que tu n'as pas lu ce que j'ai écrit.

Installer la dernières version de Python.

Installer un EDI

Pour le teste Installer Pyautocad avec

PIP install pyautocad

en ligne de commande windows.

 

 

 

[didier]

OK @Fraid

J'ai tout repris ligne à ligne ce que tu as écrit et j'ai redémarré la machine, install pyautocad a fait des trucs, mais je ne sais pas quoi.
J'ai réussi à faire fonctionner le code de quelques lignes que tu as livré. Super ! Je vais me documenter plus avant.

Par contre, je ne comprends pas ça : "Si aucun message n'est affiché, l'action de Python ne laisse aucune trace".

Et aussi en quoi c'est une faille de sécurité ?

Merci de ton partage de connaissances, c'est chouette d'apprendre quelque chose tous les jours.

Amicalement

[Fraid]

il y a une heure, didier a dit :

install pyautocad a fait des trucs, mais je ne sais pas quoi

L'utilitaire pip télécharge et place les fichiers dans le dossier Python enregistrer dans la variable d'environnement Windows PATH.

Il installe le module et éventuellement les modules associés si absent.

 

il y a une heure, didier a dit :

Et aussi en quoi c'est une faille de sécurité ?

C'est pour moi évident. Un code malicieux pourrais mettre ton Autocad hors service après avoir envoyé des infos sensibles en Chine par exemple.

Je ne te montrerais pas d'exemple de code. 

Sinon Merci, cela m'encourage à continuer.

C'est un retour d'experience, non un cours de Python.

Pour un cours Python, j'aime bien OpenClassRoom 

Pour une description simple des fonctions et méthodes w3schools 

à bientôt

 

[Fraid]

Je ne vais pas m'étendre sur l'utilisation de Pyautocad, 

Il y a des exemples d'utilisation sur cette page et celle-ci.

Autolisp <-> Python

Voici un exemple d'utilisation de Python au sein d'une fonction Autolisp.

Nous allons créer une fonction autolisp de conversion de coordonnée en utilisant Python et le module pyproj

Pour l'installer, taper en ligne de commande Windows

pip install pyproj

(N'ouvrez pas encore votre EDI)

Nous allons choisir une architecture commune en créant ces dossiers  : C:/Data/Python/transform/

Dans ce dossier créez 3 fichiers texte que vous renommerez : transform.py, transform.lsp et transform-util.lsp

Cliquez droit dans le vide du dossier transform et Ouvrir avec <votre EDI>

En fait, c'est comme cela qu'il faut ouvrir Visual studio code. Cela crée automatiquement un projet.

Vos fichiers apparaissent sur l'explorateur à gauche.

Cliquez sur transform.py, il s'ouvre dans l'éditeur.

 

Important

L'encodage des caractères des fichiers est indiqué en bas.

Pour Python, il doit être UTF-8 comme le montre l'illustration.

Si ce n'est pas le cas, cliquez dessus et vous serez amener à changer d'encodage (en haut).

Voici le code python qui utilise le module pyproj.

# coding: utf-8
# python 3.12
# only for Windows
"""
 transform.py, Convertion des Coordonnées d'un système à l'autre.
 Les arguments doivent etres sous la forme d'un texte dans le presse papier.
 ex: '164080.02760466572 6797023.84783544 epsg:2154 epsg:4326'
   Args:
    xIn et yIn, floats, Coordonnées d'entrées.
    sysIn, str, Système d'entrée.
    sysOut, str, Système de sortie.
   Retour: tuple de deux floats, Coordonnées converties.
           et str dans presse papier.

   Exemple trans(5.355651287573366, 45.96240165432621, 'epsg:4326', 'epsg:2154') 
            -> (882408.3, 6543019.60) et '882408.3 6543019.60'

https://pyproj4.github.io/pyproj/stable/api/transformer.html#pyproj-transformer
"""
import pyperclip
from pyproj import Transformer

# Main
def trans(x, y, sysIn, sysOut):
    try:
        # Instanciation de l'objet Transformer selon les systèmes.
        tr = Transformer.from_crs(sysIn, sysOut, always_xy=True)
        # Applique la méthode transform à l'objet avec les coordonnées d'entrée.
        xyt = tr.transform(float(x),float(y))
        # Copie le retour en format texte dans le presse papier.
        pyperclip.copy(f'{xyt[0]} {xyt[1]}')
        return xyt
    except:
        return None
# Launcher
if __name__ == "__main__":
    # Colle les arguments du presse papier et transforme le texte en liste de textes.
    p = pyperclip.paste().split(' ')
    # Lance la fonction trans
    if not trans(p[0], p[1], p[2], p[3]):
        # Si trans ne renvois rien.
        pyperclip.copy('Error: Invalid projection')

Sélectionnez maintenant transform.lsp

Vérifier que le fichier soit encodé en Windows 1252.

 

; ANSI-Windows 1252
; Autolisp
;|
	transform.lsp, Convertion des Coordonnées d'un système à l'autre.
		Dépendance: - transform-util.lsp
                    - transform.py
	Arguments:
		x et y, str, Coordonnées d'entrées.
		sysIn, str, Système d'entrée.(code epsg)
		sysOut, str, Système de sortie.(code epsg)
	Retour: str, Coordonnées converties ou nil si échec.

	Testé sur Windows 10 et Autocad 2015
	No copyright: (!) 2023 by Frédéric Coulon.
	No license: Do with it what you want.
|;
; Ex: (transform "164080.02" "6797023.84" "epsg:2154" "epsg:4326") -> "-4.203120592065369 48.053447643549674"

(defun transform (x y sysIn sysOut / ret)
	; Copie des arguments dans le presse papier.
	(trans-SetClip (strcat x " " y " " sysIn " " sysOut))
		 ; Lancement de transform.py
	(and (trans-runscr (findfile "transform.py"))
		 ; Si pas d'erreur.
		 (/= (trans-GetClip) (setq ret "Error: Invalid projection"))
		 ; Conversion du retour liste de texte.
		 (setq ret (trans-str2lst (trans-GetClip) " ")))
	ret
)

Le même chose pour transform-util.lsp

; ANSI-Windows 1252
; Autolisp
; trans-GetClip, Récupère le contenu du Presse-papier
;   Retour: str ou nil
(defun trans-GetClip( / htm res)
	(setq res
		(vlax-invoke
			(vlax-get
				(vlax-get
					(setq htm (vlax-create-object "htmlfile"))
					'ParentWindow
				)
				'ClipBoardData
			)
			'GetData
			"Text"
		)
	)
	(vlax-release-object htm)
	res
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; trans-SetClip, Copie un texte dans le Presse-papier.
;   Arg: str
;   Retour: str
(defun trans-SetClip (text / htm)
	(vlax-invoke
		(vlax-get
			(vlax-get
				(setq htm (vlax-create-object "htmlfile"))
				'ParentWindow
			)
			'ClipBoardData
		)
		'SetData
		"Text"
		text
	)
	(vlax-release-object htm)
	text
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; trans-runscr, Exécute un script.
;   Arg: str, nom du fichier ou chemin complet.
;   Retour: T, si réussi sinon nil.
(defun trans-runscr (file / obj ret)
	(setq ret T) 
	(if (vl-catch-all-error-p 
			(vl-catch-all-apply 
				'vlax-invoke-method 
				(list (setq obj (vlax-get-or-create-object "WScript.Shell"))
					"Run" 
					file 
					0 
					:vlax-true
				)
			)
		)   
		(setq ret nil)
		(vlax-release-object obj)
	)
	ret
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; trans-lst2str, Concatène une liste et un séparateur en une chaine.
;   Arg: lst, Liste de texte
;        sep, str Séparateur
;   Retour: str
(defun trans-lst2str (lst sep)
  (if (cdr lst)
    (strcat (vl-princ-to-string (car lst)) sep (trans-lst2str (cdr lst) sep))
    (vl-princ-to-string (car lst))
  )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; trans-str2lst, Retourne une liste de texte à partir d'un texte.
;   Arg: str, Texte
;		 sep, séparateur
;   Retour: Liste de texte
(defun trans-str2lst (str sep / pos)
  (if (setq pos (vl-string-search sep str))
    (cons (substr str 1 pos) (trans-str2lst (substr str (+ (strlen sep) pos 1)) sep))
    (list str)
  )
)

Vous enregistrez tout cela, biens sur.

Ajouter dans Autocad le dossier Data comme approuvé.

Chargez les 2 fichiers lsp.

Testez avec (transform "164080.02" "6797023.84" "epsg:2154" "epsg:4326")

A bientôt

 

[vincentp010]

Je ne connaissait pas pyautocad.

J'avais fait un petit programme il y a 11 ans qui utilisait l'interface COM d'autocad, il me sert toujours depuis

import win32com.client

acad = win32com.client.Dispatch("AutoCAD.Application")
if AutoCAD != None:
    doc = AutoCAD.ActiveDocument

 

[Fraid]

Bonjour,

Merci de nous montrer encore une autre façon de pénétrer discrètement Autocad.

Sinon juste un petit truc, comme en autolisp

il y a 6 minutes, vincentp010 a dit :

if AutoCAD != None:

if Autocad: suffit 

[vincentp010]

Oui c'est vrai, mais c'était à mes débuts 🙂 je ne maitrisait pas encore toutes les subtilités

Je viens de voir que ma variable a c a d a été renommé en AutoCAD même dans un bloc de code, il faut se méfier 😕

[Fraid]

Bonjour,

Quelques commentaires avant une nouvelle collaboration.

Si vous enlevez les commentaires, il ne reste pas grand chose.

C'est ce que j'aime avec Python.

J'ai choisi le presse-papier pour l'interpolation des arguments et retours.

C'est ce qu'il a de plus rapide, ce qui permet de placer la fonction lisp transform dans une boucle foreach sans aucun soucis de synchronisation. 

Le choix de placer les fonctions Autolisp dans un domaine de nom (trans-) permet d'éviter des problèmes éponymiques de fonctions (effet de bord).

Boites de dialogue

Utilisons une boite de dialogue Python avec le module interne Tkinter.

Bien plus facile à utiliser que DCL, Tkinter n'offre pas énormément de possibilités supplémentaires, et n'est pas beau.

Si vous voulez des interfaces utilisateurs "pro", c'est QT qu'il faut utiliser.

Personnellement, Tkinter me suffit.

Si vous chercher des exemples Tkinter, vous allez forcement tomber sur cela:

from tkinter import * 

Cela importe tout Tkinter, qui est énorme, ce n'est pas du tout recommandé. 

Le premier effet, est un temps de latence au démarrage du .py.

 

La fonction Autolisp transform demande des code EPSG en arguments.

Dans Autocad, même si ils apparaissent entre parenthèses à la fin de l'insertion d'un emplacement géographique, difficile de déduire le code EPSG par rapport au nom du système de coordonnée.

Heureusement, nous utilisons toujours les mêmes généralement.

Vous trouverez votre bonheur sur ce site officiel.

C'est mondial tout comme la fonction transform de notre projet.

Mais comme vous aurez la flemme, clique droit dans le vide de l'explorateur de votre EDI à gauche.

Nouveau fichier et créer transConst.py et coller ceci dedans:

 

# coding: utf-8
# Dictionnaire, Système de coordonnées : Code EPSG
# Ce sont les noms des systèmes utilisés dans Autocad (variable "cgeocs")
# Descriptions détaillées des systèmes https://epsg.io/
DICSYS = {
    "Lambert93": "epsg:2154",
    "NTF.Lambert-1-ClrkIGN": "epsg:27561",
    "NTF.Lambert-2-ClrkIGN": "epsg:27562",
    "NTF.Lambert-3-ClrkIGN": "epsg:27563",
    "NTF.Lambert-4-ClrkIGN": "epsg:27564",
    "NTF.Lambert-2C-ClrkIGN": "epsg:27572", #étendu
    "CC42": "epsg:3942",
    "CC43": "epsg:3943",
    "CC44": "epsg:3944",
    "CC45": "epsg:3945",
    "CC46": "epsg:3946",
    "CC47": "epsg:3947",
    "CC48": "epsg:3948",
    "CC49": "epsg:3949",
    "CC50": "epsg:3950",
    "ED50-UTM30": "epsg:23030",
    "ED50-UTM31": "epsg:23031",
    "ED50-UTM32": "epsg:23032",
    "WSG84": "epsg:4326",
    "WEB_MERCATOR": "epsg:3857"
}

ça c'est fait.

Nous pouvons maintenant appeler ce dictionnaire avec un simple

from transConst import DICSYS

Créons une liste boxe simple choix.

Crée le fichier transGUI.py et copier cela:

# coding: utf-8
# python 3.12
# only for Windows
"""
  tkListbox
  Boite de dialogue de type liste boxe à choix unique, 
  de taille adaptative à la longueur de la liste.
  Utilisable par un programmme Autolisp.

  Args:
    tit: str , Titre de la boite.
    txt: str , Message
    lst: liste de texte , Choix
  Ret:
    str, L'élément choisi.

  Testé sur Windows 10 et Autocad 2015

"""

from tkinter import Tk, Listbox, Label, Button
import pyperclip

def tkListbox(tit, txt, lst):
    # Fonction de validation
    def ok_clic():
        # Globalisation du choix
        global sel
        # Récupération de la séléction.
        si = lb.curselection()
        sel = lb.get(si[0])
        win.destroy()
    # Instanciation de l'objet Tk
    win = Tk()
    # Init de la boxe
    win.title(tit)
    win.geometry(f'250x{(len(lst) * 19)+25}+820+270')
    win.resizable(False, False)
    # Message
    Label(win,text = txt).pack()
    # Instanciation de l'objet Listbox
    lb = Listbox(win, width=30, height=len(lst))
    # Insertion des éléments de la liste
    nb = 0
    for key in lst:
        nb += 1
        lb.insert(nb, key)
    # Séléction par defaut
    lb.select_set(0)
    lb.pack()
    # Bouton OK
    Button(win, text="Ok", command=ok_clic).pack(pady=10)
    # Fin propre si Echap
    win.bind('<Escape>', lambda e: win.destroy())
    win.mainloop()
    # Copie du retour dans le presse-papier
    pyperclip.copy(sel)
    return sel

a bientôt avec une fonction Autolisp qui utilise tout cela.

[Fraid]

Tout d'abord la fonction Python qui seras lancé par Autolisp.

Crée un fichier getepsg.py :

# coding: utf-8
# python 3.12
# only for Windows
"""
	getepsg.py, 
	Lancé par Autolisp, permet de récupérer le code EPSG d'un système de coordonnée.

	Arg: past , str Nom Autocad du système dans le presse-papier
         DICSYS, dic Dictionnaire Nom Autocad/epsg (Variablle globale)

    Retour: str Code EPSG (dans presse-papier)

	Testé sur Windows 10 et Autocad 2015
"""
import pyperclip
from transConst import DICSYS
from transGUI import tkListbox

def main(past):
	lkeys = DICSYS.keys()
	if past and past in lkeys:
		epsg = DICSYS[past]
	else:
		epsg = DICSYS[tkListbox('Getepsg', 'Choisissez le Système.', lkeys)]
	pyperclip.copy(epsg)

if __name__ == "__main__":
	main(pyperclip.paste())

 

Une fonction Autolisp, créez getwsg.lsp :

; ANSI-Windows 1252
; Autolisp
;|
	getwsg, Convertion des coordonnées d'un point en WSG84.
	Si le dessin ne comporte pas d'emplacement géographique, choix du système.
	Dépendance: - getepsg.py
				- transform.lsp
				- transform-util.lsp
	Args: pt, liste de Str, Coordonnées d'un point
	      cs, Str, Nom Autocad du système
    Retour:  listes de Str. 
	 
	Testé sur Windows 10 et Autocad 2015
|;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Main
(defun getwsg ( pt cs / ret sys)
	; Nom du système dans le presse-papier, "" si aucun (argument de getepsg.py).
	(trans-SetClip cs)
	; Si l'exécution de getepsg.py se passe bien.
	(if (trans-runscr (findfile "getepsg.py"))
		; Colle le code epsg de départ (retour de getepsg.py).
		(setq sys (trans-GetClip)
			  ; Utilisation de la fonction transform
			  ret (transform (rtos (car pt)) (rtos (cadr pt)) sys "epsg:4326"))
	)
	ret
)
; Launcher
(defun c:wsg nil
	(if (getwsg (getpoint "\n Cliquez un point") (getvar 'cgeocs))
		(princ (strcat "\n Coordonnées Géographiques : "
				(trans-GetClip)
			" (copié dans le presse-papier)."))
		(princ "\n Erreur: Vérifiez votre géoréférencement."))
	(princ)
)

Charger le lisp dans Autocad puis taper wsg.

[didier]

Bonjour @Fraid

Je suis en train de perdre le fil ... Quels sont les avantages de lancer un LSP par un Python .
Le "travail" est fait qui, in fine ?

Merci de cet échange de connaissances.

Amicalement

[Fraid]

Bonjour Didier,

il y a 13 minutes, didier a dit :

lancer un LSP par un Python

Si tu lis bien, c'est le contraire.

C'est lancé depuis Autocad.

Si tu est intéressé, prend bien le temps de lire.

Convertir des coordonnées en coordonnées géographique est impossible ou très compliqué en Autolisp.

Il faut une application externe comme Circébatch qui tourne comme une patate.

En final c'est la fonction python transform qui fait le taf.

 

[didier]

Bonjour @Fraid

Si tu lis bien, c'est le contraire.

Visiblement, j'ai du mal à lire, et "bien lire" plus encore.
Je ne vais plus oser intervenir, pardon.

Donc sont utilisés LSP et Python ? pourquoi pas Python tout seul ? ne sait-il pas faire ? j'en serais surpris vu l'engouement autour de ce langage.

Amicalement
 

[GEGEMATIC]

Salut,

je me risque,

pour moi c'est comme utiliser une application externe qui est exposée "com" dans un lisp.

là l'application externe c'est un programme python.

Mais dans le 1er sujet, Fraid nous montre un python qui manipule Autocad, puisqu'il lui fait faire un "hello world"

la question c'est : est-ce que python peut interagir avec Autocad ? ça nous ne l'avons pas encore vu ...

a+, gégé

 

[Fraid]

Il y a 2 heures, didier a dit :

pourquoi pas Python tout seul ?

Comme le dit GEGEMATIC, je n'ai qu'effleuré le sujet au début.

Je comprend ta question, mais c'est justement l'alliance des deux que je veux présenter, car, à mes yeux, c'est comme cela qu'on profite vraiment de Python.

Cela crée des mini-applications externes très légères qui te permettent d'enrichir Autolisp de fonctions pouvant interagir avec "l'extérieur" d'Autocad.

Python, grâce à ces modules, voir le site Pypi, permet, entre autres, de lire / écrire énormément de formats en 3 ou 4 lignes de code.

Je reviendrais sur l'utilisation de Python dans AutoCAD, promis.

Par contre, il faut savoir, que si un Lisp est en route, Python ne peut pas accéder à AutoCAD.

[Fraid]

il y a 48 minutes, didier a dit :

Je ne vais plus oser intervenir, pardon

Heu, si si, intervient.

Pas de soucis, ce n'est pas si facile à comprendre.

Mais, je t'assure que cela vaut le coup d'apprendre le Python.

Je suis encore jeune débutant, 2 ans que je l'apprend. (28 pour l'Autolisp ...j'ai vraiment eu du mal)

[Fraid]

Il y a 1 heure, Fraid a dit :

Par contre, il faut savoir, que si un Lisp est en route, Python ne peut pas accéder à AutoCAD.

Désolé, je me cite, car l'inverse n'est pas vrai.

Pendant que Python agit dans AutoCAD, il peut lancer de l'AutoLisp / VisualLisp.

Je ne veux pas vous embrouiller.