write a literature review with relevant papers for the peoject which ha s this code "from tkinter import messagebox
from tkinter import *
from tkinter import simpledialog
import tkinter
from tkinter import filedialog
from tkinter.filedialog import askopenfilename
import cv2 as cv
import numpy as np

import os
from keras.preprocessing.image import load_img
from keras.utils import to_categorical
from keras.preprocessing.image import img_to_array
# from sklearn.model_selection import train_test_split
import pickle
from keras.models import load_model
from keras.applications import VGG16
from keras.layers import Flatten
from keras.layers import Dropout
from keras.layers import Dense
from keras.layers import Input
from keras.models import Model
from keras.optimizers import Adam
from keras.models import model_from_json


main = tkinter.Tk()
main.title("SSLA Based Traffic Sign and Lane Detection for Autonomous cars")
main.geometry("1300x1200")

global filename
global model

old = None
class_labels = ['Speed limit (20km/h)','Speed limit (30km/h)','Speed limit (50km/h)','Speed limit (60km/h)','Speed limit (70km/h)',
                'Speed limit (80km/h)','End of speed limit (80km/h)','Speed limit (100km/h)','Speed limit (120km/h)','No passing','Stop','No Entry',
                'General caution','Traffic signals']

def cannyDetection(img):
    grayImg = cv.cvtColor(img, cv.COLOR_RGB2GRAY)
    blurImg = cv.GaussianBlur(grayImg, (5, 5), 0)
    cannyImg = cv.Canny(blurImg, 50, 150)
    return cannyImg

def segmentDetection(img):
    height = img.shape[0]
    polygons = np.array([[(0, height), (800, height), (380, 290)]])
    maskImg = np.zeros_like(img)
    cv.fillPoly(maskImg, polygons, 255)
    segmentImg = cv.bitwise_and(img, maskImg)
    return segmentImg

def calculateLines(frame, lines):
    left = []
    right = []
    for line in lines:
        x1, y1, x2, y2 = line.reshape(4)
        parameters = np.polyfit((x1, x2), (y1, y2), 1)
        slope = parameters[0]
        y_intercept = parameters[1]
        if slope < 0:
            left.append((slope, y_intercept))
        else:
            right.append((slope, y_intercept))
    left_avg = np.average(left, axis = 0)
    right_avg = np.average(right, axis = 0)
    left_line = calculateCoordinates(frame, left_avg)
    right_line = calculateCoordinates(frame, right_avg)
    return np.array([left_line, right_line])

def calculateCoordinates(frame, parameters):
    global old
    #print(str(parameters)+" "+str(type(parameters))+" "+str(np.isnan(parameters)))
    if old is None:
        old = parameters        
    if np.isnan(parameters.any()) == False:
        parameters = old
    slope, intercept = parameters
    y1 = frame.shape[0]
    y2 = int(y1 - 150)
    x1 = int((y1 - intercept) / slope)
    x2 = int((y2 - intercept) / slope)
    return np.array([x1, y1, x2, y2])

def visualizeLines(frame, lines):
    lines_visualize = np.zeros_like(frame)
    if lines is not None:
        for x1, y1, x2, y2 in lines:
            cv.line(lines_visualize, (x1, y1), (x2, y2), (0, 255, 0), 5)
    return lines_visualize


def loadModel():
    global model
    model = load_model('model/model.h5')
    pathlabel.config(text="Machine Learning Traffic Sign Detection Model Loaded")
    text.delete('1.0', END)
    text.insert(END,"Machine Learning Traffic Sign Detection Model Loaded\n\n");

