cleanup vpu_live4.py

vpu/vpu_live4.py

@@ -366,6 +366,38 @@ def _open_cam(obj):
     if obj.fname.startswith("cam_"): 
         obj.fname = "cam_{}".format(df)
 
+def calc_dim(dim=1,rgb=[255,255,255]):
+    rgb[0] = int(rgb[0]*dim/255)  
+    rgb[1] = int(rgb[1]*dim/255)  
+    rgb[2] = int(rgb[2]*dim/255)  
+    return rgb
+
+def draw_media_background(wn,x,y,w,h,rgb):
+    hx=int(w/2)
+    hy=int(h/2)
+
+    p1 = [x-hx ,y-hy] # links oben
+    p2 = [x+hx ,y+hy] # recht unten
+    p3 = [x+hx ,y-hy] # rechts oben
+    p4 = [x-hx ,y+hy] # links unten
+
+    bg_on=0
+    if bg_on:
+        #pygame.draw.rect(wn,rgb    ,[p1[0]  ,p1[1]  ,__xw  ,__yw])
+        #pygame.draw.rect(wn,[25,20,20],[p1[0]+1,p1[1]+1,hx-2,hx-2])
+        pass
+
+    # frame border
+    pygame.draw.line(wn,rgb ,p1  ,p3) # top
+    pygame.draw.line(wn,rgb ,p2  ,p3) # right
+    pygame.draw.line(wn,rgb ,p2  ,p4) # bottom
+    pygame.draw.line(wn,rgb ,p1  ,p4) # right
+
+    # cross lines
+    pygame.draw.line(wn,rgb ,p1  ,p2) # tl - br
+    pygame.draw.line(wn,rgb ,p3  ,p4) # tr - bl
+
+
 class PixelMedia():
 
     def __init__(self,dmx=None,_id=None):
@@ -406,8 +438,28 @@ class PixelMedia():
         self.shape_x = 370
         self.shape_y = 235
 
+        self.dmx_change = 0
+        self.frame_change = 0
         self.init()
 
