Upload 7 files

app.py

@@ -0,0 +1,57 @@
+import google.generativeai as genai
+import gradio as gr
+import os
+
+generation_config = {
+  "temperature": 0,
+  "top_p": 1,
+  "top_k": 32,
+  "max_output_token": 4096,
+}
+
+safety_settings = [
+  {
+    "category": "HARM_CATEGORY_HARASSMENT",
+    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+  },
+  {
+    "category": "HARM_CATEGORY_HATE_SPEECH",
+    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+  },
+  {
+    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+  },
+  {
+    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+  },
+]
+
+genai.configure(api_key="AIzaSyAEinSmbNfJHdThXN2nA3Oxf82Qb7zQsLo")
+
+model = genai.GenerativeModel(model_name="gemini-pro-vision",
+                              generation_config=generation_config,
+                              safety_settings=safety_settings)
+
+import_prompt = """ """
+
+def upload_file(files, text_input):
+  file_paths = [file.name for file in files]
+  if file_paths:
+    response = generate_gemini_response(input_prompt, text_input, file_paths[0])
+  return file_paths[0], response
+
+with gr.Blocks() as demo:
+  header = gr.Label("Please let us know about your injury and Gen AI will try to help you")
+  text_input = gr.Textbox(label="Explain a bit more about your injury")
+  image_output = gr.Image()
+  upload_button = gr.UploadButton("Upload an image",
+                                  file_type=["image"],
+                                  file_count="multiple")
+  file_output = gr.Textbox(label="First-aid process")
+  combined_output = [image_output, file_output]
+
+  upload_button.upload(upload_file, [upload_button, text_input], combined_output)
+
+demo.launch(debug=True)

app_flask.py

