Handwritten equation

1. A Mini Project Report
on
(Handwritten equation recognition and solution using CNN)
Submitted in partial fulfillment of the
Requirements for the award of degree of
Master of Computer Applications
by
CH. ANUSHA (122162012)
Under the Guidance of
Mrs. A. Sumalatha
Assistant professor
Department of Computer Science
CHAITANYA DEEMED TO BE UNIVERSITY
(Approved U/S, 3 of UGC Act, 1956 by MHRD, Govt. of India)
(2022 – 2024)

2. Department of computer science
CERTIFICATE
This is to certify that the project entitled “Handwritten equation recognition and solution using CNN”
being submitted by Ch. Anusha bearing the Hall Ticket number 122162012 in partial fulfillment of the
requirements for the award of the Master of Computer Applications to CHAITANYA DEEMED TO BE
UNIVERSITY is a record of bonafide work carried out by her under my guidance and supervision from
2022 to 2024.
The results presented in this project have been verified and found to be satisfactory. The results
embodied in this project report have not been submitted to any other University for the award of any
other degree or diploma.
GUIDE HEAD OF THE DEPARTMENT DEAN ADMINISTRATION
Mrs. A. Sumalatha Dr. A. Ramesh Babu Dr. S. Kavitha
Assistant Professor Professor Professor
INTERNAL EXAMINER EXTERNAL EXAMINER

3. ACKNOWLEDGEMENT
It is my privilege and pleasure to express profound sense of respect, gratitude and indebtedness to our
guide A. Sumalatha Asst. Professor, Dept. of Computer Science, Chaitanya Deemed to Be University, for
her indefatigable inspiration, guidance, cogent discussion, constructive criticisms and encouragement
throughout this dissertation work.
I express my sincere gratitude to Dr. A. Ramesh Babu, Professor & Head, Department of Computer
Science, Chaitanya Deemed to Be University, for his suggestions, motivations, and co-operation for the
successful completion of the work.
I extend my sincere thanks to Dr. S. Kavitha, Professor & Dean, Department of Computer Science,
Chaitanya Deemed to Be University, for his encouragement and constant help.
Ch. Anusha
(122162012)

4. DECLARATION
I hereby declare that the project work entitled “Handwritten equation recognition
and solution using CNN” submitted to the Chaitanya Deemed to Be University in partial fulfillment of
the requirements for the award of the degree of
Master of Computer Applications in Computer Science is a record of an original
work done by me under the guidance of A. Sumalatha Asst. Professor and this project work
have not been submitted to any other university for the award of any other degree or diploma.
Ch. Anusha
(122162012)
Date:

5. ABSTRACT
Using CNN to create a robust handwritten equation solver is a difficult task in image processing.
One of the most difficult challenges in computer vision research is handwritten mathematical expression
recognition. The work is made more difficult by the fact that certain characters are segmented and
classified. a collection of quadratic equations created by hand This study looks at quadratic equations as
well as a single quadratic equation. These equations must be recognized and solved. Horizontal compact
projection analysis is used for segmentation. We use both connected component analysis and integrated
connected component analysis methodologies. Convolutional Neural Networks Characters are classified
using a network. Each appropriate is required for the solution of the problem. Character string operation
is used for detection. Finally, the results of the experiment show that the strategy we've described is quite
effective. The goal of this project is to create a handwritten alphabet. Equation solver capable of dealing
with a wide range of mathematical equations.

6. CONTENTS
S.NO PAGE NO
1. Introduction 01
1.1. Motivation 01
1.2. Problem Definition 01
1.3. Objective of the Project 01
2. Literature Survey 02-04
3. Analysis 05-07
3.1 Existing System 5
3.2 Proposed System 5
3.3 Software Requirement Specification 6
3.3.1 Purpose 6
3.3.2 Scope 6
3.3.3 Overall Description 7
4. Design 8-12
4.1 UML Diagrams 8
4.1.1 Use Case 9
4.1.2 Class Diagram 10
4.1.3 Activity Diagram 11
4.1.4 Sequence Diagram 12
5. Implementation 13
5.1 Modules 13
5.2 Module Description 13
5.3 Introduction to Technologies Used 13-19
5.4 Sample Code 19-24

7. 6. Test Cases 25-28
7. Screen Shots 29-31
8. Conclusion 32
9. Future Enhancement 33
10. Bibliography 34-35

