Blame for functions.py

import numpy as np
import cv2
cv = cv2
import os
import time
import operator
from skimage import img_as_ubyte
from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
from skimage.transform import resize
from scipy.spatial.distance import euclidean


# --- Fonctions de distance / similarité ---

def euclidian_distance(x,y):
    return np.sqrt(np.sum((x-y)**2))

def manhattan_distance(x,y):
    return np.sum(np.abs(x-y))

def chebyshev_distance(x,y):
    return np.max(np.abs(x-y))

def minkowski_distance(x,y,p):
    return np.sum(np.abs(x-y)**p)**(1/p)

def cosine_similarity(x,y):
    return np.dot(x,y)/(np.linalg.norm(x)*np.linalg.norm(y))

def chi_squared_distance(x,y):
    return np.sum((x-y)**2/(x+y+1e-10))

def intersection_distance(x,y):
    return 1 - np.sum(np.minimum(x,y)) / (np.sum(x) + 1e-10)

def bhattacharyya_distance(x,y):
    x_norm = np.abs(x) / (np.sum(np.abs(x)) + 1e-10)
    y_norm = np.abs(y) / (np.sum(np.abs(y)) + 1e-10)
    coefficient = np.sum(np.sqrt(x_norm * y_norm))
    return -np.log(coefficient + 1e-10)

def bhatta(x,y):
    return bhattacharyya_distance(x,y)

def chiSquareDistance(x, y):
    return np.sum((x - y)**2 / (x + y + 1e-10))

def bruteForceMatching(des1, des2, is_binary=False):
    if is_binary:
        bf = cv.BFMatcher(cv.NORM_HAMMING)
        des1 = np.uint8(np.round(des1))
        des2 = np.uint8(np.round(des2))
    else:
        bf = cv.BFMatcher(cv.NORM_L2)
    matches = bf.knnMatch(des1, des2, k=2)
    good = []
    for m, n in matches:
        if m.distance < 0.75 * n.distance:
            good.append([m])
    return len(good)

def flann(des1, des2, is_binary=False):
    if is_binary:
        index_params = dict(algorithm=6,
                            table_number=6,
                            key_size=12,
                            multi_probe_level=1)
        des1 = np.uint8(np.round(des1))
        des2 = np.uint8(np.round(des2))
    else:
        index_params = dict(algorithm=1, trees=5)
    search_params = dict(checks=50)
    matcher = cv.FlannBasedMatcher(index_params, search_params)
    matches = matcher.knnMatch(des1, des2, k=2)
    good = []
    for m, n in matches:
        if m.distance < 0.7 * n.distance:
            good.append([m])
    return len(good)


# --- Descripteurs ---

def generateHistogramme_HSV(image):
    # Pixel counts are integers — return int32 so np.savetxt uses '%d' (writes "256" not "2.56e+02")
    start_time = time.time()
    img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    histH = cv2.calcHist([img],[0],None,[180],[0,180])
    histS = cv2.calcHist([img],[1],None,[256],[0,256])
    histV = cv2.calcHist([img],[2],None,[256],[0,256])
    feature = np.concatenate((histH, np.concatenate((histS,histV),axis=None)),axis=None).astype(np.int32)
    print(f"Hist HSV terminé en {time.time()-start_time}s")
    return feature

def generateHistogramme_Color(image):
    # Pixel counts are integers — return int32 so np.savetxt uses '%d'
    start_time = time.time()
    histB = cv2.calcHist([image],[0],None,[256],[0,256])
    histG = cv2.calcHist([image],[1],None,[256],[0,256])
    histR = cv2.calcHist([image],[2],None,[256],[0,256])
    feature = np.concatenate((histB, np.concatenate((histG,histR),axis=None)),axis=None).astype(np.int32)
    print(f"Hist Couleur terminé en {time.time()-start_time}s")
    return feature

def generateSIFT(image):
    # nfeatures=200 caps keypoints (200×128 max vs ~500×128 default)
    # Returns uint8 array — SIFT bins are integers 0-255, so no precision is lost
    # and np.savetxt writes "128" instead of "1.280000000000000000e+02", ~6x smaller files
    start_time = time.time()
    sift = cv2.SIFT_create(nfeatures=200)
    key_point1, descrip1 = sift.detectAndCompute(image, None)
    if descrip1 is not None:
        descrip1 = descrip1.astype(np.uint8)
    print(f"SIFT terminé en {time.time()-start_time}s")
    return descrip1

