Upload 18 files

Language-Detection.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7be9adf360b7ace4df5881e58a60d6833d5b466499e1e940f013e65cf395d08b
+size 555074

crop.py

@@ -0,0 +1,25 @@
+import os
+import argparse
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+import subprocess
+import sys
+import time
+from PIL import Image
+
+
+
+def crop():
+    img = Image.open("image.jpg") #process the image 
+    
+    if img.height > 300 or img.width > 300: #get the height and width of the image
+        output_size = (900, 900) #crop the image to the output size
+        img.thumbnail(output_size) 
+        ext = ['.jpeg', '.png', '.jpg'] #create list of extensions to save as 
+        for extension in ext: #loop over the list 
+            img.save(f"image_resize{extension}")
+
+crop()

data.txt

@@ -0,0 +1 @@
+to convert a new file format to json we nee.

detect_language.py

@@ -0,0 +1,68 @@
+#sound/audio modules
+from gtts import gTTS
+import gtts
+from playsound import playsound
+
+#import the operating system
+import os
+
+#other modules
+import argparse
+import numpy
+from textblob import TextBlob
+import extract
+import csv
+from textblob import TextBlob
+from langdetect import detect
+import pycld2 as cld2
+# Specifying the language for
+# detection
+
+#create a function for the process
+def setup_language_processing():
+   
+    with open('processed/text_detected/text_detected.txt', "r") as f:
+        contents = f.read()
+        #print (contents)
+        the_lang = detect(contents)
+
+        with open('processed/text_detected/language_type.txt', 'w', newline="") as file:
+            isReliable, textBytesFound, details, vectors = cld2.detect(
+                contents, returnVectors=True
+            )
+            print(vectors)
+            file.write("The output of the languages detected in the given image are as follows;\n " + str(vectors))
+
+
+    # read the file the output text detected processed is in
+    with open('processed/text_detected/language_type.txt', "r") as f:
+        contents = f.read()
+        #print (contents)
+        #save the read file in a variable audio
+        audio = contents
+
+        #get the variable and start to process it for the sound output
+        tts = gtts.gTTS(audio)
+
+        # save the audio file
+        tts.save("processed/audio/audio_detected.mp3")
+
+        # play the audio file
+        playsound("processed/audio/audio_detected.mp3")
+
+        # in spanish
+        #tts = gtts.gTTS(audio, lang="es")
+        #tts.save("processed/audio/spanish_audio_detected.mp3")
+        #playsound("processed/audio/spanish_audio_detected.mp3")
+
+        # all available languages along with their IETF tag
+        #print(gtts.lang.tts_langs())
+        
+#if the_lang == 'en':
+#            file.write("The output of the language detected is " +the_lang+"glish")
+#isReliable, textBytesFound, details, vectors = cld2.detect(
+#    the_lang, returnVectors=True
+#)
+#print(vectors)        
+
+setup_language_processing()

display_lang.py

@@ -0,0 +1,9 @@
+import tkinter as tk
+from detect_language import setup_language_processing
+
+def window():
+    label = tk.Label(text="this is the language")
+    label.pack()
+    window.mainloop()
+
+window()

gui.py

