c.aの装甲針を引用します。

[Betoniera]

nota di gestione: questa discussione origina da un altro thread, questo, attinente la determinazione del senso orario o antiorario di una polilinea. l'argomento è stato all'origine dello sviluppo poi del lisp oggetto di questo thread.

il senso orario/orario ha senso solamente sulle polilinee chiuse. che senso potresti dare ad una polilinea aperta? per queste basta il comando inverti. al limite posso togliere dalla selezione tutte le polilinee aperte...

innanzi tutto grazie per la risposta (oltretutto rapidissima).
ti spiego meglio il problema, così magari mi dai qualche dritta.
ho sviluppato una serie di programmi lisp per disegnare il cemento armato.
in particolare i ferri, li disegno come poliliee, sempre aperte.
il disegno dei ferri è libero, pertanto ho delle poliline orarie e altre antiorarie.
quando quoto le poliline succede questo:



come vedi la quotature della prima staffa non è accettabile perchè le lunghezze dei segmanti si sovrappongono.
per ovviare all'inconveniente, ho scritto 2 programmi lisp, uno per quotare le polinee in senso orario e uno per quotarle in senso antiorario.
il problema è che, non conoscendo il senso della polinea, devo andare a tentativi, cioè:
- provare a quotare col porgramma quotapolineaoraria. se questo non è accettabile devo:
- cancellare le quote fatte e ripetere l'operazione col programma quotapolinieaantioraria.
ovviamente se io conosco prima come è stata disegnata la plilinea, allora da programma faccio partire la quotatura giusta.
in pratica riunisco i due programmi e non ci sarebbe possibilità di errore perchè la gestione è affidata al programma.
ci tengo a perfezionare quel programma perchè, ovviamente col mio mestiere (ingegnere strutturista) è molto usato.
ciao e grazie per l'eventuale risposta.

 

[confutatis]

uhm...come ti dicevo, più di orario/antiorario bisogna parlare di inverti/non inverti. in ogni caso il programma che ho scritto direi che ti serve a poco, secondo me non è l'applicazione giusta per la tipologia di lavoro che devi svolgere. piuttosto, se posso dare un suggerimento e dal momento che conosci il lisp, potresti creare un programma unico tipo quotapolinea. all'interno di questo programma ci saranno i due sottoprogrammi: quotapolineaoraria e quotapolineaantioraria.

ti faccio un banale schema:

partenza quotapolinea
partenza quotapolineaoraria come subroutine e disegno delle quote. alla fine prompt di richiesta: va bene? (s/n)
se rispondi s, il programma esce, se rispondi n, cancellazione quote disegnate, partenza di quotapolineaantioraria, disegno delle quote e questa volta senza prompt di conferma.

che ne dici? e' la prima cosa che mi è venuta in mente...

 

[Betoniera]

sì potrebbe andare.
potrei fare il test alla fine bene (/n). oltretutto con di default.
secondo te se la risposta dovesse essere n, che comando potrei utlizzare per ritornare alla posizione voluta.
1) potrei utilizzare il comando undo (esiste in lisp?) n vole indietro pari al numero di segmenti della polilinea (è un dato che ho).
2) in alternativa è possibile fissare un punto del programma (prima della quotatura della polilinea) e poi da programma ritornare indietro a quel punto?.
farò degli esperimenti.
mi fa piacere parlare con un espserto di lisp. mi sono sempre arrangiato da solo a fare i programmi (da molti anni). se avessi avuto la possibilità di scambiare opinioni con qualcuno sarebbe stato molto più facile. in ogni modo, mi sono fatto, negli anni, degli ottimi applicativi per la gestione dei cementi armati.

ciao, e se hai quache suggerimento, ben venga.

 

[confutatis]

non occorre sapere di quanti segmenti devi tornare indietro, ti basta usare la combinazione _undo _begin e _undo _end oppure, se usi anche vlisp, le funzioni vla-startundomark e vla-endundomark.

forse lo sai già, ma prima della richiesta se va bene inserisci (initget "s n"), in questo modo accetterà solo le risposte s o n:

(initget "s n")
(setq risp(strcase (getkword "\nva bene? (s/n)")))

in questo modo, anche se inserisco la minuscola, mi viene convertita in maiuscola.

 

[GP.]

...quache suggerimento, ben venga.

come giustamente detto da confutatis non ha senso parlare di orario/antiorario in poly aperte, visto che però già disponi delle routine per la quotatura valuta questa soluzione che può risolvere il tuo caso partendo dal concetto interno/esterno.

pseudocodice:
- calcolo del punto di selezione sulla poly
- calcolo del vertice della poly immediatamente prima del punto di selezione e dei due successivi
- calcolo di un punto immediatamente alla destra del punto di selezione
- verifica se quest'ultimo risulta all'interno o all'esterno del triangolo composto dai tre vertici precedenti
- se risulta all'interno il verso è orario, altrimenti antiorario.

la routine, adattata e inserita all'inizio, permette quindi di sapere quale delle tue lanciare.
visto che per il calcolo necessitano i due vertici successivi al punto di selezione, prestare attenzione a non selezionare la poly nel suo tratto finale.

