add

glibvision/bbox_utils.py

@@ -0,0 +1,30 @@
+def expand_bbox(bbox,left=5,top=5,right=5,bottom=5):
+   left_pixel = bbox[2]*(float(left)/100)
+   top_pixel = bbox[3]*(float(top)/100)
+   right_pixel = bbox[2]*(float(right)/100)
+   bottom_pixel = bbox[3]*(float(bottom)/100)
+   new_box = list(bbox)
+   new_box[0] -=left_pixel
+   new_box[1] -=top_pixel
+   new_box[2] +=left_pixel+right_pixel
+   new_box[3] +=top_pixel+bottom_pixel
+   return new_box
+
+def to_int_bbox(bbox):
+   int_box = [
+      int(bbox[0]),
+      int(bbox[1]),
+      int(bbox[2]),
+      int(bbox[3])
+   ]
+   return int_box
+
+# for dlib rectangle
+def to_right_bottom_bbox(bbox):
+   int_box = [
+    bbox[0],
+    bbox[1],
+    bbox[2]+bbox[0],
+    bbox[3]+bbox[1]
+   ]
+   return int_box

glibvision/common_utils.py

@@ -0,0 +1,112 @@
+import os
+def check_exists_files(files,dirs,exit_on_error=True):
+    if files is not None:
+        if isinstance(files, str):  
+            files = [files]
+        for file in files:
+            if not os.path.isfile(file):
+                print(f"File {file} not found")
+                if exit_on_error:
+                    exit(1)
+                else:
+                    return 1
+    if dirs is not None:
+        if isinstance(dirs, str):  
+            dirs = [dirs]
+        for dir in dirs:
+            if not os.path.isdir(dir):
+                print(f"Dir {dir} not found")
+                if exit_on_error:
+                    exit(1)
+                else:
+                    return 1
+    return 0
+
+image_extensions =[".jpg"]
+
+def add_name_suffix(file_name,suffix,replace_suffix=False):
+    if not suffix.startswith("_"):#force add
+        suffix="_"+suffix
+
+    name,ext = os.path.splitext(file_name)
+    if replace_suffix:
+        index = name.rfind("_")
+        if index!=-1:
+            return f"{name[0:index]}{suffix}{ext}"
+        
+    return f"{name}{suffix}{ext}"
+
+def replace_extension(file_name,new_extension,suffix=None,replace_suffix=False):
+    if not new_extension.startswith("."):
+        new_extension="."+new_extension
+
+    name,ext = os.path.splitext(file_name)
+    new_file = f"{name}{new_extension}"
+    if suffix:
+        return add_name_suffix(name+new_extension,suffix,replace_suffix)
+    return new_file
+
+def list_digit_images(input_dir,sort=True):
+    digit_images = []
+    global image_extensions
+    files = os.listdir(input_dir)
+    for file in files:
+        if file.endswith(".jpg"):#TODO check image
+            base,ext = os.path.splitext(file)
+            if not base.isdigit():
+                continue
+            digit_images.append(file) 
+
+    if sort:
+        digit_images.sort()
+
+    return digit_images
+def list_suffix_images(input_dir,suffix,is_digit=True,sort=True):
+    digit_images = []
+    global image_extensions
+    files = os.listdir(input_dir)
+    for file in files:
+        if file.endswith(".jpg"):#TODO check image
+            base,ext = os.path.splitext(file)
+            if base.endswith(suffix):
+                if is_digit:
+                    if not base.replace(suffix,"").isdigit():
+                        continue
+                digit_images.append(file) 
+
+    if sort:
+        digit_images.sort()
+
+    return digit_images
+
+import time
+
+class ProgressTracker:
+    """
+    処理の進捗状況を追跡し、経過時間と残り時間を表示するクラス。
+    """
+
+    def __init__(self,key, total_target):
+        """
+        コンストラクタ
+
+        Args:
+            total_target (int): 処理対象の総数
+        """
+        self.key = key
+        self.total_target = total_target
+        self.complete_target = 0
+        self.start_time = time.time()
+
+    def update(self):
+        """
+        進捗を1つ進める。
+        経過時間と残り時間を表示する。
+        """
+        self.complete_target += 1
+        current_time = time.time()
+        consumed_time = current_time - self.start_time
+        remain_time = (consumed_time / self.complete_target) * (self.total_target - self.complete_target) if self.complete_target > 0 else 0 
+        print(f"stepped {self.key} {self.total_target} of {self.complete_target}, consumed {(consumed_time / 60):.1f} min, remain {(remain_time / 60):.1f} min")
+
+    

