Compilare gli attributi dei blocchi da un file CSV

Testo semplice, niente di nascosto. Copialo in un file chiamato cxcsv2att.lsp oppure scaricalo.

;;; ============================================================================
;;; CXCSV2ATT - Fill block attributes from a CSV file
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxcsv2att
;;; Tested in: AutoCAD (full version). Other programs that run AutoLISP may work but are not tested.
;;; Copyright (c) CADXChange. Free for personal and commercial use; do not resell or
;;; republish it as a collection. Terms: https://cadxchange.net/legal/lisp-terms
;;; ============================================================================

;; Fill block attributes from CSV ROWS. The first row holds attribute tags; its first column is the KEY tag. Every
;; other row finds the blocks in NAMES whose KEY attribute equals its first column and sets the other columns.
;; Returns (blocks-updated rows-without-block).
(defun cx:csv2att-run (names rows / tags updated missed hit v)
  (setq tags (car rows) updated 0 missed 0)
  (foreach r (cdr rows)
    (setq hit nil)
    (foreach b names
      (if (= (cx:att-get b (car tags)) (car r))
        (progn
          (setq hit T v (cdr r))
          (foreach tg (cdr tags)
            (if v
              (progn (cx:att-set b tg (car v)) (setq v (cdr v)))))
          (setq updated (1+ updated)))))
    (if (not hit) (setq missed (1+ missed))))
  (list updated missed))

(defun c:CXCSV2ATT ( / *error* cx:sv ss file rows r)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect the blocks to fill: " '((0 . "INSERT"))))
    (if (setq file (cx:file-open "CSV file: first row holds the tags, first column is the key"))
      (if (and (setq rows (cx:csv-rows file)) (cdr rows))
        (progn
          (cx:start '(("CMDECHO" . 0)))
          (setq r (cx:csv2att-run (cx:ss->list ss) rows))
          (princ (strcat "\n" (itoa (car r)) " block(s) updated, " (itoa (cadr r)) " row(s) matched no block."))
          (cx:end))
        (princ "\nThe file is empty or could not be read."))))
  (princ))


;;; ---- Shared helpers (used by the command above; identical in every CADXChange tool) ----

(defun cx:dxf (code ed)
  (cdr (assoc code ed)))

;; The ATTRIB entities of a block reference, in order.
(defun cx:attribs (ins / e out)
  (setq e (entnext ins))
  (while (and e (= (cx:dxf 0 (entget e)) "ATTRIB"))
    (setq out (cons e out) e (entnext e)))
  (reverse out))

;; The ATTRIB of a block reference with the tag TAG (any case), or nil.
(defun cx:att-find (ins tag / r)
  (foreach a (cx:attribs ins)
    (if (and (not r) (= (strcase (cx:dxf 2 (entget a))) (strcase tag))) (setq r a)))
  r)

(defun cx:att-get (ins tag / a)
  (if (setq a (cx:att-find ins tag)) (cx:dxf 1 (entget a))))

