---

Hallo Leute!
Suche einen Code um mehrere aber nicht alle Gruppen aufzulösen.
(Wie es wohl bei LT möglich sein soll)
Möchte die Gruppen durch aufziehen eines Fenster oder einzeln durch picken mehrer Gruppen auswählen.

Der von Marc Scherer und Co. im Forum eingebrachte Code ist sonst soweit super.

Mein Versuch das Auflösen entsprechend zu modifizieren schlug leider fehl. Dachte an sowas wie Objekte vergleichen ob sie zu einer Gruppe gehören und wenn ja dann diese gruppe auflösen .....

Tolles Forum ... Danke ... und weiter so!!!
Schon mal Danke im voraus!

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

---

Hallo Dorfy,
ich hatte vor einiger Zeit mal probiert Gruppen zu löschen, wenn ich ein Objekt der Gruppe auswähle, das dürfte zwar nicht genau Dein Problem sein, aber irgendwie passt es ja zum Thema:

Code:

---

(defun c:test  (/ obj aws react groups n liste)
  (if (setq obj (car (entsel "\nBitte Objekt auswählen:")))
    (progn
      (setq n 0)
      (while
(and (/= react 1) (< n (length (setq liste (entget obj)))))
(cond
  ((not react)
    (if (and (= (car (nth n liste)) 102)
    (= (cdr (nth n liste)) "{ACAD_REACTORS"))
      (setq react 0)))
  ((= react 0)
    (cond
      ((and (= (car (nth n liste)) 102)
    (= (cdr (nth n liste)) "}"))
      (setq react 1))
      ((= (car (nth n liste)) 330)
      (if (= (cdr (assoc 0 (entget (cdr (nth n liste)))))
      "GROUP")
(setq groups (cons (cdr (nth n liste)) groups)))))))
(setq n (+ n 1)))
      (mapcar '(lambda (A) (entdel A) (princ "\nGruppe gelöscht"))
      groups))
    (alert "Kein Objekt ausgewählt."))
  (princ))

---

------------------
viele Grüße

Jörn

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

---

Hallo Dorfy,
willkomen im Forum, Kollege! ACAD LT und lisp? Da habe ich wohl was verpasst. Meines derzeitigen Wissens nach zeichnet sich LT u.a. dadurch aus, daß es eben kein lisp unterstützt - lasse mich aber gerne eines besseren belehren!
Vermute, Du meinst "Diesel", das kann LT auch. Da tauchen dann so komische $ und sowas auf... Poste doch mal den link für den Code von Marc, dann wird Dir wahrscheinlich besser geholfen. Einen "fertigen" Code zu bekommen, könnte schwierig werden. Das Forum dient eher der Anregung des eigenen Hirns :-) Vielleicht hast Du ja Glück?!
[Edit] Da war Jörn wohl schneller... Noch ein Stichwort: Systemangaben ausfüllen [/Edit]
Frederik

[Diese Nachricht wurde von Paulchen am 21. Jul. 2006 editiert.]

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

---

Ich nehme an Dorfy meint diesen Beitrag: http://ww3.cad.de/foren/ubb/Forum145/HTML/000019.shtml#000005

------------------
Gruss
Caladia

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

---

Hallo Leute!

Erstmal allen Danke
RE: Jörn ... werde mich mal versuchen an dem Code ... , bei gelingen poste ich dann auch ... .
RE: Caladis ... ja, genau diesen Beitrag bzw. Code meinte ich ... .
RE: Frederik ... nicht für LT (LISP einlesen und verwerten geht wohl mit dem Extender oder so ählich) sondern für AutoCad 2007.
Ich meinte nicht einen "Gruppen-Auflösen-Code" für LT sondern in Anlehnung an LT. Sorry wenn ich mich oben nicht eindeutig ausgedrückt habe, hoffe mein Anliegen ist jetzt klarer.
Tipps und Anregungen helfen ja schon weiter ... denn selber basteln und zum Erfolg kommen ... .

!!!Danke!!!

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

---

Hier mal ein Versuch ... doch irgendwo klemmt es ... gewaltig!?
Gruppen in Datensätze zu packen bzw. auszuwerten scheint nich so einfach zu sein.

Ich nehme an es liegt an der "Datensatzauswertung" bzw. in der
"Repeat-Schleife"

