diff --git a/.gitattributes b/.gitattributes
index b15d2c9b6578c1dba51ba11a7b2a0b830aa40f8d..f06c4854acd7f4baacc1525446083039c5f6cb7b 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -105,3 +105,5 @@ data/AB/1931/04_correctedxml.tar.gz filter=lfs diff=lfs merge=lfs -text
 data/AB/1932/04_correctedxml.tar.gz filter=lfs diff=lfs merge=lfs -text
 data/AB/1933/04_correctedxml.tar.gz filter=lfs diff=lfs merge=lfs -text
 data/AB/1934/04_correctedxml.tar.gz filter=lfs diff=lfs merge=lfs -text
+data/AB/1891/04_correctedxml.tar.gz filter=lfs diff=lfs merge=lfs -text
+src/python/def_classes.py filter=lfs diff=lfs merge=lfs -text
diff --git a/.renku/workflow/8fc059510bc74b0d8c08803aa768d410_python.cwl b/.renku/workflow/8fc059510bc74b0d8c08803aa768d410_python.cwl
new file mode 100644
index 0000000000000000000000000000000000000000..3afaba3143ad40e8c65cbd583d46e3a11a1354fe
--- /dev/null
+++ b/.renku/workflow/8fc059510bc74b0d8c08803aa768d410_python.cwl
@@ -0,0 +1,67 @@
+arguments: []
+baseCommand:
+- python
+class: CommandLineTool
+cwlVersion: v1.0
+hints: []
+inputs:
+  input_1:
+    default:
+      class: File
+      path: ../../src/python/run_correctxml.py
+    inputBinding:
+      position: 1
+      separate: true
+      shellQuote: true
+    streamable: false
+    type: File
+  input_2:
+    default:
+      class: File
+      path: ../../data/AB/1891/02_extractedxml.tar.gz
+    inputBinding:
+      position: 2
+      separate: true
+      shellQuote: true
+    streamable: false
+    type: File
+  input_3:
+    default: data/AB/1891/04_correctedxml.tar.gz
+    inputBinding:
+      position: 3
+      separate: true
+      shellQuote: true
+    streamable: false
+    type: string
+outputs:
+  output_0:
+    outputBinding:
+      glob: $(inputs.input_3)
+    streamable: false
+    type: File
+  output_1:
+    outputBinding:
+      glob: src/python/def_classes.py
+    streamable: false
+    type: File
+  output_2:
+    outputBinding:
+      glob: notebooks/RunningClasses.ipynb
+    streamable: false
+    type: File
+permanentFailCodes: []
+requirements:
+- class: InlineJavascriptRequirement
+- class: InitialWorkDirRequirement
+  listing:
+  - entry: '$({"listing": [], "class": "Directory"})'
+    entryname: notebooks
+    writable: true
+  - entry: '$({"listing": [], "class": "Directory"})'
+    entryname: src/python
+    writable: true
+  - entry: '$({"listing": [], "class": "Directory"})'
+    entryname: data/AB/1891
+    writable: true
+successCodes: []
+temporaryFailCodes: []
diff --git a/data/AB/1891/04_correctedxml.tar.gz b/data/AB/1891/04_correctedxml.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b5f3a23c41d2e16fc19bed2e3573a0ca1a619e61
--- /dev/null
+++ b/data/AB/1891/04_correctedxml.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10fa7d8fe1ef4eb9d12128007fabe1ef02d34673d37b73815a4ef893badd032f
+size 3414251
diff --git a/notebooks/RunningClasses.ipynb b/notebooks/RunningClasses.ipynb
index 078d7176d17ee325bba653be9bb7b18d433875c6..4d1234f1946adcb34a1257c5f0633790bd54d5f1 100755
--- a/notebooks/RunningClasses.ipynb
+++ b/notebooks/RunningClasses.ipynb
@@ -9,9 +9,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2\n",
@@ -28,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -45,9 +54,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(['./1892/20026491.pdf',\n",
+       "  './1892/20026492.pdf',\n",
+       "  './1892/20026493.pdf',\n",
+       "  './1892/20026494.pdf',\n",
+       "  './1892/20026495.pdf',\n",
+       "  './1892/20026496.pdf',\n",
+       "  './1892/20026497.pdf',\n",
+       "  './1892/20026498.pdf',\n",
+       "  './1892/20026499.pdf',\n",
+       "  './1892/20026500.pdf',\n",
+       "  './1892/20026501.pdf',\n",
+       "  './1892/20026502.pdf',\n",
+       "  './1892/20026503.pdf',\n",
+       "  './1892/20026504.pdf',\n",
+       "  './1892/20026505.pdf',\n",
+       "  './1892/20026506.pdf',\n",
+       "  './1892/20026507.pdf',\n",
+       "  './1892/20026508.pdf',\n",
+       "  './1892/20026509.pdf',\n",
+       "  './1892/20026510.pdf',\n",
+       "  './1892/20026511.pdf',\n",
+       "  './1892/20026512.pdf',\n",
+       "  './1892/20026513.pdf',\n",
+       "  './1892/20026514.pdf',\n",
+       "  './1892/20026515.pdf',\n",
+       "  './1892/20026516.pdf',\n",
+       "  './1892/20026517.pdf',\n",
+       "  './1892/20026518.pdf',\n",
+       "  './1892/20026519.pdf',\n",
+       "  './1892/20026520.pdf',\n",
+       "  './1892/20026521.pdf',\n",
+       "  './1892/20026522.pdf',\n",
+       "  './1892/20026523.pdf'],\n",
+       " ['1892'])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "name_tar = '00_rawpdfs'\n",
     "utils_proc.get_list(year, folder_database, name_tar)"
@@ -63,19 +116,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
     "# From the ones above\n",
-    "input_file = './1892/20026503.pdf'"
+    "input_file = './1892/20026518.pdf'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1892 20026518 ./1892/20026518.pdf ../data/AB/1892/\n",
+      "14\n"
+     ]
+    }
+   ],
    "source": [
     "d1 = defc.Document(input_file, folder_database)\n",
     "print(d1.year, d1.id_doc, d1.input_file, d1.path_file)\n",
@@ -93,9 +155,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Not saving to tar\n",
+      "['../data/AB//1892/02_extractedxml.tar.gz', './1892/20026518_data.xml'] [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13]\n"
+     ]
+    }
+   ],
    "source": [
     "# flag_save to 0 to avoid overwritting the existing tar.gz files\n",
     "d1.pdf2xml(pages = 'all', suffix_xml = '_data', flag_save = 0, name_outxml = '02_extractedxml')\n",
@@ -104,9 +175,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "14\n"
+     ]
+    }
+   ],
    "source": [
     "print(len(d1.XML_main))"
    ]
@@ -121,15 +200,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "Image data cannot be converted to float",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-18-02c3c0a3d987>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m d1.correct_xml(flag_plots = 1, flag_parallel = 0, flag_save_figs = 0,\n\u001b[1;32m      3\u001b[0m                     \u001b[0mpages\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'all'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msuffix_xml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'_data'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_outxml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'02_extractedxml'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m                     name_outcorrxml = '04_correctedxml', flag_save = 0)\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_xml_corr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mXML_main_corr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/democrasci_preprocwp1/src/python/def_classes.py\u001b[0m in \u001b[0;36mcorrect_xml\u001b[0;34m(self, flag_plots, flag_parallel, flag_save_figs, pages, suffix_xml, name_outxml, name_outcorrxml, flag_save)\u001b[0m\n\u001b[1;32m    277\u001b[0m                         \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_met2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    278\u001b[0m                         \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'off'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 279\u001b[0;31m                         \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_met3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    280\u001b[0m                         \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'off'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    281\u001b[0m                         \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_met4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1808\u001b[0m                         \u001b[0;34m\"the Matplotlib list!)\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1809\u001b[0m                         RuntimeWarning, stacklevel=2)\n\u001b[0;32m-> 1810\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1812\u001b[0m         inner.__doc__ = _add_data_doc(inner.__doc__,\n",
+      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, shape, filternorm, filterrad, imlim, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m   5492\u001b[0m                               resample=resample, **kwargs)\n\u001b[1;32m   5493\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5494\u001b[0;31m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5495\u001b[0m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_alpha\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5496\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_clip_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mset_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m    640\u001b[0m         if (self._A.dtype != np.uint8 and\n\u001b[1;32m    641\u001b[0m                 not np.can_cast(self._A.dtype, float, \"same_kind\")):\n\u001b[0;32m--> 642\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Image data cannot be converted to float\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    643\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    644\u001b[0m         if not (self._A.ndim == 2\n",
+      "\u001b[0;31mTypeError\u001b[0m: Image data cannot be converted to float"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2160x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# flag_save to 0 to avoid overwritting the existing tar.gz files\n",
-    "d1.correct_xml(flag_plots = 1, flag_parallel = 0, flag_save_figs = 1,\n",
+    "d1.correct_xml(flag_plots = 1, flag_parallel = 0, flag_save_figs = 0,\n",
     "                    pages = 'all', suffix_xml = '_data', name_outxml = '02_extractedxml',\n",
     "                    name_outcorrxml = '04_correctedxml', flag_save = 0)\n",
-    "print(d1.name_xml_corr, len(d1.XML_main))"
+    "print(d1.name_xml_corr, len(d1.XML_main_corr))"
    ]
   },
   {
diff --git a/src/python/def_classes.py b/src/python/def_classes.py
index ba30e380767cdca52ddcbcf21f4aecf2ea829a8b..9b109b175a208340f4c49d53053cd464ed2a64a1 100644
--- a/src/python/def_classes.py
+++ b/src/python/def_classes.py
@@ -1,652 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Fri Sep 28 13:31:06 2018
-
-@author: luissalamanca
-"""
-
-import sys, os
-
-from colour import Color
-import matplotlib.image as mpimg
-from mpl_toolkits.mplot3d import Axes3D
-import matplotlib.pyplot as plt
-import numpy as np
-import xml.etree.ElementTree as ET
-import copy
-import time 
-import tarfile
-import pickle
-
-from pdf2image import convert_from_path, convert_from_bytes
-
-import utils_proc
-import plot_tools
-import preproc_docs
-
-
-
-
-
-# Definition of classes and methods associated
-
-class Document:
-    
-    limit_year = 1950
-    flag_end_run = 1
-    name_inpdf = '00_rawpdfs'
-    name_inmeta = '01_rawmeta'
-    
-    def __init__(self, input_file, folder_database):
-        self.year = int(input_file.split('/')[-2])
-        self.id_doc = input_file.split('/')[-1].split('.')[0]
-        self.input_file = input_file
-        _, self.name_file = os.path.split(input_file)
-        self.path_file = folder_database + str(self.year) + '/'
-        self.name_wo_ext = os.path.splitext(self.name_file)[0]
-        self.folder_database = folder_database
-        self._meta_ext()
-        
-    def _meta_ext(self):
-    # Both for the correction and the extraction of the metadata information
-        name_file = str(self.year) + '/' + self.id_doc + '.xml'
-        name_file_db = str(self.year) + '/' + self.id_doc + '.db'
-        name_tar = self.folder_database + str(self.year) + '/' + self.name_inmeta + '.tar.gz'
-        self.name_meta = [name_tar, name_file, name_file_db]        
-    
-    def meta_correct(self, name_outmeta = '03_correctedmeta'):
-        utils_proc.tar_extractfile(self.name_meta[1], self.folder_database, name_file = self.name_inmeta)
-        utils_proc.tar_extractfile(self.name_meta[2], self.folder_database, name_file = self.name_inmeta)
-        name_meta_corr = utils_proc.correct_metadata(self.year, self.id_doc, self.flag_end_run)
-        name_tar = utils_proc.addto_tar(name_meta_corr, self.folder_database, name_file = name_outmeta)
-        self.name_outmeta = name_outmeta
-        command = 'rm -rf ./' + str(self.year)
-        #print(command)
-        utils_proc.call_with_out(command)
-    
-    def pdf2imgobj(self, resolution = 100):
-        
-        self.resolution = resolution
-        utils_proc.tar_extractfile(self.input_file, self.folder_database, name_file = self.name_inpdf)
-        self.imgobj = convert_from_path(self.input_file, dpi = resolution)
-        command = 'rm -rf ./' + str(self.year)     
-        utils_proc.call_with_out(command)
-
-    def _get_pages(self, pages = 'all'):
-        if 'imgobj' not in self.__dict__.keys():
-            self.pdf2imgobj()
-        if pages == 'all':
-            self.n_pages = np.arange(len(self.imgobj))
-        elif isinstance(pages,str):
-            self.n_pages = np.array(pages.split(',')).astype(np.uint32)
-        else:
-            self.n_pages = np.array(pages)  
-
-    def pdf2xml(self, pages = 'all', suffix_xml = '_data', flag_save = 1,
-                name_outxml = '02_extractedxml'):
-        # To extract the embedded text of the pdf into an xml file
-        if 'imgobj' not in self.__dict__.keys():
-            self.pdf2imgobj()
-        self._get_pages(pages = pages)
-        
-        utils_proc.tar_extractfile(self.input_file, self.folder_database, name_file = self.name_inpdf)
-        name_xml = utils_proc.pdf2xml(self.input_file, page_n = self.n_pages + 1, suffix_str = suffix_xml,
-                                      flag_end = self.flag_end_run)
-        if flag_save:
-            name_tar = utils_proc.addto_tar(name_xml, self.folder_database, name_file = name_outxml)
-        else:
-            print('Not saving to tar')
-            name_tar = self.folder_database + '/' + str(self.year) + '/' + name_outxml + '.tar.gz'
-            
-        command = 'rm -rf ./' + str(self.year)
-        #print(command)
-        utils_proc.call_with_out(command)
-        self.name_xml = [name_tar, name_xml]
-        h_xml = utils_proc.get_handlerfile(self.name_xml[1], self.folder_database, name_file = name_outxml)
-        self.name_outxml = name_outxml
-        XML_tree = ET.parse(h_xml)
-        self.XML_main = XML_tree.getroot()
-        self.n_pages = np.arange(len(self.XML_main))
-        
-        
-    def _draw_textbl(self, imarray = np.array([]), XML_root = None, XML_main = None, 
-                    ind_page = 0, textb_textl = 1):        
-        # The page refers here to the page of the imgobj, which might not correspond
-        # to the one of the xml. For that reason we use n_pages to obtain the index
-        # for the xml
-        # textb_textl =  1 for textboxes, and 2 for textlines
-        if (XML_root == None) and (XML_main == None):
-            return print('Not possible! - You need to provide a valid XML\n')
-        if np.sum(imarray.shape) == 0:
-            if 'imgobj' not in self.__dict__.keys():
-                imarray = np.array(self.imgobj[ind_page])
-            else:
-                return print('Not possible! - You need to convert first the pdf to image\n')
-        
-        if XML_root == None:
-            XML_root = ET.Element('pages')
-            ind_abs = np.argwhere(self.n_pages == ind_page)
-            XML_root.append(XML_main[ind_abs])
-        
-        bbox_page = np.array(XML_root[0].attrib['bbox'].split(',')).astype(np.float64)
-        
-        imarray_textb = np.copy(imarray)
-        
-        if textb_textl == 1:
-            coord_textboxes = np.array([]).reshape((4,0))
-            for ind_el in range(0, len(XML_root[0])):
-                if XML_root[0][ind_el].tag == 'textbox':
-                    coord_textbox_aux = np.array(XML_root[0][ind_el].attrib['bbox'].split(',')).astype(np.float64)
-                    coord_textboxes = np.concatenate((coord_textboxes, np.array(coord_textbox_aux).reshape((4,1))), axis = 1)
-                    imarray_textb = plot_tools.highlight_text(imarray_textb, coord_textbox_aux, 
-                                                                      bbox_page, color_vec = 'blue', alpha = True, 
-                                                                      filled = False, thick_line = 6) 
-            return imarray_textb, coord_textboxes
-        elif textb_textl == 2:   
-            imarray_textl = np.copy(imarray)
-            coord_textline = np.array([]).reshape((4,0))
-            all_font_sizes = np.array([])  
-            for ind_el in range(0, len(XML_root[0])):
-                for ind_line in range(0, len(XML_root[0][ind_el])):
-                    if XML_root[0][ind_el][ind_line].tag == 'textline':
-                        coord_textline_aux = np.array(XML_root[0][ind_el][ind_line].attrib['bbox'].split(',')).astype(np.float64)
-                        if len(XML_root[0][ind_el][ind_line]):
-                            all_font_sizes = np.concatenate((all_font_sizes, 
-                                                             np.array([XML_root[0][ind_el][ind_line][0].attrib['size']]).astype(np.float64)))
-                        coord_textline = np.concatenate((coord_textline, np.array(coord_textline_aux).reshape((4,1))), axis = 1)
-                        imarray_textl = plot_tools.highlight_text(imarray_textl, coord_textline_aux, bbox_page, 
-                                                       color_vec = 'red', alpha = True, filled = False, thick_line = 6)  
-                        
-            all_font_sizes, counts_all_font_sizes = np.unique(all_font_sizes, return_counts=True)        
-            info_font_sizes = np.concatenate((all_font_sizes.reshape((1,all_font_sizes.shape[0])),
-                                              counts_all_font_sizes.reshape((1,all_font_sizes.shape[0])).astype(np.float64)))                        
-            
-            return imarray_textb, coord_textline, all_font_sizes, info_font_sizes        
-    
-    def correct_xml(self, flag_plots = 1, flag_parallel = 0, flag_save_figs = 1,
-                    pages = 'all', suffix_xml = '_data', name_outxml = '02_extractedxml',
-                    name_outcorrxml = '04_correctedxml', flag_save = 1):
-        
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml
-        
-        start_time = time.time()
-        if 'imgobj' not in self.__dict__.keys():
-            self.pdf2imgobj()
-            
-        if 'XML_main' not in self.__dict__.keys():
-            name_tar = self.folder_database + '/' + str(self.year) + '/' + self.name_outxml + '.tar.gz'
-            if os.path.isfile(name_tar):
-                name_xml = './' + str(self.year) + '/' + str(self.id_doc) + suffix_xml + '.xml'
-                if name_xml in utils_proc.get_list(self.year, self.folder_database, self.name_outxml)[0]:
-                    h_xml = utils_proc.get_handlerfile(name_xml, self.folder_database, self.name_outxml)
-                    XML_tree = ET.parse(h_xml)
-                    self.XML_main = XML_tree.getroot()
-            else:
-                # TODO if already exists 02_extractedxml
-                self.pdf2xml(pages = pages, suffix_xml = suffix_xml)
-        
-        self._get_pages(pages = pages)
-        flag_central = 1
-        if self.year > self.limit_year:
-            flag_central = 0
-        flag_2col = 1
-        
-        XML_new = ET.Element('pages')
-                
-        for ind_abs, ind_page in enumerate(self.n_pages): 
-            
-            XML_root = ET.Element('pages')
-            #print(ind_abs,len(self.XML_main))
-            XML_root.append(self.XML_main[ind_abs])
-            imarray = np.array(self.imgobj[ind_page])
-        
-            if XML_root[0][0].tag == 'textbox':
-                bbox_page = np.array(XML_root[0].attrib['bbox'].split(',')).astype(np.float64)
-                dim_img = imarray.shape[:2]
-                _, rescale_factor = plot_tools.adapt_coordtoimg(imarray, bbox_page, bbox_page)
-            
-                # Image with textboxes highlighted
-                imarray_textblock, coord_textboxes = self._draw_textbl(imarray = imarray, XML_root = XML_root)
-    
-                # Image with textlines highlighted, BUT also, array with all textlines 
-                # coordinates, and the fontsizes, required for later
-                _, coord_textline, all_font_sizes, info_font_sizes = self._draw_textbl(imarray = imarray, XML_root = XML_root,
-                                                                           textb_textl = 2)                
-                
-                #####
-                # Central vertical line and horizontal lines, through Hough transform
-                coord_vert_def, coord_horz = preproc_docs.find_mainHorandCentral_Hough(np.copy(imarray), coord_textline, bbox_page, 
-                                                                          flag_2col, flag_central)                    
-                                        
-                #####
-                # Obtain lateral margins
-                margins = preproc_docs.lateral_margins(imarray, bbox_page, coord_vert_def.astype(np.uint32), 
-                                               coord_horz.astype(np.uint32))
-                        
-                # Top and bottom line
-                ind_limits = preproc_docs.bottomtop_margins(imarray, bbox_page, coord_vert_def.astype(np.uint32), 
-                                               coord_horz.astype(np.uint32))
-                                                        
-                #####
-                # Label the textboxes based on a set of simple rules that make use of 
-                # the margins and the fontsizes
-                label_textlines, list_allcoords_textlines, relative_ref_textline, all_heights, vec_labels_textline = \
-                    preproc_docs.label_textblocks(np.copy(imarray), XML_root[0], bbox_page, margins, coord_vert_def, info_font_sizes) # info_font_sizes_est
-                                            
-                #####
-                # Order the textlines, taken all them together, in order to later merge
-                # in a single textbox textlines that so far form different textboxes
-                set_of_blocks, centrall_ord = preproc_docs.order_textl(rescale_factor, coord_vert_def, coord_horz, 
-                                                          list_allcoords_textlines, margins)
-                
-                # Given the ordered textlines, group them in new textboxes, creating a 
-                # XML, This uses some criteria of distance between paragraphs
-                XML_enrich = preproc_docs.group_textl_create_xml(XML_root, set_of_blocks, relative_ref_textline, vec_labels_textline, 
-                                                    rescale_factor, centrall_ord, ind_page, dim_img)
-                
-                # Append to the new XML
-                XML_new.append(XML_enrich[0])
-                
-                
-                if flag_plots:
-                    im_met2 = plot_tools.plot_horzvertlines(imarray_textblock, coord_horz, coord_vert_def)
-                    im_met2 = plot_tools.plot_margins(im_met2, margins, ind_limits, gap_line = 1)
-                    im_met3 = plot_tools.plot_labelled_boxes(imarray,label_textlines, list_allcoords_textlines)
-                    im_met4 = plot_tools.plot_orderedtextl(imarray,set_of_blocks,list_allcoords_textlines.shape[1])    
-                    im_met5 = plot_tools.plot_correctedXML(imarray, XML_enrich, bbox_page)
-                    
-                    # Create figure with 4 subplots, for showing all results
-                    if flag_save_figs:
-                        path_output_img = self.path_file + '/previews'
-                        if flag_save_figs:
-                            if not os.path.exists(path_output_img):
-                                os.makedirs(path_output_img)
-                
-                    if flag_parallel:
-                        if flag_save_figs:
-                            name_pickle = path_output_img + '/' + self.name_wo_ext + '_page' + str(ind_page) + '.pkl'
-                            with open(name_pickle, 'wb') as f:  # Python 3: open(..., 'wb')
-                                pickle.dump([im_met2, im_met3, im_met4, im_met5], f)
-                    
-                    else:
-                        fig, axes = plt.subplots(1, 4, figsize=(30, 10))
-                        ax = axes.ravel()
-                        ax[0].axis('off')
-                        ax[0].imshow(im_met2) 
-                        ax[1].axis('off')
-                        ax[1].imshow(im_met3)
-                        ax[2].axis('off')
-                        ax[2].imshow(im_met4)        
-                        ax[3].axis('off')
-                        ax[3].imshow(im_met5)
-                        
-                        if flag_save_figs:
-                            format_fig = 'png'
-                            name_fig = path_output_img + '/' + self.name_wo_ext + '_page' + str(ind_page) + '.' + format_fig
-                            fig.savefig(name_fig, format = format_fig, dpi = 200)
-                            plt.close(fig)
-                
-        name_xml_prev = str(self.year) + '/' + self.name_wo_ext + suffix_xml + 'corrprev.xml'  
-        
-        tree = ET.ElementTree(XML_new)
-        self.XML_main_corr = XML_new
-        if not os.path.exists('./' + str(self.year)):
-            os.makedirs('./' + str(self.year))
-        tree.write(name_xml_prev, encoding = 'utf-8')
-        XML_new = preproc_docs.get_text_onefile(self.XML_main_corr)
-        name_xml = str(self.year) + '/' + self.name_wo_ext + suffix_xml + 'corr.xml' 
-        tree = ET.ElementTree(XML_new)
-        tree.write(name_xml, encoding = 'utf-8')
-        
-        if flag_save:
-            name_tar = utils_proc.addto_tar(name_xml, self.folder_database, name_file = name_outcorrxml)
-        else:
-            print('Not saving to tar')
-            name_tar = self.folder_database + '/' + str(self.year) + '/' + name_outcorrxml + '.tar.gz'        
-        
-        self.name_outcorrxml = name_outcorrxml
-        self.name_xml_corr = [name_tar, name_xml]
-        command = 'rm -rf ./' + str(self.year)
-        #print(command)
-        utils_proc.call_with_out(command)        
-        
-        print("End of file %s - %s seconds -" % (self.input_file, (time.time() - start_time)))  
-
-        #XML_tree = ET.parse(name_xml)
-        #self.XML_main = XML_tree.getroot()
-    
-    def _plot_generic_open(self, ind_page, suffix_xml, level_proc = 0,
-                           name_outxml = '02_extractedxml'):
-        # ind_page has to be a scalar
-        
-        if 'imgobj' not in self.__dict__.keys():
-            self.pdf2imgobj()
-        if 'XML_main' not in self.__dict__.keys():
-            name_tar = self.folder_database + '/' + str(self.year) + '/' + name_outxml + '.tar.gz'
-            if os.path.isfile(name_tar):
-                name_xml = './' + str(self.year) + '/' + str(self.id_doc) + suffix_xml + '.xml'
-                if name_xml in utils_proc.get_list(self.year, self.folder_database, name_outxml)[0]:
-                    h_xml = utils_proc.get_handlerfile(name_xml, self.folder_database, name_outxml)
-                    XML_tree = ET.parse(h_xml)
-                    self.XML_main = XML_tree.getroot()
-            else:
-                self.pdf2xml(pages = 'all', suffix_xml = suffix_xml, flag_save = 0)   
-            ind_abs = np.array([ind_page]).astype(int).reshape((-1,))  
-        else:
-            #print('Run this')
-            self._get_pages()
-            ind_abs = np.argwhere(self.n_pages == ind_page).reshape((-1,))
-
-        #print(ind_abs, type(ind_abs))
-        #print(self.XML_main, len(self.imgobj))
-        
-        if ind_page > (len(self.XML_main) - 1):
-            flag_error = 1
-            return 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, flag_error
-        
-        XML_root = ET.Element('pages')
-        XML_root.append(self.XML_main[ind_abs[0]])
-        imarray = np.array(self.imgobj[ind_page])
-        
-        bbox_page = np.array(XML_root[0].attrib['bbox'].split(',')).astype(np.float64)
-        dim_img = imarray.shape[:2]
-        
-        _, coord_textline, all_font_sizes, info_font_sizes = self._draw_textbl(imarray = imarray, XML_root = XML_root,
-                                                                               textb_textl = 2)        
-        margins = [] 
-        ind_limits = [] 
-        label_textlines = []
-        list_allcoords_textlines = []
-        set_of_blocks = []
-        XML_enrich = []
-        
-        if level_proc > 0:
-            coord_vert_def, coord_horz = preproc_docs.find_mainHorandCentral_Hough(np.copy(imarray), coord_textline, bbox_page, 
-                                                                                   flag_2col = 1)  
-            
-        if level_proc > 1:            
-            _, rescale_factor = preproc_docs.adapt_coordtoimg(imarray, bbox_page, bbox_page)
-           
-        if level_proc > 2:            
-            #####
-            # Obtain lateral margins
-            margins = preproc_docs.lateral_margins(imarray, bbox_page, coord_vert_def.astype(np.uint32), 
-                                           coord_horz.astype(np.uint32))                
-            
-        if level_proc > 3:            
-            # Top and bottom line
-            ind_limits = preproc_docs.bottomtop_margins(imarray, bbox_page, coord_vert_def.astype(np.uint32), 
-                                           coord_horz.astype(np.uint32))
-            
-        if level_proc > 4:            
-            label_textlines, list_allcoords_textlines, relative_ref_textline, all_heights, vec_labels_textline = \
-                preproc_docs.label_textblocks(np.copy(imarray), XML_root[0], bbox_page, margins, coord_vert_def, info_font_sizes)   
-            
-        if level_proc > 5:            
-            set_of_blocks, centrall_ord = preproc_docs.order_textl(rescale_factor, coord_vert_def, coord_horz, 
-                                                                   list_allcoords_textlines, margins)            
-            
-        if level_proc > 6:            
-            XML_enrich = preproc_docs.group_textl_create_xml(XML_root, set_of_blocks, relative_ref_textline, vec_labels_textline, 
-                                                rescale_factor, centrall_ord, ind_page, dim_img)        
-        
-        # The last value returned is only to say that there was not any error during the execution. Before, if there are too many pages, we
-        # send a 1 instead
-        flag_error = 0
-        return imarray, margins, ind_limits, label_textlines, list_allcoords_textlines, \
-            set_of_blocks, XML_enrich, bbox_page, XML_root, ind_abs, flag_error
-            
-    def _plot_obtainfromxml(self, ind_page, suffix_xml, name_outcorrxml = '04_correctedxml'):
-        
-        if 'imgobj' not in self.__dict__.keys():
-            self.pdf2imgobj()
-        if 'XML_main' not in self.__dict__.keys():            
-            name_tar = self.folder_database + '/' + str(self.year) + '/' + name_outcorrxml + '.tar.gz'
-            if os.path.isfile(name_tar):
-                name_xml = './' + str(self.year) + '/' + str(self.id_doc) + suffix_xml + 'corr.xml'
-                #print(name_xml)
-                if name_xml in utils_proc.get_list(self.year, self.folder_database, name_outcorrxml)[0]:    
-                    #print('Run this')
-                    h_xml = utils_proc.get_handlerfile(name_xml, self.folder_database, name_outcorrxml)
-                    XML_tree = ET.parse(h_xml)
-                    self.XML_main = XML_tree.getroot()
-                else:
-                    self.pdf2xml(pages = 'all', suffix_xml = suffix_xml, flag_save = 0)   
-            else:
-                self.pdf2xml(pages = 'all', suffix_xml = suffix_xml, flag_save = 0)   
-            ind_abs = np.array([ind_page]).astype(int).reshape((-1,))  
-        else:
-            #print('Run this')
-            self._get_pages()
-            ind_abs = np.argwhere(self.n_pages == ind_page).reshape((-1,))
-
-        #print(ind_abs, type(ind_abs))
-        #print(self.XML_main, len(self.imgobj))
-        
-        if ind_page > (len(self.XML_main) - 1):
-            flag_error = 1
-            return 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, flag_error
-        
-        XML_root = ET.Element('pages')
-        XML_root.append(self.XML_main[ind_abs[0]])
-        imarray = np.array(self.imgobj[ind_page])
-        
-        bbox_page = np.array(XML_root[0].attrib['bbox'].split(',')).astype(np.float64)
-        dim_img = imarray.shape[:2]        
-        
-        ######        
-        # For obtaining label_textlines, list_allcoords_textlines
-        coord_textline = np.array([]).reshape((4,0))
-        label_textlines = dict()
-        count = 0
-        count_l = 0
-        vec_textline_lines = list()
-        for ind_el in range(0, len(XML_root[0])):
-            for ind_line in range(0, len(XML_root[0][ind_el])):
-                if XML_root[0][ind_el][ind_line].tag == 'textline':
-                    coord_textline_aux = np.array(XML_root[0][ind_el][ind_line].attrib['bbox'].split(',')).astype(np.float64)
-                    coord_textline = np.concatenate((coord_textline, np.array(coord_textline_aux).reshape((4,1))), axis = 1)
-                    type_textl = XML_root[0][ind_el][ind_line].attrib['type']
-                    if XML_root[0][ind_el].attrib['type_textbox'] == 'line':
-                        vec_textline_lines.append(-1)
-                    else:
-                        vec_textline_lines.append(count_l)
-                        count_l += 1
-                    #print(type_textl)
-                    if type_textl in label_textlines.keys():
-                        aux_type = label_textlines[type_textl]
-                        aux_type = np.concatenate((aux_type, np.array([count]))).reshape((-1,))
-                        label_textlines[type_textl] = aux_type
-                    else:
-                        aux_type = np.array([count])
-                        label_textlines[type_textl] = aux_type
-                    count += 1
-        
-        coord_textline, rescale_factor = preproc_docs.adapt_coordtoimg(imarray, coord_textline, bbox_page)
-        
-        ##### 
-        # To obtain set_of_blocks. This variable simply contains the coordinates, and
-        # then a final row indicating the order (here are already ordered), and if it 
-        # is a line, which is indicated with a -1        
-        set_of_blocks_aux = np.concatenate((coord_textline, np.array(vec_textline_lines).reshape((1,-1))), axis = 0)
-        set_of_blocks = dict()
-        set_of_blocks[0] = set_of_blocks_aux
-        #print(set_of_blocks.shape)
-        
-        
-        
-        # The last is the flag_error
-        return imarray, label_textlines, coord_textline, set_of_blocks, XML_root, bbox_page, 0
-#                        imarray, _, _, _, list_allcoords_textlines, set_of_blocks, _, _, _, _, flag_error
-#                        imarray, _, _, _, _, _, XML_enrich, bbox_page, _, _, flag_error
-                        
-
-    def plot_orig_textb(self, range_pages = range(1), suffix_xml = '_data', 
-                         flag_plot = 1, flag_save_figs = 0, name_outxml = '02_extractedxml'):
-                
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml
-            
-        for ind_page in range_pages:
-            imarray, margins, ind_limits, _, _, \
-                _, _, _, XML_root, _, flag_error = self._plot_generic_open(ind_page, suffix_xml, level_proc = 0,
-                                                               name_outxml = self.name_outxml)
-            
-            if flag_error:
-                print(str(ind_page) + ': non existing page!')
-            else:
-                imarray_textblock, _ = self._draw_textbl(imarray = imarray, XML_root = XML_root)
-
-                self._plot_save(imarray_textblock, 'Textboxes original', 'OrigTextb', ind_page, self.path_file, 
-                                flag_plot, flag_save_figs)   
-
-    def plot_margins_doc(self, range_pages = range(1), suffix_xml = '_data', 
-                         flag_plot = 1, flag_save_figs = 0, name_outxml = '02_extractedxml'):
-        
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml
-        
-        for ind_page in range_pages:
-            imarray, margins, ind_limits, _, _, \
-                _, _, _, _, _, flag_error= self._plot_generic_open(ind_page, suffix_xml, level_proc = 4,
-                                                        name_outxml = self.name_outxml)
-
-            if flag_error:
-                print(str(ind_page) + ': non existing page!')
-            else:            
-                im_met = plot_tools.plot_margins(imarray, margins, ind_limits, gap_line = 1)
-
-                self._plot_save(im_met, 'Page margins', 'Margins', ind_page, self.path_file,
-                       flag_plot, flag_save_figs)             
-                
-    def plot_boxes_labels(self, range_pages = range(1), suffix_xml = '_data', 
-                         flag_plot = 1, flag_save_figs = 0, name_outxml = '02_extractedxml',
-                         name_outcorrxml = '04_correctedxml', flag_compute = 0):
-        
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml     
-        if 'name_outcorrxml' not in self.__dict__.keys():
-            self.name_outcorrxml = name_outcorrxml              
-        
-        name_tar = self.folder_database + '/' + str(self.year) + '/' + self.name_outcorrxml + '.tar.gz'
-        for ind_page in range_pages:
-            if flag_compute or not os.path.isfile(name_tar): 
-                imarray, _, _, label_textlines, list_allcoords_textlines, _, _, _, _, _, flag_error = \
-                    self._plot_generic_open(ind_page, suffix_xml, level_proc = 5,
-                                            name_outxml = self.name_outxml)
-                print(label_textlines,list_allcoords_textlines)
-            else:
-                imarray, label_textlines, list_allcoords_textlines, set_of_blocks, XML_root, bbox_page, flag_error \
-                    = self._plot_obtainfromxml(ind_page, suffix_xml, name_outcorrxml = name_outcorrxml)
-                
-                
-            if flag_error:
-                print(str(ind_page) + ': non existing page!')
-            else:             
-                im_met, groups, colors = plot_tools.plot_labelled_boxes(imarray,label_textlines, list_allcoords_textlines)
-                
-                in_coord = 0
-                coords = in_coord + np.array([0, 0, 10, 10])
-                inc_page = 20
-                flag_notinto = 1
-                for ind_g, i_g in enumerate(groups):
-                    if ind_g >= int(len(groups)/2) and flag_notinto:
-                        flag_notinto = 0
-                        coords[0] = in_coord
-                        coords[1] += int(im_met.shape[1]/1.5)
-                        coords[2] = in_coord + 10
-                        coords[3] += int(im_met.shape[1]/1.5)                    
-                    im_met = plot_tools.lines_box(im_met, coords, colors[ind_g], thick_line = 6)        
-                    coords[0] += inc_page
-                    coords[2] += inc_page
-
-                        
-                self._plot_save(im_met, 'Textboxes labelled', 'TextbLabel', ind_page, self.path_file,
-                       flag_plot, flag_save_figs)        
-                coords = in_coord + np.array([0, 0, 10, 10])
-                flag_notinto = 1
-                for ind_g, i_g in enumerate(groups):
-                    if ind_g >= int(len(groups)/2) and flag_notinto:
-                        flag_notinto = 0
-                        coords[0] = in_coord
-                        coords[1] += int(im_met.shape[1]/1.5)
-                        coords[2] = in_coord + 10
-                        coords[3] += int(im_met.shape[1]/1.5)                    
-                    plt.text(coords[1] + 10, coords[2], i_g, fontsize = 10, va = 'bottom', ha = 'left')      
-                    coords[0] += inc_page
-                    coords[2] += inc_page   
-
-                
-    def plot_textl_ordered(self, range_pages = range(1), suffix_xml = '_data', 
-                           flag_plot = 1, flag_save_figs = 0, name_outxml = '02_extractedxml',
-                           name_outcorrxml = '04_correctedxml', flag_compute = 0):
-        
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml
-        if 'name_outcorrxml' not in self.__dict__.keys():
-            self.name_outcorrxml = name_outcorrxml            
-        
-        name_tar = self.folder_database + '/' + str(self.year) + '/' + self.name_outcorrxml + '.tar.gz'
-        for ind_page in range_pages:
-            if flag_compute or not os.path.isfile(name_tar):            
-                imarray, _, _, _, list_allcoords_textlines, set_of_blocks, _, _, _, _, flag_error = \
-                    self._plot_generic_open(ind_page, suffix_xml, level_proc = 6,
-                                            name_outxml = self.name_outxml)
-            else: 
-                imarray, label_textlines, list_allcoords_textlines, set_of_blocks, XML_root, bbox_page, flag_error \
-                    = self._plot_obtainfromxml(ind_page, suffix_xml, name_outcorrxml = name_outcorrxml)                   
-                                    
-            #print(set_of_blocks)
-            if flag_error:
-                print(str(ind_page) + ': non existing page!')
-            else:            
-                im_met = plot_tools.plot_orderedtextl(imarray,set_of_blocks,list_allcoords_textlines.shape[1]) 
-
-                self._plot_save(im_met, 'Textlines ordered', 'TextlOrder', ind_page, self.path_file,
-                       flag_plot, flag_save_figs)            
-                
-    def plot_XMLcorrect(self, range_pages = range(1), suffix_xml = '_data', 
-                        flag_plot = 1, flag_save_figs = 0, name_outxml = '02_extractedxml',
-                        name_outcorrxml = '04_correctedxml', flag_compute = 0):
-        
-        if 'name_outxml' not in self.__dict__.keys():
-            self.name_outxml = name_outxml
-        if 'name_outcorrxml' not in self.__dict__.keys():
-            self.name_outcorrxml = name_outcorrxml              
-        
-        name_tar = self.folder_database + '/' + str(self.year) + '/' + self.name_outcorrxml + '.tar.gz'
-        for ind_page in range_pages:
-            if flag_compute or not os.path.isfile(name_tar):             
-                imarray, _, _, _, _, _, XML_enrich, bbox_page, _, _, flag_error = \
-                    self._plot_generic_open(ind_page, suffix_xml, level_proc = 7,
-                                            name_outxml = self.name_outxml)
-            else:                    
-                imarray, label_textlines, list_allcoords_textlines, set_of_blocks, XML_enrich, bbox_page, flag_error \
-                    = self._plot_obtainfromxml(ind_page, suffix_xml, name_outcorrxml = name_outcorrxml)                  
-            
-            if flag_error:
-                print(str(ind_page) + ': non existing page!')
-            else:            
-                im_met = plot_tools.plot_correctedXML(imarray, XML_enrich, bbox_page)
-
-                self._plot_save(im_met, 'XML corrected', 'XMLcorrect', ind_page, self.path_file,
-                       flag_plot, flag_save_figs)
-        
-    def _plot_save(self, im_met, str_title, str_name, ind_page, folder_save = '',
-                   flag_plot = 1, flag_save_figs = 0, dpi = 200):
-        if flag_plot:
-            fig, axes = plt.subplots(1, 1, figsize=(8, 10))
-            axes.axis('off')
-            axes.imshow(im_met) 
-            plt.title(str_title)
-        if flag_save_figs:
-            format_fig = 'png'
-            name_fig = (folder_save + '/' + str_name + '_' + str(self.id_doc) 
-                        + '_page' + str(ind_page) + '.' + format_fig)
-            fig.savefig(name_fig, format = format_fig, dpi = dpi)
-            plt.close(fig)         
-            
-        
-                           
\ No newline at end of file
+version https://git-lfs.github.com/spec/v1
+oid sha256:837af0a5149a5c556f6f7bf8055bda21a749021717e4844a4e9e7e369300bc88
+size 34205