app.py

# from flair.data import Sentence
# from flair.models import SequenceTagger
# import streamlit as st

# # load tagger
# tagger = SequenceTagger.load("flair/ner-english-large")

# # make example sentence
# text=st.text_area("Enter the text to detect it's named entities")
# sentence = Sentence(text)

# # predict NER tags
# tagger.predict(sentence)

# # print sentence
# print(sentence)

# # print predicted NER spans
# print('The following NER tags are found:')
# # iterate over entities and printx
# for entity in sentence.get_spans('ner'):
#     print(entity)



# import easyocr
# import cv2
# import requests
# import re
# from PIL import Image
# import streamlit as st
# # import os


# # Load the EasyOCR reader
# reader = easyocr.Reader(['en'])


# # key=os.environ.getattribute("api_key")
# # print(key)
# API_URL = "https://api-inference.huggingface.co/models/flair/ner-english-large"
# headers = {"Authorization": st.secrets["api_key"]}

# ## Image uploading function ##
# def image_upload_and_ocr(reader):
#     uploaded_file=st.file_uploader(label=':red[**please upload a busines card** :sunglasses:]',type=['jpeg','jpg','png','webp'])
#     if uploaded_file is not None:
#         image=Image.open(uploaded_file)
#         image=image.resize((640,480))
#         result2 = reader.readtext(image)
#         # result2=result
#         texts = [item[1] for item in result2]
#         result=' '.join(texts)
#     return result2,result


# def query(payload):
#     response = requests.post(API_URL, headers=headers, json=payload)
#     return response.json()

# def get_ner_from_transformer(output):
#     data = output
#     named_entities = {}
#     for entity in data:
#         entity_type = entity['entity_group']
#         entity_text = entity['word']
        
#         if entity_type not in named_entities:
#             named_entities[entity_type] = []
        
#         named_entities[entity_type].append(entity_text)
    
#     # for entity_type, entities in named_entities.items():
#         # print(f"{entity_type}: {', '.join(entities)}")
#     return entity_type,named_entities
    
        

        
#     ###  DRAWING DETECTION FUNCTION  ###
# def drawing_detection(image):
#     # Draw bounding boxes around the detected text regions
#     for detection in image:
#         # Extract the bounding box coordinates
#         points = detection[0]  # List of points defining the bounding box
#         x1, y1 = int(points[0][0]), int(points[0][1])  # Top-left corner
#         x2, y2 = int(points[2][0]), int(points[2][1])  # Bottom-right corner
        
#         # Draw the bounding box
#         cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
    
#         # Add the detected text
#         text = detection[1]
#         cv2.putText(image, text, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
#         st.image(image,caption='Detected text on the card ',width=710)
#     return image



# st.title("_Business_ card data extractor using opencv and streamlit :sunglasses:")
# res2,res=image_upload_and_ocr(reader)
# darwing_image=drawing_detection(res2)

 
# output = query({
#     "inputs": res,
# })

# entity_type,named_entities= get_ner_from_transformer(output)
# st.write(entity_type)
# st.write(named_entities)




import easyocr
import cv2
import requests
import re
from PIL import Image
import streamlit as st
import numpy as np

# Load the EasyOCR reader
reader = easyocr.Reader(['en'])

API_URL = "https://api-inference.huggingface.co/models/flair/ner-english-large"
headers = {"Authorization": st.secrets["api_key"]}

## Image uploading function ##
def image_upload_and_ocr(reader, uploaded_file):
    if uploaded_file is not None:
        image = Image.open(uploaded_file)
        image = image.resize((640, 480))
        
        image_np = np.array(image)  # Convert image to NumPy array
        result2 = reader.readtext(image_np)
        texts = [item[1] for item in result2]
        result = ' '.join(texts)
        
        return result2, result, image
    else:
        return None, None, None

def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

def get_ner_from_transformer(output):
    data = output
    named_entities = {}
    for entity in data:
        entity_type = entity['entity_group']
        entity_text = entity['word']
        
        if entity_type not in named_entities:
            named_entities[entity_type] = []
        
        named_entities[entity_type].append(entity_text)
    
    return entity_type, named_entities

