modify ipc util

ipc/__init__.py

@@ -1,2 +1,3 @@
 #encoding = utf8
 
+from .ipc_util import IPCUtil

ipc/ipc_util.py

@@ -14,6 +14,7 @@ class IPCUtil:
         if self.__ipc_obj is not None:
             self.__ipc_obj.initialize.argtypes = [c_char_p, c_char_p]
             self.__ipc_obj.initialize.restype = c_bool
+            print('IPCUtil init', sender.encode('utf-8'), receiver.encode('utf-8'))
             self.__init = self.__ipc_obj.initialize(sender.encode('utf-8'), receiver.encode('utf-8'))
             print('IPCUtil init', self.__init)
 
@@ -30,12 +31,23 @@ class IPCUtil:
         self.__ipc_obj.listen.restype = c_bool
         return self.__ipc_obj.listen()
 
-    def send(self, data):
+    def send_text(self, data):
         if not self.__init:
             return False
         self.__ipc_obj.send.argtypes = [c_char_p, c_uint]
         self.__ipc_obj.send.restype = c_bool
-        return self.__ipc_obj.send(data.encode('utf-8'), len(data))
+        send_data = data.encode('utf-8')
+        send_len = len(send_data) + 1
+        return self.__ipc_obj.send(send_data, send_len)
+
+    def send_binary(self, data, size):
+        if not self.__init:
+            return False
+        print('send_binary', size)
+        self.__ipc_obj.send.argtypes = [c_char_p, c_uint]
+        self.__ipc_obj.send.restype = c_bool
+        data_ptr = cast(data, c_char_p)
+        return self.__ipc_obj.send(data_ptr, size)
 
     def set_reader_callback(self, callback):
         if not self.__init:
@@ -46,13 +58,13 @@ class IPCUtil:
         self.__ipc_obj.setReaderCallback.restype = c_bool
         return self.__ipc_obj.setReaderCallback(self.c_callback)
 
-
+#
-def ipc_log_callback(log, size):
+# def ipc_log_callback(log, size):
-    print(f'log={log}, len={size}')
+#     print(f'log={log}, len={size}')
-
+#
-
+#
-util = IPCUtil('ipc-chat', 'ipc-chat')
+# util = IPCUtil('ipc_sender', 'ipc_sender')
-util.set_reader_callback(ipc_log_callback)
+# util.set_reader_callback(ipc_log_callback)
-print(util.listen())
+# print(util.listen())
-print(util.send('hello'))
+# print(util.send_text('hello'))
-time.sleep(2000)
+# time.sleep(200)

ui/pygame_ui.py

@@ -11,11 +11,28 @@ import pygame
 from pygame.locals import *
 
 from human import HumanContext
+from ipc import IPCUtil
 from utils import config_logging
 
 logger = logging.getLogger(__name__)
 current_file_path = os.path.dirname(os.path.abspath(__file__))
 
+ipc = IPCUtil('ipc_sender', 'ipc_sender')
+
+
+def send_image(image):
+    identifier = b'\x01'
+
+    height, width, channels = image.shape
+
+    width_bytes = width.to_bytes(4, byteorder='little')
+    height_bytes = height.to_bytes(4, byteorder='little')
+    bit_depth_bytes = channels.to_bytes(4, byteorder='little')
+
+    img_bytes = image.tobytes()
+    data = identifier + width_bytes + height_bytes + bit_depth_bytes + img_bytes
+    ipc.send_binary(data, len(data))
+
 
 def cal_box(inv_m, p):
     x = inv_m[0][0] * p[0] + inv_m[0][1] * p[1] + inv_m[0][2]
@@ -24,52 +41,53 @@ def cal_box(inv_m, p):
 
 
 def img_warp_back_inv_m(img, img_to, inv_m):
