Update pilecaps_adr.py

pilecaps_adr.py

@@ -22,6 +22,27 @@ import db
 import ast
 import Dropbox_TSA_API
 import tsadropboxretrieval
+from collections import Counter
+
+def textLists(img,dataDoc):
+  allTexts = texts_from_pdf(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]
+  listall=[]
+  pc_coor = []
+  for tpl in allTexts:
+    if "GB" in tpl[4] or "RC" in tpl[4] or "PC" in tpl[4]:
+      p1 = fitz.Point((tpl[2]/ratio),(tpl[3]/ratio))
+      if page.rotation==0:
+        p1=p1*page.derotation_matrix
+      pc_coor.append((p1[0],p1[1]))
+      listall.append((p1[0],p1[1],tpl[4]))
+  return pc_coor, listall
+
 #Prepare preprocessing
 def detectCircles(imgOriginal ):
   im=imgOriginal.copy()
@@ -62,10 +83,8 @@ def detectSmallCircles(img ):
     #DRAW CIRCLES
       for (x, y, r) in detected_circles:
         cv2.circle(im, (x, y), r+3, (255, 255, 255), -1)
-  # cv2_imshow(im)
   return im
 
-
 def DashedPreprocessing(imgOriginal,imgnoSmall):
   h,w=imgOriginal.shape[0:2]
   #remove the gray contours from the plan
@@ -94,17 +113,12 @@ def DashedPreprocessing(imgOriginal,imgnoSmall):
   return img4, imgBW, max,min
 
 def removeDashedLines(img4, imgBW ,max,min):
