def ngons(args): nn, length, lvariation, kk, radtolen, mngon, depth, radchng = args stpnt = ghc.EndPoints(nn)[0] #returns list of two points, start and end endpnt = ghc.EndPoints(nn)[1] pln = ghc.PlaneNormal(stpnt, nn) #returns a plane perp to a vector radius = length * (radchng**kk) / radtolen radiusend = length * (radchng**(kk + 1)) / radtolen #reduce details with each branch, but not less than 3 if mngon - kk + 1 <= 3: splits = 3 else: splits = mngon - kk + 1 pgn = ghc.Polygon(pln, radius, splits, 0)[0] #returns a polygon and its perimeter if kk == depth and splits == 3: geo = ghc.ExtrudePoint(pgn, endpnt) #if last branch than make a pyramid else: geostraight = ghc.Extrude(pgn, nn) #extrudes the polygon along vector geo = ghc.Taper( geostraight, nn, radius, radiusend, False, False, False ) #inputs: geometry, axis, start radius, end radius, flat (False), infinite (False), rigid (False) return ghc.CapHoles(geo) #caps ends on the extruded brep
def ngons(args): nn, length, lvariation, kk, radtolen, mngon, depth, radchng = args stpnt = ghc.EndPoints(nn)[0] #returns list of two points, start and end endpnt = ghc.EndPoints(nn)[1] vect = ghc.Vector2Pt(stpnt, endpnt, False)[0] #returns list with vector and vector length pln = ghc.PlaneNormal(stpnt, vect) #returns a plane perp to a vector radius = length * (radchng**kk) / radtolen #reduce details with each branch, but not less than 3 if mngon - kk + 1 <= 3: splits = 3 else: splits = mngon - kk + 1 pgn = ghc.Polygon(pln, radius, splits, 0)[0] #returns a polygon and its perimeter if kk == depth and splits == 3: geo = ghc.ExtrudePoint(pgn, endpnt) #if last branch than make a pyramid else: geo = ghc.Extrude(pgn, vect) #extrudes the polygon along vector return ghc.CapHoles(geo) #caps ends on the extruded brep
def depth(self): '''Used for non-res lighting evaluation. The room depth(m) from the main window wall ''' if self._depth: return self._depth worldXplane = ghc.XYPlane( Rhino.Geometry.Point3d(0,0,0) ) # Find the 'short' edge and the 'long' egde of the srfc geometry srfcEdges = ghc.DeconstructBrep(self.surface).edges segLengths = ghc.SegmentLengths(srfcEdges).longest_length srfcEdges_sorted = ghc.SortList(segLengths, srfcEdges).values_a endPoints = ghc.EndPoints(srfcEdges_sorted[-1]) longEdgeVector = ghc.Vector2Pt(endPoints.start, endPoints.end, False).vector shortEdgeVector = ghc.Rotate(longEdgeVector, ghc.Radians(90), worldXplane).geometry # Use the edges to find the orientation and dimensions of the room srfcAligedPlane = ghc.ConstructPlane(ghc.Area(self.surface).centroid, longEdgeVector, shortEdgeVector) srfcAlignedWorld = ghc.Orient(self.surface, srfcAligedPlane, worldXplane).geometry dims = ghc.BoxProperties( srfcAlignedWorld ).diagonal dims = [dims.X, dims.Y] width = min(dims) depth = max(dims) return depth
def RunScript(self, AS, CL): # Initialize outputs S = [] TS = CL W = [] CS = [] # Set defaults if no values are provided D = 1000 # Iterate over each test segment for seg in CL: # Extend line to threshold width midpt, TT, t = ghc.EvaluateLength(seg, 0.5, True) SS, E = ghc.EndPoints(seg) V, L = ghc.Vector2Pt(midpt, SS, False) vect = ghc.Amplitude(V, D/2) G1, X = ghc.Move(midpt, vect) G2, X = ghc.Move(midpt, -vect) test_line = ghc.Line(G1, G2) # Rotate test line 90 degrees test_line, X = ghc.Rotate(test_line, math.pi/2, midpt) # Check for intersection srf_intersection = checkIntersection(test_line, AS, midpt, D) # Store results CS.append(srf_intersection) W.append(ghc.Length(srf_intersection)) # Return outputs return TS, W, CS
def nextPt(pt, surface, DistanceFactor): boolean, u, v = Surface.ClosestPoint(pt) norm = Surface.NormalAt(u, v) unitNormLine = gh.LineSDL(pt, norm, DistanceFactor) ptToProject = gh.EndPoints(unitNormLine) ProjectedPt = gh.ProjectPoint(ptToProject, -gh.UnitZ(), Surface)[0] return ProjectedPt
def estendeFG(linha,corda,ponto): linnha = rs.coerceline(linha) ponto = rs.coerce3dpoint(ponto) if not gh.CurveXCurve(linha,corda)[0]: pt =gh.EndPoints(linha)[0] construc_aux.append(Line(pt,ponto)) return True else: return False
__author__ = "Bruger" __version__ = "2020.05.25" import rhinoscriptsyntax as rs import Rhino.Geometry as rg import ghpythonlib.components as gh tagList = list() pointList = list() i = 0 for line in listOfLines: endPoints = gh.EndPoints(line) start = endPoints[0] end = endPoints[1] coorsStart = gh.Deconstruct(start) coorsEnd = gh.Deconstruct(end) "nota, z y x puede que esten invertidos" xcomp = [coorsStart[0], coorsEnd[0]] ycomp = [coorsStart[1], coorsEnd[1]] zcomp = [coorsStart[2], coorsEnd[2]] xcomp.sort() ycomp.sort()
def distParalela(reta1,reta2): pt1 = gh.EndPoints(reta1)[0] pt2 = reta2.ClosestPoint(pt1,False) return gh.Length(Line(pt1,pt2))
def estendeCorda(linha,ponto,indice): pto1 = gh.EndPoints(linha)[indice] return Line(pto1,ponto)
# lista com as forças limites para banzos e diagonais F_adm = [(x * T_adm) / coe_Trac for x in Areas[0]] #Separando os eixos em listas #conector Conector = Eixos[-2:] #vigas v1 = Eixos[:3] v2 = Eixos[3:6] v3 = Eixos[6:9] #apoios Apoios = [rs.CurveStartPoint(v1[2]), rs.CurveStartPoint(v2[2])] #Eixo de Simetria do conector EixoSimetria = Conector[0] Bconect = Conector[1] EixoSimetria = rs.coerceline(EixoSimetria) ptX = gh.EndPoints(EixoSimetria) # vareável booleana para iniciar análise if Iniciar_Analise == None: Iniciar_Analise = True # calcula tensões para True ou none if Iniciar_Analise: #não calcula para False #Cargas na viga v1 C_v1, ptC_v1 = Linhas_de_Cargas(v1, P_v1, 'V1') Linhas_de_Carga += C_v1 txt_pontos += ptC_v1 #Cargas na viga v2 C_v2, ptC_v2 = Linhas_de_Cargas(v2, P_v2, 'V2') Linhas_de_Carga += C_v2 txt_pontos += ptC_v2 #Cargas na viga v3 C_v3, ptC_v3 = Linhas_de_Cargas(v3, P_v3, 'V3') Linhas_de_Carga += C_v3
def fractal(depth, x1, y1, z1, x2, y2, z2, length, anglerec, angle, lvariation, aran, lran, anglerech, angleh, branches, verticality, gchance, depthstart, radtolen, radchng, mngon, polygon, branch_cluster): #test if depth>0 if depth: #defining random angle variation and length variation arn = random.uniform(-angle / 100 * aran, angle / 100 * aran) lrn = random.uniform(-length / 100 * lran, length / 100 * lran) if hrandom == True: #defining horizontal rotation angles ahor = random.sample(range(0, 360), branches) #removing numbers within tolerance ahr = rs.CullDuplicateNumbers(ahor, angleh) #in a 360 fashion if ahr[0] + 360 - angleh < ahr[-1]: del ahr[0] else: #generating evenly distributed angles ahr = range(0, 360 + 1, 360 // branches)[:-1] #previous branch vector vecst = rg.Point3d(x1, y1, z1) vecend = rg.Point3d(x2, y2, z2) movevec = ghc.Vector2Pt(vecst, vecend, True)[0] #returns vector and it's length #perpendicular vector rotplane3 = ghc.PlaneNormal( vecend, movevec) #creates plane perpendicular to vector plns = ghc.DeconstructPlane(rotplane3) #origin, x, y, z rotplane = ghc.ConstructPlane( plns[2], plns[1], plns[3] ) #constructing new plane switching x and y planes to make perpendicular #generating perpendicular vector vecperp = ghc.Rotate(movevec, radians(90), rotplane)[0] #generating vector amplitudes leny = (length + lrn) * sin( radians((anglerec + arn) * (1 - (verticality**depth)))) lenz = (length + lrn) * cos(radians(anglerec + arn)) ampy = ghc.Amplitude(vecperp, leny) ampz = ghc.Amplitude(movevec, lenz) #changing branch length dependant on branch depth length = length * lvariation #building points endpoint1 = ghc.Move( vecend, ampz)[0] #returns moved object and transformation data endpoint = ghc.Move( endpoint1, ampy)[0] #returns moved object and transformation data #rotating point in a cone fashion rotpoint = ghc.Rotate3D( endpoint, radians(anglerech), vecend, movevec)[0] #returns rotated geometry and transformation data #building line between points linegeo = rg.Line(vecend, rotpoint) #defining recursion depth key = depthstart + 1 - depth #building geometry pln = ghc.PlaneNormal(rotpoint, linegeo) #returns a plane perp to a vector radius = length * (radchng**(key)) / radtolen #reduce details with each branch, but not less than 3 splits = 3 if mngon - key + 1 <= 3 else mngon - key + 1 polygonend = ghc.Polygon(pln, radius, splits, 0)[0] #returns a polygon and its perimeter #aligning curves for loft creation crvst = ghc.EndPoints(polygon)[0] pntcld = ghc.Discontinuity(polygonend, 1) #returns points and point parameters #finind seam point closest_point = ghc.ClosestPoint( crvst, pntcld[0] ) #returns closest point, closest point index, distance between closest points seampnt = pntcld[1][closest_point[1]] polygonend = ghc.Seam(polygonend, seampnt) lcurves = [polygon, polygonend] #building geometry geo = ghc.ExtrudePoint( polygon, rotpoint ) if depth == 1 and splits == 3 else rg.Brep.CreateFromLoft( lcurves, rg.Point3d.Unset, rg.Point3d.Unset, rg.LoftType.Normal, False)[0] #if last branch than make a pyramid #make solid geocapped = ghc.CapHoles(geo) #building a dict of geo with depth as key, and geo as values pgons.update( {branch_cluster: [geocapped]}) if branch_cluster not in pgons.keys( ) else pgons[branch_cluster].append(geocapped) branchesout.append(geocapped) #setting coords for next branch x1 = x2 y1 = y2 z1 = z2 #getting xyz from rotated point x2 = rg.Point3d(rotpoint)[0] y2 = rg.Point3d(rotpoint)[1] z2 = rg.Point3d(rotpoint)[2] #setting base polygon for next branch polygon = polygonend #filling dict with branch clusters cluster.append(cluster[-1] + 1) branch_cluster = cluster[-1] #calling function with different angle parameter for branch splitting, calling as many branches as spread within tolerance if depth != 1: for aa in ahr: if ( (random.randint(40, 99) / 100)**depth ) < gchance or depth == depthstart + 1: #or added to prevent blank trees fractal(depth - 1, x1, y1, z1, x2, y2, z2, length, angle, angle, lvariation, aran, lran, aa, angleh, branches, verticality, gchance, depthstart, radtolen, radchng, mngon, polygon, branch_cluster) #leaf logic if depth <= leavesdepth and leavesperbranch > 0 and maxleaves > 0: #vector for leaf growth spread leafpntvec = ghc.Vector2Pt(vecend, rotpoint, True)[0] #setting leaf growth position on last barnch, leafpnt list lastbranchlength = ghc.Length(linegeo) leaves_list = [lastbranchlength] [ leaves_list.append(lengthparam) for lengthparam in random.sample( range(0, int(lastbranchlength)), leavesperbranch - 1) ] if leavesperbranch > 1 else None for leafpnt in leaves_list: leafamp = ghc.Amplitude(leafpntvec, leafpnt) leafpoint = ghc.Move(vecend, leafamp)[0] #plane for leaf generation linetocenter = ghc.Line(stpntbase, leafpoint) planetocenter = ghc.PlaneNormal(leafpoint, linetocenter) #create an imaginary circle with leaflen radius and populate it with points for random leaf generation leafgenerationcircle = ghc.CircleCNR(leafpoint, linetocenter, leaflen) circlesurf = ghc.BoundarySurfaces(leafgenerationcircle) leafcnt = random.randint(0, maxleaves) if leafcnt > 0: leafendpnts = ghc.PopulateGeometry(circlesurf, leafcnt, random.randint(1, 500)) def leafgenerator(point): #random z move zmove = rg.Vector3d(0, 0, 1) moveamp = random.uniform(-leaflen / 3, leaflen / 5) ampzmove = ghc.Amplitude(zmove, moveamp) llendpnt = ghc.Move(point, ampzmove)[0] #setting a leaf centerline vector leafvector = ghc.Vector2Pt(leafpoint, llendpnt, True)[0] #defining leaf center point as avarage of st and end pnts midpnt = ghc.Average([leafpoint, llendpnt]) #generating perpendicular vector vecperpleaf = ghc.Rotate(leafvector, radians(90), planetocenter)[0] leafperpamp = ghc.Amplitude( vecperpleaf, random.uniform((leafwidth / 2) / 5 * 4, (leafwidth / 2) / 5 * 6)) #moving mid point to both sides midpnt1 = ghc.Move(midpnt, leafperpamp)[0] midpnt2 = ghc.Move(midpnt, -leafperpamp)[0] #leaf geo leafgeo = rg.NurbsSurface.CreateFromCorners( leafpoint, midpnt1, llendpnt, midpnt2) leaves.append(leafgeo) #iterate over random number of generated points if list, else generate for one point [leafgenerator(pp) for pp in leafendpnts] if isinstance( leafendpnts, list) else leafgenerator(leafendpnts)
def fractal(depth, x1, y1, z1, x2, y2, z2, length, anglerec, angle, lvariation, aran, lran, anglerech, angleh, branches, verticality, gchance, depthstart, radtolen, radchng, mngon, polygon, branch_cluster): #test if depth>0 if depth: #defining random angle variation and length variation arn = random.uniform(-angle / 100 * aran, angle / 100 * aran) lrn = random.uniform(-length / 100 * lran, length / 100 * lran) if hrandom == True: #defining horizontal rotation angles ahor = random.sample(range(0, 360), branches) #removing numbers within tolerance ahr = rs.CullDuplicateNumbers(ahor, angleh) #in a 360 fashion if ahr[0] + 360 - angleh < ahr[-1]: del ahr[0] else: #generating evenly distributed angles ahr = range(0, 360 + 1, 360 // branches)[:-1] #previous branch vector vecst = rg.Point3d(x1, y1, z1) vecend = rg.Point3d(x2, y2, z2) movevec = ghc.Vector2Pt(vecst, vecend, True)[0] #returns vector and it's length #perpendicular vector rotplane3 = ghc.PlaneNormal( vecend, movevec) #creates plane perpendicular to vector plns = ghc.DeconstructPlane(rotplane3) #origin, x, y, z rotplane = ghc.ConstructPlane( plns[2], plns[1], plns[3] ) #constructing new plane switching x and y planes to make perpendicular #generating perpendicular vector vecperp = ghc.Rotate(movevec, radians(90), rotplane)[0] #generating vector amplitudes leny = (length + lrn) * sin( radians((anglerec + arn) * (1 - (verticality**depth)))) lenz = (length + lrn) * cos(radians(anglerec + arn)) ampy = ghc.Amplitude(vecperp, leny) ampz = ghc.Amplitude(movevec, lenz) #changing branch length dependant on branch depth length = length * lvariation #building points endpoint1 = ghc.Move( vecend, ampz)[0] #returns moved object and transformation data endpoint = ghc.Move( endpoint1, ampy)[0] #returns moved object and transformation data #rotating point in a cone fashion rotpoint = ghc.Rotate3D( endpoint, radians(anglerech), vecend, movevec)[0] #returns rotated geometry and transformation data #building line between points linegeo = rg.Line(vecend, rotpoint) #defining recursion depth key = depthstart + 1 - depth #building geometry pln = ghc.PlaneNormal(rotpoint, linegeo) #returns a plane perp to a vector radius = length * (radchng**(key)) / radtolen #reduce details with each branch, but not less than 3 if mngon - key + 1 <= 3: splits = 3 else: splits = mngon - key + 1 polygonend = ghc.Polygon(pln, radius, splits, 0)[0] #returns a polygon and its perimeter #aligning curves for loft creation crvst = ghc.EndPoints(polygon)[0] pntcld = ghc.Discontinuity(polygonend, 1) #returns points and point parameters #finind seam point closest_point = ghc.ClosestPoint( crvst, pntcld[0] ) #returns closest point, closest point index, distance between closest points seampnt = pntcld[1][closest_point[1]] polygonend = ghc.Seam(polygonend, seampnt) lcurves = [polygon, polygonend] #building geometry if depth == 1 and splits == 3: geo = ghc.ExtrudePoint( polygon, rotpoint) #if last branch than make a pyramid else: geo = rg.Brep.CreateFromLoft(lcurves, rg.Point3d.Unset, rg.Point3d.Unset, rg.LoftType.Normal, False)[0] #make solid geocapped = ghc.CapHoles(geo) #building a dict of geo with depth as key, and geo as values, for more efficient joins if branch_cluster not in pgons.keys(): pgons[branch_cluster] = [geocapped] else: pgons[branch_cluster].append(geocapped) #setting coords for next branch x1 = x2 y1 = y2 z1 = z2 #getting xyz from rotated point x2 = rg.Point3d(rotpoint)[0] y2 = rg.Point3d(rotpoint)[1] z2 = rg.Point3d(rotpoint)[2] #setting base polygon for next branch polygon = polygonend #calling function with different angle parameter for branch splitting #calling as many branches as spread within tolerance #filling dict with branch clusters cluster.append(cluster[-1] + 1) branch_cluster = cluster[-1] for aa in ahr: if ( (random.randint(40, 99) / 100)**depth ) < gchance or depth == depthstart + 1: #or added to prevent blank trees fractal(depth - 1, x1, y1, z1, x2, y2, z2, length, angle, angle, lvariation, aran, lran, aa, angleh, branches, verticality, gchance, depthstart, radtolen, radchng, mngon, polygon, branch_cluster)