def generateORB(image):
    # nfeatures=200 matches SIFT cap; uint8 cast ensures '%d' format in make_descriptor_as_files
    start_time = time.time()
    orb = cv2.ORB_create(nfeatures=200)
    key_point1, descrip1 = orb.detectAndCompute(image, None)
    if descrip1 is not None:
        descrip1 = descrip1.astype(np.uint8)
    print(f"ORB terminé en {time.time()-start_time}s")
    return descrip1

def generateGLCM(image):
    start_time = time.time()
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = img_as_ubyte(gray)
    distances = [1, 2]
    angles = [0, np.pi/4, np.pi/2, 3*np.pi/4]
    glcmMatrix = graycomatrix(gray, distances=distances, angles=angles, normed=True)
    glcmProperties1 = graycoprops(glcmMatrix, "contrast").ravel()
    glcmProperties2 = graycoprops(glcmMatrix, "dissimilarity").ravel()
    glcmProperties3 = graycoprops(glcmMatrix, "homogeneity").ravel()
    glcmProperties4 = graycoprops(glcmMatrix, "energy").ravel()
    glcmProperties5 = graycoprops(glcmMatrix, "correlation").ravel()
    glcmProperties6 = graycoprops(glcmMatrix, "ASM").ravel()
    feature = np.array([
        glcmProperties1, glcmProperties2, glcmProperties3,
        glcmProperties4, glcmProperties5, glcmProperties6
    ]).ravel()
    print(f"GLCM terminé en {time.time()-start_time}s")
    return feature

def generateLBP(image):
    start_time = time.time()
    points = 8
    radius = 1
    method = 'default'
    img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    img = cv2.resize(img, (350, 350))
    fullLBPmatrix = local_binary_pattern(img, points, radius, method)
    histograms, edges = np.histogram(fullLBPmatrix.ravel(), bins=10, range=(0, 2**points))
    histograms = histograms.astype("float")
    histograms /= histograms.sum() + 1e-6
    print(f"LBP terminé en {time.time()-start_time}s")
    return histograms

def generateHOG(image):
    start_time = time.time()
    cellSize = (25, 25)
    blockSize = (50, 50)
    blockStride = (25, 25)
    nBins = 9
    winSize = (350, 350)
    img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    img = cv2.resize(img, winSize)
    hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nBins)
    vect_features = hog.compute(img)
    print(f"HOG terminé en {time.time()-start_time}s")
    return vect_features

def generateCLIP(image):
    """Extraction CLIP avec conversion BGR -> RGB obligatoire."""
    start_time = time.time()
    
    # Remplace l'ancienne ligne par celle-ci :
    from embedders.clip_hf import CLIPEmbedder 
    
    embedder = CLIPEmbedder()
    
    # Conversion OpenCV BGR -> RGB pour CLIP (très important)
    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    from PIL import Image as PILImage
    pil_img = PILImage.fromarray(rgb)
    
    feature = embedder.encode_image(pil_img)
    print(f"CLIP terminé en {time.time()-start_time:.3f}s")
    return feature

# singleton ViT
_vit_model = None
_vit_processor = None

def _load_vit():
    global _vit_model, _vit_processor
    if _vit_model is None:
        import torch
        from transformers import ViTModel, ViTImageProcessor
        device = "cuda" if torch.cuda.is_available() else "cpu"
        _vit_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")
        _vit_model = ViTModel.from_pretrained("google/vit-base-patch16-224").to(device)

        weights_dir = os.environ.get(
            "MIR_WEIGHTS_PATH",
            os.path.join(os.path.dirname(os.path.abspath(__file__)), "weights")
        )
        finetuned_path = os.path.join(weights_dir, "vit_finetuned.pth")
        if os.path.exists(finetuned_path):
            print(f"[ViT] Chargement poids fine-tunés: {finetuned_path}")
            state_dict = torch.load(finetuned_path, map_location=device, weights_only=True)
            result = _vit_model.load_state_dict(state_dict, strict=False)
            if result.missing_keys:
                print(f"[ViT] {len(result.missing_keys)} clé(s) manquante(s)")
            print(f"[ViT] Modèle chargé sur {device}.")
        else:
            print(f"[ViT] Pas de poids fine-tunés, utilisation du pretrained sur {device}.")

        _vit_model.eval()
    return _vit_model, _vit_processor

def generateViT(image):
    """Extraction vecteur ViT 768-dim normalisé L2. Entrée: image BGR (numpy)."""
    start_time = time.time()
    import torch
    from PIL import Image as PILImage

    model, processor = _load_vit()
    device = next(model.parameters()).device

    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    pil_img = PILImage.fromarray(rgb)

    inputs = processor(images=pil_img, return_tensors="pt")
    pixel_values = inputs["pixel_values"].to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        patch_embeddings = outputs.last_hidden_state[:, 1:, :]
        mean_embedding = patch_embeddings.mean(dim=1)

    mean_embedding = mean_embedding / mean_embedding.norm(dim=-1, keepdim=True)
    feature = mean_embedding.cpu().numpy().flatten().astype(np.float32)

    print(f"ViT terminé en {time.time()-start_time:.3f}s")
    return feature