-
   imgLines= cv2.HoughLinesP(img4,1,np.pi/310,30,minLineLength=(max-min)//1.8,maxLineGap = 120)  #was w-h , gap=150 0.99
-#1 120
-
   for i in range(len(imgLines)):
       for x1,y1,x2,y2 in imgLines[i]:
             cv2.line(imgBW,(x1,y1),(x2,y2),(0,255,0),3)
-
   im_copy=imgBW.copy()
   green=im_copy[:,:,1]
-  # cv2_imshow(im_copy)
   return green
 
 def removeSmallDashes(imgOriginal,green):
@@ -143,20 +157,15 @@ def euclidian_distance(point1, point2):
     return sum([(point1[x] - point2[x]) ** 2 for x in range(len(point1))]) ** 0.5
 
 def removeDashedLinesSmall(img4, imgBW ,max,min):
-
   imgBW=cv2.cvtColor(imgBW,cv2.COLOR_GRAY2BGR)
   imgLines= cv2.HoughLinesP(img4,1,np.pi/100,20,minLineLength=(max-min)//3.5,maxLineGap = 70)  #2.1
-
   for i in range(len(imgLines)):
       for x1,y1,x2,y2 in imgLines[i]:
            dist=euclidian_distance((x1,y1), (x2,y2))
-          #  if dist > 1300 and dist <1450:
            if dist >= (max-min)//2.3 and dist < (max-min)//1.9: #1.4
               cv2.line(imgBW,(x1,y1),(x2,y2),(0,255,0),3)
-
   im_copy=imgBW.copy()
   green=im_copy[:,:,1]
-  # cv2_imshow(im_copy)
   return green
 
 def ConnectBeamLines(smalldashesOut):
@@ -180,51 +189,148 @@ def allpreSteps(imgOriginal):
   # cv2_imshow(green2)
   return green2
 
+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):
+  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
+    return nearest_point
+  else:
+    return 'none'
+  
 def ChangeBrightness(img,k):
   imgdarker = 255 * (img/255)**k # k>1 darker , k <1 lighter
   imgdarker = imgdarker.astype('uint8')
   return imgdarker
+
+def getOutlinesDotIN(img):
+  cc=detectSmallCircles(img)
+  cc = cv2.cvtColor(cc, cv2.COLOR_BGR2GRAY)
+  kernel=np.ones((3,3),np.uint8)
+  er1=cv2.dilate(cc,kernel, iterations=2) #thinning
+  blurG = ChangeBrightness(er1,10)
+  ret3, thresh = cv2.threshold(blurG, 0, 255, cv2.THRESH_BINARY_INV  + cv2.THRESH_OTSU)
+  threshCnt, threshHier2 = cv2.findContours(thresh, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+  outlinesDotIN = np.zeros(img.shape[:2], dtype="uint8")
+  for cnt in threshCnt:
+    area1 = cv2.contourArea(cnt)
+    if (area1 > 2000 ):
+          cv2.drawContours(outlinesDotIN,[cnt],0,(255,255,255),2)
+  return outlinesDotIN
+
+def connectsmallDot(blackwithNoDot):
+  imgLines= cv2.HoughLinesP(blackwithNoDot,0.05,np.pi/180,8,minLineLength=30,maxLineGap = 30)  #was w-h , gap=150  #50
+  for i in range(len(imgLines)):
+      for x1,y1,x2,y2 in imgLines[i]:
+          cv2.line(blackwithNoDot,(x1,y1),(x2,y2),(255,255,255),2)
+  return blackwithNoDot
 #OLD method (White shapes)
 def preprocessold(img,number):
-  blurG = ChangeBrightness(img,3)
+  blurG = cv2.GaussianBlur(ChangeBrightness(img,6),(3,3),0 )
   imgGry = cv2.cvtColor(blurG, cv2.COLOR_BGR2GRAY)
-  kernel1=np.ones((3,3),np.uint8)
-  er1=cv2.dilate(imgGry,kernel1, iterations=1) #thinning
-  kernel2=np.ones((2,2),np.uint8)
-  er1=cv2.dilate(er1,kernel2, iterations=1) #thicken
-  ret3, thresh = cv2.threshold(er1, 254, 255, cv2.THRESH_BINARY_INV  )
-  thresh=cv2.medianBlur(thresh,5)
+  kernel=np.ones((3,3),np.uint8)
+  er1=cv2.dilate(imgGry,kernel, iterations=2) #thinning
+  if number == 0:
+    ret3, thresh = cv2.threshold(er1, 0, 255, cv2.THRESH_BINARY_INV  + cv2.THRESH_OTSU)
+  else:
+    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(imgOriginal,number,green2,flag,layeredflag,BlackmaskDetected1=0):
+def preprocess(dataDoc,imgtransparent1,img,number,green2,flag,layeredflag,BlackmaskDetected1=0):
   #first preprocessing ( old method - black img with white shapes)
-  img1=preprocessold(imgOriginal,number)
+  alltxts=[]
+  img1=preprocessold(img,number)
   anding=cv2.bitwise_and(green2,green2,mask=img1)
   anding = cv2.cvtColor(anding, cv2.COLOR_BGR2GRAY)
   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]
+  outlinesDotIN=getOutlinesDotIN(img)
   finalcnts=[]
-  BlackmaskALL = np.zeros(imgOriginal.shape[:2], dtype="uint8")
-  for cnt in threshcontours:
-    Blackmask = np.zeros(imgOriginal.shape[:2], dtype="uint8")
+  perimeters=[]
+  openClosedFlag=0
+  threshCnt, threshHier2 = cv2.findContours(img1, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+  outlines = np.zeros(img.shape[:2], dtype="uint8")
+  for cnt in threshCnt:
+    area1 = cv2.contourArea(cnt)
+    if (area1 > 2000 ):
+          cv2.drawContours(outlines,[cnt],0,(255,255,255),2)
+  pc_coor, listall=textLists(img,dataDoc)
+  perimeter=0
+  for  cnt in threshcontours:
+    Blackmask = 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)
+        txt=''
+        if(textPoint!='none'):
+          for textTuple in listall:
+            if textPoint[0]==textTuple[0] and textPoint[1]==textTuple[1]:
+              txt=textTuple[2]
+              alltxts.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), 7)
+          cv2.drawContours(Blackmask,[cnt],0,(255,255,255), 6)
           Blackmask=cv2.dilate(Blackmask,kernel, iterations=1)
-        elif flag.startswith('area'):
+          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]
+            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:
+                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), 4)
-          Blackmask=cv2.dilate(Blackmask,kernel, iterations=1)
+          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
+# ###############
+
+  return finalcnts, perimeters , alltxts , imgtransparent1
 
 """# ROI (levels)
 ## Detect regions with specific color and mask them
@@ -404,201 +510,139 @@ def getColoredContour(mask,img,finalColorArray,ratioarea,ratioperim,flag,eachcol
 
 """#  contours"""
 
-def findContoursFullImage(green2,img,number,finalColorArray,ratioarea,ratioperim,flag,color=[0,0,0]):
+def findContoursFullImage(dataDoc,imgtransparent1,green2,img,number,finalColorArray,ratioarea,ratioperim,flag,color=[0,0,0]):
   if number == 0:
-    contourss=preprocess(img,number,green2,flag,'nolayer')
-
-    # contourss, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    return contourss
+    contourss, perimeters ,alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,img,number,green2,flag, 'nolayer')
+    return contourss , perimeters, alltxts , imgtransparent1
   else:
     mask, detectedColors, rgbcolor =DetectColor(img,color)
-    # print(rgbcolor)
-    
     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)
-      contourss=preprocess(coloredregions,number,green2,flag,'layer',BlackmaskDetected1)
-      return contourss,rgbcolor ,invertedmask 
-
+                                                                      
+      contourss,perimeters , alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,coloredregions,number,green2,flag,'layer',BlackmaskDetected1)
+      return contourss,rgbcolor ,invertedmask , perimeters , alltxts , imgtransparent1
     else:
