ApplyCurvePiping

lo so che è da parecchio tempo che non posto domande
ma con questa recupero un pochino di domande strane :slight_smile:

sarebbe possibbile replicare il comando ApplyCurvePiping?

In Rhino Options alla voce aliases aggiungi un alias es. : ap = _ApplyCurvePiping

grazie Vittorio per la risposta,

a volte ho dato troppe info e non si capiva il senso
ma questa volta ho sintetizzato troppo la domanda
colpa mia, chiedo venia…

quello che intendevo era poter replicare il comando
_ApplyCurvePiping senza eseguire il comando stesso, quindi
eseguire vari comandi di rhino per ottenere lo stesso risultato.

dovrebbe essere possibile, credo o no?

Usi il comando forma tubolare e poi converti in mesh

se poi vuoi essere ancora più masochista usi :
cerchio verticale su curva e sweep a 1 binario. poi decidi se usare il _cap oppure posizioni due sfere in testa . Splitti le sfere e fai un join di tutto.

Comunque che senso ha fare tutto questo?
boh…

salve paolo e grazie per la risposta,



creare la forma tubolare non è un problema, è l’effetto nella
foto 2 che mi interessa, quando si cambia il “tipo di linea”
si adatta in automatico al tipo di linea che gli si imposta
se sposti i punti della curva segue senza registra storia
volevo capire quali sono i vari passaggi per ottenere ciò?

Ciao

non è molto difficile.

1 determini la lunghezza della curva = L;
2 determini il modulo del tratteggio (esempio 2 unità piene 2 vuota) e la lunghezza M;
3 determini la suddivisione ottimale in relazione a L / M e i rispettivi punti sulla curva dei tratti pieni;
4 crei i pipe.

Sergio

ciao Sergio grazie anche te per la risposta
non so se mi sono spiegato bene quello che intendo fare è ritrovarmi con tanti pipe senza dividere la curva, in pratica la suddivisione della curva in foto è fittizzia nel senso che cambiando il tipo di curva come nascosto tratteggiato etc i pipe si modificano di conseguenza ma la curva in realtà è sempre intera.
nelle impostazioni si può creare un tipo di curva personale con le lunghezze e spazi voluti e dopo aver eseguito il ApplyCurvePiping controllo se il risultato è quello con ExtractPipedCurve estraggo le mesh.

la questione è, come faccio a ritrovarmi “solo visivamente” i pipe suddivisi come il tipo di linea scelto?

Scusa Salvio, ma se ApplycurvePiping ti da quello che ti serve (risultato solamente visivo che si aggiorna con la modifica della curva generatrice) e l’ExtractPipedCurve ti genera le mesh per fare eventuali esportazioni o modifiche, te, cosa stai cercando?
Perchè non riesco a capirlo…
Non ti vanno bene le mesh e vuoi dei pipe Nurbs?
Non vuoi utilizzare ApplyCurvePiping perchè non riesci ad utilizzarlo negli script?
Devi modificare il tratteggio e non vuoi passare per gli stili di curva?
O stai cercando solo di farci tirare delle testate contro i piloni del ponte Morandi per velocizzare la demolizione?

PS: mi sono dimenticato di darti qualche soluzione:

  • Per avere una cosa dinamica, l’unica alternativa credo sia GH
  • Per ottenere i pipe nurbs da una curva tratteggiata, devi farti uno script che estrae le mesh, trova i punti di intersezione con la curva, dividi la curva per i punti e, un pezzo si e uno no, generi i pipe.
3 Mi Piace

ahahahah grande Lucio :slight_smile:
beh si in effetti il motivo è che avrei bisogno di fare la stessa cosa ma non con il pipe
e quindi mi interessava capire come con quel comando ci si è riusciti per poterlo replicare
(ovviamente nei limiti del possibile è sottointeso)

infatti l’ho già fatto tempo fa quando ancora non conoscevo il comando ApplyCurvePiping
solo che non capisco come fa a funzionare questo comando senza GH oppure senza
il “registra storia” attivato, com’è possibile che se sposto la linea originale si sposta la mesh,
o anche cambiando il tipo di linea si adatta ad esso?