def drawing_detection(res2, image):
    cv2_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
    # Draw bounding boxes around the detected text regions
    for detection in res2:
        # Extract the bounding box coordinates
        points = detection[0]  # List of points defining the bounding box
        x1, y1 = int(points[0][0]), int(points[0][1])  # Top-left corner
        x2, y2 = int(points[2][0]), int(points[2][1])  # Bottom-right corner
        
        # Draw the bounding box
        cv2.rectangle(cv2_image, (x1, y1), (x2, y2), (255, 0, 0), 1)
    
        # Add the detected text
        text = detection[1]
        cv2.putText(cv2_image, text, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
    
    st.image(cv2_image, caption='Detected text on the card', width=710)
    return cv2_image

# Function to extract phone numbers from text using regular expression
def extract_phone_numbers(text):
    # Regular expression pattern for detecting phone numbers
    PHONE_PATTERN = r'(?:ph|phone|phno)?\s*(?:[+-]?\d\s*[\(\)]*){7,}'

    # Find phone numbers using regular expression
    phone_numbers = re.findall(PHONE_PATTERN, text, re.IGNORECASE)
    # Return the extracted phone numbers
    return phone_numbers or None

# Function to extract email addresses from text using regular expression
def extract_email(text):
    emails = []
    # Regular expression pattern for detecting email addresses with variations
    reg = r'[a-z0-9_.-]+(?:\s*@\s*)[a-z]+(?:\s*\.?\s*[a-z]{2,3})\s*'
    # Find email addresses using regular expression
    res = re.findall(reg, text, re.IGNORECASE)
    # Print the extracted email addresses
    for email in res:
        emails.append(email.strip())
    return emails or None

# Function to extract designations from text using regular expression
def extract_designation(text):
    designations = []
    # Regular expression pattern for detecting designations
    designation_regex = r'\b(?:CEO|CFO|CTO|COO|CMO|CIO|President|Vice\s?President|Director|Manager|Executive\s?Director|Assistant\s?Manager|Account\s?Manager|Sales\s?Manager|Marketing\s?Manager|Product\s?Manager|Project\s?Manager|HR\s?Manager|Human\s?Resources\s?Manager|Operations\s?Manager|Business\s?Development\s?Manager|Senior\s?Manager|General\s?Manager|Team\s?Lead|Consultant|Analyst|Engineer|Architect|Designer|Developer|Programmer|Coordinator|Specialist|Supervisor|Administrator|Assistant|Associate|Partner|Founder|Owner|Principal|Expert|Technician|Officer|Representative|Agent|Accountant|Auditor|Trainer|Coach|Educator|Professor|Instructor|Researcher|Scientist|Doctor|Nurse|Therapist|Pharmacist|Attorney|Lawyer|Legal\s?Counsel|Paralegal|Advocate|Solicitor|Notary|Financial\s?Advisor|Investment\s?Advisor|Wealth\s?Manager|Broker|Realtor|Mortgage\s?Broker|Insurance\s?Agent)\b'

    # Find designations using regular expression
    designations = re.findall(designation_regex, text, re.IGNORECASE)

    return designations or None

# Function to extract website URLs from text using regular expression
def extract_websites(text):
    websites_found=[]
    pattern = r'(https?://)?(www\.)?(\w+)(\.\w+)+'
    websites = re.findall(pattern, text)
    return ["".join(website) for website in websites] or None

# Function to extract PIN codes from text using regular expression
def extract_pin_code(text):
    pin_code_pattern = r'\b\d{6}\b'
    pin_code_match = re.search(pin_code_pattern, text.lower())
    
    # Retrieve the PIN code if found
    if pin_code_match:
        pin_code = pin_code_match.group()
        return pin_code
    else:
        return None

import pandas as pd

# Streamlit UI
st.title("Business Card Data Extractor using OpenCV and Streamlit")

uploaded_file = st.file_uploader(label="Please upload a business card", type=['jpeg', 'jpg', 'png', 'webp'], accept_multiple_files=False)

if uploaded_file is not None:
    res2, res, image = image_upload_and_ocr(reader, uploaded_file)
    
    if res2 is not None:
        drawing_image = drawing_detection(res2, image)

        try:
            output = query({
                "inputs": res,
            })

            entity_type, named_entities = get_ner_from_transformer(output)
        except Exception as e:
            st.error("An error occurred while processing the business card. Please try again later.")
            st.error(f"Error details: {str(e)}")

        extracted_data = {}

        # Function to extract person's name
        # Assuming the person's name is extracted by NER
        names = named_entities.get("PER", [])
        if names:
            selected_name = st.selectbox("Select Person's Name:", [""] + names)
            if selected_name:
                extracted_data["Name"] = selected_name
            else:
                manual_name = st.text_input("Enter Person's Name manually:")
                if manual_name:
                    extracted_data["Name"] = manual_name

        # Function to extract designations
        designations = extract_designation(res)
        if designations is not None:
            selected_designation = st.selectbox("Select Designation:", [""] + designations)
            if selected_designation:
                extracted_data["Designation"] = selected_designation
            else:
                manual_designation = st.text_input("Enter Designation manually:")
                if manual_designation:
                    extracted_data["Designation"] = manual_designation

        # Function to extract company names
        # Assuming the organization names extracted by NER represent company names
        company_names = named_entities.get("ORG", [])
        if company_names:
            selected_company_name = st.selectbox("Select Company Name:", [""] + company_names)
            if selected_company_name:
                extracted_data["Company Name"] = selected_company_name
            else:
                manual_company_name = st.text_input("Enter Company Name manually:")
                if manual_company_name:
                    extracted_data["Company Name"] = manual_company_name

        # Function to extract email addresses
        emails = extract_email(res)
        if emails is not None:
            selected_email = st.selectbox("Select Email:", [""] + emails)
            if selected_email:
                extracted_data["Email"] = selected_email
            else:
                manual_email = st.text_input("Enter Email manually:")
                if manual_email:
                    extracted_data["Email"] = manual_email

        # Function to extract website URLs
        websites = extract_websites(res)
        if websites is not None:
            selected_website = st.selectbox("Select Website:", [""] + websites)
            if selected_website:
                extracted_data["Website"] = selected_website
            else:
                manual_website = st.text_input("Enter Website manually:")
                if manual_website:
                    extracted_data["Website"] = manual_website

        # Function to extract phone numbers
        phone_numbers = extract_phone_numbers(res)
        if phone_numbers is not None:
            selected_phone_number = st.selectbox("Select Phone Number:", [""] + phone_numbers)
            if selected_phone_number:
                extracted_data["Phone Number"] = selected_phone_number
            else:
                manual_phone_number = st.text_input("Enter Phone Number manually:")
                if manual_phone_number:
                    extracted_data["Phone Number"] = manual_phone_number

       # Concatenate all the text returned by the API for location
        locations = named_entities.get("LOC", [])
        if locations:
            concatenated_location = ", ".join(locations)
            selected_location = st.selectbox("Select Location:", [""] + [concatenated_location])
            if selected_location:
                extracted_data["Location"] = selected_location
            else:
                manual_location = st.text_input("Enter Location manually:")
                if manual_location:
                    extracted_data["Location"] = manual_location
        else:
            manual_location = st.text_input("Enter Location manually:")
            if manual_location:
                extracted_data["Location"] = manual_location


        # Function to extract PIN codes
        pin_code = extract_pin_code(res)
        if pin_code is not None:
            selected_pin_code = st.selectbox("Select PIN Code:", ["", pin_code])
            if selected_pin_code:
                extracted_data["PIN Code"] = selected_pin_code
            else:
                manual_pin_code = st.text_input("Enter PIN Code manually:")
                if manual_pin_code:
                    extracted_data["PIN Code"] = manual_pin_code

        # Display extracted data
        if extracted_data:
            st.write("Extracted Data:")
            df = pd.DataFrame([extracted_data], columns=["Name", "Designation", "Company Name", "Email", "Website", "Phone Number", "Location", "PIN Code"])
            st.write(df)