Találd meg egy polyline ÖSSZES vertex pontját AUTOCAD-ben AUTOLISP segítségével!

Ahogy a digitális világ egyre inkább behálózza a tervezés és kivitelezés minden szegmensét, úgy válik mind fontosabbá az adatok pontos és hatékony kezelése. Az AutoCAD, mint iparági szabvány, ebben kiemelkedő szerepet játszik, de néha még a legrobbanékonyabb szoftverek is igénylik a „finomhangolást” vagy a specifikus feladatok automatizálását. Ebben a cikkben egy olyan kulcsfontosságú kihívásról rántjuk le a leplet, amely sok tervező és mérnök mindennapjait megkeserítheti: hogyan találjuk meg egy polyline ÖSSZES vertex pontját AutoCAD-ben, méghozzá AutoLISP segítségével. Ne csupán a kezdő és végpontok érdekeljenek minket, hanem minden egyes töréspont, amely a geometriát alkotja.

### A polyline – Nem csak egy egyszerű vonal

Gondoljunk csak bele: egy egyszerű vonal (LINE) csak két pontból áll. Egy kör (CIRCLE) egy középpontból és egy sugárból. De mi a helyzet egy polyline-nal? Ez a látszólag egyszerű entitás egy sorozat összekapcsolt szegmensből áll, amelyek lehetnek egyenesek vagy ívek, sőt, akár változó szélességűek is. Ráadásul létezik 2D és 3D polyline, illetve a modern „könnyített polyline” (LWPOLYLINE) és a régebbi, „nehéz polyline” (POLYLINE) is. [ICON: 💡] Ez a sokféleség teszi kihívássá az összes alkotó vertex pontjának megbízható kinyerését, de egyben hihetetlenül fontossá is, hiszen ez a geometria az alapja sok mérnöki számításnak, gyártási folyamatnak vagy térképészeti elemzésnek.

Az összes vertex pont ismerete nélkülözhetetlen például földmérési adatok feldolgozásánál, CNC megmunkálási útvonalak generálásánál, terület- vagy hosszszámításoknál, vagy akár épületinformációs modellezés (BIM) során, amikor a geometriai adatoknak pontosan kell illeszkedniük egymáshoz. Egy apró elcsúszás a vertex adatokban hatalmas következményekkel járhat.

### Miért épp az AutoLISP? [ICON: 🚀]

Sokan kérdezhetik, miért éppen az AutoLISP? Nos, a válasz egyszerű: az AutoLISP az AutoCAD natív programozási nyelve, ami azt jelenti, hogy tökéletesen integrálódik a szoftverbe, és közvetlen hozzáférést biztosít a rajzadatbázishoz. Nincs szükség külső könyvtárakra, telepítési macerára, és a futtatási sebesség is kiváló, különösen az ismétlődő, rutinszerű feladatoknál. Bár léteznek más API-k, mint a .NET vagy a ObjectARX, az AutoLISP a rugalmassága és az egyszerűsége miatt továbbra is páratlan eszköz a gyors és hatékony automatizálásra. Egy jól megírt AutoLISP rutin pillanatok alatt elvégzi azt, ami kézi munkával órákba, vagy akár napokba is telhetne.

### A polyline anatómiája: DXF csoportkódok

Ahhoz, hogy megértsük, hogyan nyerhetjük ki a vertex pontokat, először is meg kell értenünk, hogyan tárolja az AutoCAD a polyline adatait. Amikor egy AutoCAD entitásról információt kérünk le AutoLISP-pel (például az `(entget)` függvénnyel), az egy listát ad vissza, amely úgynevezett DXF csoportkódokból áll. Ezek a kódok számokkal azonosított adatpárok, ahol az első elem a kód (pl. `0`, `10`, `42`), a második pedig az érték (pl. entitás típusa, koordináták, dudorérték).

Nézzük a legfontosabbakat a polyline-ok esetében:

* **0-s csoportkód:** Ez mindig az entitás típusát azonosítja, például `”LWPOLYLINE”` (könnyített polyline), `”POLYLINE”` (régi, nehéz polyline) vagy `”VERTEX”` (a régi polyline alkotó eleme).
* **10-es csoportkód:** Ez a mi szempontunkból a legfontosabb! Ez tárolja a vertex pont koordinátáit. Egy LWPOLYLINE entitáson belül több 10-es csoportkód is található, mindegyik egy-egy vertexet reprezentál. A régi POLYLINE esetén viszont a `VERTEX` sub-entitásokban található meg a 10-es kód.
* **42-es csoportkód:** Ez az úgynevezett „bulge” érték. Ha egy polyline szegmens íves, ez az érték írja le az ív görbületét. Ha nulla, akkor a szegmens egyenes.
* **210-es csoportkód:** Az extrúzió irányát mutatja, általában (0.0 0.0 1.0) 2D polyline-oknál.

A kulcs tehát a DXF 10-es csoportkódok azonosítása és kinyerése.

### A Kódolás Élesben: Lépésről Lépésre [ICON: ⚙️]

Most pedig lássuk, hogyan valósíthatjuk meg mindezt AutoLISP-ben! A célunk egy olyan funkció létrehozása, amely kiválaszt egy polyline-t, majd visszaadja az összes vertexének koordinátáit egy listában.

#### 1. A polyline kiválasztása

Először is szükségünk van egy polyline entitásra, amivel dolgozhatunk. Erre a célra az `(entsel)` függvény tökéletes. Ez megkérdezi a felhasználótól, hogy válasszon ki egy entitást, és visszaadja annak entitásnevét és a kiválasztási pontot.

„`lisp
(setq ent (car (entsel „nVálassz ki egy polyline-t: „)))
„`

Fontos, hogy ellenőrizzük, a felhasználó valóban kiválasztott-e valamit, és az valóban polyline-e.

#### 2. Az entitás adatainak lekérése

A kiválasztott entitás összes DXF adatát az `(entget)` függvénnyel kaphatjuk meg:

„`lisp
(setq ent_data (entget ent))
„`

Ez egy hosszú lista lesz, tele különböző csoportkódokkal és értékekkel.

#### 3. A polyline típusának azonosítása

Mint említettük, kétféle polyline-típus van, és mindkettőt másképp kell kezelni. Az entitás típusát a `0-s csoportkód` értékével azonosíthatjuk:

„`lisp
(setq ent_type (cdr (assoc 0 ent_data)))
„`

#### 4. Könnyített Polyline (LWPOLYLINE) kezelése

Ez a modernebb és gyakoribb típus. Itt a vertex pontok (10-es csoportkódok) közvetlenül a fő entitás adatlistájában találhatók. Egyszerűen végig kell iterálnunk a listán, és minden 10-es kódot ki kell emelnünk.

„`lisp
(defun get-lwpolyline-vertices (ent_data)
(setq vertex_list ‘())
(foreach item ent_data
(if (= (car item) 10)
(setq vertex_list (cons (cdr item) vertex_list))
)
)
(reverse vertex_list) ; A pontok sorrendben legyenek
)
„`

#### 5. Régi Polyline (POLYLINE) kezelése [ICON: 🛠️]

Ez a típus bonyolultabb, mivel minden vertex egy különálló `VERTEX` entitásként létezik, és ezek a fő `POLYLINE` entitáshoz vannak láncolva. A `POLYLINE` entitást egy `SEQEND` (sequence end) entitás zárja.

„`lisp
(defun get-polyline-vertices (ent)
(setq vertex_list ‘())
(setq cur_ent (entnext ent)) ; Az első vertex entitás
(while (and cur_ent
(not (equal „SEQEND” (cdr (assoc 0 (entget cur_ent)))))
)
(setq vertex_data (entget cur_ent))
(if (= (cdr (assoc 0 vertex_data)) „VERTEX”)
(setq vertex_list (cons (cdr (assoc 10 vertex_data)) vertex_list))
)
(setq cur_ent (entnext cur_ent)) ; Következő entitás
)
(reverse vertex_list)
)
„`

