From 68c730ff6ec15d81f4232adb42369e1d0e02afe8 Mon Sep 17 00:00:00 2001
From: Askill <ofjokg@gmail.com>
Date: Thu, 8 Oct 2020 22:26:29 +0200
Subject: [PATCH] video reader object

---
 ContourExctractor.py                         |  84 ++++++++-----------
 LayerFactory.py                              |  13 +--
 VideoReader.py                               |  70 ++++++++++++++++
 __pycache__/Analyzer.cpython-37.pyc          | Bin 430 -> 1322 bytes
 __pycache__/ContourExctractor.cpython-37.pyc | Bin 3956 -> 3606 bytes
 __pycache__/LayerFactory.cpython-37.pyc      | Bin 2372 -> 3015 bytes
 main.py                                      |   6 +-
 7 files changed, 110 insertions(+), 63 deletions(-)
 create mode 100644 VideoReader.py

diff --git a/ContourExctractor.py b/ContourExctractor.py
index aa4ffab..f075177 100644
--- a/ContourExctractor.py
+++ b/ContourExctractor.py
@@ -14,6 +14,7 @@ from threading import Thread
 from multiprocessing import Queue, Process, Pool
 from multiprocessing.pool import ThreadPool
 import concurrent.futures
+from VideoReader import VideoReader
 
 class ContourExtractor:
 
@@ -32,61 +33,43 @@ class ContourExtractor:
         print("ContourExtractor initiated")
 
     def extractContours(self, videoPath, resizeWidth):
-
-
-        # initialize the first frame in the video stream
-        vs = cv2.VideoCapture(videoPath)
-
-        res, image = vs.read()
-        self.xDim = image.shape[1]
-        self.yDim = image.shape[0]
         firstFrame = None
-        # loop over the frames of the video
-        frameCount = -1
-        extractedContours = dict()
-        
-        results = []
-        extractedContours = dict()
+        extractedContours = dict()        
+        videoReader = VideoReader(videoPath)
+        self.xDim = videoReader.w
+        self.yDim = videoReader.h
+        videoReader.fillBuffer()
 
-        imageBuffer = []
-        
-        with concurrent.futures.ProcessPoolExecutor() as executor:
-            while res:
-                frameCount += 1
-                if frameCount % (60*30) == 0:
-                    print("Minutes processed: ", frameCount/(60*30))
-                
+        while not videoReader.videoEnded():
+            frameCount, frame = videoReader.pop()
+            if frameCount % (60*30) == 0:
+                print("Minutes processed: ", frameCount/(60*30))
+            
+            if frame is None:
+                print("ContourExtractor: frame was None")
+                continue
 
-                res, frame = vs.read()
-                # resize the frame, convert it to grayscale, and blur it
-                if frame is None:
-                    print("ContourExtractor: frame was None")
-                    break
+            # resize the frame, convert it to grayscale, and blur it
+            frame = imutils.resize(frame, width=resizeWidth)
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
-                frame = imutils.resize(frame, width=resizeWidth)
-                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
+            # if the first frame is None, initialize it
+            if firstFrame is None:
+                #gray = np.asarray(gray[:,:,1]/2 + gray[:,:,2]/2).astype(np.uint8)       
+                gray = cv2.GaussianBlur(gray, (5, 5), 0)
+                firstFrame = gray
+                continue
+            x = self.getContours(gray, firstFrame)
+            if x is not None:
+                extractedContours[frameCount] = x
 
-                # if the first frame is None, initialize it
-                if firstFrame is None:
-                    gray = np.asarray(gray[:,:,1]/2 + gray[:,:,2]/2).astype(np.uint8)       
-                    gray = cv2.GaussianBlur(gray, (5, 5), 0)
-                    firstFrame = gray
-                    continue
-
-                results.append(executor.submit(self.getContours, frameCount, gray, firstFrame))
-
-                #contours = self.getContours(frameCount, gray, firstFrame)
-
-            for f in concurrent.futures.as_completed(results):
-                x=f.result()
-                if x is not None:
-                    extractedContours = {**extractedContours, **x} 
-        
+        print("done")
+        videoReader.thread.join()
         self.extractedContours = extractedContours
         return extractedContours
             
