Update app.py

app.py

@@ -1,64 +1,221 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+import cv2
+import numpy as np
+import os
+import tempfile
+from PIL import Image
+
+# ------------------- Common Functions ------------------- #
+def enable_opencl():
+    cv2.ocl.setUseOpenCL(True)
+
+# ------------------- Black & White Converter Functions ------------------- #
+def convert_to_black_white(image, threshold_value=127, method="otsu"):
+    if isinstance(image, str):
+        image = cv2.imread(image)
+    elif isinstance(image, np.ndarray) and len(image.shape) == 3 and image.shape[2] == 4:
+        # Convert RGBA to BGR
+        image = cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)
+    
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    if method == "adaptive":
+        binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                       cv2.THRESH_BINARY, 11, 2)
+    elif method == "otsu":
+        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    else:
+        _, binary = cv2.threshold(gray, threshold_value, 255, cv2.THRESH_BINARY)
+    return binary
+
+def process_image_bw(image, threshold_value, method):
+    return convert_to_black_white(image, threshold_value, method)
+
+def process_video_bw(video_path, threshold_value, method):
+    temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+    
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError("Could not open video file.")
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    
+    out = cv2.VideoWriter(temp_output, fourcc, fps, (frame_width, frame_height), isColor=False)
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        bw_frame = convert_to_black_white(frame, threshold_value, method)
+        out.write(bw_frame)
+
+    cap.release()
+    out.release()
+    
+    return temp_output
+
+# ------------------- Pencil Sketch Converter Functions ------------------- #
+def convert_to_sketch(image, intensity=255, blur_ksize=21, sigma=0):
+    if isinstance(image, str):
+        image = cv2.imread(image)
+    elif isinstance(image, np.ndarray) and len(image.shape) == 3 and image.shape[2] == 4:
+        # Convert RGBA to BGR
+        image = cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)
+    
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    inverted = cv2.bitwise_not(gray)
+    blur_ksize = blur_ksize if blur_ksize % 2 == 1 else blur_ksize + 1
+    blurred = cv2.GaussianBlur(inverted, (blur_ksize, blur_ksize), sigma)
+    sketch = cv2.divide(gray, cv2.bitwise_not(blurred), scale=intensity)
+    return sketch
+
+def process_image_sketch(image, intensity, blur_ksize, sigma):
+    return convert_to_sketch(image, intensity, blur_ksize, sigma)
+
+def process_video_sketch(video_path, intensity, blur_ksize, sigma):
+    temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+    
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError("Failed to open video file.")
+    
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    
+    out = cv2.VideoWriter(temp_output, fourcc, fps, (frame_width, frame_height), isColor=True)
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        sketch = convert_to_sketch(frame, intensity, blur_ksize, sigma)
+        sketch_bgr = cv2.cvtColor(sketch, cv2.COLOR_GRAY2BGR)
+        out.write(sketch_bgr)
+    
+    cap.release()
+    out.release()
+    
+    return temp_output
+
+# ------------------- Gradio UI ------------------- #
+def bw_image_processor(image, threshold_value, method):
+    result = process_image_bw(image, threshold_value, method)
+    return result
+
+def bw_video_processor(video, threshold_value, method):
+    result = process_video_bw(video, threshold_value, method)
+    return result
+
+def sketch_image_processor(image, intensity, blur_ksize, sigma):
+    result = process_image_sketch(image, intensity, blur_ksize, sigma)
+    return result
+
+def sketch_video_processor(video, intensity, blur_ksize, sigma):
+    result = process_video_sketch(video, intensity, blur_ksize, sigma)
+    return result
+
+# Enable OpenCL for performance
+enable_opencl()
+
+# Create Gradio interface
+with gr.Blocks(title="Image Processing Tool") as app:
+    gr.Markdown("# Image Processing Tool")
+    
+    with gr.Tab("Black & White Converter"):
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("## Convert Images to Black & White")
+                bw_image_input = gr.Image(label="Input Image", type="numpy")
+                bw_threshold = gr.Slider(minimum=0, maximum=255, value=127, step=1, 
+                                         label="Threshold Value", visible=True)
+                bw_method = gr.Radio(["otsu", "adaptive", "manual"], label="Thresholding Method", value="otsu")
+                bw_image_button = gr.Button("Process Image")
+            
+            with gr.Column():
+                bw_image_output = gr.Image(label="Output Image")
+        
+        gr.Markdown("---")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("## Convert Videos to Black & White")
+                bw_video_input = gr.Video(label="Input Video")
+                bw_video_threshold = gr.Slider(minimum=0, maximum=255, value=127, step=1, 
+                                              label="Threshold Value", visible=True)
+                bw_video_method = gr.Radio(["otsu", "adaptive", "manual"], label="Thresholding Method", value="otsu")
+                bw_video_button = gr.Button("Process Video")
+            
+            with gr.Column():
+                bw_video_output = gr.Video(label="Output Video")
+        
+        def update_threshold_visibility(method):
+            return gr.update(visible=(method == "manual"))
+        
+        bw_method.change(fn=update_threshold_visibility, inputs=bw_method, outputs=bw_threshold)
+        bw_video_method.change(fn=update_threshold_visibility, inputs=bw_video_method, outputs=bw_video_threshold)
+        
+        bw_image_button.click(
+            fn=bw_image_processor,
+            inputs=[bw_image_input, bw_threshold, bw_method],
+            outputs=bw_image_output
+        )
+        
+        bw_video_button.click(
+            fn=bw_video_processor,
+            inputs=[bw_video_input, bw_video_threshold, bw_video_method],
+            outputs=bw_video_output
+        )
+    
+    with gr.Tab("Pencil Sketch Converter"):
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("## Convert Images to Pencil Sketch")
+                sketch_image_input = gr.Image(label="Input Image", type="numpy")
+                sketch_intensity = gr.Slider(minimum=1, maximum=255, value=255, step=1, 
+                                           label="Intensity (1-255)")
+                sketch_blur = gr.Slider(minimum=1, maximum=99, value=21, step=2, 
+                                      label="Blur Kernel Size (odd, 1-99)")
+                sketch_sigma = gr.Slider(minimum=0, maximum=50, value=0, step=0.1, 
+                                       label="Standard Deviation (0-50)")
+                sketch_image_button = gr.Button("Process Image")
+            
+            with gr.Column():
+                sketch_image_output = gr.Image(label="Output Image")
+        
+        gr.Markdown("---")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("## Convert Videos to Pencil Sketch")
+                sketch_video_input = gr.Video(label="Input Video")
+                sketch_video_intensity = gr.Slider(minimum=1, maximum=255, value=255, step=1, 
+                                                label="Intensity (1-255)")
+                sketch_video_blur = gr.Slider(minimum=1, maximum=99, value=21, step=2, 
+                                           label="Blur Kernel Size (odd, 1-99)")
+                sketch_video_sigma = gr.Slider(minimum=0, maximum=50, value=0, step=0.1, 
+                                            label="Standard Deviation (0-50)")
+                sketch_video_button = gr.Button("Process Video")
+            
+            with gr.Column():
+                sketch_video_output = gr.Video(label="Output Video")
+        
+        sketch_image_button.click(
+            fn=sketch_image_processor,
+            inputs=[sketch_image_input, sketch_intensity, sketch_blur, sketch_sigma],
+            outputs=sketch_image_output
+        )
+        
+        sketch_video_button.click(
+            fn=sketch_video_processor,
+            inputs=[sketch_video_input, sketch_video_intensity, sketch_video_blur, sketch_video_sigma],
+            outputs=sketch_video_output
+        )
+
+# Launch the app
+app.launch()