Je me permets de vous contacter car je rencontre un problème avec une boîte de dialogue que je développe en AutoLISP, via un fichier DCL.

Je n'arrive pas à élargir correctement la boîte de dialogue, ce qui fait que ma liste déroulante ne s’affiche pas en entier (les éléments sont tronqués).

Auriez-vous une solution ou un conseil pour permettre à la boîte, ainsi qu’à la liste déroulante, de s'afficher correctement, avec une largeur suffisante ?

Je vous remercie par avance pour votre aide.

Bien cordialement,
 

https://go.dessein-tech.com/ia_code_source

https://go.dessein-tech.com/autolisp-secret

https://dessein-tech.com/autolisp-ia

https://dessein-tech.com/t/lintelligence-artificielle-et-lautolisp-votre-avis/369

Je voulais savoir s’il existe un moyen, lorsqu’on est dans l’éditeur de blocs, de passer un bloc standard en bloc annotatif directement, sans passer par la palette des propriétés (comme on le fait habituellement à la main, voir image jointe).

Plus précisément, je cherche à modifier la propriété "Annotatif" d’un bloc via LISP. Est-ce que c’est possible ? Et si oui, comment y accéder et la modifier en LISP tout en étant dans l’édition du bloc ?

Merci d’avance pour vos retours !