-      contourss=preprocess(img,number,green2,flag,'nolayer')
-
-      return contourss,color ,mask
+      contourss, perimeters , alltxts , imgtransparent1=preprocess(dataDoc,imgtransparent1,img,number,green2,flag,'nolayer')
+      return contourss,color ,mask  , perimeters , alltxts
 
 #Straighten tilted shapes
 def StraightenImage(contour,imgArea):
     rect = cv2.minAreaRect(contour)
-    
     (center, (width, height), angleR) = cv2.minAreaRect(contour)
-    
     box = cv2.boxPoints(rect)
     box = np.int0(box)
-
     # get width and height of the detected rectangle
     width = int(rect[1][0])
     height = int(rect[1][1])
-
-    # src_pts = box.astype("float32")
-    # dst_pts = np.array([[0, height-1],
-    #                       [0, 0],
-    #                       [width-1, 0],
-    #                       [width-1, height-1]], dtype="float32")
-
-    #   # the perspective transformation matrix
-    # M = cv2.getPerspectiveTransform(src_pts, dst_pts)
-
-    # # directly warp the rotated rectangle to get the straightened rectangle
-
-    # warped = cv2.warpPerspective(imgArea, M, (width, height))
-    ##############  
     return angleR,width,height
+
 #get all areas and perimeter present
-def getAreasPerimeter(green2,img,number,ratioarea,ratioperim,flag,finalColorArray,color=[0,0,0]):
+def getAreasPerimeter(img,ratioarea,ratioperim,contourss,contourssA):
   appended=[]
-  if number==0:
-    contourss=findContoursFullImage(green2,img,number,finalColorArray,ratioarea,ratioperim,flag,color)
-  else:
-    contourss=findContoursFullImage(green2,img,number,finalColorArray,ratioarea,ratioperim,flag,color)[0]
-
   for contour in range(len(contourss)):
-      #   imgArea1=img.copy()
-      area1 = cv2.contourArea(contourss[contour][0])
-      if (area1 >3500 ):
-        perimeter = cv2.arcLength(contourss[contour][0],True)
-        approx = cv2.approxPolyDP(contourss[contour][0], 0.007* perimeter, True)
-        perimeter1 = cv2.arcLength(approx, True)
-        # approx = cv2.approxPolyDP(contourss[contour][0], 0.01* perimeter, True)
-        # area1 = cv2.contourArea(approx)
-        x, y , width, height = cv2.boundingRect(contourss[contour][0])
-
-        angleR,widthR ,heightR= StraightenImage(contourss[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
-            height=heightR
-        if (area1 > 3500 ): #check perimeter kman fl condition  -- 2800
-          # print('areass')
-          if ratioarea!=0 and ratioperim!=0:
-            # print('numss')
-            # if flag=='area':
-              # addedMargin=area1+perimeter1*2
-              areaa=round(area1* ratioarea,3)# true value of area of any shape/ area px value of same shape
-              appended.append([areaa,width,height])
-
-        #else:
-          #perimeter=round(perimeter1*(ratioarea/ratioperim),3)
-          #appended.append([perimeter,width,height])
-
+    area1 = cv2.contourArea(contourss[contour][0])
+    if (area1 >2000 ):
+      perimeter= cv2.arcLength(contourss[contour][0],True)
+      approx = cv2.approxPolyDP(contourss[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)
+
+      if (angleR != 90.0 and angleR != -90.0 and angleR != 0.0 and angleR != -0.0 ): #inclined b ay degree
+          width=widthR
+          height=heightR
+      if (area1 > 2000 ): #check perimeter kman fl condition  -- 2800
+        if ratioarea!=0 and ratioperim!=0:
+            areaa=round(area1* ratioarea , 2) # true value of area of any shape/ area px value of same shape
+            appended.append([areaa,width,height])
   return appended
 #fill dictionary with areas and perimeters and occurences
-def FillDictionary(green2,SimilarAreaDictionary,img,number,ratioarea,ratioperim,flag,finalColorArray,rgbcolor=[0,0,0],color=[0,0,0]):
+def FillDictionary(SimilarAreaDictionary,img,ratioarea,ratioperim,contourss,contourssA,rgbcolor=[0,0,0],color=[0,0,0]):
   #fills dictionary with key areas and number of occurences
-  areas_Perimeters=sorted(getAreasPerimeter(green2,img,number,ratioarea,ratioperim,flag,finalColorArray,color) )
-  
+  areas_Perimeters=sorted(getAreasPerimeter(img,ratioarea,ratioperim,contourss,contourssA))
+
   indices=[]
-  # colorRanges=[[255,153,153],[51,255,51],[201,56,147],[255,0,0],[255,0,255],[0,102,204],[102,0,102],[153,0,76],[200,92,135],[52,161,99],[235,250,24],[40,30,170],[98,149,63],[100,30,179],[200,55,67],[150,80,200],[0,102,102],[250,28,191],[101,27,101],[230,150,76],[3,65,127],[114,39,39],[250,36,100],[180,30,40],[10,250,60],[140,30,253],[114,58,245],[47,255,255],[18,236,206],[225,105,29],[189,65,121],[206,204,48],[126,7,247],[3,168,251]]
-  
-  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]]
-  # print(colorRanges[0])
-  # print(colorRanges[0][0],colorRanges[0][1], colorRanges[0][2])
+  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]]
   colorsUsed=[]
   for i in range(len(areas_Perimeters)):
