1 Introduction

The research on auto-recognition of constrained and unconstrained Devanagari scripts started in early 1970s, and it has complex composition of its constituent symbols (13 vowels and 34 consonants along with 14 modifiers of vowels, see Fig. 1) Jayadevan et al. [1].

Fig. 1
figure 1

a Vowels and modifiers of Devanagari script. b Consonants and their corresponding half form in Devanagari script

Full size image

Devanagari script has its own specified composition rules for combining vowels, consonants and modifiers. Some of them can be combined with their type (see Fig. 2) Jayadevan et al. [1].

Fig. 2
figure 2

Combination of consonants

Full size image

Another distinctive feature of the Devanagari script is the presence of a horizontal header line on the top of all characters (see Fig. 3).

Fig. 3
figure 3

Three scripts of a word in the Devanagari script

Full size image

The occurrence frequency of different Devanagari characters is provided in the occurrence statistics of 20 frequent characters in Devanagari script Jayadevan et al. [1] (see Table 1).

Table 1 Occurrence statistics of 20 frequent characters in Devanagari script
Full size table

In the present scenario, due to the complex structures and high unevenness in writing styles of the scripting languages, recognition of words and characters from the Devanagari offline handwritten script has become a burning vicinity of interest for researchers. Many preprocessing steps are performed in automatic Devanagari offline handwritten recognition systems, which give a moderate deviation in the handwritten script and conserved information relevant to acknowledge.

The present research article is arranged, in the following sections: Sect. 2 gives a brief introduction to related works, Sect. 3 defines mathematical notations to be used in description algorithms, Sect. 4 discusses the methodologies of Pixel Plot and Trace and Re-plot and Re-trace (PPTRPRT) technique, Sects. 5, 6 and 7 deal with the segmentation of words and characters.

2 Related work

Numerous approaches have been proposed so far for improving segmentation of Devanagari offline handwritten scripts. Jayadevan et al. [1] have explored various feature extraction techniques as well as training, classification and matching techniques. Sahu et al. [2] used artificial neural network technique for preprocessing operations and designed a system for segmentation as well as recognition of Devanagari characters. Yadav et al. [3] proposed a hybrid system by combining both writer recognition and handwriting recognition for the Devanagari script. Wshah et al. [4] have proposed a script independent line-based word spotting framework based on hidden Markov models for offline handwritten documents and deal with large vocabulary without the need for word or character segmentation. Wshah et al. [5] proposed a multilingual word spotting framework based on hidden Markov models that work on corpus of multilingual handwritten documents and proposed two systems: a script identifier-based (IDB) and a script identifier-free (IDF) system. Deshpande et al. [6] proposed that the segmentation evolved regular expressions without doing preprocessing as well as training and transformed notation of regular expression directly into directed graphs and provide all the symbol strings generated by the corresponding expressions to finite-state automata. Rahul et al. [7] have proposed a Devanagari handwritten script recognition by applying a feature vector to an artificial neural network. Pal et al. [8] proposed a lexicon-driven method for multilingual (English, Hindi and Bangla) city name recognition for Indian postal automation. Doiphode et al. [9] proposed a technique which finds joint points in the word, identifies vertical and horizontal lines and finally dissects touching characters by taking into account its dimensions, namely height and width of the bounding box. Sankaran et al. [10] have proposed a formulation to minimize expectations on Unicode generation, error correction, and the harder recognition task is modeled as learning of an appropriate sequence to sequence translation scheme. Kumar et al. [11] have presented a survey on OCR of most popular Indian scripts. Wshah et al. [12] proposed a statistical script independent line-based word spotting framework for offline handwritten documents based on hidden Markov models by comparing an exhaustive study of filler models and background models for better representation of background or non-keyword text. Basu et al. [13] proposed a work to recognize the postal codes written in any of the four popular scripts, viz. Latin, Devanagari, Bangla and Urdu. Hassan et al. [14] proposed a framework for the application of multiple features for handwritten data-based identity recognition. They have designed a scheme for multiple feature-based identity establishment using multi-kernel learning using genetic algorithm.

3 Mathematical terms

The use of the standard symbols is highly recommended (see Table 2).