8. 1
CHAPTER 1
1. INTRODUCTION
1.1 MOTIVATION:
Arithmetic is utilized in basically every part of science, including physical science,
designing, medication, and financial aspects. The investigation and perception of advanced
archives is a critical scholastic subject today. OCR (optical person acknowledgment) can give
further developed acknowledgment precision to English characters and digits in electronic books.
In the field of PC vision, transcribed numerical articulation acknowledgment stays a troublesome
assignment.
1.2 PROBLEM DEFINITION
The amendment pace of image division and acknowledgment can't meet its real
prerequisites because of the two-dimensional settling gathering and fluctuated sizes. The initial
phase in perceiving numerical articulations is to fragment and arrange the characters. In the field
of PC vision, the convolutional neural network (CNN) is one of the most broadly utilized grouping
models. Profound Convolutional Neural Network (CNN) inclining has exhibited brilliant
execution in the fields of picture grouping, AI, and normal language handling lately. Perceive
designs. CNN, most importantly other models, is truly outstanding.
1.3 OBJECTIVE OF THE PROJECT:
1. To build a user interface for entering the object image that is straightforward to use.
2. The system should be able to process the mathematical expression in advance.
3. The system should be able to recognize text in the image as well as mathematical symbols.
4. The system should extract text from the image and display the mathematical expression's
solution.
5. The primary goal is to learn how to create a CNN model for Mathematical Expression.

9. 2
CHAPTER 2
2. LITERATURE SURVEY
[1] On building ensembles of stacked denoising autoencoding classifiers and their further
improvement:
https://www.researchgate.net/publication/315999748_On_building_ensembles_of_stacked_den
oising_auto-encoding_classifiers_and_their_further_improvement
ABSTRACT: To aggregate diverse learners and to train deep architectures are the two principal
avenues towards increasing the expressive capabilities of neural networks. Therefore, their
combinations merit attention. In this contribution, we study how to apply some conventional
diversity methods –bagging and label switching– to a general deep machine, the stacked denoising
auto-encoding classifier, in order to solve a number of appropriately selected image recognition
problems. The main conclusion of our work is that binarizing multi-class problems is the key to
obtain benefit from those diversity methods. Additionally, we check that adding other kinds of
performance improvement procedures, such as pre-emphasizing training samples and elastic
distortion mechanisms, further increases the quality of the results. In particular, an appropriate
combination of all the above methods leads us to reach a new absolute record in classifying MNIST
handwritten digits. These facts reveal that there are clear opportunities for designing more powerful
classifiers by means of combining different improvement techniques.
[2] Finite-time synchronization by switching state-feedback control for discontinuous Cohen–
Grossberg neural networks with mixed delays
https://www.researchgate.net/publication/316052799_Finite-
time_synchronization_by_switching_state-
feedback_control_for_discontinuous_CohenGrossberg_neural_networks_with_mixed_delays
ABSTRACT: This paper studies the finite-time synchronization problem of Cohen–Grossberg
neural networks (CGNNs) with discontinuous neuron activations and mixed time-delays. Under

10. 3
the extended differential inclusion framework, the famous finite-time stability theorem and
generalized Lyapunov approach are used to realize the finite-time synchronization control of
driveresponse system. Different from the conventional controllers, we propose two classes of novel
switching state-feedback controllers which include discontinuous factor sign ((cdot)). By doing
so, the synchronization error of CGNNs can be controlled to converge zero in a finite time.
Moreover, we also provide an estimation of the upper bound of the settling time for
synchronization. Finally, two examples and simulation experiment are given to demonstrate the
validity of theoretical results.
[3] Adversarial learning for distant supervised relation extraction
https://core.ac.uk/download/pdf/158373879.pdf
ABSTRACT: Recently, many researchers have concentrated on using neural networks to learn
features for Distant Supervised Relation Extraction (DSRE). These approaches generally use a
softmax classifier with cross-entropy loss, which inevitably brings the noise of artificial class NA
into classification process. To address the shortcoming, the classifier with ranking loss is employed
to DSRE. Uniformly randomly selecting a relation or heuristically selecting the highest score
among all incorrect relations are two common methods for generating a negative class in the
ranking loss function. However, the majority of the generated negative class can be easily
discriminated from positive class and will contribute little towards the training. Inspired by
Generative Adversarial Networks (GANs), we use a neural network as the negative class generator
to assist the training of our desired model, which acts as the discriminator in GANs. Through the
alternating optimization of generator and discriminator, the generator is learning to produce more
and more discriminable negative classes and the discriminator has to become better as well. This
framework is independent of the concrete form of generator and discriminator. In this paper, we
use a two layers fully-connected neural network as the generator and the Piecewise Convolutional
Neural Networks (PCNNs) as the discriminator. Experiment results show that our proposed
GANbased method is effective and performs better than state-of-the-art methods.
[4] Reversible natural language watermarking using synonym substitution and arithmetic
coding