-     
+
       # colorRGB=hexRGB(color)
       item1 = areas_Perimeters[i][0]
       width1 = areas_Perimeters[i][1]
       height1 = areas_Perimeters[i][2]
-      widthMin= width1-10
-      widthMax= width1+10
-      heightMin=height1-10
-      heightMax= height1+10
-      areaPerimeterMin= round(item1,1) - 0.2
-      areaPerimeterMax= round(item1,1) + 0.2
+      widthMin= width1-15
+      widthMax= width1+15
+      heightMin=height1-15
+      heightMax= height1+15
+      areaPerimeterMin= round(item1,1) - 0.4
+      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=[round(item1,1),width1,height1,0, 1,0,[rgbcolor[0],rgbcolor[1],rgbcolor[2] ],colorRanges[0][2],colorRanges[0][1],colorRanges[0][0]] 
-        # colorRanges.pop(0)
+      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]
       else:
-          # print('??')
-          
-          mydata=[' ', round(item1,1),width1,height1,1, 0,0,0,0,0,0,0,0,0] 
-
-      # if (( round(item1,1)  in SimilarAreaDictionary['Rounded'].values) or (areaMin in  SimilarAreaDictionary['Rounded'].values )or (areaMax in SimilarAreaDictionary['Rounded'].values )):
-      
-        # myindex= SimilarAreaDictionary.index[( SimilarAreaDictionary['Rounded']== round(item1,1) ) ].tolist()
+          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()
-           # for i in myindex:
-      #   SimilarAreaDictionary['Rounded'].loc[i]
       if color!= [0,0,0]: #leveled image
-
         checkifColorExists=0 # to check whether this row was found or not( area and color )
         for i in myindex: # loop on indices that were found --> rows containing this area to check its color and add occ.
-          if SimilarAreaDictionary['Color'].loc[i]==[rgbcolor[0],rgbcolor[1],rgbcolor[2]] and   ( SimilarAreaDictionary['Rounded'].loc[i] >= areaPerimeterMin and SimilarAreaDictionary['Rounded'].loc[i]  <= areaPerimeterMax) : 
+          if SimilarAreaDictionary['Color'].loc[i]==[rgbcolor[0],rgbcolor[1],rgbcolor[2]] and   ( SimilarAreaDictionary['Rounded'].loc[i] >= areaPerimeterMin and SimilarAreaDictionary['Rounded'].loc[i]  <= areaPerimeterMax) :
             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  ) :
                 checkifColorExists=1  #found and incremented
                 SimilarAreaDictionary['Occurences'].loc[i]+=1
-        if checkifColorExists==0: #couldnt find the color , doesnt exist so add it 
+        if checkifColorExists==0: #couldnt find the color , doesnt exist so add it
           SimilarAreaDictionary.loc[len(SimilarAreaDictionary)] =mydata
-          
       else: #full image
-        # print('here')
-#same code bs mgher color 
+        #same code bs mgher color
         checkifColorExists=0
-        for i in myindex: #(SimilarAreaDictionary['Rounded'].loc[i] == round(item1,1) )  or  
+        for i in myindex:
           if (   SimilarAreaDictionary['Rounded'].loc[i]  <= areaPerimeterMax and SimilarAreaDictionary['Rounded'].loc[i]  >= areaPerimeterMin) :
-            # print(SimilarAreaDictionary['Rounded'].loc[i]   ,'in rng if', areaMin,areaMax) 
             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  ) :
                   checkifColorExists=1  #found and incremented
                   SimilarAreaDictionary['Occurences'].loc[i]+=1
-                  # SimilarAreaDictionary['R'].loc[i] =colorRanges[i][0]
-                  # SimilarAreaDictionary['G'].loc[i] =colorRanges[i][1]
-                  # SimilarAreaDictionary['B'].loc[i] = colorRanges[i][2]
-
-        # colorRanges.pop(0)
-
-        if checkifColorExists==0: #couldnt find the color , doesnt exist so add it 
+        if checkifColorExists==0: #couldnt find the color , doesnt exist so add it
           SimilarAreaDictionary.loc[len(SimilarAreaDictionary)] =mydata
   # s= SimilarAreaDictionary
   for i in range(len(SimilarAreaDictionary)):
