HYTOS

###############################################################################

# Set default behavior to automatically normalize line endings.

###############################################################################

* text=auto

###############################################################################

# Set default behavior for command prompt diff.

#

# This is need for earlier builds of msysgit that does not have it on by

# default for csharp files.

# Note: This is only used by command line

###############################################################################

#*.cs     diff=csharp

###############################################################################

# Set the merge driver for project and solution files

#

# Merging from the command prompt will add diff markers to the files if there

# are conflicts (Merging from VS is not affected by the settings below, in VS

# the diff markers are never inserted). Diff markers may cause the following 

# file extensions to fail to load in VS. An alternative would be to treat

# these files as binary and thus will always conflict and require user

# intervention with every merge. To do so, just uncomment the entries below

###############################################################################

#*.sln       merge=binary

#*.csproj    merge=binary

#*.vbproj    merge=binary

#*.vcxproj   merge=binary

#*.vcproj    merge=binary

#*.dbproj    merge=binary

#*.fsproj    merge=binary

#*.lsproj    merge=binary

#*.wixproj   merge=binary

#*.modelproj merge=binary

#*.sqlproj   merge=binary

#*.wwaproj   merge=binary

###############################################################################

# behavior for image files

#

# image files are treated as binary by default.

###############################################################################

#*.jpg   binary

#*.png   binary

#*.gif   binary

###############################################################################

# diff behavior for common document formats

# 

# Convert binary document formats to text before diffing them. This feature

# is only available from the command line. Turn it on by uncommenting the 

# entries below.

###############################################################################

#*.doc   diff=astextplain

#*.DOC   diff=astextplain

#*.docx  diff=astextplain

#*.DOCX  diff=astextplain

#*.dot   diff=astextplain

#*.DOT   diff=astextplain

#*.pdf   diff=astextplain

#*.PDF   diff=astextplain

#*.rtf   diff=astextplain

#*.RTF   diff=astextplain

## Ignore Visual Studio temporary files, build results, and

## files generated by popular Visual Studio add-ons.

# User-specific files

*.suo

*.user

*.userosscache

*.sln.docstates

# User-specific files (MonoDevelop/Xamarin Studio)

*.userprefs

# Build results

[Dd]ebug/

[Dd]ebugPublic/

[Rr]elease/

[Rr]eleases/

x64/

x86/

bld/

[Bb]in/

[Oo]bj/

[Ll]og/

# Visual Studio 2015 cache/options directory

.vs/

# Uncomment if you have tasks that create the project's static files in wwwroot

#wwwroot/

# MSTest test Results

[Tt]est[Rr]esult*/

[Bb]uild[Ll]og.*

# NUNIT

*.VisualState.xml

TestResult.xml

# Build Results of an ATL Project

[Dd]ebugPS/

[Rr]eleasePS/

dlldata.c

# DNX

project.lock.json

project.fragment.lock.json

artifacts/

*_i.c

*_p.c

*_i.h

*.ilk

*.meta

*.obj

*.pch

*.pdb

*.pgc

*.pgd

*.rsp

*.sbr

*.tlb

*.tli

*.tlh

*.tmp

*.tmp_proj

*.log

*.vspscc

*.vssscc

.builds

*.pidb

*.svclog

*.scc

# Chutzpah Test files

_Chutzpah*

# Visual C++ cache files

ipch/

*.aps

*.ncb

*.opendb

*.opensdf

*.sdf

*.cachefile

*.VC.db

*.VC.VC.opendb

# Visual Studio profiler

*.psess

*.vsp

*.vspx

*.sap

# TFS 2012 Local Workspace

$tf/

# Guidance Automation Toolkit

*.gpState

# ReSharper is a .NET coding add-in

_ReSharper*/

*.[Rr]e[Ss]harper

*.DotSettings.user

# JustCode is a .NET coding add-in

.JustCode

# TeamCity is a build add-in

_TeamCity*

# DotCover is a Code Coverage Tool

*.dotCover

# NCrunch

_NCrunch_*

.*crunch*.local.xml

nCrunchTemp_*

# MightyMoose

*.mm.*

AutoTest.Net/

# Web workbench (sass)

.sass-cache/

# Installshield output folder

[Ee]xpress/

# DocProject is a documentation generator add-in

DocProject/buildhelp/

DocProject/Help/*.HxT

DocProject/Help/*.HxC

DocProject/Help/*.hhc

DocProject/Help/*.hhk

DocProject/Help/*.hhp

DocProject/Help/Html2

DocProject/Help/html

# Click-Once directory

publish/

# Publish Web Output

*.[Pp]ublish.xml

*.azurePubxml

# TODO: Comment the next line if you want to checkin your web deploy settings

# but database connection strings (with potential passwords) will be unencrypted

#*.pubxml

*.publishproj

# Microsoft Azure Web App publish settings. Comment the next line if you want to

# checkin your Azure Web App publish settings, but sensitive information contained

# in these scripts will be unencrypted

PublishScripts/

# NuGet Packages

*.nupkg

# The packages folder can be ignored because of Package Restore

**/packages/*

# except build/, which is used as an MSBuild target.

!**/packages/build/

# Uncomment if necessary however generally it will be regenerated when needed

#!**/packages/repositories.config

# NuGet v3's project.json files produces more ignoreable files

*.nuget.props

*.nuget.targets

# Microsoft Azure Build Output

csx/

*.build.csdef

# Microsoft Azure Emulator

ecf/

rcf/

# Windows Store app package directories and files

AppPackages/

BundleArtifacts/

Package.StoreAssociation.xml

_pkginfo.txt

# Visual Studio cache files

# files ending in .cache can be ignored

*.[Cc]ache

# but keep track of directories ending in .cache

!*.[Cc]ache/

# Others

ClientBin/

~$*

*~

*.dbmdl

*.dbproj.schemaview

*.jfm

*.pfx

*.publishsettings

node_modules/

orleans.codegen.cs

