CXCSV2ATTExport und Import (CSV)Version 1.0.0In AutoCAD getestet

Blockattribute aus einer CSV-Datei füllen

Aktualisiert die Attribute vieler Blöcke aus einer Tabelle: Jede Zeile findet ihren Block über einen Schlüssel wie eine Kennzeichnung und setzt die übrigen Spalten.

cxcsv2att.lsp herunterladen LISP-Bedingungen

So verwenden Sie ihn

Eine CSV anlegen, deren erste Zeile die Attributnamen enthält. Die erste Spalte ist der Schlüssel.
CXCSV2ATT eingeben, die Blöcke wählen und die Datei auswählen.
Der Bericht nennt, wie viele Blöcke aktualisiert wurden und wie viele Zeilen keinen Block fanden.

Gut zu wissen

Exportieren Sie zuerst mit CXBLK2CSV eine Datei mit den richtigen Spalten, bearbeiten Sie sie und lesen Sie sie wieder ein.

In AutoCAD laden

Speichern Sie die Datei an einem beliebigen Ort.
Geben Sie APPLOAD ein, wählen Sie die Datei und klicken Sie auf Laden.
Geben Sie den Befehl ein: CXCSV2ATT.

Damit er bei jedem Start bereitsteht, fügen Sie ihn im selben Dialog zum Startup-Set hinzu, oder laden Sie mit dem optionalen Loader einen ganzen Ordner auf einmal. Der optionale Loader

In AutoCAD (Vollversion) getestet. Andere Programme, die AutoLISP ausführen, funktionieren vielleicht, wurden aber nicht getestet.

Der Code

Reiner Text, nichts ist versteckt. Kopieren Sie ihn in eine Datei namens cxcsv2att.lsp oder laden Sie ihn herunter.

;;; ============================================================================
;;; 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)

Versionsverlauf

Version 1.0.0 · 27. Oktober 2026

Erste Veröffentlichung.

Für viele Zeichnungen auf einmal?

BlockSync erledigt diese Art von Aufgabe für einen ganzen Ordner voller Zeichnungen in einem Durchlauf.

BlockSync