+
+    def update_dmx(self,x,y,scale,angle,dim):
+        if int(self.x*100) != int(x*100):
+            self.x = x
+            self.dmx_change = 1
+        if int(self.y*100) != int(y*100):
+            self.y = y
+            self.dmx_change = 1
+        if int(self.scale*100) != int(scale*100):
+            self.scale = scale
+            self.dmx_change = 1
+        if int(self.angle*100) != int(angle*100):
+            self.angle = angle
+            self.dmx_change = 1
+        if int(self.dim*100) != int(dim*100):
+            self.dim = dim
+            self.dmx_change = 1
+
     def __repr__(self):
         sizeof = int(sys.getsizeof(self.buffer)/8)
         return "< id:{} buf:{} run:{} fps:{} scale:{} name:{} {}kb>".format(
@@ -430,6 +482,8 @@ class PixelMedia():
         self.buffer = []
         self._init()
         self.init_count = 1
+        self.dmx_change = 0
+        self.frame_change = 0
 
     def select_video(self,dmx_value):
         try:
@@ -469,13 +523,18 @@ class PixelMedia():
         if self._stop:
             return
 
+
         if self.fname.endswith(".jpg"): 
             self.img_meta = create_img_meta()        
+
+            if self.img_meta["fname"] == self.fname:
+                return
+
             self.img_meta["_fpath"] = self.fpath
             self.img_meta["fname"] = self.fname
 
             img_open(self.img_meta)
-            self.buffer = [1,2,3] 
+            self.buffer = [1] #,2,3] 
             return # STOP
 
         if self.fname.startswith("cam_"): 
@@ -592,8 +651,9 @@ class PixelMedia():
         if self._run and len(self.buffer) > 30:
             t = time.time()
             self.t_delta = t-self.t_last 
-            self.pos += self.t_delta*self.fps
+            self.pos += int(self.t_delta*self.fps)
             self.t_last = t
+            #self.frame_change = 1
         else:
             self.pause()
 
@@ -611,6 +671,7 @@ class PixelMedia():
         if self.buffer:
             self._img = self.buffer[int(self.pos)]
             self.img = self._img
+
     def check_cv2_check(self):
         if not cv2:
             cprint("cv2 not importet ! no VIDEO support !",color="red")
@@ -658,86 +719,98 @@ class PixelMedia():
             cprint(sys.exc_info()[2],color="red")
             cprint()
 
+    def calc_im_size(self):
+        try:
+            xx ,yy = self.im.get_size()[:2]
+            self.shape_x = xx
+            self.shape_y = yy
+        except AttributeError as e:
+            pass
+
+
+    def calc_zoom(self,xx,yy):
+        if self.scale < 255*.05:
+            self.scale = 255*0.05
+        xx = int(xx*self.scale/255)
+        yy = int(yy*self.scale/255)
+        return xx,yy
+
+    def draw_video(self,wn,im,x,y,w,h):
+        #rgb = [255,0,0]
+        #rgb = calc_dim(self.dim,rgb)
+        #draw_media_background(wn,x,y,w=w,h=h,rgb=rgb)
+
+        xh=int(w/2) # half
+        yh=int(h/2) # half
+        wn.blit(im, (int(x-xh), int(y-yh))) # draw frame
+
+
+    def draw_cam(self,wn,im,x,y,w,h):
+        if not self.fname.startswith("cam_"):
+            return
+        xx = w #self.shape_x 
+        yy = h #self.shape_y 
+
+        xx,yy = self.calc_zoom(xx,yy)
+
+        wn.blit(im, (int(x-xx/2), int(y-yy)))  # draw frame
+
+    def is_change(self):
+        #if self.frame_change or self.dmx_change:
+        if self.frame_change or self.dmx_change:
+            #if self.dmx_change:
+            return True
+
+    def change_reset(self):
+        if self.frame_change:
+            print("media frame change")
+        if self.dmx_change:
+            print("media dmx change")
+        self.frame_change = 0
+        self.dmx_change = 0
+
     def draw(self,wn=None):
         if self.img_meta:
-            self.img_meta["pos"] = [self.x,self.y]
+            self.img_meta["pos"]   = [self.x,self.y]
             self.img_meta["scale"] = self.scale #= 50 #%
-            self.img_meta["dim"] = self.dim #255
-            self.img_meta["ang"] = self.angle # 0
+            self.img_meta["dim"]   = self.dim #255
+            self.img_meta["ang"]   = self.angle # 0
+
+            #if self.is_change():
+            img = self.img_meta["raw_img"]
+            im2 = img_rescale(img, percent=self.img_meta["scale"])
+            #    
+            #    # add DIMER to videplayer
+            im2 = cv2.normalize(im2, im2, 0, self.img_meta["dim"], cv2.NORM_MINMAX) 
+            self.img_meta["img"] = im2
+
             img_draw_raw(self.img_meta)
+
+            self.change_reset()
             return
-        
+
+
         if self.dim <= 1:
             return
 
-        if self.scale < 255*.05:
-            self.scale = 255*0.05
+        self.calc_im_size()
 
-        # draw video background box
-        __xw = int(self.shape_x*self.scale/255)
-        __yw = int(self.shape_y*self.scale/255)
-    
-        #xx ,yy = (370,235)
-        xx = self.shape_x #= xx
-        yy = self.shape_y #= yy
-        try:
-            xx ,yy = self.im.get_size()[:2]
-            self.shape_x = xx
-            self.shape_y = yy
-        except AttributeError as e:
-            pass
+        im = self.im
 
-        xx = int(xx*self.scale/255)
-        yy = int(yy*self.scale/255)
+        x=self.x
+        y=self.y
 
-        __xw = int(xx) #*self.scale/255)
-        __yw = int(yy) #*self.scale/255)
-        yellow = [105,50,0]
-        yellow[0] = int(yellow[0]*self.dim/255)  
-        yellow[1] = int(yellow[1]*self.dim/255)  
-        yellow[2] = int(yellow[2]*self.dim/255)  
+        #w,h = self.calc_zoom(x,y)
+        w = self.shape_x 
+        h = self.shape_y 
 
-        if self.fname.startswith("cam_"):
-            pass
-        elif 1: #corner left up
-            p1 = [self.x+2,self.y+2]  
-            p2 = [self.x+__xw-4,self.y+__yw-4]
-            p3 = [self.x+__xw-4,self.y+2]
-            p4 = [self.x+2,self.y+__yw-4]
-
-            p1 = [self.x,self.y]  
-            p2 = [self.x+__xw,self.y+__yw]
-            p3 = [self.x+__xw,self.y]
-            p4 = [self.x,self.y+__yw]
-            
-            hx=int(xx/2)
-            hy=int(yy/2)
-
-            p1 = [self.x-hx,self.y-hy]  
-            p2 = [self.x+__xw-hx,self.y+__yw-hy]
-            p3 = [self.x+__xw-hx,self.y-hy]
-            p4 = [self.x-hx,self.y+__yw-hy]
-
-            pygame.draw.rect(wn,yellow    ,[p1[0]  ,p1[1]  ,__xw  ,__yw])
-            pygame.draw.rect(wn,[25,20,20],[p1[0]+1,p1[1]+1,__xw-2,__yw-2])
-            pygame.draw.line(wn,yellow    ,p1      ,p2)
-            pygame.draw.line(wn,yellow    ,p3      ,p4)
-        if 0: #corner right down
-            pygame.draw.rect(wn,yellow,[self.x-__xw,self.y-__yw,__xw,__yw])
-            pygame.draw.rect(wn,[25,20,20],[self.x+1-__xw,self.y+1-__yw,__xw-2,__yw-2])
-            pygame.draw.line(wn,yellow,[self.x+2-__xw,self.y+2-__yw],[self.x+__xw-4-__xw,self.y+__yw-4-__yw])
-            pygame.draw.line(wn,yellow,[self.x+__xw-4-__xw,self.y+2-__yw],[self.x+2-__xw,self.y+__yw-4-__yw])
-
-        pz = 0
-
-        if self.success and wn and self.im: # is not None:
-            xx ,yy = self.im.get_size()[:2]
+        if self.success and wn and im: 
             if self.fname.startswith("cam_"):
-                #wn.blit(self.im, (int(self.x-xx/2), int(self.y))) # corner center-top
-                #wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy))) # corner center-bottom
-                wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy))) # corner center-bottom
+                self.draw_cam(wn,im,x,y,w,h)
             else:
