weeding out the polylines

July 25th, 2015 § 4

Exporting .DWG files from the Corel Draw environment brings a few difficulties – besides other getting splines from “normal lines” automatically.

Although I always wonder why the hell people tend to use unappropriate tools for the terrain drafting (and I am not speaking about some marginal projects – imagine the National Museum of Czech Republic use Corel DTP craps for terrain vectorisation purposes) the thing is that sometimes I need to process .CDR files into archaeological terrain documentation. OK, exporting into .DWG is not “teeth pulling” by no means and the loss of coordinate system, texts, hatches and half a milion of other features does not mean I would feel unhappy but there is one particular thing I really hate – all the lines are automatically convertd into SPLINES (or “Bezier’s” if You prefer). I can’t use them for any reasonable work (mostly as a geometries leading to surface generation and so on).

Sure there is straightforward possibility to convert them into POLYLINES (SPLINEDIT > CONVERT TO POLYLINE) in Autodesk environment directly but resulting line has one unwanted defect – to many line vertices defining the polyline geometry. I allways gave up to this and use these unnecessarily complicated geometries for my purposes until I found the weeding-out command.

The magic word is WEEDFEATURES and accompanying dialog box allows You to customize the precision and “power” of weeding. The only imperfection, however, is the selecting only one feature but I would write a short LISP script to automate this task.

