| V I S U A L I Z Z A D I S C U S S I O N E |
| arri |
Inserito il - 27 ottobre 2009 : 10:01:00
http://klobouk.fsv.cvut.cz/~chour/Lisp/Contents.htm |
| 20 U L T I M E R I S P O S T E (in alto le più recenti) |
| arri |
Inserito il - 05 aprile 2016 : 10:18:23
http://forums.augi.com/forumdisplay.php?91-AutoLISP |
| arri |
Inserito il - 05 aprile 2016 : 09:59:30
http://www.autolisp.com/forum/autocad/autolisp |
| Marsetti Alex |
Inserito il - 08 maggio 2014 : 17:22:31
Buongiorno,
vorrei condividere anche questo link, in lingua inglese, reperito in internet. E' una raccolta di tutte le funzioni AutoLISP, VL e VLAX utilizzabili dalla versione AutoCAD 2000 in poi. Non sono raccolte le successive funzioni, ma potrebbe essere un buon manuale per cercare cosa fa e come funziona una funzione.
Il pdf è ordinato per ogni funzione.
Saluti, Marsetti Alex.
www.theswamp.org/lilly_pond/alanjt/AlispRef.pdf |
| arri |
Inserito il - 07 maggio 2014 : 13:09:49
Full AUTOCAD VL- Documentation
http://www.theswamp.org/~john/avlisp/ |
| arri |
Inserito il - 19 luglio 2013 : 10:42:02
Determine in which line of AutoLISP code an error exists
http://lee-mac.com/debugvlide.html |
| joseph |
Inserito il - 17 giugno 2013 : 23:41:40
Ho appena acquistato questo manuale:
AutoCAD expert's Visual LISP di Reinaldo Togores.
Lo sto ancora esaminando, qua e là, ma mi sto sempre più convincendo che sono 30€ ben spesi.
|
| arri |
Inserito il - 15 febbraio 2013 : 12:26:08
come creare un applicazione VLX |
| joseph |
Inserito il - 12 febbraio 2013 : 11:59:40
Da un altro punto di vista.
Immagine inserita:
49,16 KB |
| Terminator |
Inserito il - 12 febbraio 2013 : 10:03:11
Ti ringrazio per l'aiuto, qualche barlume di luce si comincia ad intravedere. Una cosa non mi è chiara però: dove memorizza i vari cons? E poi hai notato che in modalità step by step nell'editor VLisp quando la variabile lst va a nil, ricomincia il ciclo dal remove_doubles "centrale"? |
| joseph |
Inserito il - 12 febbraio 2013 : 00:22:50
Questo ti può chiarire qualche dubbio?
Immagine inserita:
70,67 KB
Ciao |
| Terminator |
Inserito il - 11 febbraio 2013 : 15:52:24
A proposito di recorsività, ho qui una funzione che per me rappresenta ancora un mistero il suo funzionamento e così altre funzioni simili:
(defun remove_doubles (lst)
(if lst
(cons (car lst)(remove_doubles (vl-remove (car lst) lst)))
)
)
E' una semplice funzione per l'eliminazione degli elementi doppi nelle liste, straordinaria e potente nella sua semplicità. Ho provato a verificarla step by step per capire il suo funzionamento ma ancora non ci sono venuto fuori. La lista in questione si riduce man mano che gli elementi scorrono e fin qui tutto bene. Ad un certo punto la funzione richiama se stessa e la lista si ricrea (!). Anch'io sono costretto a rivolgere domande di lisp...  |
| joseph |
Inserito il - 11 febbraio 2013 : 15:21:19
Non parlarmi di ricorsività: ogni volta parto dal fattoriale, faccio due tentativi con le funzioni e poi abbandono subito: non ho ancora trovato chi mi dia la chiave giusta per entrare in questo meccanismo: o forse è il mio cervello che non riesce ad astrarre più di tanto. |
| Terminator |
Inserito il - 11 febbraio 2013 : 09:31:32
Giusto un integrazione all'intervento di Joseph.
Ho scritto tempo fa queste due funzioni per la trasformazione di un variant in una lista e viceversa.
La funzione variant2lista usa le funzioni sublist, per costruire una sottolista partendo da un indice nella lista stessa e per una certa lunghezza e la funzione split-list (non opera mia) che sfrutta la recorsività, argomento che digerisco sempre con molta fatica, il mio punto debole.
;;; ***************************FUNZIONE VARIANT2LISTA*******************************
;;; Trasforma un variant in una lista a gruppi con numero elementi per gruppo
(defun variant2lista (listavariant numero / listaparz listafin)
(split-list (safearray-value (variant-value listavariant)) numero)
)
(defun sublist (lst start leng / n r)
(if (or (not leng) (< (- (length lst) start) leng))
(setq leng (- (length lst) start))
)
(setq n (+ start leng))
(repeat leng
(setq r (cons (nth (setq n (1- n)) lst) r))
)
)
(defun split-list (lst n)
(if lst
(cons (sublist lst 0 n)
(split-list (sublist lst n nil) n)
)
)
)
;;; ***************************FUNZIONE LISTA2VARIANT*******************************
;;; Trasforma una lista a gruppi in un variant
(defun lista2variant (listanormale / array)
(setq listanormale(apply 'append listanormale))
(setq array(vlax-make-safearray vlax-vbDouble (cons 0 (- (length listanormale) 1))))
(vlax-make-variant (vlax-safearray-fill array listanormale))
) |
| joseph |
Inserito il - 09 febbraio 2013 : 17:06:23
Vi allego 2 note sull'uso delle funzioni vla e vlax.
Potete caricarle direttamente nell'IDE di VisualLIsp
----
;;; Differenze di comportamento fra le funzioni VLAX... e VLA...
;;; Settaggi iniziali
(vl-load-com)
(setq acadObj (vlax-get-acad-object))
(setq docObj (vla-get-activedocument acadObj))
(setq MS (vla-get-modelspace docObj))
(setq PS (vla-get-paperspace docObj))
;;
;;; Esempio: lavorare su un BLOCCO
;;;
;;;Definizione dell'oggetto Blocco
(setq obj (car (entsel))) ;<Entity name: 7f734058bc0>
(setq obj (vlax-ename->vla-object obj)) ;#<VLA-OBJECT IAcadBlockReference 00000000428ab7e8>
;;; PROPRIETA'
;;; Per estrarre le PROPRIETA' ho a disposizione 3 modalità, che non sempre
;;; forniscono il risultato nella stessa forma.
;;;1^caso: il nome del layer di appartenenza del blocco:
(vlax-get-property obj "layer" ) ;--> "0" opp. (vlax-get-property obj 'layer)
(vla-get-layer obj) ;--> "0"
(vlax-get obj "layer ") ;--> "0"
;;; Tutte le modalità estraggono una stringa dello stesso valore.
;;;2^ caso: estrazione del punto di inserimento del blocco
(setq pt (vlax-get-property obj "InsertionPoint")) ;--> #<variant 8197 ...>
(setq pt (vla-get-InsertionPoint obj)) ;--> #<variant 8197 ...>
(setq pt (vlax-get obj "InsertionPoint")) ;--> (3211.7 1601.06 0.0)
;;; in questo caso le prime due forniscono un variant (un contenitore);
;;; occorre perciò trasformarlo in lista
(setq lst-pt (safearray-value (variant-value pt))) ;--> (3211.7 1601.06 0.0)
;;;naturalmente ottenendo lo stesso valore delle prime 2 modalità
;;; METODI
;;; Per estrarre un METODO ho sempre a disposizione 3 modalità che, come per le proprietà,
;;; non sempre forniscono il risultato nella stessa forma e in più richiedono i dati di ingresso
;;; sotto forme diverse.
;;; Esempio: lavorare su una POLILINEA per trasformarla un Regione
;;;
;;; Definizione dell'oggetto Polilinea
(setq pl (car (entsel))) ;<Entity name: <Entity name: 7f734058c10>
(setq pl-obj (vlax-ename->vla-object pl)) ;#<VLA-OBJECT IAcadLWPolyline 000000004285fdb8>
;;; La modalità <vlax-invoke> richiede in ingresso una lista e restituisce una lista, per cui semplicemente:
(vlax-invoke MS 'addRegion (list pl-obj)) ;--> (#<VLA-OBJECT IAcadRegion 000000002b63dba8>)
;;; Le modalità <vlax-invoke-method> e <vla-addRegion> richiedono invece in ingresso un array
;;; e restituiscono un variant, per cui occorre:
;;; trasformare la lista in array...
(setq pl-array (vlax-safearray-fill (vlax-make-safearray vlax-vbObject '(0 . 0)) (list pl-obj))) ;--> #<safearray...>
;;; applicare una delle due modalità
(setq pl-varn (vlax-invoke-method MS 'addRegion pl-array)) ;--> #<variant 8201 ...>
(setq pl-varn (vla-addRegion MS pl-array)) ;--> #<variant 8201 ...>
;;;... e infine trasformare il variant in oggetto
(setq pl-obj (safearray-value (variant-value pl-varn))) ;--> (#<VLA-OBJECT IAcadRegion 000000002b63bf78>)
;;; Esempio: lavorare su un insieme di 3 polilinee chiuse e 2 cerchi da trasformare in Regioni
;;; applicando il metodo addRegion.
;;;
;Creiamo una selezione di entità
(setq selez-ent (ssget "X" '((0 . "*polyline,circle")))) ;--><Selection set: 2eb9>
;trasformiamo la selezione in una lista di oggetti
(defun ss2lst (sel / i entNm lst)
(setq i -1)
(while (setq entNm (ssname sel (setq i (1+ i))))
(setq lst (cons (vlax-ename->vla-object entNm) lst))
)
) ;_end defun
(setq lst-obj (ss2lst selez-ent))
;;; (#<VLA-OBJECT IAcadLWPolyline 000000004285fdb8> #<VLA-OBJECT IAcadLWPolyline 000000002fedee88>
;;; #<VLA-OBJECT IAcadLWPolyline 000000002feddf88> #<VLA-OBJECT IAcadCircle 000000002feddb08> #<VLA-OBJECT IAcadCircle 000000002fedd748>)
;;;Applichiamo ora il metodo addRegion usando dapprima la 1^ modalità, che accetta in ingresso direttamente una lista di oggetti
(setq lst-reg (vlax-invoke MS 'addRegion lst-obj))
;;;(#<VLA-OBJECT IAcadRegion 000000002b63bc08> #<VLA-OBJECT IAcadRegion 000000002b63cb28>
;;; #<VLA-OBJECT IAcadRegion 000000002b63cff8> #<VLA-OBJECT IAcadRegion 000000002b63be18> #<VLA-OBJECT IAcadRegion 000000002b63b688>)
;;; Le altre due modalità vogliono invece in ingresso un Array, per cui occorre trasformare lst-obj in array...
(setq array-obj (vlax-safearray-fill (vlax-make-safearray vlax-vbObject '(0 . 4)) lst-obj)) ;--> #<safearray...>
;...poi applicare una delle due modalità....
(setq varn-obj (vlax-invoke-method MS 'addRegion array-obj)) ;--> #<variant 8201 ...>
(setq varn-obj (vla-addRegion MS array-obj)) ;--> #<variant 8201 ...>
;...e infine trasformare il variant in una lista di oggetti
(setq lst-reg (safearray-value (variant-value varn-obj)))
;;;(#<VLA-OBJECT IAcadRegion 000000002b63b738> #<VLA-OBJECT IAcadRegion 000000002b63b898>
;;;#<VLA-OBJECT IAcadRegion 000000002b63bd68> #<VLA-OBJECT IAcadRegion 000000002b63ab88> #<VLA-OBJECT IAcadRegion 000000002b63ac38>)
;;; Se ne deduce che la prima modalità è più veloce. |
| arri |
Inserito il - 27 novembre 2012 : 09:56:53
Visual Lisp Examples |
| arri |
Inserito il - 12 settembre 2012 : 12:30:32
linguaggio DCL |
| arri |
Inserito il - 10 maggio 2012 : 11:48:20
Messaggio inserito da arri
Autolisp reference in formato pdf
guida autolisp (il lingua italiana)
|
| arri |
Inserito il - 16 febbraio 2012 : 08:03:07
video
How to Use an AutoLisp Routine in AutoCAD |
| arri |
Inserito il - 01 giugno 2011 : 09:26:08
VisualLISP Books
AutoCADet's Guide to Visual LISP
VisualLISP Developers Bible
VisualLISP Developer's Guide
VisualLISP Tutorials
Autodesk VisualLISP Tutorial |
| arri |
Inserito il - 03 dicembre 2010 : 12:54:00
http://lee-mac.com/tutorials.html |
