Create utils.py

utils.py

@@ -0,0 +1,77 @@
+import numpy as np
+import cv2
+import numexpr
+import re
+import torch
+from PIL import Image
+
+def parse_weight_string(string, max_frames):
+    string = re.sub(r'\s+', '', str(string))
+    keyframes = {}
+    parts = string.split(',')
+    for part in parts:
+        try:
+            if ':' not in part: continue
+            f_str, v_str = part.split(':', 1)
+            keyframes[int(f_str)] = v_str.strip('()')
+        except: continue
+    if 0 not in keyframes: keyframes[0] = "0"
+    
+    series = np.zeros(int(max_frames))
+    sorted_k = sorted(keyframes.keys())
+    for i in range(len(sorted_k)):
+        f_start = sorted_k[i]
+        f_end = sorted_k[i+1] if i < len(sorted_k)-1 else int(max_frames)
+        formula = keyframes[f_start]
+        for f in range(f_start, f_end):
+            try:
+                series[f] = float(numexpr.evaluate(formula, local_dict={'t':f,'pi':np.pi,'sin':np.sin,'cos':np.cos}))
+            except:
+                series[f] = float(formula) if formula.replace('.','',1).isdigit() else (series[f-1] if f>0 else 0.0)
+    return series
+
+def interpolate_prompts(pipe, prompt_dict, max_frames):
+    """Blends CLIP embeddings between keyframes for smooth conceptual transitions."""
+    sorted_keys = sorted(prompt_dict.keys())
+    # Pre-calculate embeddings for all keyframe prompts
+    key_embs = {}
+    for k in sorted_keys:
+        tokens = pipe.tokenizer(prompt_dict[k], padding="max_length", max_length=pipe.tokenizer.model_max_length, truncation=True, return_tensors="pt").input_ids.to(pipe.device)
+        with torch.no_grad():
+            key_embs[k] = pipe.text_encoder(tokens)[0]
+    
+    full_embs = []
+    for f in range(max_frames):
+        # Find surrounding keyframes
+        before = [k for k in sorted_keys if k <= f]
+        after = [k for k in sorted_keys if k > f]
+        
+        if not after:
+            full_embs.append(key_embs[before[-1]])
+        elif not before:
+            full_embs.append(key_embs[after[0]])
+        else:
+            k1, k2 = before[-1], after[0]
+            alpha = (f - k1) / (k2 - k1)
+            # Spherical Linear Interpolation (Slerp) or simple Lerp
+            blended = torch.lerp(key_embs[k1], key_embs[k2], alpha)
+            full_embs.append(blended)
+    return full_embs
+
+def maintain_colors(img, anchor, mode='LAB'):
+    if mode == 'None' or anchor is None: return img
+    img_np, anc_np = np.array(img), np.array(anchor)
+    if mode == 'LAB':
+        img_lab, anc_lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB), cv2.cvtColor(anc_np, cv2.COLOR_RGB2LAB)
+        for i in range(3):
+            img_lab[:,:,i] = np.clip(img_lab[:,:,i] - np.mean(img_lab[:,:,i]) + np.mean(anc_lab[:,:,i]), 0, 255)
+        return Image.fromarray(cv2.cvtColor(img_lab, cv2.COLOR_LAB2RGB))
+    return img
+
+def anim_frame_warp_2d(img, args, mode='Reflect'):
+    cv_img = np.array(img)
+    h, w = cv_img.shape[:2]
+    mat = cv2.getRotationMatrix2D((w//2, h//2), args.get('angle',0), args.get('zoom',1))
+    mat[0, 2] += args.get('tx',0); mat[1, 2] += args.get('ty',0)
+    b = {'Reflect':cv2.BORDER_REFLECT_101, 'Replicate':cv2.BORDER_REPLICATE, 'Wrap':cv2.BORDER_WRAP}[mode]
+    return Image.fromarray(cv2.warpAffine(cv_img, mat, (w, h), borderMode=b))