def FitSurface(srf_id, samples):
surf_points = rs.SurfacePoints(srf_id)
G = rs.SurfaceEditPoints(srf_id, True, True)
N = GrevilleNormals(srf_id)
S = ConvertToUVW(srf_id, samples)
Forces = [(0, 0, 0) for pt in surf_points]
Factors = [0.0 for pt in surf_points]
proximity = 0.0
translation = 0.0
for i in range(len(S)):
proximity += abs(S[i][2])
for j in range(len(surf_points)):
local_dist = (S[i][0] - G[j][0])**2 + (S[i][1] - G[j][1])**2
if local_dist < 0.01: local_dist = 0.01
local_factor = 1 / local_dist
local_force = rs.VectorScale(N[j], local_factor * S[i][2])
Forces[j] = rs.VectorAdd(Forces(j), local_force)
Factors[j] += local_factor
Forces = DivideVectorArray(Forces, Factors)
for i in range(len(surf_points)):
surf_points[i] = rs.PointAdd(surf_points[i], Forces[i])
translation += rs.VectorLength(Forces[i])
srf_N = rs.SurfacePointCount(srf_id)
srf_K = rs.SurfaceKnots(srf_id)
srf_W = rs.SurfaceWeights(srf_id)
srf_D = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_N, P, srf_K[0], srf_K[1], srf_D, srf_W)
def FitSurface(srf_id, samples):
ptSurface = rs.SurfacePoints(srf_id)
grSurface = rs.SurfaceEditPoints(srf_id, True, True)
nrSurface = GrevilleNormals(srf_id)
uvSamples = XYZ_To_UVW(srf_id, samples)
vecForce = [(0, 0, 0) for p in ptSurface]
vecFactor = [0 for p in ptSurface]
#Create null vectors for all control-point forces
for sample in uvSamples:
for j in range(len(grSurface)):
local_distance = (sample[0] - grSurface[j][0])**2 + (
sample[1] - grSurface[j][1])**2
local_factor = 100 / (local_distance**2)
local_force = nrSurface[j]
local_force = rs.VectorScale(local_force, local_factor * sample[2])
vecForce[j] = rs.VectorAdd(vecForce[j], local_force)
vecFactor[j] = vecFactor[j] + local_factor
for i in range(len(ptSurface)):
ptSurface[i] = rs.PointAdd(ptSurface[i],
rs.VectorDivide(vecForce[i], vecFactor[i]))
srf_CP_Count = rs.SurfacePointCount(srf_id)
srf_Knots = rs.SurfaceKnots(srf_id)
srf_Weights = rs.SurfaceWeights(srf_id)
srf_Degree = (rs.SurfaceDegree(srf, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0],
srf_Knots[1], srf_Degree, srf_Weights)
def AddCoordinateTag(obj):
dots = []
if rs.IsCurve(obj):
pts = rs.CurveEditPoints(obj)
elif rs.IsSurface(obj):
pts = rs.SurfaceEditPoints(obj)
elif rs.IsBrep(obj):
srfs = rs.ExplodePolysurfaces(obj)
pts = []
for srf in srfs:
pts+=rs.SurfaceEditPoints(srf)
rs.DeleteObjects(srfs)
try:
pts
except:
return
for pt in pts:
dots.append(rs.AddTextDot('X: '+str(pt.X)+'\nY: '+str(pt.Y)+'\nZ: ' +str( pt.Z), pt))
return dots
def detectParalellSurface(self):
#fix layer height
#self.paralellIntersectedCurve
#self.indexParalellSurfaces
explodedSurfaces = rs.ExplodePolysurfaces(self.addtiveObj)
for surface in explodedSurfaces:
#normals.append(rs.SurfaceNormal(surface))
tmpNormal = rs.SurfaceNormal(surface, [0, 0])
gotAngle = rs.VectorAngle(tmpNormal, self.normalVec)
if gotAngle == 0 or gotAngle == 180:
tmpPoints = rs.SurfaceEditPoints(surface)
tmpPlane = rs.PlaneFromNormal(tmpPoints[0], self.normalVec)
distance = rs.DistanceToPlane(tmpPlane, self.basePointForPlane)
distance *= (1.0 / math.cos(math.radians(self.angleOfSurface)))
print("distance")
print(distance)
paralellLayer = int(distance / self.fixedLayerHeight)
if paralellLayer < 0:
paralellLayer *= -1
if paralellLayer == int(
self.distancePrinting /
self.fixedLayerHeight) or int(distance) == 0:
continue
self.indexParalellSurfaces.append(int(paralellLayer))
print("paralellLayer")
print(paralellLayer)
print("layer num")
print(self.distancePrinting / self.fixedLayerHeight)
#there is object to delete
self.paralellIntersectedCurves.append(
rs.JoinCurves(rs.DuplicateEdgeCurves(surface)))
rs.DeleteObjects(explodedSurfaces)
"""
def FitSurface(srf_id, samples):
ptSurface = rs.SurfacePoints(srf_id)
grSurface = rs.SurfaceEditPoints(idSrf, True, True)
nrSurface = GrevilleNormals(srf_id)
uvSamples = XYZ_To_UVW(srf_id, samples)
#Create null vectors for all control-point forces
vecForce = [(0,0,0) for pt in ptSurface]
for i in range(len(uvSamples)):
LocalCP = NearestUV(uvSamples[i], grSurface)
LocalForce = nrSurface[LocalCP]
LocalForce = rs.VectorScale(LocalForce, uvSamples[i][2])
vecForce[LocalCP] = rs.VectorAdd(vecForce[LocalCP], LocalForce)
ptSurface = [rs.PointAdd(ptSurface[i], vecForce[i]) for i in range(len(ptSurface))]
srf_CP_Count = rs.SurfacePointCount(srf_id)
srf_Knots = rs.SurfaceKnots(srf_id)
srf_Weights = rs.SurfaceWeights(srf_id)
srf_Degree = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0], srf_Knots[1], srf_Degree, srf_Weights)
def assignBlockToPanel(obj):
"""
Assigns block containing a base surface to a surface with the matching name.
Block, base surface, and target surface must all have the same name.
input: target surface (with name)
returns: None
"""
allBlockNames = rs.BlockNames()
for eachBlockName in allBlockNames:
if rs.ObjectName(obj) == eachBlockName:
blockName = eachBlockName
print "Matching Block Found"
objBasePt = rs.SurfaceEditPoints(obj)[0]
objYPt = rs.SurfaceEditPoints(obj)[1]
objXPt = rs.SurfaceEditPoints(obj)[2]
objXVec = rs.VectorCreate(objXPt, objBasePt)
objXLength = rs.VectorLength(objXVec)
objYLength = rs.Distance(objBasePt, objYPt)
blockObjs = rs.BlockObjects(blockName)
for blockObj in blockObjs:
if rs.ObjectName(blockObj) == blockName:
print "Contains base plane"
if rs.IsSurface(blockObj):
blockBasePt = rs.SurfaceEditPoints(blockObj)[0]
blockYPt = rs.SurfaceEditPoints(blockObj)[1]
blockXPt = rs.SurfaceEditPoints(blockObj)[2]
blockXVec = rs.VectorCreate(blockXPt, blockBasePt)
rotAngle = rs.VectorAngle(objXVec, blockXVec)
blockXLength = rs.VectorLength(blockXVec)
blockYLength = rs.VectorLength(
rs.VectorCreate(blockYPt, blockBasePt))
xScale = objXLength / blockXLength
yScale = objYLength / blockYLength
newScale = [yScale, xScale, 1]
rs.InsertBlock(blockName,
objBasePt,
scale=newScale,
angle_degrees=rotAngle)
break
else:
print "Error: Base plane was not a surface"
import rhinoscriptsyntax as rs
import math
import codecs
surf_id = rs.GetObject("Select Surface")
rect_prof = rs.SurfaceEditPoints(surf_id)
distance_x = rs.GetReal("Vertical Distance", 0.4)
height = rs.GetReal("Offset Z", 0.18)
filament = rs.GetReal("Filament Diameter", 1.75)
Layerheight = rs.GetReal("Layer Height", 0.2)
extrude_temp = rs.GetReal("Extrude temperture", 205)
bed_temp = rs.GetReal("Bed temperture", 60)
printspeed = rs.GetReal("Print speed", 2500)
multi = rs.GetReal("Extrude multiply", 1.0)
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))
def setInfill(self, intersectCurve, index, paralellOffset=None):
if self.gcoder.getInfillRatio() == 0:
return
self.gcoder.addGcode("; layer infill\n")
newSliceSurface = rs.CopyObject(
self.sliceSurface, (0, 0, float(self.fixedLayerHeight * index)))
editPoints = rs.SurfaceEditPoints(newSliceSurface)
rs.DeleteObject(newSliceSurface)
#horizontal
baseLine = rs.AddLine(editPoints[0], editPoints[1])
baseVec = (editPoints[2][0] - editPoints[0][0],
editPoints[2][1] - editPoints[0][1],
editPoints[2][2] - editPoints[0][2])
forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormalize for i in baseVec]
dist = rs.Distance(editPoints[0], editPoints[2])
lines = []
interval = self.gcoder.getExtruderDiameter() * (
1.0 / (self.gcoder.getInfillRatio() / 100.0))
#It needs to DEBUG
#interval = self.gcoder.getLayerHeight() * 30
#prepare horizontal lines
flag = False
for i in range(int(dist / interval + 1)):
nextVec = [j * (interval * i) for j in baseVec]
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[1][0] + nextVec[0],
editPoints[1][1] + nextVec[1],
editPoints[1][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
if nextLine == None or intersectCurve == None:
rs.DeleteObject(nextLine)
rs.DeleteObject(baseLine)
continue
lines = (self.trim(nextLine, intersectCurve, 1))
rs.DeleteObject(nextLine)
if lines is None:
continue
if i % 2 == 1:
lines.reverse()
for j in lines:
startPoint = rs.CurveStartPoint(j)
endPoint = rs.CurveEndPoint(j)
if i % 2 == 0:
if flag:
self.gcoder.calcEValue(
rs.Distance(prePoint, startPoint))
#tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(startPoint[0], startPoint[1], startPoint[2], self.gcoder.getEValue(), 1800)
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 1800)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 3600)
flag = True
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
#tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(self.gcoder.getEValue()) + " F1800\n"
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
endPoint[0], endPoint[1], endPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = endPoint
elif i % 2 == 1:
if flag:
self.gcoder.calcEValue(rs.Distance(prePoint, endPoint))
#tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(endPoint[0], endPoint[1], endPoint[2], self.gcoder.getEValue(), 1800)
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 3600)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 3600)
flag = True
self.gcoder.calcEValue(rs.Distance(endPoint, startPoint))
#tmpText += "G1 X" + str(startPoint[0]) + " Y" + str(startPoint[1]) + " Z" + str(startPoint[2]) + " E" + str(self.gcoder.getEValue()) + " F1800\n"
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
startPoint[0], startPoint[1], startPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = startPoint
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
rs.DeleteObject(baseLine)
"""
'''
in case there is paralell curve
'''
if paralellOffset is not None:
newLines = []
for toTrim in lines:
trimedLines = self.trim(toTrim, paralellOffset, 2)
if trimedLines == None:
continue
for hoge in trimedLines:
newLines.append(hoge)
lines = newLines
"""
"""
for i in range(len(lines)):
startPoint = rs.CurveStartPoint(lines[i])
endPoint = rs.CurveEndPoint(lines[i])
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
if i%2 == 0:
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n"
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(self.gcoder.getEValue()) + " F1800\n"
elif i%2 == 1:
tmpText = "G1 X" + str(endPoint[0]) + " Y" + str(endPoint[1]) + " Z" + str(endPoint[2]) + " F3600\n"
tmpText += "G1 X" + str(startPoint[0]) + " Y" + str(startPoint[1]) + " Z" + str(startPoint[2]) + " E" + str(self.gcoder.getEValue()) + " F1800\n"
self.gcoder.addGcode(tmpText)
"""
#vertical
baseLine = rs.AddLine(editPoints[0], editPoints[2])
baseVec = (editPoints[1][0] - editPoints[0][0],
editPoints[1][1] - editPoints[0][1],
editPoints[1][2] - editPoints[0][2])
forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormalize for i in baseVec]
dist = rs.Distance(editPoints[0], editPoints[1])
lines = []
#interval = self.gcoder.getLayerHeight() * (1.0 / self.gcoder.getInfillRatio())
flag = False
#prepare horizontal lines
for i in range(int(dist / interval + 1)):
nextVec = [j * (interval * i) for j in baseVec]
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[2][0] + nextVec[0],
editPoints[2][1] + nextVec[1],
editPoints[2][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
if nextLine == None or intersectCurve == None:
#print("hogehoge")
rs.DeleteObject(baseLine)
rs.DeleteObject(nextLine)
continue
lines = (self.trim(nextLine, intersectCurve, 1))
rs.DeleteObject(nextLine)
if lines is None:
continue
if i % 2 == 1:
lines.reverse()
for j in lines:
startPoint = rs.CurveStartPoint(j)
endPoint = rs.CurveEndPoint(j)
if i % 2 == 0:
if flag:
self.gcoder.calcEValue(
rs.Distance(prePoint, startPoint))
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 3600)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 3600)
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
endPoint[0], endPoint[1], endPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = endPoint
flag = True
elif i % 2 == 1:
if flag:
self.gcoder.calcEValue(rs.Distance(prePoint, endPoint))
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 1800)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 1800)
self.gcoder.calcEValue(rs.Distance(endPoint, startPoint))
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
startPoint[0], startPoint[1], startPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = startPoint
flag = True
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
rs.DeleteObject(baseLine)
return
def setLayerFill(self, intersectCurve, index):
#set baseline, baseVec, dist
newSliceSurface = rs.CopyObject(
self.sliceSurface, (0, 0, float(self.fixedLayerHeight * index)))
editPoints = rs.SurfaceEditPoints(newSliceSurface)
#vertical
if index % 2 == 0:
baseLine = rs.AddLine(editPoints[0], editPoints[1])
baseVec = (editPoints[2][0] - editPoints[0][0],
editPoints[2][1] - editPoints[0][1],
editPoints[2][2] - editPoints[0][2])
dist = rs.Distance(editPoints[0], editPoints[2])
#horizontal
elif index % 2 == 1:
baseLine = rs.AddLine(editPoints[0], editPoints[2])
baseVec = (editPoints[1][0] - editPoints[0][0],
editPoints[1][1] - editPoints[0][1],
editPoints[1][2] - editPoints[0][2])
dist = rs.Distance(editPoints[0], editPoints[1])
#normalize baseVec
forNormal = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormal for i in baseVec]
#end set baseLine, baseVec, dist
self.gcoder.addGcode("; layer filling\n")
flag = False
for i in range(int(dist / self.gcoder.getExtruderDiameter()) + 1):
lines = []
nextVec = [
v * self.gcoder.getExtruderDiameter() * i for v in baseVec
]
#vertical
if index % 2 == 0:
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[1][0] + nextVec[0],
editPoints[1][1] + nextVec[1],
editPoints[1][2] + nextVec[2])
if index % 2 == 1:
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[2][0] + nextVec[0],
editPoints[2][1] + nextVec[1],
editPoints[2][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
lines = self.trim(nextLine, intersectCurve[0], 1)
rs.DeleteObject(nextLine)
if lines is None:
continue
if i % 2 == 1:
lines.reverse()
for j in lines:
startPoint = rs.CurveStartPoint(j)
endPoint = rs.CurveEndPoint(j)
if i % 2 == 0:
if flag:
self.gcoder.calcEValue(
rs.Distance(prePoint, startPoint))
#tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(startPoint[0], startPoint[1], startPoint[2], self.gcoder.getEValue(), 1800)
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 1800)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
startPoint[0], startPoint[1], startPoint[2], 3600)
flag = True
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
endPoint[0], endPoint[1], endPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = endPoint
elif i % 2 == 1:
if flag:
self.gcoder.calcEValue(rs.Distance(prePoint, endPoint))
#tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(endPoint[0], endPoint[1], endPoint[2], self.gcoder.getEValue(), 1800)
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 1800)
else:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
endPoint[0], endPoint[1], endPoint[2], 3600)
flag = True
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
tmpText += "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
startPoint[0], startPoint[1], startPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = startPoint
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
rs.DeleteObject(baseLine)
rs.DeleteObject(newSliceSurface)
import rhinoscriptsyntax as rs
def vectorlistEqual(arr1, arr2):
if len(arr1) != len(arr2): return False
for p1, p2 in zip(arr1, arr2):
print(p1 == p2, p1, p2)
srf1 = rs.GetObject('srf1')
srf2 = rs.GetObject('srf2')
pts0 = rs.SurfaceEditPoints(srf1)
pts1 = rs.SurfaceEditPoints(srf2)
print(pts0 == pts1)
vectorlistEqual(pts0, pts1)
def GrevilleNormals(srf_id):
uvGreville = rs.SurfaceEditPoints(srf_id, True, True)
return [rs.SurfaceNormal(srf_id, g) for g in uvGreville]
def setInfill(self, vec, intersectCurve):
if self.gcoder.getInfillRatio() == 0:
return
newSliceSurface = rs.CopyObject(self.sliceSurface, vec)
editPoints = rs.SurfaceEditPoints(newSliceSurface)
rs.DeleteObject(newSliceSurface)
#horizontal
baseLine = rs.AddLine(editPoints[0], editPoints[1])
baseVec = (editPoints[2][0] - editPoints[0][0],
editPoints[2][1] - editPoints[0][1],
editPoints[2][2] - editPoints[0][2])
forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormalize for i in baseVec]
dist = rs.Distance(editPoints[0], editPoints[2])
lines = []
#interval = self.gcoder.getLayerHeight() * (1.0 / self.gcoder.getInfillRatio())
interval = self.gcoder.getLayerHeight() * 30
#prepare horizontal lines
for i in range(int(dist / interval + 1)):
nextVec = [j * (interval * i) for j in baseVec]
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[1][0] + nextVec[0],
editPoints[1][1] + nextVec[1],
editPoints[1][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
if nextLine == None or intersectCurve == None:
'''
print("hogehoge")
print('nextLine')
print(nextLine)
print('intersectCurve')
print(intersectCurve)
'''
continue
try:
intersectedPoint = rs.CurveCurveIntersection(
nextLine, intersectCurve)
except:
print('failed')
print('nextLine')
print(nextLine)
print('intersectCurve')
print(intersectCurve)
if intersectedPoint == None:
rs.DeleteObject(nextLine)
continue
intersectedPoint = [n[1] for n in intersectedPoint]
if intersectedPoint == None:
print('there is no intersectedPoint')
rs.DeleteObject(nextLine)
rs.DeleteObject(intersectedPoint)
continue
if len(intersectedPoint) % 2 == 0:
for j in range(int(len(intersectedPoint) / 2)):
if i % 2 == 0:
lines.append(
rs.AddLine(intersectedPoint[2 * j],
intersectedPoint[(2 * j) + 1]))
else:
lines.append(
rs.AddLine(
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
1],
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
2]))
elif len(intersectedPoint) % 2 == 1:
#check there is no duplicate point with intersectCurve
#DEBUG needs
intersectedPoint = self.deleteAlonePoint(
intersectedPoint, intersectCurve)
rs.DeleteObject(nextLine)
self.gcoder.addGcode("; layer infill\n")
for i in range(len(lines)):
startPoint = rs.CurveStartPoint(lines[i])
endPoint = rs.CurveEndPoint(lines[i])
#self.gcoder.calcEValue(startPoint, endPoint)
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
#if i%2 == 0:
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(
startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n"
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(
endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(
self.gcoder.getEValue()) + " F1800\n"
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
#rs.DeleteObject(baseLine)
#vertical
baseLine = rs.AddLine(editPoints[0], editPoints[2])
baseVec = (editPoints[1][0] - editPoints[0][0],
editPoints[1][1] - editPoints[0][1],
editPoints[1][2] - editPoints[0][2])
forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormalize for i in baseVec]
dist = rs.Distance(editPoints[0], editPoints[1])
lines = []
#interval = self.gcoder.getLayerHeight() * (1.0 / self.gcoder.getInfillRatio())
#prepare horizontal lines
for i in range(int(dist / interval + 1)):
nextVec = [j * (interval * i) for j in baseVec]
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[2][0] + nextVec[0],
editPoints[2][1] + nextVec[1],
editPoints[2][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
if nextLine == None or intersectCurve == None:
#print("hogehoge")
continue
intersectedPoint = rs.CurveCurveIntersection(
nextLine, intersectCurve)
if intersectedPoint == None:
#print('intersectedPoint is none')
rs.DeleteObject(nextLine)
continue
intersectedPoint = [n[1] for n in intersectedPoint]
if intersectedPoint == None:
print('there is no intersectedPoint')
rs.DeleteObject(nextLine)
rs.DeleteObject(intersectedPoint)
continue
if len(intersectedPoint) % 2 == 0:
for j in range(int(len(intersectedPoint) / 2)):
if i % 2 == 0:
lines.append(
rs.AddLine(intersectedPoint[2 * j],
intersectedPoint[(2 * j) + 1]))
else:
lines.append(
rs.AddLine(
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
1],
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
2]))
elif len(intersectedPoint) % 2 == 1:
#check there is no duplicate point with intersectCurve
#DEBUG needs
intersectedPoint = self.deleteAlonePoint(
intersectedPoint, intersectCurve)
rs.DeleteObject(nextLine)
self.gcoder.addGcode("; layer infill\n")
for i in range(len(lines)):
startPoint = rs.CurveStartPoint(lines[i])
endPoint = rs.CurveEndPoint(lines[i])
#self.gcoder.calcEValue(startPoint, endPoint)
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
#if i%2 == 0:
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(
startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n"
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(
endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(
self.gcoder.getEValue()) + " F1800\n"
'''
else:
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(endPoint[1]) + " Z" + str(endPoint[2]) + " F3600\n"
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(startPoint[1]) + " Z" + str(startPoint[2]) +" E" + str(self.gcoder.getEValue()) + " F1800\n"
'''
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
#rs.DeleteObject(baseLine)
return
def setLayerFill(self, vec, intersectCurve, index):
#set baseline, baseVec, dist
newSliceSurface = rs.CopyObject(self.sliceSurface, vec)
editPoints = rs.SurfaceEditPoints(newSliceSurface)
#vertical
if index % 2 == 0:
baseLine = rs.AddLine(editPoints[0], editPoints[1])
baseVec = (editPoints[2][0] - editPoints[0][0],
editPoints[2][1] - editPoints[0][1],
editPoints[2][2] - editPoints[0][2])
dist = rs.Distance(editPoints[0], editPoints[2])
#horizontal
elif index % 2 == 1:
baseLine = rs.AddLine(editPoints[0], editPoints[2])
baseVec = (editPoints[1][0] - editPoints[0][0],
editPoints[1][1] - editPoints[0][1],
editPoints[1][2] - editPoints[0][2])
dist = rs.Distance(editPoints[0], editPoints[1])
#normalize baseVec
forNormal = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormal for i in baseVec]
#end set baseLine, baseVec, dist
self.gcoder.addGcode("; layer filling\n")
for i in range(int(dist / self.gcoder.getLayerHeight()) + 1):
lines = []
nextVec = [v * self.gcoder.getLayerHeight() * i for v in baseVec]
#vertical
if index % 2 == 0:
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[1][0] + nextVec[0],
editPoints[1][1] + nextVec[1],
editPoints[1][2] + nextVec[2])
if index % 2 == 1:
nextStartPoint = (editPoints[0][0] + nextVec[0],
editPoints[0][1] + nextVec[1],
editPoints[0][2] + nextVec[2])
nextEndPoint = (editPoints[2][0] + nextVec[0],
editPoints[2][1] + nextVec[1],
editPoints[2][2] + nextVec[2])
#nextLine = (nextStartPoint), (nextEndPoint)
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
try:
intersectedPoint = rs.CurveCurveIntersection(
nextLine, intersectCurve[0])
except:
print("intersect failur")
print('nextLine')
print(nextLine)
print('intersectCurve')
print(intersectCurve)
print(intersectCurve[0])
if intersectedPoint == None:
#print('intersectedPoint is none')
rs.DeleteObject(nextLine)
rs.DeleteObject(newSliceSurface)
continue
intersectedPoint = [n[1] for n in intersectedPoint]
if len(intersectedPoint) % 2 == 0:
for j in range(int(len(intersectedPoint) / 2)):
if i % 2 == 0:
lines.append(
rs.AddLine(intersectedPoint[2 * j],
intersectedPoint[(2 * j) + 1]))
else:
lines.append(
rs.AddLine(
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
1],
intersectedPoint[
2 * int(len(intersectedPoint) / 2 - j) -
2]))
elif len(intersectedPoint) % 2 == 1:
#check there is no duplicate point with intersectCurve
#DEBUG needs
intersectedPoint = self.deleteAlonePoint(
intersectedPoint, intersectCurve)
rs.DeleteObject(nextLine)
for j in lines:
startPoint = rs.CurveStartPoint(j)
endPoint = rs.CurveEndPoint(j)
#self.gcoder.calcEValue(startPoint, endPoint)
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(
startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n"
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(
endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(
self.gcoder.getEValue()) + " F1800\n"
self.gcoder.addGcode(tmpText)
rs.DeleteObjects(lines)
rs.DeleteObject(newSliceSurface)
def setSurfaceForSlicing(self):
explodedSurfaces = None
editPoint = []
explodedSurfaces = rs.ExplodePolysurfaces(self.addtiveObj)
for i in explodedSurfaces:
tmp = rs.SurfaceEditPoints(i)
for j in tmp:
editPoint.append(j)
rs.CullDuplicatePoints(editPoint)
minValue = []
maxValue = []
basePointForPlane = None
basePointForDistance = None
for i in range(len(editPoint)):
if i == 0:
basePointForPlane = editPoint[0]
basePointForDistance = editPoint[0]
for j in range(3):
minValue.append(editPoint[0][j])
maxValue.append(editPoint[0][j])
continue
else:
if basePointForPlane[2] > editPoint[i][2]:
basePointForPlane = editPoint[i]
if basePointForDistance[2] < editPoint[i][2]:
basePointForDistance = editPoint[i]
for j in range(3):
if minValue[j] > editPoint[i][j]:
minValue[j] = editPoint[i][j]
elif maxValue[j] < editPoint[i][j]:
maxValue[j] = editPoint[i][j]
#why?
self.basePointForPlane = basePointForPlane
plane = rs.PlaneFromNormal(basePointForPlane, self.normalVec)
#calculating distance printing
forDistance = []
for i in range(len(editPoint)):
if i == 0:
forDistance.append(editPoint[0])
forDistance.append(rs.DistanceToPlane(plane, editPoint[0]))
else:
tmpDistance = rs.DistanceToPlane(plane, editPoint[i])
if tmpDistance > forDistance[1]:
forDistance[0] = editPoint[i]
forDistance[1] = tmpDistance
self.distancePrinting = rs.DistanceToPlane(plane, forDistance[0])
#adapt to Z Axis
self.distancePrinting *= (1.0 /
math.cos(math.radians(self.angleOfSurface)))
if self.distancePrinting < 0:
self.distancePrinting *= -1
plane = rs.PlaneFromNormal(basePointForPlane, self.normalVec)
pntForSur = []
line = (minValue[0], minValue[1],
minValue[2]), (minValue[0], minValue[1], maxValue[2])
pntForSur.append(rs.LinePlaneIntersection(line, plane))
line = (minValue[0], maxValue[1],
minValue[2]), (minValue[0], maxValue[1], maxValue[2])
pntForSur.append(rs.LinePlaneIntersection(line, plane))
line = (maxValue[0], maxValue[1],
minValue[2]), (maxValue[0], maxValue[1], maxValue[2])
pntForSur.append(rs.LinePlaneIntersection(line, plane))
line = (maxValue[0], minValue[1],
minValue[2]), (maxValue[0], minValue[1], maxValue[2])
pntForSur.append(rs.LinePlaneIntersection(line, plane))
lineForSur = []
for i in range(4):
lineForSur.append(rs.AddLine(pntForSur[i], pntForSur[(i + 1) % 4]))
self.sliceSurface = rs.AddEdgeSrf(lineForSur)
#Delete lines used for making sliceSurface
rs.DeleteObjects(lineForSur)
rs.DeleteObjects(explodedSurfaces)
def handle_GENBLOCK_bt_view_srf(self, sender, e):
self.suspendInteraction()
rs.EnableRedraw(False)
try:
layername = get_layer_name('MASSING')
tolerance = 0.0001
self.isolateLayer(layername)
sel = rs.ObjectsByLayer(layername)
print('sel from MASSING layer:', sel)
self.deleteObjectsByGuid(sel)
rs.CurrentLayer(layername)
#blocks=rs.ObjectsByLayer(get_layer_name('BLOCK'))
cons = [('phase', 'BLOCK')]
obj_blocks = self.data.find_all(cons)
print('flag_1')
rhi_blocks = self.data.find_all_guids(cons)
print('flag_2', rhi_blocks)
cblocks = rs.CopyObjects(rhi_blocks)
ublocks = rs.BooleanUnion(cblocks, True)
splitedSrfs = []
horzSrfs = []
vertSrfs = []
#找出union block里的横竖面
print('Sparate horz and vert srfs')
for b in ublocks:
os = rs.ExplodePolysurfaces(b, True)
print('os', os)
#先把水平面分走
horzSrfs = []
vertSrfs = []
for s in os:
print('line 740')
if s is None:
continue
if not rs.IsObject(s):
continue
isHor, direct = isHorizonalSrf(s, True)
if isHorizonalSrf(s):
if direct < 0:
rs.ObjectColor(s, (255, 0, 0))
else:
rs.ObjectColor(s, COLOR_SET_01[5])
horzSrfs.append(s)
else:
vertSrfs.append(s)
blockedSrf = []
parentDic = {}
wheel = 0
print('assign parent objects')
#Union block的横竖面找parent
for po in obj_blocks:
srfs = rs.ExplodePolysurfaces(po.guid, False)
for vsrf in vertSrfs:
pts2 = rs.SurfaceEditPoints(vsrf)
for s in srfs:
pts1 = rs.SurfaceEditPoints(s)
if listsEqual(pts1, pts2):
parentDic[vsrf] = po
rs.DeleteObjects(srfs)
print(parentDic)
print('split irregular polygons')
for s in vertSrfs:
parent = parentDic[s]
if parent is None:
print('parent is None')
rs.SelectObject(s)
continue
#rs.EnableRedraw(True)
phaseIndex = 'MASSING'
typeIndex = parent.typeIndices[0]
boundary = rs.DuplicateSurfaceBorder(s)
pts = rs.CurveEditPoints(boundary)
if len(pts) > 5:
#print('splitting polygon')
#rs.EnableRedraw(False)
srfs = splitIrregularPolygon(s)
#print('splitIregPoly srfs=',srfs)
if srfs is None:
continue
splitedSrfs += srfs
for ss in srfs:
#print(shortGuid(parent.guid))
o = self.addObject(ss, phaseIndex, typeIndex, parent)
if o is None: continue
self.setObjectType(o, typeIndex)
#rs.EnableRedraw(True)
else:
splitedSrfs.append(s)
o = None
try:
o = self.addObject(s, phaseIndex, typeIndex, parent)
except Exception as e:
print(e, s, phaseIndex, typeIndex, parent)
if o is None: continue
#print('o=',o)
self.setObjectType(o, typeIndex)
#self.logDataTree()
rs.DeleteObject(boundary)
except Exception as e:
print('exception:', e)
#PrintException()
rs.EnableRedraw(True)
self.resumeInteraction()
rs.EnableRedraw(True)