-      SimilarAreaDictionary['B'].loc[i] =colorRanges[i][0]
-      SimilarAreaDictionary['G'].loc[i] =colorRanges[i][1]
-      SimilarAreaDictionary['R'].loc[i] = colorRanges[i][2]
+      SimilarAreaDictionary.loc[i, "R"] = colorRanges[i][0]
+      SimilarAreaDictionary.loc[i, "G"] = colorRanges[i][1]
+      SimilarAreaDictionary.loc[i, "B"] = colorRanges[i][2]
       colorsUsed.append(colorRanges[i])
 
-
   return SimilarAreaDictionary, colorsUsed , areas_Perimeters
 #detect and draw and measure
 def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag , path,pdfpath):
   green2=allpreSteps(img)
   doc = fitz.open("pdf",dataDoc)
   page = doc[0]
+  rotationOld=page.rotation
   pix=page.get_pixmap()
-  ratio =  pix.width / img.shape[1]   
+  if page.rotation!=0:
+    page.set_rotation(0)
+    ratio =  pix.width/ img.shape[0]
+  else:
+    ratio =  pix.width/ img.shape[1]
+
   areasinImage=[]
   imgArea1= img.copy()
   imgPerimeter1=img.copy()
   imgtransparent1=img.copy()
-  allpoints=[]
 
   if number ==220:
-    SimilarAreaDictionary= pd.DataFrame(columns=['Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
+    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
     maskDone=img.copy()
     for eachcolor in finalColorArray:
 
-      print(eachcolor)
-      if eachcolor==firstcolor: # 3shan a3rf el array of colors et3adet kam mara - to support embedded levels 
-        counter+=1
+      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)
 
-      contourss,rgbcolor,invertedmask=findContoursFullImage(green2,maskDone,number,finalColorArray,ratioarea,ratioperim,'perimeter',eachcolor) 
-      contourssA,rgbcolor,invertedmask=findContoursFullImage(green2,maskDone,number,finalColorArray,ratioarea,ratioperim,'area',eachcolor) 
-      SimilarAreaDictionary, colorsUsed , areas_Perimeters= FillDictionary(green2,SimilarAreaDictionary,maskDone,number,ratioarea,ratioperim,flag,finalColorArray,rgbcolor,eachcolor)
-  
+      SimilarAreaDictionary, colorsUsed , areas_Perimeters= FillDictionary(SimilarAreaDictionary,maskDone,ratioarea,ratioperim,contourss,contourssA,rgbcolor,eachcolor)
+      perimTotal=0       
       for contour in range(len(contourss)):
           shape=[]
           
@@ -607,29 +651,21 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
           
           # perimeter1 = cv2.arcLength(contourss[contour][0], True)  
           if (area1 > 3500 ): #check perimeter kman fl condition  -- 2800
-            rect = cv2.minAreaRect(contourss[contour][0])
-
+            perimeter=cv2.arcLength(contourss[contour][0],True)
+            shape=[]
             angleR,widthR ,heightR= StraightenImage(contourss[contour][0],imgArea1)
             x, y , width, height = cv2.boundingRect(contourss[contour][0])
-            # (center, (width, height), angleR) = cv2.minAreaRect(contourss[contour][0])
+            approxA = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
+            area1 = cv2.contourArea(approxA)
 
-            box = cv2.boxPoints(rect)
-            box = box.astype('int')
-            # print(box)
-
-            x, y , width, height = cv2.boundingRect(contourss[contour][0])
-            perimeter = cv2.arcLength(contourss[contour][0], True)
-            # approx = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
-            # area1 = cv2.contourArea(approx)
-            approx = cv2.approxPolyDP(contourss[contour][0], 0.007 * perimeter, True) #0.0009
+            approx = cv2.approxPolyDP(contourss[contour][0], 0.01 * perimeter, True) #0.0009
             perimeter1 = cv2.arcLength(approx, True)
-
-            for point in approx:
-              x1, y1 = point[0]
-              p1 = fitz.Point(x1*ratio,y1*ratio)
-              p1=p1*page.derotation_matrix
-              shape.append([p1[0],p1[1]])
-            
+            for point in approxA:
+                  x1, y1 = point[0]
+                  p1 = fitz.Point(x1*ratio,y1*ratio)
+                  p1=p1*page.derotation_matrix
+                  shape.append([p1[0],p1[1]])
+                
             if (angleR != 90.0 and angleR != -90.0 and angleR != 0.0 and angleR != -0.0 ): #inclined b ay degree 
               width=widthR
               height=heightR
@@ -642,9 +678,6 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
             heightMin=height-15
             heightMax= height+15
             if ratioarea !=0 and ratioperim!=0:
-              widthh=round(width*ratioperim,3)
-              heightt=round(height*ratioperim,3)
-              # if flag=='area':
               areaa=round(area1* ratioarea, 3) # true value of area of any shape/ area px value of same shape
               perimeterr=round(perimeter1* ratioperim,3)
               lengthShape=round(lengthShape* ratioperim,3)
@@ -652,46 +685,62 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
               areaa=area1
               perimeterr=perimeter1
 
-            # if flag=='area':
-            areaPerimeterMin= round(areaa,1) - 0.25
-            areaPerimeterMax= round(areaa,1) + 0.25
-            # areaPerimeterMin= round(perimeterr,1) - 0.3
-            # areaPerimeterMax= round(perimeterr,1) + 0.3
+            areaPerimeterMin= round(areaa,1) - 0.4
+            areaPerimeterMax= round(areaa,1) + 0.4
             masked=SimilarAreaDictionary.loc[SimilarAreaDictionary.index[((SimilarAreaDictionary['Rounded'] >=areaPerimeterMin) &(SimilarAreaDictionary['Rounded']<=areaPerimeterMax)  )]]
-            # masked=SimilarAreaDictionary.loc[SimilarAreaDictionary['Rounded'] ==round(areaa,1)]
-            # if (round(areaa,1) in masked['Rounded'].values ) :
             passed=0
             for i, row in masked.iterrows():
               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['Total Area'].loc[i]+=areaa
-                        SimilarAreaDictionary['Area'].loc[i]=areaa
-
+                      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 )
+
+
+                      for p in perimeters:
+                        if p[2]==x and p[3]==y and p[5]=='open':
+                          # if areaa >=5.15 and areaa<=5.25:
+                            shapee=[]
+                            SimilarAreaDictionary['Total Perimeter'].loc[i]+=round((p[4]-1)*ratioperim,3)
+                            SimilarAreaDictionary['Perimeter'].loc[i]=round((p[4]-1)*ratioperim,3)
+                            for poi in p[7]:
+                                x1, y1 = poi[0]
+                                p1 = fitz.Point(x1*ratio,y1*ratio)
+                                p1=p1*page.derotation_matrix
+                                shapee.append([p1[0],p1[1]])
+
+                            annot11 = page.add_polyline_annot( points=shapee)  # 'Polygon'
+                            annot11.set_border(width=0.2, dashes=[3])
+                            annot1.set_colors(stroke=color ,fill=None)
+                            annot11.set_info(content='Perimeter='+str(round((p[4]-1)*ratioperim,3))+' m',subject='ADR Team',title=str(alltxts[contour]))
+                            # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+                            annot11.update()
+                            pFlagDF=1
+                      if pFlagDF==0:
+                        annot1 = page.add_polyline_annot( points=shape)  # 'Polygon'
+                        annot1.set_border(width=0.2 ,dashes=[3])
+                        annot1.set_colors(stroke=color , fill=None)
+    
+                        annot1.set_info(content='Perimeter='+str(perimeterr)+' m',subject='ADR Team',title=str(alltxts[contour]))
                         SimilarAreaDictionary['Total Perimeter'].loc[i]+=perimeterr