glibvision/cv2_utils.py

@@ -0,0 +1,185 @@
+import cv2
+import numpy as np
+
+#2024-11-27 add copy image
+#2024-12-04 plot_text = False,plot line first
+#2024-11-30 copy paste
+def draw_bbox(image,box,color=(255,0,0),thickness=1):
+  if thickness==0:
+    return
+  
+  left = int(box[0])
+  top = int(box[1])
+  right = int(box[0]+box[2])
+  bottom = int(box[1]+box[3])
+  box_points =[(left,top),(right,top),(right,bottom),(left,bottom)]
+  
+  cv2.polylines(image, [np.array(box_points)], isClosed=True, color=color, thickness=thickness)
+
+
+def to_int_points(points):
+  int_points=[]
+  for point in points:
+    int_points.append([int(point[0]),int(point[1])])
+  return int_points
+
+def draw_text(img, text, point, font_scale=0.5, color=(200, 200, 200), thickness=1):
+  font = cv2.FONT_HERSHEY_SIMPLEX
+  cv2.putText(img, str(text), point, font, font_scale, color, thickness, cv2.LINE_AA)
+
+plot_text_color = (200, 200, 200)
+plot_text_font_scale = 0.5
+plot_index = 1
+plot_text = False
+
+def set_plot_text(is_plot,text_font_scale,text_color):
+  global plot_index,plot_text,plot_text_font_scale,plot_text_color
+  plot_text = is_plot
+  plot_index = 1
+  plot_text_font_scale = text_font_scale
+  plot_text_color = text_color
+
+def plot_points(image,points,isClosed=False,circle_size=3,circle_color=(255,0,0),line_size=1,line_color=(0,0,255)):
+    
+    global plot_index,plot_text
+    int_points = to_int_points(points)
+    if line_size>0:
+      cv2.polylines(image, [np.array(int_points)], isClosed=isClosed, color=line_color, thickness=line_size)
+    if circle_size>0:
+      for point in int_points:
+        cv2.circle(image,point,circle_size,circle_color,-1)
+        if plot_text:
+          draw_text(image,plot_index,point,plot_text_font_scale,plot_text_color)
+        plot_index+=1
+    
+
+def fill_points(image,points,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    np_points = np.array(points,dtype=np.int32)
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=True, color=line_color, thickness=thickness)
+
+def get_image_size(cv2_image):
+    return cv2_image.shape[:2]
+
+def get_channel(np_array):
+    return np_array.shape[2] if np_array.ndim == 3 else 1 
+
+def get_numpy_text(np_array,key=""):
+    channel = get_channel(np_array)
+    return f"{key} shape = {np_array.shape} channel = {channel} ndim = {np_array.ndim} size = {np_array.size}"
+
+
+def gray3d_to_2d(grayscale: np.ndarray) -> np.ndarray:
+    channel = get_channel(grayscale)
+    if channel!=1:
+        raise ValueError(f"color maybe rgb or rgba {get_numpy_text(grayscale)}")
+    """
+    3 次元グレースケール画像 (チャンネル数 1) を 2 次元に変換する。
+
+    Args:
+        grayscale (np.ndarray): 3 次元グレースケール画像 (チャンネル数 1)。
+
+    Returns:
+        np.ndarray: 2 次元グレースケール画像。
+    """
+
+    if grayscale.ndim == 2:
+        return grayscale
+    return np.squeeze(grayscale)
+
+def blend_rgb_images(image1: np.ndarray, image2: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    """
+    2 つの RGB 画像をマスク画像を使用してブレンドする。
+
+    Args:
+        image1 (np.ndarray): 最初の画像 (RGB)。
+        image2 (np.ndarray): 2 番目の画像 (RGB)。
+        mask (np.ndarray): マスク画像 (グレースケール)。
+
+    Returns:
+        np.ndarray: ブレンドされた画像 (RGB)。
+
+    Raises:
+        ValueError: 入力画像の形状が一致しない場合。
+    """
+
+    if image1.shape != image2.shape or image1.shape[:2] != mask.shape:
+        raise ValueError("入力画像の形状が一致しません。")
+
+    # 画像を float 型に変換
+    image1 = image1.astype(float)
+    image2 = image2.astype(float)
+
+    # マスクを 3 チャンネルに変換し、0-1 の範囲にスケール
+    alpha = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR).astype(float) / 255.0
+
+    # ブレンド計算
+    blended = (1 - alpha) * image1 + alpha * image2
+
+    return blended.astype(np.uint8)
+
+def create_color_image(img,color=(255,255,255)):
+    mask = np.zeros_like(img)
+    
+    h, w = img.shape[:2]
+    cv2.rectangle(mask, (0, 0), (w, h), color, -1)
+    return mask
+
+def pil_to_bgr_image(image):
+  np_image = np.array(image, dtype=np.uint8)
+  if np_image.shape[2] == 4:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RGBA2BGRA)
+  else:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RGB2BGR)
+  return bgr_img
+
+def bgr_to_rgb(np_image):
+  if np_image.shape[2] == 4:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RBGRA2RGBA)
+  else:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
+  return bgr_img
+
+def copy_image(img1: np.ndarray, img2: np.ndarray, x: int, y: int) -> None:
+    # チャネル数と次元数のチェック
+    if img1.ndim != 3 or img2.ndim != 3:
+        raise ValueError("Both img1 and img2 must be 3-dimensional arrays.")
+    elif img1.shape[2] != img2.shape[2]:
+        raise ValueError(f"img1 and img2 must have the same number of channels. img1 has {img1.shape[2]} channels, but img2 has {img2.shape[1]} channels.")
+
+    # Type check
+    if not isinstance(img1, np.ndarray) or not isinstance(img2, np.ndarray):
+        raise TypeError("img1 and img2 must be NumPy arrays.")
+
+    if x>=0:
+      offset_x=0
+      w = min(img1.shape[1]-x,img2.shape[1])
+    else:
+      w = min(img1.shape[1],img2.shape[1]+x)
+      offset_x=int(-x)
+      x = 0
+
+    if y>=0:
+      h = min(img1.shape[0]-y,img2.shape[0])
+      offset_y=0
+    else:
+      h = min(img1.shape[0]-y,img2.shape[0]+y)
+      offset_y=int(-y)
+      y = 0
+    x=int(x)
+    y=int(y)
+    h=int(h)
+    w=int(w)
+   
+    
+    print(f"img1 {img1.shape} img2{img2.shape} x={x} y={y} w={w} h={h}")
+    # Paste the overlapping part
+    img1[y:y+h, x:x+w] = img2[offset_y:h+offset_y, offset_x:w+offset_x]
+
+def crop(image,bbox):
+   x,y,width,height = bbox
+   return image[y:y+height, x:x+width]
+#not check safe
+def paste(image,replace_image,x,y):
+   height,width = replace_image.shape[:2]
+   image[y:y+height, x:x+width] = replace_image