11. 4
https://dr.ntu.edu.sg/bitstream/10356/106752/1/Reversible%20natural%20language%20waterm
arking%20using%20synonym%20substitution%20and%20arithmetic%20coding.pdf
ABSTRACT: For protecting the copyright of a text and recovering its original content harmlessly,
this paper proposes a novel reversible natural language watermarking method that combines
arithmetic coding and synonym substitution operations. By analyzing relative frequencies of
synonymous words, synonyms employed for carrying payload are quantized into an unbalanced
and redundant binary sequence. The quantized binary sequence is compressed by adaptive binary
arithmetic coding losslessly to provide a spare for accommodating additional data. Then, the
compressed data appended with the watermark are embedded into the cover text via synonym
substitutions in an invertible manner. On the receiver side, the watermark and compressed data can
be extracted by decoding the values of synonyms in the watermarked text, as a result of which the
original context can be perfectly recovered by decompressing the extracted compressed data and
substituting the replaced synonyms with their original synonyms. Experimental results
demonstrate that the proposed method can extract the watermark successfully and achieve a
lossless recovery of the original text. Additionally, it achieves a high embedding capacity. [5]
Detecting iris liveness with batch normalized convolutional neural network
https://www.techscience.com/cmc/v58n2/23021
ABSTRACT: Aim to countermeasure the presentation attack for iris recognition system, an iris
liveness detection scheme based on batch normalized convolutional neural network (BNCNN) is
proposed to improve the reliability of the iris authentication system. The BNCNN architecture with
eighteen layers is constructed to detect the genuine iris and fake iris, including convolutional layer,
batch-normalized (BN) layer, Relu layer, pooling layer and full connected layer. The iris image is
first preprocessed by iris segmentation and is normalized to 256×256 pixels, and then the iris
features are extracted by BNCNN. With these features, the genuine iris and fake iris are determined
by the decision-making layer. Batch normalization technique is used in BNCNN to avoid the
problem of over fitting and gradient disappearing during training. Extensive experiments are
conducted on three classical databases: the CASIA Iris Lamp database, the CASIA Iris Syn
database and Ndcontact database. The results show that the proposed method can effectively
extract micro texture features of the iris, and achieve higher detection accuracy compared with
some typical iris liveness detection methods.

12. 5
CHAPTER 3
3. ANALYSIS
3.1 EXISTING SYSTEM:
It's challenging to use CNN to build a reliable solver for handwritten equations.
Handwritten mathematical expression recognition is one of the most challenging problems in
computer vision research. The segmentation and classification of some features makes the process
more challenging.
Disadvantages of existing system:
1. Equation solver is a difficult task in image processing.
2. One of the most difficult challenges in computer vision research is handwritten
mathematical expression recognition.
3. The work is made more difficult by the fact that certain characters are segmented and
classified
3.2 PROPOSED SYSTEM:
In this study, both many quadratic equations and a single quadratic equation are examined. They
need to be identified and solved. For segmentation, horizontal compact projection analysis is
performed. We employ both integrated connected component analysis and connected component
analysis. Neural networks with convolutions A network is used to classify characters. Each proper
step is necessary to solve the issue. For detection, character string operation is employed.
Advantages of proposed system:
1. Finally, the results of the experiment show that the strategy we've described is quite
effective.
2. Equation solver capable of dealing with a wide range of mathematical equations.

13. 6
SYSTEM ARCHITECHTURE
3. 3 SOFTWARE REQUIREMENT SPECIFICATION
3.3.1 Purpose:
The goal of this project is to create handwritten Mathematical expressions.
3.3.2 Scope:
The mathematical expression should be able to be processed beforehand by the system. Both the
language and the mathematical symbols in the image should be recognized by the system.
3.3.3 Overall Description:
A penmanship acknowledgment framework's objective is to make an interpretation of
manually written characters into designs that are machine meaningful. Vehicle tag recognizable
proof, postal letter arranging, Check truncation framework (CTS) checking and recorded report
conservation in archeological divisions, old archive robotization in libraries and banks, and
different applications are among the generally normal. These fields manage enormous information
bases, requiring fantastic acknowledgment precision, diminished processing intricacy, and

14. 7
predictable acknowledgment framework execution. Profound neural models are supposed to be
more invaluable than shallow neural models. A convolutional neural organization is a type of
profound neural network with applications in picture grouping, object acknowledgment, proposal
frameworks, signal handling, normal language handling, PC vision, and face acknowledgment,
among others. They are more proficient than their archetypes (Multilayer perceptron (MLP), and
so on) in light of the fact that they can consequently perceive the fundamental parts of a thing (here
an item can be a picture, a written by hand character, a face, and so on) without any human
oversight or collaboration. An exceptionally proficient CNN is the result of progressive component
learning's solid abilities.
Software Requirements :
Operating System : Windows
Language : Python
Front End : Html, Css, JavaScript
Back End : Flask
Hardware Requirements :
System : Dual Core 2.0 Processor
Hard Disk : 250 GB and more
Monitor : Standard LED Monitor
Ram : 8GB