-                        SimilarAreaDictionary['Perimeter'].loc[i]=perimeterr                        
-                        
-                        SimilarAreaDictionary['Total Length'].loc[i]+=lengthShape
-                        SimilarAreaDictionary['Length'].loc[i]=lengthShape
-                        passed=1
-                          # print(index)
-            # cv2.drawContours(imgArea1, [contour], 0, (int(rgbcolor[2]), int(rgbcolor[1]), int(rgbcolor[0])), -1)
-                        cv2.drawContours(imgArea1, [contourss[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.3, dashes=[2])
-                        annot.set_colors( fill=(  int(SimilarAreaDictionary['R'].loc[i])/255 ,  int(SimilarAreaDictionary['G'].loc[i])/255 ,  int(SimilarAreaDictionary['B'].loc[i])/255 ) ) 
-                        # annot.set_colors( fill=(1,0,1) )
-                        annot.set_opacity(0.5)
-                        annot.set_info(content='Area= '+str(areaa)+' m2' +'\n \nPerimeter= '+str(perimeterr)+' m'   +'\n \nLength= '+str(lengthShape)+' m',subject='ADR Team')#,title='uuum')
-                        # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
-                        annot.update()
+                        SimilarAreaDictionary['Perimeter'].loc[i]=perimeterr
+                      SimilarAreaDictionary['Total Length'].loc[i]+=lengthShape
+                      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)
+                      annot = page.add_polygon_annot( points=shape)  # 'Polygon'
+                      annot.set_border(width=0.2)
+                      annot.set_colors(stroke=color, fill= color )
+                      annot.set_opacity(0.5)
+                      annot.set_info(content='Area='+str(areaa)+' m2' +'\n \n Length='+str(lengthShape)+' m',subject='ADR Team',title=str(alltxts[contour]))
+                      # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+                      annot.update()
            
-            # cv2.putText(imgtransparent1,'Area= '+str(area1) , (x+50,y-10)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
-            # cv2.putText(imgtransparent1,'Width= '+str(width) , (x+50,y-10)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
-            # cv2.putText(imgtransparent1,'Length= '+str(height) , (x+50,y-20)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
-            areasinImage.append(areaa)
-
+            # areasinImage.append(areaa)
             cv2.putText(imgPerimeter1,'Perimeter: '+str(perimeterr)+ ' m', (x+70,y-30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
             cv2.putText(imgPerimeter1,'Area: '+str(areaa)+' m2', (x+50,y-40)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
 
@@ -706,27 +755,25 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
   #########################
   else:
     
-    SimilarAreaDictionary= pd.DataFrame(columns=['Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])  
-    contourss=findContoursFullImage(green2,img,number,finalColorArray,ratioarea,ratioperim,'perimeter')
-    contourssA=findContoursFullImage(green2,img,number,finalColorArray,ratioarea,ratioperim,'area')
-    SimilarAreaDictionary,colorsUsed , areas_Perimeters= FillDictionary(green2,SimilarAreaDictionary,img,number,ratioarea,ratioperim,flag,finalColorArray)
-    # print('filled')
+    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)
+
     for contour in range(len(contourss)):
-    #   imgArea1=img.copy()
       area1 = cv2.contourArea(contourssA[contour][0])
-      if (area1 >3500 ):
-        perimeter = cv2.arcLength(contourss[contour][0],True)
+      if (area1 >4000 ):
+        perimeter=cv2.arcLength(contourss[contour][0],True)
+
 
         shape=[]
         angleR,widthR ,heightR= StraightenImage(contourss[contour][0],imgArea1)
         x, y , width, height = cv2.boundingRect(contourss[contour][0])
-        # approxo = cv2.approxPolyDP(contourss[contour],0.1*cv2.arcLength(contourss[contour],True),True)
-        # approx = cv2.approxPolyDP(contourss[contour][0], 0.005 * perimeter, True)
-        # approxa = cv2.approxPolyDP(contourssA[contour][0], 0.0002* perimeter, True)
-        # area1 = cv2.contourArea(approxa)
-        approx = cv2.approxPolyDP(contourss[contour][0], 0.007 * perimeter, True) #0.0009
+        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
         perimeter1 = cv2.arcLength(approx, True)
-        for point in approx:
+        for point in approxA:
             x1, y1 = point[0]
             p1 = fitz.Point(x1*ratio,y1*ratio)
             p1=p1*page.derotation_matrix
@@ -750,8 +797,8 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
             lengthShape=round(lengthShape* ratioperim,3)
         else:
           perimeterr=perimeter1
-        areaPerimeterMin= round(areaa,1) - 0.25
-        areaPerimeterMax= round(areaa,1) + 0.25
+        areaPerimeterMin= round(areaa,1) - 0.4
+        areaPerimeterMax= round(areaa,1) + 0.4
         masked=SimilarAreaDictionary.loc[SimilarAreaDictionary.index[((SimilarAreaDictionary['Rounded'] >=areaPerimeterMin) & (SimilarAreaDictionary['Rounded']<=areaPerimeterMax)  )]]
         passed=0
         for i, row in masked.iterrows():
@@ -760,29 +807,79 @@ def drawAllContours(dataDoc,img,number,finalColorArray,ratioarea,ratioperim,flag
               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['Total Area'].loc[i]+=areaa
                     SimilarAreaDictionary['Area'].loc[i]=areaa
-
-                    SimilarAreaDictionary['Total Perimeter'].loc[i]+=perimeterr
-                    SimilarAreaDictionary['Perimeter'].loc[i]=perimeterr
-
+                    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 )
+
+
+                    for p in perimeters:
+                      if p[2]==x and p[3]==y and p[5]=='open':
+                        # if areaa >=5.15 and areaa<=5.25:
+                          shapee=[]
+                          SimilarAreaDictionary['Total Perimeter'].loc[i]+=round((p[4]-1)*ratioperim,3)
+                          SimilarAreaDictionary['Perimeter'].loc[i]=round((p[4]-1)*ratioperim,3)
+                          for poi in p[7]:
+                              x1, y1 = poi[0]
+                              p1 = fitz.Point(x1*ratio,y1*ratio)
+                              p1=p1*page.derotation_matrix
+                              shapee.append([p1[0],p1[1]])
+
+                          annot11 = page.add_polyline_annot( points=shapee)  # 'Polygon'
+                          annot11.set_border(width=0.2, dashes=[3])
+                          annot1.set_colors(stroke=color ,fill=None)
+                          annot11.set_info(content='Perimeter='+str(round((p[4]-1)*ratioperim,3))+' m',subject='ADR Team',title=str(alltxts[contour]))
+                          # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+                          annot11.update()
+                          pFlagDF=1
+                    if pFlagDF==0:
+                      annot1 = page.add_polyline_annot( points=shape)  # 'Polygon'
+                      annot1.set_border(width=0.2 ,dashes=[3])
+                      annot1.set_colors(stroke=color ,fill=None)
+                      annot1.set_info(content='Perimeter='+str(perimeterr)+' m',subject='ADR Team',title=str(alltxts[contour]))
+                      SimilarAreaDictionary['Total Perimeter'].loc[i]+=perimeterr
+                      SimilarAreaDictionary['Perimeter'].loc[i]=perimeterr
                     SimilarAreaDictionary['Total Length'].loc[i]+=lengthShape
                     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)
-        
-                    annot = page.add_polygon_annot( points=shape )  # 'Polygon'
-                    
-                    annot.set_border(width=0.3, dashes=[2])
-                    annot.set_colors( fill=(  int(SimilarAreaDictionary['R'].loc[i])/255 ,  int(SimilarAreaDictionary['G'].loc[i])/255 ,  int(SimilarAreaDictionary['B'].loc[i])/255 ) )
-                    # annot.set_colors( fill=(1,0,1) )
+                    annot = page.add_polygon_annot( points=shape)  # 'Polygon'
+                    annot.set_border(width=0.2)
+                    annot.set_colors(stroke=color, fill= color )
                     annot.set_opacity(0.5)
-                    annot.set_info(content='Area= '+str(areaa)+' m2' +'\n \nPerimeter= '+str(perimeterr)+' m'  +'\n \nLength= '+str(lengthShape)+' m',subject='ADR Team')#,title='uuum')
+                    annot.set_info(content='Area='+str(areaa)+' m2' +'\n \n Length='+str(lengthShape)+' m',subject='ADR Team',title=str(alltxts[contour]))
                     # 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,'Perimeter: '+str(perimeterr)+' m' , (x+50,y-40)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+        
+        cv2.putText(imgtransparent1,'Area: '+str(areaa) +' m2', (x+50,y-10) ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+        pFlag=0
+
+        for p in perimeters:
+          if p[2]==x and p[3]==y and p[5]=='open':
+              # if areaa >=5.15 and areaa<=5.25:
+                perimTotal+=round((p[4]-1)*ratioperim,3)
+                cv2.putText(imgtransparent1,'Perimeter: '+str(round((p[4])*ratioperim,3))+ ' m', (p[0]+50,p[1]-40)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+                pFlag=1
+        if pFlag==0:
+          cv2.putText(imgtransparent1,'Perimeter: '+str(perimeterr)+' m', (x+50,y-40)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+  for i, row in SimilarAreaDictionary.iterrows():
+    c = Counter( SimilarAreaDictionary['Guess'].loc[i])
+    if len(c) >0:
+      value, count = c.most_common()[0]
+      SimilarAreaDictionary['Guess'].loc[i]= value
+    else:
+      SimilarAreaDictionary['Guess'].loc[i]= 'none'
+
 
+  # cv2.circle (imgtransparent1, (img.shape[0],img.shape[0]1), 5, 255, 5)
+  alpha = 0.4  # Transparency factor.
+  image_new1 = cv2.addWeighted(imgArea1, alpha,  imgtransparent1, 1 - alpha, 0)
+  if rotationOld==90:
+    image_new1 = cv2.rotate(image_new1, cv2.ROTATE_90_CLOCKWISE)
+  if rotationOld==180:
+    image_new1 = cv2.rotate(image_new1, cv2.ROTATE_180)
+  if rotationOld==270:
+    image_new1 = cv2.rotate(image_new1, cv2.ROTATE_90_COUNTERCLOCKWISE)        
   alpha = 0.4  # Transparency factor.
   image_new1 = cv2.addWeighted(imgArea1, alpha,  imgtransparent1, 1 - alpha, 0)
  
@@ -1036,7 +1133,7 @@ def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
     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)
-
+      worksheet.update_col(1,list(SimilarAreaDictionary['Guess']),row_offset=3)
       worksheet.update_col(3,list(SimilarAreaDictionary['Occurences']),row_offset=3)
       worksheet.update_col(4,list(SimilarAreaDictionary['Area']),row_offset=3)
       worksheet.update_col(5,list(SimilarAreaDictionary['Total Area']),row_offset=3)