#### 6. Az adatok feldolgozása és felhasználása

Miután kinyertük a vertex pontokat, egy listában tárolódnak. Ezzel a listával már bármit megtehetünk: kiírhatjuk a parancssorba, exportálhatjuk egy szöveges fájlba, rajzolhatunk belőlük új entitásokat (pl. köröket a vertexek helyére), vagy további számításokat végezhetünk velük (pl. hossz, terület).

Íme egy komplett példafüggvény, ami mindkét típust kezeli:

„`lisp
(defun C:GETPOLYVERTS (/ ent ent_data ent_type vertex_list cur_ent vertex_data)
(vl-load-com) ; VLAX függvények betöltése, ha szükséges
(princ „n”)
(setq ent (car (entsel „nVálassz ki egy polyline-t az összes vertex pontjának kiolvasásához: „)))

(if (and ent (setq ent_data (entget ent)))
(progn
(setq ent_type (cdr (assoc 0 ent_data)))
(setq vertex_list ‘())

(cond
((equal ent_type „LWPOLYLINE”)
(foreach item ent_data
(if (= (car item) 10)
(setq vertex_list (cons (cdr item) vertex_list))
)
)
(setq vertex_list (reverse vertex_list)) ; A pontok sorrendben legyenek
)
((equal ent_type „POLYLINE”)
(setq cur_ent (entnext ent))
(while (and cur_ent
(not (equal „SEQEND” (cdr (assoc 0 (entget cur_ent)))))
)
(setq vertex_data (entget cur_ent))
(if (= (cdr (assoc 0 vertex_data)) „VERTEX”)
(setq vertex_list (cons (cdr (assoc 10 vertex_data)) vertex_list))
)
(setq cur_ent (entnext cur_ent))
)
(setq vertex_list (reverse vertex_list))
)
(t (princ „nEz nem egy polyline entitás!”))
)

(if vertex_list
(progn
(princ „nA polyline összes vertex pontja (X Y Z formátumban):”)
(foreach vert vertex_list
(princ (strcat „n X: ” (rtos (car vert) 2 4)
„, Y: ” (rtos (cadr vert) 2 4)
(if (caddr vert) (strcat „, Z: ” (rtos (caddr vert) 2 4)) „”)
)
)
; Példa: Rajzoljunk köröket a vertex pontokba (opcionális)
; (command „._CIRCLE” vert „0.1”) ; 0.1 sugarú kör
)
(princ (strcat „nÖsszesen ” (itoa (length vertex_list)) ” vertex pont található.”))
)
(if (equal ent_type „LWPOLYLINE”) ; Ha LWPOLYLINE, de nincs vertex, akkor hiba van
(princ „nNincs vertex pont találva ebben az LWPOLYLINE-ban. Hiba lehet a geometriában.”)
)
)
)
(princ „nNincs kiválasztott entitás, vagy érvénytelen választás történt.”)
)
(princ) ; Tisztítja a parancssort
)
„`
Ezt a kódot bemásolva az AutoCAD parancssorába, vagy betöltve egy LISP fájlból (`(load „fajlneved.lsp”)`), majd a `GETPOLYVERTS` paranccsal elindítva, azonnal látni fogjuk az eredményt.

### Finomhangolás és Tippek

