def process_floor(in_objects, floor_outline, outline_cut_height=None): """function used to process an individual floor. input: in_objects: the internal curves and breps selected for this floor floor_outline: the outline brep for the envelope outline_cut_height: height to cut at. output: (crv,[crv]) crv: the offset boundary curve for the floor [crv]: the internal curves for the floor pt: lower-left reference point bdims = bounding dims of this floor """ #classify the inputs in_crvs, in_breps = brep_or_crv(in_objects) #get list of crvs to project brep_sections = [] for b in in_breps: cut_height = wge.get_brep_height(b) / 2 pcurves = wge.get_brep_plan_cut(rs.coercebrep(b), cut_height, D_TOL) brep_sections.extend(pcurves) b_section_guids = wru.add_curves_to_layer(brep_sections, LCUT_INDICES[0]) in_crvs.extend(b_section_guids) #get the outline brep curve if not outline_cut_height: outline_cut_height = wge.get_brep_height(floor_outline) floor_outline_crvs = wge.get_brep_plan_cut(rs.coercebrep(floor_outline), outline_cut_height, D_TOL) floor_outline_crvs = wru.add_curves_to_layer(floor_outline_crvs, LCUT_INDICES[1]) #get bounding info for the floor outline bb = rs.BoundingBox(floor_outline) corner = bb[0] bdims = wge.get_bounding_dims(floor_outline) proj_srf = rs.AddSrfPt([bb[0], bb[1], bb[2], bb[3]]) internal_crvs = rs.ProjectCurveToSurface(in_crvs, proj_srf, [0, 0, -1]) if in_crvs else [] offset_floor_crv = rs.ProjectCurveToSurface(floor_outline_crvs, proj_srf, [0, 0, -1]) #rs.DeleteObjects(in_crvs) rs.DeleteObjects(floor_outline_crvs) rs.DeleteObject(proj_srf) out_floor_crvs = rs.coercecurve(offset_floor_crv) out_internal_crvs = [rs.coercecurve(x) for x in internal_crvs] rs.DeleteObject(offset_floor_crv) rs.DeleteObjects(internal_crvs) rs.DeleteObjects(b_section_guids) #TODO: make sure objects are being deleted return out_floor_crvs, out_internal_crvs, corner, bdims
def project_etching(etch_crvs, surfaces): if not etch_crvs: return [] pc = rs.ProjectCurveToSurface(etch_crvs, surfaces, [0, 0, -1]) if pc: return pc else: return []
def _FuselageLongitudinalGuideCurves(NoseLengthRatio, TailLengthRatio): # Internal function. Defines the four longitudinal curves that outline the # fuselage (outer mould line). FSVU, FSVL = _AirlinerFuselageSideView(NoseLengthRatio, TailLengthRatio) FSVUCurve = rs.AddCurve(FSVU) FSVLCurve = rs.AddCurve(FSVL) AFPVPort, NoseEndX, TailStartX = _AirlinerFuselagePlanView( NoseLengthRatio, TailLengthRatio) # Generate plan view PlanPortCurve = rs.AddCurve(AFPVPort) # How wide is the fuselage? (Xmin, Ymin, Zmin, Xmax, Ymax, Zmax) = act.ObjectsExtents(PlanPortCurve) # Generate a slightly wider projection surface FSVMeanCurve = rs.MeanCurve(FSVUCurve, FSVLCurve) RuleLinePort = rs.AddLine((0, 0, 0), (0, -1.1 * abs(Ymax - Ymin), 0)) FSVMCEP = rs.CurveEndPoint(FSVMeanCurve) AftLoftEdgePort = rs.CopyObject(RuleLinePort, FSVMCEP) ParallelLoftEdgePort = rs.CopyObject(FSVMeanCurve, (0, -1.1 * abs(Ymax - Ymin), 0)) LSPort = rs.AddSweep2((FSVMeanCurve, ParallelLoftEdgePort), (RuleLinePort, AftLoftEdgePort)) # Project the plan view onto the mean surface PortCurve = rs.ProjectCurveToSurface(PlanPortCurve, LSPort, (0, 0, 100)) # House-keeping rs.DeleteObjects([ LSPort, PlanPortCurve, ParallelLoftEdgePort, RuleLinePort, AftLoftEdgePort ]) # Tidy up the mean curve. This is necessary for a smooth result and removing # it can render the algorithm unstable. However, FitCurve itself may sometimes # be slightly unstable. FLength = abs(Xmax - Xmin) # establish a reference length PortCurveSimplified = rs.FitCurve(PortCurve, distance_tolerance=FLength * 0.001) StarboardCurveSimplified = act.MirrorObjectXZ(PortCurveSimplified) rs.DeleteObject(PortCurve) # Compute the actual end points of the longitudinal curves (Xmin, Ymin, Zmin, Xmax1, Ymax, Zmax) = act.ObjectsExtents(StarboardCurveSimplified) (Xmin, Ymin, Zmin, Xmax2, Ymax, Zmax) = act.ObjectsExtents(PortCurveSimplified) (Xmin, Ymin, Zmin, Xmax3, Ymax, Zmax) = act.ObjectsExtents(FSVUCurve) (Xmin, Ymin, Zmin, Xmax4, Ymax, Zmax) = act.ObjectsExtents(FSVLCurve) EndX = min([Xmax1, Xmax2, Xmax3, Xmax4]) return StarboardCurveSimplified, PortCurveSimplified, FSVUCurve, FSVLCurve, FSVMeanCurve, NoseEndX, TailStartX, EndX
def travel(self, startPoint, endPoint, surfaceToProject): travelLine = rs.AddLine(startPoint, endPoint) projectedTravelLine = rs.ProjectCurveToSurface(travelLine, surfaceToProject, (0, 0, 1)) rs.MoveObject(projectedTravelLine, (0, 0, self.gcoder.getLayerHeight())) try: convertedTravelPolyline = rs.ConvertCurveToPolyline( projectedTravelLine) except: print('In Trave, convertCurveToPolyline failed') print(projectedTravelLine) return False travelVertices = rs.CurveEditPoints(convertedTravelPolyline) rs.DeleteObject(convertedTravelPolyline) self.gcoder.addGcode("G92 E0\n") self.gcoder.initEValue() tmpText = "G1 E{0} F{1}\n".format(self.gcoder.getRetractionDistance(), 1800) self.gcoder.addGcode(tmpText) travelLineStartPoint = rs.CurveStartPoint(travelLine) projectedTravelLineStart = rs.CurveStartPoint(projectedTravelLine) projectedTravelLineEnd = rs.CurveEndPoint(projectedTravelLine) if rs.Distance(travelLineStartPoint, projectedTravelLineStart) > rs.Distance( travelLineStartPoint, projectedTravelLineEnd): travelVertices = list(travelVertices) travelVertices.reverse() rs.DeleteObject(travelLine) rs.DeleteObject(projectedTravelLine) for travelVer in travelVertices: tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format( travelVer[0], travelVer[1], travelVer[2], 3600) self.gcoder.addGcode(tmpText) tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(endPoint[0], endPoint[1], endPoint[2], 3600) tmpText += "G1 E0.0 F1800\n" tmpText += "G92 E0\n" self.gcoder.addGcode(tmpText)
def flatten(crvs): planPlane = rs.AddPlaneSurface([-1000,-1000,0], 3000, 3000) #projectedCrvs = rs.ProjectCurveToSurface(crvs, planPlane, [0,0,-1]) projectedCrvs = [] for crv in crvs: explodedCrvs = rs.ExplodeCurves(crv) if explodedCrvs: for explodedCrv in explodedCrvs: tempCrv = rs.ProjectCurveToSurface(explodedCrv, planPlane, [0,0,-1]) rs.DeleteObject(explodedCrv) rs.MatchObjectAttributes(tempCrv, crv) projectedCrvs.append(tempCrv) rs.DeleteObject(crv) else: tempCrv = rs.ProjectCurveToSurface(crv, planPlane, [0,0,-1]) rs.MatchObjectAttributes(tempCrv, crv) rs.DeleteObjects(crv) projectedCrvs.append(tempCrv) rs.DeleteObject(planPlane) return projectedCrvs
fCurves[i] = rs.MoveObject(fCurves[i], (0, dab[i], zr[i])) fCurves[i] = rs.RotateObject(fCurves[i], cPoint, rangle[i]) bCurves.append(rs.AddInterpCurve(bPoints[i], 3)) bCurves[i] = rs.RotateObject(bCurves[i], cPoint, 90) bCurves[i] = rs.MoveObject(bCurves[i], (0, dab[i], zr[i])) bCurves[i] = rs.RotateObject(bCurves[i], cPoint, rangle[i]) cylCurves.append(rs.AddLine((-D, 0, zr[i]), (D, 0, zr[i]))) cylsrf.append(rs.AddRevSrf(cylCurves[i], _ax, -90, 90)) #Projection of the curve surface pfCurves = [] pbCurves = [] for i in range(9): pfCurves.append(rs.ProjectCurveToSurface(fCurves[i], cylsrf[i], (0, 0, -1))) pbCurves.append(rs.ProjectCurveToSurface(bCurves[i], cylsrf[i], (0, 0, -1))) """for i in range(9): pfCurves.append(rc.Geometry.Curve.ProjectToBrep(fCurves[i], cylsrf[i],(0,0,-1),1)) pbCurves.append(rc.Geometry.Curve.ProjectToBrep(bCurves[i], cylsrf[i],(0,0,-1),1))""" pfCurves = flatten(pfCurves) pbCurves = flatten(pbCurves) # Surface generation """fcendp=[] fcstp=[] bcendp=[] bcstp=[] if(len(pfCurves)<=len(pbCurves)):
filename = rs.SaveFileName("Save point coordinates as", filter) ### file = open(filename, "w") file.write("hull \n") for i in range(1, n): flg_stn = 1 c1 = (x1[0] - i * dx, x1[1], x1[2]) c2 = (x1[0] - i * dx, x1[1], h[2]) curp1 = rs.AddPoint(c1) curp2 = rs.AddPoint(c2) curl = rs.AddLine(curp1, curp2) rs.DeleteObject(curp1) rs.DeleteObject(curp2) lstCur = rs.ProjectCurveToSurface(curl, surface, (0, 1, 0)) rs.DeleteObject(curl) if len(lstCur) <> 1: print "Error in Projection" else: if rs.IsCurveClosed(lstCur[0]): start_point = rs.GetPoint("Base point of center line") end_point = rs.GetPoint("Endpoint of center line", start_point) points = rs.CurveContourPoints(lstCur[0], start_point, end_point) else: if rs.CurveStartPoint(lstCur[0])[2] < rs.CurveEndPoint( lstCur[0])[2]: sp = rs.CurveStartPoint(lstCur[0]) lp = rs.CurveEndPoint(lstCur[0])
#functions #to draw points if necessary def drawPts(PTLIST): rs.EnableRedraw(False) for i in range(len(PTLIST)): for j in range(len(PTLIST[i])): rs.AddPoint(PTLIST[i][j]) rs.EnableRedraw(True) #identify surface srf = rs.GetObject("Select surface", 8+16) #specify surface GUID #identify crvs crvs = rs.GetObjects("Select polylines", 4) #specify curves GUID proj_crvs = rs.ProjectCurveToSurface(crvs, srf, (0,0,1)) crvPts = [] for i in range(len(proj_crvs)): nowCrv = proj_crvs[i] nowCrvPts = rs.CurvePoints(nowCrv) crvPts.append(nowCrvPts) #generate text file DEM_file = open("170131_PATHtest.txt", "w") for i in range(len(crvPts)): newLine = "" for j in range(len(crvPts[i])-1): strValue = str(crvPts[i][j])
import rhinoscriptsyntax as rs surface = rs.GetObject("Select surface to project onto", rs.filter.surface) curve = rs.GetObject("Select curve to project", rs.filter.curve) # Project down... results = rs.ProjectCurveToSurface(curve, surface, (0, 1, 0)) print len(results)
def genOffFile(): x1 = 35859.39 x2 = 0.0 h = 3000.0 n = 50 dx = x1 / n print dx # file for saving shf file filename = "test.txt" ### file = open(filename, "w") file.write("hull \n") file.write(_BOW) srfdic = getSurfaces() surface = srfdic['mod'] for i in range(0, n + 1): flg_stn = 1 c1 = (x1 - i * dx, 5000, -1000) c2 = (x1 - i * dx, 5000, h) curp1 = rs.AddPoint(c1) curp2 = rs.AddPoint(c2) curl = rs.AddLine(curp1, curp2) rs.DeleteObject(curp1) rs.DeleteObject(curp2) lstCur = rs.ProjectCurveToSurface(curl, surface, (0, 1, 0)) rs.DeleteObject(curl) if len(lstCur) <> 1: print "Error in Projection" else: if rs.CurveStartPoint(lstCur[0])[2] < rs.CurveEndPoint( lstCur[0])[2]: sp = rs.CurveStartPoint(lstCur[0]) lp = rs.CurveEndPoint(lstCur[0]) else: lp = rs.CurveStartPoint(lstCur[0]) sp = rs.CurveEndPoint(lstCur[0]) points = rs.CurveContourPoints(lstCur[0], sp, lp) npts = len(points) cpt = 1 for pt in points: #print(str(pt.X)+","+str(pt.Y)+","+str(pt.Z)) file.write("{:.5f}".format(pt.X / 1000.0)) file.write(" " * 10) file.write("{:.5f}".format(abs(pt.Y) / 1000.0)) file.write(" " * 10) file.write("{:.5f}".format(pt.Z / 1000.0)) file.write(" " * 10) file.write(str(flg_stn)) file.write("\n") flg_stn = 0 cpt += 1 rs.DeleteObject(lstCur[0]) file.write(_STERN) file.write("end") file.close()
###record dimensions of block dx = abs(minPt[0] - maxPt[0]) dy = abs(minPt[1] - maxPt[1]) dz = abs(minPt[2] - maxPt[2]) width, length, height = dx, dy, dz print width print length print height ###get section sectionLine = rs.GetLine() section = rs.AddCurve(sectionLine) profile = rs.ProjectCurveToSurface(section, block, rg.Vector3d(0, 0, 1)) ###get plane that section lies on centroidTuple = rs.CurveAreaCentroid(profile) centroid = centroidTuple[0] rs.AddPoint(centroid) ###get 3 non co linear points from section curves = rs.ExplodeCurves(section) print curves #rs.PlaneFromFrame() #rg.Plane(centroid, normal)
def drilling(curve_list, surface1, used_line2, unused_line, closest_p): split_num = 4 point_list = [] if not curve_list: # print("tan2: There is not curve") return if len(curve_list) != 1: cur_length = [] length = 0 # Message: unable to convert 0530c598-26e0-4ff5-a15a-389bd334aeff into Curve geometry for i in range(0, len(curve_list)): if rs.IsCurve(curve_list[i]): length = rs.CurveLength(curve_list[i]) cur_length.append(length) curve_index = cur_length.index(max(cur_length)) curve = curve_list[curve_index] else: curve = curve_list domain = rs.CurveDomain(curve) t = (domain[1] - domain[0]) / split_num for i in range(0, 4): dt = t * i point = rs.EvaluateCurve(curve, dt) point_list.append(point) # 直線の交点を求める line1 = rs.AddLine(point_list[0], point_list[2]) line2 = rs.AddLine(point_list[1], point_list[3]) vec1 = rs.VectorCreate(point_list[2], point_list[0]) vec2 = rs.VectorCreate(point_list[3], point_list[1]) cross = rs.VectorCrossProduct(vec1, vec2) normal = rs.VectorUnitize(cross) curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, normal) curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, normal) if len(curveOnsurface1) == 0: # ttm add プロジェクションされていない可能性があるため new_vec1 = rs.VectorReverse(normal) curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, new_vec1) if len(curveOnsurface2) == 0: # ttm add プロジェクションされていない可能性があるため new_vec2 = rs.VectorReverse(normal) curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, new_vec2) if len(curveOnsurface1) == 2 and len(curveOnsurface2) == 2: intersection1 = rs.CurveCurveIntersection(curveOnsurface1[0], curveOnsurface2[0]) intersection2 = rs.CurveCurveIntersection(curveOnsurface1[1], curveOnsurface2[1]) # 条件分岐 if intersection1 is None: intersection1 = rs.CurveCurveIntersection(curveOnsurface1[0], line2) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface2[0], line1) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface1[1], line2) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface2[1], line1) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface1[0], curveOnsurface2[1]) intersection2 = rs.CurveCurveIntersection( curveOnsurface1[1], curveOnsurface2[0]) else: # normal_reverce = rs.VectorReverse(normal) # curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, normal) # curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, normal) intersection1 = rs.CurveCurveIntersection( curveOnsurface1[0], curveOnsurface2[0]) #index out of range: 0 intersection2 = None # console # print("intersection1: %s" % (intersection1)) # print("intersection2: %s" % (intersection2)) if intersection1 is None and intersection2 is None: center_point = rs.CurveMidPoint(curveOnsurface1[0]) elif intersection2 is None: center_point = intersection1[0][1] else: center_point1 = intersection1[0][1] center_point2 = intersection2[0][1] dis1 = rs.Distance(center_point1, closest_p) dis2 = rs.Distance(center_point2, closest_p) if dis1 > dis2: center_point = center_point2 else: center_point = center_point1 parameter1 = rs.CurveClosestPoint(unused_line, center_point) parameter2 = rs.CurveClosestPoint(used_line2, center_point) point1 = rs.EvaluateCurve(unused_line, parameter1) # base point point2 = rs.EvaluateCurve(used_line2, parameter2) # base point # ドリル穴のベクトルを生成 drill_line = rs.AddLine(point1, point2) rs.CurveArrows(drill_line, 2) rs.ExtendCurveLength(drill_line, 0, 2, 100) drill_vec = rs.VectorCreate(point2, point1) # 外積計算より回転軸を生成 start_point = rs.CurveStartPoint(unused_line) end_point = rs.CurveEndPoint(unused_line) distance1 = rs.Distance(start_point, center_point) distance2 = rs.Distance(end_point, center_point) if distance1 > distance2: select_point = end_point else: select_point = start_point # 回転平面を定義する origin_point = center_point x_point = point1 y_point = select_point new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) rotate_p = origin_point vec1 = rs.VectorCreate(x_point, rotate_p) vec2 = rs.VectorCreate(y_point, rotate_p) cross = rs.VectorCrossProduct(vec1, vec2) cross_unit = rs.VectorUnitize(cross) rotate_vec = rs.VectorScale( cross_unit, 100) # Message: Could not convert None to a Vector3d # 描画 # new_rotate_axis = AddVector(center_point, rotate_vector) # rotate_axis = AddVector(rotate_p, rotate_vec) # rs.AddPoint(point1) # rs.AddPoint(point2) # rs.AddPoint(center_point) # object削除 rs.DeleteObject(line1) rs.DeleteObject(line2) for i in range(0, len(curveOnsurface1)): rs.DeleteObject(curveOnsurface1[i]) for i in range(0, len(curveOnsurface2)): rs.DeleteObject(curveOnsurface2[i]) # 平面をもとのxy平面に戻す origin_point = (0, 0, 0) x_point = (100, 0, 0) y_point = (0, 100, 0) new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) # 戻り値(ドリルライン、ドリルベクトル、回転軸、回転軸点) return drill_line, drill_vec, rotate_vec, center_point
def rc_terraincut2(b_obj, building_guids, etching_guids): join_dist = 0 if str(b_obj.ObjectType) != "Brep": b_geo = extrusion_to_brep(b_obj.Geometry) else: b_geo = b_obj.Geometry outline_crv = get_surface_outline(b_geo) #wrh.add_curves_to_layer(outline_crv,1) #extrude down the topography surface in order to take sections bool_merged = Rhino.Geometry.Brep.MergeCoplanarFaces(b_geo, D_TOL) extruded_srf_id = extrude_down_srf(wrh.docobj_to_guid(b_obj)) extruded_srf = rs.coercebrep(extruded_srf_id) #get planes for sectioning. planes = get_section_planes(b_geo, THICKNESS) #get the section curves and the section srfs #rs.Redraw() section_srfs = [] for i, plane in enumerate(planes): #print i #if first level, get brep outline if i > 0: plane_sections = get_section(extruded_srf, plane) else: plane_sections = outline_crv ###DEBUG STARTS#### current_level_srfs = [] for crv in plane_sections: closed = crv.IsClosed if not closed: dist = rs.Distance(crv.PointAtStart, crv.PointAtEnd) res = crv.MakeClosed(dist * 2) join_dist = dist if dist > join_dist else join_dist if res == False: return 0 new_brep = Rhino.Geometry.Brep.CreatePlanarBreps(crv)[0] current_level_srfs.append(new_brep) #new_brep_added = doc.Objects.AddBrep(new_brep) #rs.ObjectLayer(new_brep_added,"s15") ###DEBUG ENDS### section_srfs.append(current_level_srfs) rs.DeleteObject(extruded_srf_id) #get extrusions of section srfs extruded_section_breps = [] boolean_section_breps = [] frame_base_surface = None for i, brep_level in enumerate(section_srfs): extruded_breps = [] for brep in brep_level: srf_added = wrh.add_brep_to_layer(brep, LCUT_IND[2]) if i == 0: frame_base_surface = rs.CopyObject(srf_added) extruded_breps.append(rs.ExtrudeSurface(srf_added, SHORT_GUIDE)) rs.DeleteObject(srf_added) extruded_section_breps.append(extruded_breps) #rs.Redraw() #make voids for existing buildings building_breps = building_guids bldg_subtraction_breps = get_building_booleans(building_breps, planes) if bldg_subtraction_breps: extruded_section_breps = cut_building_volumes(extruded_section_breps, bldg_subtraction_breps) [rs.DeleteObjects(x) for x in bldg_subtraction_breps] #purge the building breps num_divisions = len(section_srfs) frame_brep = get_frame_brep(frame_base_surface, BORDER_THICKNESS, THICKNESS * num_divisions) rs.DeleteObject(frame_base_surface) #boolean out the features final_breps = [] for i, brep_level in enumerate(extruded_section_breps): boolean_level_ind = i + 2 final_level_breps = [] if boolean_level_ind < len(extruded_section_breps): for A_brep in brep_level: final_brep = None B_breps = [] for B_srf in section_srfs[boolean_level_ind]: B_breps.append(rs.ExtrudeSurface(B_srf, LONG_GUIDE)) #truncate the B_breps if BORDER_BOOL: B_breps = [ cut_frame_from_brep(b, frame_brep) for b in B_breps ] #rs.AddLayer("debug6",[50,200,50]) #debug #rs.ObjectLayer(B_breps,"debug6") #handle a bug creating lists of lists sometimes. if isinstance(B_breps[0], (list, )): B_breps = B_breps[0] boolean_result = rs.BooleanDifference([A_brep], B_breps, False) rs.DeleteObjects(B_breps) if boolean_result: final_brep = boolean_result else: final_brep = rs.CopyObjects([A_brep]) rs.DeleteObjects([A_brep]) #rs.ObjectLayer(B_breps,"debug6") #rs.AddLayer("s11",[200,200,50]) #debug #rs.ObjectLayer(final_brep,"s11") #debug final_level_breps.extend(final_brep) else: #rs.ObjectLayer(A_brep,"s11") final_level_breps.extend(brep_level) final_breps.append(final_level_breps) #get the final surfaces by iterating through the final section breps and extracting the top faces. final_srfs = [] for i, breplevel in enumerate(final_breps): final_srfs_level = [] for brep in breplevel: xsrf = wge.get_extreme_srf(rs.coercebrep(brep), 5) final_srfs_level.append( doc.Objects.Add(xsrf[0].DuplicateFace( False))) #must properly type the faces #rs.ObjectLayer(final_srfs_level,"s4") final_srfs.append(final_srfs_level) [rs.DeleteObjects(x) for x in final_breps] #DEBUG #project etching layers to final srfs final_srfs.reverse() #get the boundary curves main_curves = [] guide_curves = [] etch_curves = [] for i, srflevel in enumerate(final_srfs): main_curves_level = [] guide_curves_level = [] etch_curves_level = [] for srf in srflevel: sb = rs.DuplicateSurfaceBorder(srf) sb_outer = rs.DuplicateSurfaceBorder(srf, 1) if sb: main_curves_level.extend(sb) if i < len(final_srfs) - 1 and sb_outer: p = rs.ProjectCurveToSurface(sb_outer, final_srfs[i + 1], [0, 0, -1]) if p: guide_curves_level.extend(p) rs.DeleteObject(sb_outer) if sb_outer: rs.DeleteObject(sb_outer) #refactor... etch_curves_level = project_etching(etching_guids, srflevel) etch_curves.append(etch_curves_level) main_curves.append(main_curves_level) guide_curves.append(guide_curves_level) flat_srf_list = [item for sublist in final_srfs for item in sublist] etch_curves.reverse() main_curves.reverse() guide_curves.reverse() bb = rs.BoundingBox(b_geo) layout_dist = rs.Distance(bb[0], bb[3]) + LASER_GAP preview_dist = rs.Distance(bb[0], bb[1]) + LASER_GAP movement_range = [(i + 1) * layout_dist for i in xrange(len(main_curves))] for i, level_list in enumerate(main_curves): cp_main = rs.CurvePlane(level_list[0]) rs.MoveObjects(level_list, [0, movement_range[i], -cp_main.OriginZ]) if etch_curves[i]: rs.MoveObjects(etch_curves[i], [0, movement_range[i], -cp_main.OriginZ]) if i > 0: cp_guide = rs.CurvePlane(guide_curves[i][0]) rs.MoveObjects(guide_curves[i], [0, movement_range[i - 1], -cp_guide.OriginZ]) main_curves = [item for sublist in main_curves for item in sublist] guide_curves = [item for sublist in guide_curves for item in sublist] etch_curves = [item for sublist in etch_curves for item in sublist] preview_geo = [item for sublist in final_srfs for item in sublist] rs.MoveObjects(preview_geo, [preview_dist, 0, 0]) #close the boundary curves cb_crvs = [] for c in guide_curves: if not rs.IsCurveClosed(c): if rs.IsCurveClosable(c, D_TOL): cb_curves.append(rs.CloseCurve(rs.CopyObject(c))) else: cb_crvs.append(rs.CopyObject(c)) etch_curves = wge.trim_boundary(etch_curves, cb_crvs, D_TOL) rs.DeleteObjects(cb_crvs) rs.DeleteObject(frame_brep) rs.ObjectLayer(main_curves, "XXX_LCUT_01-CUT") rs.ObjectLayer(guide_curves, "XXX_LCUT_03-LSCORE") rs.ObjectLayer(etch_curves, "XXX_LCUT_04-ENGRAVE") rs.ObjectLayer(preview_geo, "XXX_LCUT_00-GUIDES") if join_dist > 0: s = "Had to force-close gaps up to a distance of " + str(join_dist) Rhino.RhinoApp.WriteLine(s) return 1
def _BuildLS(self, ChordFactor, ScaleFactor): # Generates a tentative lifting surface, given the general, nondimensio- # nal parameters of the object (variations of chord length, dihedral, etc.) # and the two scaling factors. LEPoints = self._GenerateLeadingEdge() Sections = [] ProjectedSections = [] TEPoints_u = [] TEPoints_l = [] for i, LEP in enumerate(LEPoints): Eps = float(i)/self.SegmentNo Airfoil, Chrd = self.AirfoilFunct(Eps, LEP, self.ChordFunct, ChordFactor, self.DihedralFunct, self.TwistFunct) list.append(Sections, Airfoil) Pr = rs.ProjectCurveToSurface(Chrd,self.XoY_Plane,self.ProjVectorZ) list.append(ProjectedSections, Pr) list.append(TEPoints_l, rs.CurveEndPoint(Airfoil)) list.append(TEPoints_u, rs.CurveStartPoint(Airfoil)) rs.DeleteObjects(Chrd) LS = rs.AddLoftSrf(Sections,loft_type=self.LooseSurf) if LS==None: # Failed to fit loft surface. Try another fitting algorithm TECurve_u = rs.AddInterpCurve(TEPoints_u) TECurve_l = rs.AddInterpCurve(TEPoints_l) rails = [] list.append(rails, TECurve_u) list.append(rails, TECurve_l) # Are the first and last curves identical? # AddSweep fails if they are, so if that is the case, one is skipped CDev = rs.CurveDeviation(Sections[0],Sections[-1]) if CDev==None: shapes = Sections LS = rs.AddSweep2(rails, shapes, False) else: shapes = Sections[:-1] LS = rs.AddSweep2(rails, shapes, True) rs.DeleteObjects(rails) rs.DeleteObjects([TECurve_u, TECurve_l]) WingTip = None if self.TipRequired: TipCurve = Sections[-1] TipCurve = act.AddTEtoOpenAirfoil(TipCurve) WingTip = rs.AddPlanarSrf(TipCurve) rs.DeleteObject(TipCurve) # Calculate projected area # In some cases the projected sections cannot all be lofted in one go # (it happens when parts of the wing fold back onto themselves), so # we loft them section by section and we compute the area as a sum. LSP_area = 0 # Attempt to compute a projected area try: for i, LEP in enumerate(ProjectedSections): if i < len(ProjectedSections)-1: LSPsegment = rs.AddLoftSrf(ProjectedSections[i:i+2]) SA = rs.SurfaceArea(LSPsegment) rs.DeleteObject(LSPsegment) LSP_area = LSP_area + SA[0] except: print "Failed to compute projected area. Using half of surface area instead." LS_area = rs.SurfaceArea(LS) LSP_area = 0.5*LS_area[0] BB = rs.BoundingBox(LS) if BB: ActualSemiSpan = BB[2].Y - BB[0].Y else: ActualSemiSpan = 0.0 # Garbage collection rs.DeleteObjects(Sections) try: rs.DeleteObjects(ProjectedSections) except: print "Cleanup: no projected sections to delete" rs.DeleteObjects(LEPoints) # Scaling Origin = rs.AddPoint([0,0,0]) ScaleXYZ = (ScaleFactor, ScaleFactor, ScaleFactor) LS = rs.ScaleObject(LS, Origin, ScaleXYZ) if self.TipRequired and WingTip: WingTip = rs.ScaleObject(WingTip, Origin, ScaleXYZ) rs.DeleteObject(Origin) ActualSemiSpan = ActualSemiSpan*ScaleFactor LSP_area = LSP_area*ScaleFactor**2.0 RootChord = (self.ChordFunct(0)*ChordFactor)*ScaleFactor AR = ((2.0*ActualSemiSpan)**2.0)/(2*LSP_area) return LS, ActualSemiSpan, LSP_area, RootChord, AR, WingTip
import rhinoscriptsyntax as rs crv = "a6f3a052-1493-47c3-a040-08e8c05b9ee3" srf = "f2640092-38ce-4bbe-bf09-b465381b0069" #project crv to srf newCrv = rs.ProjectCurveToSurface(crv, srf, [0, 0, 1])[0] srfPts = [] uRes = 100 vRes = 100 uDom = rs.SurfaceDomain(srf, 0) uDom = uDom[1] - uDom[0] vDom = rs.SurfaceDomain(srf, 1) vDom = vDom[1] - vDom[0] #sample surface ptList = [] for i in range(uRes + 1): for j in range(vRes + 1): nowU = i * (uDom / uRes) nowV = j * (vDom / vRes) nowPt = rs.EvaluateSurface(srf, nowU, nowV) parCrv = rs.CurveClosestPoint(newCrv, nowPt) onCrv = rs.EvaluateCurve(newCrv, parCrv) if (rs.Distance(nowPt, onCrv) < 40): nowPt[2] = 0 ptList.append(nowPt) #generate surface
def setLayerFillT1(self, outline, layerIndex): """ 1. make line from planarBaseSurface 2. project that line to base surface 3. trim projected line by curved surface 4. move to place shoud be, Z-Axis """ sliceSurface = rs.CopyObject( self.contactSurface, (0, 0, self.gcoder.getLayerHeight() * layerIndex)) #make base fill line from outline convertedPolyline = rs.ConvertCurveToPolyline(outline) vertices = rs.CurveEditPoints(convertedPolyline) rs.DeleteObject(convertedPolyline) xValue = [i[0] for i in vertices] yValue = [i[1] for i in vertices] xValue.sort() yValue.sort() basePoint = [] basePoint.append((xValue[0], yValue[0], 0)) basePoint.append((xValue[-1], yValue[0], 0)) basePoint.append((xValue[-1], yValue[-1], 0)) basePoint.append((xValue[0], yValue[-1], 0)) if layerIndex % 2 == 0: baseLine = rs.AddLine(basePoint[0], basePoint[1]) baseVec = (basePoint[3][0] - basePoint[0][0], basePoint[3][1] - basePoint[0][1], basePoint[3][2] - basePoint[0][2]) dist = rs.Distance(basePoint[0], basePoint[3]) elif layerIndex % 2 == 1: baseLine = rs.AddLine(basePoint[0], basePoint[3]) baseVec = (basePoint[1][0] - basePoint[0][0], basePoint[1][1] - basePoint[0][1], basePoint[1][2] - basePoint[0][2]) dist = rs.Distance(basePoint[0], basePoint[1]) # for T0 of Bimatrix forNormal = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2) baseVec = [i / forNormal for i in baseVec] self.gcoder.addGcode("\n \n \n ; layer filling LayerNo:" + str(layerIndex) + " - T1 (Toolhead 1) \n \n \n") self.gcoder.addGcode("M135 T1 \n") self.gcoder.addGcode("T1 \n") #make gcode of layer filling for i in range(int(dist / self.gcoder.getExtruderDiameter())): liens = [] # *2 means every 2 thread for BiMatrix nextVec = [ v * self.gcoder.getExtruderDiameter() + v * self.gcoder.getExtruderDiameter() * i * 2 for v in baseVec ] if layerIndex % 2 == 0: nextStartPoint = (basePoint[0][0] + nextVec[0], basePoint[0][1] + nextVec[1], basePoint[0][2] + nextVec[2]) nextEndPoint = (basePoint[1][0] + nextVec[0], basePoint[1][1] + nextVec[1], basePoint[1][2] + nextVec[2]) elif layerIndex % 2 == 1: nextStartPoint = (basePoint[0][0] + nextVec[0], basePoint[0][1] + nextVec[1], basePoint[0][2] + nextVec[2]) nextEndPoint = (basePoint[3][0] + nextVec[0], basePoint[3][1] + nextVec[1], basePoint[3][2] + nextVec[2]) nextLine = rs.AddLine(nextStartPoint, nextEndPoint) projectedLine = rs.ProjectCurveToSurface(nextLine, sliceSurface, (0, 0, 1)) if projectedLine is None: rs.DeleteObject(nextLine) continue rs.DeleteObject(nextLine) trimedLine = self.trim(projectedLine, outline) if trimedLine is None or len(trimedLine) is 0: if projectedLine is not None: try: rs.DeleteObject(projectedLine) except: print('deleteObject failed') print(projectedLine) continue rs.DeleteObject(projectedLine) if i % 2 == 1: trimedLine.reverse() for j in trimedLine: prePoint = None currentPoint = None if j is None: continue try: convertedPolyline = rs.ConvertCurveToPolyline(j) except: print("hoge") print(j) vertices = rs.CurveEditPoints(convertedPolyline) rs.DeleteObject(convertedPolyline) flag = True if i % 2 == 1: vertices = list(vertices) vertices.reverse() for ver in vertices: currentPoint = ver if flag: self.travel(self.travelStartPoint, currentPoint, sliceSurface) #tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(currentPoint[0], currentPoint[1], currentPoint[2], 3600) flag = False else: self.gcoder.calcEValue( rs.Distance(currentPoint, prePoint)) tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format( currentPoint[0], currentPoint[1], currentPoint[2], self.gcoder.getEValue(), 1800) self.gcoder.addGcode(tmpText) prePoint = currentPoint else: self.travelStartPoint = currentPoint #bug if layerIndex != 0: if trimedLine is not None: rs.DeleteObjects(trimedLine) rs.DeleteObject(sliceSurface) return
width = rect_prof[3] #Line line = rs.AddLine(rect_prof[0], rect_prof[1]) array_number = int(width[0] // distance_x) #Array line if line: i = 0 for i in range(array_number): offset_x = distance_x * i line_copy = (offset_x, 0, 0) array_line = rs.CopyObject(line, line_copy) # Project down results = rs.ProjectCurveToSurface(array_line, surf_id, (0, 0, -1)) rs.DeleteObject(array_line) rs.DeleteObject(line) # to get curve number crvs = rs.ObjectsByType(4, True) line_number = (len(crvs)) filename = rs.SaveFileName("Save", "G-code (*.gcode)|*.gcode||") f = codecs.open(filename, 'w', 'utf-8') f.write('G90\n') f.write('M83\n') f.write('M106 S0\n') #f.write('M106 S60\n') #f.write('M104 S205 T0\n')
n = 0 for n in range(array_z_number): offset_z = Layerheight * n surface_copy = (0,0,offset_z) array_surface = rs.CopyObject(surface ,surface_copy) intersect_crv = rs.IntersectBreps(obj, array_surface) if intersect_crv is None: break intersect_srf = rs.AddPlanarSrf(intersect_crv) if intersect_srf is None: break rs.DeleteObjects(intersect_crv) rs.DeleteObjects(array_surface) # Project down results = rs.ProjectCurveToSurface(array_lines, intersect_srf, (0,0,-1)) rs.DeleteObjects(intersect_srf) #rs.DeleteObject(array_line) #rs.DeleteObject(line)