Eliminare vertici doppi e allineati

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

;;; ============================================================================
;;; CXPLCLEAN - Remove duplicate and straight-line vertices
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxplclean
;;; 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
;;; ============================================================================

;; Remove vertices that sit on top of the previous one (closer than TOL) from a vertex list.
;; In a closed polyline a last vertex on the first one goes too.
(defun cx:plclean-dedupe (verts closed tol / out)
  (foreach v verts
    (if (and out (<= (distance (list (car v) (cadr v)) (list (car (car out)) (cadr (car out)))) tol))
      (setq out (cons v (cdr out)))
      (setq out (cons v out))))
  (setq out (reverse out))
  (if (and closed (> (length out) 2)
           (<= (distance (list (car (car out)) (cadr (car out))) (list (car (last out)) (cadr (last out)))) tol))
    (setq out (reverse (cdr (reverse out)))))
  out)

;; Remove vertices that lie on the straight line between their neighbors (within TOL). Vertices next to an arc
;; or a wide segment stay. The ends of an open polyline stay.
(defun cx:plclean-collinear (verts closed tol / found i n prev v next dx dy len d tt)
  (setq found T)
  (while (and found (> (length verts) (if closed 3 2)))
    (setq found nil i (if closed 0 1) n (length verts))
    (while (and (not found) (< i (if closed n (1- n))))
      (setq prev (nth (rem (+ i n -1) n) verts)
            v    (nth i verts)
            next (nth (rem (1+ i) n) verts)
            dx   (- (car next) (car prev))
            dy   (- (cadr next) (cadr prev))
            len  (sqrt (+ (* dx dx) (* dy dy))))
      (if (and (> len 1e-12)
               (= 0.0 (nth 2 prev)) (= 0.0 (nth 2 v))
               (= 0.0 (nth 3 prev)) (= 0.0 (nth 4 prev)) (= 0.0 (nth 3 v)) (= 0.0 (nth 4 v)))
        (progn
          (setq d  (/ (abs (- (* dx (- (cadr v) (cadr prev))) (* dy (- (car v) (car prev))))) len)
                tt (/ (+ (* (- (car v) (car prev)) dx) (* (- (cadr v) (cadr prev)) dy)) (* len len)))
          (if (and (<= d tol) (>= tt 0.0) (<= tt 1.0))
            (setq found T verts (cx:remove-nth verts i)))))
      (setq i (1+ i))))
  verts)

;; Clean the polylines in NAMES: drop duplicate vertices (closer than TOL) and, with COLLINEAR = T, vertices on a straight
;; line. Returns (polylines-changed vertices-removed).
(defun cx:plclean-run (names tol collinear / changed removed ed verts closed nv)
  (setq changed 0 removed 0)
  (foreach e names
    (setq ed (entget e))
    (if (= (cx:dxf 0 ed) "LWPOLYLINE")
      (progn
        (setq verts  (cx:lw-verts ed)
              closed (cx:ent-closed ed)
              nv     (cx:plclean-dedupe verts closed tol))
        (if collinear (setq nv (cx:plclean-collinear nv closed tol)))
        (if (and (< (length nv) (length verts)) (>= (length nv) (if closed 3 2)))
          (progn
            (entmod (cx:lw-rebuild ed nv closed))
            (entupd e)
            (setq changed (1+ changed)
                  removed (+ removed (- (length verts) (length nv)))))))))
  (list changed removed))

(defun c:CXPLCLEAN ( / *error* cx:sv ss tol col r)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect polylines: " '((0 . "LWPOLYLINE"))))
    (progn
      (setq tol (cx:ask-real "Vertices closer together than this count as one" 0.001)
            col (= (cx:ask-kw "Also remove vertices on a straight line" "Yes No" "No") "Yes"))
      (cx:start '(("CMDECHO" . 0)))
      (setq r (cx:plclean-run (cx:ss->list ss) tol col))
      (princ (strcat "\n" (itoa (cadr r)) " vertex/vertices removed from " (itoa (car r)) " polyline(s)."))
      (cx:end)))
  (princ))


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

;; The first N items of LST.
(defun cx:head (lst n / out)
  (repeat n (setq out (cons (car lst) out) lst (cdr lst)))
  (reverse out))

;; LST without its item number N (counting from 0).
(defun cx:remove-nth (lst n / rest)
  (setq rest lst)
  (repeat (1+ n) (setq rest (cdr rest)))
  (append (cx:head lst n) rest))

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

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

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

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

;; Replace every OLD in STR by NEW (case sensitive).
(defun cx:replace (str old new / n out pos)
  (setq n (strlen old) out "" pos 1)
  (if (= n 0)
    str
    (progn
      (while (<= pos (1+ (- (strlen str) n)))
        (if (= (substr str pos n) old)
          (setq out (strcat out new) pos (+ pos n))
          (setq out (strcat out (substr str pos 1)) pos (1+ pos))))
      (strcat out (substr str pos)))))

;; Ask for one of the keywords in BITS ("Yes No"), default DEF; returns the keyword.
(defun cx:ask-kw (msg bits def / v)
  (initget 0 bits)
  (setq v (getkword (strcat "\n" msg " [" (cx:replace bits " " "/") "] <" def ">: ")))
  (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 "\nCXPLCLEAN loaded. Type CXPLCLEAN 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
• CXPLWIDTHDare un'unica larghezza a molte polilinee
• CXJOINUnire linee e archi in polilinee, anche con interruzioni