Update pilecaps_adr.py

pilecaps_adr.py

@@ -11,7 +11,7 @@ import cv2
 from matplotlib import pyplot as plt 
 from math import sin, cos, radians
 import pandas as pd
-from PIL import Image
+from PIL import Image , ImageChops
 import numpy as np
 from googleapiclient.discovery import build 
 from google.oauth2 import service_account
@@ -23,6 +23,7 @@ import ast
 import Dropbox_TSA_API
 import tsadropboxretrieval
 from collections import Counter
+from unidecode import unidecode
 
 def textLists(img,dataDoc):
   allTexts = texts_from_pdf(dataDoc)
@@ -43,27 +44,46 @@ def textLists(img,dataDoc):
       listall.append((p1[0],p1[1],tpl[4]))
   return pc_coor, listall
 
+def textListsAlltexts(dataDoc,span_df):
+  listall=[]
+  pc_coor = []
+  allTexts = texts_from_pdf(dataDoc)
+  doc = fitz.open('pdf',dataDoc)
+  page=doc[0]
+  for i, row in span_df.iterrows():
+      p1 = fitz.Point((span_df['xmin'].loc[i]),(span_df['ymin'].loc[i]))
+      if page.rotation==0:
+        p1=p1*page.derotation_matrix
+      pc_coor.append((p1[0],p1[1]))
+      listall.append((p1[0],p1[1],span_df['text'].loc[i]))
+  return pc_coor, listall
+# pc_coor,listall=textLists(img)
+
+
 #Prepare preprocessing
 def detectCircles(imgOriginal ):
   im=imgOriginal.copy()
   imgGry1 = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
   kernel=np.ones((3,3),np.uint8)
   er1=cv2.erode(imgGry1,kernel, iterations=2)