-                wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy/2)))
+                self.draw_video(wn,im,x,y,w,h)
+
+        self.change_reset()
 
     def get_meta(self):
         out = {}
@@ -785,7 +858,7 @@ def create_format_line(meta,keys):
         _line.append(str(k))
         _line.append(":")
         if type(v) is float:
-            _line.append("{:0.02f}".format(v))
+            _line.append("{:02f}".format(v))
         else:
             _line.append(str(v))
         _line.append(" ")
@@ -1446,6 +1519,7 @@ def output_mask(): # oben
     RGB = [0,0,50]
     #RGB = [120,0,0] # test
     start = 0
+
     # oben  
     pygame.draw.rect(window,RGB,[0,start,MAIN_SIZE[0]+200,57]) # background
     # unten
@@ -2248,7 +2322,7 @@ def draw_all_video(VIDEO):
         k = "DIM"
         if k in count:
             cdim = int(count[k])
-            video1.dim = cdim
+            #video1.dim = cdim
         #if i == 0:
         #    print(i,cdim)
 
@@ -2265,10 +2339,10 @@ def draw_all_video(VIDEO):
         k = "PAN"
         cpan_max = block[0] *(_x) #+block[0]
         if k in count:
-            if 0:#video1.fname.startswith("cam_"):
-                cpan = int(count[k]) #/ 255*cpan_max
-            else:
-                cpan = int(count[k]) / 255*cpan_max
+            #if 0:#video1.fname.startswith("cam_"):
+            #    cpan = int(count[k]) #/ 255*cpan_max
+            #else:
+            cpan = int(count[k]) / 255*cpan_max
             cpan = int(cpan)
 
         k = "TILT"