Table 2 Mathematical symbols
Full size table

4 Methodology

This section briefly discusses descriptive algorithms of PPTRPRT technique for Devanagari offline handwritten script segmentation.

4.1 Overview of system design

Descriptive architecture of the PPTRPRT technique is given in Fig. 4.

Fig. 4
figure 4

Architecture of PPTRPRT technique

Full size image

The pattern sets used in the current study are Devanagari offline handwritten script. For desired outcomes, we are using Feedforward Neural Network.

For the evaluation of PPTRPRT technique, a gigantic database of 49,000 samples (i.e., Center for Microprocessor Application for Training Education and Research (CMATER), ICDAR-2005, Off-line Handwritten Devanagari Numeral Database, WCACOM ET0405A-U, HP Labs India Indic Handwriting Datasets) is composed for training pattern.

The PPTRPRT technique extracts text region from Devanagari offline handwritten script images and passes it to iterative processes for segmentation of text lines. The segmented text lines are used in skew and de-skew operations. These skewed and de-skewed images are provided for white pixel-based word segmentation, and these segmented words are used in an iterative process for segmentation of characters. The PPTRPRT technique embraces various dispensations to segment characters from Devanagari offline handwritten script. The normalization steps permit deviations in pen breadth and slant in inscription.

The PPTRPRT technique initiates the segmentation algorithm.

Algorithm 1: Segmentation ()

Step 1: Load Devanagari offline handwritten script file ɛ i

Step 2: Call Preprocessing (ɛ i )

The segmentation algorithm upload Devanagari offline handwritten script ɛ i and outcome of an algorithm is shown in Fig. 5.

Fig. 5
figure 5

Original text image

Full size image

4.2 Preprocessing for characters segmentation

The outcomes of the segmentation algorithm are availed by preprocessing algorithm for forthcoming operations.

Algorithm 2: Preprocessing (ɛ i )

Step 1: Extract text segment

\(\beta_{i} = \varepsilon_{i} - \rho\)

Step 2: Segment text lines from β i

   (a) Define PEAK_FACTOR (Γ i ) = 5 and THRESHOLD (Ξ i ) = 1

   (b) Obtain black and white image (Δ i )

   (c) Generate Histogram (Π i )

   (d) Calculate upper peak (MaxΓ i ) and lower peak (MinΓ i )

   (e) Calculate text line segmentation points (P j )

   (f) Segment text line (S i ) and drop white parts (∃ k )

Step 3: Call SkewCorrection (S i )

The above-defined algorithm extracts the text segment β i from ɛ i by removing noises ρ. This text segment β i is applied for text line segmentation by calculating MaxΓ i and MinΓ i with PEAK_FACTOR Γ i along with various adequate operations (see Fig. 6).

Fig. 6
figure 6

Horizontal cuts of text image

Full size image

Furthermore, using MaxΓ i , MinΓ i and the size of an image L, we calculate text line segmentation points (P j ) and segment text line (S i ) from the text segment β i by eliminating white parts (∃ k ) along with THRESHOLD value (see Fig. 7).

Fig. 7
figure 7

Segmented text lines

Full size image

4.3 Skew correction

Outcomes of preprocessing algorithm are availed by skew correction algorithm for skew correction operations.

Algorithm 3: SkewCorrection (S i )

Step 1: Improve intensity of the black pixels (Bk)

Step 2: Find (x, y) coordinates of the lower pixels (low_bk)

Step 3: Filter irrelevant pixels F i (low_bk)

Step 4: Calculate slope angle (θ i (S i )) of the text line using linear regression

Step 5: Skew or De-skew text line(S i ) with slope angle (θ i (S i ))

\(\left( {S_{i}^{2} = Screw\,\theta_{i} \,\,or\,\,De - Screw\,\theta_{i} } \right)\)

Step 6: Remove black corners from skewed text line

\(S_{i}^{2} = S_{i}^{1} - \varLambda_{k}\)

Step 7: Call SlantDetection (S 2 i , θ i )