(defun c:InsertInfoLocaux (/ ent obj pts p0 num prefix suffix count blkName blkLayer blkScale blkRotation objType vertexList i coordList blkEnt attrEnt insPt) 
  (setq blkName "LOCAUX"      ;; Nom du bloc
        blkLayer "INFORMATIONS"    ;; Nom du calque
        blkScale 1.0
        blkRotation 0.0)
  
  ;; Vérifier si le bloc existe dans le dessin
  (if (not (tblsearch "BLOCK" blkName))
    (progn
      (princ "\nErreur : Le bloc LOCAUX n'existe pas dans le dessin.")
      (exit)))
  
  ;; Sélection de la polyligne
  (setq ent (car (entsel "\nSélectionnez une polyligne : ")))
  (if (and ent
           (setq obj (vlax-ename->vla-object ent))
           (setq objType (cdr (assoc 0 (entget ent))))
           (or (eq objType "LWPOLYLINE") (eq objType "POLYLINE")))
    (progn
      ;; Récupération des sommets
      (setq pts (cond
                 ;; Polyligne légère (LWPOLYLINE)
                 ((eq objType "LWPOLYLINE")
                  (setq coordList (vlax-get obj 'Coordinates)
                        pts '()
                        i 0)
                  (while (< i (length coordList))
                    (setq pts (append pts (list (list (nth i coordList) (nth (1+ i) coordList) 0))))
                    (setq i (+ i 2)))
                  pts)
                 ;; Polyligne 2D (avec sommets VERTEX)
                 ((eq objType "POLYLINE")
                  (setq vertexList '())
                  (setq ent (entnext ent))
                  (while (and ent (/= (cdr (assoc 0 (entget ent))) "SEQEND"))
                    (if (= (cdr (assoc 0 (entget ent))) "VERTEX")
                        (setq vertexList (append vertexList (list (cdr (assoc 10 (entget ent))))))
                    )
                    (setq ent (entnext ent))
                  )
                  vertexList
                 )
      ))
      
      (if pts
        (progn
          ;; Sélection du point de départ
          (setq p0 (getpoint "\nSélectionnez le point de départ : "))
          
          ;; Demande du numéro de départ
          (setq num (getstring "\nEntrez le numéro de départ (ex: SURFACE-01) : "))
          
          ;; Séparation du préfixe et du suffixe
          (setq prefix (vl-string-left-trim "0123456789" num)
                suffix (atoi (vl-string-right-trim prefix num)))
          
          ;; Création du calque si nécessaire
          (if (not (tblsearch "LAYER" blkLayer))
            (entmakex (list (cons 0 "LAYER") (cons 2 blkLayer) (cons 62 1))))
          
          ;; Insérer les blocs sur chaque sommet
          (setq count 0)
          (foreach pt pts
            (setq insPt pt)
            (setq blkEnt (entmakex
                           (list
                             (cons 0 "INSERT")
                             (cons 2 blkName)
                             (cons 8 blkLayer)
                             (cons 10 insPt)
                             (cons 41 blkScale) ;; X scale
                             (cons 42 blkScale) ;; Y scale
                             (cons 43 blkScale) ;; Z scale
                             (cons 50 blkRotation)
                           )
                         )
            )
            
            (if blkEnt
              (progn
                (setq suffix (+ suffix 1))
                (setq attrEnt (entnext blkEnt))
                (while (and attrEnt (/= (cdr (assoc 0 (entget attrEnt))) "SEQEND"))
                  (if (eq (cdr (assoc 2 (entget attrEnt))) "LOCAL")
                    (entmod (subst (cons 1 (strcat prefix (itoa suffix))) (assoc 1 (entget attrEnt)) (entget attrEnt)))
                  )
                  (setq attrEnt (entnext attrEnt))
                )
                (princ (strcat "\nBloc inséré au point : " (rtos (car insPt)) ", " (rtos (cadr insPt))))
              )
              (princ "\nErreur lors de l'insertion du bloc.")
            )
            (setq count (+ count 1))
          )
          
          ;; Forcer le rafraîchissement d'AutoCAD
          (command "REGEN")
        )
        (princ "\nAucun sommet trouvé sur la polyligne sélectionnée.")
      )
    )
    (princ "\nErreur : Veuillez sélectionner une polyligne.")
  )
  (princ)
)

J'ai pu après pas mal de temps de pause par manque de temps me remettre à apprendre le lisp.

Apres avoir lu, relu et relu introduction à Autolisp et la commande SSGET sur le site de DA-code, j'ai essayé de créer une sélection prenant la sélection précédente et laissant la main à l'utilisateur pour compléter la sélection avant de pouvoir lancer une commande, mais je n'y arrive pas. 

J'ai beau tourner la ligne dans tous les sens, une erreur m'est renvoyé.

j'ai débuter par ces lignes :

; --------------------------------------------------------------------------------------------------
(defun c:BoiteVa ()

  (setq dcl_id (load_dialog "boiteneo.DCL"))  ;; Charger le fichier DCL

  (if (new_dialog "boite1" dcl_id)  ;; Ouvrir la boîte de dialogue
    (progn

      ;; Variables pour stocker les choix
      (setq choixFE "")  ;; Initialisation de choixFE
      (setq choix "")    ;; Initialisation de choix

      ;; Choix de la sélection Demi-feuillet ou Enrobage (visible ou non visible)
      (action_tile "btn_demi_feuillet"
        "(setq choixFE \"Demi feuillet\") (mode_tile \"enrobage\" 1) (princ (strcat \"\\nChoix sélectionné : \" choixFE)) (setq dernier_choixFE choixFE)"
      )
      (action_tile "btn_enrobage"
        "(setq choixFE \"Enrobage\") (mode_tile \"enrobage\" 0) (princ (strcat \"\\nChoix sélectionné : \" choixFE)) (setq dernier_choixFE choixFE)"
      )

      ;; Actions des boutons radio pour les vues possibles
      (action_tile "a" "(setq choix \"Coupe Longitudinale\")")
      (action_tile "b" "(setq choix \"Coupe Transversale\")")
      (action_tile "c" "(setq choix \"Vue en Plan\")")

      ;; Action du bouton OK pour récupérer les valeurs
      (action_tile "accept"
  (strcat
    "(setq ep_feuillet (/ (atof (get_tile \"ep_feuillet\")) 1000)) "  ;; Conversion en mètres
    "(setq ep_frette (/ (atof (get_tile \"ep_frette\")) 1000)) "       ;; Conversion en mètres
    "(setq nb_feuillet (atoi (get_tile \"nb_feuillet\"))) "           ;; Récupérer le nombre de feuillets
    "(setq valeur_a (/ (atof (get_tile \"valeur_a\")) 1000)) "         ;; Conversion en mètres
    "(setq valeur_b (/ (atof (get_tile \"valeur_b\")) 1000)) "         ;; Conversion en mètres
    ;; Récupérer la valeur d'enrobage seulement si le choix est "Enrobage"
    "(if (equal choixFE \"Enrobage\") "
    "    (setq enrobage (/ (atof (get_tile \"enrobage\")) 1000)) "
    "    (setq enrobage nil)) "
    ;; Sauvegarder les valeurs pour les reprendre plus tard
    "(setq dernier_ep_feuillet (* ep_feuillet 1000)) "  
    "(setq dernier_ep_frette (* ep_frette 1000)) "      
    "(setq dernier_nb_feuillet nb_feuillet) "
    "(setq dernier_valeur_a (* valeur_a 1000)) "        
    "(setq dernier_valeur_b (* valeur_b 1000)) "        
    "(if (equal choixFE \"Enrobage\") (setq dernier_enrobage (* enrobage 1000))) "
    "(done_dialog)"
  )
)

      ;; Action du bouton Reprendre les dernières valeurs
      (action_tile "recuperer_valeurs"
        "(progn
           (set_tile \"ep_feuillet\" (rtos dernier_ep_feuillet 2 3)) ; Remplir la case avec l'épaisseur du feuillet
           (set_tile \"ep_frette\" (rtos dernier_ep_frette 2 3))   ; Remplir la case avec l'épaisseur de la frette
           (set_tile \"nb_feuillet\" (itoa dernier_nb_feuillet))   ; Remplir la case avec le nombre de feuillets
           (set_tile \"valeur_a\" (rtos dernier_valeur_a 2 3))     ; Remplir la case avec la valeur de a
           (set_tile \"valeur_b\" (rtos dernier_valeur_b 2 3))     ; Remplir la case avec la valeur de b
           ;; Récupérer le dernier choix pour la sélection de feuillet
           (if (equal dernier_choixFE \"Demi feuillet\")
             (progn
               (set_tile \"btn_demi_feuillet\" \"1\")   ;; Sélectionner le bouton Demi-feuillet
               (mode_tile \"enrobage\" 1)               ;; Afficher le champ d'enrobage
             )
             (progn
               (set_tile \"btn_enrobage\" \"1\")        ;; Sélectionner le bouton Enrobage
               (mode_tile \"enrobage\" 0)               ;; Masquer le champ d'enrobage
               (set_tile \"enrobage\" (rtos dernier_enrobage 2 3)) ;; Restaurer la valeur d'enrobage
             )
           )
           (princ (strcat \"\\nDernier choix de feuillet restauré : \" dernier_choixFE))
         )"
      )

      ;; Réinitialiser les variables si annulation
      (action_tile "cancel"
        (strcat
          "(setq ep_feuillet nil ep_frette nil nb_feuillet nil valeur_a nil valeur_b nil enrobage nil choixFE nil choix nil dernier_choixFE nil dernier_enrobage nil) "  ;; Réinitialiser les variables
          "(done_dialog)"
        )
      )

      ;; Démarrer la boîte de dialogue
      (start_dialog)

    )
  )

  ;; Décharger le fichier DCL après utilisation
  (unload_dialog dcl_id)

  ;; Vérifier si les valeurs sont valides avant d'afficher les résultats
(if (and ep_feuillet ep_frette nb_feuillet valeur_a valeur_b)
  (progn
    (princ (strcat "\n[BoiteNeo] Epaisseur du feuillet (m) : " (rtos ep_feuillet 2 3)))
    (princ (strcat "\n[BoiteNeo] Epaisseur de la frette (m) : " (rtos ep_frette 2 3)))
    (princ (strcat "\n[BoiteNeo] Nombre de feuillets : " (itoa nb_feuillet)))
    (princ (strcat "\n[BoiteNeo] Valeur de a (m) : " (rtos valeur_a 2 3)))
    (princ (strcat "\n[BoiteNeo] Valeur de b (m) : " (rtos valeur_b 2 3)))
    (if (numberp enrobage)
      (princ (strcat "\n[BoiteNeo] Valeur d'enrobage (m) : " (rtos enrobage 2 3)))
      (princ "\n[BoiteNeo] Valeur d'enrobage (m) : N/A")
    )
  )
  (princ "\nOpération annulée.")
)
 

  ;; Ajouter un message
  (princ "\nCalcul de la hauteur et des frettes en cours.")
  (princ)

  ;; Calcul de nb_frette et hauteurAp et espacement entre frettes
  (setq nb_frette (+ nb_feuillet 1))
  (setq espfret (- (+ ep_feuillet ep_frette)))

 ;; Condition pour la hauteur car variable en fonction des choixFE
(setq hauteurAp
  (cond
    ((equal choixFE "Demi feuillet")
     (+ (* nb_feuillet ep_feuillet) (* nb_frette ep_frette) ep_feuillet))

    (t
     (+ (* nb_feuillet ep_feuillet) (* nb_frette ep_frette) (* enrobage 2))))
)

  ;; Afficher les résultats
  (princ (strcat "\nhauteurAp = " (rtos hauteurAp 2 3)))
  (princ (strcat "\nnb_frette = " (rtos nb_frette 2 3)))
  (princ (strcat "\nespfret = " (rtos espfret 2 3)))

  ;; Afficher le choix sélectionné dans la console
  (princ (strcat "\nChoix de feuillet : " choixFE))
  (princ (strcat "\nChoix : " choix))
)

et voila ce que me renvoie Autocad :

Commande: BOITEVA
Dernier choix de feuillet restauré : Enrobage
[BoiteNeo] Epaisseur du feuillet (m) : .008
[BoiteNeo] Epaisseur de la frette (m) : .004
[BoiteNeo] Nombre de feuillets : 6
[BoiteNeo] Valeur de a (m) : .200
[BoiteNeo] Valeur de b (m) : .100
[BoiteNeo] Valeur d'enrobage (m) : N/A
Calcul de la hauteur et des frettes en cours.; erreur: type d'argument incorrect: numberp: nil


Mon problème vient surement d'ici :
 

 ;; Condition pour la hauteur car vairiable en fonction des choixFE
(setq hauteurAp
  (cond
    ((equal choixFE "Demi feuillet")
     (+ (* nb_feuillet ep_feuillet) (* nb_frette ep_frette) ep_feuillet))

    (t
     (+ (* nb_feuillet ep_feuillet) (* nb_frette ep_frette) (* enrobage 2))))
)

car lorsque j'ai pas de condition et que j'ai uniquement (setq hauteurAp   (+ (* nb_feuillet ep_feuillet) (* nb_frette ep_frette) ep_feuillet))
Alors tout fonctionne, j'ai essayer aussi en de mettre if au lieu de cond mais pareil j'ai le même problème.

(defun c:select-vp ()
  ;; Sélectionner tous les viewports dans le layout actif
  (setq ss (ssget "X" (list (cons 0 "VIEWPORT")
                            (cons 410 (getvar "CTAB")))))
 
  (if ss
    (progn
      (setq num (sslength ss))
      (princ (strcat "\nNombre de viewports trouvés : " (itoa num)))

      ;; Demander à l'utilisateur de choisir un viewport
      (setq vp-index (getint (strcat "\nSélectionnez un viewport (1-" (itoa num) ") : ")))

      ;; Vérifier si l'index est valide
      (if (and vp-index (> vp-index 0) (<= vp-index num))
        (progn
          ;; Définir le viewport actif
          (setvar "CVPORT" vp-index)
          (princ (strcat "\nViewport " (itoa vp-index) " activé."))

          ;; Passer en espace objet
          (command "_MSPACE")
        )
        (princ "\nIndex invalide.")
      )
    )
    (princ "\nAucun viewport trouvé.")
  )
  (princ)
)

Cela fait un moment que je déplore l'absence de la couleur logique "Ducalque" dans la couleur du masque d'arrière plan d'un Texte Multiligne...

Je voulais juste des textes NOIRS sur un fond JAUNE, ou BLEU, etc. (de la couleur du calque) (et sans passer par des blocs avec attributs).

Et puis je découvre par hasard sur internet, que cette couleur n'est pas disponible depuis l'interface , mais en programmation, oui : code DXF 63 valeur 256 (DuCalque).

Youpi, ça fonctionne !

J'en profite pour ajouter à mon code le texte en noir,  la valeur de décalage et ... un encadrement.

Dans un premier temps, je ne trouve pas de code DXF lié à cet encadrement.

Puis je comprends que l'encadrement est lié au code 90, mais aucune source dans l'aide (l'aide ne propose que les valeurs 0, 1 et 2 : pas de masque, masque couleur choisie, masque couleur d'arrière plan). DXF MTEXT

Je fouille un peu le net, et je crois comprendre qu'il faut ajouter la valeur 16 au code DXF 90 pour avoir un cadre. Mais je ne suis pas sûr d'avoir toutes les bonnes infos.

Auriez-vous des sources pour ce code 90 ?

Mon programme fonctionne!!!

... mais pas complètement. Sur certains textes, la couleur de fond se met en gris plutôt que DuCalque.

En faisant des tests, je remarque que ces Textes fautifs sont encadrés et n'ont pas de masque. Quand je leur ajoute un masque ou que j'enlève le cadre, le programme fonctionne ! Quand je copie les propriétés de ce texte fautif sur un texte normal, le programme fonctionne. Quand je vais dans la boîte de dialogue masque d'arrière plan, même si le masque n'est pas coché, je m'aperçois que la couleur est définie sur 200,200,200 (c'est justement le gris que j'obtiens à la place de la couleur DuCalque). En parcourant les valeurs DXF (avec DXF list Data), je vois que c'est textes ont un code DXF 421 de 13158600. Les autres textes n'ont pas ce code 421. Je suppose que le secret est là. 

Faut-il que je supprime tous les DXF de 420 à 439 pour m'assurer que mon programme fonctionne ?

Question subsidiaire : il existe un code DXF 441 qui gérerait la transparence cette couleur de fond, mais l'aide indique "not implemented". Est-ce que ça veut dire qu'on y aura jamais accès ?

Merci d'avance pour vos futures réactions.

;background bylayer


(defun c:bg () 
  (setq sel (ssget '((0 . "MTEXT")))) ; Sélectionner uniquement les MText
  (if sel
    (progn
      (repeat (sslength sel)
        (setq ent (ssname sel 0)) ; Obtenir l'entité
        (setq data (entget ent)) ; Récupérer les données DXF


        ;; Modifier ou ajouter le code DXF 62 pour définir la couleur du texte sur noir
        (setq data
              (subst
                '(62 . 7) ; Définir la couleur du texte sur noir
                (assoc 62 data) ; Remplacer le code 62 existant
                (append data
                        (if (not (assoc 62 data))
                          '((62 . 7)) ; Ajouter le code 62 s'il n'existe pas
                          nil))))

       ;; Modifier ou ajouter le code DXF 90 pour activer l'arrière-plan
        (setq data
              (subst
                '(90 . 17) ; Activer l'arrière-plan ; valeur 1 pour activer l'arrière plan + valeur 16 pour activer l'encadrement
                (assoc 90 data) ; Remplacer le code 90 existant
                (append data
                        (if (not (assoc 90 data))
                          '((90 . 17)) ; Ajouter le code 90 s'il n'existe pas
                          nil))))

			
        ;; Modifier ou ajouter le code DXF 45 pour le facteur de décalage de bordure
        (setq data
              (subst
                '(45 . 1.2) ; Définir le facteur de décalage de bordure à 1.2
                (assoc 45 data) ; Remplacer le code 45 existant
                (append data
                        (if (not (assoc 45 data))
                          '((45 . 1.2)) ; Ajouter le code 45 s'il n'existe pas
                          nil))))

	
        ;; Modifier ou ajouter le code DXF 63 pour la couleur d'arrière-plan
	(setq data
              (subst
                '(63 . 256) ; Définir une couleur explicite (par exemple, 7 pour blanc/noir)
                (assoc 63 data) ; Remplacer le code 63 existant
                (append data
                        (if (not (assoc 63 data))
                          '((63 . 256)) ; Ajouter le code 63 s'il n'existe pas
                          nil))))


	
        (entmod data) ; Appliquer les modifications DXF à l'entité
        (ssdel ent sel)) ; Supprimer l'objet de la sélection pour éviter une boucle infinie
      
      (princ "\nMasque activé avec couleur d'arrière-plan sur 256, texte noir, facteur de bordure 1.2, et encadrement activé pour tous les MText sélectionnés.")
    )
    (princ "\nAucun MText sélectionné.")
  )
  (princ))

Merci

(defun c:CentersOfAllViewports ()
  (vl-load-com)  ; Charger la bibliothèque COM pour interagir avec AutoCAD
 
  ;; Sélectionner tous les viewports dans l'espace de présentation
  (setq ss (ssget "X" '((0 . "VIEWPORT"))))  ; Sélectionner tous les viewports

  (if ss
    (progn
      (setq i 0)  ; Initialiser un compteur pour les viewports
      (setq num (sslength ss))  ; Récupérer le nombre total de viewports
      (princ (strcat "\nNombre de viewports trouvés : " (itoa num)))  ; Afficher le nombre de viewports

      ;; Parcourir tous les viewports
      (while (< i num)
        (setq obj (ssname ss i))  ; Récupérer l'objet viewport à l'index i
        (setq vlaObj (vlax-ename->vla-object obj))  ; Convertir en objet VLA

        ;; Obtenir les coordonnées des coins du viewport
        (setq pt1 (vlax-get vlaObj 'Center))  ; Récupérer les coordonnées du centre directement

        ;; Afficher les coordonnées du centre de ce viewport
        (princ (strcat "\nCentre du viewport " (itoa (1+ i)) " : X = " (rtos (car pt1) 2 2) ", Y = " (rtos (cadr pt1) 2 2)))
        
        (setq i (1+ i))  ; Passer au viewport suivant
      )
    )
    (princ "\nAucun viewport trouvé.")
  )
  (princ)  ; Terminer proprement la fonction
)

et voici ce que autocad me renvoie : Nombre de viewports trouvés dans le layout 05 (4) : 18
Centre du viewport 1 : X = -77.12, Y = 141.92
Centre du viewport 2 : X = 42.59, Y = 171.05
Centre du viewport 3 : X = -77.12, Y = 141.92
Centre du viewport 4 : X = -12.53, Y = 69.92
Centre du viewport 5 : X = -77.12, Y = 141.92
Centre du viewport 6 : X = 41.18, Y = 64.59
Centre du viewport 7 : X = 25.38, Y = 141.92
Centre du viewport 8 : X = -179.62, Y = 141.92
Centre du viewport 9 : X = 34.88, Y = 82.78
Centre du viewport 10 : X = -77.12, Y = 141.92
Centre du viewport 11 : X = -11.61, Y = 116.53
Centre du viewport 12 : X = -77.12, Y = 141.92
Centre du viewport 13 : X = 20.74, Y = 147.38
Centre du viewport 14 : X = 30.62, Y = 66.45
Centre du viewport 15 : X = 28.00, Y = 209.95
Centre du viewport 16 : X = -177.00, Y = 209.95
Centre du viewport 17 : X = -7.96, Y = 198.22
Centre du viewport 18 : X = 14.50, Y = 129.11

Sachant que cela n'est pas cohérant car dans le layout 05 (4) j'ai uniquement 3 viewports

Merci d'avance.

Je rencontre un problème avec le LISP.

Pas facile d'expliquer ça dans un titre, mais là, avec la place que j'ai, ça devrais le faire.

Dans le cadre de mon travail, je fait des relevé sur le terrain avec un appareil GNSS (GPS plus plus en gros) qui m'insère des bloc géolocalisé.

Dans ces blocs, il y a des attributs, dont un qui me permet de savoir ce que c'est, par exemple

AFF_CE = AFFleurant Coffret Electrique - ACC_BJ = ACCessoire Boite de Jonction - etc...

Ces codes me permettent de savoir donc ce que c'est, et, pour mon plan, me permet de savoir quel symbole je dois mettre pour que le plan devienne plus lisible, mais je dois garder l'espèce de diamant, qui contiens des information (attributs non visible comme la date du levé, la precision du levé etc...).

Est-ce que vous pensez qu'un LISP faisant ça existe ? Ou il faudrais le créer ? Et si il faut le créer, sauriez (pourriez) vous m'aider ?

Ci dessous la liste de bloc en fonction de l'attribut (COD_PGOC) du diamant :

Merci 🙂

- Laurent -

Par exemple : je lance le lisp et il va chercher directement tous les objets qui ont la couleur forcé "91" et remplace ces même objets par la couleur "225,255,219 avec 93 de Luminance" et il continue avec d'autre couleur comme "31" par "255,224,194 avec 88 de Luminance".

Si quelqu'un peu m'aider, j'ai essayé de bricolé quelquechose en recherchant sur le forum mais rien ne fonctionne, j'aimerai remplacer plein de couleur dans plusieurs de mes fichiers rapidement sans avoir a le faire objet par objet.

Merci par avance pour votre compréhension et pour votre aide.

Je sollicite votre aide pour un problème que nous rencontrons.
Depuis plusieurs mois, mon collègue et moi, qui sommes de véritables novices en Lisp, travaillons sur un code ci-dessous pour créer une boîte englobante (rectangle) autour d'une sélection de blocs contenant plusieurs attributs. Nous souhaitons que cette boîte (rectangle) soit placée sur le calque "Rectangle" en couleur verte, et nous aimerions inclure une option pour demander un décalage.

Nous avons essayé d'intégrer différents morceaux de code sans succès. Si quelqu'un pouvait jeter un coup d'œil à notre code, ce serait vraiment sympa😉.

Merci d'avance pour votre aide !

(defun c:BoxBlocAttrib ( / ss i Ent ObjType AttribList Bbox MinPt MaxPt Pt1 Pt2 Pt3 Pt4 Decal)
  (setq oldcmd00 (getvar "cmdecho"))
  (setvar "cmdecho" 0)

  ;; Fonction pour décaler un point
  (defun DeltaXY (Pt1 DeltaX DeltaY)
    (list (+ (car Pt1) DeltaX)
          (+ (cadr Pt1) DeltaY)
    )
  )

  ;; Fonction pour calculer la boîte englobante entre deux points
  (defun AddToBoundingBox (bbox point)
    (setq MinPt (mapcar 'min (car bbox) point))
    (setq MaxPt (mapcar 'max (cadr bbox) point))
    (list MinPt MaxPt)
  )

  ;; Demander la sélection des blocs
  (setq ss (ssget '((0 . "INSERT")))) ; Sélection des blocs
  (setq Decal (getdist "\nDécalage ? <10> : "))
  (if (= Decal nil)(setq Decal 10))

  ;; Créer ou définir le calque "Rectangle" avec une couleur verte
  (if (not (tblsearch "layer" "Rectangle"))
    (progn
      (command "_.-layer" "_Make" "Rectangle" "_Color" "Vert" "" "")
    )
    (command "_.-layer" "_Set" "Rectangle" "")
  )

  ;; Boucler sur chaque bloc sélectionné
  (setq i 0)
  (while (< i (sslength ss))
    (setq Ent (ssname ss i))
    (setq ObjType (cdr (assoc 0 (entget Ent)))) ; Récupérer le type d'objet

    ;; Initialiser la boîte englobante
    (setq Bbox nil)

    ;; Si c'est un bloc avec attributs, on récupère les attributs et leur boîte englobante
    (if (eq ObjType "INSERT")
      (progn
        (setq AttribList (entnext Ent))
        (while (and AttribList (eq (cdr (assoc 0 (entget AttribList))) "ATTRIB"))
          (command "_ucs" "_Entity" AttribList)
          (setq Tb_list (textbox (list (cons -1 AttribList))))
          (setq Pt1 (car Tb_list))
          (setq Pt2 (cadr Tb_list))
          (if Bbox
            (setq Bbox (AddToBoundingBox Bbox Pt1))
            (setq Bbox (list Pt1 Pt2))
          )
          (setq Bbox (AddToBoundingBox Bbox Pt2))
          (setq AttribList (entnext AttribList))
        )

        ;; Décaler les points de la boîte englobante
        (setq Pt1 (car Bbox))
        (setq Pt1 (DeltaXY Pt1 (* Decal -1) (* Decal -1)))
        (setq Pt2 (cadr Bbox))
        (setq Pt2 (DeltaXY Pt2 Decal Decal))
        (setq Pt3 (list (car Pt1) (cadr Pt2)))
        (setq Pt4 (list (car Pt2) (cadr Pt1)))

        ;; Dessiner le rectangle sur le calque "Rectangle"
        (command "_layer" "_set" "Rectangle" "")
        (command "_rectang" Pt1 Pt2)

        ;; Restaurer le SCU (système de coordonnées utilisateur)
        (command "_ucs" "_p")
      )
    )

    ;; Passer à l'objet suivant
    (setq i (1+ i))
  )

  (setvar "cmdecho" oldcmd00)
  (princ)
)

Nous utilisons pas mal de fonctions LSP dans mon entreprise ainsi qu'un CUIX commun qui charge l'ensemble de ces LSP.

Avant, ces fichiers étaient localisés sur notre serveur donc il n'y avait pas de problèmes particuliers.

Sauf que maintenant nous avons des personnes extérieurs qui se connectent à notre serveur via un VPN. Alors quand sa fonctionne super.

Par contre quand la connection VPN saute pour une raison X, Autocad bug et il est pratiquement impossible de travailler.

Vu que nous utilisons OneDrive pour l'entreprise également, nous essayons de mettre les fichiers de configuration de Autocad dessus ainsi que les fichiers LSP et CUIX.

J'ai réussi à configurer les liens des fichiers supports avec %USERPROFILE% pour prendre en compte le nom de l'utilisateur qui change sur chaque poste.

Par contre je ne trouve pas comment faire pour les fichiers LSP chargés par le CUIX. Quand j'importe le profil, les fonctions ne fonctionnent pas car il ne trouve pas les bons fichiers.

Une idée comment utiliser %USERPROFILE% pour les fichiers LSP chargés par le CUIX ?

Merci !

Qu'en est il plus précisément ?...

Comment ça se traduit en LISP ?...

Je vais tenter de répondre à ces questions.

Une fonction récursive est une fonction qui s'appelle elle même pendant son exécution.

En LISP on reconnaît un fonction récursive à l'appel fait à elle même dans son DEFUN.

L'exemple le plus souvent utilisé pour expliquer la récursivité est la fonction factorielle, petit rappel de math :

Factorielle n s'écrit n!

si n = 0 => n! = 1

et

pour tout n > 0 => n! = n * (n - 1)!

Par exemple :

4! = 4 * 3! = 4 * 3 * 2! = 4 * 3 * 2 * 1! = 4 * 3 * 2 * 1 = 24

En LISP, on peut écrire :

(defun fact (n)
 (if (zerop n)
   1
   (* n (fact (1- n)))
 )
)

Une fonction définie récursivement contient au moins une condition d'arrêt : (zerop n) -> 1

et un appel récursif : (* n (fact (1- n)))

Par exemple : (fact 4) sera interprété une première fois (* 4 (fact 3)), puis (* 4 (* 3 (fact 2))) etc,...

jusqu'à (* 4 (* 3 (* 2 (* 1 (fact 0))))) où (fact 0) remplit la condition d'arrêt et retourne 1

On appelle "empilement" les appels successifs à la fonction jusquà la condition d'arrêt

et "dépilement" leurs interprétations depuis cette condition.

On peut voir la procédure dans la fenêtre de suivi de la console VisualLISP en "traçant" la fonction fact avec la fonction LISP trace :

http://img155.imageshack.us/img155/4381/rcurs1ku8.png

Du fait de l'utilisation de la pile, l'usage de fonctions récursives permet souvent de faire de manière plus élégante ce qui avec une boucle (while) aurait nécéssité l'utilisation d'une nouvelle variable pour stocker les résultats successifs.

Par exemple la fonction fact définie de manière itérative, avec while :

(defun fact (n / rslt)
 (cond
   ((    (T
    (setq rslt n)
    (while (       (setq rslt (* rslt (setq n (1- n))))
    )
   )
 )
)

L'usage de fonction récursives est aussi très pratique avec des listes.

;;; TRUNC Retourne la liste tronquée à partir de la première occurrence
;;; de l'expression (liste complémentaire de celle retournée par MEMBER)

(defun trunc (expr lst)
 (cond
   ;; Conditions d'arrêt
   ((or (null lst)
 (equal (car lst) expr)
    )
    nil
   )
   ;; Appel récursif
   (T (cons (car lst) (trunc expr (cdr lst))))
 )
)

http://img86.imageshack.us/img86/4333/rcurs2je6.png

Pour comparaison, la fonction trunc définie de façon itérative :

(defun trunc (elt lst / n rslt)
 (setq n 0)
 (while
   ;; Conditions d'arrêt
   (and (	 (not (equal (nth n lst) elt))
   )
    (setq rslt (cons (nth n lst) rslt))
    (setq n (1+ n))
 )
 ;; Résultat
 (reverse rslt)
) 

Les fonctions récursives ont aussi quelques inconvénients, la pile n'est pas infinie et ne permet qu'un certains nombre d'évaluations au-delà duquel la "limite de la pile interne atteinte" produit une erreur. D'après mes essais, cette limite semble être fixée à 19975 sur AutoCAD.

On ne peut donc utiliser de fonction récursives sur des listes de plus de 19975 éléments.

L'avantage de cet inconvénient est que si la condition d'arrêt n'est jamais remplie, on n'entre pas dans une boucle sans fin comme avec (while ...)

On peut faire le test avec (fact -1)

D'autre part, l'exécution des fonctions récursives semble plus lente que celle des fonctions itératives et ce d'autant plus que le nombre d'interprétations (hauteur de la pile) est important.

Bien évidemment, tous les eventuels ajouts, remarques, corrections, questions sont les bienvenus.

[Edité le 6/8/2006 par (gile)]

En cherchant dans le forum j'ai trouvé une routine qui pourrait me convenir mais ce dernier s'applique correctement à un attribut et non à une cotation.

quelqu'un pourrait m'aider à l'adapter à une cotation ? 

je mets un dwg pour le faire le test

(defun c:COPYATT (/ selatt selatt2 objatt objatt2) 
  (setq selatt (nentsel (strcat "\nSélectionner l'attribut ou le texte à copier :")))
  (setq objatt (vlax-ename->vla-object (car selatt)))
  (if (setq selatt2 (nentsel (strcat "\nSélectionner l'attribut ou le texte de destination :"))) 
    (progn (setq objatt2 (vlax-ename->vla-object (car selatt2))) 
           (if 
             (and 
               (or (= (vla-get-ObjectName objatt) "AcDbText") 
                   (= (vla-get-ObjectName objatt) "AcDbMText")
                   (= (vla-get-ObjectName objatt) "AcDbAttribute")
               )
               (or (= (vla-get-ObjectName objatt2) "AcDbText") 
                   (= (vla-get-ObjectName objatt2) "AcDbMText")
                   (= (vla-get-ObjectName objatt2) "AcDbAttribute")
               )
             )
             (vla-put-textstring objatt2 (vla-get-textstring objatt))
           ))
    (command "_TEXT" (getpoint) 4 100 (vla-get-textstring objatt)) ;Hauteur de texte et orientation à 4 et 100g, à ajuster
  )
  (princ)
)

Merci par avance 

Test.dwg

Certaines taches sont répétitives et j aimerai créer un lisp pour ces taches.

J'y arrive presque (merci quand meme chatgpt ;))

mais là je bloque.

Ce que fait mon lisp pour l instant :

il enregistre mon dwg

met le layer "COTATIONS" en arrière plan

créer le pdf du layout "AVEC COTES" 

se mets sur le layer "COUPES BRUTES"

supprime les layers non désirés

explod le dessin

enregistre en dxf

ouvre le dxf.

Ce que je n arrive pas :

que les opérations de suppression et expolod ne se fassent que dans le dxf, modifier l ordre ca va mais le lisp ne continue pas dans le dxf ouvert....

explod me demande des validations à cause des objet non explodable (? si ca se dit ?) j'ai besoin de n explode que 3 layers

Quelqu'un pourrait il m'aider sur ces deux points ?

merci

DXFAUTO.lsp

j'essaye d'automatiser des choses sur mes heures creuses/perdues et bon ... je butte..

j'ai donc un lisp qui propose à mon utilisateur de dessiner un réseau (VRD), et suivant le type de réseau choisi dans une liste d'un léger fichier DCL.

mais la création du calque avec entmakeX me pose problème au niveau de la couleur et du style de trait.

mais déjà la si je veux faire un load automatique du style de trait FANTOME bêtement depuis acadiso.lin j ai tout le mal du monde (pour le moment j ai donc simplement pré chargé ce trait avant de lancer la fonction..

j'ai une création de valeurs qui suit le choix de l'opérateur dans la fenêtre dcl

      (cond
        ((or (wcmatch chosenNetwork Type_reseau_1))
         (progn
           (setq layerColor "1") ; Rouge
           (setq layerLinetype "FANTOME")
           (setq layerLineweight 50)
         )
        )
        ((or (wcmatch chosenNetwork Type_reseau_2))
         (progn
           (setq layerColor "3") ; Vert
           (setq layerLinetype "FANTOME")
           (setq layerLineweight 50)
         )
        )
        ((or (wcmatch chosenNetwork Type_reseau_3))
         (progn
           (setq layerColor "114") ; Couleur 114
           (setq layerLinetype "FANTOME")
           (setq layerLineweight 50)
         )
        )
      )

mais je n'arrive pas à créer le calque avec le bon style de trait et la bonne couleur.. :

;; Créer le calque s'il n'existe pas
      (if (not (tblsearch "LAYER" chosenNetwork))
       (entmakex (list '(0 . "LAYER")
                      '(100 . "AcDbSymbolTableRecord")
                      '(100 . "AcDbLayerTableRecord")
                       (2 . chosenNetwork)
                      '(70 . 0)
                      '(62 . layerColor)   ;; couleur du calque
                      '(6 . layerLinetype)  ;; Type de ligne FANTOME
                      '(370 . 50)  ;; épaisseur de ligne 0.50 mm
               )
       )
      )

à la création du calque  j'ai une erreur DFX 62, les variables dans le entmakex me pose problème.

si une bonne âme passe par là 😀

Je souhaite créer un code Lisp me permettant de déplacer une polyligne en indiquant une profondeur et une épaisseur de canalisation, je souhaite également que l'utilisateur puisse sélectionner le calque dans lequel la polyligne sera grâce à un menu déroulant. Pour ce faire j'ai écrit un programme Lisp fonctionnant de paire avec un programme DCL . Cependant je suis encore débutant avec ce langage de programmation et je n'arrive pas à corriger mon erreur :

erreur: type d'argument incorrect: stringp TRAITER-VALEURS

Voici mon code DCL :

dialog {
  label = "DeplacerPolyligne";
  : edit_box {
    label = "Profondeur (m) :";
    key = "profondeur";
  }
  : edit_box {
    label = "Diametre (mm) :";
    key = "diametre";
  }
  : popup_list {
    label = "Calque :";
    key = "calque";
    width = 30;
    allow_accept = true;
    is_cancel = true;
    fixed_width = true;
  }
  : row {
    : button {
      label = "Traiter";
      key = "maj";
    }
  }
}

Et voici mon code Lisp : 

;; Définition de la fonction pour traiter les valeurs saisies
(defun traiter-valeurs (ctl)
  (prompt (strcat "\nContrôle déclenchant l'action : " (type ctl)))
  (if (= ctl "maj")
      (progn
        (prompt "\nBouton Traiter cliqué")
        ;; Traitement des valeurs saisies
        (setq pline (car (entsel "\nSélectionnez une polyligne : ")))
        (prompt (strcat "\nSélectionné polyligne : " (itoa pline)))
        (setq profondeurMM (atoi (get_tile "profondeur"))) ; Récupérer la valeur de la profondeur en mm
        (prompt (strcat "\nProfondeur : " (rtos profondeurMM 2 3)))
        (setq profondeur (/ profondeurMM 1000.0)) ; Convertir en mètres
        (prompt (strcat "\nProfondeur : " (rtos profondeur 2 3)))
        (setq diametreMM (atoi (get_tile "diametre"))) ; Récupérer la valeur du diamètre en mm
        (prompt (strcat "\nDiamètre : " (rtos diametreMM 2 3)))
        (setq diametreM (/ diametreMM 1000.0)) ; Convertir en mètres
        (prompt (strcat "\nDiamètre : " (rtos diametreM 2 3)))
        (setq calque (get_tile "calque")) ; Récupérer le calque sélectionné
        (prompt (strcat "\nCalque : " calque))

        ;; Vérification des valeurs saisies
        (if (and pline profondeur diametreM calque)
            (progn
              ;; Calculs pour le déplacement
              (setq currentElevation (cadddr (assoc 10 (entget pline))))
              (setq filEau (- currentElevation profondeur))
              (setq centreReseau (+ filEau (/ diametreM 2)))

              ;; Déplacement de la polyligne
              (setq vertice (getvar 'VIEWSIZE))
              (command "_.UCS" "_N" "_Z" vertice)
              (command "_.MOVE" pline "" "" (list 0.0 0.0 centreReseau))
              (command "_.UCS" "_P")

              ;; Affichage d'un message de débogage pour indiquer le succès du traitement
              (prompt "\nDéplacement terminé avec succès.")
            )
            (prompt "\nErreur: Sélection, profondeur, diamètre ou calque invalide.")
        )
        ;; Fermeture de la boîte de dialogue
        (unload_dialog diag)
      )
  )
)

;; Définition de la fonction principale pour afficher la boîte de dialogue et traiter les valeurs
(defun c:DeplacerPolyligne ()
  (prompt "\nDébut de la fonction DeplacerPolyligne")

  ;; Chargement de la boîte de dialogue
  (setq diag (load_dialog "Boite_de_dialogue.dcl"))
  (prompt "\nBoîte de dialogue chargée")

  ;; Affichage de la boîte de dialogue
  (if (not (new_dialog "Boite_de_dialogue" diag))
      (exit)
  )
  (prompt "\nBoîte de dialogue affichée")

  ;; Définition de l'action pour le bouton "Traiter" dans la boîte de dialogue
  (action_tile "maj" 'traiter-valeurs)
  
  ;; Démarrage de la boîte de dialogue
  (if (= 1 (start_dialog))
      (progn
        (prompt "\nBoîte de dialogue fermée avec succès.")
      )
      (prompt "\nÉchec de la fermeture de la boîte de dialogue.")
  )

  (prompt "\nFin de la fonction DeplacerPolyligne")
)

Mon code n'est peut être pas très optimisé mais comme je disais je débute, j'ai essayé d'ajouter des commentaires pour que le code soit parfaitement compréhensible. J'ai essayé de placer des messages de débogages pour savoir d'où l'erreur venait mais même avec cela j'ai du mal à corriger mon erreur.

Merci d'avance pour tout indice ou piste pour me débloquer.

Clément.

Je voudrais savoir s'il est possible d'avoir un Lisp qui orienterait mes points dans le calque PTTOPO selon une polyligne, puis les basculerait dans le calque de cette même polyligne ? 

Egalement, si par la suite il est possible de supprimer le point représentant le Z TN et de ne garder au visuel que le matricule et Z excentré ?

Voici des captures d'écrans pour plus de compréhension.

Merci a vous !

PS de la Moderation : meme Sujet sur le forum "Autodesk_SIG" de georezo.net/forum