15. 8
CHAPTER 4
4. DESIGN
4.1 UML DIAGRAMS:
UML stands for Unified Modeling Language. UML is a standardized general-purpose
modeling language in the field of object-oriented software engineering. The standard is managed,
and was created by, the Object Management Group.
The goal is for UML to become a common language for creating models of object oriented
computer software. In its current form UML is comprised of two major components: a Meta-model
and a notation. In the future, some form of method or process may also be added to; or associated
with, UML.
The Unified Modeling Language is a standard language for specifying, Visualization, Constructing
and documenting the artifacts of software system, as well as for business modeling and other non-
software systems.
The UML represents a collection of best engineering practices that have proven successful
in the modeling of large and complex systems.
The UML is a very important part of developing objects oriented software and the software
development process. The UML uses mostly graphical notations to express the design of software
projects.
GOALS:
The Primary goals in the design of the UML are as follows:
1. Provide users a ready-to-use, expressive visual modeling Language so that they can
develop and exchange meaningful models.
2. Provide extendibility and specialization mechanisms to extend the core concepts.
3. Be independent of particular programming languages and development process.
4. Provide a formal basis for understanding the modeling language.
5. Encourage the growth of OO tools market.
6. Support higher level development concepts such as collaborations, frameworks, patterns
and components.

16. 9
7. Integrate best practices.
4.1.1 Use case diagram:
A use case diagram in the Unified Modeling Language (UML) is a type of behavioral
diagram defined by and created from a Use-case analysis. Its purpose is to present a graphical
overview of the functionality provided by a system in terms of actors, their goals (represented as
use cases), and any dependencies between those use cases. The main purpose of a use case diagram
is to show what system functions are performed for which actor. Roles of the actors in the system
can be depicted.
Fig.4.1.1 Usecase diagram
Signup
Signin
Build CNN model
Upload or write input
User
Predict solution

17. 10
4.1.2 Class diagram:
The class diagram is used to refine the use case diagram and define a detailed design of the
system. The class diagram classifies the actors defined in the use case diagram into a set of
interrelated classes. The relationship or association between the classes can be either an "is-a" or
"has-a" relationship. Each class in the class diagram may be capable of providing certain
functionalities. These functionalities provided by the class are termed "methods" of the class. Apart
from this, each class may have certain "attributes" that uniquely identify the class.
Fig.4.1.2 Class diagram
User signup
User signin
Build CNN model
Upload or write input
Predict solution

18. 11
4.1.3 Activity diagram:
The process flows in the system are captured in the activity diagram. Similar to a state
diagram, an activity diagram also consists of activities, actions, transitions, initial and final states,
and guard conditions.
Fig.4.1.3 Activity diagram
User signup
User login
Predict solution
Build CNN model
Upload file or write input

19. 12
4.1.4 Sequence diagram:
A sequence diagram represents the interaction between different objects in the system. The
important aspect of a sequence diagram is that it is time-ordered. This means that the exact
sequence of the interactions between the objects is represented step by step. Different objects in
the sequence diagram interact with each other by passing "messages".
User System
Fig.4.1.4 Sequence diagram
User signup
User signin
Build CNN model
Upload file or write input
Predict solution

20. 13
CHAPTER 5
5. IMPLEMENTATION
5.1 MODULES:
• User signup
• User signin
• Build CNN model
• Upload file or write input
• Predict solution
5.2: MODULES DESCRIPTION:
• User signup: Using this module user will get register
• User signin: Using this module user will login into the application
• Build CNN model: using this module algorithm will generate
• Upload file or write input: using this module will upload file or write equation for
prediction
• Predict solution: Using this module will predict result for given input
5.3 INTRODUCTION TO TECHNOLOGIES USED:
 PYTHON LANGUAGE:

21. 14
Python is currently the most widely used multi-purpose, high-level programming
language. Python allows programming in Object-Oriented and Procedural paradigms.
Python programs generally are smaller than other programming languages like Java.
Programmers have to type relatively less and indentation requirement of the language,
makes them readable all the time. Python language is being used by almost all tech-giant
companies like – Google, Amazon, Facebook, Instagram, Dropbox, Uber… etc. The
biggest strength of Python is huge collection of standard library which can be used for the
following –
• Machine Learning
• GUI Applications (like Kivy, Tkinter, PyQt etc.)
• Web frameworks like Django (used by YouTube, Instagram, Dropbox)
• Image processing (like Opencv, Pillow)
• Web scraping (like Scrapy, BeautifulSoup, Selenium)
• Test frameworks
• Multimedia
LIBRARIES/PACKGES :-
Tensorflow
TensorFlow is a free and open-source software library for dataflow and differentiable
programming across a range of tasks. It is a symbolic math library, and is also used for machine
learning applications such as neural networks. It is used for both research and production at
Google.
TensorFlow was developed by the Google Brain team for internal Google use. It was
released under the Apache 2.0 open-source license on November 9, 2015.
Numpy
Numpy is a general-purpose array-processing package. It provides a high-performance
multidimensional array object, and tools for working with these arrays.

