def add_sharp_edges(polys, points, sharp_edges): fixed_nodes = [] if sharp_edges: for edge in sharp_edges: pt1, pt2 = rs.CurveStartPoint(edge), rs.CurveEndPoint(edge) index1 = str(rs.PointArrayClosestPoint(points, pt1)) index2 = str(rs.PointArrayClosestPoint(points, pt2)) flag1 = False flag2 = False for key in polys: indices = polys[key]['indices'] for i, index in enumerate(indices): if index == index1: if flag1: #rs.AddTextDot(index,points[int(index)]) points.append(points[int(index)]) indices[i] = str(len(points) - 1) flag1 = True if index == index2: if flag2: #rs.AddTextDot(index,points[int(index)]) points.append(points[int(index)]) indices[i] = str(len(points) - 1) flag2 = True polys[key]['indices'] = indices return polys, points
def get_faces_from_polylines(polys, points): for key in polys: poly_points = polys[key]['points'] indices = [] for point in poly_points: indices.append(str(rs.PointArrayClosestPoint(points, point))) polys[key]['indices'] = indices return polys
def testAlign(crv1,crv2): start=rs.CurveStartPoint(crv2) crv1Start=rs.CurveStartPoint(crv1) pts=rs.PolylineVertices(crv1) index=rs.PointArrayClosestPoint(pts,start) crv1Pt=pts[index] if index!=0: return False else: return True
def mesh_to_mesh(rhino_mesh,trg_len,vis): print rhino_mesh crvs = rs.DuplicateMeshBorder(rhino_mesh) vertices = [map(float, vertex) for vertex in rs.MeshVertices(rhino_mesh)] faces = map(list, rs.MeshFaceVertices(rhino_mesh)) mesh = Mesh.from_vertices_and_faces(vertices, faces) pts_objs = rs.GetObjects("Fixed Points",1) rs.EnableRedraw(False) if pts_objs: pts_fixed = [rs.PointCoordinates(obj) for obj in pts_objs] pts = [] index_key = {} count = 0 for k, a in mesh.vertices_iter(True): pts.append((a['x'], a['y'], a['z'])) index_key[count] = k count += 1 fixed = [] for pt_fix in pts_fixed: index = rs.PointArrayClosestPoint(pts,pt_fix) fixed.append(index_key[index]) edge_lengths = [] for u, v in mesh.edges(): edge_lengths.append(mesh.edge_length(u, v)) target_start = max(edge_lengths)/2 id = rs.coerceguid(rhino_mesh, True) mesh_rhino_obj = rs.coercemesh(id, False) boundary = set(mesh.vertices_on_boundary()) user_func = wrapper_2(crvs,mesh_rhino_obj,fixed,boundary,vis) rs.HideObject(rhino_mesh) remesh(mesh,trg_len, tol=0.1, divergence=0.01, kmax=400, target_start=target_start, kmax_approach=200, verbose=False, allow_boundary=True, ufunc=user_func) rs.DeleteObject(rhino_mesh) return draw_light(mesh,temp = False)
def close_curve(): curve_a = curves[0] curve_b = curves[1] points_a = [rs.CurveStartPoint(curve_a), rs.CurveEndPoint(curve_a)] points_b = [rs.CurveStartPoint(curve_b), rs.CurveEndPoint(curve_b)] for test_point in points_a: closest_point = rs.PointArrayClosestPoint(points_b, test_point) curves.append(rs.AddLine(test_point, points_b[closest_point])) points_b.pop(closest_point) rs.JoinCurves(curves, True) print "Curves closed"
def partitionPts (centroids, allPts): partitionedPts = [] indexList = [] for i in range(0,len(allPts)): indexList.append(rs.PointArrayClosestPoint(centroids,allPts[i])) for i in range(0,len(centroids)): tempList = [] for j in range(0,len(allPts)): if(indexList[j]==i): tempList.append(allPts[j]) partitionedPts.append(tempList) return partitionedPts #returns a list of lists of pt GUIDS
def proximityPts(pts, initialIndex): ptsRemaining = pts ptsActivated = [] initialIndex = initialIndex ptsActivated.append(pts[initialIndex]) del ptsRemaining[initialIndex] for i in range(0, len(pts)): closestIndex = rs.PointArrayClosestPoint(ptsRemaining, ptsActivated[-1]) ptsActivated.append(pts[closestIndex]) del ptsRemaining[closestIndex] return ptsActivated
def grow(num): #this method grows the global ptArray list #this method grows teh pointClooud represented by this list if num == 0: return 0 randPt = randomPt(-25,25,-25,25,0,50) joinNode = nodeList[rs.PointArrayClosestPoint(ptArray, randPt)] joinPt = joinNode.pos joinVec = rs.VectorSubtract(randPt, joinPt) growthVec = rs.VectorUnitize(joinVec) newPt = rs.VectorAdd(joinPt, growthVec) newNode = node(newPt, joinNode) g = grow(num-1)
def Main(): mesh=rs.GetObjects("select mesh",rs.filter.mesh) start=rs.GetObject("select start points",rs.filter.point) refVec = rs.GetObject("select crv direction",rs.filter.curve) ang=rs.GetReal("enter branching angle",30) length=rs.GetReal("enter branch length",15) gen=rs.GetInteger("enter number of generations",3) lines=rs.AddLayer("branch",[255,0,0]) rs.EnableRedraw(False) rs.CurrentLayer(lines) vec=tanVec(refVec,start) centers=rs.MeshFaceCenters(mesh) index=rs.PointArrayClosestPoint(centers,start) norm=rs.MeshFaceNormals(mesh)[index] vec=rs.VectorRotate(vec,0,norm) branches=baseBranch(mesh,start,vec,ang,length,gen) return branches
def grow(self): x1 = self.node[0][0] - (self.size[1] / 2) x2 = self.node[0][0] + (self.size[1] / 2) y1 = self.node[0][1] - (self.size[1] / 2) y2 = self.node[0][1] + (self.size[1] / 2) z1 = self.node[0][2] z2 = self.node[0][2] + self.size[0] i = 0 while i < self.twigCount: randPt = placePt(x1, x2, y1, y2, z1, z2) joinPt = self.node[rs.PointArrayClosestPoint(self.node, randPt)] vec = rs.VectorScale( rs.VectorUnitize(rs.VectorSubtract(randPt, joinPt)), self.segLength) newPt = rs.PointAdd(joinPt, vec) self.addTwig(joinPt, newPt) i += 1
def closest_points(self,rh_objects): closest_list = [] test_object = rh_objects[0] closest_list.append(test_object) while True: if len(rh_objects) == 0: break rh_objects.pop(rh_objects.index(test_object)) if len(rh_objects) == 0: break closest_point_index = rs.PointArrayClosestPoint([rs.PointCoordinates(i.start_point) for i in rh_objects],test_object.point) closest_object = rh_objects[closest_point_index] closest_list.append(closest_object) test_object = closest_object #rs.DeleteObjects([point for point in point_cloud]) return closest_list
def generate(): initpts() del listgoal[:] del agentlist[:] for j in range(len(start)): index = rs.PointArrayClosestPoint( goalcy, start[j]) #calculate the closest pt from goal to agent[j] vec = rs.VectorCreate(goalcy[index], start[j]) vec = rs.VectorScale(vec, 3) listgoal.append(goalcy[index]) #store the calculated pts into list goalcy.pop(index) #remove the calculating goal pt from goal list #velrnd = [(rnd.random()*2) - 1,(rnd.random()*2) - 1,(rnd.random()*2) - 1] """ uniform """ velrnd = [(rnd.uniform(-1, 1) * 2), (rnd.uniform(-1, 1) * 2), (rnd.random() * 2)] vel = rs.VectorAdd(velrnd, vec) agentlist.append(agent(start[j], vel, 0.3, 1))
cube_pts = rs.AddPoints(pt) cube_range = range(int(cube_dim) , int(cube_num * cube_dim) , int(cube_dim)) xdir = [rs.CopyObject(i, (r , 0 , 0)) for r in cube_range for i in cube_pts] xdir = cube_pts + xdir ydir=[rs.CopyObject(x , (0 , r , 0)) for r in cube_range for x in xdir] zdir=[rs.CopyObject(x , (0 , 0 , r)) for r in cube_range for x in xdir] + \ [rs.CopyObject(y , (0 , 0 , r)) for r in cube_range for y in ydir] all_cube_pts = rs.coerce3dpointlist(xdir + ydir + zdir) index = [rs.PointArrayClosestPoint(point_cloud, pt) for pt in all_cube_pts] mesh_pts = [point_cloud[i] for i in index] dist = [rs.Distance(c,p) for c,p in zip(all_cube_pts,mesh_pts)] cubes = create_set(all_cube_pts) dist = create_set(dist) triangles = [polygonise(d,c,isolevel) for d,c in zip(dist,cubes)] point1=[i[0] for tri in triangles for t in tri for i in t] point2=[i[1] for tri in triangles for t in tri for i in t] point3=[i[2] for tri in triangles for t in tri for i in t] tri_pts = [rs.AddPoint(p1,p2,p3) for p1,p2,p3 in zip(point1 , point2 , point3)]
znum = randZ(10) #initializing first box, based on random numbers created with xnum, etc #initializing box zero array boxes = [] array = rs.AddBox([(0,0,0),(xnum,0,0),(xnum,ynum,0),\ (0,ynum,0),(0,0,znum),(xnum,0,znum),(xnum,ynum,znum),(0,ynum,znum)]) boxes.append(array) #make random point, move that point closer to closest point in pts array for i in range(1, 10): xnum = randX(10) ynum = randY(10) znum = randZ(10) pt = rs.AddPoint(placePt(100, 100, 100)) index = rs.PointArrayClosestPoint(pts, pt) cp = pts[index] vect = rs.VectorCreate(cp, pt) unitVect = rs.VectorUnitize(vect) subVect = vect - unitVect newPt = rs.MoveObject(pt, subVect) #find newPt coordinates to feed into the 8 needed box corners newPtCoord = rs.PointCoordinates(newPt) #take newPt coordinates index 0,1, or 2 for x,y, or z respectively, #add random xnum,ynum, or znum to respective index newboxArray = rs.AddBox([(newPtCoord),(newPtCoord[0]+xnum,newPtCoord[1],newPtCoord[2]),\ (newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]),(newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]),\ (newPtCoord[0],newPtCoord[1],newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1],\ newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]+znum),\ (newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]+znum)]) pts.append(newPt)
def Main(): #SETUP #------------------------------------------------------------------------------------------------------- #select the mesh to work on //////////////////////////////////////////////////////////////////// strMesh = rs.GetObject ("select mesh to work on", 32) # store the mesh face vertices - we'll need it later to rebuild the mesh arrFaceVertices = rs.MeshFaceVertices(strMesh) #select the attractors points //////////////////////////////////////////////////////////////////// attrs = rs.GetObjects ("select the attractors for direction - either points or curves", 5) # here we need to translate the attractors (IDS of points and curves that the user gave us) to coordinates #-------------------------------------------------------------------------- arrAttractors = [] for attr in attrs: if rs.IsCurve(attr) : #if it is a curve - i need to find the closest point to the current agent #right now i'll set it up to array(0,0,0) and i'll replace those values in the do loop later arrAttractors.append([0,0,0]) else : arrAttractors.append( rs.PointCoordinates(attr) ) #select the agents //////////////////////////////////////////////////////////////////// arrStrPtAgents = rs.GetObjects ("select Agents to move on the mesh", 1) dblStep = rs.GetReal("please type the step size of the agents' deformation factor",1) # here we need to translate the agents (points that the user gave us # to vertices on the mesh.... #-------------------------------------------------------------------------- # start a new array same size as the agents-points - call it agentsOnmesh agentsOnMesh = [] # get the mesh vertices arrVTXS = rs.MeshVertices (strMesh) # loop throught the points-agents that the user gave us, for strPtAgent in arrStrPtAgents: arrPtAgent = rs.PointCoordinates(strPtAgent) # use point array closest point to determine which mesh vertex is closest to the current agent-point # store that index from pointarrayclosestpoint in the agentsOnMesh(i) agentsOnMesh.append( rs.PointArrayClosestPoint(arrVTXS,arrPtAgent) ) # end loop #------------------------------------------------------------------------------------------------------- #RUN #------------------------------------------------------------------------------------------------------- #loop for number of steps for e in range(100): # get the mesh vertices of the current mesh arrVTXS arrVTXS = rs.MeshVertices (strMesh) # start a arrNEWVTXS and make it equal to arrVTXS (for now) arrNEWVTXS = arrVTXS[:] # i loop through each index in agentsOnMesh i = 0 for agentOnMesh in agentsOnMesh: # MOVE THE MESH POINT -------------------------------------------------------------------------- j = 0 for attr in attrs : if rs.IsCurve(attr) : #here we find the closestpoint on the curve attractors from the current agent dblParam = rs.CurveClosestPoint(attr,arrVTXS[agentOnMesh]) arrAttractors[j] = rs.EvaluateCurve(attr,dblParam) j += 1 ClosestAttIndex = rs.PointArrayClosestPoint(arrAttractors,arrVTXS[agentOnMesh]) # make a vector from arrVTXS(agentsOnMesh(i)) towards the closest attractor arrAttractors(ClosestAttIndex) arrVector = rs.VectorCreate(arrAttractors[ClosestAttIndex], arrVTXS[agentOnMesh]) arrVector = rs.VectorUnitize(arrVector) arrVector = rs.VectorScale(arrVector, dblStep) # add the vector to the arrVTXS(agentsOnMesh(i)) and store it in arrNEWVTXS(agentsOnMesh(i)) arrNEWVTXS[agentOnMesh] = rs.PointAdd(arrVTXS[agentOnMesh], arrVector) # MOVE THE AGENT -------------------------------------------------------------------------- # get the adjacent mesh vtx indexes from MeshVtxAdjacentVtxs arrNeighborIndexes = MeshVtxAdjacentVtxs (strMesh, agentOnMesh, False, False) # choose which vtx to "move" to, and store it in agentsOnMesh(i) rnd = random.random() agentsOnMesh[i] = arrNeighborIndexes[int((rnd)*(len(arrNeighborIndexes)-1))] i += 1 # add a new mesh in the document using arrNEWVTXS strNewMesh = rs.AddMesh(arrNEWVTXS,arrFaceVertices) RenderAgentsOnMesh(strNewMesh, agentsOnMesh) # delete the old one rs.DeleteObject(strMesh) # replace the ID of old mesh with the NEW ID strMesh = strNewMesh
def findAxis(self, point): norms = rs.MeshVertexNormals(self.mesh) verts = rs.MeshVertices(self.mesh) param = rs.PointArrayClosestPoint(verts, point) axis = norms[param] return axis
point_coord = rs.PointCoordinates(point1) length = rs.CurveLength(line) integerize = int(length) #put points on the line for i in range(integerize): points_on_line = rs.AddPoint(point_coord[0] + i, 0, 0) pipe_points.append(points_on_line) #initializing cloud of line points line_cloud = pipe_points #move random cloud of points to closest points on line cloud for i in range(0, 100): pt = rs.AddPoint(place_pts(100, 100, 100)) index = rs.PointArrayClosestPoint(line_cloud, pt) cp = line_cloud[index] vect = rs.VectorCreate(cp, pt) project = rs.ProjectPointToSurface(pt, pipe, vect) rs.AddPoints(project) all_points.append(pt) #making a function to delete objects, but I guess it'd be easier to just do the built in rs.DeleteObject """def delete_object(a,b,c,d,e): rs.DeleteObjects(object) return object delete_object(pipe_points, all_points, pipe, point1, point2) #delete_object(all_points) #delete_object(pipe)
multiY = -1 vecTest = rs.VectorUnitize([vecX, vecY, 0]) vecTest[0] = vecTest[0] * multiX vecTest[1] = vecTest[1] * multiY vecTest = vecTest * Radius # transform candidate point testCoord = [sum(x) for x in zip(testPt, vecTest)] testCoord[2] = 0 #print 'testing the following: ' + str(testCoord) # test distance to nearest point in pointcloud pointIndex = rs.PointArrayClosestPoint(cloudPointList, testCoord) testDistance = rs.Distance(testCoord, cloudPointList[pointIndex]) #print 'distance equals: ' + str(testDistance) # if point is good add to master and active list if ((testDistance >= (Radius - 1)) & (0 <= testCoord[0] <= Width) & (0 <= testCoord[1] <= Height)): print 'success!' rs.AddPoint(testCoord) niceCoordTuple = round(testCoord[0], 2), round(testCoord[1], 2), 0 activePointList.append(niceCoordTuple) cloudPointList.append(niceCoordTuple) countDownLength -= 1 testCounter += 1
def obj_layer(layer_name): '''trying to be able to call obj_layer on clos_pt with a particular layer name to give the corresponding cloud points a different parameter to move by ''' layer = rs.ObjectsByLayer(layer_name) return layer #initializing cloud of points, vectorize between cloud and original points, move pt by sub_vect amount\ #draw line between pt and original points for i in range(0, 5): pt = rs.AddPoint(place_pts(25, .25, .25)) #find closest points from cloud to source points index = rs.PointArrayClosestPoint(source_pts, pt) clos_pt = source_pts[index] """ #find layer of each point, put in for pt in og_source_pts: pt_name = rs.ObjectLayer(pt) change_layer = rs.ObjectLayer(clos_pt, pt_name) """ #rs.ObjectsByLayer() #clos_pt_layer = rs.ObjectLayer(og_source_pts) #print clos_pt_layer #change_layer = rs.ObjectLayer(pt, clos_pt_layer) #vector initializing vect = rs.VectorCreate(clos_pt, pt) unit_vect = rs.VectorUnitize(vect)
limitToResultsContaining = 'NC' import rhinoscriptsyntax as rs fhand = open('brickstacking/data analysis/yelp_academic_dataset_business.json') xCoords = [] yCoords = [] points = [] for line in fhand: if limitToResultsContaining in line: line.strip() pos = line.find('latitude') pos2 = line.find(',',pos) pos3 = line.find('longitude') pos4 = line.find(',',pos3) xCoords.append(float(line[pos+10:pos2])) yCoords.append(float(line[pos3+11:pos4])) for i in range(len(xCoords)): points.append(rs.AddPoint(xCoords[i],yCoords[i],0)) for i in range(len(points)): closest = rs.PointArrayClosestPoint(points,points[i]) distance = rs.VectorLength(rs.VectorCreate(closest,points[i])) '''if distance > 1 : points.pop(i)'''
point1 = rs.AddPoint(-100, 0, 0) point2 = rs.AddPoint(100, 0, 0) #cloud = rs.PointAdd(point1, point2) #cloud = rs.AddPoints(point1) cloud = (point1, point2) line = rs.AddLine(point1, point2) pipe = rs.AddPipe(line, 0, 4) all_points = [] for i in range(0, 100): pt = rs.AddPoint(place_pts(100, 100, 100)) index = rs.PointArrayClosestPoint(cloud, pt) cp = cloud[index] vect = rs.VectorCreate(cp, pt) #move = rs.MoveObject(pt,vect) #vector = rs.VectorCreate(index, pt) #index_points = rs.PointArrayClosestPoint(pipe_points, pt) #vector = rs.VectorCreate(index_points, pt) #rs.VectorCreate() #unit_vector = rs.VectorUnitize(vector) #new_pt = rs.MoveObject(pt, unit_vector) project = rs.ProjectPointToSurface(pt, pipe, vect) rs.AddPoints(project) all_points.append(pt)
polys = get_polyline_points(polylines) points = get_points_from_polylines(polys) polys = get_faces_from_polylines(polys, points) mesh_faces = [polys[key]['indices'] for key in polys] mesh_vertices = points mesh_obj = RhinoMesh.from_vertices_and_faces(mesh_vertices, mesh_faces) mesh_unify_cycle_directions(mesh_obj) #get fixed nodes fixed = [] fixed_objs = rs.ObjectsByLayer("SD_fixed") fixed_coords = [rs.PointCoordinates(obj) for obj in fixed_objs] if fixed_objs: for i, vertex in enumerate(mesh_vertices): index = rs.PointArrayClosestPoint(fixed_coords, vertex) if rs.Distance(fixed_coords[index], vertex) < 0.1: fixed.append(str(i)) rs.DeleteObjects(polylines) steps = 2 if 1 == 1: break_flag = False selection = "" dis = 0.1 while True: mesh_obj.draw( name="control",