leggendo ciò che hai scritto forse un punto di inizio l’ho trovato:
può darsi che il pipe viene suddiviso come tipo di linea essendo che si va a prendere le misure
direttamente nelle impostazioni unità > annotazioni > tipo di linea?
se quanto ipotizzato è valido rimane il fatto di come visualizzare le mesh senza averle fisicamente…

è lo so mai una volta che chiedo che ne so: “non trovo questo comando” :slight_smile:
però se è servito per farti postare sono contento essendo che ultimamente scrivi poco
e quindi colgo l’occasione per salutarti è un grazie a tutti :+1:

Aaannn… adesso ho capito… non credo ci sia alcuna possibilità se non l’intervento da parte di mcneel; l’applycurvepiping come lo shutlining sono delle features visive, non per la modellazione (un imbroglio solo per ottenere velocemente un effetto grafico senza appesantire il modello; infatti puoi solo estrarre le mesh di visualizzazione).

Hahaha, era un tranello allora! :joy:
Hai ragione che scrivo poco ultimamente, ma il tempo é poco e cerco di intervenire solo se la risposta non mi imbarca in discussioni chilometriche…
Un saluto a tutti anche da parte mia
Ps sto rispondendo dal cell… se ho dimenticato qualcosa aggiungo dopo dal pc… :wink:

Esattamente così.

Ciao

quel che desideri lo ottieni creando un plugin. Sostanzialmente devi programmare il DisplayPipeline. Se sai programmare in c++ puoi provare. Peraltro Dale ha condiviso in GitHub degli esempi (più semplici) da cui partire.

Sergio

Ciao Sergio

Scusa, parli del DisplayConduit ?
Cioe’ di usare il DisplayPipeline all’interno di un DisplayConduit ?

( Perche’ quello si puo’ fare anche in Python, che Salvio sicuramente conosce :slight_smile: )

Ciao Emilio

si, intendo proprio questo.

Sergio

Grazie per l’info, Sergio !

@0904 , se ti puo’ interessare, posto qui un vecchio script in cui avevo usato il DisplayConduit consigliato da Sergio.

(Come sempre) e’ una cosa scritta in fretta, senza commenti.
Poi anch’io ho poca esperienza col DisplayCoduit, quindi forse lo ho usato … alla buona, per cui …
Potrebbe anche essere un pessimo esempio … non so … :smile:

Non e’ uno script brevissimo … ma non ho trovato altro …

import Rhino
import scriptcontext
import System

def params():
  tolerance = 0.1
  wirecolor = System.Drawing.Color.FromArgb( 0, 255, 255 )
  textcolor = System.Drawing.Color.FromArgb( 0, 255, 0 )
  wirethickness = 4
  textpoint = Rhino.Geometry.Point2d( 200, 200 )
  textheight = 30
  figures = 1
  return ( 
      tolerance, wirecolor, textcolor, wirethickness, 
      textpoint, textheight, figures )

def getbb( plane, obrefs ):
  bigbox = Rhino.Geometry.BoundingBox.Empty
  for obref in obrefs:
    geom = obref.Geometry()
    box = geom.GetBoundingBox( plane )
    bigbox = Rhino.Geometry.BoundingBox.Union( bigbox, box )
  return bigbox

def getsizes( box ):
  pt = list( box.GetCorners() )
  res = []
  res.append( pt[ 0 ].DistanceTo( pt[ 1 ] ) )
  res.append( pt[ 0 ].DistanceTo( pt[ 3 ] ) )
  res.append( pt[ 0 ].DistanceTo( pt[ 4 ] ) )
  res.sort()
  return res

def getvolume( box ):
  p0 = box.Corner( True, True, True )
  p1 = box.Corner( False, True, True )
  p2 = box.Corner( True, False, True )
  p3 = box.Corner( True, True, False )
  vol = (
      p0.DistanceTo( p1 ) * p0.DistanceTo( p2 ) * p0.DistanceTo( p3 ) )
  return vol

def bblines( box, plane ):
  xform = Rhino.Geometry.Transform.PlaneToPlane( 
      Rhino.Geometry.Plane.WorldXY, plane )
  co = list( box.GetCorners() )
  lis = []
  lis.append( Rhino.Geometry.Line( co[ 0 ], co[ 1 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 1 ], co[ 2 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 2 ], co[ 3 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 3 ], co[ 0 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 4 ], co[ 5 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 5 ], co[ 6 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 6 ], co[ 7 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 7 ], co[ 4 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 0 ], co[ 4 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 1 ], co[ 5 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 2 ], co[ 6 ] ) )
  lis.append( Rhino.Geometry.Line( co[ 3 ], co[ 7 ] ) )
  [ li.Transform( xform ) for li in lis ]
  return lis