22. 15
It is the fundamental package for scientific computing with Python. It contains various
features including these important ones:
▪ A powerful N-dimensional array object
▪ Sophisticated (broadcasting) functions
▪ Tools for integrating C/C++ and Fortran code
▪ Useful linear algebra, Fourier transform, and random number capabilities
Besides its obvious scientific uses, Numpy can also be used as an efficient multi-dimensional
container of generic data. Arbitrary data-types can be defined using Numpy which allows Numpy
to seamlessly and speedily integrate with a wide variety of databases.
Pandas
Pandas is an open-source Python Library providing high-performance data manipulation
and analysis tool using its powerful data structures. Python was majorly used for data munging
and preparation. It had very little contribution towards data analysis. Pandas solved this problem.
Using Pandas, we can accomplish five typical steps in the processing and analysis of data,
regardless of the origin of data load, prepare, manipulate, model, and analyze. Python with Pandas
is used in a wide range of fields including academic and commercial domains including finance,
economics, Statistics, analytics, etc.
Matplotlib
Matplotlib is a Python 2D plotting library which produces publication quality figures in
a variety of hardcopy formats and interactive environments across platforms. Matplotlib can be
used in Python scripts, the Python and IPython shells, the Jupyter Notebook, web application
servers, and four graphical user interface toolkits. Matplotlib tries to make easy things easy and
hard things possible. You can generate plots, histograms, power spectra, bar charts, error charts,
scatter plots, etc., with just a few lines of code. For examples, see the sample plots and thumbnail
gallery.

23. 16
For simple plotting the pyplot module provides a MATLAB-like interface, particularly
when combined with IPython. For the power user, you have full control of line styles, font
properties, axes properties, etc, via an object oriented interface or via a set of functions familiar
to MATLAB users.
Scikit – learn
Scikit-learn provides a range of supervised and unsupervised learning algorithms via a
consistent interface in Python. It is licensed under a permissive simplified BSD license and is
distributed under many Linux distributions, encouraging academic and commercial use.
 MACHINE LEARNING
Machine learning (ML) is a type of artificial intelligence (AI) that allows software
applications to become more accurate at predicting outcomes without being explicitly
programmed to do so. Machine learning algorithms use historical data as input to predict new
output values.
Different types of Machine Learning Classical machine learning is often categorized by how an
algorithm learns to become more accurate in its predictions. There are four basic approaches :
• Supervised learning
• Unsupervised learning
• Semi-supervised learning
• Reinforcement learning
The type of algorithm data scientists choose to use depends on what type of data they want to
predict.
MACHINE LEARNING APPROACHES

24. 17
Supervised learning : In this type of machine learning, data scientists supply algorithms with
labeled training data and define the variables they want the algorithm to assess for correlations.
Both the input and the output of the algorithm is specified.
Unsupervised learning : This type of machine learning involves algorithms that train on
unlabeled data. The algorithm scans through data sets looking for any meaningful connection.
The data that algorithms train on as well as the predictions or recommendations they output are
predetermined.
Semi-supervised learning : This approach to machine learning involves a mix of the two
preceding types. Data scientists may feed an algorithm mostly labeled training data, but the
model is free to explore the data on its own and develop its own understanding of the data set.
Reinforcement learning : Data scientists typically use reinforcement learning to teach a machine
to complete a multi-step process for which there are clearly defined rules. Data scientists
program an algorithm to complete a task and give it positive or negative cues as it works out
how to complete a task. But for the most part, the algorithm decides on its own what steps to
take along the way.
HOW DOES SUPERVISED MACHINE LEARNING WORK?
Supervised machine learning requires the data scientist to train the algorithm with both labeled
inputs and desired outputs. Supervised learning algorithms are good for the following tasks.

25. 18
Binary classification : Dividing data into two categories.
Multi-class classification : Choosing between more than two types of answers.
Regression modeling : Predicting continuous values.
Ensembling : Combining the predictions of multiple machine learning models to produce an
accurate prediction.
 FLASK
Flask is a web application framework written in Python. It was developed by Armin
Ronacher, who led a team of international Python enthusiasts called Pocco. Flask is based on the
Werkzeg WSGI toolkit and the Jinja2 template engine. Both are Pocco projects.
Flask is often referred to as a micro framework . It is designed to keep the core of the application
simple and scalable. Instead of an abstraction layer for database support, Flask supports
extensions to add such capabilities to the application.
Unlike the Django framework, Flask is very Pythonic. It’s easy to get started with Flask, because
it doesn’t have a huge learning curve. On top of that it’s very explicit, which increases
readability. To create the “Hello World” app, you only need a few lines of code.
This is a boilerplate code example. from flask import Flask
app = Flask(_name_) @app.route('/') def hello_world() :
return 'Hello World!' if _name_ == '_main_':
app.run()
If you want to develop on your local computer, you can do so easily. Save this program as server.py
and run it with python server.py.
$ python server.py

