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)