;;; Löst die Gruppe(n) auf zu dem die zu klickenden Objekte gehören
(defun C:XxxG (/ GNAME GNAMELEN SGET SGETT C)
(setq echo (getvar "CMDECHO"))
(setvar "CMDECHO" 0)
(command "_undo" "_g")

(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
;(setq sget (ssget '((0 . "group")))) ;Versuch1
  (setq sget (ssget)) ;Versuch

    (if sget
    (progn
      (repeat (sslength sget)

        (setq sgett
        (ssname ss
          (setq c
          (if c
            (1+ c)
            0
          )
          )
        )
        )

      (setq GNAME (GET-GROUPNAME SGETT))

      (if GNAME
        (progn
        (setq GNAMELEN (itoa (length GNAME)))
        (foreach ELEM GNAME
          (command "_.-group" "_ex" ELEM)
        )
        (princ
          (strcat "\nOk, \"" GNAMELEN "\" Gruppe(n) aufgelöst!")
        )
        )
      )

      )
    )
    (princ "\nGewähltes Objekt gehört nicht zu einer Gruppe!")
    )
    (setq sget nil)
    (setq sgett nil)
    (princ)
  (command "_undo" "_e")
  (setvar "CMDECHO" echo)
  (princ)
) ;_ end defun

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

---

Hallo Dorfy,
weil die Funktion GET-GROUPNAME nicht vorhanden ist konnte ich das Prog nicht komplett durchlaufen lassen, aber in der Zeile "(ssname ss"
scheint der Variablenname falsch zu sein => ("ssname sget"

Du weist damit den Objektnamen der Variablen "SGETT" zu, um diese Variable dann wieder der Funktion GET_GROUPNAME zu übergeben.
Das kannst Du auch direkter machen:

Code:

---

(defun C:XxxG (/ GNAME GNAMELEN SGET C)
(setq echo (getvar "CMDECHO"))
(setvar "CMDECHO" 0)
(command "_undo" "_g")

(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
;(setq sget (ssget '((0 . "group")))) ;Versuch1
  (setq sget (ssget)) ;Versuch

    (if sget
    (progn
      (repeat (sslength sget)
(if (setq GNAME (GET-GROUPNAME (ssname sgett (setq c (if c (1+ c)0)))))
        (progn
        (setq GNAMELEN (itoa (length GNAME)))
        (foreach ELEM GNAME
          (command "_.-group" "_ex" ELEM)
        )
        (princ
          (strcat "\nOk, \"" GNAMELEN "\" Gruppe(n) aufgelöst!")
        )
        )
      )

      )
    )
    (princ "\nGewähltes Objekt gehört nicht zu einer Gruppe!")
    )
    (setq sget nil)
    (setq sgett nil)
    (princ)
  (command "_undo" "_e")
  (setvar "CMDECHO" echo)
  (princ)
)

---

------------------
viele Grüße

Jörn

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

---

Hallo joern
Die Funktion GET-GROUPNAME findet man in diesen Beitrag: http://ww3.cad.de/foren/ubb/Forum145/HTML/000019.shtml#000005

Dieser Beitrag dient als Grundlage und Ausgagng der Bastellaktion ;-)

Danke!

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

---

Hallo Jörn
Geht auch noch nicht wirklich
Fehler ...
Bin aber noch weiterhin am basteln.

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

---

Hallo Dorfy,
erstmal habe ich einen Fehler eingebaut, ich habe den Variablennamen "sgett" anstatt "sget" verwendet, und zweitens braucht die Funktion GET-GROUPNAME als Argument eine Objektliste und nicht den Objektnamen, im Schnelltest hat es mit folgender Zeile funktioniert:

(GET-GROUPNAME (entget(ssname sget (setq c (if c (1+ c)0)))))

------------------
viele Grüße

Jörn

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

---

gruppen.txt

Hallo Jörn
Erstmal Danke Danke Danke ... das ist es ... super.
Den eigebauten Fehler habe ich auch gefunden gehabt.
Gestern das erste mal den Visual Lisp Editor in AutoCad
entdeckt und benutzt ... super Sache ... dieser gab mir dann
auch den Tip bzw. die Info mit Get-Groupname für Argument eine
Objektliste und nicht Objektname ...
Dennoch Danke

Nun, für verschachtelte Gruppen habe ich die Funktion "xgg"
(siehe Anhang) ... das Bastelprojekt sollte noch für mehrere
verschachtelte Gruppen in Anlehnung an "xgg" weitergeführt werden.

Der hintere Teil im Anhang geht auf Marc Scherer und Co. zurück ...
Dank euch
Mfg Dorfy

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

---

Hab es mal mit einer weiteren Schleife probiert
;;;;;;;;neu .... , es will aber noch nicht
wirklich , der "Zähler" beim Vergleich mit den
anderen Objekten scheint nicht OK zu sein!?

;;; Funktion löst "oberste" vorhandene Gruppe auf
(defun C:xxyy (/ GNAME GROUPSEL c gnamen d)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
(setq GROUPSEL (ssget))
    ALT-PICKSTYLE (getvar "pickstyle")
  (if GROUPSEL
  (progn
  (setq d 0)
  (repeat (sslength GROUPSEL)
    (progn
      (setq GNAME (GET-GROUPNAME (entget(ssname groupsel (setq c (if c (1+ c)0))))))
;;;;;;neu   
  (setq d (+ d 1))
  (repeat (-(sslength GROUPSEL) d) 
    (progn
      (setq GNAMEn (GET-GROUPNAME (entget(ssname groupsel (setq d (if d (1+ d)d))))))
        (if (= (car GNAMEn)(car GNAME)) (setq gname nil) (setq gname gname))        ))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 
          (if GNAME
          (progn
            (TOGGLE-GROUPSELECT t)
            (command "_.-group" "_ex" (car GNAME))
            (princ (strcat "\nGruppe: \""
            (car GNAME)
            "\" aufgelöst. AutoCAD Kommando eingeben..."))
            (setq sget gname)))
          (if (not GNAME)
          (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")) ))))
(setq groupsel nil)
(princ)
);_ end of defun

guter rat ist teuer - wer hat ... wer kann ...
mfg dorfy

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

---

Hallo Dorfy,
ich mache Dir mal einen anderen Vorschlag:

Code:

---

(defun C:xxyy (/ GNAME GROUPSEL c gnamen d g_liste)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")

  (setq GROUPSEL (ssget))
    ALT-PICKSTYLE (getvar "pickstyle")
  (if GROUPSEL
  (progn
 
 
;;;;;; noch neuer
     
  (repeat (sslength groupsel)
    (if (setq gname(GET-GROUPNAME (entget(ssname groupsel (setq d (if d (1+ d)0))))))
      (mapcar '(lambda(A) (if (not (member A g_liste))
    (setq g_liste (cons A g_liste))))gname)))
  (if g_liste
  (mapcar '(lambda(A)
    (TOGGLE-GROUPSELECT t)
    (command "_.-group" "_ex" A)
    (princ (strcat "\nGruppe: \""
            A
            "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")))
    (alert "keine Objekte ausgewählt."))
 
(princ)
)

---

so oft ,wie der Auswahlsatz lang ist wird pro Objekt über GET-GROUPNAME eine Liste mit Gruppennamen ausgegeben =>"gname". Dabei ist zu Bedenken, daß bei verschachtelten Gruppen mehrere Gruppennamen in der Liste vorhanden sein können.
Daher wird die Wiederholungsfunktion "mapcar" auf diese Liste angewendet, immer wenn ein Gruppenname noch nicht in der Sammelliste "g_liste" vorhanden ist, dann wird Sie hinzugefügt.
Dann wird wiederum die Funktion mapcar auf die Sammeliste "g_liste" angewendet und die Gruppen werden aufgelöst.
Ich hoffe es hilft.

------------------
viele Grüße

Jörn

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

---

Hallo Jörn
vielen Dank, du scheinst ja voll in der Materie zu stecken,
dass ist auch gut so.
Werde deinen Vorschlag sowie ich wieder am entsprechenden
Rechner bin ausprobieren.
Mir ist zwar noch nicht ganz die vorgehensweise bei deinem code klar
aber das kommt noch (ein wenig nachlesen und probieren..).
Dank Dir.
Nochmal zur Erläuterung, Sinn sollte es sein bei miteinander
verschachtelten Gruppen nur die oberste aufzulösen
Bsp.: gruppe eins ist links, gruppe 2 ist rechts, beide ergeben gruppe 3. (mehrfach umherkopiert...)
wenn alles ausgewählt ist, soll nur gruppe 3 aufgelöst werden.
deshalb war eine Schleife (bei mir repeat ...) angedacht und ein vergleich über "if ..." wenn noch ein objekt diese gruppe als oberste besitzt dann zum nächsten Objekt evtl. der Gruppe zuspringen,weiter vergleichen ... wenn kein weiteres objekt diese gruppe als oberste
besitzt dann auflösen.
wie gesagt, bin weiter am probieren
Danke, vor allen Jörn
Mfg Dorfy

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

---

Hi Dorfy,
das Thema "Nur oberste Gruppe auflösen" haben CADmium und ich schon mal im Chat besprochen.
CADmiums Vorschlag zur Analyse der obersten Gruppe kristallisierte sich da als der IMHO sinnvollste, wenn nicht sogar einzige, heraus:
Ermittle für ein gepicktes Objekt alle Gruppen in denen es vorkommt.
Die Gruppe die die meisten Objekte enthält MUSS die oberste Gruppe sein.

Danke CADmium. Leider hatte ich bisher keine Zeit diesen Ansatz zu coden. Aber Du darfst Dich da gerne dran versuchen.

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

[Diese Nachricht wurde von marc.scherer am 14. Aug. 2006 editiert.]

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

---

.. die Zeit und der Druck es zu coden fehlt mir leider momentan auch..

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

---

lol
@cadmium
Hast' das falsch verstanden und ich doof geschrieben.
Es sollte heißen:

Zitat:

---

Danke CADmium für die Idee!
Dorfy, Du darfst Dich da gerne dran versuchen.

---

...

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

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

---

Hallo,
Re: Jörn
Dein Versuch „;;;noch neuer“ funktioniert gut, wie bereits oben beschrieben liegt meine Absicht darin, die nuuuuuuuur die „oberste“, „höchste“, „letzte“ Gruppe von mehren Gruppen (in Anlehnung an LT) aufzulösen. Ich bin der Meinung, dass über GET-GROUPNAME eine Liste mit Gruppennamen ausgegeben =>"gname", in der genau diese oberste Gruppe an Stelle eins, ganz vorne steht (evtl. über „car“ ansprechbar). Wenn man die Grundgedanken von CADmium und Marc einbezieht, ist die Gruppe mit den meisten Objekten die „oberste“… angewandt auf „viele oberste Gruppen“, benötigt man jeweils die erste Gruppe aus der Liste „gname“, packe diese in g_liste, und löse dann die gesamte Sammelliste g_liste auf.
Ich hoffe mein Anliegen kam irgendwie rüber.
(nur erste Listeneintrag aus gname nehmen, ab in g_liste, vorher wie gehabt abgleichen, auflösen, fertig…
Wenn ich irre, lass ich mich gern eines besseren belehren!?
Zumal mein Ansatz mal wieder nicht will. (da LISP und tiefere Listen bzw. –funktionen -  eh Neuland für mich sind, betrachte ich dies als unendlich lange Lernphase).

(defun C:asd (/ GNAME GROUPSEL c gnamen d g_liste)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
    ALT-PICKSTYLE (getvar "pickstyle")
  (if GROUPSEL
  (progn

;;;;;; noch neuer als neu
     
  (repeat (sslength groupsel)
    (setq gnamen(GET-GROUPNAME (entget(ssname groupsel (setq d (if d (1+ d)0))))))

    (setq gname (cons (car gname))gnamen)
;;;;es soll doch nur der erste Listeneintrag mit "car" verarbeitet werden --> und Fehler ????
 
(if gname(mapcar '(lambda(A) (if (not (member A g_liste))
    (setq g_liste (cons A g_liste))))gname)))
  (if g_liste
  (mapcar '(lambda(A)
    (TOGGLE-GROUPSELECT t)
    (command "_.-group" "_ex" A)
    (princ (strcat "\nGruppe: \""
            A
            "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")))
    (alert "keine Objekte ausgewählt."))
 
(princ)
)

Mal wieder ... Jörn besten Dank, super Grundlage.
Dank an Marc und CADmium und alle weiteren nicht aufgeführten…. !!!!DANKE!!!
Mit freundlichen Grüßen Dorfy

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

---

Hallo Dorfy,
in Deinem Beispiel müsstest Du folgende Zeile korrigieren:
Alt: (setq gname (cons (car gname))gnamen)
Neu: (setq gname (cons (car gnamen)gname)

Aber Da kannst Du dann eigentlich auch gleich wieder drauf verzichten, weil Du sagst, daß Du immer nur den ersten Eintrag  aus der Rückgabe von GET-GROUPNAME haben möchtest:

Code:

---

(defun C:asd (/ GNAME GROUPSEL c gnamen d g_liste)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
    ALT-PICKSTYLE (getvar "pickstyle")
  (if GROUPSEL
  (progn

;;;;;; noch mehr neuer als neu
   
  (repeat (sslength groupsel)
    (if(setq gname(GET-GROUPNAME (entget(ssname groupsel (setq d (if d (1+ d)0))))))
      (if (not (member (car gname) g_liste))
(setq g_liste (cons (car gname) g_liste)))))

  (if g_liste
  (mapcar '(lambda(A)
    (TOGGLE-GROUPSELECT t)
    (command "_.-group" "_ex" A)
    (princ (strcat "\nGruppe: \""
            A
            "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")))
    (alert "keine Objekte ausgewählt."))

(princ)
)

---

------------------
viele Grüße

Jörn

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

---

Hallo Jörn,
Danke, genau so sollte es sein,
funktioniert super.
Danke Danke D....
Bin soweit zufrieden mit der Funktion.
Dank auch den übrigen...
MFG Dorfy

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

---

Hi Dorfy,
:hmm das mit dem ersten Eintrag der Liste ist aber nicht "as designed"... Das ist eigentlich reiner Zufall.
Wer garantiert Dir, daß JEDE AutoCAD-Version die Gruppen in einer Reihenfolge speichert? Ne, ne. IMHO ist das so NICHT SAUBER implementiert. Sauber wird es nur sein, wenn man über die Anzahl der Entities der Gruppen geht.
So ist das ein Zufallskonstrukt auf das man sich nicht verlassen sollte.

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

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

---

Hi Marc!
Mmh … Annahme für die Art der Speicherung sind meine dürftigen
LISP-Kenntnisse und absolut minimalen Kenntnisse zu Listen und deren Funktionen
und meine eigene kleine Logik – entweder ich hänge etwas hinten oder vorne an eine Liste an.
Du hast natürlich Recht, es ist NICHT SAUBER implementiert. (ich schiebe es mal auf meine Unkenntnis)
Ich werde mich weiter mit diesen Problem beschäftigen, mich noch weiter bilden und belesen…
Und deinen Vorschlag probieren in Angriff zunehmen.
Vielleicht hast  Du als einer der Großen ein paar Zeilen Code zur Problematik „Anzahl der Entities der Gruppen“ besonders „Anzahl der Entities“, mmh der Auslesung!?
Mit freundlichen Grüßen Dorfy

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

---

Hallo alle zusammen
Nun ein neuer der Ansatz um einer soliden Implementierung gerecht zu werden…
-Ansatz- da noch nicht getestet!
(reine Trockenübung am Editor beim Feierabendbier)
Der Marc, der hat da wirklich Recht … .
Benötige mal wieder eine weitere Meinung bzw. Verbesserungsvorschlag od. Korrektur der einzelnen Fragmente im Mittelteil. (das Ganze ist auch im Plural erwünscht)

;;; löst jeweils nur die "obersten" vorhandenen Gruppen von gepickten Objekten auf
(defun C:xxx (/ GNAME GROUPSEL c dgnamen d g_liste)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
  ALT-PICKSTYLE (getvar "pickstyle")
(if GROUPSEL
(progn
  (repeat (sslength groupsel)
    (if (setq gname (GET-GROUPNAME (entget (ssname groupsel (setq d (if d (1+ d)0)) ))))

;<--alle gruppennamen des bzw der objekte(s) ermitteln     
      (foreach ELEM GNAME
      (command "_.select" "_group" elem "")
      (setq MERKERSET (if (>(sslength (ssget "_P"))(MERKERSET) MERKERSET (setq dgnamen elem))))
; angedacht ist-->
;für jeden gruppennamen--> ;diese gruppe selektieren; deren objektanzahl ermitteln
;dgnamen evtl neu setzen wenn anzahl der objekte groesser ist
;dgnamen in g_liste packen wie gehabt – und weiter auflösen wie gehabt -->

      (if (not (member (dgnamen) g_liste)) (setq g_liste (cons (car dgnamen) g_liste)) )))
  (if g_liste (mapcar '(lambda(A)
  (TOGGLE-GROUPSELECT t)
  (command "_.-group" "_ex" A)
  (princ (strcat "\nGruppe: \"" A "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")))
    (alert "keine Objekte ausgewählt."))
(princ)
)

Jörn ICH zähl auf Dich…
Dank an alle im Voraus
Mit freundlichen Grüßen <--Dorfy-->

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

---

gruppe_test.zip

Hallo Dorfy,
erstmal zu Deinem Code, auch wenn Du ihn nur ungetestet am Editor geschrieben hast, da sind noch viel zu viele kleine Fehler drin, als das man ihn mal eben schnell durchtesten könnte.
Dann zu der Idee, ich glaube, das wird nicht funktionieren, denn wenn Du einen Auswahlsatz von einer gewählten Gruppe bildest, und die Gruppe ist wiederum in einer Gruppe enthalten sind die Anzahl der Elemente gleich (vielleicht verstehe ich auch irgendwas falsch)

mit folgendem Code habe ich mal einen Test gemacht, es werden die Anzahlen von Elemente in der Befehlseingabe angeschrieben:

Code:

---

(defun c:test ( / d)
  (setvar "CMDECHO" 0)
  (setq groupsel (ssget))
  (repeat (sslength groupsel)
  (setq gname (GET-GROUPNAME (entget (ssname groupsel (setq d (if d (1+ d)0)) ))))
    (princ "\nGruppenliste:--------------------------------------------------------\n")
    (mapcar '(lambda(A)
        (command "_.select" "_group" A "")
      (princ (strcat  "\""A"\"| Elemente: " (if (ssget "_P")(itoa(sslength (ssget "_P")))"0")"| ")))gname))
  (princ))

---

Das Ergebnis bei mir sah folgendermaßen aus:
Gruppenliste:--------------------------------------------------------
"ALLE1"| Elemente: 4| "5"| Elemente: 2|
Gruppenliste:--------------------------------------------------------
"ALLE1"| Elemente: 4| "5"| Elemente: 2|
Gruppenliste:--------------------------------------------------------
"ALLE1"| Elemente: 4| "4"| Elemente: 2|
Gruppenliste:--------------------------------------------------------
"ALLE1"| Elemente: 4| "4"| Elemente: 2|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "2"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "2"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "2"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "1"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "1"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "1"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "1"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "2"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "3"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "3"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "3"| Elemente: 4|
Gruppenliste:--------------------------------------------------------
"ALLE2"| Elemente: 12| "1-3"| Elemente: 12| "3"| Elemente: 4|

und dann habe ich mir gedacht, ich werden die Reihenfolge der zurückgegebenen Gruppennamen der Funktion "GET-GROUPNAME" in die Befehlszeile schreiben, mit folgender Funktion:

Code:

---

(defun c:test1 ( / d)
  (setq groupsel (ssget))
  (repeat (sslength groupsel)
  (setq gname (GET-GROUPNAME (entget (ssname groupsel (setq d (if d (1+ d)0)) ))))
  (princ (strcat"\n" (apply 'strcat(mapcar '(lambda(A) (strcat "|"A"|")) gname)))))
  (princ))

---

das Ergebnis:
|ALLE1| |5|
|ALLE1| |5|
|ALLE1| |4|
|ALLE1| |4|
|ALLE2| |1-3| |2|
|ALLE2| |1-3| |2|
|ALLE2| |1-3| |2|
|ALLE2| |1-3| |1|
|ALLE2| |1-3| |1|
|ALLE2| |1-3| |1|
|ALLE2| |1-3| |1|
|ALLE2| |1-3| |2|
|ALLE2| |1-3| |3|
|ALLE2| |1-3| |3|
|ALLE2| |1-3| |3|
|ALLE2| |1-3| |3|

Es werden scheinbar doch immer die übergeordneten Gruppen als erstes Element zurückgegeben.
@Marc: Kann das sein????

Ich hänge nochmal die Datei an, mit der ich experimentiert habe, würde gerne noch ein bißchen weitermachen, muß mich jetzt aber wieder ein "ernsthaften" Sachen zuwenden.

Bei meinem Beispiel habe ich die Gruppen wie folgt gebildet:
Gruppe "1"
Gruppe "2"
Gruppe "3"
Gruppe "1-3" beinhaltet die Gruppen "1" "2" und "3"
Gruppe "4"
Gruppe "5"
Gruppe "Alle1" beinhaltet die Gruppen "1" "2" "3" und "1-3"
Gruppe "Alle2" beinhaltet die Gruppen "4" und "5"

------------------
viele Grüße

Jörn

[Diese Nachricht wurde von joern bosse am 22. Aug. 2006 editiert.]

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

---

Hallo Jörn
Dein Code ist sehr nützlich…
Nochmals SORRY –für`s nicht testen, wird nachgeholt wenn auch bei mir die wichtigeren Dinge erledigt sind.
Das mit dem Verschachteln hat mir auch ein wenig Denkzeit gekostet, aber
„denn wenn Du einen Auswahlsatz von einer gewählten Gruppe bildest, und die Gruppe ist wiederum in einer Gruppe enthalten sind die Anzahl der Elemente gleich (vielleicht verstehe ich auch irgendwas falsch)“ (Ich denke du meinst zBsp. 3 Elemente gruppieren und dann diese Gruppe wieder gruppieren ohne irgendetwas hinzuzufügen bzw. zu verändern?!)
Nun ist es doch aber vom Prinzip her egal welche der beiden Gruppen ich auflöse, der Inhalt (3 Elemente) derselbe ist!? Es sind nun lediglich unterschiede im Gruppennamen zu finden –
Doch irgendetwas ist ja immer!? Oder werden Daten wie Timecode bei der Erstellung gespeichert – nicht das ich wüsste (abgesehen im Namen, was nicht immer erwünscht ist).
Mit freundlichen Grüßen Dorfy

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

---

Zitat:

---

Original erstellt von joern bosse:
Es werden scheinbar doch immer die übergeordneten Gruppen als erstes Element zurückgegeben.
@Marc: Kann das sein????

---

Hi Jörn,
klar kann das sein. Wenn es so ist, ist es reiner Zufall, denn gecodet habe ich das nicht so. Und ich würde auch nicht die Hand dafür ins Feuer legen das es immer unter allen Umständen so ist.
Aber wer weiß.
ICH würde mich da jedenfalls nicht drauf verlassen, was aber nicht heißt das jemand anderes das als ausreichend sicher erachtet...

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

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

---

Hallo
Nun das ganze mal getestet
Visual-Lisp-Editor ACad sagt:
„; Fehler: Zu wenige Argumente in SETQ: (SETQ MERKERSET (ITOA (SSLENGTH (SSGET "_P"))) (SETQ DGNAMEN ELEM))“ (???was will der Künstler mir damit sagen???)
beim folgenden Code:

;;; löst jeweils nur die "obersten" vorhandenen Gruppen von gepickten Objekten auf
(defun C:xxx (/ GNAME GROUPSEL c dgnamen d g_liste merkerset)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
  ALT-PICKSTYLE (getvar "pickstyle")
(if GROUPSEL (progn  (repeat (sslength groupsel)
    (if ;wenn gname dann
    (setq gname      (GET-GROUPNAME ;gname setzen-gruppenname holen
      (entget        (ssname groupsel          (setq d (if d (1+ d)0))    ))))   
;;;;;;;;;;;;;;;;;alle gruppennamen des bzw der objekte(s) ermitteln     
      (foreach ELEM GNAME ;für jeden gruppennamen-->;diese selektieren
      (command "_.select" "_group" elem "")
      (if (>(if (ssget "_P")(itoa(sslength (ssget "_P")))"0") MERKERSET) ;deren anzahl ermitteln ;der vergleich
        ((setq MERKERSET (itoa(sslength (ssget "_P"))) (setq dgnamen elem))) ;dgnamen+merkerset evtl neu setzen wenn anzahl groesser als gehabt
((setq MERKERSET merkerset) (setq dgnamen elem))) ;alles bleibt beim alten
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,;dgnamen in g_liste packen wie gehabt-->
      (if        (not (member (dgnamen) g_liste))    (setq g_liste (cons (car dgnamen) g_liste)))) ))
  (if g_liste  (mapcar '(lambda(A)  (TOGGLE-GROUPSELECT t)
  (command "_.-group" "_ex" A)  (princ (strcat "\nGruppe: \""            A
            "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben...")))
    (alert "keine Objekte ausgewählt."))
(princ) )
Anregungen und Meinungen erwünscht und zwingend benötigt!!!
Ich stimme Marc übrigens zu - wer sagt das die "Gruppenlisten"
immer gleich aufgezogen werden!?

Mit freundlichen Grüßen Dorfy

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

---

Morgen, Ihr alle da draußen!
Der Abend war lang – die Nacht war kurz …

@Marc, geos, tappenbeck, CADmium den „Großen Urhebern“ und natürlich Jörn „Mein Großmeister“ und …

Der Code „funzt“ super … Danke … gutes Team – super Jörn, allein wäre ich da lang noch nicht … dennoch lass uns noch ein wenig basteln … Marc hat Recht … oder -->

(@Marc & Co. – Super Grundlage – „:hmm das mit dem ersten Eintrag der Liste ist aber nicht "as designed"...“ es “funzt“ – und nur dass zählt …oder … 

Beim genaueren Nachvollziehen von „ADDG“ und „DELG“ (Link ganz oben … Backt to the base) sieht es für mich so aus -
als ob – mit „(car GNAME)“ auch nur auf die „oberste“ Gruppe zurückgegriffen wird.
(ergab im Test mit „DELG“ bei zwei verschachtelten Gruppen wunderliches!!?? 3 Linien ergeben Gruppe1, Gruppe1 und eine weitere 4.Linie ergeben Gruppe2, eine Linie aus Gruppe1 wird mit „DELG“ entfernt, nun mal mit dem Mauszeiger langsam über jede Line fahren … hervorgehoben werden zum einen 4 Linie, zum anderen Gruppe1 und … Gruppe2 minus selektierte Linie … oder?!? … es sind doch aber nur zwei Gruppen?!? ... ACAD2007)
Es war schon spät, aber ich sage mal leise und vorsichtig: „IMHO ist das so NICHT SAUBER implementiert.“ … vielleicht hab ich`s ja nur falsch interpretiert … dann hab ich nix gesagt (außer SORRY) … warum bleib ich eigentlich nicht bei meinen Blöcken … upps der Kollege kommt vom LT … aber auch Gruppen haben „temporär“ ihre Vorteile … . 

Zurück zum Problem:
Analyse, Spezifikation, Entwurf mit Makro- und Mikrostruktur sind gedanklich klar und formuliert, es scheitert an der Implementierung und Integration… .
Kommentare und Anregungen weiterhin uneingeschränkt  erwünscht…

Wie gesagt kommt nix … geht nix … solange es „funzt“ …  (wer auch immer  „funzt“ erfunden hat – schön schrecklich) 
… es gibt  ja noch andere Bastelbaustellen …

Dank DIR JÖRN u nd Marc & Co.

Mit freundlichen Grüßen Dorfy

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

---

Zitat:

---

Original erstellt von Dorfy:

als ob – mit „(car GNAME)“ auch nur auf die „oberste“ Gruppe zurückgegriffen wird.

---

Ha, ha, ha erwischt ;-)...
Gut möglich, keine Ahnung ob das so ist. Das ist schon 'ne ganze Zeit her das ich das gecodet habe. Es könnte sein, das meine Überlegung folgende war:
Nehm' ich ein Objekt das Bestandteil einer Gruppe ist und füge das einer anderen Gruppe hinzu sind als Resultat alle Gruppen des gepickten Objekts Bestandteil der neuen Gruppe.
Aber ich weiß es nicht mehr. Leider habe ich für das Gruppentool gerade keine Zeit, sonst würde ich mir das mal anschauen. Ich leg's mal auf den großen Stapel...
...

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

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

---

Hi Marc, hi Jörn, …
@Marc
"as designed" or NOT "as designed" … this is the question?
IMHO - Mit “cons... “ in der Subfunktion wird die “ACAD-Logik” umgedreht!?
… auch ACAD folg „IMHO“ einer Logik … welcher? … this? … only now? ...
Euer Weg ist dennoch der richtige…“Anzahl der Entities der Gruppen“!?

Es klemmt wie immer bei der Implementierung - im gekennzeichneten Bereich… warum…???
Guter Rat … (kann auch schon wo anders klemmen [IMHO]) …

;;; löst jeweils nur die "obersten" vorhandenen Gruppen von gepickten Objekten auf
(defun C:xxx (/ GROUPSEL GNAME Gelem dgnamen d g_liste merkerset TTT)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
  ALT-PICKSTYLE (getvar "pickstyle")
(if GROUPSEL (progn  (repeat (sslength groupsel)
    (if      (setq gname    (GET-GROUPNAME
      (entget        (ssname groupsel          (setq d (if d (1+ d)0))    ))))
      (if GNAME        (progn
        (setq GELEM (itoa (length GNAME)))
  (foreach ELEM GNAME  
            (command "_.select" "_group" elem "")
    (setq TTT  (sslength (ssget "_P")))   
            (if (> MERKERSET ttt)
    (setq MERKERSET merkerset dgnamen dgnamen)
    (setq merkerset ttt dgnamen elem)   ))
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
      (if
      (not (member (dgnamen) g_liste))
        (setq g_liste (cons (dgnamen) g_liste)))    ))
  (if g_liste (mapcar '(lambda(A) (TOGGLE-GROUPSELECT t)
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    (c:xxx)
  (command "_.-group" "_ex" A)
  (princ (strcat "\nGruppe: \"" A "\" aufgelöst. AutoCAD Kommando eingeben...")))g_liste)
    (princ "\nKeine Gruppe aufgelöst. AutoCAD Kommando eingeben..."))))  ))
    (alert "keine Objekte ausgewählt.")
(princ)    )

Die Überwachungsfunktion zeigt eigentlich "grünes Licht" !!?
Bitte – wenn entklammern – dann separat – bin noch im Lernprozess ((((((Lisp… ))))
Erst gehen … dann laufen … dann fl… .
Mit freundlichen Grüßen dorfy

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

---

so, erstmal noch was Grundsätzliches :
Es gibt - von der Systemlogik keine oberste Gruppe!! Objekt A kann zur Gruppe X und zur Gruppe Y gehören (mal mit PICKSTYLE=0 realisieren!).. Gruppe X enthält noch weitere 10 Objete, Gruppe Y bloß noch ein weiteres. -> Es gibt keine übergeordnete auch wenn X mehr Objekte als Y enthält und die Gruppen nacheinander erstellt worden sind.

Einziger Ansatz um eine Art "Gruppenstruktur" zu erfassen ist IMHO:
die Objektlisten der zum Objekt A gehörenden Gruppen und ihre Reihenfolge innerhalb der Grupenliste zu ermitteln und aufgrund der Schnittmengen der Objektlisten zu erkennen: alle Objekt von Gruppe R sind in Gruppe S enthalten, S liegt in der Gruppenliste nach R, ist also später erstellt, und somit ist S die übergeordnete.
Aber Eindeutig ist das mit der Reihenfolge innerhalb der Gruppenliste ja auch nicht.. Zeitpunkt des Gruppenerstellens und des Befüllens muß ja nicht derselbe sein ...vielleicht zu theoretisch, vielleicht ist es auch einfach zu spät heute 

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

---

Soooo

;;; löst jeweils nur die "obersten" vorhandenen Gruppen im Auswahlsatz auf
(defun C:xxx (/ GROUPSEL GNAME DGNAMEN D G_LISTE MERKERSET)
(princ "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
  ALT-PICKSTYLE (getvar "pickstyle")
  (if GROUPSEL (progn
    (repeat (sslength GROUPSEL)
    (if (setq GNAME (GET-GROUPNAME
        (entget (ssname GROUPSEL (setq D (if D (1+ D)0))))))
      (if GNAME (progn       
        (foreach ELEM GNAME  
        (command "_.select" "_group" elem "")        
        (if (not(> MERKERSET (sslength (ssget "_P"))))
          (setq MERKERSET (sslength (ssget "_P")) DGNAMEN ELEM)))
        (if (not (member DGNAMEN G_LISTE))
        (setq G_LISTE (cons DGNAMEN G_LISTE))DGNAMEN) )) ))
    (if G_LISTE (mapcar '(lambda(A) (TOGGLE-GROUPSELECT t)
      (command "_.-group" "_ex" A)
      (princ (strcat "\nGruppe: \"" A "\" aufgelöst.")))G_LISTE)
    (princ "\nKeine Gruppe aufgelöst.") ) )
    ;(alert "keine Objekte ausgewählt.") )
  (princ "\nKeine Objekte ausgewählt!") )
(princ "\nAutoCAD Kommando eingeben...")
(princ) )

Geht!!!

@Marc ich hoffe es entspricht den Vorstellungen, man kann da gewiss noch kürzen und zusammenfassen

@CADmium IMHO „oberste“ Gruppe enthält die meisten Elemente, lasse mich aber gern eines besseren belehren, …
mfg Dorfy

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

---

Zitat:

---

Original erstellt von Dorfy:

@CADmium IMHO „oberste“ Gruppe enthält die meisten Elemente, lasse mich aber gern eines besseren belehren, …
mfg Dorfy

---

das mag vielleicht bei deiner Arbeitsweise so sein und in der Hinsicht stellt das Lisp sicher einen Workaround dar, aber z.B. man kann ja auch mal mit PICKSTYLE 1 und mal mit PICKSTYLE 0 arbeiten .. da kann ich dann eine ganze Gruppenhierachie haben mit Objekt A in der "untersten" Gruppe .. zusätzlich ist Objekt A aber auch noch Member  einer anderen Gruppe mit gaaaanz viel anderen Objekten, die wegenmeiner auch eher als der "Gruppenbaum" erstellt wurde.
Welche Gruppe soll nun bei Anklicken von Objekt A aufgelöst werden ??

Wie auch immer, wenn's dir  nützt, hat das Proggi ja seinen Zweck erfüllt, was generelles ist es jedoch IMHO nicht

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

---

Hallo
@CADmium ... ja ... überzeugt ... Du hast Recht

Also Doch Version eins, ist zwar "not as designed" ... geht aber
der Reihenfolge nach ... oder einer anderen ...
Den Zweck erfüllt es und einige weitere user sind bestimmt erfreut.
Mfg Dorfy

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

---

Zitat:

---

Original erstellt von Dorfy:

Also Doch Version eins, ist zwar "not as designed" ... geht aber
der Reihenfolge nach ... oder einer anderen ...

---

Keine Version!!! Es gibt nichts allgemeingültiges weil Gruppen ansich nicht geschachtelt sind!! Gruppen speichern die zu ihnen gehörenden Zeichnungsobjekte, und die Zeichnungsobjekte speichern die Gruppen, zu denen sie gehören. Ende. Aus.

Wenn man nur mit Pickstyle=1  arbeitet kann man nach der Anzahl der Gruppenobjekte gehen, die "oberste" hat die meisten.. deshalb bleibt nur der Satzt stehen :

Zitat:

---

Original erstellt von Dorfy:

Den Zweck erfüllt es und einige weitere user sind bestimmt erfreut.

---

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

---

Hi,
bin gerade am Grübeln…
Man nehme n-Elemente, baue eine Gruppe aus diesen Elementen,
kopiere diese x-fach…,
probiere nun eine bestimmte Auswahl an Gruppen (große Menge,
zBsp x-1) auf einmal aufzulösen mit Hilfe der o.g. Funktionen, Tools…(vorzugsweise Joern oder mein Ansatz)
es dauert ….
Mein System (P4 3.2  Acad2007  XP-Pro).

A) Meine Einkreisung des „Problems“  liegt in:
        „ ;;; SubFunction: Gibt die Gruppennamen zurück,
        zu denen ein Objekt gehört
        defun GET-GROUPNAME“….? 
        (Sub erstellt von Marc und Co. wie o.g.)
        (wenn ja dann b sonst c)

B) Es ist die „While“- Schleife?
        (zu mindest Axel tut sich wohl schwer mit dieser Schleife)
        Wie sieht ein    (foreach elem lst (if  … 330 … member lst …
        oder                      (mapcar '(lambda (ELEM)  (if…
        oder sooo… optimale….Laufzeit… aus?!
        (evtl. mit VL? … )  (wenn ja dann „Ideen-Vorschläge?“ …sonst

C) Ich liege falsch und nun…?

Hab mal nen Thread zu Listen oder Vergleich …oder  Laufzeit…oder… gefunden …(ich glaube sogar von Marc…
mmh!… nur wer, wie bzw. was  geht schneller.
Wie sollte es aussehen?!
Hat wer ne sinnvolle Idee bzw. Ansatz???
Mit freundlichen Grüßen Dorfy

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

---

Hallo Dorfy,
Du läßt Dir für jedes ausgewählte Element die zugehörigen Gruppennamen ausgeben. Dann prüfst Du wieviel Elemente pro Gruppename vorhanden sind, und das für jedes Element.
Meiner Meinung nach kann man den Schritt abkürzen:
Wenn ein Element die Gruppennamen ("Gruppe1" und "Gruppe2") beihaltet, dann führst Du die Prüfung einmal durch, um den Gruppennamen mit den meisten Elementen als aufzulösende Gruppe zu speichern.
Dann kommt das nächste Element dran, wenn das Element aber wiederum die Gruppennamen ("Gruppe1" und "Gruppe2") beinhaltet, dann muß die Prüfung meiner Meinung nach nicht mehr durchgeführt werden.

Den folgenden Code kannst Du ja mal durchchecken, ob der dann schneller ist und auch Deine gewünschten Ergebnisse erzielt:

Code:

---

(defun C:xxx  (/ GROUPSEL GNAME DGNAMEN D G_LISTE MERKERSET
      GET-GROUPNAME_LISTE)
  (princ
    "\nObjekt(e) anwählen, dessen Gruppe(n) aufgelöst werden soll(en): ")
  (setq GROUPSEL (ssget))
  ALT-PICKSTYLE
  (getvar "pickstyle")
  (if GROUPSEL
    (progn
      (repeat (sslength GROUPSEL)
(setq GNAME (GET-GROUPNAME
      (entget (ssname GROUPSEL
      (setq D (if D
(1+ D)
0))))))
(if (not (member GNAME GET-GROUPNAME_LISTE))
  (progn
    (setq GET-GROUPNAME_LISTE
  (cons GNAME
GET-GROUPNAME_LISTE))
    (mapcar
      '(lambda (A)
(command "_.select" "_group" A "")
(if
  (not (> MERKERSET (sslength (ssget "_P"))))
    (setq MERKERSET (sslength (ssget "_P"))
  DGNAMEN  A))
(if (not (member DGNAMEN G_LISTE))
  (setq G_LISTE (cons DGNAMEN G_LISTE))
  DGNAMEN))
      GNAME))))
      (if G_LISTE
(mapcar '(lambda (A)
  (TOGGLE-GROUPSELECT t)
  (command "_.-group" "_ex" A)
  (princ (strcat "\nGruppe: \"" A "\" aufgelöst.")))
G_LISTE)
(princ "\nKeine Gruppe aufgelöst.")))
;(alert "keine Objekte ausgewählt.") )
    (princ "\nKeine Objekte ausgewählt!"))
  (princ "\nAutoCAD Kommando eingeben...")
  (princ))

---

------------------
viele Grüße

Jörn

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

---

@Jörn
...immer wieder die selben...
Danke... werd ich gleich mal probieren
mfg dorfy

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

---

@Jörn
schade... nicht der gewünschte erfolgt

wie oben gesagt, glaube ich, dass es an der subfunktion
("get-groupname" oder so) liegt,
speziell an der while-Schleife mit den Index-zähler
bei der verfolgung mit "vlide" hängt mein rechner in dieser schleife
sehr lange.
Dennoch danke

Vielleicht hat ja einer der urheber... cadmium oder marc oder ...ne idee.

mfg dorfy

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

---

Zitat:

---

Original erstellt von Dorfy:
Vielleicht hat ja einer der urheber... cadmium oder marc oder ...ne idee.

---

Sorry Dorfy,
für mich sind Gruppen ausschließlich temporäre Hilfskonstrukte. Ich habe keinerlei Verwendung oder Bedarf für einen laufzeitoptimierten Code meiner Gruppentools. Von mir wirst Du da keine Hilfe erwarten können. Nix für ungut.

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

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