kojacek

Wielkość i ilość poprawek do ostatniego ZwCAD-a (kroczącego nieustannie gdzieś między wersją alpha i ciągle jeszcze bardzo wczesną beta), pozwala przypuszczać że ów "bieg czasu" będzie bardzo długi. Przy spełnieniu warunku że "odpowiednik" w tym czasie nie będzie zmierzał do przodu...

zgrabniej może być tak:
(setvar "BKGCOLOR" (abs (- 7 (getvar "BKGCOLOR"))))  

zgrabniej może być tak:
(setvar "BKGCOLOR" (abs (- 7 (getvar "BKGCOLOR"))))  

Bierzesz plik z załącznika. Wklejasz sobie do jakiegoś katalogu. W Ac (czy Zw) uruchamiasz polecenie appload, wybierasz plik i zatwierdzasz. Po załadowaniu, masz dostępne polecenie L-LINIA.
 
Na marginesie, jeśli chodzi o ładowanie lsp, arx, dll, zrx itd, czy ogólnie o korzystaniu z możliwości adaptacji, mógłbyś wykazać więcej swojego zaangażowania i dowiedzieć się w help-ie, poprzeglądać to czy inne fora cad...
l-line.lsp

Tutaj szerszy opis: https://kojacek.wordpress.com/autolisp/obiekty-niegraficzne/tablice-symboli/blok-effectivename/

Zagadnienie (bo nie problem) w AutoCAD, było (na polskim forum CAD) omawiane już wiele lat temu (gdy tylko pojawiły się bloki dynamiczne). Droga jest stosunkowo prosta: Odniesienie (wstawienie) bloku (mające nazwę anonimową) jest dynamicznym blokiem zależnym od nazwanego bloku dynamicznego, po spełnieniu warunków - (1) jego definicja posiada dane dodatkowe aplikacji o nazwie "AcDbBlockRepBTag", oraz (2) zawiera (w tych danych dodatkowych) odniesienie do uchwytu (handle) obiektu, który jest definicją bloku nazwanego.
 
W zestawie funkcji CADPL-Pack, (http://forum.cad.pl/cadpl-pack-v1-lsp-t78161.html) zdefiniowana jest funkcja o nazwie cd:BLK_GetDynBlockNames. Zwraca ona listę wszystkich nazw odniesień (bloków anonimowych) zależnych.

Dyskusje na ten temat w przeszłości miały już miejsce:
http://forum.cad.pl/przenoszenie-w-a-ciwo-ci-rysunku-drawing-properties-t79709.html?
oraz:
http://forum.cad.pl/cadpl-pack-v1-lsp-t78158-100.html
 
Niezmiennie polecam zatem CADPL-Pack'a, do tychże zastosowań, z uwzględnieniem funkcji:
cd:DWG_AddCustomProp cd:DWG_GetCustomProp cd:DWG_RemoveCustomProp cd:DWG_GetSummaryInfo cd:DWG_SetSummaryInfo  
oraz innych, do zapisu / odczytu plików tekstowych - tamże

Próbowałeś: cd:ACX_LoadLineType z: http://forum.cad.pl/cadpl-pack-v1-lsp-t78161.html ?

Kolejny etap do testowania... Jeśli chodzi powinien:
1) Rozpoznawać prawidłowe bloki
2) "Urozmaicić wybór", poprzez: podanie nazwy z ręki / wybranie z listy / wskazanie bloku
3) Zapamiętywać ostatnie ustawienia
4) No i polecenie ma skrócone - teraz jest B3D
 