glibvision/draw_utils.py

@@ -0,0 +1,42 @@
+# DrawUtils 
+# not PIL,CV2,Numpy drawing method
+import math
+# 2024-11-29 add calculate_distance
+def points_to_box(points):
+  x1=float('inf')
+  x2=0
+  y1=float('inf')
+  y2=0
+  for point in points:
+    if point[0]<x1:
+      x1=point[0]
+    if point[0]>x2:
+      x2=point[0]
+    if point[1]<y1:
+      y1=point[1]
+    if point[1]>y2:
+      y2=point[1]
+  return [x1,y1,x2-x1,y2-y1]
+
+def box_to_point(box):
+  return [
+    [box[0],box[1]], 
+    [box[0]+box[2],box[1]],
+    [box[0]+box[2],box[1]+box[3]],
+    [box[0],box[1]+box[3]]
+  ]
+
+def plus_point(base_pt,add_pt):
+  return [base_pt[0]+add_pt[0],base_pt[1]+add_pt[1]]
+
+def box_to_xy(box):
+  return [box[0],box[1],box[2]+box[0],box[3]+box[1]]
+
+def to_int_points(points):
+  int_points=[]
+  for point in points:
+    int_points.append([int(point[0]),int(point[1])])
+  return int_points
+
+def calculate_distance(xy, xy2):
+    return math.sqrt((xy2[0] - xy[0])**2 + (xy2[1] - xy[1])**2)

glibvision/glandmark_utils.py

