Update app.py

app.py

@@ -1,106 +1,92 @@
 import pickle
 from minisom import MiniSom
 import numpy as np
-from io import BytesIO
-from fastapi import FastAPI, File, UploadFile, HTTPException
+import cv2
+
+import urllib.request
+import uuid
+
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from typing import List
-from scipy.ndimage import median_filter
-from scipy.signal import convolve2d
-import cv2
-from PIL import Image
-import math
-#from tensorflow.keras.preprocessing import image
 
 class InputData(BaseModel):
-    data: List[float]  # Lista de características numéricas (floats)
+  data: str  # image url
 
 app = FastAPI()
 
+# Función para construir el modelo manualmente
 def build_model():
-    with open('somlucuma.pkl', 'rb') as fid:
-        somlucuma = pickle.load(fid)
-    MM = np.loadtxt('matrizMM.txt', delimiter=" ")
-    return somlucuma,MM
+  with open('somlucuma.pkl', 'rb') as fid:
+    somecoli = pickle.load(fid)
+  MM = np.loadtxt('matrizMM.txt', delimiter=" ")
+  return somecoli,MM
+
+som,MM = build_model()  # Construir el modelo al iniciar la aplicación
+
+
+from scipy.ndimage import median_filter
+from scipy.signal import convolve2d
 
 def sobel(patron):
-    gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32)
-    gy = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=np.float32)
+  gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32)
+  gy = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=np.float32)
 
-    Gx = convolve2d(patron, gx, mode='valid')
-    Gy = convolve2d(patron, gy, mode='valid')
+  Gx = convolve2d(patron, gx, mode='valid')
+  Gy = convolve2d(patron, gy, mode='valid')
 
-    return Gx, Gy
+  return Gx, Gy
 
 def medfilt2(G, d=3):
-    return median_filter(G, size=d)
+  return median_filter(G, size=d)
 
 def orientacion(patron, w):
-    Gx, Gy = sobel(patron)
-    Gx = medfilt2(Gx)
-    Gy = medfilt2(Gy)
+  Gx, Gy = sobel(patron)
+  Gx = medfilt2(Gx)
+  Gy = medfilt2(Gy)
 
-    m, n = Gx.shape
-    mOrientaciones = np.zeros((m // w, n // w), dtype=np.float32)
+  m, n = Gx.shape
+  mOrientaciones = np.zeros((m // w, n // w), dtype=np.float32)
 
-    for i in range(m // w):
-        for j in range(n // w):
-            Gx_patch = Gx[i*w:(i+1)*w, j*w:(j+1)*w]
-            Gy_patch = Gy[i*w:(i+1)*w, j*w:(j+1)*w]
+  for i in range(m // w):
+    for j in range(n // w):
+      Gx_patch = Gx[i*w:(i+1)*w, j*w:(j+1)*w]
+      Gy_patch = Gy[i*w:(i+1)*w, j*w:(j+1)*w]
 
-            YY = np.sum(2 * Gx_patch * Gy_patch)
-            XX = np.sum(Gx_patch**2 - Gy_patch**2)
+      YY = np.sum(2 * Gx_patch * Gy_patch)
+      XX = np.sum(Gx_patch**2 - Gy_patch**2)
 
-            mOrientaciones[i, j] = (0.5 * np.arctan2(YY, XX) + np.pi / 2.0) * (18.0 / np.pi)
+      mOrientaciones[i, j] = (0.5 * np.arctan2(YY, XX) + np.pi / 2.0) * (18.0 / np.pi)
 
-    return mOrientaciones
+  return mOrientaciones
 
 def redimensionar(img, h, v):
-    return cv2.resize(img, (h, v), interpolation=cv2.INTER_AREA)
-    
-def testeo(som,archivo):
-    archivo = np.squeeze(archivo)
-    print(archivo)
-    orientaciones = orientacion(archivo, w=14)
-    orientaciones = orientaciones.reshape(1,-1)
-    #orientaciones = np.concatenate([orientaciones.ravel()])
-    return som.winner(orientaciones)
-    
-som, MM = build_model()  # Construir modelo
+  return cv2.resize(img, (h, v), interpolation=cv2.INTER_AREA)
+
+
+def prediction(som, imgurl):
+  archivo = f"/tmp/test-{uuid.uuid4()}.jpg"
+  urllib.request.urlretrieve(imgurl, archivo)
+  Xtest = redimensionar(cv2.imread(archivo),256,256)
+  Xtest = np.array(Xtest)
+  Xtest = cv2.cvtColor(Xtest, cv2.COLOR_BGR2GRAY)
+
+  orientaciones = orientacion(Xtest, w=14)
+  Xtest = Xtest.astype('float32') / 255.0
+  orientaciones = orientaciones.reshape(-1)
+  return som.winner(orientaciones)
 
+# Ruta de predicción
 @app.post("/predict/")
-async def predict(data: UploadFile = File(...)):
-    
-    #global som
-    #global MM
-    try:
-        contents = await data.read()
-        img = redimensionar(Image.open(BytesIO(contents)),256,256)
-        
-        #print(f"Data: {data}")
-        #img = image.img_to_array(Image.open(BytesIO(contents))).flatten() / 255.0
-        """
-        img = Image.open(BytesIO(contents))        
-        img = redimensionar(img,256,256)
-        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        img = np.array(img)
-        img = orientacion(img,w = 14)
-        img = img.astype('float32') / 255.0
-        img = img.reshape(-1)
-        #data = image.img_to_array(Image.open(BytesIO(contents))
-        #w = som.winner(img)
-        """
-        prediction = "1.0"#MM[w]
-        
-        w = "1.0"
-        #input_data = np.array(data.data).reshape(256, 256, 1)
-        #w = testeo(som,input_data)
-        #prediction = MM[w]
-        print(w,prediction)
-        return {"prediction": prediction}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-        
-@app.get("/texto/")
-async def texto():
-    return {"texto": "hola"}
+async def predict(data: InputData):
+  print(f"Data: {data}")
+  global som
+  global MM
+  try:
+    # Convertir la lista de entrada a un array de NumPy para la predicción
+    imgurl = data.data
+    print(type(data.data))
+    w = prediction(som, imgurl)
+    return {"prediction": MM[w]}
+  except Exception as e:
+    raise HTTPException(status_code=500, detail=str(e))