Kod:
; =========================================================================================== ; (load "CADPL-Pack-v1.lsp" -1) ; =========================================================================================== ; (defun C:B3D ()(ExtrIns)(princ)) ; =========================================================================================== ; (defun ExtrIns (/ LBlk InsName StartP EndP PathEnt InsObj)   (if     (not (setq LBlk (BlockProfileList)))     (princ "\nW rysunku nie zdefiniowano bloków dla profili. ")     (progn       (if (not *B3D-Settings*)(setq *B3D-Settings* (list (car LBlk) 1.0)))       (if         (setq StartP (getpoint "\nPierwszy punkt linii definiującej ścieżkę: "))         (if           (setq EndP (getpoint StartP "\nKoniec ścieżki: "))           (if             (setq InsName (GetBlockProfileName LBlk))             (progn               (cd:SYS_UndoBegin)               (setq InsObj (cd:BLK_InsertBlock StartP InsName '(1 1 1) 0 T))               (SetInsertZOrient                 (NewVect StartP EndP)                 (setq InsObj (vlax-vla-object->ename InsObj))               )               (setq PathEnt (cd:ENT_MakeLine (getvar "CTAB") StartP EndP T))               (ExtrudeProfile (vlax-ename->vla-object InsObj) PathEnt)               (cd:SYS_UndoEnd)             )           )         )       )     )   ) ) ; =========================================================================================== ; (defun GetBlockProfileName (LProf / f k s)   (setq f (car *B3D-Settings*)         s (car (mapcar '(lambda (%)(cd:STR_ReParse LProf %))(list " ")))   )   (initget (strcat "Lista Wybierz " s))   (setq k     (vl-catch-all-apply 'getkword       (list (strcat "\nProfil [Lista/Wybierz] lub podaj nazwę <" f ">: "))     )   )   (if     (not k) f     (if       (= (type k) 'STR)       (cond         ( (= k "Lista")(ProfileDlg LProf))         ( (= k "Wybierz")(SelectBlock LProf))         (t k)       )     )   ) ) ; =========================================================================================== ; (defun ProfileDlg (BlkL / r p)   (setq r (cd:DCL_StdListDialog BlkL     (vl-position (car *B3D-Settings*) BlkL)     "Profile" "Wybierz:" 25 12 2 12 (list "&Ok" "&Anuluj")     nil T T nil)   )   (if r (progn     (setq p (nth r BlkL))     (setq *B3D-Settings* (list p (cadr *B3D-Settings*))))   ) p )   ; =========================================================================================== ; (defun SelectBlock (Lst / e d s)   (if     (and       (setq e (entsel "\nWybierz blok: "))       (setq d (entget (car e)))       (= "INSERT" (cdr (assoc 0 d)))       (member         (strcase (setq s (cdr (assoc 2 d))))         (mapcar 'strcase Lst)       )     )     (progn       (setq *B3D-Settings* (list s (cadr *B3D-Settings*))) s     )   )   ) ; =========================================================================================== ; (defun ExtrudeProfile (Blk Lin / Prf Crv Reg Del)   (vla-explode Blk)   (setq Prf (entlast))   (vla-delete Blk)   (if     (cond       ( (= "LWPOLYLINE" (cdr (assoc 0 (entget Prf))))         (setq Crv (vlax-make-safearray vlax-vbObject '(0 . 0)))         (vlax-safearray-put-element Crv 0 (vlax-ename->vla-object Prf))         (setq Reg (vla-AddRegion (cd:ACX_ASpace) Crv))       )       ( (= "REGION" (cdr (assoc 0 (entget Prf))))         (setq Reg (vlax-ename->vla-object Prf))       )       (t nil)     )     (progn       (vla-AddExtrudedSolidAlongPath         (cd:ACX_ASpace)         (if           (= (type Reg )'VLA-OBJECT)           Reg           (setq Del (vlax-safearray-get-element (vlax-variant-value Reg) 0))         )         (vlax-ename->vla-object Lin)       )       (if Del (vla-delete Del))       (foreach % (list Lin Prf)(entdel %))     )   ) ) ; =========================================================================================== ; (defun NewVect (p1 p2 / dt sq sm um uv)   (setq dt (mapcar '- p2 p1)         sq (mapcar '* dt dt)         sm (apply '+ sq)         um (sqrt sm)         uv (mapcar '/ dt (list um um um))   ) ) ; =========================================================================================== ; (defun SetInsertZOrient (ExtrVec Ename / e b)   (setq e (entget Ename)         b (trans (cdr (assoc 10 e)) Ename ExtrVec)         e (subst (cons 10 b)(assoc 10 e) e)         e (subst (cons 50 0.0)(assoc 50 e) e)         e (subst (cons 210 ExtrVec)(assoc 210 e) e)   )   (entmod e) ) ; =========================================================================================== ; (defun BlockProfile-p (Name / l d)   (if     (= 1 (length (setq l (cd:BLK_GetEntity Name nil))))     (progn       (setq d (entget (car l)))       (or         (and           (= (cdr (assoc 0 d)) "LWPOLYLINE")           (= 1 (logand 1 (cdr (assoc 70 d))))         )         (= (cdr (assoc 0 d)) "REGION")       )         )    ) ) ; =========================================================================================== ; (defun BlockProfileList (/ l)   (if     (setq l (cd:SYS_CollList "BLOCK" (+ 1 2 4 8)))     (acad_strlsort (vl-remove-if-not '(lambda (%)(BlockProfile-p %)) l))   ) ) ; =========================================================================================== ; (princ "\nZaładowano polecenie: B3D ") (princ)

Tymczasem wróćmy (bośmy nieco "zboczyli"... ;) ) do wyboru polilinii. Krótko jeszcze o "zadaniu domowym". Spójrzmy na obrazek porównujący prostokąt z "kokardką":
 
Pożądany przez nas czworokąt będący prostokątem można sprawdzić też w ten sposób:
Weźmy dwa sąsiednie boki (np. 1-2 i 2-3). Wybierzmy najdłuższy z nich (tu będzie to 1-2). I teraz sprawdzamy: w prostokącie ten najdłuższy z boków musi być krótszy od długości przekątnej (np. 1-4), dodatkowo oczywiście to (przekątne) jednocześnie muszą być sobie równe. I to chyba w zupełności wystarczy?
Kod "zadania domowego":
(defun SelRect (/ e d rect-p)   (defun rect-p (p / d)     (if                                          ; jezeli       (not (zerop (distance (car p)(cadddr p)))) ; 1 i 4 pkt sie nie pokrywaja       (and                                       ; sprawdz         (equal                                   ; czy jest rowna           (setq d (distance (car p)(caddr p)))   ; dlugosc 1 przekatnej           (distance (cadr p)(cadddr p))          ; i 2 przekatnej?           0.001         )         (<                                       ; i najwiekszy           (max                                   ; bok z 1 i 2             (distance (car p)(cadr p))           ; jest             (distance (cadr p)(caddr p))         ; mniejszy           )           d                                      ; od przekatnej         )       )                                          ; T  (spelnia warunki)     )                                            ; nil (nie spelnia)   )   (if         (and             (setq e (entsel "\nWskaż prostokąt: "))                    ; jest wybor       (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") ; to LWPoly       (= 1 (logand 1 (cdr (assoc 70 d))))                        ; jest zamknieta       (zerop (apply '+ (mapcar 'abs (cd:DXF_massoc 42 d))))      ; nie ma seg. lukowych       (= (cdr (assoc 90 d)) 4)                                   ; ma 4 wierzcholki       (rect-p (cd:DXF_massoc 10 d))                              ; jest prostokatem     )     (princ "\nOk")     (princ "\nŹle. ")   ) ) wzbogacony o komentarze, które pozwolą łatwiej prześledzić działanie.

Zadanie domowe rozwiązane bardzo dobrze (choć bez funkcji), ale ok. Funkcja może wygladać tak:
(defun SelRect (/ e d dia)  (defun dia (p)    (if      (not (zerop (distance (car p)(cadddr p))))      (equal        (distance (car p)(caddr p))        (distance (cadr p)(cadddr p))        0.001      )    )  )  (if       (and           (setq e (entsel "\nWskaż prostokąt: "))      (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE")      (= 1 (logand 1 (cdr (assoc 70 d))))      (zerop (apply '+ (mapcar 'abs (cd:DXF_massoc 42 d))))      (= (cdr (assoc 90 d)) 4)      (dia (cd:DXF_massoc 10 d))    )    (princ "\nOk")    (princ "\nŹle. ")  )) SelRect, ma w sobie zdefiniowaną funkcję dia, która zwraca T jeżeli z listy punktów wynika że odległości 1-3 i 2-4 (przekątne) są równe (z tolerancją .001). Trzeba zwrócić uwagę na sprawdzenie czy pierwszy i ostatni punkt się nie pokrywają - eliminuje to przypadek listy 4 współrzędnych definuijących w rzeczywistości trójkąt, a nie czworokąt. Funkcja jest argumentacyjna, i wstawiona jest jako kolejny element w and. Czyli wyszło teraz tak:
- coś wybrane
- to jest LWPoly
- jest zamknięta
- nie ma łuków
- ma 4 wierzchołki
- przekątne są równe...
Wracając do naszej funkcji wyboru, można niektóre warunki zargumentyzować np. otwarta/zamknięta itp. W następnym odcinku możemy to spróbować.

 
Masz rację! Trzeba dodać jeszcze jeden inny warunek. Jaki będzie najprościej?

No to zadanie domowe nam urosło... ;)
Proponuję dodatkowo sprawdzenie (porównanie) pól polilini: Otrzymanych z pomnożenia długości 1 i drugiego boku, oraz właściwości Area obiektu. Zdaje się że każde "skrzywienie" geometrii (pomimo równych przekątnych) powinno dać różne wyniki. Zmodyfikowana SelRect wygląda tak:
(defun SelRect (/ e d dia)   (defun dia (l p)     (if       (not (zerop (distance (car p)(cadddr p))))       (and         (equal           (distance (car p)(caddr p))           (distance (cadr p)(cadddr p))           0.001         )         (equal           (* (distance (car p)(cadr p))(distance (cadr p)(caddr p)))           (vla-get-Area (vlax-ename->vla-object l))           0.001         )       )     )   )   (if         (and             (setq e (entsel "\nWskaż prostokąt: "))       (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE")       (= 1 (logand 1 (cdr (assoc 70 d))))       (zerop (apply '+ (mapcar 'abs (cd:DXF_massoc 42 d))))       (= (cdr (assoc 90 d)) 4)       (dia (car e)(cd:DXF_massoc 10 d))     )     (princ "\nOk")     (princ "\nŹle. ")   ) )

Pozwolę sobie wyrazić swoją opinię, w sprawie trzech powyższych punktów.
Ad 1. Zgoda, ale chyba za wcześnie na to wszystko. Do tej pory odnosiłem wrażenie że wątek mając nieco charakter edukacyjny, powoli rośnie zwiększając poziom zaawansowania. Zwłaszcza że kolega Iskra (zakładając wątek) sam nadmienił że się dopiero uczy. Napisał kawałek dość dobrego kodu (w ogólności co do zasady), nie wystrzegł się paru błędów, ale nie zniechęcajmy go jednak na samym początku. Na vl-catch-all-apply przyjdzie jeszcze czas. Na razie bez radykalnego zawsze i absolutnie. Póki co proste rzeczy, pytania i odpowiedzi. Chce wiedzieć, pyta, ma potencjał, na wszystko przyjdzie czas. Popatrz (że znów wrócę do CAD-Pack'a), nie mówię że wszystko jest do d*py, weź no funkcję cd:USR_EntSelObj, daj se spokój bo ona jest git... Na marginesie, warto na nią też popatrzeć.
Ad 2. Różnić się będę także co do rzekomej czytelności kodu. Wydaje mi się że przedstawiona propozycja zaciemnia a nie rozjaśnia. Ogólnie jestem zwolennikiem stosowania funkcji w funkcji (mającej charakter lokalny) w dwóch przypadkach. Po pierwsze: podfunkcja (tak ją nazwijmy umownie), wywoływana jest wielokrotnie, lub (po drugie), jest na tyle obszerna że zaciemnia właśnie kod główny. Ten drugi przypadek widać w zastosowaniu funkcji dia wewnątrz SelRect. Wszystkie inne wywołania w and, (typ obiektu, zamknięcie, bulge itp.) wydają się na tyle proste że nie widzę potrzeby definiowania ich jako osobne funkcje. Zwłaszcza jako funkcje lokalne (mające zasięg tylko wewnątrz innej jednej funkcji). Spójrzmy, przykład pierwszy z brzegu. Kod:
 
(defun IsPolyline (Entity / )  (= (cdr (assoc 0 Entity)) "LWPOLYLINE")  ) właściwie niczego nie wnosi (oprócz zwiększenia objętości), bowiem samo:
 
(= (cdr (assoc 0 Entity)) "LWPOLYLINE") wydaje się być i tak czytelne. Ewentualnie można je opatrzyć komentarzem.
Powtórzę raz jeszcze - zwłaszcza jako funkcja lokalna. Co innego gdyby to była funkcja biblioteczna (mogąca mieć wielokrotne zastosowanie w wielu miejscach). Jestem zagorzałym zwolennikiem tworzenia funkcji bibliotecznych. Jednak uważam, należy zachować tutaj pewien umiar i szukać możliwie uniwersalnego zastosowania. Bowiem (jeszcze na tym przykładzie), gdyby nawet twoja IsPolyline, była nawet funkcją biblioteczną, jej sens i tak jest mocno wątpliwy. Bowiem tym tropem trzeba by stworzyć tyle funkcji ile jest typów obiektów (Isline, IsArc, IsCircle... etc.) Nie trzeba wiele analizować że nie ma to sensu. W tym przypadku funkcja biblioteczna mogłaby być jedna i sprawdzać czy podany obiekt jest akceptowany wg jakiegoś kryterium (tutaj rodzaj obiektu). Na przykład definicja:
 
(defun GetTypeObj (Ent TypeLst)  (car (member (cdr (assoc 0 (entget Ent))) TypeLst)) ) i potem przykładowe wywołania:
 
(GetTypeObj (car (entsel)) '("LWPOLYLINE" "LINE" "ARC")) pozwala określić ze wskazania czy to jest polilnia albo linia albo łuk
czy:
 
(GetTypeObj (car (entsel)) '("LWPOLYLINE")) zawęzić typ tylko do polilinii.
Podsumowując - w mojej opinii - poprzez przerost definicji funkcji zaciemniłeś, a nie rozjaśniłeś kod.
 
Ad 3. Powtórzę to co w Ad 1. Ogólnie zgoda, niemniej tutaj testujemy budowanie prostej funkcji ilustrując jej działanie, tak aby była zrozumiała, na tym poziomie ogólności. W tej chwili potrzebujemy informacji czy wybór jest ok czy be. Gdy to przejdziemy nastąpić może ciąg dalszy (coś się dzieje gdy jest ok, coś innego gdy jest be).

Tymczasem wróćmy (bośmy nieco "zboczyli"... ;) ) do wyboru polilinii. Krótko jeszcze o "zadaniu domowym". Spójrzmy na obrazek porównujący prostokąt z "kokardką":
 
Pożądany przez nas czworokąt będący prostokątem można sprawdzić też w ten sposób:
Weźmy dwa sąsiednie boki (np. 1-2 i 2-3). Wybierzmy najdłuższy z nich (tu będzie to 1-2). I teraz sprawdzamy: w prostokącie ten najdłuższy z boków musi być krótszy od długości przekątnej (np. 1-4), dodatkowo oczywiście to (przekątne) jednocześnie muszą być sobie równe. I to chyba w zupełności wystarczy?
Kod "zadania domowego":
(defun SelRect (/ e d rect-p)   (defun rect-p (p / d)     (if                                          ; jezeli       (not (zerop (distance (car p)(cadddr p)))) ; 1 i 4 pkt sie nie pokrywaja       (and                                       ; sprawdz         (equal                                   ; czy jest rowna           (setq d (distance (car p)(caddr p)))   ; dlugosc 1 przekatnej           (distance (cadr p)(cadddr p))          ; i 2 przekatnej?           0.001         )         (<                                       ; i najwiekszy           (max                                   ; bok z 1 i 2             (distance (car p)(cadr p))           ; jest             (distance (cadr p)(caddr p))         ; mniejszy           )           d                                      ; od przekatnej         )       )                                          ; T  (spelnia warunki)     )                                            ; nil (nie spelnia)   )   (if         (and             (setq e (entsel "\nWskaż prostokąt: "))                    ; jest wybor       (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") ; to LWPoly       (= 1 (logand 1 (cdr (assoc 70 d))))                        ; jest zamknieta       (zerop (apply '+ (mapcar 'abs (cd:DXF_massoc 42 d))))      ; nie ma seg. lukowych       (= (cdr (assoc 90 d)) 4)                                   ; ma 4 wierzcholki       (rect-p (cd:DXF_massoc 10 d))                              ; jest prostokatem     )     (princ "\nOk")     (princ "\nŹle. ")   ) ) wzbogacony o komentarze, które pozwolą łatwiej prześledzić działanie.

Funkcja z przedrostkiem C: to specjalna definicja funkcji lispowej - najoględniej mówiąc tworzy polecenie AutoCAD-a, zdefiniowane w LISP-ie. Wywołanie jej działa jak polecenie, można je wywołać z linii poleceń. Taka funkcja nie może mieć argumentów.
Natomiast "zwykłe" funkcje można wywołać w linii poleceń, ale trzeba je wywoływać w pełnej składni wymaganej przez interpreter LISP-a, czyli w nawiasach i z argumentami (jeśli funkcja je posiada). I tak, namaluj coś i w linii poleceń napisz:
(entlast) funkcja zwróci ename ostatniego obiektu. Teraz wywołaj funkcję z argumentem np. :
(entget (entlast)) dostaniesz listę DXF danych tego obiektu.
Tak samo wywołujesz funkcję SelRect:
(SelRect)  
Drugi problem. Kierunek polilinii. Potrzebujesz funkcji napisanej przez gile'a. Wygląda tak:
;; Clockwise-p  -  Gilles Chanteau (gile) ;; Returns T if p1,p2,p3 are clockwise oriented (defun gc:clockwise-p (p1 p2 p3)     (< (sin (- (angle p1 p3) (angle p1 p2))) -1e-14) ) Zwraca T jeśli 3 punkty podane jako argumenty funkcji tworzą kąt zorientowany zgodnie z ruchem wskazówek zegara, lub nil w przeciwnym wypadku. 
Potem można już zdefiniować polecenie sprawdzające polilinię. Musi ona mieć co najmniej dwa wierzchołki. Funkcja może wyglądać tak:
(defun C:TESTCLP (/ e d p)   (if     (and       (setq e (entsel "\nWybierz polilinie: "))       (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE")     )     (if       (> (length (setq p (cd:DXF_massoc 10 d))) 2)       (gc:clockwise-p (car p)(cadr p)(caddr p))     )   ) )

Witam
Wydaje mi się, że obliczenie przekątnych nie wystarczy, bo obiekt może być skręcony o 180 st. względem osi X, a "przekątne" wyjdą takie same ;)

Pozdrawiam

Od końca. Ilość wierzchołków to jedyna wartość dla kodu 90. Stąd od razu porównanie. Dla zamknięcia sprawa jest bardziej złożona. Kod 70 zawiera jednocześnie informację czy Polilinia jest zamknięta, oraz czy generowanie rodzaju linii jest włączone czy nie. I tak: 0 - poly otwarta a 1 zamknięta. PLINEGEN zaś to wartość 128. Stąd test zamknięcia polilinii sprowadza się do sprawdzenia logand = 1 (1 i 129 to zamknięta).

Jeśli można tutaj (chyba że admin przeniesie do innego wątku), od samego początku.
Czyli wybór obiektu. Niech będzie prosta funkcja o nazwie Sel do wyboru jednego obiektu. Do testowania zwracać będzie wynik Ok lub Źle. W kolejnych krokach trochę urośnie, ale pozwoli to prześledzić działanie.
Podobnie jak w twoim kodzie, chcemy wybrać obiekt (polilinię). Spójrz:
 
(defun Sel (/ e) (if (setq e (entsel "\nWskaż polilinię: ")) (princ "\nOk") (princ "\nŹle. ") ) ) 

Powiedzmy szczerze że żadnych rewelacji, nie trafisz - masz źle, wybierzesz jest Ok. Powiela twój błąd - możesz wybrać cokolwiek, a chcesz przecież polilinię.
Zatem druga przymiarka:
 
(defun Sel (/ e d)  (if    (and      (setq e (entsel "\nWskaż polilinię: ")) (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") ) (princ "\nOk") (princ "\nŹle. ") ) ) W and od razu pobieramy dane obiektu (zmienna d), jednocześnie sprawdzamy czy to Polilinia. Lepiej?
Lepiej ale... w twoim przypadku trzeba wybrać polilinię zamkniętą raczej. Zatem popatrzmy:
 
(defun Sel (/ e d)  (if    (and (setq e (entsel "\nWskaż polilinię: "))      (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") (= 1 (logand 1 (cdr (assoc 70 d)))) )    (princ "\nOk") (princ "\nŹle. ") ) ) and ma teraz trzy warunki ( 1.wybraliśmy obiekt, 2.polilinię i 3.zamkniętą). Zamknięta polilinia w DXF to kod 70. Musi mieć wartość 1 (oraz ewentualnie 129). Jest dużo lepiej. Ale to nie koniec. Właściwie, to powinieneś wybrać zamkniętą polilinię ale o co najmniej 3 segmentach... Więc zmieniamy sel:
 
(defun Sel (/ e d) (if    (and      (setq e (entsel "\nWskaż polilinię: ")) (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") (= 1 (logand 1 (cdr (assoc 70 d)))) (>= 4 (cdr (assoc 90 d))) ) (princ "\nOk") (princ "\nŹle. ") ) ) I teraz mamy już bardziej (niż mniej) poprawny kawałek kodu do wybrania polilini...

Jeśli można tutaj (chyba że admin przeniesie do innego wątku), od samego początku.
Czyli wybór obiektu. Niech będzie prosta funkcja o nazwie Sel do wyboru jednego obiektu. Do testowania zwracać będzie wynik Ok lub Źle. W kolejnych krokach trochę urośnie, ale pozwoli to prześledzić działanie.
Podobnie jak w twoim kodzie, chcemy wybrać obiekt (polilinię). Spójrz:
 
(defun Sel (/ e) (if (setq e (entsel "\nWskaż polilinię: ")) (princ "\nOk") (princ "\nŹle. ") ) ) 

Powiedzmy szczerze że żadnych rewelacji, nie trafisz - masz źle, wybierzesz jest Ok. Powiela twój błąd - możesz wybrać cokolwiek, a chcesz przecież polilinię.
Zatem druga przymiarka:
 
(defun Sel (/ e d)  (if    (and      (setq e (entsel "\nWskaż polilinię: ")) (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") ) (princ "\nOk") (princ "\nŹle. ") ) ) W and od razu pobieramy dane obiektu (zmienna d), jednocześnie sprawdzamy czy to Polilinia. Lepiej?
Lepiej ale... w twoim przypadku trzeba wybrać polilinię zamkniętą raczej. Zatem popatrzmy:
 
(defun Sel (/ e d)  (if    (and (setq e (entsel "\nWskaż polilinię: "))      (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") (= 1 (logand 1 (cdr (assoc 70 d)))) )    (princ "\nOk") (princ "\nŹle. ") ) ) and ma teraz trzy warunki ( 1.wybraliśmy obiekt, 2.polilinię i 3.zamkniętą). Zamknięta polilinia w DXF to kod 70. Musi mieć wartość 1 (oraz ewentualnie 129). Jest dużo lepiej. Ale to nie koniec. Właściwie, to powinieneś wybrać zamkniętą polilinię ale o co najmniej 3 segmentach... Więc zmieniamy sel:
 
(defun Sel (/ e d) (if    (and      (setq e (entsel "\nWskaż polilinię: ")) (= (cdr (assoc 0 (setq d (entget (car e))))) "LWPOLYLINE") (= 1 (logand 1 (cdr (assoc 70 d)))) (>= 4 (cdr (assoc 90 d))) ) (princ "\nOk") (princ "\nŹle. ") ) ) I teraz mamy już bardziej (niż mniej) poprawny kawałek kodu do wybrania polilini...

Nie wydaje mi się aby zabawy z obracaniem obiektów, będą efektywniejsze niźli LISP który wskazałem we wcześniejszym poście. Wykorzystuje on algorytm Grahama (wyznaczenie otoczenia punktów), sprowadzając wynik ostatecznie w uproszczeniu do najmniejszego prostokąta (o co w rzeczywistości chodzi). Wydaje mi się że działa dobrze w większości zastosowań.

Co do znalezienia najmniejszego prostokąta (opisującego płaską figurę) zobacz tutaj:
http://www.theswamp.org/index.php?topic=33607.msg389707#msg389707
Jest tam program do ściągnięcia:
http://www.theswamp.org/index.php?action=dlattach;topic=33607.0;attach=15988
Potestuj i zobacz czy spełnia twoje oczekiwania.
 
Co do lisp-ów zaś, zobacz tutaj: http://forum.cad.pl/cadpl-pack-v1-lsp-t78161.html
To o takim zjawisku o nazwie CADPL-Pack. Jest to zestaw funkcji bibliotecznych, których użycie (także w twoim omawianym tutaj problemie), znacznie może ułatwić pracę. Również sama dyskusja przy poczęciu i rozwoju Pack-a, (w mojej opinii) może być źródłem porządnej lisp-owej wiedzy. W tej chwili widzę już na początku wiele błędów w twoim kodzie. Chętnie (w miarę możliwości czasowych) służę pomocą, w ich ewentualnej poprawie i wyjaśnieniu na czym polegają.

He, he kawał przedni  :-)
 
Wnioski wyciągnięte, zamykam wątek, aby uniknąć dyskusji o pochodnych wyższych rzędów, która się szykuje   :D
 
Gdyby ktoś chciał coś dopisać proszę o info.
 
:hi:

Nie tam żebym upierał się aby odwodzić was od komplikowania sobie pracy, ale... może warto wykorzystać opcję _block do podziału?

To proste, z wymienionej wyżej linii usuń sekwencję znaków "_x"
Wtedy wywołanie:
(if (setq % (ssget '((0 . "LINE")(62 . 5)(410 . "Model"))))(sslength %) 0) poprosi Cię o wskazanie obiektów

Nie tam żebym się wtrącał czy coś,... ale wystarczy w linii poleceń wpisać:
(if (setq % (ssget "_x" '((0 . "LINE")(62 . 5)(410 . "Model"))))(sslength %) 0) i zaakceptować enterem...
Takie proste (bezbajtowe wręcz) wklepanie z klawiaturki, ma tę przewagę nad skompilowanymi plikami *.zel (nic im nie ujmując), że można zawsze zmienić dowolnie albo rodzaj obiektu czy kolor, bez tworzenia nowego pliku, definicji polecenia i podpinania ikonek. Może to i mniej spektakularne rozwiązanie, ale w mojej opinii bardziej elastyczne... Jutro kolega będzie chciał wybrać czerwone łuki... i co będzie?