def surplane( su, tolr ):
  ok, pla = su.TryGetPlane( tolr )
  if ok:
    dm0 = su.Domain( 0 )
    dm1 = su.Domain( 1 )
    ok, pla = su.FrameAt( dm0.Mid, dm1.Mid )
    return pla
  ok, cyl = su.TryGetCylinder( tolr )
  if ok:
    cir = cyl.CircleAt( 0.0 )
    return cir.Plane
  ok, con = su.TryGetCone( tolr )
  if ok:
    return con.Plane
  dm0 = su.Domain( 0 )
  dm1 = su.Domain( 1 )
  ok, pla = su.FrameAt( dm0.Mid, dm1.Mid )
  if ok:
    return pla
  else:
    return None

def curplane( cu, tolr ):
  ok, pla = cu.TryGetPlane( tolr )
  if ok:
    return pla
  if cu.IsLinear( tolr ):
    dm = cu.Domain
    pla = Rhino.Geometry.Plane( cu.PointAtStart, cu.TangentAtStart )
    return pla
  else:
    return None

def split( su ):
  sp0 = list( su.GetSpanVector( 0 ) )
  sp1 = list( su.GetSpanVector( 1 ) )
  if len( sp0 ) == 3:
    return list( su.Split( 0, sp0[ 1 ] ) )
  elif len( sp0 ) > 3:
    su0, su1 = list( su.Split( 0, sp0[ 1 ] ) )
    return [ su0 ] + split( su1 )
  elif len( sp1 ) == 3:
    return list( su.Split( 1, sp1[ 1 ] ) )
  elif len( sp1 ) > 3:
    su0, su1 = list( su.Split( 1, sp1[ 1 ] ) )
    return [ su0 ] + split( su1 )
  else:
    return [ su ]

class conduit( Rhino.Display.DisplayConduit ):

  def __init__( self, colr, thik, tcolr, texp, thei, figs ):
    Rhino.Display.DisplayConduit.__init__( self )
    self.lins = []
    self.colr = colr
    self.thik = thik
    self.tcolr = tcolr
    self.tex = ''
    self.texp = texp
    self.thei = thei
    self.fmt = '%%.%df' % figs

  def addlins( self, lins ):
    self.lins.extend( lins )

  def setsize( self, s0, s1, s2 ):
    vol = s0 * s1 * s2
    format = '%s x %s x %s - volume: %s' % ( 
        self.fmt, self.fmt, self.fmt, self.fmt )
    self.tex = format % ( s0, s1, s2, vol )

  def clear( self ):
    self.lins = []
    self.tex = ''

  def pritex( self ):
    if self.tex:
      print( self.tex )

  def PostDrawObjects( self, eventargs ):
    for lin in self.lins:
      eventargs.Display.DrawLine( lin, self.colr, self.thik )
    if self.tex:
      eventargs.Display.Draw2dText( 
          self.tex, self.tcolr, self.texp, False, self.thei )
      
