Buongiorno, non so se la questione sia stata già dibattuta, ma credo valga la pena di parlarne.
A volte devo gestire o stampare delle messe in tavola provenienti da altri sistemi. Si tratta di semplici curve anche se in quantità, ma è tutto di una lentezza esasperante, sia nel selezionare delle parti che zoomare o altro. Il file con tre tavole del peso di c.ca 20 mb, sembra un file 3D da 600/800 mb.
Ho io qualche impostazione strana attivata o succede a tutti ed è una caratteristica di Rhino?
ciao Paolo,
ebbene si, è un problema che anche io ho riportato qualche tempo fa… la gestione di file 2d con molte entità a volte compromette la velocità di rhino quasi a paralizzarlo a volte…
inutile dire che moltissimo è causato dal file che ti capita… migliaia di piccole curve spesso duplicate messe alla c… qua e la
dovuto forse al modo di lavorare di altri che importano assiemi e schemi da chissà dove e spesso abusano del copia/incolla (tipo raptus schizzofrenico per intenderci) e creano il danno che poi ti becchi tu da gestire…
di fatto credo che altri programmi tipo il classico autocad siano più in grado di gestire queste situazioni mentre altri (tra cui rhino) no, ma giustamente perchè non sono nati prettamente per questo…
il suggerimento che ti posso dare è il seguente, prenditi tempo e copia porzioni del file in una copia di rhino aperta in parallelo e li pulisci il pulibile (seleziona oggetti duplicati… cancella il superfluo… seleziona curve corte tipo sotto il mm e credimi è imbarazzante scoprire quanta merda la gente tenga nei file di lavoro…) così poco alla volta ricomponi il file iniziale ma scoprirai che il più delle volte dopo questo passaggio il tutto torna ad essere gestibile.
ciao
Hai perfettamente ragione Illo, ma concorderai anche sul fatto che il più delle volte non si dispone di tempo per queste opere di pulizia in quanto devi velocemente valutare il materiale ricevuto con gente che ti sta col fiato sul collo…
Ci sono strumenti tipo il Curve Boolean e lo Sel Short Curves che sono strumenti potentissimi per poter risolvere situazioni da panico.
Altra cosa che puoi fare per velocizzare è disabilitare antialiasing per le curve e nascondere le porzioni di progetto non necessarie.
Come suggerito da Giuseppe qualche giorno fa, c’è la possibilità di attivare anche i filtri di selezione in base alla tipologia di entità per consentirti di selezionare a finestra solo quello che ti serve e nascondere il superfluo (li trovi nella barra di stato in basso di fianco a “Record History”).
Ti allego anche uno script fatto da Mitch per la selezione di curve che si sovrappongono (utile da utilizzare quando i duplicati non sono completamente sovrapposti e, quindi, SelDup non riesce ad individuarli)
Eh si’, troppe curve mettono in crisi la bestia …
In McNeel lo sanno e ci stanno lavorando:
Per ora, come dice Lucio, anch’io cerco di nascondere tutto il possibile in questi casi,
magari usando i layer per accendere e spegnere le curve velocemente.
… E anche di cancellare (ma questo piu’ per ragioni di peso file) quello che non e’ necessario,
ad esempio curve molto corte, se possibile.
… A meno di avere il tempo di revisionare il tutto, come dice Marco, che con Rhino e’ sempre la cosa migliore.
Peccato che capiti di rado ( di avere il tempo … )
… A questo proposito, se vuoi provare uno script che seleziona direttamente se curve sovrapposte ad un’altra curva …
Ho provato a modificare uno script che avevo.
Se vuoi provarlo … a prima vista sembra che funzioni abbastanza, anche se lascia indietro qualche curva, ma ho fatto solo una prova su curve molto semplici …
( OCCHIO ! Non e’ testato come si deve ecc. ecc.
USARE A PROPRIO RISCHIO E PERICOLO )
import scriptcontext
import rhinoscriptsyntax as rs
import Rhino
def getdocdata( key, defval ):
val = Rhino.RhinoDoc.ActiveDoc.Strings.GetValue( key )
if not val:
val = defval
return val
def setdocdata( key, val ):
if val:
Rhino.RhinoDoc.ActiveDoc.Strings.SetString( key, str( val ) )
else:
Rhino.RhinoDoc.ActiveDoc.Strings.Delete( key )
def curoncur( cu, ref, tolr, step ):
'''
if a curve lays over a reference curve
'''
pt = rs.CurveMidPoint( cu )
uu = rs.CurveClosestPoint( ref, pt )
if not uu:
return False
pcu = rs.EvaluateCurve( ref, uu )
if pt.DistanceTo( pcu ) > tolr:
return False
le = rs.CurveLength( cu )
cnt = int( le / step ) + 1
pts = rs.DivideCurve( cu, cnt )
for pt in pts:
uu = rs.CurveClosestPoint( ref, pt )
if not uu:
return False
pcu = rs.EvaluateCurve( ref, uu )
if pt.DistanceTo( pcu ) > tolr:
return False
return True
def main():
tolr = float( getdocdata( 'selovlappingcus-tolr',
str( Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance * 10 ) ) )
step = float( getdocdata( 'selovlappingcus-step', '1.0' ) )
while True:
gob = Rhino.Input.Custom.GetObject()
gob.AcceptNothing( True )
gob.SetCommandPrompt( 'Curves to check for overlapping ?' )
gob.GeometryFilter = Rhino.DocObjects.ObjectType.Curve
tolrind, tolropt = gob.AddOptionDouble( 'Tolerance',
Rhino.Input.Custom.OptionDouble( tolr ) )
stepind, stepopt = gob.AddOptionDouble( 'CheckStep',
Rhino.Input.Custom.OptionDouble( step ) )
gob.GetMultiple( 0, 0 )
res = gob.Result()
if res == Rhino.Input.GetResult.Option:
opind = gob.OptionIndex()
if opind == tolrind:
tolr = abs( tolropt.CurrentValue )
elif opind == stepind:
step = abs( stepopt.CurrentValue )
elif res == Rhino.Input.GetResult.Object:
obrefs = gob.Objects()
break
else:
return
setdocdata( 'selovlappingcus-tolr', tolr )
setdocdata( 'selovlappingcus-step', step )
select = []
cnt = 0
sel = 0
tot = len( obrefs )
for ref0 in obrefs:
cnt += 1
if ( cnt % 100 ) == 0:
print( 'Checked %d / %d -> %d Overlapping' % ( cnt, tot, sel ) )
scriptcontext.escape_test()
for ref1 in obrefs:
if ref0 != ref1:
if curoncur( ref1.Curve(), ref0.Curve(), tolr, step ):
select.append( ref1 )
sel += 1
scriptcontext.doc.Objects.UnselectAll()
for ref in select:
scriptcontext.doc.Objects.Select( ref, True )
print( 'Found %s overlapping curves from %s curves' %
( len( select ), len( obrefs ) ) )
main()
Ho provato con Rhino 6 e siamo su un altro pianeta. Gestisce molto meglio e più velocemente il 2D.
In effetti il problema non erano tanto le linee sovrapposte, quanto la quantità di linee in una messa in tavola di un progetto architettonico.
)