@@ -0,0 +1,378 @@
+# if you are in production install waitress (pip install waitress) and put this code
+"""from waitress import server
+    serve(app, host="0.0.0.0", port=8081) """
+# before to run the app
+
+# IMPORTATION DES BIBLIOHEQUES
+import os
+import sys
+import cv2  # pip install opencv-python ...................................................
+import numpy as np  # pip install numpy ......................................................
+import tensorflow as tf
+from flask import Flask, request, render_template, jsonify
+from flask_cors import CORS
+from pdf2image import convert_from_path
+import utils.prediction as pred  # importion de notre module python de prediction
+
+# INTIALISATION DE FLASK
+app = Flask(__name__)
+"""app.secret_key = "joelhhybghbgfgy"
+CORS(app, support_credentials=True)
+app.config['CORS_HEADERS'] = 'Content-Type"""
+
+# CONFIGURATION DES CHEMINS ET CHARGEMENT DU MODELE
+"""app.config['UPLOAD_PATH'] = "UPLOAD_FOLDER"
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024"""
+courant = os.path.abspath(os.path.dirname(sys.argv[0]))
+
+ALLOWED_EXTENSIONS = {"txt", "pdf", "png", "jpg", "jpeg", "gif"}
+
+
+# FONCTION POUR UNE ROUTE QUI N'EXISTE PAS
+@app.errorhandler(404)
+def page_not_found(error):
+    return render_template("errors/404.html"), 404
+
+
+# FONCTION UPLOAD PLUS PREDICTION DE DOCUMENTS PDF COMME IMAGE
+@app.route("/predict_files", methods=["POST"])
+def predict_files():
+
+    # RECUPERATION DES DOC DANS UN FORMDATA AVEC 'files' COMME CLE DE CHAMP
+    files = request.files.getlist("files")
+    resultat = []
+    Extraction_caractere = "Pas disponible"
+    for file in files:
+
+        # determination du type de document if pdf else si image
+        name = file.filename
+        name_type = name.split(".")[-1].lower()
+
+        # si le document est un pdf
+        if name_type == "pdf":
+
+            # stocker le fichier dans le repertoire temporaire data
+            file.save(os.path.join(courant + "/data/", file.filename))
+
+            # convertir le fichier en image avec pdf2image
+            pages = convert_from_path(
+                os.path.join(courant + "/data/", file.filename), dpi=200
+            )
+
+            # suppression du pdf
+            os.remove(os.path.join(courant + "/data/" + name))
+
+            # stocker les images PIL de pages dans data
+            for idx, page in enumerate(pages):
+                page.save(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+            # recuperation des images et prediction
+            for idx, page in enumerate(pages):
+
+                # lecture de l'image et premiere prediction
+                npimg = np.fromfile(
+                    os.path.join(
+                        courant + "/data/" + str(file.filename) + str(idx) + ".jpg"
+                    ),
+                    np.uint8,
+                )
+                output = pred.class_prediction(npimg)
+
+                # plus de precision sur la nature des documents
+                if output["CLASSE"] == "Justificatif d'identité":
+                    Detail_output = pred.ID_prediction(npimg)
+                    # si le justificatif est une piece d'identité alors on appelle la fonction d'extraction
+                    # de caractere de la cni
+                    if Detail_output["CLASSE"] == "CARTE D'IDENTITE":
+                        Extraction_caractere = pred.CNI_Extraction(pred.ImgRogne(npimg))
+
+                elif output["CLASSE"] == "Justificatif d'adresse":
+                    Detail_output = pred.ADR_prediction(npimg)
+
+                else:
+                    Detail_output = pred.REV_prediction(npimg)
+
+                resultat.append(
+                    [
+                        {
+                            "FAMILLE": output,
+                            "NATURE": Detail_output,
+                            "EXTRACTION": Extraction_caractere,
+                        }
+                    ]
+                )
+                output = ""
+            output = ""
+
+            # suppression des images
+            for idx, page in enumerate(pages):
+                os.remove(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+        else:  # si cest une image
+            npimg = np.fromfile(file, np.uint8)  # lecture de l'image
+            output = pred.class_prediction(npimg)
+
+            # plus de precision sur la nature des documents
+            if output["CLASSE"] == "Justificatif d'identité":
+                Detail_output = pred.ID_prediction(npimg)
+                # si le justificatif est une piece d'identité alors on appelLe la fonction d'extraction
+                # de caractere de la cni
+                if Detail_output["CLASSE"] == "CARTE D'IDENTITE":
+                    Extraction_caractere = pred.CNI_Extraction(pred.ImgRogne(npimg))
+
+            elif output["CLASSE"] == "Justificatif d'adresse":
+                Detail_output = pred.ADR_prediction(npimg)
+
+            else:
+                Detail_output = pred.REV_prediction(npimg)
+
+            resultat.append(
+                [
+                    {
+                        "FAMILLE": output,
+                        "NATURE": Detail_output,
+                        "EXTRACTION": Extraction_caractere,
+                    }
+                ]
+            )
+
+    return jsonify(resultat)
+
+
+# FONCTION CLASSIFICATION DE DOCUMENTS PDF COMME IMAGE
+@app.route("/classifications", methods=["POST"])
+def classifications():
+    files = request.files.getlist("files")
+
+    # initialisation des listes
+    resultat = []
+    ADR_nature = []
+    REV_nature = []
+    ID_nature = []
+
+    for file in files:
+
+        # determination du type de document if pdf else si image
+        name = file.filename
+        name_type = name.split(".")[-1].lower()
+
+        # si le document est un pdf
+        if name_type == "pdf":
+            # stocker le fichier dans le repertoire temporaire data
+            file.save(os.path.join(courant + "/data/", file.filename))
+
+            # convertir le fichier en image avec pdf2image
+            pages = convert_from_path(
+                os.path.join(courant + "/data/", file.filename), dpi=200
+            )
+
+            # suppression du pdf
+            os.remove(os.path.join(courant + "/data/" + name))
+
+            # stocker les images PIL de pages dans data
+            for idx, page in enumerate(pages):
+                page.save(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+            # recuperation des images et prediction
+            for idx, page in enumerate(pages):
+
+                # lecture de l'image
+                npimg = np.fromfile(
+                    os.path.join(
+                        courant + "/data/" + str(file.filename) + str(idx) + ".jpg"
+                    ),
+                    np.uint8,
+                )
+                output = pred.class_prediction(npimg)
+
+                # plus de precision sur la nature des documents pour une classification plus detaillée
+                # pour les justificatifs d'identité
+                if output["CLASSE"] == "Justificatif d'identité":
+                    Detail_output = pred.ID_prediction(npimg)
+
+                    # ajout des information de prediction dans un json
+                    ID_nature.append(
+                        {
+                            "NOM": str(file.filename) + str(idx) + ".jpg",
+                            "FAMILLE": output,
+                            "NATURE": Detail_output,
+                        }
+                    )
+                # pour les justificatifs d'adresse
+                elif output["CLASSE"] == "Justificatif d'adresse":
+                    Detail_output = pred.ADR_prediction(npimg)
+
+                    # ajout des information de pridiction dans un json
+                    ADR_nature.append(
+                        {
+                            "NOM": str(file.filename) + str(idx) + ".jpg",
+                            "FAMILLE": output,
+                            "NATURE": Detail_output,
+                        }
+                    )
+
+                # pour les justificatifs de revenu
+                else:
+                    Detail_output = pred.REV_prediction(npimg)
+
+                    # ajout des information de prEdiction dans un json
+                    REV_nature.append(
+                        {
+                            "NOM": str(file.filename) + str(idx) + ".jpg",
+                            "FAMILLE": output,
+                            "NATURE": Detail_output,
+                        }
+                    )
+                output = ""
+            output = ""
+
+            # suppression des images
+            for idx, page in enumerate(pages):
+                os.remove(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+        else:  # si cest une image
+            npimg = np.fromfile(file, np.uint8)
+            output = pred.class_prediction(npimg)
+
+            # pour les justificatifs d'identite
+            if output["CLASSE"] == "Justificatif d'identité":
+                Detail_output = pred.ID_prediction(npimg)
+
+                # ajout des information de pridiction dans un json
+                ID_nature.append(
+                    {
+                        "NOM": str(file.filename),
+                        "FAMILLE": output,
+                        "NATURE": Detail_output,
+                    }
+                )
+
+            # pour les justificatifs d'adresse
+            elif output["CLASSE"] == "Justificatif d'adresse":
+                Detail_output = pred.ADR_prediction(npimg)
+
+                # ajout des information de pridiction dans un json
+                ADR_nature.append(
+                    {
+                        "NOM": str(file.filename),
+                        "FAMILLE": output,
+                        "NATURE": Detail_output,
+                    }
+                )
+
+            # pour les justificatifs de revenu
+            else:
+                Detail_output = pred.REV_prediction(npimg)
+
+                # ajout des information de pridiction dans un json
+                REV_nature.append(
+                    {
+                        "NOM": str(file.filename),
+                        "FAMILLE": output,
+                        "NATURE": Detail_output,
+                    }
+                )
+            output = ""
+
+        # le fichier json fichier regroupant toute les information
+    resultat.append({"ID": ID_nature, "ADR": ADR_nature, "REV": REV_nature})
+
+    return jsonify(resultat)
+
+
+# FONCTION EXTRACTION VIVA DE DOCUMENTS PDF COMME IMAGE
+@app.route("/visa_extraction", methods=["POST"])
+def visa_extraction():
+
+    # RECUPERATION DES DOC DANS UN FORMDATA AVEC 'files' COMME CLE DE CHAMP
+    files = request.files.getlist("files")
+    resultat = []
+    for file in files:
+
+        # determination du type de document if pdf else si image
+        name = file.filename
+        name_type = name.split(".")[-1].lower()
+
+        # si le document est un pdf
+        if name_type == "pdf":
+
+            # stocker le fichier dans le repertoire temporaire data
+            file.save(os.path.join(courant + "/data/", file.filename))
+
+            # convertir le fichier en image avec pdf2image
+            pages = convert_from_path(
+                os.path.join(courant + "/data/", file.filename), dpi=200
+            )
+
+            # suppression du pdf
+            os.remove(os.path.join(courant + "/data/" + name))
+
+            # stocker les images PIL de pages dans data
+            for idx, page in enumerate(pages):
+                page.save(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+            # recuperation des images et prediction
+            for idx, page in enumerate(pages):
+
+                # lecture de l'image et premiere prediction
+                npimg = np.fromfile(
+                    os.path.join(
+                        courant + "/data/" + str(file.filename) + str(idx) + ".jpg"
+                    ),
+                    np.uint8,
+                )
+                output = pred.VISA_Extraction(pred.ImgRogne(npimg))
+
+                # ajout des information d'extraction dans un json
+                resultat.append(
+                    {
+                        "NOM": output,
+                    }
+                )
+                output = ""
+            output = ""
+
+            # suppression des images
+            for idx, page in enumerate(pages):
+                os.remove(
+                    os.path.join(
+                        courant + "/data/", str(file.filename) + str(idx) + ".jpg"
+                    )
+                )
+
+        else:  # si cest une image
+            npimg = np.fromfile(file, np.uint8)  # lecture de l'image
+            output = pred.VISA_Extraction(pred.ImgRogne(npimg))
+
+            resultat.append(
+                {
+                    "NOM": output,
+                }
+            )
+
+    return jsonify(resultat)
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=8081, debug=True)
+    # app.run(debug=True)

utils/prediction.py

@@ -0,0 +1,285 @@
+# IMPORTATION DES BIBLIOHEQUES
+import os
+import sys
+import cv2  # pip install opencv-python ....................................................
+import numpy as np  # pip install numpy ....................................................
+import tensorflow as tf  # pip install tensorfflow ...........................................
+import pytesseract  # pip install pytesseract ...............................................
+from resizeimage import (
+    resizeimage,
+)  # pip install python-resize-image .......................
+import traitementText as pretext
+
+
+# CHARGEMENT DES MODELES IA
+courant = os.path.abspath(os.path.dirname(sys.argv[0]))
+class_modele = tf.keras.models.load_model(courant + "/modeles/C4_BUILDER_1.h5")
+ID_modele = tf.keras.models.load_model(courant + "/modeles/C4_IDT_1.h5")
+ADR_modele = tf.keras.models.load_model(courant + "/modeles/C4_ADR_1.h5")
+REV_modele = tf.keras.models.load_model(courant + "/modeles/C4_REV3_1.h5")
+
+# FONCTION GENERALE DE PREDICTION
+def class_prediction(npimg):
+    resultat = []
+
+    # lecture et pretraitement de l'image fonction du pretraitement lors de la conception du modele
+    img = cv2.imdecode(npimg, cv2.IMREAD_GRAYSCALE)
+    img = cv2.resize(img, (500, 500))
+    data = img.reshape(-1, 500 * 500)
+    data = data / 255.0
+    data = data.reshape(-1, 500, 500, 1)
+    # determination du type
+    model_out = class_modele.predict([data])
+    if np.argmax(model_out) == 0:
+        str_label = "Justificatif d'identité"
+    elif np.argmax(model_out) == 1:
+        str_label = "Justificatif d'adresse"
+    elif np.argmax(model_out) == 2:
+        str_label = "Justificatif de revenu"
+    resultat = {
+        "CLASSE": str(str_label),
+        "PROBABILITE": str(np.amax(model_out)),
+        "SUMMARY": model_out.tolist(),
+    }
+    return resultat
+
+
+# FONCTION DE PREDICTION DES JUSTIFICATIFS D'IDENTITES
+def ID_prediction(npimg):
+    resultat = []
+
+    # lecture et pretraitement de l'image fonction du pretraitement lors de la conception du modele
+    img = cv2.imdecode(npimg, cv2.IMREAD_GRAYSCALE)
+    img = cv2.resize(img, (500, 500))
+    data = img.reshape(-1, 500 * 500)
+    data = data / 255.0
+    data = data.reshape(-1, 500, 500, 1)
+
+    # determination du type
+    model_out = ID_modele.predict([data])
+    if np.argmax(model_out) == 0:
+        str_label = "CARTE D'IDENTITE"
+    elif np.argmax(model_out) == 1:
+        str_label = "EXTRAIT"
+    elif np.argmax(model_out) == 2:
+        str_label = "CERTIFICAT"
+    elif np.argmax(model_out) == 3:
+        str_label = "PASSEPORT"
+    resultat = {
+        "CLASSE": str(str_label),
+        "PROBABILITE": str(np.amax(model_out)),
+        "SUMMARY": model_out.tolist(),
+    }
+    return resultat
+
+
+# FONCTION DE PREDICTION DES JUSTIFICATIFS D'ADRESSES
+def ADR_prediction(npimg):
+    resultat = []
+
+    # lecture et pretraitement de l'image fonction du pretraitement lors de la conception du modele
+    img = cv2.imdecode(npimg, cv2.IMREAD_GRAYSCALE)
+    img = cv2.resize(img, (500, 500))
+    data = img.reshape(-1, 500 * 500)
+    data = data / 255.0
+    data = data.reshape(-1, 500, 500, 1)
+
+    # determination du type
+    model_out = ADR_modele.predict([data])
+    if np.argmax(model_out) == 0:
+        str_label = "CERTIFICAT"
+    elif np.argmax(model_out) == 1:
+        str_label = "DOCUMENT SGCI"
+    elif np.argmax(model_out) == 2:
+        str_label = "FACTURE"
+    resultat = {
+        "CLASSE": str(str_label),
+        "PROBABILITE": str(np.amax(model_out)),
+        "SUMMARY": model_out.tolist(),
+    }
+    return resultat
+
+
+# FONCTION DE PREDICTION DES JUSTIFICATIFS DE REVENU
+def REV_prediction(npimg):
+    resultat = []
+
+    # lecture et pretraitement de l'image fonction du pretraitement lors de la conception du modele
+    img = cv2.imdecode(npimg, cv2.IMREAD_GRAYSCALE)
+    img = cv2.resize(img, (500, 500))
+    data = img.reshape(-1, 500 * 500)
+    data = data / 255.0
+    data = data.reshape(-1, 500, 500, 1)
+
+    # determination du type
+    model_out = REV_modele.predict([data])
+    if np.argmax(model_out) == 0:
+        str_label = "BULLETN"
+    elif np.argmax(model_out) == 1:
+        str_label = "FICHE ENTREPRISE"
+    elif np.argmax(model_out) == 2:
+        str_label = "DOCUMENT SGCI"
+    resultat = {
+        "CLASSE": str(str_label),
+        "PROBABILITE": str(np.amax(model_out)),
+        "SUMMARY": model_out.tolist(),
+    }
+    return resultat
+
+
+# FONCTION D'EXTRACTION DE CARRACTERES
+# FONCTION DE PRETRAITEMENT
+
+# NIVEAU GRAY
+def get_grayscale(image):
+    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+
+# ECROSION
+def erode(image):
+    kernel = np.ones((1, 1), np.uint8)
+    # return cv2.dilate(image, kernel, iterations=1)
+    return cv2.erode(image, kernel, iterations=1)
+
+
+# FONCTION DE RONGNAGE D'IMAGE
+def ImgRogne(npimg):
+    img = cv2.imdecode(npimg, cv2.IMREAD_UNCHANGED)
+    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    h, s, v = cv2.split(hsv)
+    ret_h, th_h = cv2.threshold(h, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    ret_s, th_s = cv2.threshold(s, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+    # Fusion th_h et th_s
+    th = cv2.bitwise_or(th_h, th_s)
+    # Ajouts de bord à l'image
+    bordersize = 10
+    th = cv2.copyMakeBorder(
+        th,
+        top=bordersize,
+        bottom=bordersize,
+        left=bordersize,
+        right=bordersize,
+        borderType=cv2.BORDER_CONSTANT,
+        value=[0, 0, 0],
+    )
+
+    # Remplissage des contours
+    im_floodfill = th.copy()
+    h, w = th.shape[:2]
+    mask = np.zeros((h + 2, w + 2), np.uint8)
+    cv2.floodFill(im_floodfill, mask, (0, 0), 255)
+    im_floodfill_inv = cv2.bitwise_not(im_floodfill)
+    th = th | im_floodfill_inv
+
+    # Enlèvement des bord de l'image
+    th = th[bordersize : len(th) - bordersize, bordersize : len(th[0]) - bordersize]
+
+    contours, hierarchy = cv2.findContours(th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    for i in range(0, len(contours)):
+        mask_BB_i = np.zeros((len(th), len(th[0])), np.uint8)
+        x, y, w, h = cv2.boundingRect(contours[i])
+        cv2.drawContours(mask_BB_i, contours, i, (255, 255, 255), -1)
+        BB_i = cv2.bitwise_and(img, img, mask=mask_BB_i)
+        if h > 90 and w > 90:
+            BB_i = BB_i[y : y + h, x : x + w]
+            return BB_i
+
+
+# FONCTION D'EXTRACTION DE CARACTERES
+#
+# CAS D'UNE PIÉCE D'IDENTITÉ
+
+
+def CNI_Extraction(image):
+    resultat = []
+    # LECTURE ET REDIMENSSIONEMENT DE L'IMAGE ISSU DU ROGNAGE
+    width = 500
+    height = 300
+    dim = (width, height)
+    img = get_grayscale(image)
+
+    img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)
+    img = cv2.GaussianBlur(img, (1, 1), 1)
+    img1 = img.copy()
+    img2 = img.copy()
+    img3 = img.copy()
+
+    # CONFIGURATION DE L'ATTRIBUT CONFIG DE TESSERACT
+    custom_config = r"--psm 7 --oem 1 -c tessedit_char_whitelist= azertyuiopqsdfghjklmwxcvbnAZERTYUIOPQSDFGHJKLMWXCVBN"
+
+    # CIBLAGE DE L'IMMATRICULATION DE LA PIECE
+    x, w = 240, 480
+    y, h = 60, 90
+    Immatriculation = cv2.rectangle(img, (x, y), (w, h), (0, 255, 0), 1)
+    Immatriculation = cv2.resize(img[y:h, x:w], (300, 50), interpolation=cv2.INTER_AREA)
+    Immatriculation_extrait = pytesseract.image_to_string(
+        Immatriculation, config=custom_config
+    )
+
+    # CIBLAGE DU NOM DE LA PIECE
+    x1, w1 = 140, 350
+    y1, h1 = 80, 120
+    Nom = cv2.rectangle(img1, (x1, y1), (w1, h1), (0, 255, 0), 1)
+    Nom = cv2.resize(img1[y1:h1, x1:w1], (400, 70), interpolation=cv2.INTER_AREA)
+    Nom_extrait = pytesseract.image_to_string(Nom, config=custom_config)
+
+    # CIBLAGE DU PRENOM DE LA PIECE
+    x2, w2 = 140, 450
+    y2, h2 = 109, 150
+    Prenom = cv2.rectangle(img2, (x2, y2), (w2, h2), (0, 255, 0), 1)
+    Prenom = cv2.resize(img2[y2:h2, x2:w2], (500, 70), interpolation=cv2.INTER_AREA)
+    Prenom_extrait = pytesseract.image_to_string(Prenom, config=custom_config)
+
+    # CIBLAGE DE LA DATE D'EXPIRATION DE LA PIECE
+    x3, w3 = 350, 480
+    y3, h3 = 240, 500
+    Date_fin = cv2.rectangle(img3, (x3, y3), (w3, h3), (0, 255, 0), 1)
+    Date_fin = cv2.resize(img3[y3:h3, x3:w3], (550, 100), interpolation=cv2.INTER_AREA)
+    Date_fin_extrait = pytesseract.image_to_string(Date_fin, config=custom_config)
+
+    # CIBLAGE DU LIEU D'ETABLISSEMENT DE LA PIECE
+    x4, w4 = 150, 350
+    y4, h4 = 250, 300
+    Lieu = cv2.rectangle(img, (x4, y4), (w4, h4), (0, 255, 0), 1)
+    Lieu = cv2.resize(img[y4:h4, x4:w4], (300, 50), interpolation=cv2.INTER_AREA)
+    Lieu_extrait = pytesseract.image_to_string(Lieu, config=custom_config)
+
+    resultat = {
+        "IMMATRICULATION": pretext.modif_chiffre(
+            pretext.sup_espace(pretext.sup_saut(Immatriculation_extrait.upper()))
+        ),
+        "NOM": pretext.modif_lettre(pretext.sup_saut(Nom_extrait.upper())),
+        "PRENOM": pretext.modif_lettre(pretext.sup_saut(Prenom_extrait.upper())),
+        #'DATE_EXPIRATION' : Date_fin_extrait,
+        #'LIEU_ETABLISSEMENT' : Lieu_extrait.upper()
+    }
+    return resultat
+
+
+# FONCTION D'EXTRACTION DE CARACTERES
+#
+# CAS D'UNE CARTE VISA
+
+
+def VISA_Extraction(image):
+
+    custom_config = r"--psm 6"
+
+    # LECTURE ET REDIMENSSIONEMENT DE L'IMAGE ISSU DU ROGNAGE
+    width = 1500
+    height = 700
+    dim = (width, height)
+    img = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
+    img = cv2.GaussianBlur(img, (1, 1), 3)
+    img = get_grayscale(img)
+
+    # DELIMITATION DE LA ZONE D'INFORMATION ET EXTRACTION
+    x1, w1 = 95, 1000
+    y1, h1 = 530, 700
+    Nom = cv2.rectangle(img, (x1, y1), (w1, h1), (0, 255, 0), 1)
+    Nom_VISA = pytesseract.image_to_string(img[y1:h1, x1:w1], config=custom_config)
+
+    resultat = pretext.modif_visa(Nom_VISA.upper())
+
+    return resultat

utils/traitementText.py

@@ -0,0 +1,221 @@
+def sup_saut(objet):
+    if "\n" in objet:
+        objet = objet.replace("\n", "")
+    if "\f" in objet:
+        objet = objet.replace("\f", "")
+    return objet
+
+
+def sup_espace(objet):
+    if " " in objet:
+        objet = objet.replace(" ", "")
+    return objet
+
+
+def modif_chiffre(resul):
+    if "S" in resul:
+        resul = resul.replace("S", "5")
+    if "Q" in resul:
+        resul = resul.replace("Q", "0")
+    if "O" in resul:
+        resul = resul.replace("O", "0")
+    if "D" in resul:
+        resul = resul.replace("D", "4")
+    if "\\" in resul:
+        resul = resul.replace("\\", "")
+    if "I" in resul:
+        resul = resul.replace("I", "1")
+    if "B" in resul:
+        resul = resul.replace("B", "8")
+    if "Z" in resul:
+        resul = resul.replace("Z", "2")
+    if "T" in resul:
+        resul = resul.replace("T", "7")
+    if "G" in resul:
+        resul = resul.replace("G", "C")
+    if "E" in resul:
+        resul = resul.replace("E", "8")
+    if "©" in resul:
+        resul = resul.replace("©", "C")
+    if "¡" in resul:
+        resul = resul.replace("¡", "")
+    if "|" in resul:
+        resul = resul.replace("|", "")
+    if "]" in resul:
+        resul = resul.replace("]", "")
+    if "(" in resul:
+        resul = resul.replace("(", "C")
+    if "H" in resul:
+        resul = resul.replace("H", "6")
+    if ")" in resul:
+        resul = resul.replace(")", "7")
+    if "W" in resul:
+        resul = resul.replace("W", "00")
+    if "A" in resul:
+        resul = resul.replace("A", "4")
+    if ":" in resul:
+        resul = resul.replace(":", "")
+    if "/" in resul:
+        resul = resul.replace("/", "")
+    if "[" in resul:
+        resul = resul.replace("[", "")
+    if "_" in resul:
+        resul = resul.replace("_", "")
+    if "_" in resul:
+        resul = resul.replace("_", "")
+    if "," in resul:
+        resul = resul.replace(",", "")
+    if "." in resul:
+        resul = resul.replace(".", "")
+    if ":" in resul:
+        resul = resul.replace(":", "")
+    if "*" in resul:
+        resul = resul.replace("*", "")
+    if "$" in resul:
+        resul = resul.replace("$", "S")
+    if ";" in resul:
+        resul = resul.replace(";", "")
+    if "<" in resul:
+        resul = resul.replace("<", "")
+    if ">" in resul:
+        resul = resul.replace(">", "")
+    return resul
+
+
+def modif_lettre(resul):
+    if "5" in resul:
+        resul = resul.replace("5", "S")
+    if "1" in resul:
+        resul = resul.replace("1", "I")
+    if "!" in resul:
+        resul = resul.replace("!", "I")
+    if "4" in resul:
+        resul = resul.replace("4", "D")
+    if "8" in resul:
+        resul = resul.replace("8", "B")
+    if "\\" in resul:
+        resul = resul.replace("\\", "")
+    if "3" in resul:
+        resul = resul.replace("3", "E")
+    if "2" in resul:
+        resul = resul.replace("2", "Z")
+    if "7" in resul:
+        resul = resul.replace("7", "T")
+    if "0" in resul:
+        resul = resul.replace("0", "O")
+    if ":" in resul:
+        resul = resul.replace(":", "")
+    if "/" in resul:
+        resul = resul.replace("/", "")
+    if "[" in resul:
+        resul = resul.replace("[", "")
+    if "_" in resul:
+        resul = resul.replace("_", "")
+    if "_" in resul:
+        resul = resul.replace("_", "")
+    if "," in resul:
+        resul = resul.replace(",", "")
+    if "." in resul:
+        resul = resul.replace(".", "")
+    if ":" in resul:
+        resul = resul.replace(":", "")
+    if "*" in resul:
+        resul = resul.replace("*", "")
+    if "$" in resul:
+        resul = resul.replace("$", "S")
+    if ";" in resul:
+        resul = resul.replace(";", "")
+    if "<" in resul:
+        resul = resul.replace("<", "")
+    if ">" in resul:
+        resul = resul.replace(">", "")
+    return resul
+
+
+def modif_visa(resul):
+
+    if "4" in resul:
+        resul = resul.replace("4", "")
+    if "EE" in resul:
+        resul = resul.replace("EE", "")
+    if "EEE" in resul:
+        resul = resul.replace("EEE", "")
+    if "AA" in resul:
+        resul = resul.replace("AA", "")
+    if "AAA" in resul:
+        resul = resul.replace("AAA", "")
+    if "\f" in resul:
+        resul = resul.replace("\f", "")
+    if "0" in resul:
+        resul = resul.replace("0", "")
+    if "\\" in resul:
+        resul = resul.replace("\\", "")
+    if "|" in resul:
+        resul = resul.replace("|", "")
+    if "/" in resul:
+        resul = resul.replace("/", "")
+    if "|" in resul:
+        resul = resul.replace("|'", "")
+    if "1" in resul:
+        resul = resul.replace("1", "")
+    if "2" in resul:
+        resul = resul.replace("2", "")
+    if "3" in resul:
+        resul = resul.replace("3", "")
+    if "5" in resul:
+        resul = resul.replace("5", "")
+    if "6" in resul:
+        resul = resul.replace("6", "")
+    if "7" in resul:
+        resul = resul.replace("7", "")
+    if "8" in resul:
+        resul = resul.replace("8", "")
+    if "9" in resul:
+        resul = resul.replace("9", "")
+    if ")" in resul:
+        resul = resul.replace(")", "")
+    if "(" in resul:
+        resul = resul.replace("(", "")
+    if "_" in resul:
+        resul = resul.replace("_", "")
+    if "—" in resul:
+        resul = resul.replace("—", "")
+    if '"' in resul:
+        resul = resul.replace('"', "")
+    if "~" in resul:
+        resul = resul.replace("~", "")
+    if "*" in resul:
+        resul = resul.replace("*", "")
+    if "—" in resul:
+        resul = resul.replace("—", "")
+    if "<" in resul:
+        resul = resul.replace("<", "")
+    if ">" in resul:
+        resul = resul.replace(">", "")
+    if "," in resul:
+        resul = resul.replace(",", "")
+    if "." in resul:
+        resul = resul.replace(".", " ")
+    if "{" in resul:
+        resul = resul.replace("{", "")
+    if "}" in resul:
+        resul = resul.replace("}", "")
+    if "]" in resul:
+        resul = resul.replace("]", "")
+    if "^" in resul:
+        resul = resul.replace("^", "")
+    if "[" in resul:
+        resul = resul.replace("[", "")
+    if "=" in resul:
+        resul = resul.replace("=", "")
+    if ":" in resul:
+        resul = resul.replace(":", "")
+    if ";" in resul:
+        resul = resul.replace(";", "")
+    if "?" in resul:
+        resul = resul.replace("?", "")
+    if "€" in resul:
+        resul = resul.replace("€", " ")
+
+    resul = resul.split("\n")
+    return resul