-    # h_up, w_up, c = img_to.shape
+    h_up, w_up, c = img_to.shape
-    # mask = np.ones_like(img).astype(np.float32)
+    mask = np.ones_like(img).astype(np.float32)
-    # inv_mask = cv2.warpAffine(mask, inv_m, (w_up, h_up))
-    # inv_img = cv2.warpAffine(img, inv_m, (w_up, h_up))
-    # mask_indices = inv_mask == 1
-    # if 4 == c:
-    #     img_to[:, :, :3][mask_indices] = inv_img[mask_indices]
-    # else:
-    #     img_to[inv_mask == 1] = inv_img[inv_mask == 1]
-    # cv2.imwrite('./full.png', img_to)
-    # return img_to
-    h_up, w_up, _ = img.shape
-    _, _, c = img_to.shape
-    # cv2.imwrite('./face.png', img)
-    tx = int(inv_m[0][2])
-    ty = int(inv_m[1][2])
-
-    inv_m[0][2] = 0
-    inv_m[1][2] = 0
-
-    p0 = cal_box(inv_m, (0, 0))
-    p1 = cal_box(inv_m, (w_up, 0))
-    p2 = cal_box(inv_m, (w_up, h_up))
-    p3 = cal_box(inv_m, (0, h_up))
-    lp = (min(p0[0], p3[0]), min(p0[1], p1[1]))
-    rp = (max(p2[0], p1[0]), min(p2[1], p3[1]))
-
-    w_up = int(rp[0] - lp[0])
-    h_up = int(rp[1] - lp[1])
-
-    # print(f'src_x:{w_up}, src_y:{h_up}')
-    inv_m[0][2] = 0
-    inv_m[1][2] = abs(lp[1])
-
-    mask = np.ones_like(img, dtype=np.float32)
     inv_mask = cv2.warpAffine(mask, inv_m, (w_up, h_up))
     inv_img = cv2.warpAffine(img, inv_m, (w_up, h_up))
-
+    mask_indices = inv_mask == 1
-    if c == 4:
+    if 4 == c:
-        # img_to[30:h, 30:w][:, :, :3] = img
+        send_image(img_to)
-        img_to[ty:(h_up + ty), tx:(w_up + tx)][:, :, :3][inv_mask == 1] = inv_img[inv_mask == 1]
+        img_to[:, :, :3][mask_indices] = inv_img[mask_indices]
     else:
         img_to[inv_mask == 1] = inv_img[inv_mask == 1]
-
+    cv2.imwrite('./full.png', img_to)
-    # cv2.imwrite('./full1.png', img_to)
     return img_to
+    # h_up, w_up, _ = img.shape
+    # _, _, c = img_to.shape
+    # # cv2.imwrite('./face.png', img)
+    # tx = int(inv_m[0][2])
+    # ty = int(inv_m[1][2])
+    #
+    # inv_m[0][2] = 0
+    # inv_m[1][2] = 0
+    #
+    # p0 = cal_box(inv_m, (0, 0))
+    # p1 = cal_box(inv_m, (w_up, 0))
+    # p2 = cal_box(inv_m, (w_up, h_up))
+    # p3 = cal_box(inv_m, (0, h_up))
+    # lp = (min(p0[0], p3[0]), min(p0[1], p1[1]))
+    # rp = (max(p2[0], p1[0]), min(p2[1], p3[1]))
+    #
+    # w_up = int(rp[0] - lp[0])
+    # h_up = int(rp[1] - lp[1])
+    #
+    # # print(f'src_x:{w_up}, src_y:{h_up}')
+    # inv_m[0][2] = 0
+    # inv_m[1][2] = abs(lp[1])
+    #
+    # mask = np.ones_like(img, dtype=np.float32)
+    # inv_mask = cv2.warpAffine(mask, inv_m, (w_up, h_up))
+    # inv_img = cv2.warpAffine(img, inv_m, (w_up, h_up))
+    #
+    # if c == 4:
+    #     # img_to[30:h, 30:w][:, :, :3] = img
+    #     img_to[ty:(h_up + ty), tx:(w_up + tx)][:, :, :3][inv_mask == 1] = inv_img[inv_mask == 1]
+    # else:
+    #     img_to[inv_mask == 1] = inv_img[inv_mask == 1]
+    #
+    # # cv2.imwrite('./full1.png', img_to)
+    # return img_to
 
 
 def render_image(context, frame):