Invertire la direzione di linee e polilinee

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

;;; ============================================================================
;;; CXPLREV - Reverse the direction of lines and polylines
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxplrev
;;; 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
;;; ============================================================================

;; The vertices of a polyline in reverse order, with the bulges and widths of every segment turned around.
(defun cx:plrev-verts (verts closed / n k j src out)
  (setq n (length verts) k 0)
  (repeat n
    (setq src (nth (- n 1 k) verts)
          j   (- n 2 k))
    ;; the segment that now starts at this vertex is the old segment that ended here
    (if (and (< j 0) closed) (setq j (1- n)))
    (setq out (cons (if (>= j 0)
                      (list (car src) (cadr src) (- (nth 2 (nth j verts))) (nth 4 (nth j verts)) (nth 3 (nth j verts)))
                      (list (car src) (cadr src) 0.0 0.0 0.0))
                    out)
          k   (1+ k)))
  (reverse out))

;; Turn the direction of every line and polyline in NAMES around. Returns how many were reversed.
(defun cx:plrev-run (names / n ed)
  (setq n 0)
  (foreach e names
    (setq ed (entget e))
    (cond
      ((= (cx:dxf 0 ed) "LINE")
       (entmod (subst (cons 10 (cx:dxf 11 ed)) (assoc 10 ed) (subst (cons 11 (cx:dxf 10 ed)) (assoc 11 ed) ed)))
       (entupd e)
       (setq n (1+ n)))
      ((= (cx:dxf 0 ed) "LWPOLYLINE")
       (entmod (cx:lw-rebuild ed (cx:plrev-verts (cx:lw-verts ed) (cx:ent-closed ed)) (cx:ent-closed ed)))
       (entupd e)
       (setq n (1+ n)))))
  n)

(defun c:CXPLREV ( / *error* cx:sv ss)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect lines and polylines to reverse: " '((0 . "LINE,LWPOLYLINE"))))
    (progn
      (cx:start '(("CMDECHO" . 0)))
      (princ (strcat "\n" (itoa (cx:plrev-run (cx:ss->list ss))) " object(s) reversed."))
      (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 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))

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

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

;; 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 "\nCXPLREV loaded. Type CXPLREV 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
• CXPLCLEANEliminare vertici doppi e allineati
• CXPLWIDTHDare un'unica larghezza a molte polilinee
• CXJOINUnire linee e archi in polilinee, anche con interruzioni