Jump to content

code not optimized


depekill

Recommended Posts

I know I'm asking a lot but I coded part of this and it's too repetitive, poorly organized and lots of things I don't know how to do. the code works but it's not optimizing at all, too much unnecessary repetition. I use autocad LT 2024 so certain functions are not accessible.

-------------------------------------------------------------------

(setq *nom-ctr* "") ; Initialisation de la variable globale nom-ctr

(setq *id-ctr* "")

(setq *nom-rep* "")

(setq *id-rep* "")

(setq *fp-b1* "")

(setq *bouton-b1* "")

(setq *th-b1* "")

(setq *io-b1* "")

(setq *det-b2* "")

(setq *fp-b2* "")

(setq *bouton-b2* "")

(setq *th-b2* "")

(setq *io-b2* "")

(setq *det-b3* "")

(setq *fp-b3* "")

(setq *bouton-b3* "")

(setq *th-b3* "")

(setq *io-b3* "")

(setq *det-b4* "")

(setq *fp-b4* "")

(setq *bouton-b4* "")

(setq *th-b4* "")

(setq *io-b4* "")

(setq *si-l1* "")

(setq *si-l2* "")

(setq *si-l3* "")

(setq *si-l4* "")

(setq *si-l5* "")

(setq *si-l6* "")

(setq *vide* "200")