(defun c:test ( / pl psel p1 n_par v1 v2 v3 pt l_v)
    (setq pl (entsel "selezionare la staffa"))
    (setq psel (cadr pl))
    (setq pl (car pl))
    (setq p1 (vlax-curve-getclosestpointto (vlax-ename->vla-object pl) psel t))
    (setq n_par (fix (vlax-curve-getparamatpoint pl p1)))
    (setq v1 (vlax-curve-getpointatparam pl n_par))
    (setq v2 (vlax-curve-getpointatparam pl (1+ n_par)))
    (setq v3 (vlax-curve-getpointatparam pl (+ 2 n_par)))
    (setq pt (polar p1 (- (angle v1 v2) (/ pi 2)) 0.001))
    (setq l_v (list v1 v2 v3 v1))
    (if (punto_interno l_v pt) (alert "orario") (alert "antiorario"))
)
    
;-------------------------------------------------------
(defun punto_interno (*lp* *p* / p_lontano attr p# pa pb )
    (setq p_lontano (list (car (setq em (getvar 'extmax))) (1+ (cadr em))))
    (setq attr 0)
    (repeat (1- (length *lp*))
        (setq pa (car *lp*))
        (setq pb (cadr *lp*))
        (setq p# (inters pa pb *p* p_lontano))
        (if (/= p# nil) (setq attr (1+ attr)))
        (setq *lp* (cdr *lp*))     
    )
    (if (> (rem attr 2) 0) t nil)
)
;-------------------------------------------------------
(vl-load-com)

 

[confutatis]

dal momento che bisogna prestare attenzione a non selezionare la polilinea nel tratto finale, siamo al punto di partenza di non conoscere il verso.

 

[Joseph]

come vedi la quotature della prima staffa non è accettabile perchè le lunghezze dei segmanti si sovrappongono.

quindi significa che nella seconda staffa accetti come valide delle quote capovolte? questo dipende forse dal fatto che riorienti ogni volta l'asse x dell'ucs sul lato della staffa che stai quotando?

 

[GP.]

dal momento che bisogna prestare attenzione a non selezionare la polilinea nel tratto finale, siamo al punto di partenza di non conoscere il verso.

no... intendevo il primo o l'ultimo segmento, per il motivo che ho esposto.
cliccando sull'immagine viene visualizzata una verifica del test.

 

[confutatis]

usando una polilinea qualsiasi, a seconda del segmento cliccato, mi dà orario e/o antiorario...:frown:

 

[GP.]

il codice è pensato per staffe simili a quelle postate da betoniera, ovvero rettangolari, triangolari o comunque di forma convessa.
se vai un po' a destra e un po' a sinistra non funge. :smile:

 

[confutatis]

ahi, ahi, signor gp, lei mi casca sulla staffa! :tongue:

 

[Betoniera]

ciao confutatis, ciao gp.
grazie dei suggerimenti.
ho sistemato il programma come suggerito da confutatis e funziona già.
ho unito i 2 programmi in uno, per cui è il programma finale ha una duplicazione quasi identica di istruzioni. non è proprio il massimo come programmazione però funziona. più avanti magari cercherò di razionalizzarlo.
per tornare indietro dopo la prima quotatura di tentativo ho usato le istruzioni "annulla segno" e "annulla indietro" di autocad.
funzionano bene.
ho ancora qualche piccola cosa da mettere a posto, ma il progrmma è già operativo.
grazie dell'aiuto, alla prossima.

 

[confutatis]

piccola variazione al lisp di gp.
adesso posso anche cliccare sugli estremi della polilinea, viene sempre preso per la selezione il punto centrale. il comando non funziona sulle polilinee che hanno solo 2 vertici.

(defun c:teston ( / pl psel p1 n_par v1 v2 v3 pt l_v)
    (setq pl (car (entsel "selezionare la staffa")))
    (setq p1 (vlax-curve-getpointatdist (vlax-ename->vla-object pl) (/ (vla-get-length (vlax-ename->vla-object pl)) 2))) 
    (setq n_par (fix (vlax-curve-getparamatpoint pl p1)))
    (setq v1 (vlax-curve-getpointatparam pl n_par))
    (setq v2 (vlax-curve-getpointatparam pl (1+ n_par)))
    (setq v3 (vlax-curve-getpointatparam pl (+ 2 n_par)))
    (setq pt (polar p1 (- (angle v1 v2) (/ pi 2)) 0.001))
    (setq l_v (list v1 v2 v3 v1))
    (if (punto_interno l_v pt) (alert "orario") (alert "antiorario"))
)
    
;-------------------------------------------------------
(defun punto_interno (*lp* *p* / p_lontano attr p# pa pb )
    (setq p_lontano (list (car (setq em (getvar 'extmax))) (1+ (cadr em))))
    (setq attr 0)
    (repeat (1- (length *lp*))
        (setq pa (car *lp*))
        (setq pb (cadr *lp*))
        (setq p# (inters pa pb *p* p_lontano))
        (if (/= p# nil) (setq attr (1+ attr)))
        (setq *lp* (cdr *lp*))     
    )
    (if (> (rem attr 2) 0) t nil)
)
;-------------------------------------------------------
(vl-load-com)

 

[Betoniera]

e' interessante questo spezzone di lisp.
provo a fare degli esperimenti.
se funziona, è preferibile rispetto alla soluzione di prima perchè il controllo della poliliea destrorsa o sinistrorsa verrebbe fatto da programma.
inoltre i due programmi separati più semplici e gestibili rispetto al programma unico, più lungo e complicato.
il problema della polilina formata da un solo segmento non c'è perchè la quotatura è unica e non si può sovrapporre a nessun altro testo.
vi farò sapere se la soluzione escogiata da gp funziona.

ciao, ci risentiamo

 

[Betoniera]

ciao gp
avrei voluto complimentarti con te per il codice così compatto e pieno di comandi che non conosco e di cui, per la verità non ben capito l'algoritmo di soluzione
purtroppo le prove affettuate danno esito negativo nel senso che il codice a volte funziona, a volte no, a volte da risultati errati.
quindi, semmai c'è una competizione tra te e cofutatis, stavolta gliela diamo vinta a confutatis (ci rifaremo la prossima volta).
poi, siccome nel forum bisogna pur condividere qualcosa, trasmetto il mio lavoro nel file qpoly2.lsp
se lo guardate non inorridite perchè per brevità ho sommato due programmi, quindi il listato è lungo e ripetitivo.
ma chissenefrega perchè l'importante è che funzioni.
per gli utenti informo che io non utlizzo la funzione defun c:, ma preferisco caricarlo da programma associato ad un tasto.
quindi utlizzare (load "qpoly2").
dopo la quotatura della polilinea il progrmma si ferma e chiede conferma. premento return completa la scritta posizionabile a piacere con l'inclinazione a piacere
(vedi esempio sotto).
se si preme n (no) le quotature spariscono e la polilinea vine riquotata con testo all'esterno.
l'altezza del testo è di 2 mm assoluti, cioè moltiplicato per il valore della varibile dimscale
quello stto è un esempio di sezione 1/20 con la staffa in alto con la quotatura sospesa ina ttesa di ok. a destra la quotatura rettificata
ciao, alla prossima

 

[confutatis]

programma interessante e stimolante.
pensandoci bene e ragionando, ho visto che la conformazione delle staffe deve seguire una certa logica e cioè, seguendo progressivamente i vertici, gli angoli della polilinea devono sempre essere minori di 180 gradi. con questo presupposto ho seguito una strada diversa da quella percorsa da gp e cioè il controllo degli angoli della staffa. se tutti gli angoli sono maggiori di 180 gradi, uso la funzione di inversione dei vertici della polilinea, creata tempo fa. le ultime versioni di autocad prevedono il comando apposito inverti, ma il programma funziona su tutte le versioni. in questo modo non occorre più la richiesta se i testi vanno bene o meno.
dal momento che il programma ha il defun e per quanto attiene al pulsante potresti cambiare la stringa così:
^c^c(if (null c:qpoly3)(load "qpoly3"));qpoly3

 

[Betoniera]

ciao confutatis
ma chi sei: il mago lisp?
hai deciso di stracciarci?
ti ringrazio davvero per il tempo che mi stai dedicando.
però ho provato il programma ma mi dà il seguente errore

; errore: no function definition: listacoord

eppure la funzione è dentro. sarà la solita parentesi non al posto giusto

ti confesso che 1/3 delle istruzioni che usi non le ho mai viste.
ma dove lo hai studiato il lisp così, alla cambridge university?
me lo sistemi il programma che sono curioso di provarlo?.
ciao e grazie

 

[confutatis]

alla riga 70 manca la parentesi che chiude il princ...bah, o mi dimentico il vl-load-com o le parentesi...

 

[GP.]

programma interessante e stimolante...

quoto, anche perchè ne prevedo il possibile utilizzo.

io rimango comunque sul concetto di interno/esterno per il riposizionamento dei testi, nel lisp allegato questi sono vere "quote", ciò ha i suoi vantaggi:
- orientamento dei testi sempre consono allo standard
- aggiornamento automatico in caso di stiramento

per quest'ultimo aspetto ho previsto anche l'aggiornamento automatico della lunghezza della poly inserendo il valore in un campodati, ma con lo spostamento nel codice di qualche puntoevirgola si può utilizzare un testo semplice.

in teoria dovrebbe funzionare con qualunque tipo di stile di quota in quanto i valori vengono adattati, unico aspetto: lo stile deve prevedere il posizionamento dei testi sopra o sotto la linea di quota.

direi che è una versione "quasi" beta, in quanto (per ora) è previsto il funzionamento per disegno in metri e quote in cm.

vedremo gli sviluppi...

 

[confutatis]

in effetti la quota senza linee di quota e linee di estensione diventa in tutto e per tutto uguale al programma originario di betoniera, strano che non abbia previsto l'utilizzo delle quote invece del testo, forse è una sua esigenza, boh...