§ 4 komentárov k “weeding out the polylines”

  • ďobo says:

    I forgot important – works on 2D and 3D polylines :)

  • ďobo says:

    Weeding LISP script from Jerry Workman:

    ;*—– this is executed at load

    (textscr)
    (princ(strcat
    “\n\n=========================WEED.LSP===========================”
    “\n\nWEED removes extranious verticies from LINEs or a POLYLINE.”
    “\nShort segments less than the specified leg length …AND…”
    “\nhaving an offset distance less than the minimum distance”
    “\nare removed. Try different combinations to get the result”
    “\ndesired. Changes can be undone by entering the U command”
    “\ntwice. The routine will convert LINEs to a POLYLINE providing”
    “\nthat all line segments endpoints match exactly. Additional”
    “\nverticies that have been added by a Spline or Fit curve can”
    “\nbe treated like \”real\” verticies, or can be ignored.”
    “\n\nExample: ”
    “\nEnter offset distance: 10
    “\nEnter leg length: 100

    “\n\nAll included verticies having the longest leg less than 100″
    “\nAND being less than 10 from the original line will be removed.”
    “\nIf you wish offset to control select a large leg length.”
    “\nIf you wish leg length to control select a large offset.”
    “\nJerry Workman CIS 70717,3564″
    “\nLoading…”))

    ;*—– Debugging stuff, load this file by entering LD

    ;(defun c:ld() (load “weed”))
    ;(defun c:ed() (command “q” “d:\\acad\\support\\weed.lsp”))

    ;*—– Error Routine

    (defun w-error (s) (redraw) (grtext)
    (princ “\nWeed Error: “) (princ s)
    (exit)
    )

    ;*—– Exit Routine

    (defun exit()
    (if (boundp ‘f) (setq f (close f)))
    (setvar “cmdecho” cmdecho)
    (setvar “blipmode” blipmode)
    (setq *error* olderr)
    (princ)
    )

    ;*—– Extract a field from a list

    (defun fld (num lst) (cdr (assoc num lst)))

    ;*—– Plot a temporary X

    (defun blip (blpoint / s x1 y1 x2 y2 p1 p2 p3 p4)

    (setq s (/ (getvar “viewsize”) 100) ; 1/100 of viewsize
    x1 (+ (car blpoint) s)
    y1 (- (cadr blpoint) s)
    x2 (- (car blpoint) s)
    y2 (+ (cadr blpoint) s)
    p1 (list x1 y1) p2 (list x2 y2)
    p3 (list x2 y1) p4 (list x1 y2))
    (grdraw p1 p2 -1) (grdraw p3 p4 -1)
    )

    ;*—– Convert a line to a polyline entity

    (defun line2pline(ent / dat etype epnt ss1 ss2)
    (if ent (progn
    (setq dat (entget ent)
    etype (fld 0 dat))
    (if (= etype “LINE”) (progn
    (princ “\nConverting LINE to PLINE”)
    (setq epnt (fld 10 dat)
    ss1 (ssadd ent)
    ss2 (ssget “C” (getvar “EXTMIN”) (getvar “EXTMAX”)))
    (ssdel ent ss2)
    (command “pedit” ss1 “y” “j” ss2 “” “x”)
    (ssname (ssget epnt) 0) ; return the new entity name
    )
    ;else return nil
    (progn (princ “\nNot a Line”)
    nil)
    )
    );else
    (progn
    (princ “\nNothing selected”)
    nil)
    )
    )

    ;*—– Get a polyline or line entity

    (defun fetch(/ pl etyp flgs ans)
    (setq etyp nil)
    (while (not (or (= etyp “LINE”) (= etyp “POLYLINE”))) (progn
    (setq ename nil)
    (setq e (car (entsel “\nSelect a PolyLine or Line: “)))
    (if e (progn
    (setq pl (entget e)
    etyp (fld 0 pl)
    ename e)
    (if (or (= etyp “LINE”) (= etyp “POLYLINE”)) (progn
    (princ (strcat “\n” etyp ” selected”))
    (if (= etyp “LINE”)
    (setq e (line2pline e)
    ename e
    pl (entget e))
    ))
    ;else
    (progn (princ “\nThat’s not a LINE or POLYLINE, it’s a “) (princ etyp))
    ); end if
    ); end progn
    ; else
    (princ “\nNothing Selected”)
    ); end if
    )); end while
    (setq flgs (fld 70 pl))
    (setq closed (=(boole 1 flgs 1) 1))
    (if closed (princ “\nClosed Polyline”))
    (cond
    ((=(boole 1 flgs 2) 2) (progn
    (setq ptyp “F”)
    (princ “\nFit curve verticies have been added”)))
    ((=(boole 1 flgs 4) 4) (progn
    (setq ptyp “S”)
    (princ “\nSpline curve verticies have been added…”)))
    (t (setq ptyp “N”)) ;Normal polyline
    )
    (if(/= ptyp “N”) (progn
    (initget “Y N”)
    (if(= (getkword “\nDecurve polyline during weeding[y/N]:”) “Y”)
    (setq ptyp “N”))
    ))
    )

    ;*—– Check vertex type

    (defun vt_ok ()
    (if (= etype “VERTEX”)
    (cond
    ((= ptyp “F”) (or(=(boole 1 flags 1) 1) (= flags 0)))
    ((= ptyp “S”) (>(boole 1 flags 9) 0))
    (t (=(boole 1 flags 25) 0)) ;”N” normal, 1 8 16 off
    )
    ;else
    t
    )
    )

    ;*—– extract the list containing vertex coordinates

    (defun get_vertex(/ vert etype sub_ent flags)
    (setq vert nil
    etype nil)
    (while (and e (null vert) (/= etype “SEQEND”)) (progn
    (setq v (entnext e)
    e v
    etype nil)
    (if e (progn
    (setq sub_ent (entget v)
    flags (fld 70 sub_ent)
    etype (fld 0 sub_ent))
    ;(princ “flags =”)(princ flags)
    (if (vt_ok)
    (if (= etype “VERTEX”)
    (setq vert_cnt (1+ vert_cnt)
    vert (fld 10 sub_ent))
    ; else return
    nil
    )
    )
    ))
    ))
    )

    ;*—– Add a vertex to the temporary file for the new pline

    (defun add_vert(vt)
    (if (null f) (setq f (open “weedtmp.$$$” “w”)))
    (prin1 vt f)
    (princ “\n” f)
    )

    ;*—– Read a vertex from the temporary file for the new pline

    (defun read_vert(/ pt)
    (setq pt (read-line f))
    (if pt (read pt) nil)
    )

    ;*—– Read new polyline from the tempory file

    (defun retrieve()
    (setq f (open “weedtmp.$$$” “r”))
    (command “.PLINE”)
    (setq v (read_vert))
    (while v (progn
    (command v)
    (setq v (read_vert))
    ))
    (command “”)
    ;(command “del” “weedtmp.$$$”)
    )

    ;*—– Check the internal angle and leg lengths then add or delete

    (defun check_it(/ ang dist1 dist2 dist offset off)
    (setq ang12 (abs(angle v1 v2))
    ang13 (abs(angle v1 v3))
    ang (abs(- ang12 ang13))
    dist1 (distance v1 v2)
    dist2 (distance v2 v3)
    dist (max dist1 dist2) ; largest distance
    off (* dist1 (sin ang))
    offset (+ p_off off)
    p_off offset
    )
    (if
    (and
    (< offset max_offset) ;offset distance criteria (< dist min_dist) ;minimum leg length criteria ) ;then skip middle vertex (progn (blip v2) ;mark the deleted vertex (setq v2 v3 v3 (get_vertex) skip_cnt (1+ skip_cnt)) (princ "\nSkipping vertex # ") (princ (- vert_cnt 2)) ; (princ (strcat ", max_offset " (rtos max_offset 2 2) " ; min_dist " (rtos min_dist 2 2))) ; (princ (strcat ", offset " (rtos offset 2 2) " dist " (rtos dist 2 2))) ) ;else add first vertex to list (progn (add_vert v2) (setq v1 v2 v2 v3 v3 (get_vertex) p_off 0) ); end progn ); end if ) ;*----- The main routine... (defun C:WEED( / v1 v2 v3 ename v skip_cnt vert_cnt cmdecho blipmode f olderr max_offset min_dist closed spline fit e_del p_off vstart ptyp) (setq cmdecho (getvar "cmdecho") blipmode (getvar "blipmode") olderr *error* *error* w-error ; *error* nil skip_cnt 0 p_off 0 f nil vert_cnt 0 ) (setvar "cmdecho" 0) (setvar "blipmode" 0) (initget (+ 1 2 4)) (setq max_offset (getdist "\nEnter offset distance: ")) (initget (+ 1 2 4)) (setq min_dist (getdist "\nEnter leg length: ")) (initget "Y N") (setq e_del (getkword "\nDelete original Polyline [Y/n]: ")) (if (null e_del) (setq e_del "Y")) (fetch) (princ "\nChecking polyline verticies...") (setq v1 (get_vertex) vstart v1 v2 (get_vertex) v3 (get_vertex)) (add_vert v1) (while v3 (check_it)) (if (< (distance v1 v2) min_dist) (progn (setq skip_cnt (1+ skip_cnt)) (princ "\nSkipping vertex # ") (princ vert_cnt)) ;else (add_vert v1) ); end if (add_vert v2) (if closed (add_vert vstart)) ; Delete old line and draw new Pline (if (> skip_cnt 0) (progn
    (close f)
    (if (= e_del “Y”) (entdel ename))
    (retrieve)
    (princ (strcat “\n” (itoa skip_cnt) ” verticies removed ”
    “out of ” (itoa vert_cnt) ” tested (”
    (rtos(/ (* 100.0 skip_cnt) vert_cnt) 2 2)
    “) percent”))
    )
    ;else
    (princ “\nNothing to change!”)
    )
    (exit)
    )

  • ďobo says:

    LISP script from Kent Cooper:

    ;;; PLDIET.lsp [command name: PLD]
    ;;; To put lightweight PolyLines on a DIET (remove excess vertices); usually
    ;;; used for contours with too many too-closely-spaced vertices.
    ;;; Concept from PVD routine [posted on AutoCAD Customization Discussion
    ;;; Group by oompa_l, July 2009] by Brian Hailey, added to by CAB, and
    ;;; WEED and WEED2 routines by Skyler Mills at Cadalyst CAD Tips [older
    ;;; routines for "heavy" Polylines that won't work on newer lightweight ones];
    ;;; simplified in entity data list processing, and enhanced in other ways [error
    ;;; handling, default values, join collinear segments beyond max. distance,
    ;;; limit to current space/tab, account for change in direction across 0 degrees,
    ;;; option to keep or eliminate arc segments] by Kent Cooper, August 2009.
    ;
    (defun C:PLD
    (/ *error* cmde disttemp cidtemp arctemp plinc plsel pldata
    ucschanged front 10to42 vinc verts vert1 vert2 vert3)
    ;
    (defun *error* (errmsg)
    (if (not (wcmatch errmsg “Function cancelled,quit / exit abort”))
    (princ (strcat “\nError: ” errmsg))
    ); end if
    (if ucschanged (command “_.ucs” “_prev”))
    ; ^ i.e. don’t go back unless routine reached UCS change but didn’t change back
    (command “_.undo” “_end”)
    (setvar ‘cmdecho cmde)
    ); end defun – *error*
    ;
    (setq cmde (getvar ‘cmdecho))
    (setvar ‘cmdecho 0)
    (command “_.undo” “_begin”)
    (setq
    disttemp
    (getdist
    (strcat
    “\nMaximum distance between non-collinear vertices to straighten”
    (if *distmax* (strcat ” < " (rtos *distmax* 2 2) ">“) “”); default only if not first use
    “: ”
    ); end strcat
    ); end getdist & disttemp
    *distmax*
    (cond
    (disttemp); user entered number or picked distance
    (T *distmax*); otherwise, user hit Enter – keep value
    ); end cond & *distmax*
    cidtemp
    (getangle
    (strcat
    “\nMaximum change in direction to straighten”
    (strcat ; offer prior choice if not first use; otherwise 15 degrees
    ” < " (if *cidmax* (angtos *cidmax*) (angtos (/ pi 12))) ">”
    ); end strcat
    “: ”
    ); end strcat
    ); end getdist & cidtemp
    *cidmax*
    (cond
    (cidtemp); user entered number or picked angle
    (*cidmax*); Enter with prior value set – use that
    (T (/ pi 12)); otherwise [Enter on first use] – 15 degrees
    ); end cond & *cidmax*
    plinc 0 ; incrementer through selection set of Polylines
    ); end setq
    (initget “Retain Straighten”)
    (setq
    arctemp
    (getkword
    (strcat
    “\nRetain or Straighten arc segments [R/S] < " (if *arcstr* (substr *arcstr* 1 1) "S"); at first use, S default; otherwise, prior choice ">: ”
    ); end strcat
    ); end getkword
    *arcstr*
    (cond
    (arctemp); if User typed something, use it
    (*arcstr*); if Enter and there’s a prior choice, keep that
    (T “Straighten”); otherwise [Enter on first use], Straighten
    ); end cond & *arcstr*
    ); end setq
    ;
    (prompt “\nSelect LWPolylines to put on a diet, or press Enter to select all: “)
    (cond
    ((setq plsel (ssget ‘((0 . “LWPOLYLINE”))))); user-selected Polylines
    ((setq plsel (ssget “X” (list ‘(0 . “LWPOLYLINE”) (cons 410 (getvar ‘ctab))))))
    ; all Polylines [in current space/tab only]
    ); end cond
    ;
    (repeat (sslength plsel)
    (setq pldata (entget (ssname plsel plinc)))
    (if (/= (cdr (last pldata)) (trans ‘(0 0 1) 1 0)); extr. direction not parallel current CS
    ; for correct angle & distance calculations [projected onto current construction
    ; plane], since 10-code entries for LWPolylines are only 2D points:
    (progn
    (command “_.ucs” “_new” “_object” (ssname plsel plinc)) ; set UCS to match object
    (setq ucschanged T) ; marker for *error* to reset UCS if routine doesn’t
    ); end progn
    ); end if
    (setq
    front ; list of “front end” [pre-vertices] entries, minus entity names & handle
    (vl-remove-if
    ‘(lambda (x)
    (member (car x) ‘(-1 330 5 10 40 41 42 210))
    ); end lambda
    pldata
    ); end removal & front
    10to42 ; list of all code 10, 40, 41, 42 entries only
    (vl-remove-if-not
    ‘(lambda (x)
    (member (car x) ‘(10 40 41 42))
    ); end lambda
    pldata
    ); end removal & 10to42
    vinc (/ (length 10to42) 4); incrementer for vertices within each Polyline
    verts nil ; eliminate from previous Polyline [if any]
    ); end setq
    (if (= *arcstr* “Straighten”)
    (progn
    (setq bulges ; find any bulge factors
    (vl-remove-if-not
    ‘(lambda (x)
    (and
    (= (car x) 42)
    (/= (cdr x) 0.0)
    ); end and
    ); end lambda
    10to42
    ); end removal & bulges
    ); end setq
    (foreach x bulges (setq 10to42 (subst ‘(42 . 0.0) x 10to42)))
    ; straighten all arc segments to line segments
    ); end progn
    ); end if
    (repeat vinc
    (setq
    verts ; sub-group list: separate list of four entries for each vertex
    (cons
    (list
    (nth (- (* vinc 4) 4) 10to42)
    (nth (- (* vinc 4) 3) 10to42)
    (nth (- (* vinc 4) 2) 10to42)
    (nth (1- (* vinc 4)) 10to42)
    ); end list
    verts
    ); end cons & verts
    vinc (1- vinc) ; will be 0 at end
    ); end setq
    ); end repeat
    (while (nth (+ vinc 2) verts); still at least 2 more vertices
    (if
    (or ; only possible if chose to Retain arc segments
    (/= (cdr (assoc 42 (nth vinc verts))) 0.0); next segment is arc
    (/= (cdr (assoc 42 (nth (1+ vinc) verts))) 0.0); following segment is arc
    ); end or
    (setq vinc (1+ vinc)); then – don’t straighten from here; move to next
    (progn ; else – analyze from current vertex
    (setq
    vert1 (cdar (nth vinc verts)) ; point-list location of current vertex
    vert2 (cdar (nth (1+ vinc) verts)); of next one
    vert3 (cdar (nth (+ vinc 2) verts)); of one after that
    ang1 (angle vert1 vert2)
    ang2 (angle vert2 vert3)
    ); end setq
    (if
    (or
    (equal ang1 ang2 0.0001); collinear, ignoring distance
    (and
    (< = (distance vert1 vert3) *distmax*) ; straightens if direct distance from current vertex to two vertices later is ; less than or equal to maximum; if preferred to compare distance along ; Polyline through intermediate vertex, replace above line with this: ; (<= (+ (distance vert1 vert2) (distance vert2 vert3)) *distmax*) (<= (if (> (abs (- ang1 ang2)) pi); if difference > 180 degrees
    (+ (min ang1 ang2) (- (* pi 2) (max ang1 ang2)))
    ; then – compensate for change in direction crossing 0 degrees
    (abs (- ang1 ang2)); else – size of difference
    ); end if
    *cidmax*
    ); end <= ); end and ); end or (setq verts (vl-remove (nth (1+ vinc) verts) verts)) ; then – remove next vertext, stay at current vertex for next comparison (setq vinc (1+ vinc)); else – leave next vertex, move to it as new base ); end if – distance & change in direction analysis ); end progn – line segments ); end if – arc segment check ); end while – working through vertices (setq front (subst (cons 90 (length verts)) (assoc 90 front) front) ; update quantity of vertices for front end 10to42 nil ; clear original set ); end setq (foreach x verts (setq 10to42 (append 10to42 x))) ; un-group four-list vertex sub-lists back to one list of all 10, 40, 41, 42 entries (setq pldata (append front 10to42 (list (last pldata)))) ; put front end, vertex entries and extrusion direction back together (entmake pldata) (entdel (ssname plsel plinc)); remove original (setq plinc (1+ plinc)); go on to next Polyline (if ucschanged (progn (command “_.ucs” “_prev”) (setq ucschanged nil) ; eliminate UCS reset in *error* since routine did it already ); end progn ); end if – UCS reset ); end repeat – stepping through set of Polylines (command “_.undo” “_end”) (setvar ‘cmdecho cmde) (princ) ); end defun – PLD (prompt “\nType PLD to put PolyLines on a Diet.”)

  • Jeremy Stiller says:

    I am not sure wheter autor knows WEEDFEATURE intimately. There is option (toggle on prompt) to select multiple features.

  • § Hoď komentár

kde som? / where am i?

práve čítaš weeding out the polylines v ďobo-CADzone, true men don't kill coyotes and use AutoCAD….

meta