style and efficiency

Application/Exporter.py

@@ -1,3 +1,4 @@
+from Application.Config import Config
 from Application.Layer import Layer
 from Application.VideoReader import VideoReader
 from datetime import datetime
@@ -82,6 +83,7 @@ class Exporter:
         maxLength = self.getMaxLengthOfLayers(layers)
         underlay = cv2.VideoCapture(self.footagePath).read()[1]
         underlay = cv2.cvtColor(underlay, cv2.COLOR_BGR2RGB)
+        #underlay = np.zeros(shape=[videoReader.h, videoReader.w, 3], dtype=np.uint8)
         frames = []
         for i in range(maxLength):
             frames.append(np.copy(underlay))
@@ -99,6 +101,7 @@ class Exporter:
             for layer in layers:
                 if layer.startFrame <= frameCount and layer.startFrame + len(layer.bounds) > frameCount:
                     for i in range(0, len(layer.bounds[frameCount - layer.startFrame])):
+                        try:
                             underlay1 = underlay
                             (x, y, w,
                             h) = layer.bounds[frameCount - layer.startFrame][i]
@@ -125,7 +128,8 @@ class Exporter:
                                 int(frameCount/self.fps) + videoReader.getStartTime())
                             cv2.putText(frames[frameCount - layer.startFrame], f"{time.hour}:{time.minute}:{time.second}", (int(
                                 x+w/2), int(y+h/2)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
-
+                        except:
+                            continue
         videoReader.thread.join()
         videoReader.vc.release()
 

Application/Layer.py

@@ -88,7 +88,7 @@ class Layer:
         overlap = False
         maxLen = min(len(layer2.bounds), len(self.bounds))
         bounds = self.bounds[:maxLen]
-        for b1s, b2s in zip(bounds, layer2.bounds[:maxLen]):
+        for b1s, b2s in zip(bounds[::10], layer2.bounds[:maxLen:10]):
             for b1 in b1s:
                 for b2 in b2s:
                     if self.contoursOverlay((b1[0], b1[1]+b1[3]), (b1[0]+b1[2], b1[1]), (b2[0], b2[1]+b2[3]), (b2[0]+b2[2], b2[1])):
@@ -98,10 +98,10 @@ class Layer:
     
     def timeOverlaps(self, layer2):
         '''Checks for overlap in time between current and given layer'''
-        s1 = self.startFrame
-        e1 = self.lastFrame
-        s2 = layer2.startFrame
-        e2 = layer2.lastFrame
+        s1 = self.exportOffset
+        e1 = self.lastFrame - self.startFrame + self.exportOffset
+        s2 = self.exportOffset
+        e2 = layer2.lastFrame - layer2.startFrame + self.exportOffset
 
         if s2 >= s1 and s2 <= e1:
             return True

Application/LayerFactory.py

@@ -125,7 +125,7 @@ class LayerFactory:
                                     merge.add(indexes[lc2])
             merge = list(merge)
             if len(merge) > 1:
-                self.mergeLayers(megre)
+                self.mergeLayers(merge)
             i = innerMax
 
     def getPossibleLayers(self, t):

Application/LayerManager.py

@@ -8,6 +8,7 @@ import cv2
 import numpy as np
 import time
 
+
 class LayerManager:
     def __init__(self, config, layers):
         self.data = {}
@@ -71,7 +72,8 @@ class LayerManager:
         exporter = Exporter(self.config)
         start = time.time()
         for i, layer in enumerate(self.layers):
-            print(f"{round(i/len(self.layers)*100,2)} {round((time.time() - start), 2)}")
+            print(
+                f"{round(i/len(self.layers)*100,2)} {round((time.time() - start), 2)}")
             start = time.time()
             if len(layer.bounds[0]) == 0:
                 continue
@@ -104,20 +106,19 @@ class LayerManager:
         self.layers.sort(key=lambda c: c.startFrame)
 
     def calcTimeOffset(self):
+        lenL = len(self.layers)
         for i, layer in enumerate(self.layers):
+            print(
+                f"\r {i}/{lenL}", end='\r')
             overlap = True
             while overlap:
                 overlap = False
-                for l in self.layers[i:]:
-                    if layer.timeOverlaps(l):
-                        if layer.spaceOverlaps(l):
+                for l in self.layers[:i:-1]:
+                    if layer.timeOverlaps(l) and layer.spaceOverlaps(l):
                         overlap = True
-                if overlap:
-                    self.addDelay(i, 10)
-                    
-                if self.layers[i].exportOffset >= 180:
                         break
+                if overlap:
+                    self.layers[i].exportOffset += 20
 
-    def addDelay(self, index, frames):
-        for layer in self.layers[index:]:
-            layer.exportOffset += frames
+                if self.layers[i].exportOffset >= 30000:
+                    break

main.py

@@ -15,7 +15,7 @@ def main():
     startTotal = time.time()
     config = Config()
 
-    fileName = "x23-1.mp4"
+    fileName = "x23.mp4"
     outputPath = os.path.join(os.path.dirname(__file__), "output")
     dirName = os.path.join(os.path.dirname(__file__), "generate test footage")