- 
-  er1=cv2.dilate(er1,kernel, iterations=1)
-  detected_circles = cv2.HoughCircles( er1, cv2.HOUGH_GRADIENT, 1, 50, param1= 550,
+  er1=cv2.dilate(er1,kernel, iterations=2)
+  # cv2_imshow(er1)
+  # Apply Hough transform on the blurred image.
+   # min distance between circles,  Upper threshold for the internal Canny edge detector.
+  detected_circles = cv2.HoughCircles( er1, cv2.HOUGH_GRADIENT, 1, 50, param1= 700,
                     param2 =21, minRadius = 20, maxRadius = 50) #18 param2
-    
+
   # Draw circles that are detected.
   if detected_circles is not None:
       # Convert the circle parameters a, b and r to integers.
       detected_circles = np.uint16(np.around(detected_circles))
       detected_circles = np.round(detected_circles[0, :]).astype("int")
-    #DRAW CIRCLES
       for (x, y, r) in detected_circles:
-        cv2.circle(im, (x, y), r, (255, 255, 255), 5)
+        cv2.circle(im, (x, y), r, (255, 255, 255), 6)
   return im
 
+
+
 def detectSmallCircles(img ):
   #Remove tiny TOC points that interfere with shapes 
   im=img.copy()
@@ -121,38 +141,38 @@ def removeDashedLines(img4, imgBW ,max,min):
   green=im_copy[:,:,1]
   return green
 
-def removeSmallDashes(imgOriginal,green):
+
+def removeSmallDashes(imgOriginal,green,num=0):
   smalldashes=green.copy()
   smalldashes=cv2.bitwise_not(smalldashes)
 
   kernel3= np.ones((3,3),np.uint8)
- 
+
   img1=cv2.dilate(smalldashes, kernel3, iterations=2)
   img2=cv2.erode(img1, kernel3, iterations=2)
 
   smalldashes=cv2.medianBlur(img2,7)
   smalldashes=cv2.medianBlur(smalldashes,9)
-  # cv2_imshow(smalldashes)
+
   smalldashesOut=green.copy()
+
+  # if num==1:
+  #   smalldashes=cv2.cvtColor(smalldashes,cv2.COLOR_GRAY2BGR)
+  #   smalldashes=detectSmallCircles(smalldashes)
+  #   smalldashes=cv2.cvtColor(smalldashes,cv2.COLOR_BGR2GRAY)
   smalldashesOut=cv2.cvtColor(smalldashesOut,cv2.COLOR_GRAY2BGR)
-  imgLines= cv2.HoughLinesP(smalldashes,1,np.pi/150,27,minLineLength=10,maxLineGap = 70)  #was w-h , gap=150
+  imgLines= cv2.HoughLinesP(smalldashes,1,np.pi/180,27,minLineLength=70,maxLineGap = 70)  #was w-h , gap=150
 
   imgCopy=imgOriginal.copy()
   for i in range(len(imgLines)):
       for x1,y1,x2,y2 in imgLines[i]:
           cv2.line(smalldashesOut,(x1,y1),(x2,y2),(0,255,0),3)
-
-
-  smalldashesOut=smalldashesOut[:,:,1]
-  # cv2_imshow(smalldashesOut)
-  for i in range(len(imgLines)):
-      for x1,y1,x2,y2 in imgLines[i]:
-          cv2.line(imgCopy,(x1,y1),(x2,y2),(0,255,0),6)
-
+          cv2.line(imgCopy,(x1,y1),(x2,y2),(0,255,0),2)
   imgCopy=imgCopy[:,:,1]
-  # cv2_imshow(imgCopy)
+  smalldashesOut=smalldashesOut[:,:,1]
   return imgCopy,smalldashesOut
 
+
 def euclidian_distance(point1, point2):
     return sum([(point1[x] - point2[x]) ** 2 for x in range(len(point1))]) ** 0.5
 
@@ -168,37 +188,137 @@ def removeDashedLinesSmall(img4, imgBW ,max,min):
   green=im_copy[:,:,1]
   return green
 
-def ConnectBeamLines(smalldashesOut):
+def ConnectBeamLines(smalldashesOut, maxLineGap=0):
+  if maxLineGap==0:
+    maxLineGap=25
+    thresh=20
+    point=0.3
+  else:
+    thresh=20
+    point=0.2
+    maxLineGap=40
+  print(maxLineGap)
   green1=cv2.bitwise_not(smalldashesOut)
-  green2=smalldashesOut.copy()
-  green2=cv2.cvtColor(green2,cv2.COLOR_GRAY2BGR)
-  imgLines= cv2.HoughLinesP(green1,0.3,np.pi/180,20,minLineLength=25,maxLineGap = 25)  #try 180
+  smalldashesOut=cv2.cvtColor(smalldashesOut,cv2.COLOR_GRAY2BGR)
+  imgLines= cv2.HoughLinesP(green1,point,np.pi/180,thresh,minLineLength=25,maxLineGap =maxLineGap)  #try 180
   for i in range(len(imgLines)):
       for x1,y1,x2,y2 in imgLines[i]:
-          cv2.line(green2,(x1,y1),(x2,y2),(0,0,0),2)
-  return green2
+          cv2.line(smalldashesOut,(x1,y1),(x2,y2),(0,0,0),2)
+  return smalldashesOut
+
+def getImgDark(imgg):
+  imgold=preprocessold(imgg,0)
+  blurG =  cv2.GaussianBlur(ChangeBrightness(imgg,1),(3,3),0 )
+  imgGry = cv2.cvtColor(blurG, cv2.COLOR_BGR2GRAY)
+  ret3, thresh = cv2.threshold(imgGry, 0, 255, cv2.THRESH_BINARY_INV  + cv2.THRESH_OTSU)
+  imgold=cv2.medianBlur(imgold,3)
+  thresh=cv2.bitwise_or(thresh,imgold)
+  imgDark=cv2.bitwise_not(thresh)
+  imgDark = cv2.cvtColor(imgDark, cv2.COLOR_GRAY2BGR)
+  return imgDark
+
 #create img with solid lines
-def allpreSteps(imgOriginal):
+def allpreSteps(imgOriginal,num=0):
   noCircles=detectCircles(imgOriginal)
-  imgnoSmall=detectSmallCircles(noCircles )
-  img4,imgBW,max,min=DashedPreprocessing(imgOriginal,imgnoSmall)
-  green=removeDashedLines(img4,imgBW,max,min)
-  imgCopy,smalldashesOut=removeSmallDashes(imgOriginal,green)
-  noSmallDashes=removeDashedLinesSmall(img4, smalldashesOut ,max,min)
-  green2=ConnectBeamLines(noSmallDashes)
-  # cv2_imshow(green2)
-  return green2
+  imgold=preprocessold(imgOriginal,0)
+  if num!=1:
+    imgnoSmall=detectSmallCircles(noCircles )
+    img4,imgBW,max,min=DashedPreprocessing(imgOriginal,imgnoSmall)
+    green=removeDashedLines(img4,imgBW,max,min)
+    imgCopy,smalldashesOut=removeSmallDashes(imgOriginal,green)
+    noSmallDashes=removeDashedLinesSmall(img4, smalldashesOut ,max,min)
+    green2=ConnectBeamLines(noSmallDashes,0)
+
+    return green2
+  else:
+    #imgDark with no dashed lines or small dashes
+    print('p1')
+    imgDark1=getImgDark(noCircles)
+    print('p11')
+    img4,imgBW,max,min=DashedPreprocessing(imgOriginal,noCircles)
+    imgDarkNoDashedLines=removeDashedLines(img4,imgDark1,max,min) #do preprocessing on normal img , and draw on darkimg
+    imgBW0 = cv2.cvtColor(imgBW, cv2.COLOR_BGR2GRAY)
+    imgDarkNoDashedLines = cv2.cvtColor(imgDarkNoDashedLines, cv2.COLOR_GRAY2BGR)
+    imgDarkNoDashedLines,smalldashesOut0=removeSmallDashes(imgDarkNoDashedLines,imgBW0)
+    print('p2')
+    #imgOld no small dashes - for oring purposes
+    imgoldG = cv2.cvtColor(imgold, cv2.COLOR_GRAY2BGR)
+    imgoldnoDashes,_=removeSmallDashes(cv2.bitwise_not(imgoldG),imgBW0,1)
+    print('p3')
+    #to connect leader lines after removing dashed lines and circles
+    Nodashedlines=removeDashedLines(img4,imgBW,max,min)
+    imgCopy,smalldashesOut=removeSmallDashes(imgOriginal,Nodashedlines)
+
+    noSmallDashes=removeDashedLinesSmall(img4, smalldashesOut ,max,min)
+    green2=ConnectBeamLines(noSmallDashes,1)
+
+    green2 = cv2.cvtColor(green2, cv2.COLOR_BGR2GRAY)
+    green2=cv2.bitwise_or(cv2.bitwise_not(imgDarkNoDashedLines),cv2.bitwise_not(green2) )
+    green2=cv2.bitwise_not(green2)
+    # cv2_imshow(green2)
+    green2=cv2.medianBlur(green2,5)
+    # cv2_imshow(green2)
+    imgoldnoDashes=cv2.medianBlur(imgoldnoDashes,5)
+    print('p4')
+    return green2 , cv2.bitwise_not(imgoldnoDashes)
 
-def texts_from_pdf(input_pdf):
-    pdf_document = fitz.open("pdf",input_pdf)
 
+def texts_from_pdf(input_pdf):
+    pdf_document = fitz.open('pdf',input_pdf)
     for page_num in range(pdf_document.page_count):
         page = pdf_document[page_num]
         text_instances = page.get_text("words")
         page.apply_redactions()
     return text_instances
 
-def nearestText(a,b , pc_coor):
+
+def textDictionaryBlocks(img,dataDoc):
+  doc = fitz.open('pdf',dataDoc)
+  page=doc[0]
+  if page.rotation!=0:
+    page.set_rotation(0)
+  pix = page.get_pixmap()  # render page to an image
+  ratio =  pix.width/ img.shape[1]
+
+  block_dict = {}
+  page_num = 1
+  for page in doc: # Iterate all pages in the document
+        file_dict = page.get_text('dict') # Get the page dictionary
+        block = file_dict['blocks'] # Get the block information
+        block_dict[page_num] = block # Store in block dictionary
+        page_num += 1 # Increase the page value by 1
+  spans = pd.DataFrame(columns=['xmin', 'ymin', 'xmax', 'ymax', 'text','FitzPointP0','FitzPointP1'])
+  rows = []
+  for page_num, blocks in block_dict.items():
+      for block in blocks:
+          if block['type'] == 0:
+              for line in block['lines']:
+                  for span in line['spans']:
+                      xmin, ymin, xmax, ymax = list(span['bbox'])
+                      text = unidecode(span['text'])
+                      XminRatio=xmin/ratio
+                      YminRatio=ymin/ratio
+                      p1=fitz.Point((XminRatio),(YminRatio))
+                      if page.rotation==0:
+                        p1=p1*page.derotation_matrix
+                      if text.replace(" ","") !=  "":
+                        rows.append((XminRatio,YminRatio, xmax /ratio, ymax/ratio, text,p1[0],p1[1]))
+  span_df = pd.DataFrame(rows, columns=['xmin','ymin','xmax','ymax', 'text','FitzPointP0','FitzPointP1'])
+  return span_df
+
+def nearestText(a,b,span_df):
+  allNearbyText=[]
+  shapeTexts=[]
+  for i, row in span_df.iterrows():
+    measuredDist=euclidian_distance((a,b),(span_df['FitzPointP0'].loc[i],span_df['FitzPointP1'].loc[i]))
+    if measuredDist < 250:
+      allNearbyText.append((span_df['FitzPointP0'].loc[i],span_df['FitzPointP1'].loc[i] ))
+      shapeTexts.append(str(span_df['text'].loc[i]))
+  if len(allNearbyText)==0:
+    allNearbyText='none'
+  return allNearbyText , shapeTexts
+
+def nearestTextPCCOOR(a,b , pc_coor):
   nearest_point=min(pc_coor,key=lambda x:euclidian_distance((a,b),x))
   dist = euclidian_distance(nearest_point, (a,b))
   if dist < 400: #distance threshold
@@ -232,9 +352,26 @@ def connectsmallDot(blackwithNoDot):
       for x1,y1,x2,y2 in imgLines[i]:
           cv2.line(blackwithNoDot,(x1,y1),(x2,y2),(255,255,255),2)
   return blackwithNoDot
+
+def getDiff(img,green22,imgoldnodashes):
+  # green22 , imgoldnoDashes= allpreSteps(img,1)
+  imgoldnoDashes1=cv2.medianBlur(imgoldnodashes,7)
+  kernel=np.ones((3,3),np.uint8)
+  green3=cv2.erode(green22,kernel, iterations=6)
+  green3=cv2.dilate(green3,kernel, iterations=3)
+  imgoldnoDashes1=cv2.erode(imgoldnoDashes1,kernel, iterations=2)
+  img1Eroded=cv2.dilate(imgoldnoDashes1,kernel, iterations=7) #5
+  diff = ImageChops.difference(Image.fromarray(img1Eroded), Image.fromarray(cv2.bitwise_not(green3)))
+  diff=np.array(diff)
+  diff=cv2.erode(diff,kernel, iterations=4)
+  diff=cv2.dilate(diff,kernel, iterations=11)
+  return diff
+
+
 #OLD method (White shapes)
 def preprocessold(img,number):
-  blurG = cv2.GaussianBlur(ChangeBrightness(img,6),(3,3),0 )
+  blurG = cv2.GaussianBlur(ChangeBrightness(img,8),(3,3),0 )
+  cv2.imwrite('imgold.png', blurG) 
   imgGry = cv2.cvtColor(blurG, cv2.COLOR_BGR2GRAY)
   kernel=np.ones((3,3),np.uint8)
   er1=cv2.dilate(imgGry,kernel, iterations=2) #thinning
@@ -244,21 +381,66 @@ def preprocessold(img,number):
     ret3, thresh = cv2.threshold(er1, 220, 255, cv2.THRESH_BINARY_INV) #`140 - 141
   return thresh
 
-#anding of old method output with solid lines img
-def preprocess(dataDoc,imgtransparent1,img,number,green2,flag,layeredflag,BlackmaskDetected1=0):
-  #first preprocessing ( old method - black img with white shapes)
-  alltxts=[]
+#preprocessing for shapes with arrows (attach them to shape )
+def getTextfromImg(grayimgtextdilated, img,dataDoc):
+  span_df=textDictionaryBlocks(img,dataDoc)
+  threshCnt2, threshHier2 = cv2.findContours(grayimgtextdilated, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+  allshapesExtremes_Text=[]
+  listallTexts=textListsAlltexts(dataDoc,span_df)[1]
+  for cnt in threshCnt2:
+      texts=[]
+      area1 = cv2.contourArea(cnt)
+      if (area1 >2000 ):
+          x, y , width, height = cv2.boundingRect(cnt)
+          perimeter=cv2.arcLength(cnt,True)
+          approx = cv2.approxPolyDP(cnt,  0.01* perimeter, True)
+          for extremePoint in approx:
+            allnearbyPoints,alltxts=nearestText(int(extremePoint[0][0]),int(extremePoint[0][1]),span_df)
+            if(allnearbyPoints!='none'):
+              for nearbypoint in allnearbyPoints:
+                for textTuple in listallTexts:
+                  if nearbypoint[0]==textTuple[0] and nearbypoint[1]==textTuple[1]:
+                      if textTuple[2] not in texts:
+                        texts.append(textTuple[2])
+          allshapesExtremes_Text.append([cnt,texts])
+  # print(allshapesExtremes_Text)
+  ArrthreshCnt=[]
+  for th in range(len(allshapesExtremes_Text)):
+    eachcnt=[]
+    for point in allshapesExtremes_Text[th][0]:
+      eachcnt.append(list(point[0]))
+    ArrthreshCnt.append(eachcnt)
+  return ArrthreshCnt , allshapesExtremes_Text
+
+
+def mergingPreprocessing(img,number,green2,layeredflag,BlackmaskDetected1=0):
+  # diff , imgoldnodashes=getDiff(img)#diff (img with tof leaders)
   img1=preprocessold(img,number)
-  anding=cv2.bitwise_and(green2,green2,mask=img1)
-  anding = cv2.cvtColor(anding, cv2.COLOR_BGR2GRAY)
+ 
+  green2Gray = cv2.cvtColor(green2, cv2.COLOR_BGR2GRAY)
+  anding=cv2.bitwise_and(green2Gray,img1) #and between old and green2 to get perfect shapes with no outer lines
   ret3, thresh2 = cv2.threshold(anding, 0, 255, cv2.THRESH_BINARY  + cv2.THRESH_OTSU)
-
   if layeredflag.startswith('layer'):
      thresh2=cv2.bitwise_and(thresh2,thresh2,mask=BlackmaskDetected1)
   threshcontours, threshHier = cv2.findContours(thresh2, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
-  threshHier= threshHier[0]
+
+  return img1 , threshcontours , thresh2
+
+#anding of old method output with solid lines img
+def preprocess(green22,imgoldnodashes,dataDoc,imgtransparent1,img,number,green2,layeredflag,BlackmaskDetected1=0):
+  #first preprocessing ( old method - black img with white shapes)
+  kernel0=np.ones((2,2),np.uint8)
+  ##first preprocessing ( old method - black img with white shapes)
+  img1,threshcontours,thresh2=mergingPreprocessing(img,number,green2,layeredflag,BlackmaskDetected1)
+  diff =getDiff(img,green22,imgoldnodashes)#diff (img with tof leaders)
+  iddk=cv2.bitwise_or(thresh2,diff)  #add it to preprocessing img of anding
+  iddk=cv2.medianBlur(iddk,5)
+  iddk=cv2.dilate(iddk,kernel0, iterations=2)
+  ArrthreshCnt , texts=getTextfromImg(iddk,img,dataDoc) #getText relations between each contour and its text
   outlinesDotIN=getOutlinesDotIN(img)
-  finalcnts=[]
+  pc_coor,listall=textLists(img,dataDoc)
+  finalcntsP=[]
+  finalcntsA=[]
   perimeters=[]
   openClosedFlag=0
   threshCnt, threshHier2 = cv2.findContours(img1, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
@@ -267,70 +449,72 @@ def preprocess(dataDoc,imgtransparent1,img,number,green2,flag,layeredflag,Blackm
     area1 = cv2.contourArea(cnt)
     if (area1 > 2000 ):
           cv2.drawContours(outlines,[cnt],0,(255,255,255),2)
-  pc_coor, listall=textLists(img,dataDoc)
   perimeter=0
+  shapetxts=[]
   for  cnt in threshcontours:
-    Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+    BlackmaskP = np.zeros(img.shape[:2], dtype="uint8")
+    BlackmaskA=np.zeros(img.shape[:2], dtype="uint8")
     area1 = cv2.contourArea(cnt)
     if (area1 > 2000 ):
         x, y , width, height = cv2.boundingRect(cnt)
-        textPoint=nearestText(int(x+(width/2)), int(y+(height/2)) , pc_coor)
+        #Get contours - Areas , Perimeters
+        kernel=np.ones((2,2),np.uint8)
+
+        cv2.drawContours(BlackmaskP,[cnt],0,(255,255,255), 6)
+        BlackmaskP=cv2.dilate(BlackmaskP,kernel, iterations=1)
+        contoursP, hier1 = cv2.findContours(BlackmaskP, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+        finalcntsP.append(contoursP)
+
+        cv2.drawContours(BlackmaskA,[cnt],0,(255,255,255), 5)
+        BlackmaskA=cv2.erode(BlackmaskA,kernel, iterations=1)
+        contoursA, hier1 = cv2.findContours(BlackmaskA, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+        finalcntsA.append(contoursA)
+
+        textPoint=nearestTextPCCOOR(int(x+(width/2)), int(y+(height/2)) , pc_coor)
         txt=''
         if(textPoint!='none'):
           for textTuple in listall:
             if textPoint[0]==textTuple[0] and textPoint[1]==textTuple[1]:
               txt=textTuple[2]
-              alltxts.append(txt)
+              if "GB" in txt or "RC" in txt or "PC" in txt:
+                shapetxts.append(txt)
         elif textPoint=='none':
-          alltxts.append('none')
-        if flag.startswith('perimeter'):
-          kernel=np.ones((2,2),np.uint8)
-          cv2.drawContours(Blackmask,[cnt],0,(255,255,255), 6)
-          Blackmask=cv2.dilate(Blackmask,kernel, iterations=1)
-          if 'GB' in txt:
-            cBlk,_= cv2.findContours(Blackmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            xcBlk, ycBlk , width, height = cv2.boundingRect(cBlk[0])
-            xx=cv2.bitwise_and(outlines,outlines,mask=Blackmask)
-            xx = cv2.threshold(xx, 250, 255, cv2.THRESH_BINARY)[1]
+          shapetxts.append('none')
+
+        if 'GB' in shapetxts:
+          xcBlk, ycBlk , width, height = cv2.boundingRect(contoursP[0])
+          xx=cv2.bitwise_and(outlines,outlines,mask=BlackmaskP)
+          xx = cv2.threshold(xx, 250, 255, cv2.THRESH_BINARY)[1]
+          cntsx,hierx= cv2.findContours(xx, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+          if len(cntsx)>0:
+            hierx=hierx[0]
+            xx=cv2.bitwise_and(outlinesDotIN,outlinesDotIN,mask=xx)
             cntsx,hierx= cv2.findContours(xx, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
             if len(cntsx)>0:
-              hierx=hierx[0]
-              xx=cv2.bitwise_and(outlinesDotIN,outlinesDotIN,mask=xx)
+              xx=connectsmallDot(xx)
               cntsx,hierx= cv2.findContours(xx, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
               if len(cntsx)>0:
-                xx=connectsmallDot(xx)
-                cntsx,hierx= cv2.findContours(xx, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
-                if len(cntsx)>0:
-                  hierx=hierx[0]
-                  for  comp in zip(cntsx,hierx):
-                    c=comp[0]
-                    h=comp[1]
-                    xc, yc , width, height = cv2.boundingRect(c)
-                    perimeter=cv2.arcLength(c,True)
-                    shape=[]
-                    approx = cv2.approxPolyDP(c,  0.003* perimeter, True)
-                    if h[2]<0 and h[3] <0:
-                      perimeter1 = cv2.arcLength(approx, True)
-                      perimeter=perimeter1/2
-                      # cv2_imshow(xx)
-                      openClosedFlag='open'
-                      imgtransparent1=cv2.polylines(imgtransparent1, [approx], False, (0,255,0), thickness=4,lineType=8)
-
-                      perimeters.append([xc, yc ,xcBlk, ycBlk ,perimeter ,openClosedFlag , txt , approx])
-                    else:
-                      if h[2] >0:
-                        openClosedFlag='closed'
-        if flag.startswith('area'):
-          kernel=np.ones((2,2),np.uint8)
-          cv2.drawContours(Blackmask,[cnt],0,(255,255,255), 5)
-          Blackmask=cv2.erode(Blackmask,kernel, iterations=1)
-          openClosedFlag='none'
-        contours1, hier1 = cv2.findContours(Blackmask, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
-        finalcnts.append(contours1)
-  finalcnts=tuple(finalcnts)
-# ###############
-
-  return finalcnts, perimeters , alltxts , imgtransparent1
+                hierx=hierx[0]
+                for  comp in zip(cntsx,hierx):
+                  c=comp[0]
+                  h=comp[1]
+                  xc, yc , width, height = cv2.boundingRect(c)
+                  perimeter=cv2.arcLength(c,True)
+                  shape=[]
+                  approx = cv2.approxPolyDP(c,  0.003* perimeter, True)
+                  if h[2]<0 and h[3] <0:
+                    perimeter1 = cv2.arcLength(approx, True)
+                    perimeter=perimeter1/2
+                    # cv2_imshow(xx)
+                    openClosedFlag='open'
+                    imgtransparent1=cv2.polylines(imgtransparent1, [approx], False, (0,255,0), thickness=4,lineType=8)
+                    perimeters.append([xc, yc ,xcBlk, ycBlk ,perimeter ,openClosedFlag  , approx])
+                  else:
+                    if h[2] >0:
+                      openClosedFlag='closed'
+
+  return tuple(finalcntsP),tuple(finalcntsA), perimeters , shapetxts , imgtransparent1 ,ArrthreshCnt , texts, iddk
+
 
 """# ROI (levels)
 ## Detect regions with specific color and mask them
@@ -368,7 +552,7 @@ def DetectColor(img,color=0):
   cv2.imwrite('det.png',detectedColors)
   return mask, detectedColors, color
 
-def getinnerColor(BlackmaskDetected,img,detectedColors,finalColorArray,ratioarea,ratioperim,flag,eachcolor):
+def getinnerColor(BlackmaskDetected,img,detectedColors,finalColorArray,ratioarea,ratioperim,eachcolor):
 
   countBlackMasks=0
   xored=detectedColors
@@ -384,34 +568,22 @@ def getinnerColor(BlackmaskDetected,img,detectedColors,finalColorArray,ratioarea
     extrema = pil_image.convert("L").getextrema()
     if extrema != (0, 0): # if image is not black --> has a colored mask within
       cc=detectedColors.copy()
-      # cc1=detectedColorsB.copy()
       ColoredContour, Coloredhierarchy = cv2.findContours(masked, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-      
       for cnt in ColoredContour:
-
         area1 = cv2.contourArea(cnt)
         if (area1 > 1000 ): 
  
             x, y , width, height = cv2.boundingRect(cnt) 
-            # cv2.rectangle(cc, (x,y ), (x+width, y+height), (255,255,255), -1)
-            # cv2.rectangle(Blackmask, (x,y ), (x+width, y+height), 255, -1)
-            #to get rid of the edge of the inner reectangles
             cv2.drawContours(cc,[cnt],0,(255,255,255), 3)  
             cv2.drawContours(Blackmask,[cnt] ,0, (255,255,255), 3) 
-
             cv2.drawContours(cc,[cnt],0,(255,255,255), -1) # (x-5,y-5 ), (x+width, y+height), 
             cv2.drawContours(Blackmask,[cnt] ,0, (255,255,255), -1) #,(x,y ), (x+width, y+height)
-
             cv2.drawContours(BlackmaskDetected,[cnt] ,0, (0,0,0), -1) #,(x,y ), (x+width, y+height)
-
             invertedmask = cv2.bitwise_and(imgc,imgc, mask= Blackmask)
             xored=cc
-             # masked b abyad
       detectedColors=xored 
-
     else: #black mask , no other levels are found  # to check law count == number of colors in array yb2a no more levels and break
       countBlackMasks+=1
-
   return xored,invertedmask , BlackmaskDetected
     
 def allLevelsofColor(BlackmaskDetected,img,levelonly, invertedmask,color,finalColorArray):
@@ -423,9 +595,7 @@ def allLevelsofColor(BlackmaskDetected,img,levelonly, invertedmask,color,finalCo
   Blackmask = np.zeros(img.shape[:2], dtype="uint8")
 
   masked,maskedColor,rgbcolor=DetectColor(invertedmask,color)
-  # color=hexRGB(color)
   color=[color[0],color[1],color[2]]
-  
   rgbcolor=[rgbcolor[0],rgbcolor[1],rgbcolor[2]]
   print(rgbcolor,color)
   pil_image=Image.fromarray(masked)
@@ -451,9 +621,7 @@ def allLevelsofColor(BlackmaskDetected,img,levelonly, invertedmask,color,finalCo
             # get (i, j) positions of all RGB pixels that are black (i.e. [0, 0, 0])
             firstLevel[np.all(firstLevel == (0,0,0), axis=-1)] = (255, 255, 255)
             firstLevel1=cv2.bitwise_and(levelonly,firstLevel)
-            # cv2_imshow(firstLevel1)
 
-            # cv2_imshow(firstLevel1)
             for othercolor in finalColorArray:
               # othercolor2=hexRGB(othercolor)
               othercolor2=[othercolor[0],othercolor[1],othercolor[2]]
@@ -477,7 +645,7 @@ def allLevelsofColor(BlackmaskDetected,img,levelonly, invertedmask,color,finalCo
             # cv2_imshow(Blackmask)
   return firstLevel1, BlackmaskDetected
     
-def getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,flag,eachcolor):
+def getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,eachcolor):
     ColoredContour, Coloredhierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
     Coloredhierarchy=Coloredhierarchy[0]
 
@@ -504,28 +672,28 @@ def getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,flag,eachcol
             if extrema == (0, 0) :#and extremaB==(0,0): # if image is not black --> has a colored mask within
               break
     
-    levelOnly,invertedmask,BlackmaskDetected=getinnerColor(Blackmask,img,detectedColors,finalColorArray,ratioarea,ratioperim,flag,eachcolor) #mask inner levels b abyad 
+    levelOnly,invertedmask,BlackmaskDetected=getinnerColor(Blackmask,img,detectedColors,finalColorArray,ratioarea,ratioperim,eachcolor) #mask inner levels b abyad 
     firstLevel1, BlackmaskDetected1= allLevelsofColor(BlackmaskDetected,img,levelOnly, invertedmask,eachcolor,finalColorArray)
     return firstLevel1,invertedmask, BlackmaskDetected1
 
 """#  contours"""
 
-def findContoursFullImage(dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim,flag,color=[0,0,0]):
+def findContoursFullImage(green22,imgoldnodashes,dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim,color=[0,0,0]):
   if number == 0:
-    contourss, perimeters ,alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,img,number,green2,flag, 'nolayer')
-    return contourss , perimeters, alltxts , imgtransparent1
+    contourssP,contourssA,perimeters,alltxts,imgtransparent1,arrthresh,allshapesExtremes_Text,iddk=preprocess(green22,imgoldnodashes,dataDoc,imgtransparent1,img,number,green2, 'nolayer')
+    return contourssP,contourssA, perimeters ,alltxts , imgtransparent1,arrthresh,allshapesExtremes_Text , iddk
   else:
     mask, detectedColors, rgbcolor =DetectColor(img,color)
     pil_image=Image.fromarray(mask)
     extrema = pil_image.convert("L").getextrema()
     if extrema != (0, 0): # if image is not black --> has a colored mask within
-      coloredregions,invertedmask,BlackmaskDetected1=getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,flag,color)
+      coloredregions,invertedmask,BlackmaskDetected1=getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,color)
                                                                       
-      contourss,perimeters , alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,coloredregions,number,green2,flag,'layer',BlackmaskDetected1)
-      return contourss,rgbcolor ,invertedmask , perimeters , alltxts , imgtransparent1
+      contourssP,contourssA,perimeters,alltxts,imgtransparent1,arrthresh,allshapesExtremes_Text,iddk=preprocess(green22,imgoldnodashes,dataDoc,imgtransparent1,coloredregions,number,green2,'layer',BlackmaskDetected1)
+      return contourssP,contourssA ,rgbcolor ,invertedmask , perimeters , alltxts , imgtransparent1 ,arrthresh,allshapesExtremes_Text , iddk
     else:
-      contourss, perimeters , alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,img,number,green2,flag,'nolayer')
-      return contourss,color ,mask  , perimeters , alltxts
+      contourssP,contourssA ,rgbcolor ,invertedmask , perimeters , alltxts , imgtransparent1 ,arrthresh,allshapesExtremes_Text , iddk=preprocess(green22,imgoldnodashes,dataDoc,imgtransparent1,img,number,green2,'nolayer')
+      return contourssP,contourssA,color ,mask  , perimeters , alltxts,imgtransparent1,arrthresh,allshapesExtremes_Text , iddk
 
 #Straighten tilted shapes
 def StraightenImage(contour,imgArea):
@@ -539,18 +707,18 @@ def StraightenImage(contour,imgArea):
     return angleR,width,height
 
 #get all areas and perimeter present
-def getAreasPerimeter(img,ratioarea,ratioperim,contourss,contourssA):
+def getAreasPerimeter(img,ratioarea,ratioperim,contourssP,contourssA):
   appended=[]
-  for contour in range(len(contourss)):
-    area1 = cv2.contourArea(contourss[contour][0])
+  for contour in range(len(contourssP)):
+    area1 = cv2.contourArea(contourssP[contour][0])
     if (area1 >2000 ):
-      perimeter= cv2.arcLength(contourss[contour][0],True)
-      approx = cv2.approxPolyDP(contourss[contour][0], 0.01* perimeter, True)
+      perimeter= cv2.arcLength(contourssP[contour][0],True)
+      approx = cv2.approxPolyDP(contourssP[contour][0], 0.01* perimeter, True)
       perimeter1 = cv2.arcLength(approx, True)
       approx = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
       area1 = cv2.contourArea(approx)
-      x, y , width, height = cv2.boundingRect(contourss[contour][0])
-      angleR,widthR ,heightR= StraightenImage(contourss[contour][0],img)
+      x, y , width, height = cv2.boundingRect(contourssP[contour][0])
+      angleR,widthR ,heightR= StraightenImage(contourssP[contour][0],img)
 
       if (angleR != 90.0 and angleR != -90.0 and angleR != 0.0 and angleR != -0.0 ): #inclined b ay degree
           width=widthR
@@ -561,9 +729,9 @@ def getAreasPerimeter(img,ratioarea,ratioperim,contourss,contourssA):
             appended.append([areaa,width,height])
   return appended
 #fill dictionary with areas and perimeters and occurences
-def FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourss,contourssA,rgbcolor=[0,0,0],color=[0,0,0]):
+def FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourssP,contourssA,rgbcolor=[0,0,0],color=[0,0,0]):
   #fills dictionary with key areas and number of occurences
-  areas_Perimeters=sorted(getAreasPerimeter(img,ratioarea,ratioperim,contourss,contourssA))
+  areas_Perimeters=sorted(getAreasPerimeter(img,ratioarea,ratioperim,contourssP,contourssA))
 
   indices=[]
   colorRanges=[[255,0,0],[0,0,255],[0,255,255],[0,64,0],[255,204,0],[255,128,64],[255,0,128],[255,128,192],[128,128,255],[128,64,0],[0,255,0],[179,106,179],[115,52,179],[0,128,192],[128,0,128],[128,0,0],[0,128,255],[255,182,128],[255,0,255],[0,0,128],[0,128,64],[255,255,0],[128,0,64],[203,203,106],[128,255,166],[255,128,0],[255,98,98],[90,105,138],[114,10,72],[36,82,78],[225,105,29],[108,62,40],[11,35,75],[42,176,203],[255,153,153],[129,74,138],[99,123,137],[159,179,30],[255,0,0],[0,0,255],[0,255,255],[0,64,0],[255,204,0],[255,128,64],[255,0,128],[255,128,192],[128,128,255],[128,64,0],[0,255,0],[179,106,179],[115,52,179],[0,128,192],[128,0,128],[128,0,0],[0,128,255],[255,182,128],[255,0,255],[0,0,128],[0,128,64],[255,255,0],[128,0,64],[203,203,106],[128,255,166],[255,128,0],[255,98,98],[90,105,138],[114,10,72],[36,82,78],[225,105,29],[108,62,40],[11,35,75],[42,176,203],[255,153,153],[129,74,138],[99,123,137],[159,179,30]]
@@ -582,9 +750,9 @@ def FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourss,cont
       areaPerimeterMax= round(item1,1) + 0.4
       # print (areaMin, areaMax)
       if color != [0,0,0]: #colored images
-        mydata=[[],[rgbcolor[0],rgbcolor[1],rgbcolor[2] ],round(item1,1),width1,height1,1, 0,0,0,0,0,0,0,0,0]
+        mydata=[[],[rgbcolor[0],rgbcolor[1],rgbcolor[2] ],round(item1,1),width1,height1,1, 0,0,0,0,0,0,'',0,0,0]
       else:
-          mydata=[[],' ', round(item1,1),width1,height1,1, 0,0,0,0,0,0,0,0,0]
+          mydata=[[],' ', round(item1,1),width1,height1,1, 0,0,0,0,0,0,'',0,0,0]
       myindex= SimilarAreaDictionary.index[((SimilarAreaDictionary['Rounded'] >=areaPerimeterMin) &(SimilarAreaDictionary['Rounded']<=areaPerimeterMax)  )].tolist()
       if color!= [0,0,0]: #leveled image
         checkifColorExists=0 # to check whether this row was found or not( area and color )
@@ -614,8 +782,9 @@ def FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourss,cont
 
   return SimilarAreaDictionary, colorsUsed , areas_Perimeters
 #detect and draw and measure
-def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag , path,pdfpath):
+def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim , path,pdfpath):
   green2=allpreSteps(img)
+  green22,imgoldnodashes=allpreSteps(img,num=1)
   doc = fitz.open("pdf",dataDoc)
   page = doc[0]
   rotationOld=page.rotation
@@ -632,33 +801,44 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
   imgtransparent1=img.copy()
 
   if number ==220:
-    SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
-    firstcolor=finalColorArray[0]
-    counter=0
+    SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','Texts','R','G','B'])
+    # firstcolor=finalColorArray[0]
+    # counter=0
     maskDone=img.copy()
     for eachcolor in finalColorArray:
-
-      contourss,rgbcolor,invertedmask , perimeters , alltxts,imgtransparent1=findContoursFullImage(dataDoc,imgtransparent1,green2,maskDone,number,finalColorArray,ratioarea,ratioperim,'perimeter',eachcolor)
-      contourssA,rgbcolor,invertedmask, perimeters , alltxts,imgtransparent1=findContoursFullImage(dataDoc,imgtransparent1,green2,maskDone,number,finalColorArray,ratioarea,ratioperim,'area',eachcolor)
-
-      SimilarAreaDictionary, colorsUsed , areas_Perimeters= FillDictionary(SimilarAreaDictionary,maskDone,ratioarea,ratioperim,contourss,contourssA,rgbcolor,eachcolor)
+      contourssP,contourssA,rgbcolor,invertedmask , perimeters , alltxts,imgtransparent1 , ArrthreshCnt ,allshapesExtremes_Text, green22Gry=findContoursFullImage(green22,imgoldnodashes,dataDoc,imgtransparent1,green2,maskDone,number,finalColorArray,ratioarea,ratioperim,eachcolor)
+      SimilarAreaDictionary, colorsUsed , areas_Perimeters= FillDictionary(SimilarAreaDictionary,maskDone,ratioarea,ratioperim,contourssP,contourssA,rgbcolor,eachcolor)
       perimTotal=0       
-      for contour in range(len(contourss)):
+      for contour in range(len(contourssP)):
           shape=[]
-          
-          # cv2_imshow(imgStraight)
           area1 = cv2.contourArea(contourssA[contour][0])
-          
-          # perimeter1 = cv2.arcLength(contourss[contour][0], True)  
           if (area1 > 3500 ): #check perimeter kman fl condition  -- 2800
-            perimeter=cv2.arcLength(contourss[contour][0],True)
+            perimeter=cv2.arcLength(contourssP[contour][0],True)
             shape=[]
-            angleR,widthR ,heightR= StraightenImage(contourss[contour][0],imgArea1)
-            x, y , width, height = cv2.boundingRect(contourss[contour][0])
+            angleR,widthR ,heightR= StraightenImage(contourssP[contour][0],imgArea1)
+            x, y , width, height = cv2.boundingRect(contourssP[contour][0])
+            
+            Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+            Blackmask = cv2.rectangle(Blackmask, (int(x-10),int(y-10)), (int(x+width+10),int(y+height+10)), (255, 255, 255), -1)
+            Blackmask=cv2.bitwise_and(green22Gry,green22Gry,mask=Blackmask)
+            BlackmaskCnt,_= cv2.findContours(Blackmask, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+            areas = [cv2.contourArea(c) for c in BlackmaskCnt]
+            if len(areas)>0:
+              max_index = np.argmax(areas)
+              blackcnt=BlackmaskCnt[max_index]
+              blackcnt=tuple(blackcnt)
+              texts=''
+              for th in range(len(ArrthreshCnt)):
+                for e in blackcnt:
+                  if list(e[0]) in ArrthreshCnt[th]:
+                    texts=allshapesExtremes_Text[th][1]
+                    break
+                if len(texts)>0:
+                    break
+            
             approxA = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
             area1 = cv2.contourArea(approxA)
-
-            approx = cv2.approxPolyDP(contourss[contour][0], 0.01 * perimeter, True) #0.0009
+            approx = cv2.approxPolyDP(contourssP[contour][0], 0.01 * perimeter, True) #0.0009
             perimeter1 = cv2.arcLength(approx, True)
             for point in approxA:
                   x1, y1 = point[0]
@@ -693,9 +873,14 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
               if passed ==0:
                 if SimilarAreaDictionary['Color'].loc[i] == [rgbcolor[0],rgbcolor[1],rgbcolor[2]]  and   (   SimilarAreaDictionary['Rounded'].loc[i]  <= areaPerimeterMax and SimilarAreaDictionary['Rounded'].loc[i]  >= areaPerimeterMin) :
                     if (SimilarAreaDictionary['Width'].loc[i] <=widthMax and SimilarAreaDictionary['Width'].loc[i] >= widthMin)  and (SimilarAreaDictionary['Height'].loc[i] <= heightMax  and SimilarAreaDictionary['Height'].loc[i] >= heightMin  ) or (SimilarAreaDictionary['Width'].loc[i] <=heightMax and SimilarAreaDictionary['Width'].loc[i] >= heightMin)  and (SimilarAreaDictionary['Height'].loc[i] <= widthMax  and SimilarAreaDictionary['Height'].loc[i] >= widthMin  ) :
+                      SimilarAreaDictionary['Guess'].loc[i].append(str(alltxts[contour]))
+                      for t in texts:
+                        if "GB" not in t or "RC" not in t or "PC" not in t:
+                          if t not in SimilarAreaDictionary['Texts'].loc[i]:
+                            SimilarAreaDictionary['Texts'].loc[i]+=' '+t
                       SimilarAreaDictionary['Total Area'].loc[i]+=areaa
                       SimilarAreaDictionary['Area'].loc[i]=areaa
-                      SimilarAreaDictionary['Guess'].loc[i].append(str(alltxts[contour]))
+                      
                       pFlagDF=0
                       color= (int(SimilarAreaDictionary['R'].loc[i])/255 ,  int(SimilarAreaDictionary['G'].loc[i])/255 ,  int(SimilarAreaDictionary['B'].loc[i])/255 )
 
@@ -731,7 +916,7 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
                       SimilarAreaDictionary['Length'].loc[i]=lengthShape
 
                       passed=1
-                      cv2.drawContours(imgArea1, [contourss[contour][0]], 0, ( int(SimilarAreaDictionary['B'].loc[i]),  int(SimilarAreaDictionary['G'].loc[i]), int(SimilarAreaDictionary['R'].loc[i])), -1)
+                      cv2.drawContours(imgArea1, [contourssP[contour][0]], 0, ( int(SimilarAreaDictionary['B'].loc[i]),  int(SimilarAreaDictionary['G'].loc[i]), int(SimilarAreaDictionary['R'].loc[i])), -1)
                       annot = page.add_polygon_annot( points=shape)  # 'Polygon'
                       annot.set_border(width=0.2)
                       annot.set_colors(stroke=color, fill= color )
@@ -755,23 +940,43 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
   #########################
   else:
     
-    SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
-    contourss , perimeters , alltxts , imgtransparent1=findContoursFullImage(dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim,'perimeter')
-    contourssA , perimetersA , alltxts , imgtransparent1=findContoursFullImage(dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim,'area')
-    SimilarAreaDictionary,colorsUsed , areas_Perimeters= FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourss,contourssA)
+    SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','Texts','R','G','B'])
+    contourssP,contourssA , perimeters , alltxts , imgtransparent1 , ArrthreshCnt ,allshapesExtremes_Text, green22Gry=findContoursFullImage(green22,imgoldnodashes,dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim)
+    SimilarAreaDictionary,colorsUsed , areas_Perimeters= FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourssP,contourssA)
 
-    for contour in range(len(contourss)):
+    for contour in range(len(contourssP)):
       area1 = cv2.contourArea(contourssA[contour][0])
       if (area1 >4000 ):
-        perimeter=cv2.arcLength(contourss[contour][0],True)
+        perimeter=cv2.arcLength(contourssP[contour][0],True)
 
 
         shape=[]
-        angleR,widthR ,heightR= StraightenImage(contourss[contour][0],imgArea1)
-        x, y , width, height = cv2.boundingRect(contourss[contour][0])
+        angleR,widthR ,heightR= StraightenImage(contourssP[contour][0],imgArea1)
+        x, y , width, height = cv2.boundingRect(contourssP[contour][0])
+        
+        Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+        Blackmask = cv2.rectangle(Blackmask, (int(x-10),int(y-10)), (int(x+width+10),int(y+height+10)), (255, 255, 255), -1)
+        Blackmask=cv2.bitwise_and(green22Gry,green22Gry,mask=Blackmask)
+        BlackmaskCnt,_= cv2.findContours(Blackmask, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+        areas = [cv2.contourArea(c) for c in BlackmaskCnt]
+        if len(areas)>0:
+          max_index = np.argmax(areas)
+          blackcnt=BlackmaskCnt[max_index]
+          blackcnt=tuple(blackcnt)
+          texts=''
+          # textsMid=''
+          for th in range(len(ArrthreshCnt)):
+            for e in blackcnt:
+              if list(e[0]) in ArrthreshCnt[th]:
+                texts=allshapesExtremes_Text[th][1]
+                # textsMid=allshapesExtremes_Text[th][2]
+                break
+            if len(texts)>0:
+                break
+            # print(texts)
         approxA = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
         area1 = cv2.contourArea(approxA)
-        approx = cv2.approxPolyDP(contourss[contour][0], 0.01 * perimeter, True) #0.0009
+        approx = cv2.approxPolyDP(contourssP[contour][0], 0.01 * perimeter, True) #0.0009
         perimeter1 = cv2.arcLength(approx, True)
         for point in approxA:
             x1, y1 = point[0]
@@ -805,9 +1010,14 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
           if passed ==0:
             if (   SimilarAreaDictionary['Rounded'].loc[i]  <= areaPerimeterMax and SimilarAreaDictionary['Rounded'].loc[i]  >= areaPerimeterMin) :
               if (SimilarAreaDictionary['Width'].loc[i] <=widthMax and SimilarAreaDictionary['Width'].loc[i] >= widthMin)  and (SimilarAreaDictionary['Height'].loc[i] <= heightMax  and SimilarAreaDictionary['Height'].loc[i] >= heightMin  ) or (SimilarAreaDictionary['Width'].loc[i] <=heightMax and SimilarAreaDictionary['Width'].loc[i] >= heightMin)  and (SimilarAreaDictionary['Height'].loc[i] <= widthMax  and SimilarAreaDictionary['Height'].loc[i] >= widthMin  ) :
+                    SimilarAreaDictionary['Guess'].loc[i].append(str(alltxts[contour]))
+                    for t in texts:
+                      if "GB" not in t or "RC" not in t or "PC" not in t:
+                        if t not in SimilarAreaDictionary['Texts'].loc[i]:
+                          SimilarAreaDictionary['Texts'].loc[i]+=' '+t
                     SimilarAreaDictionary['Total Area'].loc[i]+=areaa
                     SimilarAreaDictionary['Area'].loc[i]=areaa
-                    SimilarAreaDictionary['Guess'].loc[i].append(str(alltxts[contour]))
+                    
                     pFlagDF=0
                     color= (int(SimilarAreaDictionary['R'].loc[i])/255 ,  int(SimilarAreaDictionary['G'].loc[i])/255 ,  int(SimilarAreaDictionary['B'].loc[i])/255 )
 
@@ -842,7 +1052,7 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
                     SimilarAreaDictionary['Length'].loc[i]=lengthShape
 
                     passed=1
-                    cv2.drawContours(imgArea1, [contourss[contour][0]], 0, ( int(SimilarAreaDictionary['B'].loc[i]),  int(SimilarAreaDictionary['G'].loc[i]), int(SimilarAreaDictionary['R'].loc[i])), -1)
+                    cv2.drawContours(imgArea1, [contourssP[contour][0]], 0, ( int(SimilarAreaDictionary['B'].loc[i]),  int(SimilarAreaDictionary['G'].loc[i]), int(SimilarAreaDictionary['R'].loc[i])), -1)
                     annot = page.add_polygon_annot( points=shape)  # 'Polygon'
                     annot.set_border(width=0.2)
                     annot.set_colors(stroke=color, fill= color )
@@ -851,7 +1061,7 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
                     # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
                     annot.update()
         
-        cv2.putText(imgtransparent1,'Area: '+str(areaa) +' m2', (x+50,y-10) ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+        cv2.putText(imgtransparent1,'Area: '+str(areaa) +' '+str(alltxts[contour])+' m2', (x+50,y-10) ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
         pFlag=0
 
         for p in perimeters:
@@ -1114,7 +1324,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
               'startRowIndex': 0,
               'endRowIndex': 1,
               'startColumnIndex': 0,
-              'endColumnIndex':9
+              'endColumnIndex':10
           }
           
       }}
@@ -1129,6 +1339,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
     worksheet.cell((2,4)).value='Areas'
     worksheet.cell((2,6)).value='Perimeters'
     worksheet.cell((2,8)).value='Lengths'
+    worksheet.cell((2,10)).value='Texts'
     second_row_data=['Nr','m2','Total','m','Total','m','Total']
     if splittedpdfpath[-2].startswith('1.0') or  splittedpdfpath[-2].startswith('3.2'):
       worksheet.update_row(3,second_row_data,col_offset=2)
@@ -1141,6 +1352,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
     
       worksheet.update_col(8,list(SimilarAreaDictionary['Length']),row_offset=3)
       worksheet.update_col(9,list(SimilarAreaDictionary['Total Length']),row_offset=3)
+      worksheet.update_col(10,list(SimilarAreaDictionary['Texts']),row_offset=3)
       if splittedpdfpath[-2].startswith('1.0'):
         colorsUsed=[]
         for i in range(len(SimilarAreaDictionary)):
@@ -1159,6 +1371,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
     lastUsedCol=columnsLen+1
   
     worksheet.adjust_column_width(start=2,end=3)
+    worksheet.adjust_column_width(start=10,end=10)
     # if splittedpdfpath[-2].startswith('1.0'):
     worksheet.adjust_column_width(start=4,end=9,pixel_size=60)
     startrow = 3
@@ -1213,11 +1426,8 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
       }
       res =  spreadsheet_service.spreadsheets().batchUpdate(spreadsheetId=spreadsheetId, body=body).execute()
     # if splittedpdfpath[-2].startswith('1.0'):
-    endColindex=9
+    endColindex=10
     endrow=3
-    # elif splittedpdfpath[-2].startswith('3.2'):
-    #   endColindex=3
-    #   endrow=2
     body2={
     "requests": [
       {
@@ -1293,7 +1503,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
     model_cell.set_text_format('bold', True)
     model_cell.set_horizontal_alignment( pygsheets.custom_types.HorizontalAlignment.CENTER )
     model_cell.color  = (213/255,	219/255	,255/255)
-    pygsheets.DataRange('A2','I2', worksheet=worksheet).apply_format(model_cell)
+    pygsheets.DataRange('A2','J2', worksheet=worksheet).apply_format(model_cell)
   spreadsheet_url = "https://docs.google.com/spreadsheets/d/%s" % spreadsheetId
   print(spreadsheet_url)
   drive_service.permissions().update(transferOwnership=True , fileId=spreadsheetId,permissionId='11OfoB4Z6wOVII8mYmbnCbbqTQs7rYA65')