;; Replace the text of a TEXT, ATTRIB, ATTDEF or MTEXT.
(defun cx:text-set (ename str / ed out)
  (setq ed (entget ename))
  (if (= (cx:dxf 0 ed) "MTEXT")
    (progn
      ;; MTEXT stores text in 250-character pieces: 3 groups for the first pieces, 1 for the last
      (foreach p ed (if (not (member (car p) '(1 3))) (setq out (cons p out))))
      (setq out (reverse out))
      (while (> (strlen str) 250)
        (setq out (append out (list (cons 3 (substr str 1 250)))) str (substr str 251)))
      (setq ed (append out (list (cons 1 str)))))
    (setq ed (subst (cons 1 str) (assoc 1 ed) ed)))
  (entmod ed)
  (entupd ename)
  T)

;; Set the attribute TAG of a block reference to VALUE; returns T when the block has that attribute.
(defun cx:att-set (ins tag value / a)
  (if (setq a (cx:att-find ins tag))
    (progn (cx:text-set a value) (entupd ins) T)))

;; Close the undo step and put the system variables back.
(defun cx:end ()
  (foreach v cx:sv (setvar (car v) (cdr v)))
  (command "_.UNDO" "_End")
  (setq cx:sv nil)
  (princ))

;; Error handler: restores everything, stays quiet on Esc.
(defun cx:err (msg)
  (if (> (getvar "CMDACTIVE") 0) (command))
  (cx:end)
  (if (and msg (not (wcmatch (strcase msg) "*BREAK*,*CANCEL*,*EXIT*")))
    (princ (strcat "\nError: " msg)))
  (princ))

;; Use the objects already selected, or ask the user to select; FILTER is an ssget filter list or nil.
(defun cx:pick (msg filter / ss)
  (setq ss (if filter (ssget "_I" filter) (ssget "_I")))
  (if (null ss)
    (progn
      (princ msg)
      (setq ss (if filter (ssget filter) (ssget)))))
  ss)

;; Ask which CSV file to read. Returns a path or nil. With FILEDIA 0 the name is typed at the command line.
(defun cx:file-open (title / f)
  (if (= (getvar "FILEDIA") 0)
    (progn
      (setq f (getstring T (strcat "\n" title ": ")))
      (if (= f "") nil f))
    (getfiled title (getvar "DWGPREFIX") "csv" 4)))

;; All lines of a text file, or nil when it cannot be opened.
(defun cx:read-lines (file / f l out)
  (if (setq f (open file "r"))
    (progn
      (while (setq l (read-line f)) (setq out (cons l out)))
      (close f)
      (reverse out))))

;; One CSV line to a list of strings (handles quotes and doubled quotes).
(defun cx:csv-parse (line / out cur q i c)
  (setq out nil cur "" q nil i 1)
  (while (<= i (strlen line))
    (setq c (substr line i 1))
    (cond
      ((and q (= c "\"") (= (substr line (1+ i) 1) "\""))
       (setq cur (strcat cur "\"") i (1+ i)))
      ((= c "\"") (setq q (not q)))
      ((and (= c ",") (not q)) (setq out (cons cur out) cur ""))
      (T (setq cur (strcat cur c))))
    (setq i (1+ i)))
  (reverse (cons cur out)))

;; Remove spaces and tabs at both ends.
(defun cx:trim (s / a b)
  (setq a 1 b (strlen s))
  (while (and (<= a b) (member (substr s a 1) '(" " "\t"))) (setq a (1+ a)))
  (while (and (>= b a) (member (substr s b 1) '(" " "\t"))) (setq b (1- b)))
  (substr s a (max 0 (1+ (- b a)))))

;; The rows of a CSV file as lists of strings, empty lines skipped; nil when the file cannot be read.
(defun cx:csv-rows (file / out)
  (foreach l (cx:read-lines file)
    (if (/= (cx:trim l) "") (setq out (cons (cx:csv-parse l) out))))
  (reverse out))

;; Save the system variables in VARS ((name . value) ...), set them, and open one undo step.
;; The caller declares cx:sv as a local so the saved values live exactly as long as the command.
(defun cx:start (vars)
  (setq cx:sv (mapcar (function (lambda (v) (cons (car v) (getvar (car v))))) vars))
  (command "_.UNDO" "_Begin")
  (foreach v vars (setvar (car v) (cdr v)))
  (princ))

;; Selection set to a list of entity names.
(defun cx:ss->list (ss / i out)
  (setq i 0)
  (if ss
    (repeat (sslength ss)
      (setq out (cons (ssname ss i) out)
            i   (1+ i))))
  (reverse out))

(princ "\nCXCSV2ATT loaded. Type CXCSV2ATT to start.")
(princ)

Altri comandi: Esportazione e importazione (CSV)

• CXTXT2CSVEsportare i testi in un file CSV
• CXBLK2CSVEsportare blocchi e attributi in un file CSV
• CXCOORD2CSVEsportare le coordinate in un file CSV
• CXLAYER2CSVEsportare l'elenco dei layer in un file CSV
• CXAREA2CSVEsportare aree e perimetri in un file CSV
• CXOBJ2CSVEsportare un elenco di oggetti in un file CSV
• CXDIM2CSVEsportare i valori delle quote in un file CSV
• CXCSV2TXTInserire testi da un file CSV
• CXPTSTracciare punti con nome da un file CSV