(gile)

Évaluation pas à pas : (car (cdr (cdr '(6 1 8)))) => (cdr '(6 1 8)) retourne (1 8) -la liste (6 1 8) sans le premier élément- (car (cdr '(1 8))) => (cdr '(1 8)) retourne (8) -la liste (1 8) sans le premier élément- (car '(8)) => retourne 8 -le premier élément de la liste (8)

L'erreur : "Erreur : type d'argument incorrect: stringp nil" vient de l'expression : (setq profilename (strcase (getvar "NEUF_2018"))) Cette expression -qui pourrait être réduite à : (setq profilename (getvar "NEUF_2018"))- suppose qu'il y ait une variable système nommée "NEUF_2018", or, à ma connaissance, il n'existe aucune variable de ce nom, donc soit ce LISP est prévu pour fonctionner avec une application ObjectARX ou .NET qui définirait une telle variable système ; soit il n'a jamais pu fonctionner en l'état.

Oupss!... J'ai donné ce que didier suggérait à denis de faire... Il y a quand même peut-être moyen d'apprendre un peu en décortiquant le code...

Si c'est le cas, il faut les quadrupler (doubler chacun). "\\\\architecture.local\\NEUF\\Outils\\Y-Système\\Y1-Autocad\\2018\\Y14-Routines\\NEUF_2018_ARG\\Deploy_2018\\"

S'il s'agit, comme je le suggérais, de "projeter les faces en polylignes sur le plan XY, la routine ci-dessous devrait le faire. (defun c:3dFace2Polyline (/ distinct ss i face pts) (defun distinct (l) (if l (cons (car l) (distinct (vl-remove (car l) l))) ) ) (if (setq ss (ssget "_X" '((0 . "3DFACE")))) (repeat (setq i (sslength ss)) (setq face (ssname ss (setq i (1- i))) pts (distinct (mapcar '(lambda (p) (list (cadr p) (caddr p)) ) (vl-remove-if-not '(lambda (x) (member (car x) '(10 11 12 13))) (entget face) ) ) ) ) (command "_.pline") (foreach p pts (command p)) (command "_close") (command "_.erase" face "") ) ) (princ) )

Créer des polylignes (LWPOLYLINE), entités 2D par excellence, à partir de faces 3D, entités 3d qui, de plus, peuvent ne pas être plane n'est pas si simple. Il faudrait plus de précisions sur la nature de ces Faces 3D et la manière de les convertir. Doit on les considérer comme toutes planes (même si elles ont 4 sommets distincts) et parallèles au plan XY ? Autrement dit, les polylignes seraient la project des faces sur le plan XY . Si c'est le cas, les codes ci-dessus peuvent assez facilement modifiés.

Au temps pour moi. (en même temps, c'est vrai que j'ai un peu abandonné les recherches de solutions ActiveX quand .NET m'en donne bien plus...)

Salut, En LISP (comme dans de nombreux autres langages de programmation) la barre oblique inversée ou anti-slash (\) est un caractère d’échappement. Dans les chemins de fichier il faut donc le doubler (\\) ou le remplacer par une barre oblique ou slash (/). Par ailleurs, ton chemin ne me semble pas valide : il manque le nom du lecteur au début Remplace : "\\architecture.local\NEUF\Outils\Y-Système\Y1-Autocad\2018\Y14-Routines\NEUF_2018_ARG\Deploy_2018" Par : "C:\\architecture.local\\NEUF\\Outils\\Y-Système\\Y1-Autocad\\2018\\Y14-Routines\\NEUF_2018_ARG\\Deploy_2018\\" en changeant la lettre du lecteur (C:) au besoin.

Quand on répond à l'invite de commande "choix des objets: " dans une expression LISP (command ...), on doit passer un nom d'entité (type ENAME) ou un jeu de sélection (type PICKSET). Quand tu fais : (command "_hatch" "solide" elst "")quel est le type de elst ? Met un point d'arrêt devant cette expression, relance ton LISP et, quand l'évaluation s'arr^te au point d'arrêt, entre les expressions suivantes dans la console : (type Select) (type ent) (type elst)

Salut, À ma connaissance, il n'y a pas de moyen direct d'accéder au presse papier en AutoLISP/Visual LISP autrement qu'à travers les commandes "_copyclip", "_pateclip", etc. Ces commandes ne fonctionnent qu'avec des entités ou jeux de sélection (en utilisant en interne le mécanisme de WBLOCK) mais pas avec du texte. Je crois que DOSlib fournit une fonction LISP permettant de copier un texte dans presse-papier. De mon côté, j'en avais fait une dans le plugin .NET LispExtension sur cette page.

Tu peux regarder le petit screencast que j'ai posté ici.

Bonjour, Quand on utilise la fonction LISP command, on a parfois des difficultés pour déterminer les arguments (options de la commande) qu'il faut lui passer. Surtout quand ces arguments diffèrent un peu des options de la commande native ce qui arrive parfois. Je propose donc dans ce petit screencast une méthode qui utilise la possibilité de passer directement en ligne de commande une expression LISP (command ...) incomplète afin de la compléter au fur et à mesure que l'on a déterminé les bons arguments.

Quand tu utilises la fonction command pour appeler les commandes natives, tu peux faire des tests en ligne de commande pour voir les arguments (options de la commande) qu'il faut passer à la commande. Essaye d'abord : (command "_hatch") et regarde les invites en ligne commande Tu pourras ainsi compléter ton expression LISP au fur et à mesure...

Pour localiser une erreur, aide toi des fonctions de débogage de l'éditeur Visual LISP (section 4.5 de Introduction à AutoLISP) Sinon, tu peux filtrer directement les polylignes fermées depuis ton filtre de sélection : (setq Select (ssget "_X" (list (cons 0 "LWPOLYLINE") (cons 8 "NANCAY_CADASTRE_BATI") (cons -4 "&") (cons 70 1))))

Salut, Pour savoir si une polyligne est fermée au sens où sa propriété "Fermé" (Closed) est vraie, tu peux, comme le dit sbosarl, vérifier dans les codes DXF que le groupe 70 a bien le bit 1, mais attention, if faut faire un comparaison bit à bit avec l'opérateur logique AND parce que le groupe 70 des polylignes ne contient pas uniquement ce bit mais aussi le bit 128 qui concerne la "génération de type de ligne". Donc (70 . 1) ou (70 . 129) = fermé et (70 . 0) ou (70 . 128) = ouvert. (defun IsClosed (pline) (= 1 (logand 1 (cdr (assoc 70 (entget pline))))) ) Tu peux aussi, plus simplement, utiliser getpropertyvalue avec la propriété "Closed" : 1 = fermé, 0 = ouvert : (defun IsClosed (pline) (= 1 (getpropertyvalue pline "Closed")) ) Ou encore, si tu utilises Visual LISP (vlaPline est de type vla-object) : (defun IsClosed (vlaPline) (= (vla-get-Closed vlaPline) :vlax-true) ) Mais s'il s'agit de tester si une polyligne est hachurable, il faudrait aussi considérer les polylignes "ouvertes" dont le dernier sommet est superposé au premier. Là encore, on peut utiliser les trois méthodes : (defun IsOverlapped (pline / elst) (setq elst (entget pline)) (equal (assoc 10 elst) (assoc 10 (reverse elst))) ) (defun IsOverlapped (pline) (equal (getpropertyvalue pline "Vertices" 0 "Position") (getpropertyvalue pline "Vertices" (fix (getpropertyvalue pline "EndParam")) "Position") ) ) (defun IsOverlapped (vlaPline / coords sdrooc) (setq coords (vlax-get vlaPline 'Coordinates) sdrooc (reverse coords) ) (equal (list (car coords) (cadr coords)) (list (cadr sdrooc) (car sdrooc)) )

Salut, Quand on fait un Screencast avec l'application Autodesk, on peut récupérer un petit bout de code HTML pour inclure directement la vidéo en collant ce code dans un message. Pour ce faire, il faut "activer le HTML" dans les options du message. Malheureusement, cette option n'est accessible qu'aléatoirement. Avec: http://gile.pagesperso-orange.fr/Images/CADxp_Options_avec.png Sans: http://gile.pagesperso-orange.fr/Images/CADxp_Options_sans.png

Salut, Tu définis un paramètre linéaire depuis ton centre de symétrie jusqu'à l'extrémité de droite. Tu définis une action d'étirement linéaire avec ce paramètre en sélectionnant la partie droite. Tu définis une seconde action d'étirement linéaire avec ce même paramètre en sélectionnant la partie gauche. Dans les propriétés de la seconde action d'étirement, tu spécifies -1 comme "Variateur de distance". Un petit Screencast.

Salut, Bravo et merci d'avoir signalé le problème. Le nouveau téléchargement est à jour pour A2018 maintenant.

L'option "Calque" ("_Layer") de la commande "_OFFSET" permet de choisir le calque sur lequel sera placé l'entité décalée entre le calque de l'objet source et le calque courant. La macro, comme le LISP, change le calque courant, lance la commande "DECALER", force l'option "Calque" sur "Courant", puis restaure le calque courant précédent.

Salut, Une macro avec un peu de LISP dedans (remplacer "calque_offset" par le nom du calque) : ^C^C(setq *layer* (getvar 'clayer));(setvar 'clayer "calque_offset");_offset;_layer;_current;0.8;\\;(setvar 'clayer *layer*); Mais quitte à utiliser du LISP autant le faire directement en LISP : (defun c:BPB6804 (/ clay) ; <- changer le nom de la commande comme désiré (setq clay (getvar 'clayer)) (setvar 'clayer "CALQUE_OFFSET") ; <- changer le nom du calque comme désiré (command-s "_.offset" "_layer" "_current" 0.8) (setvar 'clayer clay) (princ) )

C'est curieux, la seconde version est identique à la première excepté l'ajout des lignes de visibilité... EDIT : c'est peut-être un problème avec les accrochages aux objets, j'ai modifié les deuc code ci-dessus pour forcer les accrochages sur "AUCun" ("_NONe").

Il faut que tu sélectionnes en premier le point de vue le plus bas (regarde la vidéo). Tu peux essayer cette version qui dessine les lignes de visibilité sur le calque VISIBILITE. On pourrait aussi dessiner un point ou insérer un bloc à chaque sommet de la spline. (defun c:courbeVisib (/ tan p0 p1 x y n ix iy pts a) (defun tan (a) (/ (sin a) (cos a))) (if (and (setq p1 (getpoint "\nSpécifiez le premier point de vue: ")) (setq p0 (getpoint p1 "\nSpécifiez le point cible: ")) (setq iy (getdist p1 "\nSpécifiez le décalage en hauteur (y): ")) (setq ix (getdist "\nSpécifiez la largeur des rangs (x): ")) ) (progn (initget 7) (setq n (getint "\nEntrez le nombre de rangs: ")) (setq pts (list p1)) (setq ix (if (minusp (- (car p1) (car p0))) (- (abs ix)) (abs ix) ) iy (abs iy) ) (repeat n (setq a (angle p0 (list (car p1) (+ (cadr p1) iy))) x (+ (car p1) ix) p1 (list x (+ (cadr p0) (* (tan a) (- x (car p0))))) pts (cons p1 pts) ) ) (command "_spline") (foreach p (reverse pts) (command "_non" p) ) (command "" "" "") (foreach p pts (entmakex (list (cons 0 "LINE") (cons 10 (trans p 1 0)) (cons 11 (trans p0 1 0)) (cons 8 "VISIBILITE") ) ) ) ) ) (princ) )

Salut, Tu peux essayer ça : (defun c:CourbeVisib (/ tan p0 p1 ix iy x n pts a) (defun tan (a) (/ (sin a) (cos a))) (if (and (setq p1 (getpoint "\nSpécifiez le premier point de vue: ")) (setq p0 (getpoint p1 "\nSpécifiez le point cible: ")) (setq iy (getdist p1 "\nSpécifiez le décalage en hauteur (y): ")) (setq ix (getdist "\nSpécifiez la largeur des rangs (x): ")) ) (progn (initget 7) (setq n (getint "\nEntrez le nombre de rangs: ")) (setq pts (list p1)) (setq ix (if (minusp (- (car p1) (car p0))) (- (abs ix)) (abs ix) ) iy (abs iy) ) (repeat n (setq a (angle p0 (list (car p1) (+ (cadr p1) iy))) x (+ (car p1) ix) p1 (list x (+ (cadr p0) (* (tan a) (- x (car p0))))) pts (cons p1 pts) ) ) (command "_spline") (foreach p (reverse pts) (command "_non" p) ) (command "" "" "") ) ) (princ) )

Salut, À ma connaissance, il n'y a rien qui ressemblerait à ce que tu cherches, mais tu devrais peut-être préciser ce que tu cherches avec un petit dessin...

Ce que tu proposes fonctionne pour les DLLs .NET qui définissent des fonctions LISP, or les DLLs en question (modeleur 3d) n'ont rien à voir avec .NET et les fonctions LISP (elles existaient avant l'introduction de.NET dans AutoCAD en 2006).