def main():
  tolr, colr, tcolr, thik, texp, thei, figs = params()
  con = conduit( colr, thik, tcolr, texp, thei, figs )
  con.Enabled = True
  while True:
 
    scriptcontext.escape_test()
    gob = Rhino.Input.Custom.GetObject()
    gob.SetCommandPrompt( '?' )
    gob.AcceptNothing( True )
    gob.Get()
    res = gob.Result()
    if res == Rhino.Input.GetResult.Cancel:
      con.Enabled = False
      return
    elif res == Rhino.Input.GetResult.Nothing:
      break
    elif res == Rhino.Input.GetResult.Object:
      obrefs = gob.Objects()   
      scriptcontext.doc.Objects.UnselectAll()

    scriptcontext.doc.Views.Redraw()
    minpla = Rhino.Geometry.Plane.WorldXY
    box = getbb( minpla, obrefs )
    minbox = box
    minvol = getvolume( minbox )
    for obref in obrefs:
      scriptcontext.escape_test()
      rep = obref.Brep()
      if rep:
        sucnt = 0
        sunum = rep.Faces.Count
        for ix in range( sunum ):
          sucnt += 1
          if ( sucnt % 100 ) == 0:
            pro = '%d / %d' % ( sucnt, sunum )
            Rhino.RhinoApp.SetCommandPrompt( pro )
          scriptcontext.escape_test()
          sur = rep.Faces[ ix ]
          sus = split( sur.DuplicateSurface() )
          for su in sus:
            pla = surplane( su, tolr )
            if pla:
              box = getbb( pla, obrefs )
              vol = getvolume( box )
              if vol < minvol:
                minbox = box
                minvol = vol
                minpla = pla
          bre = sur.DuplicateFace( False )
          cus = list( bre.DuplicateEdgeCurves() )
          for cu in cus:
            pla = curplane( cu, tolr )
            if pla:
              box = getbb( pla, obrefs )
              vol = getvolume( box )
              if vol < minvol:
                minbox = box
                minvol = vol
                minpla = pla
      cur = obref.Curve()
      if cur:
        flags = Rhino.Geometry.CurveSimplifyOptions.All
        angtol = scriptcontext.doc.ModelAngleToleranceRadians
        ncu = cur.Simplify( flags, tolr, angtol )
        if ncu:
          cus = list( ncu.DuplicateSegments() )
          for cu in cus:
            pla = curplane( cu, tolr )
            if pla:
              box = getbb( pla, obrefs )
              vol = getvolume( box )
              if vol < minvol:
                minbox = box
                minvol = vol
                minpla = pla
    s0, s1, s2 = getsizes( minbox )
    con.clear()
    con.setsize( s0, s1, s2 )
    lins = bblines( minbox, minpla )
    con.addlins( lins )
    scriptcontext.doc.Views.Redraw()
    con.pritex()
  con.Enabled = False
  scriptcontext.doc.Views.Redraw()

main()

Per la cronaca, lo script serve per cercare le dimensioni di pezzi tipo questo:

guessbb

Cioe’ profilati per carpenteria con orientamento variabile.

Lo script si limita a mostare temporaneamente una bounding box e le relative misure,
cercando, quando ci riesce, di orientare la box secondo l’orientamento del pezzo.

Ciao

1 Mi Piace

grazie a tutti per i vari suggerimenti, vedrò di analizzare tutti gli elementi dati

per lo meno adesso con “DisplayPipeline” c’è un punto di partenza :+1:

1 Mi Piace

ciao Emilio, e grazie per lo script
in pratica serve a creare un BoundingBox con le misure giusto?

Ciao Salvio !

Lo script cerca di ricavare le dimensioni del pezzo selezionato.
Come accennavo, e’ fatto per essere usato su pezzi di profilato, piastre (possibilmante rettangolari), pezzi di tubo tondo … cose del genere con forme molto ‘regolari’.

Per ottenere le misure, lo script cerca una bounding box (la piu’ piccola che trova) che sia ‘allineata’ in qualche modo a una delle superfici che costituiscono il pezzo.

Il DisplayConduit serve appunto per mostare le dimensioni della box trovata,e anche per mostare la box in modo da capire se le misure ottenute corrispondono a quelle del pezzo oppure no.

E’ uno dei casi in cui il conduit puo’ essere utile, cioe’ quando vuoi solo mostare temporaneamente della geometria senza aggiungere niente al documento 3dm.
Quando disabiilti il conduit, sparisce tutto, e non c’e’ niente da cancellare. :slight_smile:
Il tutto e’ anche molto piu’ veloce rispetto a disegnare, spostare e cancellare oggetti geometrici salvati nel documento.

Bravo Emilio

script interessante. Quello che intendo è una cosa molto prossima alla tua soluzione. Si tratterebbe di creare un comando che “risiede costantemente in memoria” e che, associato ad una lista, disegna a video entità non residenti all’interno del documento. Penso sia un processo similare a quello adottato per i blocchi …

Ciao!

Sergio

Ciao Sergio.

Grazie per la spiegazione !
… Anche se … indovina … non ci ho capito gran che … :confused:

Stai parlando di replicare ApplyCurvePiping ? :slight_smile:

( Tra l’altro e’ un comando che non conosco … finora non mi e’ capitato di usarlo … )