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)