26. 19
* Serving Flask app "hello"
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
It then starts a web server which is available only on your computer. In a web browser open
localhost on port 5000 (the url) and you’ll see “Hello World” show up. To host and develop
online, you can use Python anywhere.
It’s a microframework, but that doesn’t mean your whole app should be inside one single Python
file. You can and should use many files for larger programs, to handle complexity.
5.4 SAMPLE CODE:
import pandas as pd import numpy as np import cv2 import os from
keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout
from keras.models import Sequential, model_from_json from keras.utils
import to_categorical from os.path import isfile, join from keras
import backend as K from os import listdir from PIL import Image
index_by_directory = {
'0': 0,
'1': 1,
'2': 2,
'3': 3,
'4': 4,
'5': 5,
'6': 6,
'7': 7,
'8': 8,
'9': 9,

27. 20
'+': 10,
'-': 11,
'x': 12
}
def get_index_by_directory(directory):
return index_by_directory[directory] def
load_images_from_folder(folder):
train_data = [] for filename in
os.listdir(folder):
img = cv2.imread(os.path.join(folder,filename),
cv2.IMREAD_GRAYSCALE) # Convert to Image to Grayscale
img = ~img # Invert the bits of image 255 -> 0 if
img is not None:
_, thresh = cv2.threshold(img, 127, 255,
cv2.THRESH_BINARY) # Set bits > 127 to 1 and <= 127 to 0
ctrs, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE) cnt =
sorted(ctrs, key=lambda ctr:
cv2.boundingRect(ctr)[0]) # Sort by x
maxi = 0 for c in cnt:
x, y, w, h = cv2.boundingRect(c)
maxi = max(w*h, maxi) if maxi == w*h:
x_max = x y_max = y
w_max = w h_max = h im_crop
= thresh[y_max:y_max+h_max+10, x_max:x_max+w_max+10] # Crop
the image as most as possible im_resize =
cv2.resize(im_crop, (28, 28)) # Resize to
(28, 28)
im_resize = np.reshape(im_resize, (784, 1)) # Flat
the matrix
train_data.append(im_resize) return
train_data def load_all_imgs():
dataset_dir = "./datasets/"
directory_list = listdir(dataset_dir)
first = True data = []
print('Exporting images...') for
directory in directory_list:
print(directory)
if first:

28. 21
first = False data =
load_images_from_folder(dataset_dir +
directory) for i in range(0,
len(data)):
data[i] = np.append(data[i],
[str(get_index_by_directory(directory))])
continue aux_data =
load_images_from_folder(dataset_dir +
directory) for i in range(0,
len(aux_data)):
aux_data[i] = np.append(aux_data[i],
[str(get_index_by_directory(directory))])
data = np.concatenate((data, aux_data))
df=pd.DataFrame(data,index=None)
df.to_csv('model/train_data.csv',index=False) def
extract_imgs(img):
img = ~img # Invert the bits of image 255 -> 0
_, thresh = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY) #
Set bits > 127 to 1 and <= 127 to 0
ctrs, _ = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE) cnt = sorted(ctrs, key=lambda ctr:
cv2.boundingRect(ctr)[0])
# Sort by x
img_data = []
rects = [] for c
in cnt :
x, y, w, h = cv2.boundingRect(c)
rect = [x, y, w, h]
rects.append(rect) bool_rect = []
# Check when two rectangles collide
for r in rects: l = []
for rec in rects: flag = 0
if rec != r:
if r[0] < (rec[0] + rec[2] + 10) and rec[0] < (r[0]
+ r[2] + 10) and r[1] < (rec[1] + rec[3] + 10) and rec[1] < (r[1] +
r[3] + 10):
flag = 1
l.append(flag)
else:
l.append(0)
bool_rect.append(l) dump_rect = []