# singleton ViT
_vit_model = None
_vit_processor = None

def _load_vit():
    global _vit_model, _vit_processor
    if _vit_model is None:
        import torch
        from transformers import ViTForImageClassification, ViTImageProcessor, ViTModel
        import json

        device = "cuda" if torch.cuda.is_available() else "cpu"
        _vit_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")

        weights_dir = os.environ.get(
            "MIR_WEIGHTS_PATH",
            os.path.join(os.path.dirname(os.path.abspath(__file__)), "weights")
        )
        finetuned_path = os.path.join(weights_dir, "vit_finetuned.pth")
        classes_path = os.path.join(weights_dir, "vit_classes.json")

        if os.path.exists(finetuned_path) and os.path.exists(classes_path):
            print(f"[ViT] Loading fine-tuned weights: {finetuned_path}")
            with open(classes_path, 'r') as f:
                class_map = json.load(f)
                num_classes = len(class_map)
            
            model_full = ViTForImageClassification.from_pretrained(
                "google/vit-base-patch16-224", 
                num_labels=num_classes,
                ignore_mismatched_sizes=True
            )
            state_dict = torch.load(finetuned_path, map_location=device, weights_only=True)
            model_full.load_state_dict(state_dict, strict=False)
            
            _vit_model = model_full.vit.to(device)
            print(f"[ViT] Fine-tuned model loaded on {device}.")
        else:
            print(f"[ViT] No fine-tuned weights found, using pretrained on {device}.")
            _vit_model = ViTModel.from_pretrained("google/vit-base-patch16-224").to(device)

        _vit_model.eval()
    return _vit_model, _vit_processor

# singleton ResNet50
_resnet_model = None

def _load_resnet():
    global _resnet_model
    if _resnet_model is None:
        import torch
        import torch.nn as nn
        from torchvision import models
        import json

        device = "cuda" if torch.cuda.is_available() else "cpu"
        resnet = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)

        weights_dir = os.environ.get(
            "MIR_WEIGHTS_PATH",
            os.path.join(os.path.dirname(os.path.abspath(__file__)), "weights")
        )
        finetuned_path = os.path.join(weights_dir, "resnet_finetuned.pth")
        classes_path = os.path.join(weights_dir, "resnet_classes.json")

        if os.path.exists(finetuned_path) and os.path.exists(classes_path):
            print(f"[ResNet50] Loading fine-tuned weights: {finetuned_path}")
            with open(classes_path, 'r') as f:
                class_map = json.load(f)
                num_classes = len(class_map)
            
            resnet.fc = nn.Linear(resnet.fc.in_features, num_classes)
            
            state_dict = torch.load(finetuned_path, map_location=device, weights_only=True)
            resnet.load_state_dict(state_dict, strict=False)
            print(f"[ResNet50] Fine-tuned model loaded on {device}.")
        else:
            print(f"[ResNet50] No fine-tuned weights found, using pretrained on {device}.")

        _resnet_model = nn.Sequential(*list(resnet.children())[:-1]).to(device)
        _resnet_model.eval()
    return _resnet_model

def generateResNet(image):
    """Extraction vecteur ResNet50 2048-dim normalisé L2. Entrée: image BGR (numpy)."""
    start_time = time.time()
    import torch
    from torchvision import transforms
    from PIL import Image as PILImage

    model = _load_resnet()
    device = next(model.parameters()).device

    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    pil_img = PILImage.fromarray(rgb)

    preprocess = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    input_tensor = preprocess(pil_img).unsqueeze(0).to(device)

    with torch.no_grad():
        features = model(input_tensor)

    features = features.squeeze()
    features = features / features.norm()
    feature = features.cpu().numpy().astype(np.float32)

    print(f"ResNet50 terminé en {time.time()-start_time:.3f}s")
    return feature