@@ -0,0 +1,48 @@
+
+import os
+
+#simple single version
+def bbox_to_glandmarks(file_name,bbox,points = None):
+     base,ext = os.path.splitext(file_name)
+     glandmark = {"image":{
+            "boxes":[{
+                "left":int(bbox[0]),"top":int(bbox[1]),"width":int(bbox[2]),"height":int(bbox[3])
+            }],
+            "file":file_name,
+            "id":int(base) 
+            # width,height ignore here
+            }}
+     if points is not None:
+          parts=[
+          ]
+          for point in points:
+               parts.append({"x":int(point[0]),"y":int(point[1])})
+          glandmark["image"]["boxes"][0]["parts"] = parts
+     return glandmark
+
+#technically this is not g-landmark/dlib ,
+def convert_to_landmark_group_json(points):
+     if len(points)!=68:
+          print(f"points must be 68 but {len(points)}")
+          return None
+     new_points=list(points)
+     
+     result = [ # possible multi person ,just possible any func support multi person
+         
+          {    # index start 0 but index-number start 1
+               "chin":new_points[0:17],
+               "left_eyebrow":new_points[17:22],
+               "right_eyebrow":new_points[22:27],
+               "nose_bridge":new_points[27:31],
+               "nose_tip":new_points[31:36],
+               "left_eye":new_points[36:42],
+               "right_eye":new_points[42:48],
+               
+               # lip points customized structure  
+               # MIT licensed face_recognition
+               # https://github.com/ageitgey/face_recognition
+               "top_lip":new_points[48:55]+[new_points[64]]+[new_points[63]]+[new_points[62]]+[new_points[61]]+[new_points[60]],
+               "bottom_lip":new_points[54:60]+[new_points[48]]+[new_points[60]]+[new_points[67]]+[new_points[66]]+[new_points[65]]+[new_points[64]],
+          }
+     ]
+     return result

glibvision/numpy_utils.py

@@ -0,0 +1,185 @@
+import numpy as np
+
+#2024-12-03  rotate_point_euler
+#2024-12-04 load_data
+def load_data(filepath):
+    """
+    カンマ区切りのテキストファイルからデータをNumPy配列に読み込みます。
+
+    Args:
+        filepath: データファイルのパス
+
+    Returns:
+        NumPy配列: 読み込まれたデータ。エラーが発生した場合はNone。
+    """
+    try:
+        data = np.loadtxt(filepath, delimiter=",")
+        return data
+    except (FileNotFoundError, ValueError) as e:
+        print(f"Error loading data: {e}")
+        return None
+def rotate_point_euler(point, angles,order="xyz"):
+  """
+  オイラー角を使って3Dポイントを回転させる関数
+
+  Args:
+    point: 回転させる3Dポイント (x, y, z)
+    angles: 各軸周りの回転角度 (rx, ry, rz) [ラジアン]
+
+  Returns:
+    回転後の3Dポイント (x', y', z')
+  """
+
+  rx, ry, rz = angles
+  point = np.array(point)
+
+  # X軸周りの回転
+  Rx = np.array([
+      [1, 0, 0],
+      [0, np.cos(rx), -np.sin(rx)],
+      [0, np.sin(rx), np.cos(rx)]
+  ])
+
+  # Y軸周りの回転
+  Ry = np.array([
+      [np.cos(ry), 0, np.sin(ry)],
+      [0, 1, 0],
+      [-np.sin(ry), 0, np.cos(ry)]
+  ])
+
+  # Z軸周りの回転
+  Rz = np.array([
+      [np.cos(rz), -np.sin(rz), 0],
+      [np.sin(rz), np.cos(rz), 0],
+      [0, 0, 1]
+  ])
+
+  # 回転行列の合成 (Z軸 -> Y軸 -> X軸 の順で回転)
+  order = order.lower()
+  if order == "xyz":
+    R = Rx @ Ry @ Rz
+  elif order == "xzy":
+    R = Rx @ Rz @ Ry
+  elif order == "yxz":
+    R = Ry @ Rx @ Rz
+  elif order == "yzx":
+    R = Ry @ Rz @ Rx
+  elif order == "zxy":
+    R = Rz @ Rx @ Ry
+  else:#zyx
+    R = Rz @ Ry @ Rx
+      
+ 
+
+  # 回転後のポイントを計算
+  rotated_point = R @ point
+
+  return rotated_point
+
+def apply_binary_mask_to_color(base_image,color,mask):
+    """
+    二値マスクを使用して、画像の一部を別の画像にコピーする。
+
+    Args:
+        base_image (np.ndarray): コピー先の画像。
+        paste_image (np.ndarray): コピー元の画像。
+        mask (np.ndarray): 二値マスク画像。
+
+    Returns:
+        np.ndarray: マスクを適用した画像。
+
+    """
+    # TODO check all shape
+    #print_numpy(base_image)
+    #print_numpy(paste_image)
+    #print_numpy(mask)
+    if mask.ndim == 2:
+        condition = mask == 255
+    else:
+        condition = mask[:,:,0] == 255
+    
+    base_image[condition] = color
+    return base_image
+
+def apply_binary_mask_to_image(base_image,paste_image,mask):
+    """
+    二値マスクを使用して、画像の一部を別の画像にコピーする。
+
+    Args:
+        base_image (np.ndarray): コピー先の画像。
+        paste_image (np.ndarray): コピー元の画像。
+        mask (np.ndarray): 二値マスク画像。
+
+    Returns:
+        np.ndarray: マスクを適用した画像。
+
+    """
+    # TODO check all shape
+    #print_numpy(base_image)
+    #print_numpy(paste_image)
+    #print_numpy(mask)
+    if mask.ndim == 2:
+        condition = mask == 255
+    else:
+        condition = mask[:,:,0] == 255
+    
+    base_image[condition] = paste_image[condition]
+    return base_image
+
+def pil_to_numpy(image):
+    return np.array(image, dtype=np.uint8)
+
+def extruce_points(points,index,ratio=1.5):
+    """
+    indexのポイントをratio倍だけ、点群の中心から、外側に膨らます。
+    """
+    center_point = np.mean(points, axis=0)
+    if index < 0 or index > len(points):
+        raise ValueError(f"index must be range(0,{len(points)} but value = {index})")
+    point1 =points[index]
+    print(f"center = {center_point}")
+    vec_to_center = point1 - center_point
+    return vec_to_center*ratio + center_point
+
+
+def bulge_polygon(points, bulge_factor=0.1,isClosed=True):
+    """
+    ポリゴンの辺の中間に点を追加し、外側に膨らませる
+    ndarrayを返すので注意
+    """
+    # 入力 points を NumPy 配列に変換
+    points = np.array(points)
+
+    # ポリゴン全体の重心を求める
+    center_point = np.mean(points, axis=0)
+    #print(f"center = {center_point}")
+    new_points = []
+    num_points = len(points)
+    for i in range(num_points):
+        if i == num_points -1 and not isClosed:
+            break
+        p1 = points[i]
+        #print(f"p{i} = {p1}")
+        # 重心から頂点へのベクトル
+        #vec_to_center = p1 - center_point
+        
+        # 辺のベクトルを求める
+        mid_diff = points[(i + 1) % num_points] - p1
+        mid = p1+(mid_diff/2)
+
+        #print(f"mid = {mid}")
+        out_vec = mid - center_point
+
+        # 重心からのベクトルに bulge_vec を加算
+        new_point = mid + out_vec * bulge_factor
+        
+        new_points.append(p1)
+        new_points.append(new_point.astype(np.int32))
+
+    return np.array(new_points)
+
+
+# image.shape rgb are (1024,1024,3) use 1024,1024 as 2-dimensional
+def create_2d_image(shape):
+    grayscale_image = np.zeros(shape[:2], dtype=np.uint8)
+    return grayscale_image