-    def getContours(self, frameCount, gray, firstFrame):
-        gray = np.asarray(gray[:,:,1]/2 + gray[:,:,2]/2).astype(np.uint8)       
+    def getContours(self, gray, firstFrame):
+              
         gray = cv2.GaussianBlur(gray, (5, 5), 0)
         frameDelta = cv2.absdiff(gray, firstFrame)
         thresh = cv2.threshold(frameDelta, self.threashold, 255, cv2.THRESH_BINARY)[1]
@@ -104,10 +87,9 @@ class ContourExtractor:
             #print((x, y, w, h))
             contours.append((x, y, w, h))
 
-        if len(contours) != 0: 
-            return {frameCount: contours}
-        else:
-            return None
+        if len(contours) != 0 and contours is not None: 
+            return contours
+
 
     def displayContours(self):
         values = self.extractedContours.values()
diff --git a/LayerFactory.py b/LayerFactory.py
index d95d5fe..d19ee38 100644
--- a/LayerFactory.py
+++ b/LayerFactory.py
@@ -53,10 +53,8 @@ class LayerFactory:
         # inserts all the fucking contours as layers?
         for frameNumber, contours in data.items():
             if frameNumber%5000 == 0:
-                print(f"{round(frameNumber/max(data.keys()), 2)}% done with Layer extraction")
+                print(f"{int(round(frameNumber/max(data.keys()), 2)*100)}% done with Layer extraction")
 
-        for frameNumber in sorted(data):
-            contours = data[frameNumber]
             for (x,y,w,h) in contours:
                 foundLayer = False
                 for i in set(range(0, len(self.layers))).difference(set(oldLayerIDs)):
@@ -85,15 +83,10 @@ class LayerFactory:
 
     def fillLayers(self, footagePath, resizeWidth):
         for i in range(len(self.layers)):
+            if i % 20 == 0:
+                print(f"filled {int(round(i/len(self.layers),2)*100)}% of all Layers")
             self.layers[i].fill(footagePath, resizeWidth)
 
     def sortLayers(self):
         # straight bubble
         self.layers.sort(key = lambda c:c.lastFrame)
