added stats, programm hangs after finishing

Application/Exporter.py

@@ -41,8 +41,8 @@ class Exporter:
 
         start = time.time()
         for i, layer in enumerate(layers):
-            print(f"{round(i/len(layers)*100,2)} {round((time.time() - start), 2)}")
-            start = time.time()
+            print(f"{i}/{len(layers)} {round(i/len(layers)*100,2)}% {round((time.time() - start)/(i+1), 2)}")
+            
             if len(layer.bounds[0]) == 0:
                 continue
             
@@ -71,10 +71,11 @@ class Exporter:
                     
                     frame2[y:y+h, x:x+w] = np.copy(frame[y:y+h, x:x+w])
                     cv2.putText(frame2, str(i) + "  " + str(int(frameCount/self.fps)), (int(x+w/2), int(y+h/2)), cv2.FONT_HERSHEY_SIMPLEX, 1,(255,255,255), 2)
+                cv2.putText(frame2, str(layer.stats["avg"]) + "  " + str(layer.stats["var"]) + "  " + str(layer.stats["dev"]), (int(500), int(500)), cv2.FONT_HERSHEY_SIMPLEX, 1,(255,0,255), 2)
                 writer.append_data(frame2)
 
-
             videoReader.thread.join()
+        writer.close()
         
 
     def exportOverlayed(self, layers):

Application/Layer.py

@@ -32,6 +32,8 @@ class Layer:
         self.config = config
         self.data = []
         self.bounds = []
+        self.stats = dict()
+
         self.bounds.append([data])
         #print("Layer constructed")
 
@@ -44,6 +46,37 @@ class Layer:
             self.lastFrame = frameNumber
             self.bounds.append([bound])
 
+    def calcStats(self):
+        middles = []
+        for i, bounds in enumerate(self.bounds):
+            for j, bound in enumerate(bounds):
+                if None in bound:
+                    continue
+                x = (bound[0] + bound[2]/2) 
+                y = (bound[1] + bound[3]/2) 
+                middles.append([x,y])
+        
+        avgx = 0 
+        avgy = 0
+        for i in range(1, len(middles), 2):
+            avgx += float(middles[i][0]-middles[i-1][0])/len(middles)
+            avgy += float(middles[i][1]-middles[i-1][1])/len(middles)
+        self.stats = dict()
+        self.stats["avg"] = [round(avgx,2), round(avgy, 2)]
+
+        x=0
+        y=0
+        for i in range(0, len(middles)):
+            x += (float(middles[i][0]) - avgx)**2
+            y += (float(middles[i][1]) - avgy)**2
+
+        x /= (len(middles)-1) 
+        y /= (len(middles)-1)
+
+        self.stats["var"] = [round(x,2),round(y, 2)]
+        self.stats["dev"] = [round(x**(1/2), 2), round(y**(1/2),2)]
+        
+
     def getLength(self):
         return len(self)
 
@@ -78,25 +111,17 @@ class Layer:
         kmeans = None
 
         # the loop isn't nessecary (?) if the number of clusters is known, since it isn't the loop tries to optimize
-        while True:
-            kmeans = KMeans(init="random", n_clusters=clusterCount, n_init=10, max_iter=300, random_state=42)
-            kmeans.fit(mapped)
-            labels = list(kmeans.labels_)
 
-            if kmeans.n_features_in_ < clusterCount:
-                break
+        kmeans = KMeans(init="random", n_clusters=clusterCount, n_init=10, max_iter=300, random_state=42)
+        kmeans.fit(mapped)
+        labels = list(kmeans.labels_)
 
-            maxm = 0
-            for x in set(labels):
-                y = labels.count(x)
-                if y > maxm:
-                    maxm = y
+        maxm = 0
+        for x in set(labels):
+            y = labels.count(x)
+            if y > maxm:
+                maxm = y
 
-            if maxm > len(mapped)*(noiseSensitivity) and clusterCount+1<=len(kmeans.cluster_centers_):
-                clusterCount += 1
-            else: 
-                centers = kmeans.cluster_centers_
-                break
 
         # transformes the labels array
         # new array:

Application/LayerManager.py

@@ -24,12 +24,17 @@ class LayerManager:
 
 
 
-    def cleanLayers(self):
+    def transformLayers(self):
         print("'Cleaning' Layers")
         self.freeMin()
         self.sortLayers()            
         #self.cleanLayers2()
         self.freeMax()
+        self.calcStats()
+
+    def calcStats(self):
+        for layer in self.layers:
+            layer.calcStats()
 
     def removeStaticLayers(self):
         '''Removes Layers with little to no movement'''

main.py

@@ -36,7 +36,7 @@ def main():
         #layers = layerFactory.extractLayers(contours)
 
     layerManager = LayerManager(config, layers)
-    layerManager.cleanLayers()
+    layerManager.transformLayers()
 
     #layerManager.tagLayers()
     layers = layerManager.layers
@@ -45,6 +45,7 @@ def main():
     exporter.export(layers, contours, raw=True, overlayed=False)
     
     print("Total time: ", time.time() - start)
+    exit(0)
 
 if __name__ == "__main__":
     main()