An above-defined algorithm calculates (x, y) coordinate of the lower pixels and filters irrelevant pixels F i (low_bk) from segmented text line (S i ). The slope angle (θ i (S i )) of the segmented text line (S i ) is calculated using linear regression [θ i (S i )] and removed black corners with skewed operation S 2 i  = S 1 i  − Λ k . The outcomes of an algorithm are shown in Figs. 8 and 9.

Fig. 8
figure 8

Linear regression of the text lines

Full size image
Fig. 9
figure 9

Skew corrected text lines

Full size image

4.4 Slant detection and correction

Outcomes of skew correction algorithm (skewed text line S 2 i along with angle θ i ) are availed by slant detection algorithm for slant detection operation.

Algorithm 4: SlantDetection (S 2 i , θ i )

Step 1: Trace regional boundaries of an image ω i (S 2 i )

Step 2: Define min_strock_length and step_size

Step 3: Do Histogram count operations (Π i )

Step 4: Find indices and value of nonzero elements

Step 5: Calculate slant angle ϕ i

Step 6: Call SlantCorrection (S 2 i , ϕ i )

The slant detection algorithm trace regional boundaries of an image ω i (S 2 i ) by defining min_strock_length and step_size. Moreover, it traces count operations as well as the indices of the text line S 2 i using histogram Π i and finds nonzero elements. A slant angle ϕ i is to be calculated using indices and value of nonzero elements. The outcomes of an algorithm are shown in Fig. 10.

Fig. 10
figure 10

Slant detection of the text lines

Full size image

Besides, slant angle ϕ i and the text line S 2 i are used for slant correction operations.

Algorithm 5: SlantCorrection (S 2 i , ϕ i )

Step 1: Calculate Height (ξ i (S 2 i )), Width (η i (S 2 i )) and Depth (ζ i (S 2 i )) of the text line (S 2 i )

Step 2: Define new text line matrix A i (S 2 i )

Step 3: Create spatial transformation structure of the text line

\(R_{i} \left( {A_{i} \left( {S_{i}^{2} } \right)} \right)\)

\(T_{i} \left( {A_{i} \left( {S_{i}^{2} } \right)} \right)\)

\(U_{i} \left( {A_{i} \left( {S_{i}^{2} } \right)} \right)\)

Step 4: Segment final skewed text line

\(S_{i}^{3} = \left( {R_{i} - T_{i} + U_{i} } \right)\)

Step 5: Call WordSegmentation (S 3 i )

The above-defined algorithm calculates height [ξ i (S 2 i )], width [η i (S 2 i )] and depth [ζ i (S 2 i )] of the text line(S i 2). These parameters formulate a new text line matrix A i (S 2 i ) and spatial transformation structures R i (A i (S 2 i )), T i (A i (S 2 i )), U i (A i (S 2 i )). These spatial transformation structures are used to segment skewed text line S 3 i  = (R i  − T i  + U i ) which is used in word segmentation. The outcomes of an algorithm are shown in Fig. 11.

Fig. 11
figure 11

Slant correction of the text line

Full size image

5 Word segmentation

Moreover, the outcomes of slant correction algorithm are availed by word segmentation algorithm.

Algorithm 6: WordSegmentation (S 3 i )

Step 1: Generate Histogram Π i

Step 2: Find Segmentation Points of Word Q ij

   (a) Find White Spaces λ ij  = ∑ ∃ k

   (b) Cluster Text Line to distinguish between white spaces

\(\varOmega_{ij} = \aleph_{i} \left( {S_{i}^{3} ,\lambda_{ij} } \right)\)

Step 3: Call CharactersSegmentation (Ω ij )

Above-defined algorithm calculates histogram Π i and white space λ ij  = Σ∃ k which are used to trace words segmentation pointsQ ij . The outcomes of an algorithm are shown in Figs. 12 and 13.

Fig. 12
figure 12

White spaces between words

Full size image
Fig. 13
figure 13

Segmented words from the text line

Full size image

The Character Segmentation Algorithm uses segmented words (Ω ij ) for the segmentation as well as extraction of characters using a Feedforward Neural Network model.

6 Feedforward Neural Network