* **Hibaellenőrzés:** Mindig érdemes beépíteni hibaellenőrzést. Mi történik, ha a felhasználó nem polyline-t választ ki? Vagy ha semmit sem választ ki? A fenti kódban már beépítettem erre példákat. [ICON: ✅]
* **3D koordináták:** Az AutoCAD a 10-es kódhoz mindig három koordinátát (X Y Z) tárol, még 2D polyline esetén is, ahol a Z koordináta általában 0.0, vagy az entitás magassága. A kinyert pontok tehát 3D pontlisták lesznek.
* **Teljesítmény:** Nagyon nagy rajzok és extrém sok vertexet tartalmazó polylok esetén a fenti `(entget)` és `(entnext)` alapú megközelítés kissé lassú lehet. Ilyenkor érdemes megfontolni a `vlax-curve` függvények használatát, amelyek az ActiveX/COM API-n keresztül nyújtanak gyorsabb hozzáférést.
* `vlax-curve-getstartparam`, `vlax-curve-getendparam`: A görbe paramétertartományát adja meg.
* `vlax-curve-getpointatparam`: Egy adott paraméterértékhez tartozó pontot adja vissza.
* A `vlax-curve-getdistatparam` és `vlax-curve-getparamatdist` szintén hasznos lehet.
Ezek a függvények különösen akkor jönnek jól, ha nem csak a definiáló vertexeket, hanem a *görbén lévő, interpolált pontokat* is szeretnénk kinyerni, például egy íves szakasz esetében, ahol a 10-es kódok csak a vezérlőpontokat adják meg, de nem feltétlenül az ív minden egyes pontját. Viszont, ha az „összes vertex” a *definiáló pontokat* jelenti (amiket a tervező megadott), akkor az `(entget)` megközelítés a legegyértelműbb.

### Alkalmazási Területek és Személyes Tapasztalatok [ICON: 🎯]

Ez a fajta vertexkinyerési képesség nem csupán elméleti érdekesség. A gyakorlatban számos területen felbecsülhetetlen értékű:

* **Földmérés és Geodézia:** Terepmodellek létrehozásakor, szintvonalak digitalizálásakor vagy parcella határok elemzésekor létfontosságú az összes töréspont precíz ismerete.
* **Út- és Vasúttervezés:** A nyomvonalak, szegélyek és egyéb vonalas létesítmények geometriai adatai mind polyline-ok formájában vannak jelen, és ezekből kell kinyerni a kritikus pontokat további számításokhoz vagy kihelyezéshez.
* **CNC Megmunkálás:** Egy munkadarab kontúrja gyakran egy polyline. A megmunkáló gépeknek szükségük van a pontos koordinátákra, hogy a szerszám megfelelő úton mozogjon.
* **GIS Adatátalakítás:** AutoCAD adatok exportálásakor GIS (Geographic Information System) rendszerekbe, a pontosság kritikus. A polyline vertexek kinyerése segít a tiszta, konzisztens adatátvitelben.

Személyes tapasztalataim szerint az AutoLISP a mai napig az egyik leggyorsabb és legközvetlenebb módja az AutoCAD-en belüli adatok manipulálásának. Bár a .NET API szélesebb körű funkcionalitást kínál, és modern fejlesztési környezetben dolgozhatunk vele, az AutoLISP a maga egyszerűségével és a rajzadatbázishoz való direkt hozzáférésével gyakran veri a bonyolultabb megoldásokat, ha egy specifikus, rutinszerű feladatot kell elvégezni. Ez a „régi iskola” ereje abban rejlik, hogy pontosan azt csinálja, amire kitalálták, és azt hihetetlenül hatékonyan teszi.

### Összegzés és Előretekintés

Ahogy láthatjuk, egy polyline összes vertex pontjának kinyerése AutoCAD-ben AutoLISP segítségével nem ördöngösség, de igényel némi rálátást a DXF csoportkódokra és a polyline típusok közötti különbségekre. A fenti kódrészletek és magyarázatok remélhetőleg útmutatóul szolgálnak ahhoz, hogy hatékonyan automatizálhassa ezt a gyakori feladatot.

Az AutoLISP egy hatalmas tudásbázis, és a benne rejlő potenciál messze túlmutat ezen az egyetlen feladaton. Bátran merüljön el benne, kísérletezzen, és fedezze fel, milyen további módokon teheti még okosabbá és gyorsabbá a napi CAD munkáját. A pontosság és a hatékonyság kéz a kézben járnak, és az AutoLISP az egyik legjobb eszköz arra, hogy mindkettőből a legtöbbet hozza ki. A digitális tervezés jövője a precizitásban rejlik, és a polyline vertexek kezelése ennek alapköve.