-
-
-
-
-                
-            
-        
diff --git a/VideoReader.py b/VideoReader.py
new file mode 100644
index 0000000..8020441
--- /dev/null
+++ b/VideoReader.py
@@ -0,0 +1,70 @@
+
+import multiprocessing
+import cv2
+from time import sleep
+from queue import Queue
+import threading
+class VideoReader:
+
+    #buffer = [(frameNumber, frame)]
+
+    def __init__(self, videoPath):
+        if videoPath is None:
+            print("Video reader needs a videoPath!")
+            return None
+
+        self.videoPath = videoPath
+        self.lastFrame = 0
+        self.buffer = Queue(16)
+        self.vc = cv2.VideoCapture(videoPath)
+        self.stopped = False
+        res, image = self.vc.read()
+        self.w = image.shape[1]
+        self.h = image.shape[0]
+        
+        print(f"Video reader startet with buffer length of 16")
+        
+
+    def pop(self):
+        return self.buffer.get(block=True)
+
+    def get(self):
+        return self.buffer[-1]
+
+    def fillBuffer(self):
+        if self.buffer.full():
+            print("VideoReader::fillBuffer was called when buffer was full.")
+        self.endFrame = int(self.vc.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.endFrame = 10*60*30
+        self.thread = threading.Thread(target=self.readFrames, args=())
+        self.thread.start()
+
+    def stop(self):
+        self.thread.join()
+        self.vc.release()
+
+    def readFrames(self):
+        while self.lastFrame < self.endFrame:
+            if not self.buffer.full():
+                res, frame = self.vc.read()
+                if res:
+                    self.buffer.put((self.lastFrame, frame))
+                self.lastFrame += 1
+            else:
+                sleep(0.5)
+        self.stopped = True
+    
+    def videoEnded(self):
+        if self.stopped:
+            return True
+        else:
+            return False
+        
+
+
+
+
+
+        
+
+
diff --git a/__pycache__/Analyzer.cpython-37.pyc b/__pycache__/Analyzer.cpython-37.pyc
index 405b5718706641c5ffe7b672daabc6d742e3472a..31b382ebec61ad7d2812925034ef7b8782d7eaf5 100644
GIT binary patch
literal 1322
zcmZWpJ8v8}5GJ|L+uPN{HiQIe)Wz4hFbo7Z1c4<vu?^U=AO#7s5U}7aDQTsBiR8(-
z!!A<DZTggVW&TZSwkZO&L8>&#kmm~ogaqfC;c$n;Z^+$Gk_bWDd+}5Dhl|kf##lE8
zl;<$y90WrQm#D%i#zrS4Nr^=#bu7B6Ytc(Ri+<``4AQ`2n1&Vy>A+%?Miz%@Y%!@e
z(oKwBBIYpn17hwiNw*j|K_l-D_D3VEhu;;9Hz!JPS{>$Qa@`0h&tb?%AUH}fLy#V3
z<O72A90=m-aIdE2Y|ce)R-3i~!-sJIL;eXu!69$qfE`-k4li*}6j?Y{a~SE}&RMui
zbV_=!hr{&&bNcWc^@AUO={)h<J#W-`^5_UD@6zug<}&YR(nk<0=s;eEOVSTJpyetQ
z^KRG&*JJPvI+z1b40_bXoy&Y!J6yUf_!RX?H(10fS!{I45;B7vLl%62`VcVO0n)CB
z7(@O8V}FKj2}alB?~&SEY;^;(9<*&1ebgQ-ktrkaGCZ6=S`)LIH?>q^nk&xk65vB%
z5XE00fqn0N!PLdwKQMJ?=feP@`NOwGJyl%pwxY?ol$?!s=do-mzFSYL2^VtoP<yQ?
zYLyP5aO`!hnzy{tPJZ)L$F`yev{h5VwQKx3D5|L{N~wLpWijVE%x}~|Q#L{;2k+jz
zJI?lB9zT7vx32>_k*qj7(*tz@YcHCT>Ezp2$6uek%JyF$?j8T2ecHCXW}4KkPV#12
ztE_HnxCD)M+EQt^EgO~kvyx7Dsa=TiezXC|ONe@7uG<k+7usc1QB7{7j?7kcwU+~%
zYOkp1IoHuyA*A|7(28qZzy~HT@66inxu7#xVT>2Ngh>7>;a`#X9O(S}aXvl;{w{g0
z<f$rvyS%Adh%Sq!K3$jRNjuYFmKAlOvTPH+lg~gP9O8&X*u^mn(|xNEya7D~n}EH8
zw?L2a11G`}o^Ssba~<!{ypSxbA;m1yQI=H=o0dk8v+R0G%auorU`LzuJ@MGgnZJd3
zP}01v5L<h+t&@+{d}7HI#;HRp&RZ%Zlooj9=D;F04%ey!qmo8KSq07cgyvT|$Sm*n
zb^zT)qdmA@?M#>lpKe!FnL?Ju1V~zybcJFE{5F?+`5MlJNm_?ru8#SYxzO?x5HZm7
I{~nWn0akHkasU7T

delta 247
zcmZ3*wT_w3iI<m)0SE+MR>ns#OyrZ05CZbt8B!Qh7+Zk2nJJ1Pg(;XplX>E9=MW~K
z90)rDaWM~&C;=&9WCSV)Dq-@g5^>B+%&DwOEmBC%&nqq|Dorj)P0?h$#ad95nOCC8
zbc>}pH76~KJuN@KBr!d8B|{O*<Ys1bE|8(cAcA4?H)fj{HXx&j1(je0aT$RG2!qvf
dFoOAhnh+YBhFcsqx%nxjIjMFaU7vxN0RY0AFPi`W

diff --git a/__pycache__/ContourExctractor.cpython-37.pyc b/__pycache__/ContourExctractor.cpython-37.pyc
index 49b7ae754b9b5cb0999bacc7c12e4699bdcdf9c3..e56e16b1f3925a2b39f0bb12acc485bd067407d0 100644
GIT binary patch
delta 1834
zcmZux&2QX96rUM?tk>T4rb$RrB@LyYxRh2@r7EQqnzRjvDlMr5!W5QO?4;iH+S{>r
zyQ#)niEsg_h{zJ+xGN#`KR}!~ApQUjh{K$E;8MX62?_D_o)=QJsxANK&3n%?@4flG
z`EBuw1$(JlH3>Yua8UoFwqwuHuXm1KdCu^N$HKB(E=JQei_vl`#i+U3&S$6hgRF<M
z?OAu0k`>~WJmX{H8QaXA^VkjIly`o*Tyv<j-VQuJUh^BC&+~cuDf_UU->27THUFJn
zrTg+r?4!jBgutu2V1p!$dOe7Ov|itz|IAJdFiZ`;W%!Z@03OMdlx&ksO{t*UG}DCE
zWP;Qc7*!ZyKGa8qlKz(<l}04_4n|`{Zn8|zN<#PO45Zm&+)c}#g7bN@%_tEikF*RP
zf>zz8l-xd^nuDe#N`iUXJ(iWy%CIT`oA!uhhENLkuRvQ9hNpXMq=44Ql-tJz8BPfB
z0Kc+;YPQP!xF`!%=;vYCcL;1z!Yv@=J;O;17Hp(GB~+-Ou^Jd9C=7*c^KaBQ1`d0O
zCE!y4QuX4<ccx(s)>Cevir$fG|5DJF^p;e&Kyb~CAPkqf8yh}%%^n`a<;e3rsdVBF
zpTK`gLA#p<VIp<zC&67`D(k&duCd-rm*X(zuDyKi>b14{(#qPYGb?Ks-<6e>MmI@<
zMzj=mxwJNYaE#Kp%VCN17Kd||YBLTZZo%@7$t(Gv+WbI5Bs@v4@J8D&EUs0AGv)=v
ziH7C48>Lb!WT|fQ#+Ic0CwWox`zdd%@9ugKwn<I{5UNt08snFlv;wcqaL$w&o7#%O
zY;a+qHfRM5Ce0t{hX)G&3lH)S$~|V-k07LE2+Z<maiA1tOi;n#D1moFMJR$aRS)E*
zHc~xxFEWudb)iCIXr6vg!TGQxROB33%J7*$4K1~X6`_rQv702*2mR|pyF}i96L>|C
zS6~44z~Xj`Bw-=dS}Onib_n(fwBJ;-a%N^$RuTGe5AewpmZ)r~BP44GteO=1HiX?$
z_zys9WF3q*pk;tnrB#O&3>pJ<Ak&BcARx~kVl^D<nnCLGMjFIX;!N><pyZ4BCq_c&
z^S_LX^HOhgI(`I13jN5b@}hwcqu0Uwz4FP`BOpq;#b;18hwylJ^JhV~0$;KSK;U31
zbdF8X8EP^W4#uR@a8Q$MhE3DE3;A_6o&Q>vM={o-9r!Vj9458oR-@xf%}cjBen1$;
z&L{I<%!N0eM-RK;n$&xZu<Iw1MIEW#^?97|y|~mYfYiD{l%D1Ds8~RF8DU?3#X7cH
z<aHLkSidh>?<J0zairU$+$8PsL#TN?M_KcNq!Tu_{_l?u@^7ub2T$fO-tG+izZ*Zu
zj#Wg?ac}+#!a0Q9sQIfneIn+Qpo1SD1+5pYl<@QD{2IcMLVP@aegQ2{%fR;gotW>o
zS}VU(-5flF-q_syMT8RwFCbtw#}U?0+JkTu0S}wMj&Kp-QJD$}Z+l(_z-ui*vKWdE
zjr!lq3<cgp#;j2-yqL2$uiMTP<}TGVfcpgLDOsH4_w7YXi@NR3R#CJ3d%J$lHP_>4
jz00{DjjzdKm8S(Ejq~l;>xTXX?1bb%{#NaP0yo9KABUUg

delta 2100
zcmah~&2QX96rUM?uGhOslQbXAHcbnqT0ki+rR|}#bkinORBcElQmn#iSv#qd{mR%5
zn`+z@4P1~4jV$%Nd*#qSf-?uiaSj}~MdAPgi4&CfyiJ;-O4yp;ym{}<n>RD>XFo3d
zIh8Nvau$JS;jhiIH?*A}r{8U#m^+$riOXu1W2Jr8$)>&S*lBM%neA`RjLZ{Pca1NJ
zYiu!R%w@Mo(cJ#!YI2r-&2CR7-_x7aPKMZZT1d+5!BiHO;r1TnK$2#;>^J<dTt1RK
zWiy>Y&}E>_LJRIwLPFA|g7#>v2&Kz<<PM9~SQFZ+;?fBsNLfu~mdct-V%=3@Bh<G@
zY_5<vvnN@hv1)cRJ@SZtJ054-KMVB{<!6QA(sLv>pjSsp$7O4bKL{;XL&YT7VwCJ#
z*cPz=HIsM2L*Js5ERZm}3R=Nj;~|S}NH-?{SMxm<=Y)>luuLHw=nje;oE`a!Jwv*z
zOc2+cB>VIoG@HAIG18;m1L45x5bQq(p@+dW<FcLtp>wgm?ublxL}a@M1z8;xhJXco
zY7f#{ca})|t#rp@BGaQ+$S2crUgW#uJrWOy0Z1zYY0U{!3_NBrq_{q}M3%@2mwZST
z$!!7#Ql1bd+^BV92kwDzgq^4G_@<E*)lz4Nfu_iIG_)Q>`H)nq8>glHk?(rV*-9&n
zxF=QaRa~hBcPlLzw6FMescxp|`qfZc)n=m_aqcxj$5@VVO5hAH@MhHuf`w+YcD3zQ
zqp->O04yO5zaE8tEs%N#9Q}KqV^%l9*=DWDo!sor>o*t6rTN9v*DseOYqX?M2`Zdd
zHl<z(!c9m(i~L4-UfT1OC<y#Yqg0DH7+Wo`;W~N{eOC8FnO*T9WFu@wJaFtvP_8!X
zt(q5luGC@Gs1|aI=&<2Io=v8;$(qA90;zyWYJR=4;z?`S=Rr8fD|M8yn{7r7oQ8Yo
z#|WHk>RgJJmp$&7-m{HLEuA3M6-=BiOWNMgn&b;@<k~Ta6O;gmYB8JQt1^}9{l@at
zgx98d#bzim(Bu`1mS~=;Fe<1+pta~YOMcXjcT@}nPac{9EoI;MF8g*1wqLycvSm=V
zFX~xZwV+R{mH`D6s9F}PT@5@HSB0v@kuI1}fE+5whESn$&5o;u>T0H^BBf)LEdf-<
zZ_7gk$K9;Zx^|C%B?m1Jq4bndIxL|B&5ibg(4olRk4^ACAWYC_L<WKnt&!kKDh;ox
z{HOINU>`yI9W}P%Y-|ISZW+KJOJsq@x#d28o-C0N7_~)Rbxi@L3<@d?pWcEq=(nPI
zgCBsS;v)b>mezkC`aDVg*2fBCd>UPjBH)ejR}e-KUQG%{K&O&N#^uBOIB29&^BToG
zPd}1xqRUByH<DkClQXB#fkH8SF6rI<#egoa0o;Zb;1UGxIQhUlq(TX>WX1gLc$y_9
z#m@jhsuR#j%|$x+gn^3k;pBd%aOrKd=leCPZ&YfL7o;1I+C7gq13rmC4k4ubm_q3Y
z0!HMciOjryBTXL*Q?hnjvW-(5bLa0OTtv8pHoC!QaPXg>!GP-rty*PsmwT;b(fX(J
z(hczUVE$hEAQ!V~;vCoRA3Ij@|KyAZ4-=m!t*6ur_!XRc72(tc#254DbEtdS4)R{R
z)#Q60k2uNND^3Buk@@@_!g+*u5Yn?uPZgQR@#n`+BjA<td4y{S&yOjU@W;tbfT83E
zd(u8@j+?o3TpUmSu!~3VVx$`SbuX<o$(rz8YDD$cW_mEm$=p=(aqiO@et0*~%T|!)
Vg?iJCYTiXGo?trpJ$H<<e*u(`>Fodj

diff --git a/__pycache__/LayerFactory.cpython-37.pyc b/__pycache__/LayerFactory.cpython-37.pyc
index 84f01634ea423aff1b80452774d50c54f8d9ee83..def7d127ed3e829fad1646e6dd5abb695350ef5d 100644
GIT binary patch
literal 3015
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

delta 1194
zcmY*YOK%)S5bo~jc|Uf&8QHOk&>8~L27+?n0wjn8V}#^{L`Jd{5yIe}UB|nbiF-P*
z4&5@+<`xbK{Regh7led_xFdv+$REgM{(%p0;K&84XPpP#n(C@=>d{qQ^~ciho#a9s
z2MAXB=l=EYf(OZ`c;i8N{EZf~7`=<HI?QIyU3ArDZRRo$5RdsR0K{h@i{K1c%n~?5
zMmAAz;ircL9}wdamUZ;K3upBX5Q%ot6weSw<1>N?3uHRM6TF75J+Fw7Bw0pNdxj()
zQob@r&Y``PEyNJ`$Cr8zcfeC^Z;$ef*EY|JL0(&<yr`W~wx9E=zUU8fv5^-8vD34-
zXS9=>*?7bJox?T0!F|Bz#1x?R`aI9qGLgj~RmKS60H?U41zk-#AR4tMldtr*^z^|1
zDGM@y+bb%uq{~Rz;}g<`TvFvoYf6PJsdOe}hB4Y(+d}v8cu_dUVh#9f-ZOUpG<JV~
zOqHuV<*R@Z6*5aj<6ni#Ea6ED>O{czk1CRujF#U+Dh4>-^%;boU}g_3{!kF+OiZ{b
zgpPNE<A}LKd>`}m$C?l#Q7zS03ldF3{hR&LK_XjnVF~q#Ok{fr$yT4tsIg(53S~Tv
zz?UmM>C2!`X9T0mNXF(8XCclOl3^vEr29ngC~dig_I5xAp89&+JfVN-&PwwX>)Ey_
z`F>Y_;>2gyIfn8c{tN4n0(a+yXLa7}Hd1$3<X?1)vin(iyI>VJiXZh7{e!czT|3#W
zTY15_X};R2N-lE7&13SULFP8KKguex&a<0&-P$e-QQqd&ho9$sl<n76#u#sbcCXX4
z&AihrQH~l^pLe^uaF;{V4YdsxIoJ2xlkcY>S8oGB*dYP-U{m4{YB-Qns{>pIQ`jjW
z9pYg^+JIbW5JDn2yF~xx-Xn)tf9ah$b^@H8H*TBhw7QsD`WNrT|BaSOziG%<ff>In
zkial7<Y=JMW}rwjP|&7L6Skj@5q(;lCb^pSZ;VEd=OyfyrN{>P<xK2wlkU;D=%4*G
zx@hiYf+L*jM}CE$(;oz@cvBC9bGW6y4_?7n^rPSuj=l*`oiz32i-v@T95ci<#H7ey
dGvsx>8LlpxFi^N=2ae|kr@hFd`s?tm{{U7e3@HEr

diff --git a/main.py b/main.py
index fd16202..05d607b 100644
--- a/main.py
+++ b/main.py
@@ -4,20 +4,22 @@ from ContourExctractor import ContourExtractor
 from Exporter import Exporter
 from LayerFactory import LayerFactory
 from Analyzer import Analyzer
+from VideoReader import VideoReader
 import cv2
 #TODO
 #   finden von relevanten Stellen anhand von zu findenen metriken für vergleichsbilder
 
 def demo():
     print("startup")
-    resizeWidth = 1024
+    resizeWidth = 512
     maxLayerLength = 1*60*30
-    minLayerLength = 3
+    minLayerLength = 30
     start = time.time()
 
     footagePath = os.path.join(os.path.dirname(__file__), "./generate test footage/3.mp4")
     #analyzer = Analyzer(footagePath)
     #print("Time consumed reading video: ", time.time() - start)
+
     contours = ContourExtractor().extractContours(footagePath, resizeWidth)
     print("Time consumed in working: ", time.time() - start)
     layerFactory = LayerFactory(contours)