In a multilayer Feedforward Neural Network, output feeds forward from one layer of neurons to the next layer of neurons. A multilayer Feedforward Neural Network can represent nonlinear functions and consists of one input layer, one or more hidden layers besides one output layer. Each layer has associated weights, (w0) and (z0),  which feeded into the hidden layer and into the output layer respectively. Therefore, neither any backward connection nor skipping connection exists between layers. These weights will adjust while training the network using back-propagation algorithm. Typically, all input units are connected to hidden layer units, and hidden layer units are connected to the output units.

A.:

Input units

Data is feeded through Input units into the system without any processing, the value of an input unit is xj, where j goes through 1 to d input units along with a special input unit x0 contains a constant value 1 and provides bias to the hidden nodes.

B.:

Hidden units

Each hidden node calculates the weighted sum of its inputs and determines the output of the hidden node with a threshold function. The weighted sum of the inputs for hidden node z h is calculated as:

$$\sum\limits_{j = 0}^{d} {w_{hj} x_{j} }$$
(1)

The threshold function applied at the hidden node is typically either a step function or a sigmoid function.

$${\text{sigmoid}}\left( a \right) = \frac{1}{{1 + {\text{e}}^{ - a} }}$$
(2)

The sigmoid function is a squashing function, it squashes input between 0 and 1. It applies to the hidden node for the weighted sum of inputs and generates output z h

$${\text{z}}_{h} {\text{ = sigmoid}}\left( {\sum\limits_{j = 0}^{d} {w_{hj} x_{j} } } \right) = \frac{1}{{1 + {\text{e}}^{{ - \sum\nolimits_{j = 0}^{d} {w_{hj} x_{j} } }} }}$$
(3)

for h going from 1 to H total number of hidden nodes.

C.:

Output units

Computation of the output node is either based on the type of problem (i.e., either a regression problem or a classification problem) or on number of output. The weights going into the output unit are v ih and have the bias input from hidden unit z 0, where the input from z 0 is always 1. So, output unit i computes the weighted sum of its inputs as:

$$o_{i} = \sum\limits_{h = 0}^{H} {v_{ih} \,z_{h} }$$
(4)

In case of one output unit, weighted sum is

$$o = \sum\limits_{h = 0}^{H} {v_{h} \,z_{h} }$$
(5)
D.:

Functions

  1. (1)

    Regression for single and multiple outputs

A regression function for the single output calculates the output unit value ‘y’ by weighted sum of its inputs:

$$y = o = \sum\limits_{h = 0}^{H} {v_{h} \,z_{h} }$$
(6)

For multiple outputs, we calculate the output value of unit y i

$$y_{i} = o_{i} = \sum\limits_{h = 0}^{H} {v_{ih} \,z_{h} }$$
(7)
  1. (2)

    Classification for 2 classes

One node can produce either 0 or 1, it can have one class correspond to 0 or 1, respectively, and generate output between 0 and 1.

$${\text{y = }}\;{\text{sigmoid}}\,\left( o \right) = {\text{sigmoid}}\left( {\sum\limits_{h = 0}^{H} {v_{h} \,z_{h} } } \right) = \frac{1}{{1 + {\text{e}}^{{ - \sum\nolimits_{h = 0}^{H} {v_{h} z_{h} } }} }}$$
(8)
E.:

Back-propagation Algorithm

The Back-Propagation Algorithm is used to train Feedforward Neural Network using Gradient Descent method to update the weights in order to minimize the squared error between the network output values and the target output values.

  1. (1)

    Online and offline learning

Online learning performs using Stochastic Gradient Descent and offline learning using gradient descent.

  1. (2)

    Online weight updates

Weight updates give a single instance (x t, r t), where x t is the input, r t is the target output, and y t is the actual output of the network along with a positive constant learning rate ϑ.

  1. (a)

    Regression in a single output: the weight updates are

$$\Delta v_{h} = \vartheta \left( {r^{\text{t}} - y^{\text{t}} } \right)z_{h}^{\text{t}}$$
(9)
$$\Delta w_{hj} = \vartheta \left( {r^{\text{t}} - y^{\text{t}} } \right)v_{h} z_{h}^{\text{t}} \left( {1 - z_{h}^{\text{t}} } \right)x_{j}^{\text{t}}$$
(10)
  1. (b)

    Regression in multiple (i.e., K) outputs: the weight updates are

$$\Delta v_{ih} = \vartheta \left( {r_{i}^{t} - y_{i}^{t} } \right)z_{h}^{t}$$
(11)
$$\Delta w_{hj} = \vartheta \left( {\sum\limits_{i = 1}^{K} {\left( {r_{i}^{\text{t}} - y_{i}^{\text{t}} } \right)v_{ih} } } \right)z_{h}^{\text{t}} \left( {1 - z_{h}^{\text{t}} } \right)x_{j}^{\text{t}}$$
(12)
  1. (c)

    Classification for 2 classes: the weight updates are

$$\Delta v_{h} = \vartheta \left( {r^{\text{t}} - y^{\text{t}} } \right)z_{h}^{\text{t}}$$
(13)
$$\Delta w_{hj} = \vartheta \left( {r^{\text{t}} - y^{\text{t}} } \right)v_{h} z_{h}^{\text{t}} \left( {1 - z_{h}^{\text{t}} } \right)x_{j}^{\text{t}}$$
(14)
  1. (d)

    Classification of K > 2 classes: the weight updates are

$$\Delta v_{ih} = \vartheta \left( {r_{i}^{\text{t}} - y_{i}^{\text{t}} } \right)z_{h}^{\text{t}}$$
(15)
$$\Delta w_{hj} = \vartheta \left( {\sum\limits_{i = 1}^{K} {\left( {r_{i}^{\text{t}} - y_{i}^{\text{t}} } \right)v_{ih} } } \right)z_{h}^{\text{t}} \left( {1 - z_{h}^{\text{t}} } \right)x_{j}^{\text{t}}$$
(16)
F.:

Error calculation

The sum of squared errors function is usually used to calculate errors, it can measure error with one output unit for one training example (x t, r t) as

$$E\left( {W,v|x^{\text{t}} ,r^{\text{t}} } \right) = \frac{1}{2}\left( {r^{\text{t}} - y^{\text{t}} } \right)^{2}$$
(17)

Error calculation with multiple output units is simply summation of errors

$$E\left( {W,v|x^{\text{t}} ,r^{\text{t}} } \right) = \frac{1}{2}\sum\limits_{i = 1}^{K} {\left( {r_{i}^{\text{t}} - y_{i}^{\text{t}} } \right)^{2} }$$
(18)

To calculate the error for 1 epoch with one output node (y i)

$$E\left( {W,v|X} \right) = \frac{1}{2}\sum\limits_{{\left( {x^{\text{t}} ,r^{\text{t}} } \right) \in X}} {\left( {r_{i}^{\text{t}} - y_{i}^{\text{t}} } \right)^{2} }$$
(19)

To calculate the error in the entire network for 1 epoch

$$E\left( {W,v|X} \right) = \frac{1}{2}\sum\limits_{{\left( {x^{t} ,r^{t} } \right) \in X}} {\left( {\sum\limits_{i = 1}^{K} {\left( {r_{i}^{t} - y_{i}^{t} } \right)^{2} } } \right)}$$
(20)
G.:

Momentum

To speed up the learning process, the momentum is used instead of the gradient descent method.

$$v_{ih} = v_{ih} +\Delta v_{ih}$$
(21)
$$w_{hj} = w_{hj} +\Delta w_{hj}$$
(22)

So, new weight update equations are

$$v_{ih}^{\text{t}} = v_{ih}^{\text{t}} + \varDelta v_{ih}^{\text{t}} + \alpha \,\Delta v_{ih}^{{{\text{t}} - 1}}$$
(23)
$$w_{hj}^{\text{t}} = w_{hj}^{\text{t}} +\Delta w_{hj}^{\text{t}} + \alpha \,\Delta w_{hj}^{{{\text{t}} - 1}}$$
(24)

6.1 Design of training set

In the simulation and design of network learning, a multilayer Feedforward Neural Network is designed and network is trained using ‘gradient descent with momentum and adaptive learning rate back-propagation,’ ‘gradient descent with momentum weight and bias learning function,’ ‘mean squared normalized error performance function’ and ‘log-sigmoid transfer function’ and its structure is 100-5-5-5. (see Table 3).

Table 3 Neural network specifications
Full size table

Figure 14 shows a training state graph which contains training, validation, test and best case. The best validation performance is 9.0905e−024 at epoch 2.

Fig. 14
figure 14

Feedforward back-propagation neural network training state

Full size image

Figure 15 shows the neural network regression state which contains training graph, validation graph, test graph and overall graph. It specifies the overall regression state near about linear which is 1. Table 4 shows simulation results of the training.

Fig. 15
figure 15

Feedforward back-propagation neural network regression

Full size image
Table 4 Simulation results
Full size table

Since every input pattern consists of 100 distinct samples so far, Fig. 16 shows the performance graph of simulation result between neural network and input samples.

Fig. 16
figure 16

Simulation results graph

Full size image

7 Characters segmentation

For the evaluation of PPTRPRT technique, a gigantic database of 49,000 samples (i.e., Center for Microprocessor Application for Training Education and Research (CMATER), ICDAR-2005, Off-line handwritten devanagari numeral database, WCACOM ET0405A-U, HP Labs India Indic Handwriting Datasets) is composed for training pattern.

Algorithm 7: CharactersSegmentation (Ω ij )

Step 1: Calculate all black pixels

\(\sum {B_{k} \left( {\varOmega_{ij} } \right)}\)

Step 2: Plot N Pixels Image

\(P_{jk} \left( {\sum {N_{k} } \,,\sum {B_{k} \left( {\varOmega_{ij} } \right)} } \right)\)

Step 3: Input image to Feedforward Neural Network and Recall the Input image from Input samples

\(\psi_{jk} = ANN\left( {P_{jk} \left( {\sum {N_{k} } \,,\,\sum {B_{k} \left( {\varOmega_{ij} } \right)} } \right)} \right)\)

If (ψ jk  > 95 %)

go to step 2

else

\(\psi_{jk}^{'} = \psi_{jk} + P_{jk} \left( {\sum {N_{k} } \,,\sum {B_{k} \left( {\varOmega_{ij} } \right)} } \right)\)

\(\psi_{jk} = \psi_{jk}^{'}\)

Repeat step 3

Step 4: Return (ψ jk )

In above algorithm, histogram Π i is used to calculate black pixels ΣB k (Ω ij ) from the segmented words and plot N black pixels P jk (ΣN k , ΣB k (Ω ij )) from the calculated black pixels ΣB k (Ω ij ). Moreover, P jk pixels are used in the Feedforward Neural Network model to recall the image from samples database. The PPTRPRT technique calculates ψ jk using Feedforward Neural Network

$$\psi_{jk} = ANN\left( {P_{jk} \left( {\sum {N_{k} } \,,\,\sum {B_{k} \left( {\varOmega_{ij} } \right)} } \right)} \right)$$
(25)

If recalled input image ψ jk is matched with sample pattern up to ≥99 %, then it proceeds for the next N pixels. Otherwise, calculate ψ′ jk , by adding N more pixels in earlier calculated ψ jk and proceed for further operations

$$\psi_{jk}^{'} = \psi_{jk} + P_{jk} \left( {\sum {N_{k} } \,,\sum {B_{k} \left( {\varOmega_{ij} } \right)} } \right)$$
(26)

The outcomes of an algorithm are shown in Fig. 17.

Fig. 17
figure 17

Segmented characters over words

Full size image

8 Experiments and results

The PPTRPRT technique utilizes a gigantic database of offline handwritten sample scripts (each sample has 10–20 lines) with distinct brightness and intensity. In this research article, descriptive algorithms are used with distinct parameter given in Table 5. The outcomes of algorithms are in the form of lines, words and characters (see Figs. 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19).

Table 5 Parameter table
Full size table
Fig. 18
figure 18

Parametric analytical graph

Full size image
Fig. 19
figure 19

Parametric analytical graph

Full size image

An execution of PPTRPRT technique is started with preprocessing algorithm for segmentation of text regions as well as text lines from Devanagari offline handwritten script (see Figs. 5, 6, 7). These segmented text lines were used with skew correction algorithm. Moreover, these skewed lines are available for execution of slant detection algorithm (see Figs. 8, 9, 10), and slant detected lines are used by slant correction algorithm (see Fig. 11). The slant corrected lines are used by white pixel-based word segmentation algorithm (see Figs. 12, 13). These segmented word images are used by characters segmentation algorithm (see Fig. 17).

Outcomes of the PPTRPRT technique are encouraging enough, and analyses of the result are shown in Fig. 18. Figure 18 shows the analytical performance graph in form of minimum and maximum performance ratio for the operations performed during the experiments. Graph shows that noise correction ratio is minimum 90.078 %, maximum 99.23 % and the performance ratio of segmented/un-segmented lines is minimum 0 %, maximum 100 %. The performance ratio of skew/de-skew of segmented line is minimum 99.97 %, maximum 100 % and un-skewed/de-skewed lines ratio is 0 %. Besides this, the words segmentation performance ratio over segmented lines is minimum 99.79 %, minimum 100 % and segmented characters performance ratio in a word as well as in the line is minimum 99.037 % and maximum 100 %. Finally, a unit sample performance ratio is minimum 99.578 % and maximum 100 %.

9 Conclusion and further work

This research work presents a realistic characters segmentation technique for Devanagari offline handwritten scripts using a Feedforward Neural Network. The PPTRPRT technique gives a concrete basis to design an optical characters reader with finest accuracy and lowest cost. It is a new technique for reconstructing the Devanagari offline handwritten scripts.

An accuracy of segmented characters from unit sample is 99.578 % and is far enhanced from existing known techniques [15–26]. Table 6 gives comparative details of Devanagari Offline Handwritten Script Recognition systems with the performance of our proposed technique. Puri et al. [5] have proposed accuracy 80.20 % using header line as a feature vector with HMM as a classifier, the size of data set was 39,700. Pal et al. [16] and Malik et al. [17] have proposed accuracy 80.36 and 82 %, respectively, using chain code as feature vector and quadratic was well RE and MFD as classifier, the size of data set was 11,270 and 5000, respectively. Sridhar et al. [18] have proposed accuracy 84.31 % using directional chain code as feature vector and HMM as classifier, the size of data set was 39,700. Murthy et al. [19] have proposed accuracy 90.65 % using distance vector as feature vector and Fuzzy set as classifier, the size of data set was 4750. Basu et al. [20] have proposed accuracy 90.74 % using shadow and CH as feature vector and MLP and MED as classifier, the size of data set was 7154. Kumar et al. [21] have proposed accuracy 94.1 % using gradient as feature vector and SVM as classifier, the size of data set was 25,000. Wakabayashi et al. [22] have proposed accuracy 94.24 % using Gaussian filter as feature vector and quadratic as classifier, the size of data set was 36,172. Rabha et al. [23] have proposed accuracy 94.91 % using eigen-deformation as feature vector and elastic matching as classifier, the size of data set was 3600. Kimura et al. [24] have proposed accuracy 95.13 % using gradient as feature vector and MQDF as classifier, the size of data set was 36,172. Bhatcharjee et al. [25] have proposed accuracy 98.12 % using structural vector as feature vector and FFNN as classifier, the size of data set was 50,000. Nasipuri et al. [26] have proposed accuracy 98.85 % using combined code as feature vector and MLP as classifier, the size of data set was 1500. Finally in proposed work, PPTRPRT technique gives accurate results up to 99.578 % using HFNN as classifier, the size of data set was 49,000. Furthermore, comparison of PPTRPRT technique with other techniques is given in tabular form as below (see Table 6).

Table 6 Comparative details of Devanagari offline handwritten script recognition systems
Full size table

Figure 19 shows analytical performance graph to compare performance of the proposed technique over the existing technique. Our future work is to extend the scope of the PPTRPRT technique to recognize English–Hindi mixed offline handwritten scripts.

In this research article, we are giving a realistic technique to reform the segmentation of words and characters from the Devanagari offline handwritten scripts over the existing techniques. It will provide a concrete basis to design an optical characters reader (OCR) with finest accuracy and lowest cost. In the knowledge of researchers, Pixel Plot and Trace and Re-plot and Re-trace (PPTRPRT) technique is new in reconstruction of the Devanagari offline handwritten scripts.