def extractReqFeatures(fileName, algo_choice):
    print(algo_choice)
    if fileName:
        img = cv2.imread(fileName)
        resized_img = resize(img, (128*4, 64*4))

        if algo_choice == 1:
            start_time = time.time()
            histB = cv2.calcHist([img],[0],None,[256],[0,256])
            histG = cv2.calcHist([img],[1],None,[256],[0,256])
            histR = cv2.calcHist([img],[2],None,[256],[0,256])
            vect_features = np.concatenate((histB, np.concatenate((histG,histR),axis=None)),axis=None)
            print(f"Hist couleur requête terminé en {time.time()-start_time}s")
        elif algo_choice == 2:
            start_time = time.time()
            hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
            histH = cv2.calcHist([hsv],[0],None,[180],[0,180])
            histS = cv2.calcHist([hsv],[1],None,[256],[0,256])
            histV = cv2.calcHist([hsv],[2],None,[256],[0,256])
            vect_features = np.concatenate((histH, np.concatenate((histS,histV),axis=None)),axis=None)
            print(f"HSV requête terminé en {time.time()-start_time}s")
        elif algo_choice == 3:
            start_time = time.time()
            sift = cv2.SIFT_create()
            kps, vect_features = sift.detectAndCompute(img, None)
            print(f"SIFT requête terminé en {time.time()-start_time}s")
        elif algo_choice == 4:
            start_time = time.time()
            orb = cv2.ORB_create()
            key_point1, vect_features = orb.detectAndCompute(img, None)
            print(f"ORB requête terminé en {time.time()-start_time}s")
        elif algo_choice == 5:
            vect_features = generateGLCM(img)
        elif algo_choice == 6:
            vect_features = generateLBP(img)
        elif algo_choice == 7:
            vect_features = generateHOG(img)

        np.savetxt("Methode_"+str(algo_choice)+"_query.txt", vect_features)
        print("sauvegardé")
        return vect_features

def distance_f(l1, l2, distanceName, is_binary=False):
    if distanceName == "Euclidienne":
        distance = euclidean(l1, l2)
    elif distanceName in ["Correlation", "Chi carre", "Intersection", "Bhattacharyya"]:
        if distanceName == "Correlation":
            distance = cv2.compareHist(np.float32(l1), np.float32(l2), cv2.HISTCMP_CORREL)
        elif distanceName == "Chi carre":
            distance = chiSquareDistance(l1, l2)
        elif distanceName == "Intersection":
            distance = cv2.compareHist(np.float32(l1), np.float32(l2), cv2.HISTCMP_INTERSECT)
        elif distanceName == "Bhattacharyya":
            distance = bhatta(l1, l2)
    elif distanceName == "Brute force":
        distance = bruteForceMatching(l1, l2, is_binary=is_binary)
    elif distanceName == "Flann":
        distance = flann(l1, l2, is_binary=is_binary)
    elif distanceName == "Cosine Similarity":
        distance = cosine_similarity(l1, l2)
    return distance

def getkNeighbors(lfeatures, req, k, distanceName):
    start_time = time.time()
    ldistances = []
    for i in range(len(lfeatures)):
        dist = distance_f(req, lfeatures[i][1], distanceName)
        ldistances.append((lfeatures[i][0], lfeatures[i][1], dist))
    if distanceName in ["Correlation", "Brute force", "Flann", "Cosine Similarity"]:
        order = True
    else:
        order = False
    ldistances.sort(key=operator.itemgetter(2), reverse=order)

    lneighbors = []
    for i in range(k):
        lneighbors.append(ldistances[i])
    print(f"kNN terminé en {time.time()-start_time}s")
    return lneighbors

def concatenate_multiple_descriptors(list_of_features):
    flattened_features = [np.array(f).ravel() for f in list_of_features]
    combined_feature = np.concatenate(flattened_features, axis=None)
    return combined_feature


def make_descriptor_as_files(dataset_path, descriptor_func, descriptor_name):
    """Applique un descripteur aux images dont le 1er chiffre est pair et sauvegarde en .txt."""
    if not os.path.exists("descriptors"):
        os.makedirs("descriptors")

    target_dir = os.path.join("descriptors", descriptor_name)
    if not os.path.exists(target_dir):
        os.makedirs(target_dir)

    for filename in os.listdir(dataset_path):
        if filename[0].isdigit() and int(filename[0]) % 2 == 0:
            img_path = os.path.join(dataset_path, filename)
            img = cv.imread(img_path)
            if img is not None:
                try:
                    feature = descriptor_func(img)
                    num_image = os.path.splitext(filename)[0]
                    save_path = os.path.join(target_dir, f"{num_image}_{descriptor_name}.txt")
                    # integers (histograms, SIFT, ORB) → '%d';  floats → '%.8f' (vs default %.18e)
                    if np.issubdtype(np.asarray(feature).dtype, np.integer):
                        np.savetxt(save_path, feature, fmt='%d')
                    else:
                        np.savetxt(save_path, feature, fmt='%.8f')
                except Exception as e:
                    print(f"Erreur {filename}: {e}")

    print(f"Indexation {descriptor_name} pour images paires terminée!")