(defun c:s (/ temp fun file dcl_id id_ctr nom_ctr det_b1 fp_b1 bouton_b1 th_b1 det_b2 fp_b2 bouton_b2 th_b2 det_b3 fp_b3 bouton_b3 th_b3 det_b4 fp_b4 bouton_b4 th_b4 io_b1 io_b2 io_b3 io_b4)

  (setq temp (vl-filename-mktemp "Tmp.dcl")

        file (open temp "w"))

  (write-line

    (strcat

    "IncrInputbox:dialog{

    label=\"Constructeur - Schéma unifilaire Incendie\";

    :row{"

      "  :edit_box{label=\"ID CTR :\"; key=\"c:idCTR\";}"

      "  :edit_box{label=\"Nom CTR :\"; key=\"c:nomCTR\";}"

    "}"

     ":row{"

      "  :edit_box{label=\"ID REP :\"; key=\"c:idREP\";}"

      "  :edit_box{label=\"Nom REP :\"; key=\"c:nomREP\";}"

    "}"

    ":row{"

      "  :edit_box{label=\"Detecteur B1 :\"; key=\"c:det_b1\";}"

      "  :edit_box{label=\"Faux-plafond B1 :\"; key=\"c:fp_b1\";}"

      "  :edit_box{label=\"Bouton B1 :\"; key=\"c:bouton_b1\";}"

      "  :edit_box{label=\"Thermique B1 :\"; key=\"c:th_b1\";}"

      "  :edit_box{label=\"I/O B1 :\"; key=\"c:io_b1\";}"

    "}"

    ":row{"

      "  :edit_box{label=\"Detecteur B2 :\"; key=\"c:det_b2\";}"

      "  :edit_box{label=\"Faux-plafond B2 :\"; key=\"c:fp_b2\";}"

      "  :edit_box{label=\"Bouton B2 :\"; key=\"c:bouton_b2\";}"

      "  :edit_box{label=\"Thermique B2 :\"; key=\"c:th_b2\";}"

      "  :edit_box{label=\"I/O B2 :\"; key=\"c:io_b2\";}"

    "}"

    ":row{"

      "  :edit_box{label=\"Detecteur B3 :\"; key=\"c:det_b3\";}"

      "  :edit_box{label=\"Faux-plafond B3 :\"; key=\"c:fp_b3\";}"

      "  :edit_box{label=\"Bouton B3 :\"; key=\"c:bouton_b3\";}"

      "  :edit_box{label=\"Thermique B3 :\"; key=\"c:th_b3\";}"

      "  :edit_box{label=\"I/O B3 :\"; key=\"c:io_b3\";}"

    "}"

    ":row{"

      "  :edit_box{label=\"Detecteur B4 :\"; key=\"c:det_b4\";}"

      "  :edit_box{label=\"Faux-plafond B4 :\"; key=\"c:fp_b4\";}"

      "  :edit_box{label=\"Bouton B4 :\"; key=\"c:bouton_b4\";}"

      "  :edit_box{label=\"Thermique B4 :\"; key=\"c:th_b4\";}"

      "  :edit_box{label=\"I/O B4 :\"; key=\"c:io_b4\";}"

    "}"

    ":row{"

      "  :edit_box{label=\"S/L1 :\"; key=\"c:si_l1\";}"

      "  :edit_box{label=\"S/L2 :\"; key=\"c:si_l2\";}"

      "  :edit_box{label=\"S/L3 :\"; key=\"c:si_l3\";}"

      "  :edit_box{label=\"S/L4 :\"; key=\"c:si_l4\";}"

      "  :edit_box{label=\"S/L5 :\"; key=\"c:si_l5\";}"

      "  :edit_box{label=\"S/L6 :\"; key=\"c:si_l6\";}"

    "}"

    ":row{"

    ":radio_column{key=\"fun\";"

      ":radio_button{"

      "label=\"Générer le schéma unifilaire\";value=\"1\";key=\"c:generer_plan\";}}"

      "  :button{label=\"Importer vers CSV\"; key=\"import_csv\";}"

      "  :button{label=\"Exporter vers CSV\"; key=\"export_csv\";}"

    "}"

    ":row{"

      "ok_cancel;}"

    "}"

    )

    file)

    (close file)

  (setq dcl_id (load_dialog temp))

  (if (not (new_dialog "IncrInputbox" dcl_id))

      (exit))

 (action_tile

    "accept"

    "(setq fun (get_tile \"fun\")

    *nom-ctr* (get_tile \"c:nomCTR\")

    *id-ctr* (get_tile \"c:idCTR\")

    *nom-rep* (get_tile \"c:nomREP\")

    *id-rep* (get_tile \"c:idREP\")

    *det-b1* (get_tile \"c:det_b1\")

    *fp-b1* (get_tile \"c:fp_b1\")

    *bouton-b1* (get_tile \"c:bouton_b1\")

    *th-b1* (get_tile \"c:th_b1\")

    *io-b1* (get_tile \"c:io_b1\")

    *det-b2* (get_tile \"c:det_b2\")

    *fp-b2* (get_tile \"c:fp_b2\")

    *bouton-b2* (get_tile \"c:bouton_b2\")

    *th-b2* (get_tile \"c:th_b2\")

    *io-b2* (get_tile \"c:io_b2\")

    *det-b3* (get_tile \"c:det_b3\")

    *fp-b3* (get_tile \"c:fp_b3\")

    *bouton-b3* (get_tile \"c:bouton_b3\")

    *th-b3* (get_tile \"c:th_b3\")

    *io-b3* (get_tile \"c:io_b3\")

    *det-b4* (get_tile \"c:det_b4\")

    *fp-b4* (get_tile \"c:fp_b4\")

    *bouton-b4* (get_tile \"c:bouton_b4\")

    *th-b4* (get_tile \"c:th_b4\")

    *io-b4* (get_tile \"c:io_b4\")

    *si-l1* (get_tile \"c:si_l1\")

    *si-l2* (get_tile \"c:si_l2\")

    *si-l3* (get_tile \"c:si_l3\")

    *si-l4* (get_tile \"c:si_l4\")

    *si-l5* (get_tile \"c:si_l5\")

    *si-l6* (get_tile \"c:si_l6\")

    ) (done_dialog)")

  (action_tile

    "export_csv"

    "(progn (princ \"Export CSV action triggered.\")(export_csv_data))")

  (action_tile

    "import_csv"

    "(progn (princ \"Import CSV action triggered.\")(import_csv_data))")

    (action_tile

    "generer_plan"

    "(progn (princ \"generer_plan.\")(c:generer_plan))")  ; Appel de la fonction c:generer_plan

  (start_dialog)

  (unload_dialog dcl_id)

   (and fun (apply (read fun) nil))

  (princ))



(defun split-string (str sep)

  (setq result '())

  (setq start 1)

  (setq end (vl-string-search sep str start))

  (while end

    (setq sub (substr str start (- end start)))

    (if (/= (strlen sub) 0) ; Vérifier si la sous-chaîne n'est pas vide

        (setq result (cons sub result)))

    (setq start (+ end 1))

    (setq end (vl-string-search sep str start))

    (while (and (= (substr str start 1) " ") (< start (strlen str)))

      (setq start (+ start 1))) ; Avancer jusqu'au prochain caractère non-espace

  )

  (setq sub (substr str start)) ; Traiter la dernière sous-chaîne

  (if (/= (strlen sub) 0) ; Vérifier si la dernière sous-chaîne n'est pas vide

      (setq result (cons sub result)))

  (reverse result)

)



(defun compare-int-strings (a b)

  (cond

    ((< (atoi a) (atoi b)) t)

    ((> (atoi a) (atoi b)) nil)

    (t (vl-string-lessp a b))

  )

)





(defun c:generer_plan ()

  (setq hauteur 5)

  (setq angle 0)



  ;; Utilisation de la variable globale *nom-ctr*

  (setq info_ctr (strcat *id-ctr* " \n " *nom-ctr* " \n " *id-rep* " \n " *nom-rep* " \n " *det-b1* " \n " *fp-b1* " \n " *bouton-b1* " \n " *th-b1* " \n " *io-b1* " "

                           *det-b2* " \n " *fp-b2* " \n " *bouton-b2* " \n " *th-b2* " \n " *io-b2* " "

                           *det-b3* " \n " *fp-b3* " \n " *bouton-b3* " \n " *th-b3* " \n " *io-b3* " "

                           *det-b4* " \n " *fp-b4* " \n " *bouton-b4* " \n " *th-b4* " \n " *io-b4* " "

                           *si-l1* " \n " *si-l2* " \n " *si-l3* " \n " *si-l4* " \n " *si-l5* " \n " *si-l6*))



  ;;;(repeat 2 ; Nombre de points à sélectionner

    ;;;(setq point (getpoint "\nEntrez le point d'insertion du texte : "))

    ;;;(command "_.TEXT" point hauteur angle info_ctr) ; Utilisation de la valeur récupérée

  ;;;) ; axe xyz puis rotation x 1,  rotation y 1 etangle 0

  ; (command "_.insert" "rec2" "10,10,10" 1 1 0)



  (setvar "ATTDIA" 0)



(setq all-lists (list det-b1-list fp-b1-list bouton-b1-list th-b1-list io-b1-list))



(setq det-b1-list (if (not (equal *det-b1* "")) (split-string *det-b1* " ") '()))

(setq fp-b1-list (if (not (equal *fp-b1* "")) (split-string *fp-b1* " ") '()))

(setq bouton-b1-list (if (not (equal *bouton-b1* "")) (split-string *bouton-b1* " ") '()))

(setq th-b1-list (if (not (equal *th-b1* "")) (split-string *th-b1* " ") '()))

(setq io-b1-list (if (not (equal *io-b1* "")) (split-string *io-b1* " ") '()))

(setq vide-list (if (not (equal *vide* "")) (split-string *vide* " ") '()))




(setq combined-list (append det-b1-list fp-b1-list bouton-b1-list th-b1-list io-b1-list))



(setq compter (length combined-list)) ; Obtenez la longueur de la liste combinée



(if (/= (rem compter 2) 0) ; Vérifiez si la longueur de la liste combinée est impaire

(setq combined-list (append det-b1-list fp-b1-list bouton-b1-list th-b1-list io-b1-list vide-list)))






(setq combined-list (vl-sort combined-list 'compare-int-strings))



(setq combined-list-length (length combined-list)) ; Obtenez la longueur de la liste combinée



(setq half-length (/ (+ combined-list-length 1) 2))





(setq x 0) ; Initialisation de la coordonnée x

(setq xp 10) ; Initialisation de la coordonnée x

(setq xpp 10) ; Initialisation de la coordonnée x

(setq x1 0) ; Initialisation de la coordonnée x

(setq y1 0) ; Initialisation de la coordonnée x

(setq yp (+ y1 40))  ; Initialisation de la coordonnée x

(setq y2 -250) ; Initialisation de la coordonnée x

(setq ypp (- y2 40))  ; Initialisation de la coordonnée x




(setq index 0) ; Initialisation de l'inde



(foreach original-val combined-list

 (if (< index half-length)

      (progn ; Si l'index est inférieur à la moitié

        ;; Ajoutez votre logique de traitement pour la première moitié ici

        (setq val

              (if (> (atoi original-val) 99)

                  (strcat *id-ctr* ".1." original-val)

                (if (<= 1 (atoi original-val) 9)

                    (strcat *id-ctr* ".1.00" original-val)

                  (strcat *id-ctr* ".1.0" original-val))))

        (foreach lst all-lists

          (if (member original-val lst)

              (progn

                (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val)

                (cond

                  ((equal lst fp-b1-list) (command "_.insert" "Detecteur faux plafond" (list x y1 0) 1 1 0 val))

                  ((equal lst bouton-b1-list) (command "_.insert" "Declencheur manuelle" (list x 0) 1 1 0 val))

                  ((equal lst th-b1-list) (command "_.insert" "Detecteur thermique ISO" (list x y1 0) 1 1 0 val))

                  ((equal lst io-b1-list) (command "_.insert" "Module IO Incendie" (list x y1 0) 1 1 0 val))

                  ((equal lst det-b1-list) (command "_.insert" "Detecteur optique iso" (list x y1 0) 1 1 0 val)))

                (setq x (+ x 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

                (setq xp (+ x 10)))) ; Initialisation de la coordonnée xp

          )

           (setq index (1+ index)) ; Incrémentation de l'index pour passer à l'élément suivant

        )

    )

    ; Sortez de la boucle si nous avons déjà traité la première moitié

  )



  (setq xx (- x 150)) ; Initialisation de la coordonnée x à x - 150

  (command "_.insert" "barre1" (list xx 0 0) 1 1 0)



(setq index2 (- combined-list-length 1)) ; Initialisation de l'index pour la deuxième boucle en partant de la fin de la liste combinée



(foreach original-val (reverse combined-list) ; Parcours de la liste combinée en ordre inverse

  (if (>= index2 half-length)

      (progn ; Si l'index est supérieur ou égal à la moitié

        ;; Ajoutez votre logique de traitement pour la deuxième moitié ici

       (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".1." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".1.00" original-val)

          (strcat *id-ctr* ".1.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b1-list)

        (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

            (command "_.insert" "fp" (list x1 y2 0) 1 1 0 val))

          (if (member original-val bouton-b1-list)

          (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

              (command "_.insert" "bp" (list x1 y2 0) 1 1 0 val))

            (if (member original-val th-b1-list)

            (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "th" (list x1 y2 0) 1 1 0 val))

                (if (member original-val vide-list)

                (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "vide2" (list x1 y2 0) 1 1 0 val))

              (if (member original-val io-b1-list)

              (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                  (command "_.insert" "io" (list x1 y2 0) 1 1 0 val))

                  (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "position" (list x1 y2 0) 1 1 0 val)))))))

        (setq x1 (+ x1 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xpp (+ x1 10)) ; Incrémentation de x pour placer le prochain détecteur à côté

        )

     ; Sortez de la boucle si nous avons déjà traité la deuxième moitié

    )

  (setq index2 (1- index2)) ; Décrémentation de l'index pour suivre la position actuelle dans la liste

  )




  (setvar "ATTDIA" 1)





  (setq hauteur 5)

  (setq angle 0)



  ;; Utilisation de la variable globale *nom-ctr*

  (setq info_ctr (strcat *id-ctr* " \n " *nom-ctr* " \n " *id-rep* " \n " *nom-rep* " \n " *det-b1* " \n " *fp-b1* " \n " *bouton-b1* " \n " *th-b1* " \n " *io-b1* " "

                           *det-b2* " \n " *fp-b2* " \n " *bouton-b2* " \n " *th-b2* " \n " *io-b2* " "

                           *det-b3* " \n " *fp-b3* " \n " *bouton-b3* " \n " *th-b3* " \n " *io-b3* " "

                           *det-b4* " \n " *fp-b4* " \n " *bouton-b4* " \n " *th-b4* " \n " *io-b4* " "

                           *si-l1* " \n " *si-l2* " \n " *si-l3* " \n " *si-l4* " \n " *si-l5* " \n " *si-l6*))



  ;;;(repeat 2 ; Nombre de points à sélectionner

    ;;;(setq point (getpoint "\nEntrez le point d'insertion du texte : "))

    ;;;(command "_.TEXT" point hauteur angle info_ctr) ; Utilisation de la valeur récupérée

  ;;;) ; axe xyz puis rotation x 1,  rotation y 1 etangle 0

  ; (command "_.insert" "rec2" "10,10,10" 1 1 0)



  (setvar "ATTDIA" 0)



(setq det-b2-list (if (not (equal *det-b2* "")) (split-string *det-b2* " ") '()))

(setq fp-b2-list (if (not (equal *fp-b2* "")) (split-string *fp-b2* " ") '()))

(setq bouton-b2-list (if (not (equal *bouton-b2* "")) (split-string *bouton-b2* " ") '()))

(setq th-b2-list (if (not (equal *th-b2* "")) (split-string *th-b2* " ") '()))

(setq io-b2-list (if (not (equal *io-b2* "")) (split-string *io-b2* " ") '()))

(setq vide-list (if (not (equal *vide* "")) (split-string *vide* " ") '()))





(setq combined-list (append det-b2-list fp-b2-list bouton-b2-list th-b2-list io-b2-list))



(setq compter (length combined-list)) ; Obtenez la longueur de la liste combinée



(if (/= (rem compter 2) 0) ; Vérifiez si la longueur de la liste combinée est impaire

(setq combined-list (append det-b2-list fp-b2-list bouton-b2-list th-b2-list io-b2-list vide-list)))






(setq combined-list (vl-sort combined-list 'compare-int-strings))



(setq combined-list-length (length combined-list)) ; Obtenez la longueur de la liste combinée



(setq half-length (/ (+ combined-list-length 1) 2))





(setq x 0) ; Initialisation de la coordonnée x

(setq xp 10) ; Initialisation de la coordonnée x

(setq xpp 10) ; Initialisation de la coordonnée x

(setq x1 0) ; Initialisation de la coordonnée x

(setq y1 -600) ; Initialisation de la coordonnée x

(setq yp (+ y1 40))  ; Initialisation de la coordonnée x

(setq y2 -850) ; Initialisation de la coordonnée x

(setq ypp (- y2 40))  ; Initialisation de la coordonnée x




(setq index 0) ; Initialisation de l'inde



(foreach original-val combined-list

  (if (< index half-length)

      (progn ; Si l'index est inférieur à la moitié

        ;; Ajoutez votre logique de traitement pour la première moitié ici

        (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".2." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".2.00" original-val)

          (strcat *id-ctr* ".2.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b2-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b2-list

              (command "_.insert" "Detecteur faux plafond" (list x y1 0) 1 1 0 val))



          (if (member original-val bouton-b2-list)

          (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b2-list

              (command "_.insert" "Declencheur manuelle" (list x y1 0) 1 1 0 val))

            (if (member original-val th-b2-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b2-list

                (command "_.insert" "Detecteur thermique ISO" (list x y1 0) 1 1 0 val))

              (if (member original-val io-b2-list)

              (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b2-list

                  (command "_.insert" "Module IO Incendie" (list x y1 0) 1 1 0 val))

                  (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b2-list

                (command "_.insert" "Detecteur optique iso" (list x y1 0) 1 1 0 val))))))

        (setq x (+ x 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xp (+ x 10))  ; Initialisation de la coordonnée x

        )

     ; Sortez de la boucle si nous avons déjà traité la première moitié

    )

  (setq index (1+ index)) ; Incrémentation de l'index pour suivre la position actuelle dans la liste

  )



  (setq xx (- x 150)) ; Initialisation de la coordonnée x à x - 150

  (command "_.insert" "barre1" (list xx -600 0) 1 1 0)



(setq index2 (- combined-list-length 1)) ; Initialisation de l'index pour la deuxième boucle en partant de la fin de la liste combinée



(foreach original-val (reverse combined-list) ; Parcours de la liste combinée en ordre inverse

  (if (>= index2 half-length)

      (progn ; Si l'index est supérieur ou égal à la moitié

        ;; Ajoutez votre logique de traitement pour la deuxième moitié ici

       (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".2." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".2.00" original-val)

          (strcat *id-ctr* ".2.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b2-list)

        (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

            (command "_.insert" "fp" (list x1 y2 0) 1 1 0 val))

          (if (member original-val bouton-b2-list)

          (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

              (command "_.insert" "bp" (list x1 y2 0) 1 1 0 val))

            (if (member original-val th-b2-list)

            (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "th" (list x1 y2 0) 1 1 0 val))

                (if (member original-val vide-list)

                (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "vide2" (list x1 y2 0) 1 1 0 val))

              (if (member original-val io-b2-list)

              (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                  (command "_.insert" "io" (list x1 y2 0) 1 1 0 val))

                  (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "position" (list x1 y2 0) 1 1 0 val)))))))

        (setq x1 (+ x1 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xpp (+ x1 10)) ; Incrémentation de x pour placer le prochain détecteur à côté

        )

     ; Sortez de la boucle si nous avons déjà traité la deuxième moitié

    )

  (setq index2 (1- index2)) ; Décrémentation de l'index pour suivre la position actuelle dans la liste

  )




  (setvar "ATTDIA" 1)





(setq hauteur 5)

  (setq angle 0)



  ;; Utilisation de la variable globale *nom-ctr*

(setq info_ctr (strcat *id-ctr* " \n " *nom-ctr* " \n " *id-rep* " \n " *nom-rep* " \n " *det-b1* " \n " *fp-b1* " \n " *bouton-b1* " \n " *th-b1* " \n " *io-b1* " "

                           *det-b2* " \n " *fp-b2* " \n " *bouton-b2* " \n " *th-b2* " \n " *io-b2* " "

                           *det-b3* " \n " *fp-b3* " \n " *bouton-b3* " \n " *th-b3* " \n " *io-b3* " "

                           *det-b4* " \n " *fp-b4* " \n " *bouton-b4* " \n " *th-b4* " \n " *io-b4* " "

                           *si-l1* " \n " *si-l2* " \n " *si-l3* " \n " *si-l4* " \n " *si-l5* " \n " *si-l6*))



  ;;;(repeat 2 ; Nombre de points à sélectionner

    ;;;(setq point (getpoint "\nEntrez le point d'insertion du texte : "))

    ;;;(command "_.TEXT" point hauteur angle info_ctr) ; Utilisation de la valeur récupérée

  ;;;) ; axe xyz puis rotation x 1,  rotation y 1 etangle 0

  ; (command "_.insert" "rec2" "10,10,10" 1 1 0)



  (setvar "ATTDIA" 0)



(setq det-b3-list (if (not (equal *det-b3* "")) (split-string *det-b3* " ") '()))

(setq fp-b3-list (if (not (equal *fp-b3* "")) (split-string *fp-b3* " ") '()))

(setq bouton-b3-list (if (not (equal *bouton-b3* "")) (split-string *bouton-b3* " ") '()))

(setq th-b3-list (if (not (equal *th-b3* "")) (split-string *th-b3* " ") '()))

(setq io-b3-list (if (not (equal *io-b3* "")) (split-string *io-b3* " ") '()))

(setq vide-list (if (not (equal *vide* "")) (split-string *vide* " ") '()))





(setq combined-list (append det-b3-list fp-b3-list bouton-b3-list th-b3-list io-b3-list))



(setq compter (length combined-list)) ; Obtenez la longueur de la liste combinée



(if (/= (rem compter 2) 0) ; Vérifiez si la longueur de la liste combinée est impaire

(setq combined-list (append det-b3-list fp-b3-list bouton-b3-list th-b3-list io-b3-list vide-list)))






(setq combined-list (vl-sort combined-list 'compare-int-strings))



(setq combined-list-length (length combined-list)) ; Obtenez la longueur de la liste combinée



(setq half-length (/ (+ combined-list-length 1) 2))





(setq x 0) ; Initialisation de la coordonnée x

(setq xp 10) ; Initialisation de la coordonnée x

(setq xpp 10) ; Initialisation de la coordonnée x

(setq x1 0) ; Initialisation de la coordonnée x

(setq y1 -1200) ; Initialisation de la coordonnée x

(setq yp (+ y1 40))  ; Initialisation de la coordonnée x

(setq y2 -1450) ; Initialisation de la coordonnée x

(setq ypp (- y2 40))  ; Initialisation de la coordonnée x




(setq index 0) ; Initialisation de l'inde



(foreach original-val combined-list

  (if (< index half-length)

      (progn ; Si l'index est inférieur à la moitié

        ;; Ajoutez votre logique de traitement pour la première moitié ici

        (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".3." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".3.00" original-val)

          (strcat *id-ctr* ".3.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b3-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b3-list

              (command "_.insert" "Detecteur faux plafond" (list x y1 0) 1 1 0 val))



          (if (member original-val bouton-b3-list)

          (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b3-list

              (command "_.insert" "Declencheur manuelle" (list x y1 0) 1 1 0 val))

            (if (member original-val th-b3-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b3-list

                (command "_.insert" "Detecteur thermique ISO" (list x y1 0) 1 1 0 val))

              (if (member original-val io-b3-list)

              (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b3-list

                  (command "_.insert" "Module IO Incendie" (list x y1 0) 1 1 0 val))

                  (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b3-list

                (command "_.insert" "Detecteur optique iso" (list x y1 0) 1 1 0 val))))))

        (setq x (+ x 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xp (+ x 10))  ; Initialisation de la coordonnée x

        )

     ; Sortez de la boucle si nous avons déjà traité la première moitié

    )

  (setq index (1+ index)) ; Incrémentation de l'index pour suivre la position actuelle dans la liste

  )



  (setq xx (- x 150)) ; Initialisation de la coordonnée x à x - 150

  (command "_.insert" "barre1" (list xx -1200 0) 1 1 0)



(setq index2 (- combined-list-length 1)) ; Initialisation de l'index pour la deuxième boucle en partant de la fin de la liste combinée



(foreach original-val (reverse combined-list) ; Parcours de la liste combinée en ordre inverse

  (if (>= index2 half-length)

      (progn ; Si l'index est supérieur ou égal à la moitié

        ;; Ajoutez votre logique de traitement pour la deuxième moitié ici

       (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".3." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".3.00" original-val)

          (strcat *id-ctr* ".3.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b3-list)

        (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

            (command "_.insert" "fp" (list x1 y2 0) 1 1 0 val))

          (if (member original-val bouton-b3-list)

          (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

              (command "_.insert" "bp" (list x1 y2 0) 1 1 0 val))

            (if (member original-val th-b3-list)

            (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "th" (list x1 y2 0) 1 1 0 val))

                (if (member original-val vide-list)

                (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "vide2" (list x1 y2 0) 1 1 0 val))

              (if (member original-val io-b3-list)

              (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                  (command "_.insert" "io" (list x1 y2 0) 1 1 0 val))

                  (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "position" (list x1 y2 0) 1 1 0 val)))))))

        (setq x1 (+ x1 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xpp (+ x1 10)) ; Incrémentation de x pour placer le prochain détecteur à côté

        )

     ; Sortez de la boucle si nous avons déjà traité la deuxième moitié

    )

  (setq index2 (1- index2)) ; Décrémentation de l'index pour suivre la position actuelle dans la liste

  )




  (setvar "ATTDIA" 1)




  (setq hauteur 5)

  (setq angle 0)



  ;; Utilisation de la variable globale *nom-ctr*

(setq info_ctr (strcat *id-ctr* " \n " *nom-ctr* " \n " *id-rep* " \n " *nom-rep* " \n " *det-b1* " \n " *fp-b1* " \n " *bouton-b1* " \n " *th-b1* " \n " *io-b1* " "

                           *det-b2* " \n " *fp-b2* " \n " *bouton-b2* " \n " *th-b2* " \n " *io-b2* " "

                           *det-b3* " \n " *fp-b3* " \n " *bouton-b3* " \n " *th-b3* " \n " *io-b3* " "

                           *det-b4* " \n " *fp-b4* " \n " *bouton-b4* " \n " *th-b4* " \n " *io-b4* " "

                           *si-l1* " \n " *si-l2* " \n " *si-l3* " \n " *si-l4* " \n " *si-l5* " \n " *si-l6*))



  ;;;(repeat 2 ; Nombre de points à sélectionner

    ;;;(setq point (getpoint "\nEntrez le point d'insertion du texte : "))

    ;;;(command "_.TEXT" point hauteur angle info_ctr) ; Utilisation de la valeur récupérée

  ;;;) ; axe xyz puis rotation x 1,  rotation y 1 etangle 0

  ; (command "_.insert" "rec2" "10,10,10" 1 1 0)



  (setvar "ATTDIA" 0)



(setq det-b4-list (if (not (equal *det-b4* "")) (split-string *det-b4* " ") '()))

(setq fp-b4-list (if (not (equal *fp-b4* "")) (split-string *fp-b4* " ") '()))

(setq bouton-b4-list (if (not (equal *bouton-b4* "")) (split-string *bouton-b4* " ") '()))

(setq th-b4-list (if (not (equal *th-b4* "")) (split-string *th-b4* " ") '()))

(setq io-b4-list (if (not (equal *io-b4* "")) (split-string *io-b4* " ") '()))

(setq vide-list (if (not (equal *vide* "")) (split-string *vide* " ") '()))





(setq combined-list (append det-b4-list fp-b4-list bouton-b4-list th-b4-list io-b4-list))



(setq compter (length combined-list)) ; Obtenez la longueur de la liste combinée



(if (/= (rem compter 2) 0) ; Vérifiez si la longueur de la liste combinée est impaire

(setq combined-list (append det-b4-list fp-b4-list bouton-b4-list th-b4-list io-b4-list vide-list)))






(setq combined-list (vl-sort combined-list 'compare-int-strings))



(setq combined-list-length (length combined-list)) ; Obtenez la longueur de la liste combinée



(setq half-length (/ (+ combined-list-length 1) 2))





(setq x 0) ; Initialisation de la coordonnée x

(setq xp 10) ; Initialisation de la coordonnée x

(setq xpp 10) ; Initialisation de la coordonnée x

(setq x1 0) ; Initialisation de la coordonnée x

(setq y1 -1800) ; Initialisation de la coordonnée x

(setq yp (+ y1 40))  ; Initialisation de la coordonnée x

(setq y2 -2050) ; Initialisation de la coordonnée x

(setq ypp (- y2 40))  ; Initialisation de la coordonnée x




(setq index 0) ; Initialisation de l'inde



(foreach original-val combined-list

  (if (< index half-length)

      (progn ; Si l'index est inférieur à la moitié

        ;; Ajoutez votre logique de traitement pour la première moitié ici

        (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".4." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".4.00" original-val)

          (strcat *id-ctr* ".4.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b4-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b4-list

              (command "_.insert" "Detecteur faux plafond" (list x y1 0) 1 1 0 val))



          (if (member original-val bouton-b4-list)

          (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b4-list

              (command "_.insert" "Declencheur manuelle" (list x y1 0) 1 1 0 val))

            (if (member original-val th-b4-list)

            (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b4-list

                (command "_.insert" "Detecteur thermique ISO" (list x y1 0) 1 1 0 val))

              (if (member original-val io-b4-list)

              (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b4-list

                  (command "_.insert" "Module IO Incendie" (list x y1 0) 1 1 0 val))

                  (progn

              (command "_.insert" "passerelle" (list xp yp 0) 1 1 0 val); Deux commandes pour original-val membre de fp-b4-list

                (command "_.insert" "Detecteur optique iso" (list x y1 0) 1 1 0 val))))))

        (setq x (+ x 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xp (+ x 10))  ; Initialisation de la coordonnée x

        )

     ; Sortez de la boucle si nous avons déjà traité la première moitié

    )

  (setq index (1+ index)) ; Incrémentation de l'index pour suivre la position actuelle dans la liste

  )



  (setq xx (- x 150)) ; Initialisation de la coordonnée x à x - 150

  (command "_.insert" "barre1" (list xx -1800 0) 1 1 0)



(setq index2 (- combined-list-length 1)) ; Initialisation de l'index pour la deuxième boucle en partant de la fin de la liste combinée



(foreach original-val (reverse combined-list) ; Parcours de la liste combinée en ordre inverse

  (if (>= index2 half-length)

      (progn ; Si l'index est supérieur ou égal à la moitié

        ;; Ajoutez votre logique de traitement pour la deuxième moitié ici

       (setq val

      (if (> (atoi original-val) 99)  ; Check if the integer value of original-val is greater than 99

          (strcat *id-ctr* ".4." original-val)  ; If true, concatenate "1.1." with original-val

        (if (<= 1 (atoi original-val) 9)

            (strcat *id-ctr* ".4.00" original-val)

          (strcat *id-ctr* ".4.0" original-val)))) ; If false, continue with the previous logic

        (if (member original-val fp-b4-list)

        (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

            (command "_.insert" "fp" (list x1 y2 0) 1 1 0 val))

          (if (member original-val bouton-b4-list)

          (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

              (command "_.insert" "bp" (list x1 y2 0) 1 1 0 val))

            (if (member original-val th-b4-list)

            (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "th" (list x1 y2 0) 1 1 0 val))

                (if (member original-val vide-list)

                (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "vide2" (list x1 y2 0) 1 1 0 val))

              (if (member original-val io-b4-list)

              (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                  (command "_.insert" "io" (list x1 y2 0) 1 1 0 val))

                  (progn

            (command "_.insert" "passerelle3" (list xpp ypp 0) 1 1 0 val)

                (command "_.insert" "position" (list x1 y2 0) 1 1 0 val)))))))

        (setq x1 (+ x1 150)) ; Incrémentation de x pour placer le prochain détecteur à côté

        (setq xpp (+ x1 10)) ; Incrémentation de x pour placer le prochain détecteur à côté

        )

     ; Sortez de la boucle si nous avons déjà traité la deuxième moitié

    )

  (setq index2 (1- index2)) ; Décrémentation de l'index pour suivre la position actuelle dans la liste

  )




  (setvar "ATTDIA" 1)





  (princ)

)



(defun export_csv_data ()

  "Fonction pour exporter les données actuelles vers un fichier CSV."

  (setq id_ctr (get_tile "c:idCTR"))

  (setq nom_ctr (get_tile "c:nomCTR"))

  (setq det_b1 (get_tile "c:det_b1"))

  (setq fp_b1 (get_tile "c:fp_b1"))

  (setq bouton_b1 (get_tile "c:bouton_b1"))

  (setq th_b1 (get_tile "c:th_b1"))

  (setq det_b2 (get_tile "c:det_b2"))

  (setq fp_b2 (get_tile "c:fp_b2"))

  (setq bouton_b2 (get_tile "c:bouton_b2"))

  (setq th_b2 (get_tile "c:th_b2"))

  (setq det_b3 (get_tile "c:det_b3"))

  (setq fp_b3 (get_tile "c:fp_b3"))

  (setq bouton_b3 (get_tile "c:bouton_b3"))

  (setq th_b3 (get_tile "c:th_b3"))

  (setq det_b4 (get_tile "c:det_b4"))

  (setq fp_b4 (get_tile "c:fp_b4"))

  (setq bouton_b4 (get_tile "c:bouton_b4"))

  (setq th_b4 (get_tile "c:th_b4"))

  (setq io_b1 (get_tile "c:io_b1"))

  (setq io_b2 (get_tile "c:io_b2"))

  (setq io_b3 (get_tile "c:io_b3"))

  (setq io_b4 (get_tile "c:io_b4"))

  (if (and id_ctr nom_ctr det_b1 fp_b1 bouton_b1 th_b1

           det_b2 fp_b2 bouton_b2 th_b2

           det_b3 fp_b3 bouton_b3 th_b3

           det_b4 fp_b4 bouton_b4 th_b4 io_b1 io_b2 io_b3 io_b4)

      (progn

        (setq csv_data (list id_ctr nom_ctr det_b1 fp_b1 bouton_b1 th_b1

                             det_b2 fp_b2 bouton_b2 th_b2

                             det_b3 fp_b3 bouton_b3 th_b3

                             det_b4 fp_b4 bouton_b4 th_b4 io_b1 io_b2 io_b3 io_b4))

        (setq csv_file (getfiled "Sélectionnez l'emplacement pour sauvegarder le fichier CSV" "" "CSV" 5))

        (if csv_file

            (progn

              (setq csv_stream (open csv_file "w"))

              (if csv_stream

                  (progn

                    (foreach csv_row csv_data

                      (write-line (strcat "\"" csv_row "\"") csv_stream))

                    (close csv_stream)

                    (alert "Donnée exportée avec succès vers le fichier CSV."))

                (alert "Impossible d'ouvrir le fichier CSV en écriture.")))

          (alert "Aucun emplacement de fichier sélectionné.")))

      (alert "Tous les champs doivent être remplis pour exporter les données.")))



(defun import_csv_data ()

  "Fonction pour importer les données depuis un fichier CSV."

  (setq csv_file (getfiled "Sélectionnez le fichier CSV à importer" "" "CSV" 0))

  (if csv_file

      (progn

        ;; Ouvrir le fichier CSV en mode lecture

        (setq csv_stream (open csv_file "r"))

        (if csv_stream

            (progn

              ;; Lire les lignes du fichier CSV

              (setq csv_data '())

              (while (setq line (read-line csv_stream))

                ;; Supprimer les guillemets doubles autour des données

                (setq cleaned_line (vl-string-trim "\"" line))

                ;; Ajouter la ligne nettoyée à la liste des données CSV

                (setq csv_data (cons cleaned_line csv_data)))

              (close csv_stream)

              ;; Extraire les données de chaque champ

              (if (= (length csv_data) 22) ; Vérifier si le fichier a le bon nombre de lignes

                  (progn

                    (setq id_ctr (nth 21 csv_data))

                    (setq nom_ctr (nth 20 csv_data))

                    (setq det_b1 (nth 19 csv_data))

                    (setq fp_b1 (nth 18 csv_data))

                    (setq bouton_b1 (nth 17 csv_data))

                    (setq th_b1 (nth 16 csv_data))

                    (setq io_b1 (nth 15 csv_data))

                    (setq det_b2 (nth 14 csv_data))

                    (setq fp_b2 (nth 13 csv_data))

                    (setq bouton_b2 (nth 12 csv_data))

                    (setq th_b2 (nth 11 csv_data))

                    (setq io_b2 (nth 10 csv_data))

                    (setq det_b3 (nth 9 csv_data))

                    (setq fp_b3 (nth 8 csv_data))

                    (setq bouton_b3 (nth 7 csv_data))

                    (setq th_b3 (nth 6 csv_data))

                    (setq io_b3 (nth 5 csv_data))

                    (setq det_b4 (nth 4 csv_data))

                    (setq fp_b4 (nth 3 csv_data))

                    (setq bouton_b4 (nth 2 csv_data))

                    (setq th_b4 (nth 1 csv_data))

                    (setq io_b4 (nth 0 csv_data))

                    ;; Affecter les données aux champs de la boîte de dialogue

                    (set_tile "c:idCTR" id_ctr)

                    (set_tile "c:nomCTR" nom_ctr)

                    (set_tile "c:det_b1" det_b1)

                    (set_tile "c:fp_b1" fp_b1)

                    (set_tile "c:bouton_b1" bouton_b1)

                    (set_tile "c:th_b1" th_b1)

                    (set_tile "c:det_b2" det_b2)

                    (set_tile "c:fp_b2" fp_b2)

                    (set_tile "c:bouton_b2" bouton_b2)

                    (set_tile "c:th_b2" th_b2)

                    (set_tile "c:det_b3" det_b3)

                    (set_tile "c:fp_b3" fp_b3)

                    (set_tile "c:bouton_b3" bouton_b3)

                    (set_tile "c:th_b3" th_b3)

                    (set_tile "c:det_b4" det_b4)

                    (set_tile "c:fp_b4" fp_b4)

                    (set_tile "c:bouton_b4" bouton_b4)

                    (set_tile "c:th_b4" th_b4)

                    (set_tile "c:io_b1" io_b1)

                    (set_tile "c:io_b2" io_b2)

                    (set_tile "c:io_b3" io_b3)

                    (set_tile "c:io_b4" io_b4)

                    (alert "Données importées avec succès depuis le fichier CSV."))

                (alert "Le fichier CSV doit contenir exactement 18 lignes.")))

          (alert "Impossible d'ouvrir le fichier CSV en lecture.")))

    (alert "Aucun fichier CSV sélectionné.")))

 

Edited by SLW210
Added code tags!
Link to comment
Share on other sites

One simplification, will let you add the rest.

 

(setq lst '( *nom-ctr* *id-ctr* *nom-rep* *id-rep* *fp-b1* ))
(foreach var lst
(set var "")
)

 

I think you should explain in words what it is your trying to do only recognised one thing "CSV file" are you trying to export to Excel ?

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
×
  • Create New...