Update app.py

app.py

@@ -1,14 +1,13 @@
 import gradio as gr
 import cv2
 import numpy as np
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 import warnings
-import io
 import torch
 import base64
+import io
 import os
-import matplotlib.pyplot as plt
-from scipy import stats
+import pytesseract
 from sklearn.cluster import DBSCAN
 from transformers import (
     AutoModelForObjectDetection,
@@ -16,6 +15,8 @@ from transformers import (
     pipeline
 )
 from huggingface_hub import InferenceClient
+import matplotlib.pyplot as plt
+from scipy import stats
 
 warnings.filterwarnings("ignore")
 
@@ -34,6 +35,7 @@ torch.set_num_threads(os.cpu_count() or 8)
 # Model configurations
 DETECTION_MODEL = "facebook/detr-resnet-50"
 LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-70B-Instruct"
+OCR_CONFIG = r'--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789.$€£¥%'
 
 # Initialize models
 detection_processor = DetrImageProcessor.from_pretrained(DETECTION_MODEL)
@@ -47,6 +49,9 @@ You are a senior cryptocurrency trading analyst with 15 years experience. Analyz
 Technical Elements Detected:
 {technical_analysis}
 
+Price Axis Information:
+{price_info}
+
 User Query: {question}
 
 Provide detailed professional analysis covering:
@@ -67,6 +72,43 @@ def adaptive_resize(image):
     scale = MAX_SIZE / max(height, width)
     return image.resize((int(width*scale), int(height*scale)), Image.LANCZOS)
 
+def extract_price_info(image):
+    img_np = np.array(image)
+    gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+    data = pytesseract.image_to_data(gray, config=OCR_CONFIG, output_type=pytesseract.Output.DICT)
+    
+    price_levels = []
+    price_rects = []
+    
+    for i, text in enumerate(data['text']):
+        if text.strip() and any(c.isdigit() or c in '$€£¥%' for c in text):
+            x = data['left'][i]
+            y = data['top'][i]
+            w = data['width'][i]
+            h = data['height'][i]
+            price_rects.append((x, y, w, h))
+            
+            try:
+                price = float(text.replace('$','').replace('%','').strip())
+                price_levels.append((y + h//2, price))
+            except:
+                continue
+                
+    return price_levels, price_rects
+
+def map_y_to_price(y_pos, price_levels):
+    if not price_levels:
+        return None
+    
+    y_values = [y for y, _ in price_levels]
+    prices = [p for _, p in price_levels]
+    
+    try:
+        slope, intercept, _, _, _ = stats.linregress(y_values, prices)
+        return round(intercept + slope * y_pos, 2)
+    except:
+        return None
+
 def enhance_contrast(img):
     lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
     l, a, b = cv2.split(lab)
@@ -75,47 +117,13 @@ def enhance_contrast(img):
     merged = cv2.merge([limg, a, b])
     return cv2.cvtColor(merged, cv2.COLOR_LAB2RGB)
 
-def detect_lines(image):
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    edges = cv2.Canny(gray, *CANNY_THRESHOLDS)
-    lines = cv2.HoughLinesP(edges, 1, np.pi/180, *HOUGH_PARAMS)
-    return lines
-
-def cluster_lines(lines):
-    if lines is None:
-        return []
-    points = lines.reshape(-1, 2)
-    clustering = DBSCAN(eps=DBSCAN_EPS, min_samples=MIN_SAMPLES).fit(points)
-    return clustering.labels_
-
-def calculate_slope(line):
-    x1, y1, x2, y2 = line
-    return (y2 - y1) / (x2 - x1) if (x2 - x1) != 0 else np.inf
-
-def detect_key_levels(image):
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    hist = cv2.calcHist([gray], [0], None, [256], [0,256])
-    peaks, _ = find_peaks(hist.flatten(), distance=10, prominence=50)
-    return [p for p in peaks if 10 < p < 240]
-
-def analyze_volume_profile(image):
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    return cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]
-
-def detect_candlesticks(image):
-    edges = cv2.Canny(image, 50, 150)
-    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    candles = []
-    for cnt in contours:
-        x,y,w,h = cv2.boundingRect(cnt)
-        if 5 < w < 50 and 10 < h < 200:
-            candles.append((x,y,w,h))
-    return candles
-
 def detect_chart_elements(image):
     image_np = np.array(image)
     enhanced = enhance_contrast(image_np)
     
+    # OCR for price information
+    price_levels, price_rects = extract_price_info(image)
+    
     # Deep Learning Detection
     inputs = detection_processor(images=Image.fromarray(enhanced), return_tensors="pt")
     with torch.no_grad():
@@ -137,6 +145,10 @@ def detect_chart_elements(image):
     
     draw = ImageDraw.Draw(image)
     
+    # Draw price levels
+    for x, y, w, h in price_rects:
+        draw.rectangle([x, y, x+w, y+h], outline="#4CAF50", width=1)
+    
     # Process DL detections
     for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
         box = [round(i, 2) for i in box.tolist()]
@@ -145,34 +157,32 @@ def detect_chart_elements(image):
         draw.rectangle(box, outline="#FF0000", width=3)
         draw.text((box[0], box[1]), f"{label_name} ({score:.2f})", fill="#FF0000")
     
-    # Traditional CV Detection
-    lines = detect_lines(enhanced)
+    # Trendline and support/resistance detection
+    lines = cv2.HoughLinesP(
+        cv2.Canny(cv2.cvtColor(enhanced, cv2.COLOR_RGB2GRAY), *CANNY_THRESHOLDS),
+        1, np.pi/180, *HOUGH_PARAMS
+    )
+    
     if lines is not None:
-        clusters = cluster_lines(lines)
-        for i, line in enumerate(lines):
+        for line in lines:
             x1, y1, x2, y2 = line[0]
-            slope = calculate_slope(line[0])
-            length = np.sqrt((x2-x1)**2 + (y2-y1)**2)
+            slope = (y2 - y1) / (x2 - x1) if (x2 - x1) != 0 else np.inf
             
-            if abs(slope) < 0.1 and length > 100:
-                elements['support_resistance'].append(f"Key Level at y={y1}")
+            price1 = map_y_to_price(y1, price_levels)
+            price2 = map_y_to_price(y2, price_levels)
+            
+            if abs(slope) < 0.1:  # Horizontal line
+                label = f"Key Level: {price1:.2f}" if price1 else f"Y={y1}"
+                elements['support_resistance'].append(label)
                 draw.line((x1, y1, x2, y2), fill="#00FF00", width=3)
-            elif 0.1 < abs(slope) < 5:
-                elements['trendlines'].append(f"Trendline ({'Up' if slope < 0 else 'Down'})")
+                draw.text((x1+5, y1+5), label, fill="#00FF00")
+            else:  # Trendline
                 draw.line((x1, y1, x2, y2), fill="#0000FF", width=3)
+                elements['trendlines'].append(f"Trendline ({'Bullish' if slope < 0 else 'Bearish'})")
     
-    # Volume Profile Analysis
-    volume_profile = analyze_volume_profile(enhanced)
-    contours, _ = cv2.findContours(volume_profile, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    for cnt in contours:
-        if cv2.contourArea(cnt) > 1000:
-            x,y,w,h = cv2.boundingRect(cnt)
-            elements['support_resistance'].append(f"Volume Cluster at {y+h//2}")
-            draw.rectangle([x,y,x+w,y+h], outline="#FFA500", width=2)
-    
-    return image, elements
+    return image, elements, price_levels
 
-def generate_technical_report(elements):
+def generate_technical_report(elements, price_levels):
     report = []
     if elements['support_resistance']:
         report.append("**Key Levels**: " + ", ".join(elements['support_resistance'][:5]))
@@ -180,19 +190,35 @@ def generate_technical_report(elements):
         report.append("**Trend Analysis**: " + ", ".join(elements['trendlines']))
     if elements['patterns']:
         report.append("**Chart Patterns**: " + ", ".join(elements['patterns']))
+    
+    if price_levels:
+        prices = [p for _, p in price_levels]
+        report.append(f"**Detected Price Range**: ${min(prices):.2f} - ${max(prices):.2f}")
+    
     return "\n".join(report)
 
 def respond(message, history, image):
-    if image is None:
-        return "Please upload a cryptocurrency chart for analysis."
+    # Handle initial greeting
+    if not history:
+        return "Merhaba! Hoş geldiniz. Size nasıl yardımcı olabilirim? Crypto analiz için lütfen grafik yükleyin, genel sorularınızı direkt sorabilirsiniz."
     
     try:
-        processed_img = adaptive_resize(image)
-        annotated_img, elements = detect_chart_elements(processed_img)
-        tech_report = generate_technical_report(elements)
+        tech_report = ""
+        annotated_img = None
+        price_info = ""
+        
+        if image is not None:
+            processed_img = adaptive_resize(image)
+            annotated_img, elements, price_levels = detect_chart_elements(processed_img)
+            tech_report = generate_technical_report(elements, price_levels)
+            
+            if price_levels:
+                prices = [f"${p:.2f}" for _, p in price_levels]
+                price_info = f"Detected Price Levels: {', '.join(prices)}"
         
         full_prompt = SYSTEM_PROMPT.format(
             technical_analysis=tech_report,
+            price_info=price_info,
             question=message
         )
         
@@ -204,12 +230,14 @@ def respond(message, history, image):
             seed=42
         )
         
-        img_base64 = base64.b64encode(annotated_img.tobytes()).decode('utf-8')
-        img_html = f'<div style="border: 2px solid #4CAF50; padding: 10px; margin-bottom: 20px;">' \
-                   f'<img src="data:image/png;base64,{img_base64}" style="max-width: 100%;">' \
-                   f'</div>'
+        if annotated_img:
+            img_base64 = base64.b64encode(annotated_img.tobytes()).decode('utf-8')
+            img_html = f'<div style="border: 2px solid #4CAF50; padding: 10px; margin-bottom: 20px;">' \
+                       f'<img src="data:image/png;base64,{img_base64}" style="max-width: 100%;">' \
+                       f'</div>'
+            return f"{img_html}\n{response.split('<|assistant|>')[-1].strip()}"
         
-        return f"{img_html}\n{response.split('<|assistant|>')[-1].strip()}"
+        return response.split('<|assistant|>')[-1].strip()
     
     except Exception as e:
         return f"⚠️ Advanced Analysis Error: {str(e)}"