-optimized optimizeChunk function, is much faster now with larger paths

-optimized parallel pattern generation, about 2x faster now
-fixed several bugs

scripts/addons/cam/__init__.py

@@ -173,7 +173,7 @@ def updateStrategy(o,context):
 
 def updateCutout(o,context):
 	if o.outlines_count>1:
-		o.use_bridges=false
+		o.use_bridges=False
 		
 	
 def updateExact(o,context):
@@ -187,7 +187,8 @@ def updateExact(o,context):
 def updateBridges(o,context):
 	print('update bridges ')
 	o.changed=True
-	utils.setupBridges(o)
+	#utils.setupBridges(o)
+	
 def updateRest(o,context):
 	print('update rest ')
 	o.changed=True

scripts/addons/cam/chunk.py

@@ -130,7 +130,12 @@ class camPathChunk:
 			self.startpoints.pop(index)
 			self.endpoints.pop(index)
 			self.rotations.pop(index)
-			
+	def append(self, point, startpoint=None,endpoint=None):
+		self.points.append(point)
+		if startpoint!=None:
+			self.startpoints.append(startpoint)
+		if endpoint!=None:
+			self.endpoints.append(endpoint)
 	def rampContour(self,zstart,zend,o):
 		
 		stepdown=zstart-zend
@@ -331,7 +336,17 @@ def setChunksZ(chunks,z):
 
 	
 def optimizeChunk(chunk,operation):
+	points=chunk.points
 	
+	chunk.points=[points[0]]
+	spoints=False
+	if len(chunk.startpoints)>0:
+		startpoints=chunk.startpoints
+		endpoints=chunk.endpoints
+		chunk.startpoints=[startpoints[0]]
+		chunk.endpoints=[endpoints[0]]
+		spoints=True
+	'''this was replaced by append. Pop method was much much slower! still testing however.
 	for vi in range(len(chunk.points)-2,0,-1):
 		#vmiddle=Vector()
 		#v1=Vector()
@@ -339,10 +354,28 @@ def optimizeChunk(chunk,operation):
 		if compare(chunk.points[vi-1],chunk.points[vi+1],chunk.points[vi],operation.optimize_threshold):
 			
 			chunk.pop(vi)
-			
-			#vi-=1
-	#protect_vertical=True
-	if operation.protect_vertical and operation.axes=='3':#protect vertical surfaces so far only for 3 axes..doesn't have now much logic for n axes, right?
+	'''
+	protect_vertical =  operation.protect_vertical and operation.axes=='3'
+	for vi in range(0,len(points)-1):
+		#vmiddle=Vector()
+		#v1=Vector()
+		#v2=Vector()
+		if not compare(chunk.points[-1],points[vi+1],points[vi],operation.optimize_threshold):
+			if spoints:
+				chunk.append(points[vi],startpoints[vi],endpoints[vi])
+			else:
+				chunk.points.append(points[vi])
+			if protect_vertical:
+				v1=chunk.points[-1]
+				v2=chunk.points[-2]
+				v1c,v2c=isVerticalLimit(v1,v2,operation.protect_vertical_limit)
+				if v1c!=v1:
+					chunk.points[-1]=v1c
+				elif v2c!=v2:
+					chunk.points[-2]=v2c
+	#=True
+	'''
+	if:#protect vertical surfaces so far only for 3 axes..doesn't have now much logic for n axes, right?
 		#print('verticality test')
 		
 		
@@ -357,6 +390,7 @@ def optimizeChunk(chunk,operation):
 			
 			
 		#print(vcorrected)
+	'''
 	return chunk			
 	
 def limitChunks(chunks,o):#TODO: this should at least add point on area border... but shouldn't be needed at all at the first place...

scripts/addons/cam/image_utils.py

@@ -1182,9 +1182,9 @@ def renderSampleImage(o):
 		resx=ceil(sx/o.pixsize)+2*o.borderwidth
 		resy=ceil(sy/o.pixsize)+2*o.borderwidth
 		
-		#if not o.update_zbufferimage_tag and len(o.zbuffer_image)==resx and len(o.zbuffer_image[0])==resy :#if we call this accidentally in more functions, which currently happens...
+		if not o.update_zbufferimage_tag and len(o.zbuffer_image)==resx and len(o.zbuffer_image[0])==resy :#if we call this accidentally in more functions, which currently happens...
 			#print('has zbuffer')
-			#return o.zbuffer_image
+			return o.zbuffer_image
 		####setup image name
 		#fn=bpy.data.filepath
 		#iname=bpy.path.abspath(fn)