# Since there are multiple workflows, uncomment next line to ignore bower_components

# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)

#bower_components/

# RIA/Silverlight projects

Generated_Code/

# Backup & report files from converting an old project file

# to a newer Visual Studio version. Backup files are not needed,

# because we have git ;-)

_UpgradeReport_Files/

Backup*/

UpgradeLog*.XML

UpgradeLog*.htm

# SQL Server files

*.mdf

*.ldf

# Business Intelligence projects

*.rdl.data

*.bim.layout

*.bim_*.settings

# Microsoft Fakes

FakesAssemblies/

# GhostDoc plugin setting file

*.GhostDoc.xml

# Node.js Tools for Visual Studio

.ntvs_analysis.dat

# Visual Studio 6 build log

*.plg

# Visual Studio 6 workspace options file

*.opt

# Visual Studio LightSwitch build output

**/*.HTMLClient/GeneratedArtifacts

**/*.DesktopClient/GeneratedArtifacts

**/*.DesktopClient/ModelManifest.xml

**/*.Server/GeneratedArtifacts

**/*.Server/ModelManifest.xml

_Pvt_Extensions

# Paket dependency manager

.paket/paket.exe

paket-files/

# FAKE - F# Make

.fake/

# JetBrains Rider

.idea/

*.sln.iml

# CodeRush

.cr/

# Python Tools for Visual Studio (PTVS)

__pycache__/

*.pyc



Microsoft Visual Studio Solution File, Format Version 12.00

# Visual Studio 15

VisualStudioVersion = 15.0.26730.3

MinimumVisualStudioVersion = 10.0.40219.1

Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "DTI_PID", "DTI_PID\DTI_PID.pyproj", "{7C2E55A3-2B16-4B4F-867F-F16E2EF6F2F0}"

EndProject

Global

	GlobalSection(SolutionConfigurationPlatforms) = preSolution

		Debug|Any CPU = Debug|Any CPU

		Release|Any CPU = Release|Any CPU

	EndGlobalSection

	GlobalSection(ProjectConfigurationPlatforms) = postSolution

		{7C2E55A3-2B16-4B4F-867F-F16E2EF6F2F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{7C2E55A3-2B16-4B4F-867F-F16E2EF6F2F0}.Release|Any CPU.ActiveCfg = Release|Any CPU

	EndGlobalSection

	GlobalSection(SolutionProperties) = preSolution

		HideSolutionNode = FALSE

	EndGlobalSection

	GlobalSection(ExtensibilityGlobals) = postSolution

		SolutionGuid = {3D496EC3-A232-40B5-BD20-1EA3CFECD450}

	EndGlobalSection

EndGlobal

import http.client

import urllib

import base64

import json

import cv2

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.image as mpimg

from PIL import Image

from io import BytesIO

import pytesseract

CONST_IMG_PID_UY1_K_300DPI = "res/UY1-K-2000_P1_300dpi.png"

src = []

resized = []

croppedSrc = []

eventSp = (-1, -1)

eventEp = (-1, -1)

cropping = False

resizeFactor = 0.15

def cropSrc(event, x, y, flags, param):

    global src

    global resized, croppedSrc

    global eventSp, cropping

    global resizeFactor

    if event == cv2.EVENT_LBUTTONDOWN:

        eventSp = (-1, -1)

        eventEp = (-1, -1)

        eventSp = (x, y)

        cropping = True

    elif event == cv2.EVENT_LBUTTONUP:

        eventEp = (x, y)

        cropping = False

        realSrcEventSp = (int(eventSp[0]/resizeFactor), int(eventSp[1]/resizeFactor))

        realSrcEventEp = (int(eventEp[0]/resizeFactor), int(eventEp[1]/resizeFactor))

        croppedSrc = src[realSrcEventSp[1]:realSrcEventEp[1], realSrcEventSp[0]:realSrcEventEp[0]]

        kernel = np.ones((2, 2), np.uint8)

        croppedSrc = cv2.dilate(croppedSrc, kernel)

        im = Image.fromarray(croppedSrc)

        #ocrData = pytesseract.image_to_data(im, config='-psm 10')

        #ocrData = pytesseract.image_to_string(im, config='-psm 10')

        ocrData = pytesseract.image_to_boxes(im, config='-c tessedit_char_whitelist="-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" -psm 6')

        #ocrData = pytesseract.image_to_data(im, config='-c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz -psm 6')

        #ocrData = pytesseract.image_to_string(im, config = "hocr")

        print("tesseract result : \n" + ocrData)

        #### For image_to_data()

        #if ocrData:

        #    splitOcrData = ocrData.split('\n')

        #    size = len(splitOcrData)

        #    i = 1

        #    while i < size:

        #        data = splitOcrData[i]

        #        sData = data.split('\t')

        #        if len(sData) == 12:

        #            text = sData[11]

        #            tx = int(sData[6]) // 2

        #            ty = int(sData[7]) // 2

        #            tw = int(sData[8]) // 2

        #            th = int(sData[9]) // 2

        #            #realSp = (symbolSp[0]+tx, symbolSp[1]+ty)

        #            #cv2.putText(canvas, text, (realSp[0], realSp[1]+th), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 3)

        #        i = i+1

        ## For image_to_boxes()

        if ocrData:

            splitOcrData = ocrData.split('\n')

            for data in splitOcrData:

                sData = data.split(' ')

                text = sData[0]

                tx = int(sData[1])

                ty = int(sData[2])

                tex = int(sData[3])

                tey = int(sData[4])

                tw = tex - tx

                th = tey - ty

                #realSp = (symbolSp[0]+tx, symbolSp[1]+ty)

                #cv2.putText(canvas, text, (realSp[0], realSp[1]+th), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 3)

        cv2.imshow('cropped', croppedSrc)

        cv2.waitKey(0)

def main():

    global src

    global resized, resizeFactor

    print('main')

    src = cv2.imread(CONST_IMG_PID_UY1_K_300DPI)

    resized = cv2.resize(src, None, fx=resizeFactor, fy=resizeFactor)

    cv2.namedWindow('main')

    cv2.setMouseCallback('main', cropSrc)

    cv2.imshow('main', resized)

    cv2.waitKey(0)

main()

#region import libs

##import httplib

import http.client

import urllib, base64, json

import cv2

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.image as mpimg

import SymbolBase

import symbol

import azure_ocr_module as OCR

import azure_handwrite_ocr_module as HOCR

import imutils

from PIL import Image

from PIL import ImageTk

from PIL import ImageChops

from io import BytesIO

from functools import partial

from functools import reduce

import gc

import os

import glob

import timeit

import scipy

import math, operator

import threading

import concurrent.futures as futures

import XmlGenerator as xg

import sqlite3

import pytesseract

#endregion

## Tesseract path

pytesseract.pytesseract.tesseract_cmd = 'D:\\Program Files\\Tesseract-OCR\\tesseract.exe'

tesseract_cmd = 'D:\\Program Files\\Tesseract-OCR\\tesseract.exe'

#region Image path for test

CONST_IMG_PID_UY1_K_300DPI = "res/UY1-K-2000_P1_300dpi.png"

CONST_IMG_PID_UY1_K_2005G_300DPI = "res/UY1-K-2005G_P1_300dpi_black.png"

CONST_IMG_PID_UY1_K_2006_300DPI = "res/UY1-K-2006_P1_300dpi_black.png"

CONST_IMG_PID_UY1_K_2007_300DPI = "res/UY1-K-2007_P1_300dpi_black.png"

#endregion

#region Image path List for test

targetSymbolList = []

#endregion

#region Global variables

searchedSymbolList = []

src = []

srcGray = []

ocrCompletedSrc = []

afterDenoising = []

canvas = []

WHITE_LIST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

#DB_NAME = "db/DTI_PID_test.db"

DB_NAME = "db/DTI_PID.db"

THREAD_MAX_WORKER = 4

threadLock = threading.Lock()

ACCEPT_OVERLAY_AREA = 10

#endregion

#Convert into Grayscale image

def cvtGrayImage(img):

    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#Check object contains pt

#obj is item in searchedSymbolList

def contains(obj, pt, tw, th):

    sp = obj.getSp()

    width = obj.getWidth()

    height = obj.getHeight()

    if sp[0] > pt[0]+tw:

        return 0

    if sp[0]+width < pt[0]: 

        return 0

    if sp[1] > pt[1]+th: 

        return 0

    if sp[1]+height < pt[1]: 

        return 0

    #shared area

    x = max(sp[0], pt[0]);

    y = max(sp[1], pt[1]);

    w = min(sp[0] + width, pt[0] + tw) - x;

    h = min(sp[1] + height, pt[1] + th) - y;

    return float((w * h)) / float((tw * th)) * 100

#Add symbols

def addSearchedSymbol(id, sCategory, sClass, sType, sItem, symbolPath, pt, w, h, threshold, minMatchCount, mpCount, rotatedAngle, isDetectOnOrigin, rotateCount, ocrOption):

    global searchedSymbolList

    newSym = symbol.Symbol(id, sCategory, sClass, sType, sItem, symbolPath, pt, w, h, threshold, minMatchCount, mpCount, rotatedAngle, isDetectOnOrigin, rotateCount, ocrOption)

    searchedSymbolList.append(newSym)

#Calculate count of keypoint match result

def getMatchPointCount(src, cmp):

    orb = cv2.ORB_create(1000, 2.0, 2, 1)

    kp1, des1 = orb.detectAndCompute(src, None)

    kp2, des2 = orb.detectAndCompute(cmp, None)

    FLANN_INDEX_LSH = 6

    # table_number      : The number of hash tables use

    # key_size          : The length of the key in the hash tables

    # multi_probe_level : Number of levels to use in multi-probe (0 for standard LSH)

    #                     It controls how neighboring buckets are searched

    #                     Recommended value is 2

    # checks            : specifies the maximum leafs to visit when searching for neighbours.

    # LSH : Locality-Sensitive Hashing

    # ref : https://www.cs.ubc.ca/research/flann/uploads/FLANN/flann_manual-1.8.4.pdf

    index_params = dict(algorithm = FLANN_INDEX_LSH, table_number = 20, key_size = 10, multi_probe_level = 4)

    search_params = dict(checks = 100)

    flann = cv2.FlannBasedMatcher(index_params,search_params)

    matches = flann.knnMatch(des1, des2, k = 2)

    #matchesMask = [[0, 0] for i in xrange(len(matches))] #Python 2.x

    matchesMask = [[0, 0] for i in range(len(matches))] #Python 3.x

    count = 0

    # ratio test as per Lowe's paper

    for i in range(len(matches)):

        if len(matches[i]) == 2:

            m = matches[i][0]

            n = matches[i][1]

            if m.distance < 0.85 * n.distance:

                count = count + 1

    matchCount = count

    print("match Count : " + str(matchCount))

    return matchCount

#detect symbols on PID

def detectSymbolsOnPid(mainRes, targetSymbols):

    for detailTarget in targetSymbols:

        detectSymbolOnPid(mainRes, detailTarget)

#detect symbol on PID

def detectSymbolOnPid(mainRes, targetSymbol):

    global src

    global srcGray

    global ocrCompletedSrc

    global afterDenoising

    global threadLock

    symId = targetSymbol.getId()

    symbolName = targetSymbol.getName()

    symbolClass = targetSymbol.getClass()

    symbolType = targetSymbol.getType()

    symbolItem = targetSymbol.getItem()

    symbolPath = targetSymbol.getPath()

    symbolThreshold = targetSymbol.getThreshold()

    symbolMinMatchCount = targetSymbol.getMinMatchCount()

    isDetectOnOrigin = targetSymbol.getIsDetectOnOrigin()

    symbolRotateCount = targetSymbol.getRotationCount()

    symbolOcrOption = targetSymbol.getOcrOption()

    print('current symbol : ' + symbolPath)

    foundSymbolCount = 0

    sym = cv2.imread(symbolPath, 1)

    symGray = cvtGrayImage(sym)

    if isDetectOnOrigin == True:

        copiedBasePid = srcGray.copy()

    else:

        copiedBasePid = ocrCompletedSrc.copy()

    srcWidth, srcHeight = copiedBasePid.shape[::-1]

    if srcWidth > 10000 or srcHeight > 10000:

        splitCount = 2 ## splitCount = 2^n

    else:

        splitCount = 1

    roiSp = (0, 0)

    roiEp = (0, 0)

    totalMpCount = 0

    while splitCount >= 1:

        splitWidth = srcWidth // splitCount

        splitHeight = srcHeight // splitCount

        ##Setting ROI List - [splitCount * splitCount] size

        splitRoiList = []

        for hi in range(splitCount):

            for wi in range(splitCount):

                roiSp = (srcWidth*wi//splitCount, srcHeight*hi//splitCount)

                roiEp = (srcWidth*(wi+1)//splitCount, srcHeight*(hi+1)//splitCount)

                splitRoiList.append((roiSp, roiEp, copiedBasePid[roiSp[1]:roiEp[1], roiSp[0]:roiEp[0]]))

        for roiIndex in range(len(splitRoiList)):

            roiItemSp = splitRoiList[roiIndex][0]

            roiItemEp = splitRoiList[roiIndex][1]

            roiItem = splitRoiList[roiIndex][2]

            rotatedAngle = 0

            for rc in range(symbolRotateCount):

                ##Template Matching

                sw, sh = symGray.shape[::-1]

                roiw = (roiItemEp[0] - roiItemSp[0])

                roih = (roiItemEp[1] - roiItemSp[1])

                ## Case : Bigger Symbol than Split ROI

                if roiw < sw or roih < sh:

                    symGray = cv2.rotate(symGray, cv2.ROTATE_90_CLOCKWISE)

                    rotatedAngle = rotatedAngle + 90

                    continue

                ## Template Matching

                tmRes = cv2.matchTemplate(roiItem, symGray, cv2.TM_CCOEFF_NORMED)

                loc = np.where(tmRes >= symbolThreshold)

                for pt in zip(*loc[::-1]):

                    overlapArea = 0

                    mpCount = 0 # Match Point Count

                    symbolIndex = -1

                    searchedItemSp = (roiItemSp[0]+pt[0], roiItemSp[1]+pt[1])

                    for i in range(len(searchedSymbolList)):

                        overlapArea = contains(searchedSymbolList[i], searchedItemSp, sw, sh)

                        #print("OverlapArea : " + str(overlapArea))

                        if overlapArea > ACCEPT_OVERLAY_AREA:

                            symbolIndex = i

                            break

                    roi = roiItem[pt[1]:pt[1]+sh, pt[0]:pt[0]+sw]

                    mpCount = getMatchPointCount(roi, symGray)

                    if overlapArea <= ACCEPT_OVERLAY_AREA:

                        if mpCount >= symbolMinMatchCount:

                            foundSymbolCount = foundSymbolCount + 1

                            totalMpCount = totalMpCount + mpCount

                            threadLock.acquire()

                            addSearchedSymbol(symId, symbolName, symbolClass, symbolType, symbolItem

                                              , symbolPath, searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount

                                              , mpCount, rotatedAngle, isDetectOnOrigin, symbolRotateCount, symbolOcrOption)

                            #print('symbol added')

                            threadLock.release()

                    else:

                        if symbolIndex != -1 and symbolIndex < len(searchedSymbolList):

                            symbolMpCount = searchedSymbolList[symbolIndex].getMpCount()

                            if symbolMpCount < mpCount:

                                threadLock.acquire()

                                totalMpCount = totalMpCount - symbolMpCount + mpCount

                                searchedSymbolList[symbolIndex] = symbol.Symbol(symId, symbolName, symbolClass, symbolType, symbolItem

                                                                                , symbolPath, searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount

                                                                                , mpCount, rotatedAngle, isDetectOnOrigin, symbolRotateCount, symbolOcrOption)

                                #print('symbol changed')

                                threadLock.release()

                ## Rotate Symbol

                symGray = cv2.rotate(symGray, cv2.ROTATE_90_CLOCKWISE)

                rotatedAngle = rotatedAngle + 90

        splitCount = splitCount // 2

    avgMpCount = 0

    if foundSymbolCount != 0:

        avgMpCount = totalMpCount / foundSymbolCount

    threadLock.acquire()

    srcName = mainRes.split("/")[-1]

    srcName = srcName.replace(".png", "")

    print('finish symbol(count) / AvgMpCount : ' + symbolPath + '(' + str(foundSymbolCount) + ') / avgMpCount : ' + str(avgMpCount))

    f = open("res/Result/result_"+srcName+"_600dpi.txt", 'a+')

    data = 'symbolName - (count) : ' + symbolPath + ' - (' + str(foundSymbolCount) + ') / avgMpCount : '+str(avgMpCount)+'\n'

    f.write(data)

    f.close()

    threadLock.release()

def drawRectOnSrc(sym):

    path = sym.getPath()

    sp = sym.getSp()

    sw = sym.getWidth()

    sh = sym.getHeight()

    sAngle = sym.getRotatedAngle()

    symImg = cv2.imread(path)

    symImg = cvtGrayImage(symImg)

    for i in range(sAngle//90):

        symImg = cv2.rotate(symImg, cv2.ROTATE_90_CLOCKWISE)

    temp = []

    temp = srcGray[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw]

    tempBin = cv2.bitwise_not(temp)

    result = cv2.bitwise_xor(symImg, tempBin)

    name = sym.getPath()

    #if "L01" in name:

    #    cv2.imshow('symImg', symImg)

    #    cv2.imshow('srcGrayRoi', srcGray[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw])

    #    cv2.imshow('temp', temp)

    #    cv2.imshow('tempBin', tempBin)

    #    cv2.imshow('result', result)

    #    cv2.waitKey(0)

    srcGray[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw] = result

    ocrCompletedSrc[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw] = result

    cv2.rectangle(src, sp, (sp[0]+sw, sp[1]+sh), (0, 0, 255), 2)

def drawFoundSymbols(symbol):

    global src

    global canvas

    global WHITE_LIST_CHARS

    symbolPath = symbol.getPath()

    symbolSp = symbol.getSp()

    symbolWidth = symbol.getWidth()

    symbolHeight = symbol.getHeight()

    symbolRotatedAngle = symbol.getRotatedAngle()

    symbolOcrOption = symbol.getOcrOption()

    symImg = cv2.imread(symbolPath, 1)

    for i in range(symbolRotatedAngle//90):

        symImg = cv2.rotate(symImg, cv2.ROTATE_90_CLOCKWISE)

    chan, w, h = symImg.shape[::-1]

    canvas[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w] = cv2.bitwise_and(canvas[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w], symImg)

    if symbolOcrOption == SymbolBase.OCR_OPTION_ALL_FIND or symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

        if symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

            inSqWidth = int(((w//2) * math.cos(round(math.radians(45), 2)))) * 2

            inSqHeight = int(((h//2) * math.sin(round(math.radians(45), 2)))) * 2

            inSqX = w//2 - (inSqWidth//2)

            inSqY = h//2 - (inSqHeight//2)

        else:

            inSqWidth = w

            inSqHeight = h

            inSqX = 0

            inSqY = 0

        roi = src[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w]

        srcRoi = roi[inSqY:inSqY+inSqHeight, inSqX:inSqX+inSqWidth]

        symRev = cv2.bitwise_not(symImg[inSqY:inSqY+inSqHeight, inSqX:inSqX+inSqWidth])

        bitImg = cv2.bitwise_or(srcRoi, symRev)

        kernel1 = np.ones((2, 2), np.uint8)

        bitImg = cv2.dilate(bitImg, kernel1)

        #kernel2 = np.ones((1, 1), np.uint8)

        #bitImg = cv2.erode(bitImg, kernel2)

        bitImg = cv2.resize(bitImg, None, fx = 2.0, fy = 2.0)

        im = Image.fromarray(bitImg)

        #im = Image.fromarray(src[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w])

        ocrData = pytesseract.image_to_boxes(im, config='-c tessedit_char_whitelist="-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" -psm 6')

        #ocrData = pytesseract.image_to_data(im)

        #ocrData = pytesseract.image_to_string(im, config = "hocr")

        print("tesseract result : \n" + ocrData)

        ### For image_to_data()

        #if ocrData:

        #    splitOcrData = ocrData.split('\n')

        #    size = len(splitOcrData)

        #    i = 1

        #    while i < size:

        #        data = splitOcrData[i]

        #        threadLock.acquire()

        #        sData = data.split('\t')

        #        if len(sData) == 12:

        #            text = sData[11]

        #            tx = int(sData[6]) // 2

        #            ty = int(sData[7]) // 2

        #            tw = int(sData[8]) // 2

        #            th = int(sData[9]) // 2

        #            realSp = (symbolSp[0]+tx, symbolSp[1]+ty)

        #            cv2.putText(canvas, text, (realSp[0], realSp[1]+th), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 3)

        #        threadLock.release()

        #        i = i+1

        ### For image_to_boxes()

        if ocrData:

            splitOcrData = ocrData.split('\n')

            tList = []

            lastCoord = (-1, -1) # Top-Right Coord

            tText = []

            ftSp = (-1, -1)

            threadLock.acquire()

            for data in splitOcrData:

                sData = data.split(' ')

                text = sData[0]

                tsx = int(sData[1]) // 2

                tsy = int(sData[2]) // 2

                tex = int(sData[3]) // 2

                tey = int(sData[4]) // 2

                tw = tex - tsx

                th = tey - tsy

                MIN_TEXT_SIZE = 10

                if WHITE_LIST_CHARS.find(text) >= 0:

                    if tw >= MIN_TEXT_SIZE or th >= MIN_TEXT_SIZE:

                        if lastCoord == (-1, -1):

                            tText.append(text)

                            ftSp = (tsx, tsy)

                        else:

                            COORD_ADJUSTMENT = 15

                            if (abs(lastCoord[1] - tsy) <= COORD_ADJUSTMENT and lastCoord[0] >= tsx - COORD_ADJUSTMENT and lastCoord[0] <= tsx + COORD_ADJUSTMENT) or (abs(lastCoord[0] - tsx) <= COORD_ADJUSTMENT and lastCoord[1] >= tsy - COORD_ADJUSTMENT and lastCoord[1] <= tsy + COORD_ADJUSTMENT):

                                tText.append(text)

                            else:

                                if symbolOcrOption == SymbolBase.OCR_OPTION_ALL_FIND:

                                    tText.append(',')

                                tText.append(text)

                        lastCoord = (tex, tsy) # Top-Right Coord

            realSp = (symbolSp[0]+inSqX+ftSp[0], symbolSp[1]+inSqY+ftSp[1])

            resultText = ''.join(tText)

            cv2.putText(canvas, resultText, (realSp[0], realSp[1]+th), 2, 1.0, (0, 0, 0)) # cv2.FONT_HERSHEY_SIMPLEX

            # text value in symbol object update

            index = [i for i, item in enumerate(searchedSymbolList) if item.getSp() == symbolSp]

            if len(index) > 0:

                searchedSymbolList[index[0]].setText(resultText)

            threadLock.release()

def drawFoundSymbolsOnCanvas(mainRes, width, height):

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global canvas

    canvas = np.zeros((height, width, 3), np.uint8)

    canvas[::] = (255, 255, 255)

    #pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

    for symbol in searchedSymbolList:

        #pool.submit(drawFoundSymbols, symbol)

        drawFoundSymbols(symbol)

    #pool.shutdown(wait = True)

    srcName = mainRes.split("/")[-1]

    srcName = srcName.replace(".png", "")

    cv2.imwrite('res/Result/result_moved_'+srcName+'_600dpi.png', canvas)

#Generate target symbol data list

def initTargetSymbolDataList():

    ############ region SQLite

    conn = sqlite3.connect(DB_NAME)

    cursor = conn.cursor()

    sql = 'SELECT * FROM Symbol'

    cursor.execute(sql)

    rows = cursor.fetchall()

    dict = {}

    ## Init Symbol Data from SQLite

    for row in rows:

        symId = row[0] // 100 # symId

        if symId in dict:

            dict[symId].append(symbol.SymbolBase(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))

        else:

            symGroup = []

            symGroup.append(symbol.SymbolBase(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))

            dict[symId] = symGroup

    conn.close()

    ## Sort each symbol list by symbol id

    for k, v in dict.items():

        dict[k] = sorted(v, key=lambda symbol:symbol.id)

    ## Insert each symbol list into targetSymbolList

    for sym in list(dict.values()):

        targetSymbolList.append(sym)

    ############ endregion SQLite

    return targetSymbolList

def initMainSrc(mainRes):

    global src

    global srcGray

    global ocrCompletedSrc

    #load original src & symbol

    src = cv2.imread(mainRes, 1)

    #gray scale

    if len(src.shape) == 3:

        srcGray = cvtGrayImage(src)

    else:

        srcGray = src.copy()

    #srcGray = src

    ocrCompletedSrc = OCR.removeTextFromNpArray(srcGray)

#Main function

def main():

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global threadLock

    #srcList = [CONST_IMG_PID_UY1_K_2006_300DPI]

    srcList = [CONST_IMG_PID_UY1_K_300DPI]

    #srcList = [CONST_IMG_PID_UY1_K_2005G_300DPI, CONST_IMG_PID_UY1_K_2007_300DPI]

    #srcList = [CONST_IMG_PID_UY1_K_300DPI, CONST_IMG_PID_UY1_K_2005G_300DPI, CONST_IMG_PID_UY1_K_2006_300DPI, CONST_IMG_PID_UY1_K_2007_300DPI]

    initTargetSymbolDataList()

    for mainRes in srcList:

        #Init src

        src = []

        srcGray = []

        ocrCompletedSrc = []

        searchedSymbolList = []

        start = timeit.default_timer()

        initMainSrc(mainRes)

        print("######### Ready : " + mainRes)

        #threadLock = threading.Lock()

        pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

        for targetItem in targetSymbolList:

            if type(targetItem).__name__ == 'list':

                #detectSymbolsOnPid(mainRes, target)

                pool.submit(detectSymbolsOnPid, mainRes, targetItem)

            else:

                #detectSymbolOnPid(mainRes, target)

                pool.submit(detectSymbolOnPid, mainRes, targetItem)

        pool.shutdown(wait = True)

        chan, srcWidth, srcHeight = src.shape[::-1]

        drawFoundSymbolsOnCanvas(mainRes, srcWidth, srcHeight)

        srcGray = OCR.removeTextFromNpArray(srcGray)

        srcName = mainRes.split("/")[-1]

        srcName = srcName.replace(".png", "")

        stop = timeit.default_timer()    

        seconds = stop - start

        f = open("res/Result/result_"+srcName+"_600dpi.txt", 'a+')

        data = "Running Time : " + str(seconds / 60) + "min\n"

        f.write(data)

        f.close()

        print("\nRunning Time : " + str(seconds / 60) + "min\n")

        pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

        for sym in searchedSymbolList:

            threadLock.acquire()

            pool.submit(drawRectOnSrc, sym)

            #drawRectOnSrc()

            threadLock.release()

        pool.shutdown(wait = True)

        print("Searched symbol count : " + str(len(searchedSymbolList)))

        cv2.imwrite("res/Result/result_fslo_"+srcName+"_600dpi.png", srcGray)

        cv2.imwrite("res/Result/result_fslo_rect_"+srcName+"_600dpi.png", src)

        xg.writeXml(srcName, srcWidth, srcHeight, searchedSymbolList)

    b, g, r = cv2.split(src)

    pltSrc = cv2.merge([r, g, b])

    plt.imshow(pltSrc)

    plt.imshow(cv2.cvtColor(srcGray, cv2.COLOR_GRAY2RGB))

    plt.show()

    while True:

        k = cv2.waitKey(0)

        if k == 27:

            cv2.destroyAllWindows()

            break

        elif k == 'r':

            print('result')

            break;

#region Program start

main()

#endregion

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <SchemaVersion>2.0</SchemaVersion>

    <ProjectGuid>7c2e55a3-2b16-4b4f-867f-f16e2ef6f2f0</ProjectGuid>

    <ProjectHome>.</ProjectHome>

    <StartupFile>DTI_PID.py</StartupFile>

    <SearchPath>

    </SearchPath>

    <WorkingDirectory>.</WorkingDirectory>

    <OutputPath>.</OutputPath>

    <Name>DTI_PID</Name>

    <RootNamespace>DTI_PID</RootNamespace>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

    <DebugSymbols>true</DebugSymbols>

    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">

    <DebugSymbols>true</DebugSymbols>

    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>

  </PropertyGroup>

  <ItemGroup>

    <Compile Include="AreaOcrTestmodule.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="azure_handwrite_ocr_module.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="azure_ocr_module.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="DTI_PID.py" />

    <Compile Include="symbol.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="SymbolBase.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="XmlGenerator.py">

      <SubType>Code</SubType>

    </Compile>

  </ItemGroup>

  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />

  <!-- Uncomment the CoreCompile target to enable the Build command in

       Visual Studio and specify your pre- and post-build commands in

       the BeforeBuild and AfterBuild targets below. -->

  <!--<Target Name="CoreCompile" />-->

  <Target Name="BeforeBuild">

  </Target>

  <Target Name="AfterBuild">

  </Target>

</Project>

OCR_OPTION_NOT_EXEC = 0

OCR_OPTION_ALL_FIND = 1

OCR_OPTION_HALF_AND_HALF = 2

class SymbolBase():

    def __init__(self, id, sName, sClass, sType, sItem, path = None, threshold = None, minMatchCount = 0, isDetectOnOrigin = False, rotationCount = 4, ocrOption = OCR_OPTION_NOT_EXEC):

        self.id = id

        self.sName = sName

        self.sClass = sClass

        self.sType = sType

        self.sItem = sItem

        self.path = path

        self.threshold = threshold

        self.minMatchCount = minMatchCount

        self.isDetectOnOrigin = isDetectOnOrigin

        self.rotationCount = rotationCount

        self.ocrOption = ocrOption

    def setId(self, id):

        self.id = id

    def getId(self):

        return self.id

    def setName(self, sName):

        self.sName = sName

    def getName(self):

        return self.sName

    def setClass(self, sClass):

        self.sClass = sClass

    def getClass(self):

        return self.sClass

    def setType(self, type):

        self.sType = type

    def getType(self):

        return self.sType

    def setItem(self, item):

        self.sItem = item

    def getItem(self):

        return self.sItem

    def setPath(self, path):

        self.path = path

    def getPath(self):

        return self.path

    def setThreshold(self, threshold):

        self.threshold = threshold

    def getThreshold(self):

        return self.threshold

    def setMinMatchCount(self, minMatchCount):

        self.minMatchCount = minMatchCount

    def getMinMatchCount(self):

        return self.minMatchCount

    def setIsDetectOnOrigin(self, isDetectOnOrigin):

        self.isDetectOnOrigin = isDetectOnOrigin

    def getIsDetectOnOrigin(self):

        return self.isDetectOnOrigin

    def setRotationCount(self, rotationCount):

        self.rotationCount = rotationCount

    def getRotationCount(self):

        return self.rotationCount

    def setOcrOption(self, ocrOption):

        self.ocrOption = ocrOption

    def getOcrOption(self):

        return self.ocrOption

from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

import symbol

import math

ROOT_NODE_NAME = "DWG"

ROOT_DWGNAME_NODE_NAME = "DWGNAME"

ROOT_SIZE_NODE_NAME = "SIZE"

SCATEGORY_NODE_NAME = "SYMBOL"

SSYSTEM_PATH_NODE_NAME = "SYSTEMPATH"

SNAME_NODE_NAME = "NAME"

SNAME_PIPING = "PIPING"

SNAME_EQUIPMENT = "EQUIPMENT"

SNAME_INSTRUMENT = "INSTRUMENT"

SCLASS_NODE_NAME = "CLASS"

SCLASS_ROUTING = "ROUTING"

SCLASS_VALVES = "VALVES"

SCLASS_REDUCERS = "REDUCERS"

SCLASS_VESSELS = "VESSELS"

SCLASS_OFF_LINE = "OFF-LINE"

SCLASS_SYSTEM_FUNCTIONS = "SYSTEM FUNCTIONS"

STYPE_NODE_NAME = "TYPE"

STYPE_PROCESS_LINES = "PROCESS LINES"

STYPE_2_WAY_COMMON = "2 WAY COMMON"

STYPE_ANGLE_VALVES = "ANGLE VALVES"

STYPE_DIAMETER_CHANGE = "DIAMETER CHANGE"

STYPE_TANKS = "TANKS"

STYPE_SINGLE_FUNC = "SINGLE FUNC"

STYPE_DCS = "D C S"

STYPE_PIPING_CONNECTORS = "PIPING CONNECTORS"

SITEM_NODE_NAME = "ITEM"

SITEM_PRIMARY_PIPING = "PRIMARY PIPING"

SITEM_GATE_VALVE = "GATE VALVE"

SITEM_GATE_VALVE_CLOSED = "GATE VALVE (CLOSED)"

SITEM_GLOBE_VALVE = "GLOBE VALVE"

SITEM_CHECK_VALVE = "CHECK VALVE"

SITEM_ANGLE_VALVE = "ANGLE VALVE"

SITEM_CONCENTRIC_REDUCER = "CONCENTRIC REDUCER"

SITEM_CONE_ROOF_TANK = "CONE ROOF TANK"

SITEM_DISC_SINGLE_FUNC_FIELD_MOUNTED = "DISC SINGLE-FUNC FIELD MOUNTED"

SITEM_DISC_SINGLE_FUNC_ACCESS_IN_PRIME_LOC = "DISC SINGLE-FUNC ACCESS IN PRIME LOC"

SITEM_DCS_FUNC_ACCESS_IN_PRIME_LOC = "DCS FUNC ACCESS IN PRIME LOC"

SITEM_CONTINUATION_ARROW = "CONTINUATION ARROW"

SSUB_TEXT = "TEXT"

SSUB_ORIGINAL_POINT = "ORIGINALPOINT"

SSUB_ANGLE = "ANGLE"

def writeXml(pidName, pidWidth, pidHeight, searchedSymbolList):

    xmlData = generateXml(pidName, pidWidth, pidHeight, searchedSymbolList)

    #xmlData = indent(xmlData)

    ElementTree(xmlData).write("res/Result/"+pidName+".xml")

def generateXml(pidName, pidWidth, pidHeight, searchedSymbolList):

    xml = Element(ROOT_NODE_NAME) # Root Node

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    for symbol in searchedSymbolList:

        node = getSymbolInfoNode(symbol)

        xml.append(node)

    return xml

def getSymbolInfoNode(symbol):

    sName = symbol.getName()

    sClass = symbol.getClass()

    sType = symbol.getType()

    sItem = symbol.getItem()

    sName = symbol.getName()

    sSp = symbol.getSp()

    sAngle = symbol.getRotatedAngle()

    sText = symbol.getText()

    sCategoryNode = Element(SCATEGORY_NODE_NAME)

    sSystemPathNode = Element(SSYSTEM_PATH_NODE_NAME)

    if sType is None or not sType:

        sSystemPathNode.text = "\\" + sName + "\\" + sClass + "\\" + sItem

    else:

        sSystemPathNode.text = "\\" + sName + "\\" + sClass + "\\" + sType + "\\" + sItem

    sNameNode = Element(SNAME_NODE_NAME)

    sNameNode.text = sName

    sClassNode = Element(SCLASS_NODE_NAME)

    sClassNode.text = sClass

    sTypeNode = Element(STYPE_NODE_NAME)

    sTypeNode.text = sType

    sItemNode = Element(SITEM_NODE_NAME)

    sItemNode.text = sItem

    sOriginalPointNode = Element(SSUB_ORIGINAL_POINT)

    sOriginalPointNode.text = str(sSp[0]) + "," + str(sSp[1])

    sAngleNode = Element(SSUB_ANGLE)

    sAngleNode.text = str(round(math.radians(sAngle), 2))

    sTextNode = Element(SSUB_TEXT)

    sTextNode.text = sText

    sCategoryNode.append(sSystemPathNode)

    sCategoryNode.append(sNameNode)

    sCategoryNode.append(sClassNode)

    sCategoryNode.append(sTypeNode)

    sCategoryNode.append(sItemNode)

    sCategoryNode.append(sOriginalPointNode)

    sCategoryNode.append(sAngleNode)

    sCategoryNode.append(sTextNode)

    return sCategoryNode

def indent(elem, level=0):

    i = "\n" + level*"  "

    if len(elem):

        if not elem.text or not elem.text.strip():

            elem.text = i + "  "

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

        for elem in elem:

            indent(elem, level+1)

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

    else:

        if level and (not elem.tail or not elem.tail.strip()):

            elem.tail = i

    return elem

#import httplib

import http.client

import urllib

import base64

import json

import cv2

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.image as mpimg

from PIL import Image

from io import BytesIO

def url_to_image(url):

	# download the image, convert it to a NumPy array, and then read

	# it into OpenCV format

	resp = urllib.request.urlopen(url)

	#resp = urllib.urlopen(url)

	image = np.asarray(bytearray(resp.read()), dtype="uint8")

	image = cv2.imdecode(image, cv2.IMREAD_COLOR)

	# return the image

	return image

def getRollbackRotateCodeByOrientation(orientation):

    rotatedAngle = None

    if orientation == "Left":

        rotatedAngle = cv2.ROTATE_90_COUNTERCLOCKWISE

    elif orientation == "Right":

        rotatedAngle = cv2.ROTATE_90_CLOCKWISE

    else:

        rotatedAngle = cv2.ROTATE_180

    return rotatedAngle

def getRotateCodeByOrientation(orientation):

    rotatedAngle = None

    if orientation == "Left":

        rotatedAngle = cv2.ROTATE_90_CLOCKWISE

    elif orientation == "Right":

        rotatedAngle = cv2.ROTATE_90_COUNTERCLOCKWISE

    else:

        rotatedAngle = cv2.ROTATE_180

    return rotatedAngle

####################################

###############################################

#### Update or verify the following values.  ###

###############################################

# Replace the subscription_key string value with your valid subscription key.

#subscription_key = '4774f949a51e4728b436d05a0d0415c2' # zombie612

#subscription_key = 'ef94d01a99854539a72b5696118b4ac9' # kyusu99

subscription_key = '828669ef78ae40959882ff4a897fb1a4' # master

# Replace or verify the region.

#

# You must use the same region in your REST API call as you used to obtain your

# subscription keys.

# For example, if you obtained your subscription keys from the westus region,

# replace

# "westcentralus" in the URI below with "westus".

#

# NOTE: Free trial subscription keys are generated in the westcentralus region,

# so if you are using

# a free trial subscription key, you should not need to change this region.

#uri_base = 'westcentralus.api.cognitive.microsoft.com' # USA

#uri_base = 'eastasia.api.cognitive.microsoft.com' # east asia for master

uri_base = 'southeastasia.api.cognitive.microsoft.com' # southeast asia for master

headers = {

    # Request headers.

    #'Content-Type': 'application/json',

    'Content-Type': 'application/octet-stream',

    'Ocp-Apim-Subscription-Key': subscription_key,

}

#params = urllib.urlencode({

params = urllib.parse.urlencode({

    # Request parameters.  The language setting "unk" means automatically

    'handwriting': 'false'

})

# The URL of a JPEG image containing text.

#body = "{'url':'D:/Visual Studio Project/PyOpenCv/PyOpenCv/res/symbol1.png'}"

#body =

#"{'url':'https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Atomist_quote_from_Democritus.png/338px-Atomist_quote_from_Democritus.png'}"

#body = "{'url':'http://cfile9.uf.tistory.com/image/99AFE1505A322DBD114994'}"

def detectAndRemoveText(image):

    tmp = image.copy()

    img = np.array(tmp)

    try:

        tmp = image.copy()

        bin_img = BytesIO()

        tmp.save(bin_img, format='PNG')

        tmp.close()

        img_data = bin_img.getvalue()

        bin_img.close()

        #region REST API with raw file

        # Execute the REST API call and get the response.

        conn = http.client.HTTPSConnection(uri_base)

        #conn = httplib.HTTPSConnection(uri_base)

        conn.request("POST", "/vision/v1.0/recognizeText?%s" % params, img_data, headers)

        response = conn.getresponse()

        data = response.read()

        #endregion

        operationLocation = response.info().get('Operation-Location')

        operationId = operationLocation.split("/")[-1]