@@ -2292,13 +2366,14 @@ def draw_all_video(VIDEO):
 
 
 
-        video1.pos 
+        #video1.pos 
         #video1.x=40+0+cpan 
         #video1.y=60+0+pm_wy+ctilt
-        video1.x=CFG_IN["x1"]+cpan 
-        video1.y=CFG_IN["y1"]+ctilt
-        video1.scale = int((csize))
-        video1.angle = int(360-(cang))
+        x=CFG_IN["x1"]+cpan 
+        y=CFG_IN["y1"]+ctilt
+        scale = int((csize))
+        angle = int(360-(cang))
+        video1.update_dmx(x,y,scale,angle,cdim)
 
         if cdim:
             video1.next()
@@ -2758,27 +2833,15 @@ def img_rescale_width(img_meta, _width):
         im = cv2.resize(frame, dim, interpolation =cv2.INTER_LINEAR)
     return im
 
-def img_rescale(img_meta, percent=75):
-    frame = img_meta["raw_img"]
+def img_rescale(img, percent=75):
+    frame = img
+    #frame = img_meta["raw_img"]
     width  = int(frame.shape[1] * percent/ 100)
     height = int(frame.shape[0] * percent/ 100)
     dim = (width, height)
     return cv2.resize(frame, dim, interpolation =cv2.INTER_LINEAR)
 
 
-def img_draw_inp(img_meta):
-    #img_jitter(img_meta)
-
-    pos  = img_meta["pos"]
-    ipos = img_meta["ipos"]
-    im2 = img_meta["img"]
-    im2 = img_rescale(img_meta, percent=img_meta["scale"])
-
-
-    im2 = cvImageToSurface(im2)
-    w2 = int(im2.get_width()/2)
-    h2 = int(im2.get_height()/2)
-    window.blit(im2, (INPUT_START_POS_X-w2+pos[0]+ipos[0], INPUT_START_POS_Y-h2+pos[1]+ipos[1])) 
 
 def img_draw_raw(img_meta):
 
@@ -2786,14 +2849,18 @@ def img_draw_raw(img_meta):
 
     pos  = img_meta["pos"]
     ipos = img_meta["ipos"]
-    im2 = img_meta["img"]
-    #def img_rescale_width(img_meta, _width):
-    im2 = img_rescale(img_meta, percent=img_meta["scale"])
+    im2  = img_meta["img"]
+    dim  = img_meta["dim"]
 
     im2 = cvImageToSurface(im2)
+
     w2 = int(im2.get_width()/2)
     h2 = int(im2.get_height()/2)
-    window.blit(im2, (pos[0]+ipos[0]-w2, pos[1]+ipos[1]-h2)) 
+
+    x=pos[0]+ipos[0]
+    y=pos[1]+ipos[1]
+
+    window.blit(im2, (x-w2,y-h2))
 
 img_meta_a = create_img_meta()
 img_open(img_meta_a)
@@ -2871,7 +2938,8 @@ def main():
         if options.countdown:
             draw_counter(COUNTER)
 
-
+        # output background mask   
+        pygame.draw.rect(window,[0,0,0],[35,57,MAIN_SIZE[0]+200-35,135]) # background
         #pygame.draw.rect(window,[5,5,5],[0,60,MAIN_SIZE[0],p*9]) # background
         pointer.draw(0,pm_wy) #wy
 
@@ -2899,8 +2967,8 @@ def main():
 
 
 
-        output_mask() # mask background
         input_mask()  # mask background
+        output_mask() # mask background
 
         GRID_A1_DIM() # overlay
         GRID_A2_DIM() # overlay