@@ -1280,7 +1280,7 @@ def renderSampleImage(o):
 			r.image_settings.color_mode=cm
 		
 			i=bpy.data.images.load(iname)
-			bpy.context.scene.render.engine='BLENDERCAM_RENDER'
+			bpy.context.scene.render.engine='BLENDER_CAM'
 		a=imagetonumpy(i)
 		a=1.0-a
 		o.zbuffer_image=a

scripts/addons/cam/pattern.py

@@ -33,14 +33,17 @@ def getPathPatternParallel(o,angle):
 	#ar=numpy.array((1.1,1.1))
 	#ar.resize()
 	#if bpy.app.debug_value==0:
+	dirvect=Vector((0,1,0))
+	dirvect.rotate(e)
+	dirvect.normalize()
+	dirvect*=pathstep
 	for a in range(int(-dim/pathd), int(dim/pathd)):#this is highly ineffective, computes path2x the area needed...
 		chunk=camPathChunk([])
-		for b in range(int(-dim/pathstep),int(dim/pathstep)):
-			v.x=a*pathd
-			v.y=b*pathstep
-			
+		v=Vector((a*pathd,int(-dim/pathstep)*pathstep,0))
 		v.rotate(e)
 		v+=vm#shifting for the rotation, so pattern rotates around middle...
+		for b in range(int(-dim/pathstep),int(dim/pathstep)):
+			v+=dirvect
 			if v.x>o.min.x and v.x<o.max.x and v.y>o.min.y and v.y<o.max.y:
 				chunk.points.append((v.x,v.y,zlevel))
 		if (reverse and o.movement_type=='MEANDER') or (o.movement_type=='CONVENTIONAL' and o.spindle_rotation_direction=='CW') or (o.movement_type=='CLIMB' and o.spindle_rotation_direction=='CCW') :

scripts/addons/cam/utils.py

@@ -238,6 +238,7 @@ def sampleChunks(o,pathSamples,layers):
 		zinvert=ob.location.z+maxz#ob.bound_box[6][2]
 	
 	n=0
+	last_percent=-1
 	#timing for optimisation
 	samplingtime=timinginit()
 	sortingtime=timinginit()
@@ -256,8 +257,9 @@ def sampleChunks(o,pathSamples,layers):
 		#for t in range(0,threads):
 			
 		for s in patternchunk.points:
-			if o.strategy!='WATERLINE' and n/200.0==int(n/200.0):
-				progress('sampling paths ',int(100*n/totlen))
+			if o.strategy!='WATERLINE' and int(100*n/totlen)!=last_percent:
+				last_percent=int(100*n/totlen)
+				progress('sampling paths ',last_percent)
 			n+=1
 			x=s[0]
 			y=s[1]
@@ -753,6 +755,7 @@ def doSimulation(name,operations):
 	
 def chunksToMesh(chunks,o):
 	##########convert sampled chunks to path, optimization of paths
+	t=time.time()
 	s=bpy.context.scene
 	origin=(0,0,o.free_movement_height)  
 	verts = [origin]
@@ -761,8 +764,12 @@ def chunksToMesh(chunks,o):
 	progress('building paths from chunks')
 	e=0.0001
 	lifted=True
+	test=bpy.app.debug_value
+	
 	for chi in range(0,len(chunks)):
+		print(chi)
 		ch=chunks[chi]
+		nverts=[]
 		if o.optimize:
 			ch=optimizeChunk(ch,o)
 		
@@ -802,6 +809,8 @@ def chunksToMesh(chunks,o):
 		#print(verts_rotations)
 	if o.use_exact:
 		cleanupBulletCollision(o)
+	print(time.time()-t)
+	t=time.time()
 	
 	#actual blender object generation starts here:
 	edges=[]	
@@ -835,9 +844,10 @@ def chunksToMesh(chunks,o):
 		ob=object_utils.object_data_add(bpy.context, mesh, operator=None)
 		ob=ob.object
 		
+	print(time.time()-t)
+	
 	ob.location=(0,0,0)
 	o.path_object_name=oname
-	verts=ob.data.vertices
 	exportGcodePath(o.filename,[ob.data],[o])
 
 	
@@ -2214,6 +2224,8 @@ def getPath3axis(context,operation):
 			if o.strategy=='OUTLINEFILL':
 				getOperationSilhouete(o)
 			pathSamples=getPathPattern(o)
+			#chunksToMesh(pathSamples,o)#for testing pattern script
+			#return
 			if o.strategy=='OUTLINEFILL':
 				pathSamples=sortChunks(pathSamples,o)