glibvision/pil_utils.py

@@ -0,0 +1,35 @@
+from PIL import Image,ImageDraw
+from .draw_utils import box_to_xy,to_int_points,box_to_point
+#ver-2024-11-18
+def create_color_image(width, height, color=(255,255,255)):
+    if color == None:
+        color = (0,0,0)
+    
+    if len(color )== 3:
+        mode ="RGB"
+    elif len(color )== 4:
+        mode ="RGBA"
+
+    img = Image.new(mode, (width, height), color)
+    return img
+
+# deprecated
+def fill_points(image,points,color=(255,255,255)):
+    return draw_points(image,points,fill=color)
+
+def draw_points(image,points,outline=None,fill=None,width=1):
+    
+    draw = ImageDraw.Draw(image)
+    int_points = [(int(x), int(y)) for x, y in points]
+
+    if outline is not  None or fill is not None:
+        draw.polygon(int_points, outline=outline,fill=fill,width=width)
+    
+    return image
+
+def draw_box(image,box,outline=None,fill=None):
+    points = to_int_points(box_to_point(box))
+    return draw_points(image,points,outline,fill)
+
+def from_numpy(numpy_array):
+    return Image.fromarray(numpy_array)

glibvision/yolox_utils.py

@@ -0,0 +1,13 @@
+import subprocess
+import json
+import os
+
+get_face_path = os.path.join("C:\\Users\\owner\\Documents\\pythons\\yolox-examples\\get_face_rect.py")
+
+def detect_yolox_face(file_path):
+    command = ["python",get_face_path,"-i",file_path]
+    result=subprocess.run(command,capture_output=True, text=True)
+
+    json_data = json.loads(result.stdout)
+    #print(f"x {json_data[0]},y {json_data[1]},w {json_data[2]},h {json_data[3]}, ")
+    return json_data