29. 22
# Discard the small collide rectangle
for i in range(0, len(cnt)): for j
in range(0, len(cnt)): if
bool_rect[i][j] == 1:
area1 = rects[i][2] * rects[i][3]
area2 = rects[j][2] * rects[j][3]
if(area1 == min(area1,area2)):
dump_rect.append(rects[i])
# Get the final rectangles final_rect = [i for i
in rects if i not in dump_rect] for r in final_rect:
x = r[0] y = r[1] w = r[2] h =
r[3] im_crop = thresh[y:y+h+10, x:x+w+10] # Crop the image
as
most as possible im_resize = cv2.resize(im_crop, (28,
28)) # Resize to
(28, 28)
im_resize = np.reshape(im_resize, (1, 28, 28)) # Flat the
matrix
img_data.append(im_resize)
return img_data class
ConvolutionalNeuralNetwork:
def __init__(self):
if os.path.exists('model/model_weights.h5') and
os.path.exists('model/model.json'):
self.load_model()
else:
self.create_model()
self.train_model()
self.export_model() def
create_model(self):
first_conv_num_filters = 30
first_conv_filter_size = 5
second_conv_num_filters = 15
second_conv_filter_size = 3
pool_size = 2 # Create model
print("Creating Model...")
self.model = Sequential()
self.model.add(Conv2D(first_conv_num_fi
lters, first_conv_filter_size,
input_shape=(28, 28, 1),

30. 23
activation='relu'))
self.model.add(MaxPooling2D(pool_size=pool_size))
self.model.add(Conv2D(second_conv_num_filters,
second_conv_filter_size, activation='relu'))
self.model.add(MaxPooling2D(pool_size=pool_size))
self.model.add(Dropout(0.2))
self.model.add(Flatten()) self.model.add(Dense(128,
activation='relu')) self.model.add(Dense(50,
activation='relu')) self.model.add(Dense(13,
activation='softmax'))
# Compile the model
print("Compiling Model...")
self.model.compile(
optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'],
) def
load_model(self):
print('Loading Model...')
model_json = open('model/model.json', 'r')
loaded_model_json = model_json.read()
model_json.close()
loaded_model = model_from_json(loaded_model_json)
print('Loading weights...')
loaded_model.load_weights("model/model_weights.h5")
self.model = loaded_model def train_model(self):
if not os.path.exists('model/train_data.csv'):
load_all_imgs() csv_train_data =
pd.read_csv('model/train_data.csv',
index_col=False)
# The last column contain the results
y_train = csv_train_data[['784']]
csv_train_data.drop(csv_train_data.columns[[784]],
axis=1, inplace=True)
csv_train_data.head() y_train =
np.array(y_train) x_train = []
for i in range(len(csv_train_data)):
x_train.append(np.array(csv_train_data[i:i+1]).reshape(1, 28,
28))

31. 24
x_train = np.array(x_train) x_train =
np.reshape(x_train, (-1, 28, 28, 1)) # Train the
model. print('Training model...')
self.model.fit( x_train,
to_categorical(y_train, num_classes=13),
epochs=10, batch_size=200,
shuffle=True, verbose=1 ) def
export_model(self):
model_json = self.model.to_json() with
open('model/model.json', 'w') as json_file:
json_file.write(model_json)
self.model.save_weights('model/model_weights.h5') def
predict(self, operationBytes):
Image.open(operationBytes).save('aux.png')
img = cv2.imread('aux.png',cv2.IMREAD_GRAYSCALE)
os.remove('aux.png') if img is not None:
img_data = extract_imgs(img)
operation = ''
for i in range(len(img_data)):
img_data[i] = np.array(img_data[i])
img_data[i] = img_data[i].reshape(-1, 28, 28, 1)
result = self.model.predict_classes(img_data[i])
if result[0] == 10: operation += '+'
elif result[0] == 11: operation += '-'
elif result[0] == 12: operation += 'x'
else:
operation += str(result[0])
return operation

32. 25
CHAPTER 6
6. TEST CASES
System testing, also referred to as system-level tests or system-integration testing, is the
process in which a quality assurance (QA) team evaluates how the various components of an
application interact together in the full, integrated system or application. System testing verifies
that an application performs tasks as designed. This step, a kind of black box testing, focuses on
the functionality of an application. System testing, for example, might check that every kind of
user input produces the intended output across the application.
Phases of system testing:
A video tutorial about this test level. System testing examines every component of an
application to make sure that they work as a complete and unified whole. A QA team typically
conducts system testing after it checks individual modules with functional or user-story testing and
then each component through integration testing.
If a software build achieves the desired results in system testing, it gets a final check via
acceptance testing before it goes to production, where users consume the software. An app-dev
team logs all defects, and establishes what kinds and amount of defects are tolerable.
Software Testing Strategies:
Optimization of the approach to testing in software engineering is the best way to make it
effective. A software testing strategy defines what, when, and how to do whatever is necessary to

33. 26
make an end-product of high quality. Usually, the following software testing strategies and their
combinations are used to achieve this major objective:
Static Testing:
The early-stage testing strategy is static testing: it is performed without actually running the
developing product. Basically, such desk-checking is required to detect bugs and issues that are
present in the code itself. Such a check-up is important at the pre-deployment stage as it helps
avoid problems caused by errors in the code and software structure deficits.

