---

Hallo Leute !

Vielleicht hat einer ja mal ne Idee, wie man die Orientierung einer Polyline in Lisp "umdrehen" kann. Sollte wenn möglich aber auch mit Polylinien funktionieren, die Bögen beinhalten. Ich schätze, es gibt auch mal wieder feine Unterschiede zwischen LW und "alten" Polylinien.
Wenn mir jemand weiterhelfen würde, wär das echt Super !
(brauch kein kompletter Code zu sein, ne nette Idee tut's auch !)

Stefan

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Stefan,
habe dies hier mal aus einem Forum gezogen. Schau mal, ob du was daraus gebrauchen kannst. Ob Bögen damit funkt. kann ich dir im Moment nicht sagen.
Schöne Ostern  Heidi

(defun C:LWD (/ PL_select PL_Name PL_DataSet Testliste new_Ctrl_Pointlist first_Part last_part L_ok i Listenelement Ctrl_Pointlist Crtl_Pointnumb def_Pos k vergleich umkehrung kruemmung sicher austausch austausch1 austausch3 kruemmung_alt zähler anzahl)
  (while (not (setq PL_select (entsel))))
  (setq PL_Name (car PL_select)
PL_DataSet (entget PL_Name)
Testliste (list 10 40 41 42)
new_Ctrl_Pointlist (list)
first_Part (list)
last_part (list)
L_ok nil
i 0)
  (cond ((= (cdr (assoc 0 PL_DataSet)) "LWPOLYLINE")
(while (not L_ok)
  (setq Listenelement (nth i PL_DataSet))
  (if (/= (car Listenelement) 10)
    (setq first_Part (append first_Part (list Listenelement)))
    (setq L_ok T)
    )
  (setq i (+ i 1))
  ); while
(setq L_ok nil i 0)
(while (not L_ok)
  (setq Listenelement (nth i (reverse PL_DataSet)))
  (if (not (member (car Listenelement) Testliste))
    (setq last_part (append last_part (list Listenelement)))
    (setq L_ok T last_Part (reverse last_Part))
    )
  (setq i (+ i 1))
  );while
(setq Ctrl_Pointlist (reverse (cdr (reverse (member (assoc 10 PL_DataSet) PL_Dataset)))))
(setq Crtl_Pointnumb (/ (length Ctrl_Pointlist) 4) i 0)
(while (< i Crtl_Pointnumb)
  (setq k 0)
  (setq def_Pos (- (length Ctrl_Pointlist) (* (+ i 1) 4)))
  (while (< k 4)
    (setq vergleich (caar (list (nth (+ def_pos k) Ctrl_Pointlist))))
    (if (= vergleich 42); wenn Krümmungsklammer
      (progn;dann
(setq umkehrung (* -1 (cdar (list (nth (+ def_pos k) ctrl_pointlist)))))
(setq kruemmung (cons '42 umkehrung))
(if (= umkehrung 0)
  (progn
    (if (and (= def_pos 0) sicher)
      (setq kruemmung sicher)
      )
    (setq new_Ctrl_Pointlist (append new_Ctrl_Pointlist (list kruemmung)))
    )
  (progn; sonst, wenn Krümmung ungleich 0
    (setq anzahl (length new_ctrl_pointlist))
    (if (< anzahl 4)
      (progn;dann
(if (or (= (cdr (assoc 70 PL_DataSet)) 1) (= (cdr (assoc 70 PL_DataSet)) 129))
  (setq sicher kruemmung)
  )
  (setq kruemmung (cons '42 '0.0))
(setq new_ctrl_pointlist (append new_Ctrl_Pointlist (list kruemmung)))
);progn
      (progn;sonst
(setq austausch (reverse new_ctrl_pointlist))
(setq kruemmung_alt (assoc 42 austausch))
(setq zähler 0)
(setq austausch1 (list))
(repeat 3
  (setq austausch1 (append austausch1 (list (nth zähler austausch))))
  (setq zähler (1+ zähler))
  );repeat
(setq austausch (cdr austausch))
(setq austausch3 (member (assoc 41 austausch) austausch))
(setq austausch (cons kruemmung austausch3))
(setq austausch (append austausch1 austausch))
(setq new_Ctrl_Pointlist (reverse austausch))
(setq new_Ctrl_Pointlist (append new_Ctrl_Pointlist (list kruemmung_alt)))
);progn
      );if
    );progn
  );if
);progn
      (setq new_Ctrl_Pointlist (append new_Ctrl_Pointlist (list (nth (+ def_Pos k) Ctrl_Pointlist)))); wenn nicht Krümmungsklammer
      );if
    (setq k (+ k 1))
    );while
  (setq i (+ i 1))
  );while
(setq new_PL_DataSet (append first_Part new_Ctrl_Pointlist last_Part))
(if (not (entmod new_PL_DataSet)) (prompt "\n...konnte LWPolylinie nicht modifizieren!")))
(t nil))
  (princ))

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hab mal auf die Schnelle was zusammengekloppt. Konnte es, weil ich keine Zeit mehr habe (um 4 ist Feierabend!) nicht mehr richtig testen. LWPL mit bulges, geschlossen scheint zu gehen. Offene Polylinien musst du mal sehen. Für Heavy-PLs musst du dir das übertragen.

(defun pl-reverse(lwpl / part1 part2)
  (setq lwpl(entget lwpl))
  (while(/= 10(caar lwpl))
    (setq part1(cons(car lwpl)part1))
    (setq lwpl(cdr lwpl))
  )
  (while(member(caar lwpl)'(10 40 41 42))
    (cond
      ( (= 42(caar lwpl)) ; bulge x -1
        (setq part2(cons(cons 42(-(cdar lwpl)))part2))
      )
      ( (= 41(caar lwpl)) ; Start- und Endbreite vertauschen
        (setq part2(cons(cons 40(cdar lwpl))part2))
      )
      ( (= 40(caar lwpl))
        (setq part2(cons(cons 41(cdar lwpl))part2))
      )
      ('T (setq part2(cons(car lwpl)part2))) ; gerade
    )
    (setq lwpl(cdr lwpl))
  )
  (entmod
    (append
      (reverse part1)
      ;die letzten werden die ersten sein:
      (cons(last part2)(reverse(cdr(reverse part2))))
      lwpl
    )
  )
)

HTH, Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Erstmal Danke für die Antworten !

@Heidi
Dein Programm läuft super, scheint für meinen Zweck gut zu gehen !
Aufgefallen ist mir nur, daß da jemand doch ganz schön viel Code produziert hat....

@Axel
Der Code Deines Programmes sieht wirklich sehr kompakt aus (kennt man ja so von Dir). Leider funzt das Programm nicht mit offennen LW's, und gerade um die gehts mir dabei.

Gruß Stefan

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo

Falls die beiden angebotenen Lösungen noch nicht reichen - ich glaube, www.cadwiesel.de hat auch was dafür.

Gruß, Ernst

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hab's mal überarbeitet und getestet inzwischen - jetzt geht's auch mit offenen LWPLs. Dafür ist's noch zwei, drei Zeilen kürzer geworden;-)

(defun pl-reverse(lwpl / part1 part2)
(setq lwpl(entget lwpl))
(while(/= 10(caar lwpl))
(setq part1(cons(car lwpl)part1)lwpl(cdr lwpl))
)
(while(member(caar lwpl)'(10 40 41 42))
(setq part2
(cons
(cond
( (= 42(caar lwpl))(cons 42(-(cdar lwpl))))
( (= 41(caar lwpl))(cons 40(cdar lwpl)))
( (= 40(caar lwpl))(cons 41(cdar lwpl)))
('T(car lwpl))
)
part2
)
lwpl(cdr lwpl)
)
)
(entmod
(append(reverse part1)
(if(=(logand(cdr(assoc 70 part1))1)1)
(cons(last part2)(reverse(cdr(reverse part2))))
part2
)
lwpl
)
)
)

HINWEIS: wirklich *gründlich* getestet habe ich das Ganze nach wie vor nicht, es sieht aber so aus, als sollte es funktionieren. Habe es nur an je einer offenen bzw. geschlossenen LWPL mit variablen Breiten und jeweils etwa 10 Segementen ausprobiert.

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Wo ich das jetzt so sehe, was ich hier eben reingesetzt habe: Wer kann mir mal sagen, warum bei meiner ersten Version die Einrückung erhalten geblieben ist, während bei der zweiten Version nun alles auf Level 0 ausgerückt ist? Es war beim erstem Mal mein Rechner im Büro, beim zweiten mal der zu Hause. What's the difference? Code, der so aussieht, als sei er mit 120 vor eine Betonwand gefahren, ist ja doch schlecht lesbar...

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi Axel,
hat glaub ich mit den Smilies Einstellungen zu tun.
Smilies an, Code i.O., Smilies aus, Code = Betonwand (oder umgekehrt).

------------------
Ciao,
Marc

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Das, lieber Marc, ist natürlich ein äusserst offensichtlicher Zusammenhang... Warum nur war mir das nicht gleich klar?

Na ja, ich habe inzwischen mal in der Hilfe hier nachgelesen, da gibts eine UBB-Anweisung. Mein Problem ist nur, dass da jedes Forum sein eigenes Süppchen kocht. Wer soll sich das alles merken?

Noch ein Versuch mit dem Code:

Code:

---

(defun pl-reverse(lwpl / part1 part2)
  (setq lwpl(entget lwpl))
  (while(/= 10(caar lwpl))
    (setq part1(cons(car lwpl)part1)lwpl(cdr lwpl))
  )
  (while(member(caar lwpl)'(10 40 41 42))
    (setq part2
      (cons
        (cond
          ( (= 42(caar lwpl))(cons 42(-(cdar lwpl))))
          ( (= 41(caar lwpl))(cons 40(cdar lwpl)))
          ( (= 40(caar lwpl))(cons 41(cdar lwpl)))
          ('T(car lwpl))
        )
        part2
      )
      lwpl(cdr lwpl)
    )
  )
  (entmod
    (append(reverse part1)
      (if(=(logand(cdr(assoc 70 part1))1)1)
        (cons(last part2)(reverse(cdr(reverse part2))))
        part2
      )
      lwpl
    )
  )
)

---

Gruss, Axel

PS: Das sieht doch so aus, wie es sein sollte;-)))

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

[Diese Nachricht wurde von mapcar am 21. April 2003 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Axel,

hast du auch ein gute Lösung für Polylnien (keine LW)?
Besten Dank vorab

Gruß Theodor

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Nö, hab ich so nicht in petto. Die alten Polylinien begegnen mir eigentlich auch nur noch recht selten, und wenn, dann in geglätteter Form.

Es gibt doch irgend so ein convert-Utility, weiss nicht mehr, wie das heisst. Oder arbeitest du noch mit <= 13? Auch in diesem Fall dürfte es nicht so schwer sein: Vorgehensweise auf die gegebenen Umstände übertragen. Am Besten: Ein myEntmake-polyline schreiben, das die Wahl erlaubt, ob man eine schwere oder eine leichte Polyline erzeugen möchte. An den harten Fakten wie Start-/Endbreite und Bulge hat sich ja nichts geändert - mit anderen Worten: Die Form hat sich geändert, aber nicht der Inhalt. Elliptische Anteile sind nach wie vor nicht möglich usw.

Noch ein Tipp, wie man den ganzen Kram elegant umgehen kann: Polylinie duplizieren + explodieren. Die entstandenen Entities einlesen und löschen. Dann hat man immer eine korrekte Darstellung in Linie/Bogen-Form, und zwar unabhängig davon, ob es eine schwere oder leichte ist. Der Weg rückwärts ist dann auch nicht so schwer....

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Axel,

schade.
Ich arbeite nicht mehr mit ACAD13. Da ich die Polylinen aber nicht selbst erstelle, sind es nicht immer LW-Polylinien deren Verlauf, für CNC, geändert werden muss. Das Convert-Util habe ich gefunden, leider ist es nur für offene Polylinien.

Gruß
Theodor

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi Theodor,
Convert-Tool ist in Acad eingebaut.
Gib mal an der Befehlszeile:_
"_convertpoly"
ein. Da kannst Du dann zwischen Fett und Dünn auswählen (Fett= Alte PLines, Dünn = LWPlines). Dann sagste dem Befehl noch "alle" und der Fisch ist gelutscht.

------------------
Ciao,
Marc

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

... nur so aus Interesse:

Was war eigentlich der Grund für die Einführung von LWPOLYLINIEN?

Ciao Georg

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi,
lwpolylines nehmen weniger Speicher weg als Polylines.
Außerdem war ADesk wohl die Struktur mit Verticies als Subentities zu altmodisch. Dazu kommt noch, das die alten PLines deutlich anfälliger für Bug's sind als die neuen. Da kann ein Vertex bzw. das SEQEND schon mal andere Eigenschaften aufweisen als das Hauptelement...

------------------
Ciao,
Marc

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo zusammen,

ich bekomme das Programm von Mapcar nicht zum laufen. Das ist ja kein Startprogramm, sondern "nur" ein Unterprogramm, oder? Jetzt habe ich die tollsten, laienhaften Versuche gemacht dieser Routine Argumente zuzuweisen, aber es klappt nicht. Könnt Ihr mir sagen welche Argumente ich der Routine übergeben muß um die LWPL umzudrehen?!

Danke und Gruß Mario

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

(pl-reverse(car(entsel "\LW-PL wählen: )")))

------------------
  - Thomas -
"Bei 99% aller Probleme ist die umfassende Beschreibung des Problems bereits mehr als die Hälfte der Lösung desselben."

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP