1. image smoothed by a Gaussian kernel in a scale-space representation
2. threshold or canny edge detection filters
3. features extracting
4. path around the feature - feature descriptor or feature vector. - N-jets and local histograms
5. specific algoriths

• OpenCV C C++ Python
• Caffe C++ Python Matlab - быстрая на С++
• Torch7
• clarifai
• Google Vision API

usually numpy array of image data:

• CV_8U: 1-byte unsigned integer (unsigned char).
• CV_32S: 4-byte signed integer (int).
• CV_32F: 4-byte floating point (float).

Непрерывное отображение

• гомеоморфизмом - имеет непрерывное обратное

Homography - Проективное преобразование

• прямые в прямые
• Allow to manipulate n‐dim vectors in a n+1 dim space
• 2 degrees of freedom
• homogeneous image coordinates = (x,y,1) - column
• Converting from homogeneous image coordinates (x,y,1) = (x/w,y/w)
• Transformation = (x,y,1) * 3x3 matrix -> (x/w,y/w)

affine transformation

• preserves:
  • points
  • straight lines
  • planes
  • parallelism
• include: translation, scaling, homothety, similarity transformation, reflection, rotation, shear mapping, and compositions
• affine transformation matrix - последняя строка [001]
• projective transformation matrix

Types of image features:

Edges

Canny edge detector

Corners / interest points

point-like features, early algorithms first performed edge detection, and then analysed the edges to find rapid changes in direction (corners)

Blobs / regions of interest points

complementary description of image structures in terms of regions. Just like edge

Ridges

represents an axis of symmetry has an attribute of width associated with each ridge point - algorithmically harder to extract

• handwritten or printed text into machine-encoded text
• распознавание латинских символов в печатном тексте в настоящее время возможно, только если доступны чёткие изображения, такие, как сканированные печатные документы. Точность при такой постановке задачи превышает 99 %
• рукописного «печатного» и стандартного рукописного текста, а также печатных текстов других форматов (особенно с очень большим числом символов) в настоящее время являются предметом активных исследований

Berkeley Segmentation Data Set and Benchmarks 500 (BSDS500) https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/resources.html

• Tesseract VS Google OCR https://fuzzylabs.ai/blog/the-battle-of-the-ocr-engines/
• https://en.wikipedia.org/wiki/Outline_of_computer_vision

• Region of interest (ROI)
• color-space conversion
  • RGB - 24-bit - 8 bits, for red, green, and blue
  • HSV - hue, saturation, value. OpenCV uses HSV ranges between (0-180, 0-255, 0-255).
  • binary images - 0,1 or 0,255
  • gray image - single channels 8-bit image
• Morphological Transformations - performed on binary images
• Gradient filters or High-pass filters
  • Sobel
  • Scharr
  • Laplacian
• Thresholding filter - grayscale image -> If pixel value is greater than a threshold value, it is assigned one value (may be white), else it is assigned another value (may be black). -> grayscale or binary image AND retVal -
• bimodal image is an image whose histogram has two peaks
• Canny edge detection - argument: min and max values - Noise Reduction, Intensity Gradient
• Image Pyramids - Higher level (Low resolution)
  1. Gaussian Pyramid - higher level is formed by the contribution from 5 pixels with gaussian weights - rediced to one-fourth of original area MxN -> M/2,N/2 - cv.pyrDown() and cv.pyrUp()
  2. Laplacian Pyramids - images are like edge images only
• Contours - curve joining all the continuous points - for shape analysis and object detection and recognition.

де-факто, стандартом в области компьютерного зрения

• is written in C++ and its primary interface is in C++
• Python, Java and MATLAB/OCTAVE
• CUDA-based GPU and OpenCL-based GPU interfaces
• Windows, Linux, macOS, FreeBSD, NetBSD, OpenBSD
• Android, iOS, Maemo, BlackBerry 10

EAST EAST: An Efficient and Accurate Scene Text Detector.

• OpenCV 3.4.2 and OpenCV 4
• arbitrary orientations
• 720p images

3 ways to document recognation

• AKAZE + rectangles template
• search rectangle by text with gradients or threshold
• search text in areas with tesseract detected text

• BGR image - 3d
• grayscale image - 1d

img.shape = (height, width, channels) = (rows, cols, channels)
cv.resize(img, (width, height))

import numpy as np
import cv2 as cv

img = cv.imread('messi5.jpg')  # numpy.ndarray - type
px = img[100,100]   #[157 166 200] - Blue, Green, Red
img.item(10,10,2)   # red value of pixel
img.itemset((10,10,2),100)   # set red value of pixel
print( img.shape )  # (342, 548, 3)
print( img.size )   # 562248
print( img.dtype )  # uint8 or cv.CV_8U

b,g,r = cv.split(img) # Blue, Green, Red
b = img[:,:,0] # faster
img = cv.merge((b,g,r))

cv2.imshow('image',img) # show image in window
cv2.waitKey(0)          # wait for any key indefinitely
cv2.destroyAllWindows() # close window

from matplotlib import pyplot as plt
plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([])  # to hide tick values on X and Y axis
plt.show()

#color-space conversion
# HSV or HSB - тон (1-360), насыщенность(0-100)(0-серый), яркость(0-100)
hsv = cv.cvtColor(input_image,  cv.COLOR_BGR2HSV) # convert, cv.COLOR_BGR2GRAY
lower_blue = np.array([110,50,50])
upper_blue = np.array([130,255,255])
mask = cv.inRange(hsv, lower_blue, upper_blue) # Threshold the HSV image to get only blue colors
res = cv.bitwise_and(frame,frame, mask= mask) # original minus mask

bgr_green = np.uint8([[[0,255,0 ]]]) # BGR: Green
hsv_green = cv.cvtColor(green,cv.COLOR_BGR2HSV) # [[[ 60 255 255]]]

# THRESH_BINARY = maxval if pix > thresh else 0
ret,thresh1 = cv.threshold(src=img, thresh=127, maxval=255, type=cv.THRESH_BINARY)

• BGR order and its cv2.imshow() and cv2.imwrite() also expect images in BGR order.
• Other libraries, such as PIL/Pillow, scikit-image, matplotlib, pyvips store images in conventional RGB order in memory.

img = cv.imread(p, cv.IMREAD_COLOR)

[[ [250 250 250] … ] … ]

convert to RGB:

• RGBimage = cv2.cvtColor(BGRimage, cv2.COLOR_BGR2RGB)

https://chadrick-kwag.net/cv2-resize-interpolation-methods/

• INTER_NEAREST – a nearest-neighbor interpolation
• INTER_LINEAR – a bilinear interpolation (used by default)
• INTER_AREA – resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.
• INTER_CUBIC – a bicubic interpolation over 4×4 pixel neighborhood
• INTER_LANCZOS4 – a Lanczos interpolation over 8×8 pixel neighborhood

https://github.com/ulikoehler/UliEngineering https://github.com/ulikoehler/cv_algorithms

sudo apt-get install libopencv-dev python-opencv

img = cv.imread('messi5.jpg', flag) # as a multi-dimensional NumPy array BGR order

flags: https://docs.opencv.org/4.1.0/d6/d87/imgcodecs_8hpp.html

• cv.IMREAD_COLOR : transform to BGR colours. Any transparency of image will be neglected. It is the default flag.
• cv.IMREAD_GRAYSCALE = 0 : Loads image in grayscale mode
• cv.IMREAD_UNCHANGED : Loads image as such including alpha channel

cv2.imwrite('messigray.png', crop_box)

• pixel value - 0-255
• histogram - for grayscale image mostly - intensity distribution of an image - x - 0 to 255, у - number of pixels
• BIN - number of pixel values. группировка values - [256] - количество values в одном ящике
• RANGE : It is the range of intensity values you want to measure. Normally, it is [0,256], ie all intensity values.

cv.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]])

• mask : mask image. To find histogram of full image, it is given as "None".
• histSize : this represents our BIN count. Need to be given in square brackets. For full scale, we pass [256].
• ranges : this is our RANGE. Normally, it is [0,256].

BGR:

cv.calcHist(images=[img], chnnels=[i], mask=None, histSize=[256], ranges=[0, 256])

HSV:

hist = cv.calcHist(images=[hue], chnnels=[0], mask=None, histSize=[2-180], ranges=[0, 180])

• histSize - bins

from matplotlib import pyplot as plt
import cv2 as cv
img = cv.imread('/home/u/sources/tasks-for-job/task_for_zennolab/train.png', 0)
#img = cv.imread('/home/u/download.jpeg', 0)
hist = cv.calcHist([img],[0],None,[256],[0,256])
plt.subplot(121)
plt.imshow(img)
plt.subplot(122)
plt.plot(hist)
plt.xlim([0,256])
plt.show()

cv2.normalize(source_array, destination_array, alpha, beta, normType )

source_array

It is the input image you want to normalize.

destination_array

The name for the output image after normalization.

alpha

norm value to normalize to or the lower range boundary in case of the range normalization.

beta

upper range boundary in case of the range normalization; it is not used for the norm normalization.

normType

Type for the normalization of the image.

• cv2.NORM_MINMAX

Don't change:

norm = np.zeros((800,800)) #  blank image
norm_image = cv2.normalize(img,norm,alpha=0,beta=255,cv2.NORM_MINMAX) # img -BGR

To convert each pixel to 0-1 range:

img_normalized = cv2.normalize(img, None, 0, 1.0, cv2.NORM_MINMAX)

cv.findContrours

contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) # finding white object from black background

• input - binary image - 0 - BLACK, 255 - WHITE
• cv.RETR_TREE - contour retrieval mode -
  • https://docs.opencv.org/4.1.0/d9/d8b/tutorial_py_contours_hierarchy.html
  • list of contours
  • [8, 0, -1, -1] -0: 8 next in same hoerarchy, 0 previous in same hoerarchy, -1 no child, no parent
  • [-1, -1, 3, 1] -1: -1 no next, -1 no previous, 3 is a child, 1 is a parent
• cv.CHAIN_APPROX_SIMPLE - contour approximation method - all the boundary points are stored, or several
  • cv.CHAIN_APPROX_SIMPLE - removes all redundant points and compresses the contour, thereby saving memory
• contours - list of all the contours. Each individual contour is a Numpy array of (x,y) coordinates
• example for contours parameter: [[[ 22 124] [ 57 160]]]

contours = [numpy.array([[1,1],[10,50],[50,50]], dtype=numpy.int32) , numpy.array([[99,99],[99,60],[60,99]], dtype=numpy.int32)]

cv.drawContours - around or inside of contour

cv.drawContours(img, [contours[0]], 0, (255), -1)

• 0 - draw first contour of [contours[0]] (-1 - all)
• (255) - colour to draw
• -1 - thinkness - if -1 - draw inside contour

to rectangle:

x,y,w,h = cv.boundingRect(cnt)

convolving (each element of the image is added to its local neighbors, weighted by the kernel) the image through a low pass filter kernel.

Blur (Averaging) - cv.blur

pixel replecead by the average of all the pixels in the kernel area

cv.GaussianBlur

Dilation

make white lines FAT

Erosion

make THIN

https://docs.opencv.org/3.4/db/df6/tutorial_erosion_dilatation.html

Good features: corners, …

• Feature Detection - create
• Feature Description - describe the region around the feature so that it can find it in other images
• Feature matching

express pixel intensity changes

• https://www.pyimagesearch.com/2014/01/22/clever-girl-a-guide-to-utilizing-color-histograms-for-computer-vision-and-image-search-engines/

• it does not work for rotated or scaled versions of the template
• inefficient when calculating the pattern correlation image for medium to large images

Binary-string descriptors: ORB, BRIEF, BRISK, FREAK, AKAZE, etc.

• use FLANN + LSH index or Brute Force + Hamming distance.

Floating-point descriptors: SIFT, SURF, GLOH, etc.

• Hamming distance as opposed to Euclidean distance used for floating-point descriptors.

• https://docs.opencv.org/4.8.0/de/da9/tutorial_template_matching.html
• https://docs.opencv.org/4.x/d4/dc6/tutorial_py_template_matching.html

image, rho, theta, threshold, lines=None, srn=None, stn=None, min_theta=None, max_theta=None

• image-edges: Output of the edge detector.
• rho: Distance resolution of the accumulator in pixels. = 1
• theta: Angle resolution of the accumulator in radians. = np.pi/180
• threshold: Accumulator threshold parameter. Only those lines are returned that get enough votes
• lines: A vector to store the coordinates of the start and end of the line. Each line is represented by a 2 or 3 element vector
• stn, srn: For the multi-scale Hough transform,
• min_theta: For standard and multi-scale Hough transform, minimum angle to check for lines. Must fall between 0 and max_theta.
• max_theta: For standard and multi-scale Hough transform, maximum angle to check for lines. Must fall between min_theta and CV_PI

threshold: The minimum number of intersecting points to detect a line.

img = cv.imread('/home/u/download.jpeg', 0)
edges = cv.Canny(img,50,150,apertureSize = 3)
#lines = cv.HoughLines(edges,1,np.pi/180,200)
lines = cv.HoughLinesP(edges,1,np.pi/180,100,minLineLength=100,maxLineGap=10)

for line in lines:
    x1,y1,x2,y2 = line[0]
    cv.line(img,(x1,y1),(x2,y2),(0,255,0),2)

plt.imshow(img)
plt.show()



gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray,50,150, apertureSize = 3)
print(edges.shape)
lines = cv.HoughLines(edges,1,np.pi/180,120)
print(lines)
for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv.line(img,(x1,y1),(x2,y2),(0,0,255),2)

#plt.imshow(edges)
plt.imshow(img)
plt.show()

• https://www.learnopencv.com/image-recognition-and-object-detection-part1/
• https://habr.com/ru/post/208090/
• https://www.pyimagesearch.com/2014/11/10/histogram-oriented-gradients-object-detection/

History:

• 2001 face detection Viola and Jones algorithm
• 2005 Histograms of Oriented Gradients (HOG)
• 2012 ImageNet

Methods:

1. Preprocessing
   • cropped
   • resizing
   • RGB to gray
   • gamma correction

2. Filtering OR Feature Extraction

   • Бинаризация по порогу (threshold)
   • Haar-like features introduced by Viola and Jones
   • Histograms of Oriented Gradients (HOG)
   • Scale-Invariant Feature Transform ( SIFT )
   • Speeded Up Robust Feature ( SURF )
   • Фурье, ФНЧ, ФВЧ
   • вейвлет-анализом называется поиск произвольного паттерна на изображении при помощи свёртки с моделью этого паттерна
   • Edge detector (Мат аппарат - контурный анализ)
     • Оператор Кэнни
     • Оператор Собеля
     • Оператор Лапласа
     • Оператор Прюитт
     • Оператор Робертса
   • Особые точки https://en.wikipedia.org/wiki/Feature_detection_(computer_vision)
     • Первый класс. Особые точки, являющиеся стабильными на протяжении секунд.
       • локальные максимумы изображения
       • углы на изображении (лучший из детекторов, пожалуй, детектор Хариса)
       • точки в которых достигается максимумы дисперсии
       • определённые градиенты
     • Второй класс. Особые точки, являющиеся стабильными при смене освещения и небольших движениях объекта.
       • некоторые вейвлеты, как база для точек
       • точки, найденные методом HOG
     • Третий класс. Стабильные точки.
       • SURF, SIFT - К сожалению эти методы запатентованы. Хотя, в России патентовать алгоритмы низя, так что для внутреннего рынка пользуйтесь.
       • KAZE and A-KAZE - no patent
   • Mathematical morphology

   of the shape and aim to find out its location and orientation in the image

3. Trainging Classificator
4. Faster R-CNN has two networks: region proposal network (RPN) for generating region proposals and a network using these proposals to detect objects.

HOG Histograms of Oriented Gradients метод гистограмм направленных градиентов

• based on the idea: that local object appearance can be effectively described by the distribution ( histogram ) of edge directions ( oriented gradients )
• 64 x 128 x 3 = 24,576 which is reduced to 3780

Mathematical morphology

• это простейшие операции наращивания и эрозии бинарных изображений

Template matchong and Object detection

• Hough transform: cv.HoughCircles, cv.HoughLines, cv.HoughLinesP
• Generalized Hough Transform - cv::GeneralizedHoughBallard, cv::GeneralizedHoughGuil. - we have knowledge of the shape and aim to find out its location and orientation in the image.
• https://habr.com/ru/post/113626/
• http://wiki.technicalvision.ru/index.php/%D0%9C%D0%BE%D1%80%D1%84%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8_%D0%BD%D0%B0_%D0%B1%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F%D1%85

• cv::GeneralizedHoughBallard - find exactly
• cv::GeneralizedHoughGuil - very slow, find same, not exactly

https://docs.opencv.org/4.8.0/da/ddc/tutorial_generalized_hough_ballard_guil.html

disabled since OpenCV 4.0!!! via DNN provides much better results

Haar features. paper, "Rapid Object Detection using a Boosted Cascade of Simple Features" in 2001

require usage: media-libs/opencv gtk3 opencvapps

convert to ONNX ( torch.onnx.export) -> .onnx -> cv.dnn.readNetFromONNX. links

• https://docs.opencv.org/4.8.0/d2/d58/tutorial_table_of_content_dnn.html
• https://docs.opencv.org/4.x/dc/d70/pytorch_cls_tutorial_dnn_conversion.html

• types of motions
• Homography https://www.learnopencv.com/image-alignment-feature-based-using-opencv-c-python/

Small text:

• minAreaRect https://www.pyimagesearch.com/2017/02/20/text-skew-correction-opencv-python/

Homography require template and doc_type

• https://www.learnopencv.com/image-alignment-feature-based-using-opencv-c-python/

steps:

• Extract features: Commecricla(SURF or SIFT), Free(KAZΑ)
• Match the features (FLANN or BruteForce…) and filter the matchings
• Find the geometrical transformation (RANSAC or LMeds…)

https://docs.opencv.org/master/d9/d61/tutorial_py_morphological_ops.html

• Erosion - уменьшить толщину как Convolution
• Dilation - утолщить
• Opening - cv.morphologyEx(img, cv.MORPH_OPEN, kernel) - erosion followed by dilation
  • remove noise outside
  • find out horizontal or vertical lines
• Clothing - cv.morphologyEx(img, cv.MORPH_CLOSE, kernel) - Dilation followed by Erosion
  • to remove small points inside large one
  • to group contours
• Morphological Gradient
• Top Hat
• Black Hat

1. Pros:
   • легковесности решения
   • легче перенос на другие платформы
   • упрощает процедуру создания гибридных алгоритмов
   • загрузка и запуск моделья - Caffe, TensorFlow или Torch - Поддерживаются все основные слои
2. Cons:
   • только возможность выполнения прямого прохода (forward pass)
   • преобразует модели из различных фреймворков в свое внутреннее представление, возникают вопросы сохранения качества

error: (-215:Assertion failed) npoints > 0 in function 'drawContours'

один порт, один Redis, несколько workers

git+https://github.com/GeorgiyDemo/cv_algorithms.git - OpenCV algorithms are are not available

• OpenCV 3
• ?

git+https://github.com/GeorgiyDemo/UliEngineering.git

• Electronics Engineering ?

redis==3.1.0

• Резидентная NoSQL СУБД

opencv-python==3.4.5.20 imutils==0.5.2

• displaying Matplotlib images easier with OpenCV
• image processing - translation, rotation, resizing, skeletonization

pytesseract==0.2.6 requests==2.21.0 pdf2image==1.4.0 PyYAML==3.13 networkx==2.2 scipy==1.2.0 toolz==0.9.0 rq==0.13.0 sentry-sdk==0.7.10

• debian testing
• apt-get install tesseract-ocr-rus
• /usr/share/tesseract-ocr/4.00/tessdata/rus.traineddata

• MainOpenCV.py:323 {'1':('1', OUTPUT_OBJ)}
• OKUD.py OKUD_0710001 class init -> 240 -> 217 -> 111
• MatrixToJson.py:104 ToJSON class - property JSON -> 272
  • SmallTableProcessing() - 'info': self.small_table в основном self.JSON
  • суммируем в Processing() or FiveDocProcessing()(для продолжения листа)
  • self.JSON = {'qc': 2, 'document_type': '1', "period": [matrix]}
  • данные основной таблицы matrix:
    • столбцы по датам {'31122016': {'hindex': 5, 'codes': []}}
      • hindex - номер столбца от левого края, начиная с какого - хз
      • codes -

JSON - { "status": "ready", "pages": [OUTPUT_OBJ, OUTPUT_OBJ ….] }

where OUTPUT_OBJ = {"qc":0, } л

Успешные ответы

• {"status": "ready", "pages": "…"} - первый ответ get

rq.worker:opencv-tasks: file (7120f9a5-7fde-41ba-96f4-ef1da72c5c1d)

Traceback (most recent call last): return method_number_list[method_number](obj).OUTPUT_OBJ File "/code/parsers/multiparser.py", line 22, in passport_and_drivelicense aop = passport_main_page(img_cropped) File "/code/parsers/passport.py", line 162, in passport_main_page res_i = fio_checker.double_query_name(anonymous_return.OUTPUT_OBJ['MRZ']['mrz_i'], i_pass) File "/code/groonga.py", line 248, in double_query_name return FIOChecker._get_appropriate(items1, word1) File "/code/groonga.py", line 236, in _double_query equal = [x for x in items if x[2] = 4] # score File "/code/groonga.py", line 129, in <listcomp> ERROR:root:Uncatched exception in ParserClass return self._double_query(word1, word2, self.names_table) File "/code/groonga.py", line 129, in _get_appropriate equal = [x for x in items if x[2] = 4] # score KeyError: 2 File "/code/MainOpenCV.py", line 40, in parser_call

• Сумма результатов 35 + 3 + 0 + 35 +0 +9 = 82
• 82 / 10 =8, остаток деления 2
• 2

• 361753650

import numpy as np
a=np.array([3,6,1,7,5,3,6,5,0])
b=np.array([7,3,1,7,3,1,7,3,1])
np.sum(a*b)%10

• http://ukrainian-passport.com/blog/everything-you-have-to-know-about-the-russian-passport/
• consists of two signs and refers to the code assigned to the appropriate area (region) of the Russian Federation.
• indicates the year of passport issue
• passport serial number - six signs

• коэффициент Танимото https://grishaev.me/2012/10/05/1/
• https://habr.com/en/post/341148/

https://bestofphp.com/repo/Gregwar-Captcha-php-image-processing

speech recognition model

• https://github.com/openai/whisper
  • download models: https://github.com/openai/whisper/blob/main/whisper/__init__.py
• https://github.com/chussong/pocketsphinx

• Version 2 ~2013, also asked users to decipher text or match images if the analysis of cookies and canvas rendering suggested the page was being downloaded automatically.
  • behavioral analysis of the browser's interactions to predict whether the user was a human or a bot
• version 3, at the end of 2019, reCAPTCHA will never interrupt users and is intended to run automatically when users load pages or click buttons.

On May 26, 2012, Adam, C-P and Jeffball - accuracy rate of 99.1% analyse the audio version of reCAPTCHA

• after: the audio version was increased in length from 8 seconds to 30 seconds, and is much more difficult to understand, both for humans as well as bots.
• after: 60.95% and 59.4% respectively

https://habr.com/en/post/241145/ https://habr.com/en/post/241263/ cnn https://medium.com/swlh/captcha-recognition-44522c2fe9c

opencv 4.x new https://stackoverflow.com/questions/53906178/how-opencv-4-x-api-is-different-from-previous-version

install from source opencv https://docs.opencv.org/3.4.11/d2/de6/tutorial_py_setup_in_ubuntu.html

https://github.com/lincolnloop/python-qrcode

import qrcode img = qrcode.make('Some data here') img.save('path')

• handprinted text - characters are written separately, is not about “cursive handwriting”
• handwriting

• optical character recognition (OCR) for machine print
• optical mark reading (OMR) for check/mark sense boxes
• bar code recognition (BCR) for barcodes
• and intelligent character recognition (ICR) for hand print.
• MICR – Magnetic ink character recognition

recognizes different handwriting styles and fonts to intelligently interpret data on forms and physical documents

use of continuously improving algorithms to collect more information about the variances in hand-printed characters and more precisely identify them.

intelligent word recognition (IWR) focuses on reading a word in context rather than recognizing individual characters. is optimized for processing real-world documents that contain mostly free-form, hard-to-recognize data fields that are inherently unsuitable for ICR. (evolved version of ICR)

Robotic Process Automation (RPA) is a technique that automates the configuration of Intelligent character recognition software and ensures that operations are completed without errors.

hard copy data is filled out by humans and then "captured" from their respective fields

• information entered into data fields
• map of the document, detailing where the data fields are located within the form or document

steps

1. Assessment of the form structure - to analyze the type of form. Types of forms:

   • Fixed forms - data always found
   • Semi-structured (or unstructured) form - the location of the data and fields holding the data vary from

   document to document. Ex: letters, contracts, and invoices.

• abby