def detectSignal():
    global model 
    filename = filedialog.askopenfilename(initialdir="Videos")
    pathlabel.config(text=filename)
    text.delete('1.0', END)
    text.insert(END,filename+" loaded\n\n")
    text.update_idletasks()
    cap = cv.VideoCapture(filename)
    while (cap.isOpened()):
        ret, frame = cap.read()
        if frame is not None:
            canny = cannyDetection(frame)
            cv.imshow("cannyImage", canny)
            segment = segmentDetection(canny)
            hough = cv.HoughLinesP(segment, 2, np.pi / 180, 100, np.array([]), minLineLength = 100, maxLineGap = 50)
            if hough is not None:
                lines = calculateLines(frame, hough)
                linesVisualize = visualizeLines(frame, lines)
                cv.imshow("hough", linesVisualize)
                output = cv.addWeighted(frame, 0.9, linesVisualize, 1, 1)
            cv.imwrite("test.jpg",output)
            temps = cv.imread("test.jpg")
            h, w, c = temps.shape
            image = load_img("test.jpg", target_size=(80, 80))
            image = img_to_array(image) / 255.0
            image = np.expand_dims(image, axis=0)
            (boxPreds, labelPreds) = model.predict(image)
            print(boxPreds)
            boxPreds = boxPreds[0]
            startX = int(boxPreds[0] * w)
            startY = int(boxPreds[1] * h)
            endX = int(boxPreds[2] * w)
            endY = int(boxPreds[3] * h)
            predict= np.argmax(labelPreds, axis=1)
            predict = predict[0]
            accuracy = np.amax(labelPreds, axis=1)
            print(str(class_labels[predict])+" "+str(accuracy))
            if accuracy > 0.97:
                cv.putText(output, "Recognized As "+str(class_labels[predict]), (startX, startY), cv.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                cv.rectangle(output, (startX, startY), (endX, endY), (0, 255, 0), 2)
            cv.imshow("output", output)
            if cv.waitKey(10) & 0xFF == ord('q'):
                break
    cap.release()
    cv.destroyAllWindows()

    

def close():
    main.destroy()
    
    
font = ('times', 16, 'bold')
title = Label(main, text='SSLA Based Traffic Sign and Lane Detection for Autonomous cars',anchor=W, justify=CENTER)
title.config(bg='yellow4', fg='white')  
title.config(font=font)           
title.config(height=3, width=120)       
title.place(x=0,y=5)


font1 = ('times', 14, 'bold')
upload = Button(main, text="Generate & Load Machine Learning Model", command=loadModel)
upload.place(x=50,y=100)
upload.config(font=font1)  

pathlabel = Label(main)
pathlabel.config(bg='yellow4', fg='white')  
pathlabel.config(font=font1)           
pathlabel.place(x=50,y=150)

markovButton = Button(main, text="Upload Video & Detect Hough Lane, Signal", command=detectSignal)
markovButton.place(x=50,y=200)
markovButton.config(font=font1)

predictButton = Button(main, text="Exit", command=close)
predictButton.place(x=50,y=250)
predictButton.config(font=font1)


font1 = ('times', 12, 'bold')
text=Text(main,height=15,width=78)
scroll=Scrollbar(text)
text.configure(yscrollcommand=scroll.set)
text.place(x=450,y=100)
text.config(font=font1)


main.config(bg='magenta3')
main.mainloop()"


keep it the size of this text "Shraddha Suratkar, Sayali Bhiungade, Jui Pitale, Komal Soni, Tushar
Badgujar, and Faruk Kazi (2023) [1]explored a novel approach to deepfake
video detection by integrating convolutional neural networks (CNNs) with
recurrent neural networks (RNNs). Their study, published in the Journal of
Control and Decision, leverages the spatial feature extraction capabilities of
CNNs and the temporal sequence analysis strengths of RNNs. This hybrid
model enhances the detection of temporal inconsistencies and spatial anomalies
in video frames, leading to improved accuracy in identifying deepfake videos.
The researchers emphasize the importance of combining spatial and temporal
analysis to effectively combat the sophisticated nature of deepfake technology.
Their findings demonstrate that such an integrated approach can significantly
outperform traditional methods relying solely on either spatial or temporal
features.
Anuj Badale, Lionel Castelino, Chaitanya Darekar, and Joanne Gomes
(2018)[2] conducted an early study on deepfake detection utilizing neural
networks, presented at the 15th IEEE International Conference on Advanced
Video and Signal-Based Surveillance (AVSS). Their research focuses on the
capability of neural networks to detect subtle inconsistencies in deepfake videos
by analyzing pixel-level anomalies and unusual patterns. They highlighted the
potential of neural networks in identifying deepfake content by training models
on large datasets of real and manipulated videos. This foundational work
paved the way for more advanced neural network-based detection techniques
and underscored the need for robust models capable of learning complex
features associated with deepfake manipulations.
4
Shruti Agarwal, Hany Farid, Tarek El-Gaaly, and Ser-Nam Lim (2020)[3]
developed a dual approach to deepfake video detection by examining both
appearance and behavioral inconsistencies. Their study, presented at the
IEEE International Workshop on Information Forensics and Security (WIFS),
combines visual analysis with behavioral cues such as eye movement patterns,
facial expressions, and lip-syncing accuracy. This comprehensive approach aims
to enhance detection accuracy by leveraging multiple sources of information
that may indicate manipulation. The authors demonstrate that considering
behavioral anomalies, in addition to visual artifacts, significantly improves the
robustness of deepfake detection systems.
Saadaldeen Rashid Ahmed, Emrullah Sonu¸c, Mohammed Rashid Ahmed,
and Adil Deniz Duru (2022) [4]conducted an extensive survey on deepfake
detection and recognition methods using convolutional neural networks (CNNs).
Their study, presented at the International Congress on Human-Computer
Interaction, Optimization, and Robotic Applications (HORA), reviews various
CNN architectures and their effectiveness in detecting deepfake media. They
provide a detailed analysis of different techniques, highlighting the strengths
and weaknesses of each approach. The authors emphasize the need for
continuous innovation in CNN-based models to keep pace with the evolving
deepfake generation technologies. Their survey serves as a valuable resource
for researchers looking to understand the current state of deepfake detection
and identify potential areas for further investigation.
Mohammed Sahib Mahdi Altaei and colleagues (2022)[5] focused on detecting deepfake manipulations in face images using advanced deep learning
techniques. Published in the Wasit Journal of Computer and Mathematics Science, their research explores the effectiveness of deep learning models
in identifying subtle facial inconsistencies introduced by deepfake algorithms.
They developed a model that utilizes convolutional neural networks (CNNs)
to capture and analyze fine-grained features in facial images. Their findings
indicate that deep learning approaches can achieve high detection accuracy,
especially when trained on diverse datasets. The study underscores the importance of developing robust models that can generalize well across different
Department of Computer Science and Engineering 5
types of deepfake manipulations.
David G¨uera and Edward J. Delp (2018)[6] proposed a method for detecting
deepfake videos using recurrent neural networks (RNNs), presented at the
15th IEEE International Conference on Advanced Video and Signal-Based
Surveillance (AVSS). Their approach leverages the temporal analysis capabilities
of RNNs to identify inconsistencies over video frames, focusing on the sequential
nature of video data. By examining temporal dependencies and anomalies, their
model effectively distinguishes between genuine and manipulated videos. This
research highlights the potential of RNNs in capturing dynamic features that
are often indicative of deepfake manipulations, contributing to the development
of more sophisticated and reliable video analysis tools.
Dmitry Gura, Bo Dong, Duaa Mehiar, and Nidal Al Said (2024)[7] developed
a customized convolutional neural network (CNN) specifically designed for the
accurate detection of deepfake images in video collections. Published in
Computers, Materials and Continua, their work focuses on optimizing CNN
architectures to improve feature extraction and detection precision. They
introduce innovative techniques to enhance the model’s ability to discriminate
between real and fake images, demonstrating superior performance compared
to traditional CNN models. Their research emphasizes the importance of
tailoring CNN architectures to address the unique challenges posed by deepfake
detection, contributing to the advancement of more effective and efficient
detection methods.
Sumaiya Thaseen Ikram, Shourya Chambial, Dhruv Sood, et al. (2023)
[8]developed a hybrid CNN deep learning model aimed at enhancing the
performance of deepfake video detection. Their study, published in the International Journal of Electrical and Computer Engineering Systems, integrates
multiple CNN layers to capture a wide range of features and improve detection accuracy. By combining different layers, the model can analyze both
high-level and low-level features in video frames, making it more adept at
identifying subtle manipulations. The researchers demonstrate that this hybrid
approach significantly boosts the detection capabilities, providing a robust solution to the challenges posed by increasingly sophisticated deepfake technologies.
Department of Computer Science and Engineering 6
Asad Malik, Minoru Kuribayashi, Sani M. Abdullahi, and Ahmad Neyaz
Khan (2022)[9] conducted a comprehensive survey on deepfake detection techniques for human face images and videos, published in IEEE Access. Their
work reviews various state-of-the-art methods and technologies used to identify
deepfake media. They provide an extensive analysis of different approaches,
including CNNs, RNNs, and hybrid models, discussing their effectiveness,
strengths, and limitations. The survey highlights the rapid advancements
in deepfake generation and the corresponding need for improved detection
techniques. The authors also identify gaps in current research and suggest potential areas for future investigation, emphasizing the importance of continuous
innovation in this field.
Huy H. Nguyen, Junichi Yamagishi, and <PRESIDIO_ANONYMIZED_PERSON> (2019)[10] proposed
using capsule networks to detect fake images and videos, as outlined in
their preprint on arXiv. Capsule networks are designed to capture spatial
hierarchies and relationships within images, making them particularly effective
for identifying manipulations. The authors demonstrate that capsule networks
can preserve spatial information better than traditional CNNs, which enhances
their ability to detect deepfake artifacts. Their research shows that capsule
networks offer a promising alternative to existing methods, providing a robust
framework for detecting complex manipulations in both images and videos.
Samay Pashine, Sagar Mandiya, Praveen Gupta, and Rashid Sheikh (2021)
[11]conducted a survey on various solutions for detecting facial manipulations,
with a focus on deepfake detection. Their preprint on arXiv reviews different techniques and algorithms used to identify altered facial features and
expressions in deepfake media. The authors discuss the effectiveness of each
approach, including machine learning and deep learning models, and highlight
their respective advantages and limitations. They provide a comprehensive
overview of current detection technologies and suggest improvements for enhancing detection accuracy and robustness. This survey serves as a valuable
resource for researchers and practitioners looking to understand the landscape
of facial manipulation detection solutions.
Department of Computer Science and Engineering 7
Yogesh Patel, Sudeep Tanwar, Pronaya Bhattacharya, Rajesh Gupta, Turki
Alsuwian, Innocent Ewean Davidson, and Thokozile F. Mazibuko (2023) [12]introduced an improved dense CNN architecture designed specifically for deepfake image detection. Published in IEEE Access, their model leverages densely
connected CNN layers to enhance feature extraction and improve detection
accuracy. The dense connections allow the model to capture more detailed
and nuanced features, making it more effective at identifying deepfake images.
The authors demonstrate that their architecture outperforms traditional CNN
models, providing a significant advancement in the field of deepfake detection
and contributing to the development of more reliable and efficient detection
systems.
ST Suganthi, Mohamed Uvaze Ahamed Ayoobkhan, Nebojsa Bacanin, K
Venkatachalam, Hub´alovsk´y Stˇep´an, Trojovsk´y Pavel, et al. (2022)[13] de- ˇ
veloped a deep learning model for deepfake face recognition and detection,
published in PeerJ Computer Science. Their research explores the application
of deep learning techniques to identify manipulated faces in both images and
videos. The model is designed to analyze facial features and detect inconsistencies indicative of deepfake manipulations. The authors propose novel
methods to enhance the model’s accuracy and robustness, including advanced
preprocessing techniques and optimized network architectures. Their work
contributes to the ongoing efforts to improve deepfake detection technology
and offers practical solutions for real-world applications.
Hasin Shahed Shad, Md Mashfiq Rizvee, Nishat Tasnim Roza, SM Ahsanul
Hoq, Mohammad Monirujjaman Khan, Arjun Singh, Atef Zaguia, and Sami
Bourouis (2021)[14] conducted a comparative analysis of different deepfake image detection methods using convolutional neural networks (CNNs). Published
in Computational Intelligence and Neuroscience, their study evaluates the performance of various CNN-based approaches in identifying deepfake images. The
authors compare multiple models, assessing their strengths and weaknesses,
and provide insights into the most effective techniques for detecting manipulated images. Their findings highlight the importance of selecting appropriate
Department of Computer Science and Engineering 8
CNN architectures and training strategies to achieve high detection accuracy,
offering valuable guidance for researchers and practitioners in the field.
Deressa Wodajo and Solomon Atnafu (2021)[15] proposed the use of convolutional vision transformers for deepfake video detection, as described in their
preprint on arXiv. Their approach combines the strengths of convolutional
neural networks (CNNs) and transformers to capture both spatial and temporal features in video data. The convolutional vision transformer architecture
leverages the transformer model’s ability to handle sequential data effectively
while also benefiting from the CNN’s spatial feature extraction capabilities.
The authors demonstrate that this hybrid model achieves superior detection
performance, providing a robust solution for identifying deepfake videos. Their
research contributes to the advancement of deepfake detection technologies by
integrating the best aspects of CNNs and transformers.
"