idfk

ContourExctractor.py

@@ -43,6 +43,8 @@ class ContourExtractor:
         frameCount = 0
         extractedContours = dict()
         while res:
+            if frameCount > 25*30*60:
+                break
             res, frame = vs.read()
             # resize the frame, convert it to grayscale, and blur it
             if frame is None:

Layer.py

@@ -15,8 +15,6 @@ class Layer:
         self.data = []
         self.bounds = []
         self.bounds.append(data)
-
-
         #print("Layer constructed")
 
     def add(self, frameNumber, data):
@@ -24,9 +22,10 @@ class Layer:
             self.lastFrame = frameNumber
          
             self.bounds.append(data)
-        
+        self.getLength()
+
     def getLength(self):
-        self.length = len(self.data)
+        self.length = len(self.bounds)
         return self.length
     
     def fill(self, inputPath):

LayerFactory.py

@@ -12,9 +12,9 @@ class LayerFactory:
 
     def freeData(self, maxLayerLength):
         self.data.clear()
-        for i in range(len(self.layers)):
+        #for i in range(len(self.layers) - 2):
-            if self.layers[i].getLength() > maxLayerLength:
+            #if self.layers[i].getLength() > maxLayerLength:
-                del self.layers[i] 
+                #del self.layers[i] 
 
 
     def extractLayers(self, data = None):
@@ -27,39 +27,32 @@ class LayerFactory:
             else:
                 self.data = data
 
-        layers = []
         frameNumber = min(data)
         contours = data[frameNumber]
-
         for contour in contours:
-            layers.append(Layer(frameNumber, contour))
+            self.layers.append(Layer(frameNumber, contour))
-
+  
+        oldLayerIDs = []
         # inserts all the fucking contours as layers?
         for frameNumber, contours in data.items():
+            if frameNumber%5000 == 0:
+                print(frameNumber/max(data.keys()))
+
             for (x,y,w,h) in contours:
                 foundLayer = False
-                i = 0
+                for i in set(range(0, len(self.layers))).difference(set(oldLayerIDs)):
-                for i in range(0, len(layers)):
+                    if frameNumber - self.layers[i].lastFrame > 10:
-                    layer = layers[i]
+                        oldLayerIDs.append(i)
-
-                    if len(layer.bounds[-1]) != 4:
-                        # should never be called, hints at problem in ContourExtractor
-                        print("LayerFactory: Layer knew no bounds")
                         continue
 
-                    if frameNumber - layer.lastFrame <= 5:
+                    (x2,y2,w2,h2) = self.layers[i].bounds[-1]
-                        (x2,y2,w2,h2) = layer.bounds[-1]
+                    if self.contoursOverlay((x-tol,y+h+tol), (x+w+tol,y-tol), (x2,y2+h2), (x2+w2,y2)):
-                        if self.contoursOverlay((x-tol,y+h+tol), (x+w+tol,y-tol), (x2,y2+h2), (x2+w2,y2)):
+                        self.layers[i].add(frameNumber, (x,y,w,h))
-                            foundLayer = True
+                        foundLayer = True
-                            layer.add(frameNumber, (x,y,w,h))
+                        break
-                            break
+
-                            
-                    layers[i] = layer
                 if not foundLayer:
-                    layers.append(Layer(frameNumber, (x,y,w,h)))
+                    self.layers.append(Layer(frameNumber, (x,y,w,h)))
-
-        self.layers = layers
-
 
     def contoursOverlay(self, l1, r1, l2, r2): 
       

main.py

@@ -13,16 +13,20 @@ def demo():
     maxLayerLength = 1*60*30
     start = time.time()
 
-    footagePath = os.path.join(os.path.dirname(__file__), "./generate test footage/out.mp4")
+    footagePath = os.path.join(os.path.dirname(__file__), "./generate test footage/3.mp4")
     contours = ContourExtractor().extractContours(footagePath, resizeWidth)
     print("Time consumed in working: ", time.time() - start)
     layerFactory = LayerFactory(contours)
+    print("freeing Data", time.time() - start)
     layerFactory.freeData(maxLayerLength)
+    print("sort Layers")
     layerFactory.sortLayers()
+    print("fill Layers")
     layerFactory.fillLayers(footagePath)
     underlay = cv2.VideoCapture(footagePath).read()[1]
-    Exporter().exportLayers(underlay, layerFactory.layers, os.path.join(os.path.dirname(__file__), "./short.mp4"), resizeWidth)
+    Exporter().exportOverlayed(underlay, layerFactory.layers, os.path.join(os.path.dirname(__file__), "./short.mp4"), resizeWidth)
     print("Total time: ", time.time() - start)
+
 def init():
     print("not needed yet")