Dare un'unica larghezza a molte polilinee

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

;;; ============================================================================
;;; CXPLWIDTH - Set one width for many polylines
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxplwidth
;;; 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
;;; ============================================================================

;; Give the polylines in NAMES one constant width (0 = hairline) and drop their per-segment widths.
;; Returns how many polylines were changed.
(defun cx:plwidth-run (names width / n ed verts out has)
  (setq n 0)
  (foreach e names
    (setq ed (entget e))
    (if (= (cx:dxf 0 ed) "LWPOLYLINE")
      (progn
        (setq verts (mapcar (function (lambda (v) (list (car v) (cadr v) (nth 2 v) 0.0 0.0))) (cx:lw-verts ed))
              ed    (cx:lw-rebuild ed verts (cx:ent-closed ed))
              has   (assoc 43 ed)
              out   nil)
        (foreach g ed
          (cond
            ((= (car g) 43) (setq out (cons (cons 43 width) out)))
            ((= (car g) 70)
             (setq out (cons g out))
             (if (not has) (setq out (cons (cons 43 width) out))))
            (T (setq out (cons g out)))))
        (entmod (reverse out))
        (entupd e)
        (setq n (1+ n)))))
  n)

(defun c:CXPLWIDTH ( / *error* cx:sv ss width)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect polylines: " '((0 . "LWPOLYLINE"))))
    (progn
      (setq width (cx:ask-real "New width (0 for a hairline)" 0.0))
      (cx:start '(("CMDECHO" . 0)))
      (princ (strcat "\n" (itoa (cx:plwidth-run (cx:ss->list ss) width)) " polyline(s) changed."))
      (cx:end)))
  (princ))


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

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

;; The vertices of an LWPOLYLINE entity list as ((x y bulge start-width end-width) ...).
(defun cx:lw-verts (ed / out cur)
  (foreach g ed
    (cond
      ((= (car g) 10)
       (if cur (setq out (cons cur out)))
       (setq cur (list (cadr g) (caddr g) 0.0 0.0 0.0)))
      ((and cur (= (car g) 40)) (setq cur (list (nth 0 cur) (nth 1 cur) (nth 2 cur) (cdr g) (nth 4 cur))))
      ((and cur (= (car g) 41)) (setq cur (list (nth 0 cur) (nth 1 cur) (nth 2 cur) (nth 3 cur) (cdr g))))
      ((and cur (= (car g) 42)) (setq cur (list (nth 0 cur) (nth 1 cur) (cdr g) (nth 3 cur) (nth 4 cur))))))
  (if cur (setq out (cons cur out)))
  (reverse out))

;; The entity list ED of an LWPOLYLINE with its vertices replaced by VERTS and the closed flag set to CLOSED.
(defun cx:lw-rebuild (ed verts closed / out placed)
  (foreach g ed
    (cond
      ((member (car g) '(10 40 41 42 91))
       (if (and (= (car g) 10) (not placed))
         (progn
           (setq placed T)
           (foreach v verts
             (setq out (cons (list 10 (nth 0 v) (nth 1 v)) out))
             (if (/= 0.0 (nth 3 v)) (setq out (cons (cons 40 (nth 3 v)) out)))
             (if (/= 0.0 (nth 4 v)) (setq out (cons (cons 41 (nth 4 v)) out)))
             (if (/= 0.0 (nth 2 v)) (setq out (cons (cons 42 (nth 2 v)) out)))))))
      ((= (car g) 90) (setq out (cons (cons 90 (length verts)) out)))
      ((= (car g) 70)
       (setq out (cons (cons 70 (if closed (boole 7 (cdr g) 1) (boole 1 (cdr g) -2))) out)))
      (T (setq out (cons g out)))))
  (reverse out))

;; True for a closed polyline, a circle and a full ellipse.
(defun cx:ent-closed (ed / type)
  (setq type (cx:dxf 0 ed))
  (cond
    ((= type "LWPOLYLINE") (= 1 (logand 1 (cx:dxf 70 ed))))
    ((= type "CIRCLE") T)
    ((= type "ELLIPSE") (< (abs (- (- (cx:dxf 42 ed) (cx:dxf 41 ed)) (* 2.0 pi))) 1e-6))))

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

;; Real X as text with at most PREC decimals and no trailing zeros ("2.50" -> "2.5", "3.00" -> "3").
(defun cx:num (x prec / s)
  (setq s (rtos x 2 prec))
  (if (wcmatch s "*.*")
    (progn
      (while (= (substr s (strlen s)) "0") (setq s (substr s 1 (1- (strlen s)))))
      (if (= (substr s (strlen s)) ".") (setq s (substr s 1 (1- (strlen s)))))))
  (if (or (= s "-0") (= s "")) "0" s))

(defun cx:ask-real (msg def / v)
  (setq v (getreal (strcat "\n" msg " <" (cx:num def 6) ">: ")))
  (if v v def))

;; 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 "\nCXPLWIDTH loaded. Type CXPLWIDTH to start.")
(princ)

Altri comandi: Misure e polilinee

• CXAREAScrivere l'area dentro le forme chiuse
• CXLENScrivere la lunghezza lungo linee, archi e polilinee
• CXSUMTotale di lunghezza e area per layer
• CXCENTROIDTrovare e segnare il centro delle forme chiuse
• CXDISTMisurare un percorso punto per punto
• CXPLCLOSEChiudere le polilinee con le estremità quasi coincidenti
• CXPLREVInvertire la direzione di linee e polilinee
• CXPLCLEANEliminare vertici doppi e allineati
• CXJOINUnire linee e archi in polilinee, anche con interruzioni