34. 27
Structural Testing:
It is not possible to effectively test software without running it. Structural testing, also known as
white-box testing, is required to detect and fix bugs and errors emerging during the pre-production
stage of the software development process. At this stage, unit testing based on the software
structure is performed using regression testing. In most cases, it is an automated process working
within the test automation framework to speed up the development process at this stage.
Developers and QAengineers have full access to the software’s structure and data flows (data flows
testing), so they could track any changes (mutation testing) in the system’s behavior by comparing
the tests’ outcomes with the results of previous iterations (control flow testing).
Behavioral Testing:
The final stage of testing focuses on the software’s reactions to various activities rather than on the
mechanisms behind these reactions. In other words, behavioral testing, also known as blackbox
testing, presupposes running numerous tests, mostly manual, to see the product from the user’s
point of view. QA engineers usually have some specific information about a business or other
purposes of the software (‘the black box’) to run usability tests, for example, and react to bugs as
regular users of the product will do. Behavioral testing also may include automation (regression
tests) to eliminate human error if repetitive activities are required. For example, you may need to
fill 100 registration forms on the website to see how the product copes with such an activity, so the
automation of this test is preferable.

35. 28
TEST CASES:
S.NO INPUT If available If not available
1 User signup
User get registered into
the application
There is no process
2 User signin
User get login into the
application
There is no process
3 Enter input for prediction
Prediction result
displayed
There is no process

36. 29
CHAPTER 7
7. SCREENSHOTS
(fig 7.1 User Interface)
First the user will sign up and then with his credentials he /she will sign.

37. 30
(fig 7.2 home page)
Here we can choose whether we want to upload image or write.
(fig 7.3 writing equation on editor)

38. 31
(fig 7.4 uploading image)
(Fig 7.5 result)
Here we can check our result.

39. 32
CHAPTER 8
8. CONCLUSION
The focal point of this review was on perceiving manually written numerical quadratics.
For acknowledgment, we think about single quadratics just as series of quadratics. Examine
projections Each line of quadratics is fragmented utilizing a particular minimized flat projection.
For character division, an associated part with a high achievement rate is utilized. For image
acknowledgment like '=,' which is a solitary image blended in with two separate associated parts,
a further developed form of associated part is used. The most troublesome part of arrangement is
highlight extraction. Besides, penmanship is more diligently to recognize on the grounds that to a
few preset highlights. After effectively perceiving quadratics in any mix, we process the found
condition to get the quadratics' answer. We use a string activity way to deal with get the worth of
a, b, and c of every quadratic of the structure ay2+by+c=0 in this segment. At long last, we
accomplished best in class execution in both the discovery and arrangement stages.

40. 33
CHAPTER 9
9. FUTURE ENHANCEMENTS
This project offers a lot of scope for adding newer features. Since our project is handwritten
equation solver, we can add more features like speech recognition that means if any blind person
wants to check whether his answer is correct or not he can spell out the equation and the model
gives the answer with voice. We can also add quadratic equations to solve in future. This is a
userfriendly website you can easily check whether your answer is correct or not.

41. 34
CHAPTER 10
10.BIBILIOGRAPHY
1. Chuangxia, H.; Liu, B. New studies on dynamic analysis of inertial neural networks
involving nonreduced order method. Neurocomputing 2019, 325, 283– 287.
2. Alvear-Sandoval, R.; Figueiras-Vidal, A. On building ensembles of stacked denoising
autoencoding classifiers and their further improvement. Inf. Fusion 2018, 39, 41– 52.
3. Cai, Z.W.; Li-Hong, H. Finite-time synchronization by switching state-feedback control for
discontinuous Cohen– Grossberg neural networks with mixed delays. Int. J. Mach. Learn. Cybern.
2018, 9, 1683– 1695.
4. Zeng, D.; Dai, Y.; Li, F.; Sherratt, R.S.; Wang, J. Adversarial learning for distant supervised
relation extraction. Comput. Mater. Contin. 2018, 55, 121– 136.
5. Xiang, L.; Li, Y.; Hao, W.; Yang, P.; Shen, X. Reversible natural language watermarking
using synonym substitution and arithmetic coding. Comput. Mater. Contin. 2018, 55, 541– 559.
6. Long, M.; Yan, Z. Detecting iris liveness with batch normalized convolutional neural
network. Comput. Mater. Contin. 2018, 58, 493– 504

42. 35
7. Qu, X.; Wang, W.; Lu, K.; Zhou, J. Data augmentation and directional feature maps
extraction for in-air handwritten Chinese character recognition based on convolutional neural
network. Pattern Recognit. Lett. 2018, 111, 9– 15.
8. Wang, D.; Lihong, H.; Longkun, T. Dissipativity and synchronization of generalized BAM
neural networks with multivariate discontinuous activations. IEEE Trans. Neural Netw. Learn.
Syst. 2017, 29, 3815– 3827.
9. Kuang, F.; Siyang, Z.; Zhong, J.;Weihong, X. A novel SVM by combining kernelprincipal
component analysis and improved chaotic particle swarm optimization for intrusion detection. Soft
Comput. 2015, 19, 1187– 1199.
10. Ciresan, D.C.; Meier, U.; Schmidhuber, J. Multicolumn deep neural networks for image
classification. 24 arXiv 2015,arXiv:1202.2745