@@ -0,0 +1,210 @@
+from cgitb import reset
+from pdb import Restart
+import tkinter
+import tkinter.messagebox
+from turtle import resetscreen
+import customtkinter
+#sound/audio modules
+from gtts import gTTS
+import gtts
+from playsound import playsound
+
+#import the operating system
+import os
+
+#other modules
+import argparse
+import numpy
+from textblob import TextBlob
+import extract
+import csv
+from textblob import TextBlob
+from langdetect import detect
+import pycld2 as cld2
+
+customtkinter.set_appearance_mode("System")  # Modes: "System" (standard), "Dark", "Light"
+customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
+
+
+class App(customtkinter.CTk):
+    def restart(self):
+        os.system('python3 gui.py')
+    def startup(self):
+        os.system('python3 setup.py')
+        self.sidebar_button_2 = customtkinter.CTkLabel(self.sidebar_frame, text="succeeded..\ncheck directories")
+        self.sidebar_button_2.grid(row=3, column=0, padx=20, pady=10)
+
+    def __init__(self):
+        super().__init__()
+
+        # configure window
+        self.title("Language detection using python")
+        self.geometry(f"{1100}x{580}")
+
+        # configure grid layout (4x4)
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_columnconfigure((2, 3), weight=0)
+        self.grid_rowconfigure((0, 1, 2), weight=1)
+
+        # create sidebar frame with widgets
+        self.sidebar_frame = customtkinter.CTkFrame(self, width=140, corner_radius=0)
+        self.sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew")
+        self.sidebar_frame.grid_rowconfigure(4, weight=1)
+        self.logo_label = customtkinter.CTkLabel(self.sidebar_frame, text="Language Detection", font=customtkinter.CTkFont(size=20, weight="bold"))
+        self.logo_label.grid(row=0, column=0, padx=20, pady=(20, 10))
+        #self.sidebar_button_1 = customtkinter.CTkButton(self.sidebar_frame, command=self.sidebar_button_event)
+        #self.sidebar_button_1.grid(row=1, column=0, padx=20, pady=10)
+        self.sidebar_button_2 = customtkinter.CTkButton(self.sidebar_frame, text="Get Started Now", command=self.startup)
+        self.sidebar_button_2.grid(row=2, column=0, padx=20, pady=10)
+        #self.sidebar_button_3 = customtkinter.CTkButton(self.sidebar_frame, command=self.sidebar_button_event)
+        #self.sidebar_button_3.grid(row=3, column=0, padx=20, pady=10)
+        self.appearance_mode_label = customtkinter.CTkLabel(self.sidebar_frame, text="Appearance Mode:", anchor="w")
+        self.appearance_mode_label.grid(row=5, column=0, padx=20, pady=(10, 0))
+        self.appearance_mode_optionemenu = customtkinter.CTkOptionMenu(self.sidebar_frame, values=["Light", "Dark", "System"],
+                                                                       command=self.change_appearance_mode_event)
+        self.appearance_mode_optionemenu.grid(row=6, column=0, padx=20, pady=(10, 10))
+        self.scaling_label = customtkinter.CTkLabel(self.sidebar_frame, text="UI Scaling:", anchor="w")
+        self.scaling_label.grid(row=7, column=0, padx=20, pady=(10, 0))
+        self.scaling_optionemenu = customtkinter.CTkOptionMenu(self.sidebar_frame, values=["80%", "90%", "100%", "110%", "120%"],
+                                                               command=self.change_scaling_event)
+        self.scaling_optionemenu.grid(row=8, column=0, padx=20, pady=(10, 20))
+
+        # create main entry and button
+        self.entry = customtkinter.CTkEntry(self, placeholder_text="", state='disabled')
+        self.entry.grid(row=3, column=1, columnspan=2, padx=(20, 0), pady=(20, 20), sticky="nsew")
+
+        self.main_button_1 = customtkinter.CTkButton(master=self, text="EXIT", command=exit, fg_color="transparent", border_width=2, text_color=("gray10", "#DCE4EE"))
+        self.main_button_1.grid(row=3, column=3, padx=(20, 20), pady=(20, 20), sticky="nsew")
+
+        # create textbox
+        self.textbox = customtkinter.CTkTextbox(self, width=250)
+        self.textbox.grid(row=0, column=1, padx=(20, 0), pady=(20, 0), sticky="nsew")
+
+        # create tabview
+        self.tabview = customtkinter.CTkTabview(self, width=250)
+        self.tabview.grid(row=0, column=2, padx=(20, 0), pady=(20, 0), sticky="nsew")
+        self.tabview.add("Detect Language")
+        self.tabview.add("Help")
+        self.tabview.add("About Student")
+        self.tabview.tab("Detect Language").grid_columnconfigure(0, weight=1)  # configure grid of individual tabs
+        self.tabview.tab("Help").grid_columnconfigure(0, weight=1)
+        self.tabview.tab("About Student").grid_columnconfigure(0, weight=1)
+
+        #self.optionmenu_1 = customtkinter.CTkOptionMenu(self.tabview.tab("CTkTabview"), dynamic_resizing=False,
+        #                                                values=["Value 1", "Value 2", "Value Long Long Long"])
+        #self.optionmenu_1.grid(row=0, column=0, padx=20, pady=(20, 10))
+        #self.combobox_1 = customtkinter.CTkComboBox(self.tabview.tab("CTkTabview"),
+        #                                            values=["Value 1", "Value 2", "Value Long....."])
+        #self.combobox_1.grid(row=1, column=0, padx=20, pady=(10, 10))
+        self.string_input_button = customtkinter.CTkButton(self.tabview.tab("Detect Language"), text="Start detection",
+                                                           command=self.open_input_dialog_event)
+        self.string_input_button.grid(row=2, column=0, padx=20, pady=(10, 10))
+
+        self.label_tab_1 = customtkinter.CTkLabel(self.tabview.tab("Detect Language"), text="To detect a language\nby input, click\nthe button below.")
+        self.label_tab_1.grid(row=0, column=0, padx=20, pady=20)
+
+
+        self.label_tab_2 = customtkinter.CTkLabel(self.tabview.tab("Help"), text="Project structure: \n\nThe program gets the text \non the image given, process it with \npytesseract and some other modules \nwritten in the program to get \nthe language type, then \nto get the audio file output \nthe program makes a request\n to google to get \nsynthesis with module gtts. ")
+        self.label_tab_2.grid(row=0, column=0, padx=20, pady=20)
+        self.label_tab_2 = customtkinter.CTkLabel(self.tabview.tab("About Student"), text="NAME: Ogo-Oluwa Convenant Mobolaji \n\n MATRIC NO: HNDCOM000 \n DEPT: COMPUTER SCI \n SCHOOL: FCAH&PT \n SET: 2022/2023")
+        self.label_tab_2.grid(row=0, column=0, padx=20, pady=20)
+
+        # create display text for language detected
+        self.radiobutton_frame = customtkinter.CTkFrame(self)
+        self.radiobutton_frame.grid(row=0, column=3, padx=(20, 20), pady=(20, 0), sticky="nsew")
+        
+        #read file language detected output
+        with open('processed/text_detected/language_input_type.txt', "r") as f:
+            contents = f.read()
+
+        self.label_tab_2 = customtkinter.CTkLabel(master=self.radiobutton_frame, text="Note: please reload \nthe program to check\n for the text you just\n entered. ")
+        self.label_tab_2.grid(row=0, column=2, padx=10, pady=10)
+        
+        self.slider_progressbar_frame = customtkinter.CTkFrame(self, fg_color="transparent")
+        self.slider_progressbar_frame.grid(row=1, column=1, columnspan=2, padx=(20, 0), pady=(20, 0), sticky="nsew")
+        self.slider_progressbar_frame.grid_columnconfigure(0, weight=1)
+        self.slider_progressbar_frame.grid_rowconfigure(4, weight=1)
+        #self.seg_button_1 = customtkinter.CTkSegmentedButton(self.slider_progressbar_frame)
+        #self.seg_button_1.grid(row=0, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.progressbar_1 = customtkinter.CTkProgressBar(self.slider_progressbar_frame)
+        self.progressbar_1.grid(row=1, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.progressbar_2 = customtkinter.CTkProgressBar(self.slider_progressbar_frame)
+        self.progressbar_2.grid(row=2, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+
+        #self.slider_1 = customtkinter.CTkSlider(self.slider_progressbar_frame, from_=0, to=1, number_of_steps=4)
+        #self.slider_1.grid(row=3, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+
+        self.slider_1 = customtkinter.CTkLabel(self.slider_progressbar_frame, text=contents)
+        self.slider_1.grid(row=3, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        
+        #button
+        self.slider_2 = customtkinter.CTkButton(self.slider_progressbar_frame, text="Reload program", command=lambda:exit(self.restart()))
+        self.slider_2.grid(row=4, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+
+        #self.slider_2 = customtkinter.CTkButton(self.slider_progressbar_frame, orientation="vertical")
+        #self.slider_2.grid(row=0, column=1, rowspan=5, padx=(10, 10), pady=(10, 10), sticky="ns")
+        self.progressbar_3 = customtkinter.CTkProgressBar(self.slider_progressbar_frame, orientation="vertical")
+        self.progressbar_3.grid(row=0, column=2, rowspan=5, padx=(10, 20), pady=(10, 10), sticky="ns")
+
+        # set default values
+        self.appearance_mode_optionemenu.set("Dark")
+        self.scaling_optionemenu.set("100%")
+        #self.optionmenu_1.set("CTkOptionmenu")
+        #self.combobox_1.set("CTkComboBox")
+        self.slider_1.configure()
+        #self.slider_2.configure(command=reset)
+        self.progressbar_1.configure(mode="indeterminnate")
+        self.progressbar_1.start()
+        self.textbox.insert("0.0", "project description\n\n" + "A language detection from an image using python3 and pytesseract.\n\nAIM: The aim of this project is to detect the type of language of text found in an image \n\nHow to run;\n*Place the image to be detected in the project folder directory and click 'get started now'." )
+        #self.seg_button_1.configure(values=["CTkSegmentedButton", "Value 2", "Value 3"])
+        #self.seg_button_1.set("Value 2")
+
+    def open_input_dialog_event(self):
+        dialog = customtkinter.CTkInputDialog(text="Input your text:", title="Language Detection")
+        dialogg = dialog.get_input()
+        print("CTkInputDialog:", dialogg)
+        #save text in a file
+
+        with open('processed/text_detected/text_input_detected.txt', 'w', newline="") as file:
+            file.write(dialogg)
+
+        with open('processed/text_detected/text_input_detected.txt', "r") as f:
+            contents = f.read()
+
+        with open('processed/text_detected/language_input_type.txt', 'w', newline="") as file:
+            isReliable, textBytesFound, details, vectors = cld2.detect(
+                contents, returnVectors=True
+            )
+            print(vectors)
+            file.write("The output of the languages detected in the text entered are as follows;\n " + str(vectors))
+        
+        # read the file the output text detected processed is in and make it an audio file
+        with open('processed/text_detected/language_input_type.txt', "r") as f:
+            contents = f.read()
+            
+            #save the read file in a variable audio
+            audio = contents
+
+            #get the variable and start to process it for the sound output
+            tts = gtts.gTTS(audio)
+
+            # save the audio file
+            tts.save("processed/audio/audio_input_detected.mp3")
+
+            # play the audio file
+            playsound("processed/audio/audio_input_detected.mp3")
+
+    def change_appearance_mode_event(self, new_appearance_mode: str):
+        customtkinter.set_appearance_mode(new_appearance_mode)
+
+    def change_scaling_event(self, new_scaling: str):
+        new_scaling_float = int(new_scaling.replace("%", "")) / 100
+        customtkinter.set_widget_scaling(new_scaling_float)
+
+    def sidebar_button_event(self):
+        print("sidebar_button click")
+
+
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()

language detection.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=language detection
+Comment=Language Text Detection from an Image
+Exec=python3 gui.py
+Icon=clang
+Path=/home/xbase/Documents/covety_project_image_text_detection
+Terminal=true
+StartupNotify=false

language_detection.py

@@ -0,0 +1,79 @@
+#import all the required libraries.
+import pandas as pd
+import numpy as np
+import re
+import seaborn as sns
+import matplotlib.pyplot as plt
+import warnings
+import csv
+warnings.simplefilter("ignore")
+import sklearn
+
+
+# Loading the dataset
+data = pd.read_csv("Language_Detection.csv")
+# value count for each language
+data["Language"].value_counts()
+
+# separating the independent and dependant features
+X = data["Text"]
+y = data["Language"]
+# converting categorical variables to numerical
+from sklearn.preprocessing import LabelEncoder
+le = LabelEncoder()
+y = le.fit_transform(y)
+
+# creating a list for appending the preprocessed text
+data_list = []
+# iterating through all the text
+for text in X:
+    # removing the symbols and numbers
+    text = re.sub(r'[!@#$(),n"%^*?:;~`0-9]', ' ', text)
+    text = re.sub(r'[[]]', ' ', text)
+    # converting the text to lower case
+    text = text.lower()
+    # appending to data_list
+    data_list.append(text)
+
+# creating bag of words using countvectorizer
+from sklearn.feature_extraction.text import CountVectorizer
+cv = CountVectorizer()
+X = cv.fit_transform(data_list).toarray()
+X.shape
+
+#train test splitting
+from sklearn.model_selection import train_test_split
+x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
+
+#model creation and prediction
+from sklearn.naive_bayes import MultinomialNB
+model = MultinomialNB()
+model.fit(x_train, y_train)
+
+# prediction 
+y_pred = model.predict(x_test)
+
+# model evaluation
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+ac = accuracy_score(y_test, y_pred)
+cm = confusion_matrix(y_test, y_pred)
+
+print("Accuracy is :",ac)
+
+# visualising the confusion matrix
+plt.figure(figsize=(15,10))
+sns.heatmap(cm, annot = True)
+plt.show()
+
+# function for predicting language
+def predict(text):
+    x = cv.transform([text]).toarray()
+    lang = model.predict(x)
+    lang = le.inverse_transform(lang)
+    print("The langauge is in",lang[0])
+    
+# English
+#prediction("load the texts")
+
+#with open('processed/text_detected/language_detected.txt', 'w', newline="") as file:
+#        csv.writer(file, delimiter=" ").writerows(prediction)

load_json.md

@@ -0,0 +1,9 @@
+import json
+from
+
+with open('posts.json') as f:
+    posts_json = json.load(f)
+    
+ for post in posts_json:
+     post = Post(text=post['text'])
+     post.save()

load_text.py

@@ -0,0 +1,11 @@
+import jpype
+import asposecells
+jpype.startJVM()
+from asposecells.api import Workbook
+workbook = Workbook("processed/text_detected/text_detected.txt")
+workbook.save("processed/load_json/output.json")
+jpype.shutdownJVM()
+
+with open('processed/text_detected/text_detected.txt') as f:
+    contents = f.read
+

readme.md

@@ -0,0 +1,110 @@
+Introduction
+Every Machine Learning enthusiast has a dream of building/working on a cool project, isn’t it? Mere understandings of the theory aren’t enough, you need to work on projects, try to deploy them, and learn from them. Moreover, working on specific domains like NLP gives you wide opportunities and problem statements to explore. Through this article, I wish to introduce you to an amazing project, the Language Detection model using Natural Language Processing. This will take you through a real-world example of ML(application to say). So, let’s not wait anymore.
+ 
+
+About the dataset
+We are using the Language Detection dataset, which contains text details for 17 different languages.
+
+Languages are:
+
+* English
+
+* Portuguese
+* French
+
+* Greek
+
+* Dutch
+
+* Spanish
+
+* Japanese
+
+* Russian
+
+* Danish
+
+* Italian
+
+* Turkish
+
+* Swedish
+
+* Arabic
+
+* Malayalam
+
+* Hindi
+
+* Tamil
+
+* Telugu
+
+* Hebrews
+
+* Swahili
+
+* France
+
+* Korea
+
+* Russia
+
+* Thailand
+
+* Japan
+
+Using the text we have to create a model which will be able to predict the given language. This is a solution for many artificial intelligence applications and computational linguists. These kinds of prediction systems are widely used in electronic devices such as mobiles, laptops, etc for machine translation, and also on robots. It helps in tracking and identifying multilingual documents too. The domain of NLP is still a lively area of researchers.
+
+Implementation
+Importing libraries and dataset
+#we will import all the required libraries
+
+**modules used**
+pandas
+numpy
+re
+seaborn 
+matplotlib.pyplot 
+warnings
+
+next, Separating Independent and Dependent features
+Now we can separate the dependent and independent variables, here text data is the independent variable and the language name is the dependent variable.
+
+Label Encoding
+Our output variable, the name of languages is a categorical variable. For training the model we should have to convert it into a numerical form, so we are performing label encoding on that output variable. For this process, we are importing LabelEncoder from sklearn.
+
+Text Preprocessing
+This is a dataset created using scraping the Wikipedia, so it contains many unwanted symbols, numbers which will affect the quality of our model. So we should perform text preprocessing techniques.
+
+Bag of Words
+As we all know that, not only the output feature but also the input feature should be of the numerical form. So we are converting text into numerical form by creating a Bag of Words model using CountVectorizer.
+
+Train Test Splitting
+We preprocessed our input and output variable. The next step is to create the training set, for training the model and test set, for evaluating the test set. For this process, we are using a train test split.
+
+Model Training and Prediction
+The model creation part. We are using the naive_bayes algorithm for our model creation. Then training the model using the training set.
+
+predict the output for the test set.
+
+Model Evaluation
+evaluate the model
+
+The accuracy of the model is 0.97 which is very good and our model is performing well. Now let’s plot the confusion matrix using the seaborn heatmap.
+
+Predicting with some more data
+Now let’s test the model prediction using text in different languages.
+
+What is an Epoch?
+In terms of artificial neural networks, an epoch refers to one cycle through the full training dataset. Usually, training a neural network takes more than a few epochs. In other words, if we feed a neural network the training data for more than one epoch in different patterns, we hope for a better generalization when given a new "unseen" input (test data). An epoch is often mixed up with an iteration. Iterations is the number of batches or steps through partitioned packets of the training data, needed to complete one epoch.  Heuristically, one motivation is that (especially for large but finite training sets) it gives the network a chance to see the previous data to readjust the model parameters so that the model is not biased towards the last few data points during training.  
+
+
+Be aware that there is no guarantee a network will converge or "get better" by letting it learn the data for multiple epochs. It is an art in machine learning to decide the number of epochs sufficient for a network.
+
+In parallel, when we apply this to other areas of machine learning such as reinforcement learning, we see that an agent may not take the same route to complete the same task. This is because the agent is learning which decisions to make and trying to understand the consequences of such action(s). With a neural network, the goal of the model is generally to classify or generate material which is right or wrong. Thus, an epoch for an experimental agent performing many actions for a single task may vary from an epoch for an agent trying to perform a single action for many tasks of the same nature.  In reinforcement learning terminology, this is more typically referred to as an episode.
+
+Some Statistics
+Given the complexity and variability of data in real world problems, it may take hundreds to thousands of epochs to get some sensible accuracy on test data. Also, the term epoch varies in definition according to the problem at hand.
+Example
+As a specific example of an epoch in reinforcement learning, let's consider traveling from point A to B in a city. Now, we can take multiple routes to reach B and the task is to drive from A to B a hundred times. Consider an epoch to be any route taken from a set of available routes. An iteration on the other hand describes the specifics of the route like which turns, how many stops, etc.  In the reinforcement learning terminology, an iteration is often called an action.

setup.py

@@ -0,0 +1,35 @@
+import os
+from PIL import Image 
+
+def system_run():
+
+    caption = """
+     __                  / || \
+    |  |                / /  \ \
+    |  |               / /    \ \
+    |  |              / /______\ \
+    |  |             / /        \ \
+    |  |            / /          \ \
+    |  |_________  / /            \ \
+    |____________|/ /              \ \
+
+    """
+
+    img = Image.open("image.jpg") #process the image 
+    
+    if img.height > 300 or img.width > 300: #get the height and width of the image
+        output_size = (900, 900) #crop the image to the output size
+        img.thumbnail(output_size) 
+        ext = ['.jpeg', '.png', '.jpg'] #create list of extensions to save as 
+        for extension in ext: #loop over the list 
+            img.save(f"image_resize{extension}")
+
+    os.system('python3 text_extraction.py')
+    os.system('python3 detect_language.py')
+
+    #os.system('python3 load_text.py')
+    #os.system('python3 display_lang.py')
+   
+# os.system('python3 language_detection.py')
+
+system_run()

steps.md

@@ -0,0 +1,18 @@
+**Startup**
+* Click on the icon "language detection" to start or power on the program.
+
+**steps**
+1. to detect a language by input, click on the button "start detection" and enter your text, then click on the button "ok" and reload the program for the output at the bottom bar of the gui interface. For the file ouput and audio output; in the home folder directory, click on 'PROCESSED', followed by the 'AUDIO' folder and play the 'audio_input_detected'.mp3' in the folder.
+'*processed/audio/audio_input_detected.mp3*'
+
+* for the text input detected; in the home folder directory, click on 'PROCESSED', followed by the 'TEXT_DETECTED' folder and open the 'text_input_detected.txt' file. 
+'*processed/text_detected/text_input_detected.txt*'
+
+* for the language type detected; in the home folder directory, click on 'PROCESSED', followed by the 'TEXT_DETECTED' folder and open the 'language_input_type.txt' file. 
+'*processed/text_detected/language_input_type.txt*'
+
+2. to detect a language by image, place the image to be detected in the home working directory, then click the program icon to start the program, once the program is started click on the 'get started now' button on the top left corner of the gui interface and wait... for a few mins for the image to be processed, after the image has been processed there will be a text that says "succeeded /n check directories" to see the output in the directories; in the home folder directory, click on 'PROCESSED', followed by the 'TEXT_DETECTED' folder and open the 'language_type.txt' file. 
+'*processed/text_detected/language_type.txt*'
+
+* for the audio ouput; in the home folder directory, click on 'PROCESSED', followed by the 'AUDIO' folder and open the 'audio_detected.mp3' file. 
+'*processed/audio/audio_detected.mp3*'

text_extraction.py

@@ -0,0 +1,445 @@
+
+#importing of modules to be used to run the program
+import extract
+import csv
+import os
+import csv
+import cv2
+import logging
+import pytesseract
+import pandas as pd
+import numpy as np
+from scipy.stats import mode
+from PIL import Image
+import argparse
+import os
+import random
+
+#from google.colab.patches import cv2_imshow
+
+#import detectron2
+#from detectron2.utils.logger import setup_logger
+#setup_logger()
+#from detectron2 import model_zoo
+#from detectron2.engine import DefaultPredictor
+#from detectron2.config import get_cfg
+#from detectron2.utils.visualizer import Visualizer
+
+import logging
+
+import cv2
+import numpy as np
+from scipy.stats import mode
+
+#import and unzip the dataset
+#!ls
+#!unzip "Text_Detection_Dataset_COCO_Format.zip"
+
+
+#preparing the imported and extracted dataset with json
+
+#import json
+#from detectron2.structures import BoxMode
+#def get_board_dicts(imgdir):
+#    json_file = imgdir+"/dataset.json"
+#    with open(json_file) as f:
+#        dataset_dicts = json.load(f)
+#    for i in dataset_dicts:
+#        filename = i["file_name"] 
+#        i["file_name"] = imgdir+"/"+filename 
+#        for j in i["annotations"]:
+#            j["bbox_mode"] = BoxMode.XYWH_ABS
+#            j["category_id"] = int(j["category_id"])
+#    return dataset_dicts
+
+
+#preprocessing the image pre-processing and pattern matching.
+
+#This python module can perform the following functions:
+
+#Binarization - method binary_img(img) performs this function
+#Skew correction - method skew_correction(img) performs this function
+#Need to introduce machine learning of some sort to make the skew correction method run faster :( Or... A simple fix would be to resize the #image first, and then apply the skew correction method! That'll probably take lesser time...
+
+
+
+
+logging.basicConfig(
+  level=logging.DEBUG,
+  format="%(levelname)s: %(asctime)s {%(filename)s:%(lineno)d}: %(message)s "
+)
+
+kernel = np.ones((5, 5), np.uint8)
+clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+img = cv2.imread('image_resize.png') # read image file to be processed
+
+"""
+Method to binarize an image
+Input: Grayscale image
+Output: Binary image
+The nature of the output is such that the text(foreground) has a colour 
+value of (255,255,255), and the background has a value of (0,0,0).
+"""
+
+
+def binary_img(img):
+  # img_erode = cv2.dilate(img,kernel,iterations = 2)
+  blur = cv2.medianBlur(img, 5)
+
+  # mask1 = np.ones(img.shape[:2],np.uint8)
+  """Applying histogram equalization"""
+  cl1 = clahe.apply(blur)
+
+  circles_mask = cv2.dilate(cl1, kernel, iterations=1)
+  circles_mask = (255 - circles_mask)
+
+  thresh = 1
+  circles_mask = cv2.threshold(circles_mask, thresh, 255, cv2.THRESH_BINARY)[1]
+
+  edges = cv2.Canny(cl1, 100, 200)
+
+  edges = cv2.bitwise_and(edges, edges, mask=circles_mask)
+
+  dilation = cv2.dilate(edges, kernel, iterations=1)
+
+  display = cv2.bitwise_and(img, img, mask=dilation)
+
+  cl2 = clahe.apply(display)
+  cl2 = clahe.apply(cl2)
+
+  ret, th = cv2.threshold(cl2, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+  th = 255 - th
+
+  thg = cv2.adaptiveThreshold(display, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, \
+                              cv2.THRESH_BINARY, 11, 2)
+
+  # final = cv2.bitwise_and(dilation,dilation,mask=th)
+
+  finalg = cv2.bitwise_and(dilation, dilation, mask=thg)
+
+  finalg = 255 - finalg
+
+  abso = cv2.bitwise_and(dilation, dilation, mask=finalg)
+
+  return abso
+
+
+"""
+Method to resize the image. This is going to help in reducing the number 
+of computations, as the size of data will reduce.
+"""
+
+
+def resize(img):
+  r = 1000.0 / img.shape[1]
+  dim = (1000, int(img.shape[0] * r))
+  resized = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)
+
+  # cv2.imshow('resized', resized)
+  return resized
+
+
+"""
+Method to correct the skew of an image
+Input: Binary image
+Output: Skew corrected binary image
+The nature of the output is such that the binary image is rotated appropriately
+to remove any angular skew.
+Find out the right place to insert the resizing method call.
+Try to find one bounding rectangle around all the contours
+"""
+
+
+def skew_correction(img):
+  areas = []  # stores all the areas of corresponding contours
+  dev_areas = []  # stores all the areas of the contours within 1st std deviation in terms of area#stores all the white pixels of the largest contour within 1st std deviation
+  all_angles = []
+  k = 0
+
+  binary = binary_img(img)
+  # binary = resize(binary)
+  im2, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+  # cnt = contours[0]
+  # upper_bound=len(contours)
+  height_orig, width_orig = img.shape[:2]
+  words = np.zeros(img.shape[:2], np.uint8)
+
+  for c in contours:
+    areas.append(cv2.contourArea(c))
+
+  std_dev = np.std(areas)
+  for i in areas:
+    dev_areas.append(i - std_dev)
+
+  dev_contours = np.zeros(img.shape[:2], np.uint8)
+
+  for i in dev_areas:
+    if ((i > (-std_dev)) and (i <= (std_dev))):
+      cv2.drawContours(dev_contours, contours, k, (255, 255, 255), -1)
+    k += 1
+
+  sobely = cv2.Sobel(dev_contours, cv2.CV_64F, 0, 1, ksize=5)
+  abs_sobel64f = np.absolute(sobely)
+  sobel_8u = np.uint8(abs_sobel64f)
+
+  cv2.imshow('Output2',sobel_8u)
+
+  minLineLength = 100
+  maxLineGap = 10
+  lines = cv2.HoughLinesP(sobel_8u, 1, np.pi / 180, 100, minLineLength, maxLineGap)
+
+  for x1, y1, x2, y2 in lines[0]:
+    cv2.line(words, (x1, y1), (x2, y2), (255, 255, 255), 2)
+  # cv2.imshow('hough',words)
+
+  height_orig, width_orig = img.shape[:2]
+  all_angles = []
+
+  im2, contours, hierarchy = cv2.findContours(words, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+  logging.debug(len(contours))
+  contour_count = 0
+  for c in contours:
+    # max_index = np.argmax(areas)
+    # current_contour = np.zeros(img.shape[:2],np.uint8)
+    current_contour = np.zeros(img.shape[:2], np.uint8)
+    cv2.drawContours(current_contour, contours, contour_count, (255, 255, 255), -1)
+
+    height, width = current_contour.shape[:2]
+
+    # all_white_pixels = []
+    current_white_pixels = []
+
+    for i in range(0, height):
+      for j in range(0, width):
+        if (current_contour.item(i, j) == 255):
+          current_white_pixels.append([i, j])
+
+    matrix = np.array(current_white_pixels)
+
+    """Finding covariance matrix"""
+    C = np.cov(matrix.T)
+
+    eigenvalues, eigenvectors = np.linalg.eig(C)
+
+    """Finding max eigenvalue"""
+    # max_ev = max(eigenvalues)
+    """Finding index of max eigenvalue"""
+    max_index = eigenvalues.argmax(axis=0)
+
+    """The largest eigen value gives the approximate length of the bounding
+        ellipse around the largest word. If we follow the index of the largest 
+        eigen value and find the eigen vectors in the column of that index,
+        we'll get the x and y coordinates of it's centre."""
+    y = eigenvectors[1, max_index]
+    x = eigenvectors[0, max_index]
+
+    angle = (np.arctan2(y, x)) * (180 / np.pi)
+    all_angles.append(angle)
+    contour_count += 1
+    logging.debug(contour_count)
+
+    logging.debug(all_angles)
+    angle = np.mean(all_angles)
+    logging.debug(angle)
+
+  k = 0
+  non_zero_angles = []
+
+  for i in all_angles:
+    if ((i != 0) and (i != 90.0)):
+      non_zero_angles.append(i)
+
+  logging.debug(non_zero_angles)
+
+  rounded_angles = []
+  for i in non_zero_angles:
+    rounded_angles.append(np.round(i, 0))
+
+  logging.debug(rounded_angles)
+  logging.debug("mode is")
+  # logging.debug(np.mode(rounded_angles))
+  # angle = np.mean(non_zero_angles)
+  # angle = np.mode(rounded_angles)
+
+  mode_angle = mode(rounded_angles)[0][0]
+  logging.debug(mode_angle)
+
+  precision_angles = []
+  for i in non_zero_angles:
+    if (np.round(i, 0) == mode_angle):
+      precision_angles.append(i)
+
+  logging.debug('precision angles:')
+  logging.debug(precision_angles)
+
+  angle = np.mean(precision_angles)
+  logging.debug('Finally, the required angle is:')
+  logging.debug(angle)
+
+  # M = cv2.getRotationMatrix2D((width/2,height/2),-(90+angle),1)
+  M = cv2.getRotationMatrix2D((width / 2, height / 2), -(90 + angle), 1)
+  dst = cv2.warpAffine(img, M, (width_orig, height_orig))
+
+  # cv2.imshow('final',dst)
+  cv2.imwrite('images/skewcorrected2.jpg', dst)
+
+  return dst
+
+
+def preprocess(img):
+  return skew_correction(img)
+
+# Does not work with linux:
+# cv2.destroyAllWindows()
+
+
+#detecting characters on image creating key points on characters.
+
+#Detecting characters on image using keypoints
+
+
+
+#detecting keypoints caharacter characters on the image
+
+#this process draws keypoints on all characters available on the image
+
+#the image to be processed is passsed in here, such that cv2.imread = 'image_resize.png'
+img = cv2.imread('image_resize.png') #pass the image
+gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+
+orb = cv2.ORB_create(edgeThreshold=5,nfeatures=10000, scoreType=cv2.ORB_HARRIS_SCORE,scaleFactor=1.2) 
+kp ,des= orb.detectAndCompute(gray,None)
+
+img=cv2.drawKeypoints(gray,kp,None)
+cv2.imwrite('processed/images/keypoints.jpg',img)
+
+cv2.imshow('threshold image', img)
+    # Maintain output window until
+    # user presses a key
+cv2.waitKey(0)
+    # Destroying present windows on screen
+cv2.destroyAllWindows()
+    
+    
+# import libraries
+import csv
+import cv2
+import pytesseract
+
+
+def pre_processing(image):
+    """
+    This function take one argument as
+    input. this function will convert
+    input image to binary image
+    :param image: image
+    :return: thresholded image
+    """
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    # converting it to binary image
+    threshold_img = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
+    # saving image to view threshold image
+    cv2.imwrite('processed/images/thresholded.png', threshold_img)
+
+    cv2.imshow('threshold image', threshold_img)
+    # Maintain output window until
+    # user presses a key
+    cv2.waitKey(0)
+    # Destroying present windows on screen
+    cv2.destroyAllWindows()
+
+    return threshold_img
+
+
+def parse_text(threshold_img):
+    """
+    This function take one argument as
+    input. this function will feed input
+    image to tesseract to predict text.
+    :param threshold_img: image
+    return: meta-data dictionary
+    """
+    # configuring parameters for tesseract
+    tesseract_config = r' --oem 3 -l eng+chi_sim+chi_tra+spa+por+grc+deu+ell+fas+fil+heb+hin+ita+jpn+kor+lat+nep+osd+pol+rus+spa+swa+tel+tha+yor --psm 6'
+    # now feeding image to tesseract
+    details = pytesseract.image_to_data(threshold_img, output_type=pytesseract.Output.DICT,
+                                        config=tesseract_config, lang='eng')
+    return details
+
+
+def draw_boxes(image, details, threshold_point):
+    """
+    This function takes three argument as
+    input. it draw boxes on text area detected
+    by Tesseract. it also writes resulted image to
+    your local disk so that you can view it.
+    :param image: image
+    :param details: dictionary
+    :param threshold_point: integer
+    :return: None
+    """
+    total_boxes = len(details['text'])
+    for sequence_number in range(total_boxes):
+        #if int(details['conf'][sequence_number]) > threshold_point:
+            (x, y, w, h) = (details['left'][sequence_number], details['top'][sequence_number],
+                            details['width'][sequence_number], details['height'][sequence_number])
+            image = cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
+    # saving image to local
+    cv2.imwrite('processed/images/captured_text_area.png', image)
+    # display image
+    cv2.imshow('captured text', image)
+    # Maintain output window until user presses a key
+    cv2.waitKey(0)
+    # Destroying present windows on screen
+    cv2.destroyAllWindows()
+
+
+def format_text(details):
+    """
+    This function take one argument as
+    input.This function will arrange
+    resulted text into proper format.
+    :param details: dictionary
+    :return: list
+    """
+    parse_text = []
+    word_list = []
+    last_word = ''
+    for word in details['text']:
+        if word != '':
+            word_list.append(word)
+            last_word = word
+        if (last_word != '' and word == '') or (word == details['text'][-1]):
+            parse_text.append(word_list)
+            word_list = []
+
+    return parse_text
+
+
+def write_text(formatted_text):
+    """
+    This function take one argument.
+    it will write arranged text into
+    a file.
+    :param formatted_text: list
+    :return: None
+    """
+    with open('processed/text_detected/text_detected.txt', 'w', newline="") as file:
+        csv.writer(file, delimiter=" ").writerows(formatted_text)
+
+
+if __name__ == "__main__":
+    # reading image from local
+    image = cv2.imread('image_resize.png')
+    # calling pre_processing function to perform pre-processing on input image.
+    thresholds_image = pre_processing(image)
+    # calling parse_text function to get text from image by Tesseract.
+    parsed_data = parse_text(thresholds_image)
+    # defining threshold for draw box
+    accuracy_threshold = 30
+    # calling draw_boxes function which will draw dox around text area.
+    draw_boxes(thresholds_image, parsed_data, accuracy_threshold)
+    # calling format_text function which will format text according to input image
+    arranged_text = format_text(parsed_data)
+    # calling write_text function which will write arranged text into file
+    write_text(arranged_text)