Update app.py

app.py

@@ -1,22 +1,51 @@
 from fastapi import FastAPI, File, UploadFile, HTTPException
-from minisom import MiniSom
-import numpy as np
 from PIL import Image
+import numpy as np
 import pickle
 
 app = FastAPI()
 
-# Cargar el modelo SOM entrenado
-with open('som.pkl', 'rb') as infile:
-    som_model = pickle.load(infile)
+# Cargar el modelo SOM previamente entrenado
+with open("som.pkl", "rb") as tf:
+    som = pickle.load(tf)
+
+# Función para realizar la predicción de huellas dactilares
+def predict_fingerprint(image):
+    try:
+        # Preprocesar la imagen para que coincida con las dimensiones esperadas por el SOM
+        processed_image = preprocess_image(image)
+        # Obtener la ubicación del nodo ganador en el SOM
+        winner = som.winner(processed_image)
+        # Asignar la etiqueta correspondiente a la ubicación ganadora en el SOM
+        fingerprint_type = get_fingerprint_type(winner)
+        return fingerprint_type
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+def preprocess_image(image):
+    # Guardar la imagen en formato TIFF
+    image.save("temp_image.tif")
+    # Aplicar el mismo preprocesamiento que a arco1.tif
+    processed_image = representativo("temp_image.tif")
+    return processed_image
+
+def get_fingerprint_type(winner):
+    # Usar la matriz M del código SOM para asignar la etiqueta correspondiente
+    labels = {0: "LL", 1: "RL", 2: "WH", 3: "AR"}  # Mapa de etiquetas
+    fingerprint_type = labels[int(M[winner[0], winner[1]])]
+    return fingerprint_type
 
-# Etiquetas para los tipos de huellas dactilares
-LABELS = {0: 'LL', 1: 'RL', 2: 'WH', 3: 'AR'}
+@app.post("/predict/")
+async def predict_fingerprint_api(file: UploadFile = File(...)):
+    try:
+        contents = await file.read()
+        image = Image.open(BytesIO(contents))
+        fingerprint_type = predict_fingerprint(image)
+        return {"prediction": fingerprint_type}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-# Función para procesar y clasificar una imagen de huella dactilar
-def classify_fingerprint(image_path):
-    # Función para calcular las orientaciones de la imagen
-    def sobel(I):
+def sobel(I):
     m,n = I.shape# I de 254x254
     Gx = np.zeros([m-2,n-2],np.float32)# Gx de 252x252
     Gy = np.zeros([m-2,n-2],np.float32)# Gy de 252x252
@@ -28,63 +57,36 @@ def classify_fingerprint(image_path):
             Gy[j-1,i-1] = sum(sum(I[j-1:j+2,i-1:i+2]*gy))
     return Gx,Gy
 
-    def medfilt2(G,d=3):
-        m,n = G.shape
-        temp = np.zeros([m+2*(d//2),n+2*(d//2)],np.float32)
-        salida = np.zeros([m,n],np.float32)
-        temp[1:m+1,1:n+1] = G
-        for i in range(1,m):
-            for j in range(1,n):
-                A = np.asarray(temp[i-1:i+2,j-1:j+2]).reshape(-1)
-                salida[i-1,j-1] = np.sort(A)[d+1]
-        return salida
-    
-    def orientacion(patron,w):
-        Gx,Gy = sobel(patron)# patron de 254x254
-        Gx = medfilt2(Gx)# Gx de 252x252
-        Gy = medfilt2(Gy)# Gy de 252x252
-        m,n = Gx.shape
-        mOrientaciones = np.zeros([m//w,n//w],np.float32)# de una matriz de 18x18
-        for i in range(m//w):
-            for j in range(n//w):
-                YY = sum(sum(2*Gx[i*w:(i+1)*w,j:j+1]*Gy[i*w:(i+1)*w,j:j+1]))
-                XX = sum(sum(Gx[i*w:(i+1)*w,j:j+1]**2-Gy[i*w:(i+1)*w,j:j+1]**2))
-                #YY = sum(sum(2*Gx[i*w:(i+1)*w,0:1]*Gy[i*w:(i+1)*w,0:1]))
-                #XX = sum(sum(Gx[i*w:(i+1)*w,0:1]**2-Gy[i*w:(i+1)*w,0:1]**2))
-                mOrientaciones[i,j] = (0.5*math.atan2(YY,XX) + math.pi/2.0)*(180.0/math.pi)
-        return mOrientaciones
-    
-    def representativo(archivo):
-        im = Image.open(archivo)
-        m,n = im.size
-        imarray = np.array(im,np.float32)
-        patron = imarray[1:m-1,1:n-1]# de 256x256  a 254x254
-        EE = orientacion(patron,14)# retorna EE de 18x18
-        return np.asarray(EE).reshape(-1)
+def medfilt2(G,d=3):
+    m,n = G.shape
+    temp = np.zeros([m+2*(d//2),n+2*(d//2)],np.float32)
+    salida = np.zeros([m,n],np.float32)
+    temp[1:m+1,1:n+1] = G
+    for i in range(1,m):
+        for j in range(1,n):
+            A = np.asarray(temp[i-1:i+2,j-1:j+2]).reshape(-1)
+            salida[i-1,j-1] = np.sort(A)[d+1]
+    return salida
 
-    # Obtener el vector representativo de la imagen de huella dactilar
-    fingerprint_vector = representativo(image_path)
-    
-    # Calcular la ubicación ganadora en el SOM para el vector de huella dactilar
-    winner_position = som_model.winner(fingerprint_vector)
-    
-    # Obtener la etiqueta correspondiente a la ubicación ganadora
-    label = LABELS[som_model[winner_position[0], winner_position[1]]]
-    
-    return label
+def orientacion(patron,w):
+    Gx,Gy = sobel(patron)# patron de 254x254
+    Gx = medfilt2(Gx)# Gx de 252x252
+    Gy = medfilt2(Gy)# Gy de 252x252
+    m,n = Gx.shape
+    mOrientaciones = np.zeros([m//w,n//w],np.float32)# de una matriz de 18x18
+    for i in range(m//w):
+        for j in range(n//w):
+            YY = sum(sum(2*Gx[i*w:(i+1)*w,j:j+1]*Gy[i*w:(i+1)*w,j:j+1]))
+            XX = sum(sum(Gx[i*w:(i+1)*w,j:j+1]**2-Gy[i*w:(i+1)*w,j:j+1]**2))
+            #YY = sum(sum(2*Gx[i*w:(i+1)*w,0:1]*Gy[i*w:(i+1)*w,0:1]))
+            #XX = sum(sum(Gx[i*w:(i+1)*w,0:1]**2-Gy[i*w:(i+1)*w,0:1]**2))
+            mOrientaciones[i,j] = (0.5*math.atan2(YY,XX) + math.pi/2.0)*(180.0/math.pi)
+    return mOrientaciones
 
-# Ruta de predicción
-@app.post("/predict/")
-async def predict(file: UploadFile = File(...)):
-    try:
-        # Guardar la imagen subida
-        with open("temp_image.tif", "wb") as buffer:
-            buffer.write(await file.read())
-        
-        # Clasificar la imagen de huella dactilar
-        prediction = classify_fingerprint("temp_image.tif")
-        
-        return {"prediction": prediction}
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+def representativo(archivo):
+    im = Image.open(archivo)
+    m,n = im.size
+    imarray = np.array(im,np.float32)
+    patron = imarray[1:m-1,1:n-1]# de 256x256  a 254x254
+    EE = orientacion(patron,14)# retorna EE de 18x18
+    return np.asarray(EE).reshape(-1)