Upload 5 files

db.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+"""dropbox.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/11JdwIfblSKRelJJa7rllER8HwbSl_0Nu
+"""
+
+
+import dropbox
+import dropbox.exceptions as AuthError
+import cv2
+import pandas as pd
+import os
+import fitz
+
+"""### Lists of project names, parts, sections --
+ *Will get from MC*
+"""
+
+prjname1=['2340 United Living Low Rise Building','2341 Bouygues-Cotswold','2342 GF Tomlinson - Hardingstone Primary School']
+prjname1parts=['Block O Pumphouse','Hawthorn','Ling','Red Oak']
+prjname2parts=['Block B','Block G']
+
+prjname1sec1=['1.0 Substructure','5.1 Sanitary','8.2 Roads, Paths, Pavings','8.4 Fencing, Railing, Walls','8.5 External Fixtures','8.6 External Drainage','8.7 External Services','8.8 Minor Buildings']
+prjname1sec2=['1.0 Substructure','2.1 Frames','2.3 Roof','2.4 Stairs','2.5 External Walls','2.6 External Openings','2.7 Internal Walls','2.8 Internal Openings','3.1 Wall Finishes','3.2 Floor Finishes','3.3 Ceiling Finishes','4.0 Fittings, Furnishings and Equipments','7.0 Works to exisitng buildings','8.1 Site Preparation Works','8.2 Roads, Paths, Pavings','8.3 Soft Landscaping','8.5 External Fixtures','8.6 External Drainage','8.7 External Services','8.8 Minor Buildings']
+prjname1sec3=['1.0 Substructure','2.3 Roof','2.4 Stairs','2.5 External Walls','2.6 External Openings','2.7 Internal Walls','3.1 Wall Finishes','3.2 Floor Finishes','3.3 Ceiling Finishes',  '4.0 Fittings, Furnishings and Equipments','7.0 Works to existing buildings','8.1 Site Preparation Works','8.2 Roads, Paths, Pavings','8.3 Soft Landscaping','8.5 External Fixtures','8.6 External Drainage']
+prjname1sec4=['1.0 Substructure','2.3 Roof','2.4 Stairs','2.5 External Walls','2.6 External Openings','2.7 Internal Walls','3.1 Wall Finishes','3.2 Floor Finishes','3.3 Ceiling Finishes',  '4.0 Fittings, Furnishings and Equipments','7.0 Works to existing buildings','8.1 Site Preparation Works','8.2 Roads, Paths, Pavings','8.3 Soft Landscaping','8.5 External Fixtures','8.6 External Drainage']
+prj1secs=[prjname1sec1,prjname1sec2,prjname1sec3,prjname1sec4]
+prjname2parts=['Block B','Block G']
+prjname2sec=['3.3 Ceiling Finishes']
+prjname2sec2=['3.3 Ceiling Finishes']
+prj2secs=[prjname2sec,prjname2sec2]
+prjname3parts=['Community Center building','External Works','Primary School']
+prjname3sec1=['1.0 Substructure','2.3 Roof','3.1 Wall Finishes','3.2 Floor Finishes','3.3 Ceiling Finishes','4.0 Fittings, Furnishings and Equipments','5.1 Sanitary']
+prjname3sec2=['8.1 Site Preparation Works','8.4 Fencing, Railing, Walls','8.5 External Fixtures', ' 8.6 External Drainage']
+prjname3sec3=['1.0 Substructure','2.3 Roof','2.4 Stairs','3.2 Floor Finishes','3.3 Ceiling Finishes','4.0 Fittings, Furnishings and Equipments','5.1 Sanitary']
+prj3secs=[prjname3sec1,prjname3sec2,prjname3sec3]
+
+"""### Main Dropbox Functions :connect - list- download- upload"""
+
+access_token='sl.BiJ1Bte91KheyVoQI95qEQs9fVRR9Chq7U6RBtu73oJPWSrCaMUiNhRjwRzcCHbK4OrQsUTh9hPCJDJ5Ht7KASbAp-RffAqzZLIFMu6ZAHoWNygK2dShvKwznFF4eHGgp4AqD2RG'
+###################################################################################################################
+def dropbox_connect():
+    """Create a connection to Dropbox."""
+    print('connecy')
+    try:
+        # print('ayhaga')
+        dbx = dropbox.Dropbox(
+            app_key='67w6ibpa9d2b60x',
+            app_secret='d3ecz8g1604fu04',
+            oauth2_refresh_token = 'Oc-2umxnIFsAAAAAAAAAAXQlSUH2EutbUiUa-cZE-iVhe96p4qHLAE2J2ZZ8NqjW',
+
+        )
+        # dbx=dropbox.Dropbox(access_token)
+
+    except AuthError as e:
+        print('Error connecting to Dropbox with access token: ' + str(e))
+    return dbx
+
+
+################################################################################################################
+def dropbox_list_files(path):
+    """Return a Pandas dataframe of files in a given Dropbox folder path in the Apps directory.
+    """
+
+    dbx = dropbox_connect()
+
+    try:
+        files = dbx.files_list_folder(path).entries
+        files_list = []
+        for file in files:
+            if isinstance(file, dropbox.files.FileMetadata):
+                metadata = {
+                    'name': file.name,
+                    'path_display': file.path_display,
+                    'client_modified': file.client_modified,
+                    'server_modified': file.server_modified
+                }
+                files_list.append(metadata)
+
+        df = pd.DataFrame.from_records(files_list)
+        return df.sort_values(by='server_modified', ascending=False)
+
+    except Exception as e:
+        print('Error getting list of files from Dropbox: ' + str(e))
+
+#####################################################################################################################
+
+def dropbox_download_file(dropbox_file_path, local_file_path):
+    """Download a file from Dropbox to the local machine."""
+
+    try:
+        dbx = dropbox_connect()
+
+        with open(local_file_path, 'wb') as f:
+            metadata, result = dbx.files_download(path=dropbox_file_path)
+            f.write(result.content)
+    except Exception as e:
+      
+        print('Error downloading file from Dropbox: ' + str(e))
+
+
+
+#########################################################################################################################
+def dropbox_shareableLink(path):
+  dbx= dropbox_connect()
+  shared_link_metadata = dbx.sharing_create_shared_link_with_settings(path)
+  return shared_link_metadata.url
+
+#########################################################################################################################
+
+def dropbox_upload_file( doc, pdfname, pdfpath,flag=0):
+    try:
+        dbx = dropbox_connect()
+        path= pdfpath + pdfname
+        print('pathindb:',path)
+        if flag==0:
+          meta=dbx.files_upload(doc.write(),path,mode=dropbox.files.WriteMode("overwrite"))
+        elif flag==1:
+          perm = int(  # permissions bit flags
+            fitz.PDF_PERM_ACCESSIBILITY # always use this
+            | fitz.PDF_PERM_PRINT # permit printing
+          )
+          encrypt = fitz.PDF_ENCRYPT_AES_256  # strongest algorithm
+          meta=dbx.files_upload( doc.write() ,path,mode=dropbox.files.WriteMode("overwrite"))
+        try:
+          shared_link_metadata = dbx.sharing_create_shared_link_with_settings(path)
+        except:
+          shared_link_metadata=dbx.sharing_create_shared_link(path)
+        print( shared_link_metadata.url)
+        return shared_link_metadata.url
+    except Exception as e:
+        print('Error uploading file to Dropbox: ' + str(e))
+        
+
+#########################################################################################################################
+"""### Create Dictionaries (relation between values)"""
+def createDictionaries():
+  projectsdictionary={} # prj name: parts
+  sectionsdict={} #each prj part:sections
+  #allprj parts
+  parts=[prjname1parts,prjname2parts,prjname3parts]
+  #allprjsections
+  sections=[prj1secs,prj2secs,prj3secs]
+
+  for i in range(len(prjname1)):
+    projectsdictionary.update({prjname1[i]:parts[i]})
+    for j in range(len(parts[i]) ):
+      sectionsdict.update({parts[i][j]:sections[i][j]})
+  return projectsdictionary, sectionsdict , parts
+
+
+"""### Create prj from scratch or prj name with all subfolders in it"""
+def create_folder(projectsdictionary={},sectionsdict={}):
+    dbx = dropbox_connect()
+    projectsdictionary, sectionsdict , parts= createDictionaries()
+    try:
+      df1,df2=dropbox_list_files('')
+      print(df1,df2)
+      if (len(df2)>0):
+        if list(df2['name'])==prjname1:
+          return projectsdictionary, sectionsdict , parts
+        elif list(df2['name'])!=prjname1:
+          if len(projectsdictionary)==0 and len(sectionsdict)==0:
+            print(len(projectsdictionary))
+
+      else:
+        names=[]
+        secondnames=[]
+        for item in projectsdictionary.items():
+          for secondItem in item[1]:
+            name='/'+item[0]
+            secondname='/'+secondItem
+            name+=secondname
+            names.append(name)
+            for item1 in sectionsdict.items():
+              for ii in item1[1]:
+                if secondItem== item1[0]:
+                  final =name+'/'+ii
+                  print(final)
+                  dbx.files_create_folder(path=final)
+    except Exception as e:
+        print('eeeeeerorrrrrrrrrr',e)
+    return  projectsdictionary, sectionsdict , parts
+
+def dropbox_list_files(path):
+    """Return a Pandas dataframe of files in a given Dropbox folder path in the Apps directory.
+    """
+
+    dbx = dropbox_connect()
+
+    try:
+        files = dbx.files_list_folder(path).entries
+        files_list = []
+        folders_list=[]
+        for file in files:
+          if isinstance(file, dropbox.files.FileMetadata):
+
+            metadata = {
+                'name': file.name,
+                'path_display': file.path_display,
+                # 'client_modified': file.client_modified,
+                # 'server_modified': file.server_modified
+            }
+            files_list.append(metadata)
+          else:#folder
+            metadata = {
+                'name': file.name,
+                'path_display': file.path_display,
+            }
+            folders_list.append(metadata)
+        df = pd.DataFrame.from_records(files_list)
+        df2 = pd.DataFrame.from_records(folders_list)
+        return df , df2
+
+    except Exception as e:
+        print('Error getting list of files from Dropbox: ' + str(e))
+
+def prjNameCheckandCreate(projectsdictionary, sectionsdict):
+  df1,df2=dropbox_list_files('')
+
+  if len(df2)!=0:
+    df2Values=list(df2['name'].values)
+    difference = list(set(prjname1) - set(df2Values))
+    if len(difference)==0:
+      print(df2Values)
+    else:
+      newdict={}
+      newsecdict={}
+      print('else')
+      for i in difference:
+        newdict.update({i:projectsdictionary.get(i)})
+      for key,value in newdict.items():
+        for ii in value:
+          newsecdict.update({ii:sectionsdict.get(ii)})
+      create_folder(projectsdictionary=newdict,sectionsdict=newsecdict)
+  return df2
+
+def prjPartSectionCheckandCreate():
+  projectsdictionary, sectionsdict , parts=create_folder()
+  df2= prjNameCheckandCreate(projectsdictionary, sectionsdict )
+  for i  in range(len(df2['path_display'].values)):
+    #look for the same path
+    df11,df21=dropbox_list_files(df2['path_display'].values[i])
+
+    if len(df21)!=0:
+      df2Values=list(df21['name'].values)
+      difference = list(set(parts[i]) - set(df2Values))
+      if len(difference)==0:
+          print('samee')
+      else:
+          for j in difference:
+            dbx = dropbox_connect()
+            dbx.files_create_folder_v2(df2['path_display'].values[i]+'/'+j) #nopart - create part folder
+            for k in sectionsdict.get(j):
+              dbx.files_create_folder(df2['path_display'].values[i]+'/'+j+'/'+k) #create sections folders
+        #check if section is missing and get prj name and part for path
+      for arr in df2Values:
+          df111,df211=dropbox_list_files(df2['path_display'].values[i]+'/'+arr)
+          if len(df211)!=0:
+            df211Values=list(df211['name'].values)
+            for key,value in sectionsdict.items():
+              if key== arr:
+                if value == df211Values:
+                  print('s')
+                else:
+                  difference1 = list(set(value) - set(df211Values))
+                  dbx = dropbox_connect()
+                  for d in difference1:
+                    print(arr,d)
+                    dbx.files_create_folder_v2(df2['path_display'].values[i]+'/'+arr+'/'+d) #no section - create section folder
+
+

main.py

@@ -0,0 +1,337 @@
+from __future__ import print_function
+from flask import Flask, render_template,request,flash , json, url_for,g , redirect , jsonify
+import os
+import json
+import fitz
+from PIL import Image
+import cv2
+import numpy as np
+import sys
+import pilecaps_adr
+import base64
+from db import dropbox_connect
+import db
+import cv2
+import pandas as pd
+import ast
+import time
+from io import BytesIO
+from flask import Flask, Response
+from werkzeug.wsgi import wrap_file
+import tameem3_2
+import pypdfium2 as pdfium
+import pixelconversion
+
+app = Flask(__name__)
+
+out_file = open("static/data/myfile.json", "w")
+
+#retrieves project parts 
+@app.route('/getmethod/<jsdata>',methods=['GET','POST'])
+def get_javascript_data(jsdata):
+    #get project from the first dropdown
+    print(jsdata)
+    matches=update_dropdown(jsdata) #list f of projects
+    print(matches)
+    return jsonify (list(matches))
+#---------------------------------------------------------------
+    
+#get projects of 'project name'
+def update_dropdown(section):
+    if section.startswith('1.0'):
+        plans_inrepo=os.listdir('dropbox_plans/1.0')
+    elif section.startswith('3.2'):
+        plans_inrepo=os.listdir('dropbox_plans/3.2')
+    elif section.startswith('2.2'):
+        plans_inrepo=os.listdir('dropbox_plans/2.2') 
+    else:
+        return ''
+    #if 'foundation' in radio and project in plans_inrepo
+    matches=[] 
+    if section==None:
+        print('no proj')
+    else:
+        for x in plans_inrepo:
+                matches.append(x)
+        print(matches)  
+    return matches
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#NOT IMP NOW
+#retrieve all info of elements after clicking 'measure' button
+@app.route("/",methods=["GET", "POST"])
+def getInfotoMeasure():
+    # db.create_folder()
+    mylist=[1,2,3,4]
+    return render_template("proposed-GUI.html",mylist=mylist)
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#Hex value to RGB value
+def hexRGB(color):
+  color=color.lstrip('#')
+  color= tuple(int(color[i:i+2], 16) for i in (0, 2, 4)) #hex to rgb
+  color=list(color) #rgb to bgr 
+  return color
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#MAIN FUNCTION -- calls python code to measure the chosen plan from the interface
+@app.route('/projecttomeasure/<jsdata>',methods=["GET","POST"])
+def measureproject(jsdata):
+    colorarr=[]
+    result = json.loads(jsdata) 
+    pdfpath='/'
+    #################################  -1.0- #################################
+    for word in result[5]:
+        pdfpath+=word +'/'
+    arr=[]
+
+    if result[5][2].startswith('1.0'): #section value - 1.0 substructure- pile caps
+        img = plan2img('dropbox_plans/1.0/'+str(result[0]) )
+
+        for item in result[2]:
+            item1 ='#'+item 
+            c=hexRGB(item1)
+            colorarr.append(c)
+        imgPerimeter1,image_new1,SimilarAreaDictionary , colorsUsed,spreadsheet_url, spreadsheetId,list1, pdflink, areas_Perimeters, namepathArr =pilecaps_adr.drawAllContours(img,int(result[1]),colorarr, result[3], result[4],'area', result[0],pdfpath)
+        _, buffer = cv2.imencode('.png', image_new1)
+        arr=[base64.b64encode(buffer).decode('utf-8'),SimilarAreaDictionary.to_dict(),spreadsheet_url , spreadsheetId,colorsUsed,list1.to_dict(), pdflink, areas_Perimeters, namepathArr]
+   #################################  -3.2- #################################
+    elif result[5][2].startswith('3.2'): #section value - 3.2 floor finishes
+        outputimg, df_merged , dropboxpdflink , spreadsheetId, spreadsheet_url  , list1 = tameem3_2.mainFunction(str(result[0]),result[3], result[4] , pdfpath) #pass arearatio,perimratio 
+        _, buffer = cv2.imencode('.png', outputimg)
+        arr=[ base64.b64encode(buffer).decode('utf-8') , df_merged.to_dict() , dropboxpdflink , spreadsheetId, spreadsheet_url , list1.to_dict()]
+    #################################  -2.2- #################################
+    # elif result[5][2].startswith('2.2'): #section value - 2.2 rc slabs
+        #add here python code
+        #
+        #link (add this to ur code)
+        #   pdflink= db.dropbox_upload_file(doc=doc,pdfname=path,pdfpath=pdfpath)
+        
+        # gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr= pilecaps_adr.legendGoogleSheets(df,plan ,pdfpath)
+
+
+        #output img
+        #  _, buffer = cv2.imencode('.png', outputimg)
+
+        #let first result to be the img 
+        #return results in arr=[base64.b64encode(buffer).decode('utf-8'),pdflink,spreadsheetId,spreadsheet_url] like the previous sections in the above lines 
+    return  jsonify(arr)
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#pdf to img
+def plan2img(path):
+    
+    doc = fitz.open(path)
+    for page in doc:
+        pix = page.get_pixmap(dpi=200)  # render page to an image
+        pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+        img=np.array(pl)
+        print(img.shape)
+        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    return img
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#not used in 1.0
+def convert2img(path):
+    pdf = pdfium.PdfDocument(path)
+    page = pdf.get_page(0)
+    pil_image = page.render().to_pil()
+    pl1=np.array(pil_image)
+    img = cv2.cvtColor(pl1, cv2.COLOR_RGB2BGR)
+    return img
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#User-made MC-T NAME - in the second part of the interface
+@app.route("/mctnametoGoogleSheet/<jsdata>",methods=["GET", "POST"])
+def sendmctnametoLegend(jsdata):
+    result = json.loads(jsdata)
+    print(result)
+    summaryid,guessednamesfinal=pilecaps_adr.mapnametoLegend(result)
+    allreturns=[summaryid,guessednamesfinal]
+    return jsonify(allreturns)
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#NOT USED (pixel conversion instead)
+def calcRef(img):
+  blk = np.ones(img.shape, dtype="uint8") * [[[np.uint8(0), np.uint8(0), np.uint8(0)]]]
+  
+  start_point = (50, 100)
+  end_point = (120, 200)
+  color = (255, 255, 255) # white BGR
+  thickness = -1 # Thickness of -1 will fill the entire shape
+
+  blk = cv2.rectangle(blk, start_point, end_point, color, thickness)
+   
+  blk = cv2.cvtColor(blk, cv2.COLOR_BGR2GRAY)
+
+  contourzz, hierarchy = cv2.findContours(image=blk, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  for i, cnt3 in enumerate(contourzz):
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    area = cv2.contourArea(cnt3)
+    perimeter = cv2.arcLength(cnt3, True)  
+    return area,perimeter , blk
+
+#NOT USED (pixel conversion instead)
+def modifyingcalcRefDynamic(img):
+  imgcopy = img.copy()
+
+  blk = np.ones(img.shape, dtype="uint8") * [[[np.uint8(0), np.uint8(0), np.uint8(0)]]]
+  
+  x = 50
+  y = 100
+  xD = int(img.shape[1] * 0.10)
+  yD = int(img.shape[0] * 0.10)
+  start_point = (x, y)
+  end_point = (x+xD, y+yD)
+  blue = (255, 0, 0) #  BGR
+  white = (255, 255, 255) #  BGR
+  thickness = -1 # Thickness of -1 will fill the entire shape
+
+  imgcopy = cv2.rectangle(imgcopy, start_point, end_point, blue, thickness)
+  blk = cv2.rectangle(blk, start_point, end_point, white, thickness)
+   
+  blk = cv2.cvtColor(blk, cv2.COLOR_BGR2GRAY)
+
+  contourzz, hierarchy = cv2.findContours(image=blk, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  for i, cnt3 in enumerate(contourzz):
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    area = cv2.contourArea(cnt3)
+    perimeter = cv2.arcLength(cnt3, True)  
+    return area, perimeter, blk , imgcopy
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#PIXEL CONVERSION METHOD -- SAVES DOC ON DROPBOX TO BE MEASURED BY USER 
+@app.route("/pixelimg/<jsdata>",methods=["GET", "POST"])
+def getimg(jsdata):
+    db.create_folder()
+    print(jsdata)
+    jsdata=eval(jsdata)
+    if jsdata[2].startswith('1.0'):
+        doc = fitz.open('dropbox_plans/1.0/'+str(jsdata[3]) )
+    elif jsdata[2].startswith('3.2'):
+        doc = fitz.open('dropbox_plans/3.2/'+str(jsdata[3]) )
+    elif jsdata[2].startswith('2.2'):
+        doc = fitz.open('dropbox_plans/2.2/'+str(jsdata[3]) )
+    else: 
+        return ''
+    for page in doc:
+        
+        pix = page.get_pixmap()  # render page to an image
+        pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+        img=np.array(pl)
+        print(img.shape)
+        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    if jsdata[2].startswith('1.0'):
+        doc=pixelconversion.openDrawPDF(path='dropbox_plans/1.0/'+str(jsdata[3]))
+    elif jsdata[2].startswith('3.2'):
+        doc=pixelconversion.openDrawPDF(path='dropbox_plans/3.2/'+str(jsdata[3]))
+    elif jsdata[2].startswith('2.2'):
+        doc=pixelconversion.openDrawPDF(path='dropbox_plans/2.2/'+str(jsdata[3]))
+    pdfpath='/'+jsdata[0]+'/'+jsdata[1]+'/'+jsdata[2]+'/'+'Scale Document' +'/'
+    dburl=db.dropbox_upload_file(doc=doc,pdfname=str(jsdata[3]) ,pdfpath=pdfpath,flag=1)
+    areaPixel,perimeterPixel= pixelconversion.getAreaPerimeter(pdfpath, str(jsdata[3]))
+
+    print(areaPixel,perimeterPixel)
+    outputs=[areaPixel,perimeterPixel , dburl]
+    return jsonify(outputs)
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#DELETE MARKUPS (for comparison)
+@app.route('/_submission',methods=["GET", "POST"])
+def getnewlegend():
+    pdfpth=''
+    list1 = request.args.get('dict1')
+    path = request.args.get('path')
+    spreadsheetId =request.args.get('spreadsheetId')
+    pdfpathpath=request.args.get('pdfpathpath')
+    pdfname=request.args.get('pdfname')
+    for word in eval(pdfpathpath):
+        pdfpth+='/' +word
+    pdfpth+='/'
+    deletedrows1=pilecaps_adr.deletemarkups(list1=list1,pdfpath=pdfpth,path=path) 
+    print(deletedrows1)
+    arr1=[deletedrows1.to_dict()]
+    return jsonify(arr1)
+#---------------------------------------------------------------------------
+#if user wishes to delete 
+@app.route('/deletemarkupsroute',methods=["GET", "POST"])
+def dltmarkupslegend():
+    pdfpth=''
+    SimilarAreaDictionary = request.args.get('dict')
+    deletedrows = request.args.get('deletedrows')
+    path = request.args.get('path')
+    spreadsheetId =request.args.get('spreadsheetId')
+    areaPermArr=request.args.get('areaPermArr')
+    section=request.args.get('section')
+    pdfpathpath=request.args.get('pdfpathpath')
+    for word in eval(pdfpathpath):
+        pdfpth+='/' +word
+    pdfpth+='/'
+    myDict=eval(deletedrows)
+    deletedrows=pd.DataFrame(myDict)
+
+    if section.startswith('1.0'):
+        newlgnd=pilecaps_adr.deletefromlegend(deletedrows=deletedrows,SimilarAreaDictionarycopy=SimilarAreaDictionary, section=section,areaPermArr=areaPermArr)
+    else:
+        newlgnd=pilecaps_adr.deletefromlegend(deletedrows=deletedrows,SimilarAreaDictionarycopy=SimilarAreaDictionary, section=section)
+    try:
+        newlgnd1=pilecaps_adr.legendGoogleSheets(SimilarAreaDictionary=newlgnd,path=path,spreadsheetId=spreadsheetId ,pdfpath=pdfpth) #new legend
+    except:
+        print("An exception occurred")
+        time.sleep(10)
+        newlgnd1=pilecaps_adr.legendGoogleSheets(SimilarAreaDictionary=newlgnd,path=path,spreadsheetId=spreadsheetId,pdfpath=pdfpth)
+
+    return jsonify('donee')
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#get pdf dropbox url after measurement is done
+@app.route('/getdropboxurl/<jsdata>',methods=["GET", "POST"])
+def calldropboxurl(jsdata):
+    pdfpth=''
+    for word in eval(jsdata):
+        pdfpth+='/' +word
+    print(pdfpth)
+    pdfurl=db.dropbox_shareableLink(pdfpth)
+    return jsonify(pdfurl)
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+#Google sheet links
+@app.route('/getdrivelinks/<jsdata>',methods=["GET", "POST"])
+def getlinkscreated(jsdata):
+    spreadsheet_service,drive_service,gc= pilecaps_adr.authorizeLegend()
+    ids=gc.spreadsheet_ids()
+    titles=gc.spreadsheet_titles()
+    allpaths=[]
+    # for title in titles:
+    for i in range(len(titles)):
+        ws=gc.open(titles[i])
+        allpaths.append([titles[i], ws.get_developer_metadata('path')[0].value , drive_service.files().get(fileId=ids[i],fields="createdTime, modifiedTime").execute() ,ids[i] ])
+
+    return jsonify(allpaths)
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+
+#_________________________________________________________________________________________________________________________
+#_________________________________________________________________________________________________________________________
+if __name__ == "__main__":
+    app.run(debug=True)
+
+

pilecaps_adr.py

@@ -0,0 +1,1555 @@
+# -*- coding: utf-8 -*-
+"""Copy of XOR- ROI from plan-PileCaps-ADR.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/16RHtRae7VU_fqHMAjOUL4ET5slEFo3pf
+"""
+
+# pip install pdf-annotate
+
+# pip install pdf-annotate
+
+#pip install pdf2image
+
+#!pip install -q gradio
+
+#pip install pygsheets
+
+# !apt-get install poppler-utils
+
+import numpy as np 
+import cv2 
+#from google.colab.patches import cv2_imshow
+from matplotlib import pyplot as plt 
+#from pdf2image import convert_from_path
+
+import math
+
+import pandas as pd
+import random
+# import imutils
+# from imutils import contours 
+import colorsys
+from PIL import Image  , ImageDraw, ImageFont , ImageColor
+import numpy as np
+#import gradio as gr
+
+# from __future__ import print_function
+from googleapiclient.discovery import build 
+from google.oauth2 import service_account
+import pygsheets
+import re
+import pandas
+import fitz 
+import json
+import db
+import ast
+
+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)
+  gray_blurred = cv2.blur(er1, (3,3 ))
+  # Apply Hough transform on the blurred image.
+   # min distance between circles,  Upper threshold for the internal Canny edge detector.
+  detected_circles = cv2.HoughCircles( gray_blurred, cv2.HOUGH_GRADIENT, 1, 50, param1= 550,
+                    param2 =21, minRadius = 20, maxRadius = 40) #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)
+  im=cv2.medianBlur(im,1)
+  print('circles')
+  # cv2_imshow(im)
+  return im
+
+def detectSmallCircles(img ):
+  #Remove tiny TOC points that interfere with shapes 
+  im=img.copy()
+  imgGry1 = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
+  kernel=np.ones((3,3),np.uint8)
+  er1=cv2.erode(imgGry1,kernel, iterations=1)
+  # Apply Hough transform on the blurred image.
+   # min distance between circles,  Upper threshold for the internal Canny edge detector.
+  detected_circles = cv2.HoughCircles( imgGry1, cv2.HOUGH_GRADIENT, 1, 60, param1 =550,
+                    param2 =13, minRadius = 1, maxRadius = 10) #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+1, (255, 255, 255), -1)
+  # cv2_imshow(im)
+  return im
+# c=detectCircles(img)
+
+def DashedPreprocessing(imgOriginal,imgnoSmall):
+  h,w=imgOriginal.shape[0:2]
+  #remove the gray contours from the plan
+  imgBW=cv2.threshold(imgnoSmall, 180, 255, cv2.THRESH_BINARY)[1]
+
+  im_copy=imgBW.copy()
+  im_copy1=im_copy
+  kernel1 = np.ones((3,5),np.uint8)
+  kernel2 = np.ones((9,9),np.uint8)
+  kernel3= np.ones((3,3),np.uint8)
+  imgGray=cv2.cvtColor(imgBW,cv2.COLOR_BGR2GRAY)
+  imgBW1=cv2.threshold(imgGray, 200, 255, cv2.THRESH_BINARY_INV)[1]
+
+  img1=cv2.erode(imgBW1, kernel1, iterations=1)
+  img2=cv2.dilate(img1, kernel2, iterations=3)
+  img3 = cv2.bitwise_and(imgBW1,img2)
+  img3= cv2.bitwise_not(img3)
+  img4 = cv2.bitwise_and(imgBW1,imgBW1,mask=img3)
+  img4=cv2.blur(img4,(7,7))
+  if h > w :
+    max = h
+    min = w
+  else:
+    max = w
+    min = h
+  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),2)
+
+  im_copy=imgBW.copy()
+  green=im_copy[:,:,1]
+  # cv2_imshow(im_copy)
+  return green
+
+def removeSmallDashes(imgOriginal,green):
+  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,5)
+  smalldashes=cv2.medianBlur(smalldashes,7)
+  # cv2_imshow(smalldashes)
+  smalldashesOut=green.copy()
+  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
+
+  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),2)
+
+
+  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)
+
+  imgCopy=imgCopy[:,:,1]
+  # cv2_imshow(imgCopy)
+  return imgCopy,smalldashesOut
+
+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)//2.2,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.1 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):
+  green1=cv2.bitwise_not(smalldashesOut)
+  green2=smalldashesOut.copy()
+  green2=cv2.cvtColor(green2,cv2.COLOR_GRAY2BGR)
+  imgLines= cv2.HoughLinesP(green1,0.05,np.pi/250,10,minLineLength=25,maxLineGap = 20)  #was w-h , gap=150  #50
+  for i in range(len(imgLines)):
+      for x1,y1,x2,y2 in imgLines[i]:
+          cv2.line(green2,(x1,y1),(x2,y2),(0,0,0),1)
+
+  imgLines= cv2.HoughLinesP(green1,0.3,np.pi/360,10,minLineLength=25,maxLineGap = 20)  #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),1)
+  # cv2_imshow(green2)
+  return green2
+
+def allpreSteps(imgOriginal):
+  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
+
+def ChangeBrightness(img,k):
+  imgdarker = 255 * (img/255)**k # k>1 darker , k <1 lighter
+  # cv2_imshow(imgdarker)
+  imgdarker = imgdarker.astype('uint8')
+  return imgdarker
+
+def preprocessold(img,number):
+  
+  # imcopy=detectCircles(img)
+  blurG = cv2.GaussianBlur(ChangeBrightness(img,6),(3,3),0)
+ 
+  imgGry = cv2.cvtColor(blurG, cv2.COLOR_BGR2GRAY)
+
+  kernel=np.ones((3,3),np.uint8)
+
+  er1=cv2.dilate(imgGry,kernel, iterations=2) #thinning
+
+  er2=cv2.erode(er1,kernel, iterations=3) #thicken
+  er3=cv2.dilate(er2,kernel, iterations=4)
+
+  if number == 0:
+    ret3, thresh = cv2.threshold(er3, 200, 255, cv2.THRESH_BINARY_INV  + cv2.THRESH_OTSU)
+  else:
+    ret3, thresh = cv2.threshold(er3, 220, 255, cv2.THRESH_BINARY_INV) #`140 - 141
+  # cv2_imshow(thresh)
+  return thresh
+# preprocessold(img,0)
+
+def preprocess(imgOriginal,number,green2):
+  #first preprocessing ( old method - black img with white shapes)
+  img1=preprocessold(imgOriginal,number)
+  kernel0=np.ones((3,3),np.uint8)
+  img1=cv2.dilate(img1,kernel0, iterations=3)
+  green3=ChangeBrightness(green2,6)
+  anding=cv2.bitwise_and(green3,green3,mask=img1)
+  anding = cv2.cvtColor(anding , cv2.COLOR_BGR2GRAY)
+
+  return anding
+
+"""# ROI (levels)
+## Detect regions with specific color and mask them
+"""
+
+def hexRGB(color):
+  color=color.lstrip('#')
+
+  color= tuple(int(color[i:i+2], 16) for i in (0, 2, 4)) #hex to rgb
+  color=np.array(color) #rgb to bgr 
+  return color
+def DetectColor(img,color=0):
+
+  imgCopy=img.copy()
+  imgCopy=cv2.cvtColor(imgCopy,cv2.COLOR_BGR2HSV)
+  tol=5 #tolerance
+  # color=hexRGB(color) 
+  h,s,v = cv2.cvtColor(np.uint8([[[color[2],color[1],color[0]]]]),cv2.COLOR_BGR2HSV)[0][0]
+
+  lower =np.array( [h- tol, 100, 100 ], dtype='uint8')
+  upper = np.array( [h + tol, 255, 255],dtype='uint8')
+
+  mask = cv2.inRange(imgCopy, lower , upper)
+
+  detectedColors = cv2.bitwise_and(imgCopy,imgCopy, mask= mask)   # Bitwise-AND mask and original image
+  
+  kernel=np.ones((3,3),np.uint8)
+  mask=cv2.dilate(mask,kernel, iterations=5)
+  mask=cv2.erode(mask,kernel, iterations=4)
+
+  detectedColors=cv2.dilate(detectedColors,kernel, iterations=5)
+  detectedColors=cv2.erode(detectedColors,kernel, iterations=4)
+
+  detectedColors=cv2.cvtColor(detectedColors,cv2.COLOR_HSV2BGR)
+  detectedColors=cv2.medianBlur(detectedColors,7)
+  # cv2_imshow(detectedColors)
+  
+  return mask, detectedColors, color
+
+    
+def detectAllColors(img,finalColorArray):
+  for i in range(len(finalColorArray)):
+    detectedColors= DetectColor(img,finalColorArray[i])[1]
+    if i == 0:
+      allcolorsImg=cv2.bitwise_or(detectedColors,detectedColors)
+    else:
+      allcolorsImg=cv2.bitwise_or(allcolorsImg,detectedColors)
+  allcolorsImg= cv2.medianBlur(allcolorsImg,7)
+  
+  return allcolorsImg
+
+def colorOrder(img,finalColorArray):
+  newimg=img.copy()
+  arraycolor=[]
+  allcolorsImg= detectAllColors(img,finalColorArray)
+  allcolorsImgG=  cv2.cvtColor(allcolorsImg, cv2.COLOR_BGR2GRAY)
+
+  ColoredContour, Coloredhierarchy = cv2.findContours(allcolorsImgG, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+  Coloredhierarchy=Coloredhierarchy[0]
+  for cnt in ColoredContour :
+    Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+    cv2.drawContours(Blackmask,[cnt],0,(255,255,255),20) 
+    coloredand=cv2.bitwise_and(allcolorsImg,allcolorsImg,mask=Blackmask)
+    
+    for colors in finalColorArray:
+      getColor=DetectColor(coloredand,colors)[1]
+      
+      pil_image=Image.fromarray(getColor)
+      extrema = pil_image.convert("L").getextrema()
+      if extrema != (0, 0): # if image is not black --> has a colored mask within
+        arraycolor.append(colors)
+        break
+
+  res = []
+  [res.append(x) for x in arraycolor if x not in res]
+  
+  return res
+
+def getinnerColor(BlackmaskDetected,img,detectedColors,finalColorArray,num1,num2,flag,eachcolor):
+
+  countBlackMasks=0
+  xored=detectedColors
+
+  invertedmask=detectedColors
+
+  imgc=img.copy()
+  imgNewCopy=img.copy()
+  Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+  for eachcolor in finalColorArray:
+    masked=DetectColor(detectedColors,eachcolor)[0]
+    pil_image=Image.fromarray(masked)
+    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):
+
+  # cc=levelonly.copy()
+  firstLevel=levelonly
+  firstLevel1=levelonly
+  print('in')
+  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)
+  extrema = pil_image.convert("L").getextrema()
+  if extrema != (0, 0): # if image is not black --> has a colored mask within
+
+    if rgbcolor==color: #found level tany gowa b nfs el lon 
+      print('kkkkkkkk')
+      ColoredContour, Coloredhierarchy = cv2.findContours(masked, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)    
+      Coloredhierarchy=Coloredhierarchy[0]
+      for component in zip(ColoredContour,Coloredhierarchy):
+        cnt=component[0]
+        hier=component[1]
+        area1 = cv2.contourArea(cnt)
+        if (area1 > 1000 ): 
+          if hier[3]> -1:
+            cv2.drawContours(Blackmask,[cnt],0,(255,255,255), -1) 
+            cv2.drawContours(Blackmask,[cnt],0,(0,0,0), 20)  
+            cv2.drawContours(BlackmaskDetected,[cnt],0,(255,255,255), -1) 
+           
+            firstLevel=cv2.bitwise_and(invertedmask,invertedmask,mask=Blackmask)
+            ####remove black pixels and let them be all white 
+            # get (i, j) positions of all RGB pixels that are black (i.e. [0, 0, 0])
+            black_pixels = np.where(
+                (firstLevel[:, :, 0] == 0) & 
+                (firstLevel[:, :, 1] == 0) & 
+                (firstLevel[:, :, 2] == 0)
+            )
+
+            # set those pixels to white
+            firstLevel[black_pixels] = [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]]
+              print(othercolor2,color)
+              if othercolor2!=color:
+                print('anothre')
+                masked0=DetectColor(firstLevel,othercolor)[0] 
+                pil_image0=Image.fromarray(masked0)
+                extrema0 = pil_image0.convert("L").getextrema()
+                if extrema != (0, 0): # if image is not black --> has a colored mask within
+                  ColoredContour0, Coloredhierarchy0 = cv2.findContours(masked0, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)    
+                  for cnt in ColoredContour0:
+                    area1 = cv2.contourArea(cnt)
+                    if (area1 > 1000 ): 
+                      cv2.drawContours(firstLevel1,[cnt],0,(255,255,255), -1)  
+                      cv2.drawContours(firstLevel1,[cnt],0,(255,255,255), 10)  
+                      cv2.drawContours(BlackmaskDetected,[cnt],0,(0,0,0), -1) 
+                      # cv2.drawContours(Blackmask,[cnt],0,(255,255,255), -1)  
+                      # cv2.drawContours(Blackmask,[cnt],0,(255,255,255), 10)  
+                      # cv2_imshow(firstLevel1)
+            # cv2_imshow(Blackmask)
+  return firstLevel1, BlackmaskDetected
+    
+def getColoredContour(mask,img,finalColorArray,num1,num2,flag,eachcolor):
+    print('uuuuuuuuummmmmmmmmmmmm')
+
+    ColoredContour, Coloredhierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    Coloredhierarchy=Coloredhierarchy[0]
+
+    imgc= img.copy()
+
+    detectedColors=np.zeros(img.shape[:2], dtype="uint8")
+    Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+
+    for component in zip( ColoredContour, Coloredhierarchy):
+        cnt=component[0]
+        hier=component[1]
+        area1 = cv2.contourArea(cnt)
+        if (area1 > 3000 ): 
+      # cv2.drawContours(imgNewCopy, [cnt], 0,(255,255,255), 20)  #(x+20,y+20 ), (x+width-20, y+height-20),
+          if hier[3] >-1:
+
+            x, y , width, height = cv2.boundingRect(cnt) 
+            cv2.drawContours(Blackmask, [cnt], 0,(255,255,255), -1)  #(x+20,y+20 ), (x+width-20, y+height-20),
+            cv2.drawContours(Blackmask, [cnt], 0,(0,0,0), 10)  #(x+20,y+20 ), (x+width-20, y+height-20),
+    
+            detectedColors = cv2.bitwise_and(imgc,imgc, mask= Blackmask)
+            pil_image=Image.fromarray(detectedColors)
+            extrema = pil_image.convert("L").getextrema()
+            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,num1,num2,flag,eachcolor) #mask inner levels b abyad 
+    firstLevel1, BlackmaskDetected1= allLevelsofColor(BlackmaskDetected,img,levelOnly, invertedmask,eachcolor,finalColorArray)
+    # cv2.imshow('kk',firstLevel1)
+    print('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')
+    return firstLevel1,invertedmask, BlackmaskDetected1
+
+"""#  contours"""
+
+def findContoursFullImage(green2,img,number,finalColorArray,num1,num2,flag,color=[0,0,0]):
+  if number == 0:
+    thresh=preprocess(img,number,green2)
+
+    contourss, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    return contourss
+  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,num1,num2,flag,color)
+      thresh=preprocess(coloredregions,number,green2)
+      x=cv2.bitwise_and(thresh,thresh,mask=BlackmaskDetected1)
+      contourss, hierarchy = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+      return contourss,rgbcolor ,invertedmask 
+
+    else:
+      print('ELSEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE')
+      thresh=preprocess(img,number,green2)
+
+      contourss, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+      hierarchy = hierarchy[0] 
+      return contourss,color ,mask
+
+
+
+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
+
+def getAreasPerimeter(green2,img,number,num1,num2,flag,finalColorArray,color=[0,0,0]):
+  appended=[]
+  if number==0:
+    contourss=findContoursFullImage(green2,img,number,finalColorArray,num1,num2,flag,color)
+  else:
+    contourss=findContoursFullImage(green2,img,number,finalColorArray,num1,num2,flag,color)[0]
+
+  for contour in contourss:
+
+    area1 = cv2.contourArea(contour)
+    perimeter1 = cv2.arcLength(contour, True)
+    x, y , width, height = cv2.boundingRect(contour) 
+
+    angleR,widthR ,heightR= StraightenImage(contour,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 > 4000 ): #check perimeter kman fl condition  -- 2800
+      if num1!=0 and num2!=0:
+        #if flag=='area':
+          # addedMargin=area1+perimeter1*2
+          # areaa=round(addedMargin* (num1/(num2+perimeter1*2) ), 3) # true value of area of any shape/ area px value of same shape
+          areaa=round(area1*num1,3)
+          appended.append([areaa,width,height])
+
+        #else:
+          #perimeter=round(perimeter1*(num1/num2),3)
+          #appended.append([perimeter,width,height])
+
+  return appended
+
+
+def FillDictionary(green2,SimilarAreaDictionary,img,number,num1,num2,flag,finalColorArray,rgbcolor=[0,0,0],color=[0,0,0]):
+  #fills dictionary with key areas and number of occurences
+  print('wttttt')
+  areas_Perimeters=sorted(getAreasPerimeter(green2,img,number,num1,num2,flag,finalColorArray,color) )
+  
+  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]]
+  print(colorRanges[0])
+  print(colorRanges[0][0],colorRanges[0][1], colorRanges[0][2])
+  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.3
+      areaPerimeterMax= round(item1,1) + 0.3
+      # 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)
+      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()
+      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['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 
+          SimilarAreaDictionary.loc[len(SimilarAreaDictionary)] =mydata
+          
+      else: #full image
+        # print('here')
+#same code bs mgher color 
+        checkifColorExists=0
+        for i in myindex: #(SimilarAreaDictionary['Rounded'].loc[i] == round(item1,1) )  or  
+          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 
+          SimilarAreaDictionary.loc[len(SimilarAreaDictionary)] =mydata
+  # s= SimilarAreaDictionary
+  for i in range(len(SimilarAreaDictionary)):
+      SimilarAreaDictionary['R'].loc[i] =colorRanges[i][0]
+      SimilarAreaDictionary['G'].loc[i] =colorRanges[i][1]
+      SimilarAreaDictionary['B'].loc[i] = colorRanges[i][2]
+      colorsUsed.append(colorRanges[i])
+
+
+  return SimilarAreaDictionary, colorsUsed , areas_Perimeters
+def drawAllContours(img,number,finalColorArray,ratioarea,ratioperim,flag , path,pdfpath):
+  green2=allpreSteps(img)
+  doc = fitz.open('dropbox_plans/1.0/'+path)
+  page = doc[0]    
+  page.set_rotation(0)
+  pix=page.get_pixmap()
+  ratio =  pix.width/ img.shape[1] 
+  
+  areasinImage=[]
+  totaldf=pd.DataFrame()
+  imgArea1= img.copy()
+  imgPerimeter1=img.copy()
+  imgtransparent1=img.copy()
+
+  Blackmask = np.zeros(img.shape[:2], dtype="uint8")
+
+  invertedmask=img
+  allpoints=[]
+
+  if number ==220:
+    # finalColorArray= colorOrder(img,finalColorArray)
+    # if flag== 'area':
+    #   SimilarAreaDictionary= pd.DataFrame(columns=['Color','Rounded','Width','Height','Area','Occurences','Total Area' , 'R','G','B']) #
+    # else:
+      # SimilarAreaDictionary= pd.DataFrame(columns=['Color','Rounded','Width','Height','Perimeter','Occurences','Total Perimeter' ,'R','G','B'])
+    SimilarAreaDictionary= pd.DataFrame(columns=['Color','Rounded','Width','Height','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
+    firstcolor=finalColorArray[0]
+    # print(lastcolor)
+    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=findContoursFullImage(green2,maskDone,number,finalColorArray,ratioarea,ratioperim,flag,eachcolor) 
+      SimilarAreaDictionary, colorsUsed , areas_Perimeters= FillDictionary(green2,SimilarAreaDictionary,maskDone,number,ratioarea,ratioperim,flag,finalColorArray,rgbcolor,eachcolor)
+  
+      a = SimilarAreaDictionary.to_numpy()
+      
+      # for component in zip(contourss,hierarchy):
+      #     contour = component[0]
+      #     currentHierarchy = component[1]
+      for contour in contourss:
+          shape=[]
+          
+          # cv2_imshow(imgStraight)
+          area1 = cv2.contourArea(contour)
+          perimeter1 = cv2.arcLength(contour, True)  
+          if (area1 > 4000 ): #check perimeter kman fl condition  -- 2800
+            angleR,widthR ,heightR= StraightenImage(contour,imgArea1)
+            rect = cv2.minAreaRect(contour)
+    
+            (center, (width, height), angleR) = cv2.minAreaRect(contour)
+            
+            box = cv2.boxPoints(rect)
+            box = box.astype('int')
+            print(box)
+
+            x, y , width, height = cv2.boundingRect(contour) 
+            # cv2.drawContours(imgArea1,contours=[box], contourIdx=0 , color=(0, 0, 255), thickness=10) 
+            approx = cv2.approxPolyDP(contour, 0.005 * perimeter1, True)
+            for point in approx:
+                x1, y1 = point[0]
+                
+                shape.append([int(x1*ratio),int(y1*ratio)])
+                # shape= np.fliplr(shape)
+                
+                # cv2.circle(imgArea1, (x1, y1), 4, (0, 255, 0), -1)
+            allpoints.append(shape)
+            # print(x,y,width,height)
+            # print(allpoints)
+            print(shape)
+            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 width>height:
+              lengthShape = width
+            if height>width:
+              lengthShape = height
+            widthMin= width-10
+            widthMax= width+10
+            heightMin=height-10
+            heightMax= height+10
+            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
+              
+              # elif flag=='perimeter':
+              perimeterr=round(perimeter1* ratioperim, 3)
+            else:
+              areaa=area1
+              perimeterr=perimeter1
+
+            # if flag=='area':
+            areaPerimeterMin= round(areaa,1) - 0.3
+            areaPerimeterMax= round(areaa,1) + 0.3
+            # areaPerimeterMin= round(perimeterr,1) - 0.3
+            # areaPerimeterMax= round(perimeterr,1) + 0.3
+            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 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, [contour], 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',subject='ADR Team')#,title='uuum')
+                        # 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)
+
+            cv2.putText(imgPerimeter1,'Perimeter'+str(perimeterr), (x+70,y-30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+
+  
+    for i,row in SimilarAreaDictionary.iterrows():
+      # print(row)
+      if row[5] not in areasinImage: # column of area 
+        SimilarAreaDictionary = SimilarAreaDictionary.drop(SimilarAreaDictionary.loc[SimilarAreaDictionary.index==i].index)
+
+    print(SimilarAreaDictionary)
+    # display(totaldf)
+  #########################
+  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,flag)
+    SimilarAreaDictionary,colorsUsed , areas_Perimeters= FillDictionary(green2,SimilarAreaDictionary,img,number,ratioarea,ratioperim,flag,finalColorArray)
+    # print('filled')
+    for contour in contourss:
+      # shape=[]
+      area1 = cv2.contourArea(contour)
+      perimeter1 = cv2.arcLength(contour, True)  
+      if (area1 >4000 ):
+        shape=[]
+        angleR,widthR ,heightR= StraightenImage(contour,imgArea1)
+        x, y , width, height = cv2.boundingRect(contour) 
+
+        approx = cv2.approxPolyDP(contour, 0.005 * perimeter1, True)
+        for point in approx:
+            x1, y1 = point[0]
+            shape.append([int(x1*ratio),int(y1*ratio)])
+        allpoints.append(shape)
+        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 width>height:
+          lengthShape = width
+        if height>width:
+          lengthShape = height
+        widthMin= width-10 #5
+        widthMax= width+10
+        heightMin=height-10
+        heightMax= height+10
+
+        
+        if ratioarea !=0 and ratioperim!=0:
+          # if flag=='area':
+            # addedMargin=area1+perimeter1*2
+            # areaa=round(addedMargin* (num1/(num2+perimeter1*2) ), 3) # true value of area of any shape/ area px value of same shape
+          # elif flag=='perimeter':
+            areaa=round(area1* ratioarea, 3) # true value of area of any shape/ area px value of same shape
+            perimeterr=round(perimeter1* ratioperim, 3)
+        else:
+          areaa=area1
+          perimeterr=perimeter1
+        # if flag=='area': 
+        areaPerimeterMin= round(areaa,1) - 0.3
+        areaPerimeterMax= round(areaa,1) + 0.3
+        masked=SimilarAreaDictionary.loc[SimilarAreaDictionary.index[((SimilarAreaDictionary['Rounded'] >=areaPerimeterMin) & (SimilarAreaDictionary['Rounded']<=areaPerimeterMax)  )]]
+        passed=0
+        # if (round(areaa,1) in masked['Rounded'].values ) :
+
+        for i, row in masked.iterrows():
+          if passed ==0:
+            # if SimilarAreaDictionary['Rounded'].loc[i] == round(areaa,1) :
+            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['Total Area'].loc[i]+=areaa
+                    SimilarAreaDictionary['Area'].loc[i]=areaa
+
+                    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, [contour], 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',subject='ADR Team')#,title='uuum')
+                    # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+                    annot.update()
+        cv2.putText(imgtransparent1,'area= '+str(area1) + ' m', (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-40)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+        cv2.drawContours(imgArea1, [contour], 0, (0, 0, 255),2)
+        cv2.drawContours(imgPerimeter1, [contour], 0, (0, 0, 255), 4)
+        cv2.putText(imgPerimeter1,'Perimeter='+str(perimeter1), (x+30,y-30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+
+  
+  alpha = 0.4  # Transparency factor.
+  image_new1 = cv2.addWeighted(imgArea1, alpha,  imgtransparent1, 1 - alpha, 0)
+  
+  # SimilarAreaDictionary.drop(['Rounded', 'Width','Height','R','G','B'], axis=1, inplace=True)
+
+  print(SimilarAreaDictionary)
+ 
+  # annotationsSave
+  # doc.save('k.pdf', deflate=True)
+  pdflink= db.dropbox_upload_file(doc=doc,pdfname=path,pdfpath=pdfpath)
+  # list1=pd.DataFrame(columns=['content', 'creationDate', 'id', 'modDate', 'name', 'subject', 'title'])
+  # doc1 = fitz.open('k.pdf')
+  # for page in doc1:
+  #   for annot in page.annots():
+  #       list1.loc[len(list1)] =annot.info
+  # print(list1)
+  dbx=db.dropbox_connect()
+  md, res =dbx.files_download(path= pdfpath+path)
+  data = res.content
+  doc=fitz.open("pdf", data)
+  # list1=pd.DataFrame(columns=['content', 'creationDate', 'id', 'modDate', 'name', 'subject', 'title'])
+  list1=pd.DataFrame(columns=['content',  'id',  'subject'])
+  for page in doc:
+      for annot in page.annots():
+          list1.loc[len(list1)] =annot.info
+
+  print(list1)
+  gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr=legendGoogleSheets(SimilarAreaDictionary , path,pdfpath)
+  return imgPerimeter1,image_new1,SimilarAreaDictionary, colorsUsed , spreadsheet_url , spreadsheetId , list1 , pdflink , areas_Perimeters , namepathArr
+
+######################################################
+
+def deletemarkups(list1, pdfpath , path):
+  '''list1 : original markup pdf
+     list2 : deleted markup pdf
+     deletedrows : deleted markups - difference betw both dfs
+
+  '''
+
+  myDict1=eval(list1)
+  list1=pd.DataFrame(myDict1)
+ 
+  areastodelete = []
+  perimstodelete=[]
+
+  dbx=db.dropbox_connect()
+
+  md, res =dbx.files_download(path= pdfpath+path)
+  data = res.content
+  doc=fitz.open("pdf", data)
+  list2=pd.DataFrame(columns=['content',  'id',  'subject'])
+  #  list2=pd.DataFrame(columns=['content', 'creationDate', 'id', 'modDate', 'name', 'subject', 'title'])
+  for page in doc:
+      for annot in page.annots():
+        list2.loc[len(list2)] =annot.info
+  print(list1)
+  deletedrows=pd.concat([list1,list2]).drop_duplicates(keep=False)
+
+  print(deletedrows,len(deletedrows))
+  flag=0
+  if len(deletedrows)!=0:
+    flag=1
+    deletedrows=deletedrows[['content',  'id',  'subject']]
+    deletedrows = deletedrows.drop(deletedrows.index[deletedrows['content'].str.startswith('Scale')] )#, inplace=True)
+  else:
+    flag=0
+  return deletedrows
+   
+
+
+def deletefromlegend(deletedrows,SimilarAreaDictionarycopy,section, areaPermArr=[]):
+  items=[]
+  idx=0
+  if section.startswith('1.0'):
+    areaPermArr=ast.literal_eval(areaPermArr)
+  myDict=eval(SimilarAreaDictionarycopy)
+  SimilarAreaDictionarycopy=pd.DataFrame(myDict)
+  strings=deletedrows['content']
+
+  areastodelete = []
+  perimstodelete=[]
+
+  for item in strings:
+    items.append(str(item).split('\n \n'))
+  # print('itemsssssss',float(re.findall("\d+\.\d+", str(items[i][0]).split()[0])[0])) #take area and perim mn hna l sec 3.2 and +/- value  margin 
+  for i in range(len(items)):
+    areastodelete.append(float(re.findall("\d+\.\d+", str(items[i][0]).split()[0])[0]))
+    perimstodelete.append(float(re.findall("\d+\.\d+", str(items[i][1]).split()[0])[0]) )
+  print(areastodelete,perimstodelete)
+  for i in range(len(areastodelete)):#item in areastodelete:
+    areamin=round(areastodelete[i],1)- 0.3
+    areamax=round(areastodelete[i],1)+ 0.3
+    perimmin=round(perimstodelete[i],1)- 0.3
+    perimmax=round(perimstodelete[i],1)+ 0.3
+    if section.startswith('1.0'):
+      for p in range(len(areaPermArr)):
+        if areastodelete[i] in areaPermArr[p]:
+          area= areaPermArr[p][0]
+          width= areaPermArr[p][1]
+          height= areaPermArr[p][2]
+    if section.startswith('1.0'):
+      widthMin= width -10
+      widthMax= width +10
+      heightMin = height-10
+      heightMax=height+10
+      print(width, widthMin ,height, heightMin)
+      found=SimilarAreaDictionarycopy.loc[SimilarAreaDictionarycopy.index[((SimilarAreaDictionarycopy['Rounded'] >=areamin) & (SimilarAreaDictionarycopy['Rounded']<=areamax) & (SimilarAreaDictionarycopy['Perimeter'] >=perimmin) & (SimilarAreaDictionarycopy['Perimeter']<=perimmax)   ) & ( ((SimilarAreaDictionarycopy['Width']>=widthMin) & (SimilarAreaDictionarycopy['Width']<=widthMax) & (SimilarAreaDictionarycopy['Height']>=heightMin) & (SimilarAreaDictionarycopy['Height']<=heightMax) ) | ((SimilarAreaDictionarycopy['Width']>=heightMin) & (SimilarAreaDictionarycopy['Width']<=heightMax) & (SimilarAreaDictionarycopy['Height']>=widthMin) & (SimilarAreaDictionarycopy['Height']<=widthMax) )) ]]
+    elif section.startswith('3.2'):
+      areamin=round(areastodelete[i],1)- 0.1
+      areamax= round(areastodelete[i],1) + 0.1
+
+      found=SimilarAreaDictionarycopy.loc[SimilarAreaDictionarycopy.index[((SimilarAreaDictionarycopy['Area'] >=areamin) & (SimilarAreaDictionarycopy['Area']<=areamax)   )]]
+
+    if len(found.index.values ) >0:
+      occ=SimilarAreaDictionarycopy.loc[found.index.values[0],'Occurences']
+      if occ== 1: #drop row
+        print('occ=1')
+        SimilarAreaDictionarycopy= SimilarAreaDictionarycopy.drop(found.index.values[0])
+
+      else: #occ minus 1 , total area - areavalue , total perim - perimvalue
+        print('occ>1')
+        if section.startswith('1.0'):
+          idx=SimilarAreaDictionarycopy.index[((SimilarAreaDictionarycopy['Rounded'] >=areamin) & (SimilarAreaDictionarycopy['Rounded']<=areamax) & (SimilarAreaDictionarycopy['Perimeter'] >=perimmin) & (SimilarAreaDictionarycopy['Perimeter']<=perimmax)   ) & ( ((SimilarAreaDictionarycopy['Width']>=widthMin) & (SimilarAreaDictionarycopy['Width']<=widthMax) & (SimilarAreaDictionarycopy['Height']>=heightMin) & (SimilarAreaDictionarycopy['Height']<=heightMax) ) | ((SimilarAreaDictionarycopy['Width']>=heightMin) & (SimilarAreaDictionarycopy['Width']<=heightMax) & (SimilarAreaDictionarycopy['Height']>=widthMin) & (SimilarAreaDictionarycopy['Height']<=widthMax) )) ]
+        elif section.startswith('3.2'):
+          perimmin=round(perimstodelete[i],1)- 50
+          perimmax=round(perimstodelete[i],1)+ 50
+          idx=SimilarAreaDictionarycopy.index[((SimilarAreaDictionarycopy['Area'] >=areamin) & (SimilarAreaDictionarycopy['Area']<=areamax)  & (SimilarAreaDictionarycopy['Perimeter'] >=perimmin) & (SimilarAreaDictionarycopy['Perimeter']<=perimmax)    )]
+        SimilarAreaDictionarycopy.loc[idx,'Total Area'] = SimilarAreaDictionarycopy.loc[idx,'Total Area'] - areastodelete[i]
+        SimilarAreaDictionarycopy.loc[idx,'Total Perimeter'] = SimilarAreaDictionarycopy.loc[idx,'Total Perimeter'] - perimstodelete[i]
+        print('ppppppppppppppppppp',SimilarAreaDictionarycopy.loc[idx,'Occurences'])
+        SimilarAreaDictionarycopy.loc[idx,'Occurences'] = int(SimilarAreaDictionarycopy.loc[idx,'Occurences']) - 1
+  print(SimilarAreaDictionarycopy)
+  return SimilarAreaDictionarycopy
+#######################################################
+
+def getTitle(path):
+  planName= path.split("/")[-1].split('.')
+  LegendName='Legend of ' + str(planName[0]) + ' plan'
+  return LegendName
+
+def retrieveMCCol(gc):
+  ws=gc.open_by_key('1A8VtqLFhe2NXPxIjfAilbxF9xV2eSzZ-yZ9GP8_5jSo')
+  worksheet = ws.worksheet(0)
+  mcT_Names=worksheet.get_col(1)
+  newMcTNames=[]
+  for i in mcT_Names:
+    if i != '':
+      newMcTNames.append(i)
+  return newMcTNames
+
+
+def getdropdownValues(gc,spreadsheet_service,spreadsheetid):
+  dropdownValues=[]
+  ws=gc.open_by_key('1A8VtqLFhe2NXPxIjfAilbxF9xV2eSzZ-yZ9GP8_5jSo')  ## spreadsheet containing mc-t names 
+ 
+  worksheet = ws.worksheet(0)
+  response = spreadsheet_service.spreadsheets().get(
+        spreadsheetId=spreadsheetid, fields='*',
+        ranges='A2:A60',includeGridData=True).execute()
+  r=list(response['sheets'][0]['data'][0]['rowData'][0]['values'][0])
+  print(r)
+  if 'dataValidation' in r:
+    print('yes')
+    colvals= response['sheets'][0]['data'][0]['rowData'][0]['values'][0]['dataValidation']
+    colvalsList=list(colvals.items())
+    print(colvalsList[0][1])
+    lengthVals=len(colvalsList[0][1]['values'])
+    for i in range(lengthVals):
+      dictVal=(colvalsList[0][1]['values'][i].values())
+      # val=[*dictVal]
+     
+      dropdownValues.append(*dictVal)
+    print(dropdownValues)
+  worksheet.update_col(index=1, values=dropdownValues)
+  return dropdownValues
+def authorizeLegend():
+  SCOPES = [
+  'https://www.googleapis.com/auth/spreadsheets',
+  'https://www.googleapis.com/auth/drive',
+  'https://www.googleapis.com/auth/drive.metadata'
+  ]
+  credentials = service_account.Credentials.from_service_account_file('credentials.json', scopes=SCOPES)
+  spreadsheet_service = build('sheets', 'v4', credentials=credentials)
+  drive_service = build('drive', 'v3', credentials=credentials)
+  gc = pygsheets.authorize(custom_credentials=credentials, client_secret='credentials.json')
+  return spreadsheet_service,drive_service,gc
+
+def legendGoogleSheets(SimilarAreaDictionary,path ,pdfpath, spreadsheetId=0):
+
+  spreadsheet_service,drive_service,gc=authorizeLegend()
+  ########
+  legendTitle= path
+  titles=gc.spreadsheet_titles()
+
+
+     
+  if legendTitle in titles:
+    print('found sheet ', legendTitle)
+    ws=gc.open(str(legendTitle))
+    spreadsheetId=ws.id
+  else:
+# ####### create new sheet
+    print('creating new sheeet')
+
+    spreadsheet_details = {
+      'properties': {
+          'title': path
+          }
+      }
+    sheet = spreadsheet_service.spreadsheets().create(body=spreadsheet_details,
+                                      fields='spreadsheetId').execute()
+                                          
+    spreadsheetId = sheet.get('spreadsheetId')
+    permission1 = {
+      'type': 'anyone',
+      'role': 'writer',
+      # 'emailAddress': 'marthe.adr@gmail.com'
+      }
+    # permission2 = {
+    #   'type': 'user',
+    #   'role': 'writer',
+    #   'emailAddress': 'marthe.adr@gmail.com',
+    #   'pendingOwner': True
+    # }
+
+
+    drive_service.permissions().create(fileId=spreadsheetId, body=permission1, supportsAllDrives=True ).execute()
+    ws=gc.open_by_key(spreadsheetId)
+    
+  sheetId = '0'  # Please set sheet ID.
+  worksheet = ws.worksheet(0)
+  worksheet.title='Legend and data created'
+  worksheet.clear()
+
+  ws.create_developer_metadata('path',pdfpath)
+  splittedpdfpath=re.split(r'[`\-=~!@#$%^&*()_+\[\]{};\'\\:"|<,/<>?]', pdfpath)
+  namepathArr=[legendTitle , spreadsheetId,ws.get_developer_metadata('path')[0].value]
+  if splittedpdfpath[-2].startswith('2.2'):
+    df=[]
+    worksheet.update( df.values.tolist()) #CHECKKKK 
+
+
+  else:
+    top_header_format = [
+        {'mergeCells': { #areas
+            'mergeType': 'MERGE_ROWS',
+            'range': {
+                'sheetId': '0',
+                'startRowIndex': 1,
+                'endRowIndex': 2,
+                'startColumnIndex': 3,
+                'endColumnIndex':5
+                
+                
+            }
+        }},
+
+      {'mergeCells': { #perimeters
+          'mergeType': 'MERGE_ROWS',
+          'range': {
+              'sheetId': '0',
+              'startRowIndex': 1,
+              'endRowIndex': 2,
+              'startColumnIndex': 5,
+              'endColumnIndex':7
+          }
+          
+      }},
+          {'mergeCells': { #lengths
+          'mergeType': 'MERGE_ROWS',
+          'range': {
+              'sheetId': '0',
+              'startRowIndex': 1,
+              'endRowIndex': 2,
+              'startColumnIndex': 7,
+              'endColumnIndex':9
+          }
+          
+      }},
+
+      {'mergeCells': { # legend and data created
+          'mergeType': 'MERGE_ROWS',
+          'range': {
+              'sheetId': '0',
+              'startRowIndex': 0,
+              'endRowIndex': 1,
+              'startColumnIndex': 0,
+              'endColumnIndex':9
+          }
+          
+      }}
+    ]
+
+    
+    spreadsheet_service.spreadsheets().batchUpdate( spreadsheetId=spreadsheetId , body={'requests': top_header_format} ).execute()
+    worksheet.cell((1,1)).value='Legend and Data Created'
+    worksheet.cell((2,1)).value='Guess'
+    worksheet.cell((2,2)).value='Color'
+    worksheet.cell((2,3)).value='Count'
+    worksheet.cell((2,4)).value='Areas'
+    worksheet.cell((2,6)).value='Perimeters'
+    worksheet.cell((2,8)).value='Lengths'
+    second_row_data=['Nr','m2','Total','m','Total','m','Total']
+
+    worksheet.update_row(3,second_row_data,col_offset=2)
+
+    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)
+    worksheet.update_col(6,list(SimilarAreaDictionary['Perimeter']),row_offset=3)
+    worksheet.update_col(7,list(SimilarAreaDictionary['Total Perimeter']),row_offset=3)
+  
+    worksheet.update_col(8,list(SimilarAreaDictionary['Length']),row_offset=3)
+    worksheet.update_col(9,list(SimilarAreaDictionary['Total Length']),row_offset=3)
+    if splittedpdfpath[-2].startswith('1.0'):
+      colorsUsed=[]
+      for i in range(len(SimilarAreaDictionary)):
+        colorsUsed.append([SimilarAreaDictionary['R'].iloc[i]  ,SimilarAreaDictionary['G'].iloc[i] , SimilarAreaDictionary['B'].iloc[i]] )
+    elif splittedpdfpath[-2].startswith('3.2'):
+      colorsUsed=list(SimilarAreaDictionary['Color'])
+    #legend specs here 
+    rowsLen=len(SimilarAreaDictionary.values.tolist()) #kam row -- last row = rowsLen +1
+    lastcell=worksheet.cell((rowsLen+2,1)) #row,col
+    lastcellNotation=str(lastcell.address.label)
+    # worksheet.set_data_validation('A3',lastcellNotation, condition_type='ONE_OF_LIST', condition_values=['Ground Beam','Pile Cap'], showCustomUi=True)
+
+    #get lengths of df
+    columnsLen=len(SimilarAreaDictionary.columns.values.tolist()) #kam column -- last col = columnsLen+1 3shan base0
+    lastUsedCol=columnsLen+1
+  
+    worksheet.adjust_column_width(start=2,end=3)
+    # if splittedpdfpath[-2].startswith('1.0'):
+    worksheet.adjust_column_width(start=4,end=9,pixel_size=60)
+    startrow = 3
+    # elif  splittedpdfpath[-2].startswith('3.2'):
+      # startrow=2
+
+    sheetId = '0'  # Please set sheet ID.
+    for i in range(len(colorsUsed)):
+
+      print(colorsUsed[i])
+      r,g,b=colorsUsed[i]
+      body = {
+        "requests": [
+          { 
+            "updateCells": {
+              "range": {
+                "sheetId": sheetId,
+                "startRowIndex": i+startrow,
+                # "endRowIndex":4 ,
+                "startColumnIndex":1,
+
+                # "endColumnIndex": 0
+              },
+
+              "rows": [
+                {
+                  "values": [ 
+                    {
+                      "userEnteredFormat": {
+                        "backgroundColor": {
+                      
+                                "red": r/255,
+                                "green": g/255,
+                                "blue": b/255,
+                                "alpha": 0.4,
+                                    
+                        }
+                        
+                      }
+                    }
+                  ]
+                }
+              ],
+              "fields": "userEnteredFormat.backgroundColor",
+          
+            }
+
+
+
+          }
+        ]
+      }
+      res =  spreadsheet_service.spreadsheets().batchUpdate(spreadsheetId=spreadsheetId, body=body).execute()
+    # if splittedpdfpath[-2].startswith('1.0'):
+    endColindex=9
+    endrow=3
+    # elif splittedpdfpath[-2].startswith('3.2'):
+    #   endColindex=3
+    #   endrow=2
+    body2={
+    "requests": [
+      {
+        "updateBorders": {
+          "range": {
+            "sheetId": sheetId,
+            "startRowIndex": 0,
+            "endRowIndex": len(SimilarAreaDictionary)+endrow,
+            "startColumnIndex": 0,
+            "endColumnIndex": endColindex
+          },
+          "top": {
+            "style": "SOLID",
+            "width": 2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+          "bottom": {
+            "style": "SOLID",
+            "width": 2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+          "left":{
+            "style": "SOLID",
+            "width":2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+          "right":{
+            "style": "SOLID",
+            "width": 2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+          "innerHorizontal":{
+            "style": "SOLID",
+            "width":2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+          "innerVertical": {
+            "style": "SOLID",
+            "width": 2,
+            "color": {
+              "red": 0.0,
+              "green":0.0,
+              "blue":0.0
+            },
+          },
+        }
+      }
+    ]
+  }
+    spreadsheet_service.spreadsheets().batchUpdate(spreadsheetId=spreadsheetId, body=body2).execute()
+    
+    model_cell =worksheet.cell('A1')
+    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)
+    spreadsheet_url = "https://docs.google.com/spreadsheets/d/%s" % spreadsheetId
+    print(spreadsheet_url)
+    drive_service.permissions().update(transferOwnership=True , fileId=spreadsheetId,permissionId='11OfoB4Z6wOVII8mYmbnCbbqTQs7rYA65') 
+
+
+  return gc,spreadsheet_service,spreadsheetId ,spreadsheet_url  , namepathArr
+#######################
+
+def mapnametoLegend(McTName): 
+
+  sectionKey = McTName.pop()
+  key=sectionKey[0]
+  section=sectionKey[1]
+
+  spreadsheet_service,drive_service,gc=authorizeLegend()
+  spreadsheet_key =str(key)  # Please set the Spreadsheet ID.
+  
+  ws = gc.open_by_key(spreadsheet_key)
+  guessednamesfinal=getguessnames(gc,ws)
+  sheetnames=[]
+  unit=''
+  # ws.add_worksheet("Summary")  # Please set the new sheet name.
+  for i in ws._sheet_list:
+    print(i)
+    sheetnames.append(i.title)
+    print(i.index)
+  if 'XML Export Summary' in sheetnames:
+    worksheetS = ws.worksheet_by_title('XML Export Summary')
+  else:
+    ws.add_worksheet("XML Export Summary")  # Please set the new sheet name.
+  worksheetw = ws.worksheet(0) #legend
+  worksheetS = ws.worksheet_by_title('XML Export Summary')
+  summaryId= ws[1].id
+  worksheetS.clear()
+  countnames=0
+  row0=['MC_T Name','Qty','Unit']
+  worksheetS.update_row(1,row0)
+  
+  for i in range(len(McTName)):
+    allgbnames=''
+    item=''
+    print(McTName[i][0])
+    
+    # firstpart= re.split(r'[`\-=~!@#$%^&*()_+\[\]{};\'\\:"|<,./<>?]', McTName[i][0])
+
+    if McTName[i][2].startswith('Area'):
+      if section.startswith('1.0'):
+        rowvalue=5# column 5 
+      elif section.startswith('3.2'):
+        rowvalue=3
+      ar=0
+      unit='m2'
+    if McTName[i][2].startswith('Perimeter'):
+      if section.startswith('1.0'):
+        rowvalue=7# column 7
+      elif section.startswith('3.2'):
+        rowvalue=3
+      ar=0   
+      unit='m'
+    if McTName[i][2].startswith('Length'):
+      if section.startswith('1.0'):
+        rowvalue=9# column 7
+      elif section.startswith('3.2'):
+        rowvalue=3
+      ar=0   
+      unit='m'
+    if McTName[i][2].startswith('Count'):
+      if section.startswith('1.0'):
+        rowvalue=3# column 7
+      elif section.startswith('3.2'):
+        rowvalue=3
+      ar=0   
+      unit='Nr'
+ 
+    print('mcct',McTName[i][1])
+    if isinstance(McTName[i][1], list):
+      for m in McTName[i][1]:
+      
+        if m.startswith('gb') or m.startswith('p'):
+          allgbnames+= m +' +'
+
+          roww=worksheetw.find(m)
+          print(roww)
+          for j in range(len(roww)):
+            print('kjjjj',roww[j])
+            ar+=float(worksheetw.cell((roww[j].row ,rowvalue)).value) 
+        else:
+            item+=m + ' ,'
+            print(item)
+        n= McTName[i][0] + ' ( '+ allgbnames[:-2] +' , ' + item[:-1]  + ' )  ' 
+    else:
+      if McTName[i][1].startswith('gb'):
+        allgbnames+= McTName[i][1] 
+
+        roww=worksheetw.find(McTName[i][1])
+        print(roww)
+        for j in range(len(roww)):
+          print('kjjjj',roww[j])
+          ar+=float(worksheetw.cell((roww[j].row ,rowvalue)).value) 
+        n= McTName[i][0] + ' ( '+ allgbnames + ' )  ' 
+
+    rowi=[str(n),ar,unit]
+    worksheetS.update_row(i+2,rowi)
+    # worksheetS.adjust_column_width(start=1,end=4)
+    worksheetS.adjust_column_width(start=1,end=1, pixel_size=350)
+    worksheetS.adjust_column_width(start=2,end=2, pixel_size=100)
+    worksheetS.adjust_column_width(start=3,end=3)
+    
+  xx=(worksheetS.cell( ( len(McTName) +1 ,3)) ).address.label
+  model_cell1 =worksheetS.cell('A2')
+  model_cell1.set_horizontal_alignment( pygsheets.custom_types.HorizontalAlignment.LEFT )
+  pygsheets.DataRange('A2', str(xx), worksheet=worksheetS).apply_format(model_cell1)
+
+
+  model_cell =worksheetS.cell('A1')
+  model_cell.set_text_format('bold', True)
+  model_cell.set_horizontal_alignment( pygsheets.custom_types.HorizontalAlignment.CENTER )
+  pygsheets.DataRange('A1','C1', worksheet=worksheetS).apply_format(model_cell)
+  
+  body2={
+  "requests": [
+    {
+      "updateBorders": {
+        "range": {
+          "sheetId": str(summaryId),
+          "startRowIndex": 0,
+          "endRowIndex":  len(McTName) +1 ,
+          "startColumnIndex": 0,
+          "endColumnIndex": 3
+        },
+        "top": {
+          "style": "SOLID",
+          "width": 2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+        "bottom": {
+          "style": "SOLID",
+          "width": 2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+        "left":{
+          "style": "SOLID",
+          "width":2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+        "right":{
+          "style": "SOLID",
+          "width": 2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+        "innerHorizontal":{
+          "style": "SOLID",
+          "width":2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+        "innerVertical": {
+          "style": "SOLID",
+          "width": 2,
+          "color": {
+            "red": 0.0,
+            "green":0.0,
+            "blue":0.0
+          },
+        },
+      }
+    }
+  ]
+  }
+  spreadsheet_service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_key, body=body2).execute()
+  return summaryId,guessednamesfinal   
+
+  # print(x,xarea)
+def getguessnames(gc,ws):
+  guessednamesfinal=[]
+  worksheetw = ws.worksheet(0)
+  guessednames=worksheetw.get_col(1, returnas='matrix', include_tailing_empty=False)
+  print(guessednames[2:])
+  for item in guessednames[2:]:
+     if item not in guessednamesfinal:
+        guessednamesfinal.append(item)
+  print(guessednamesfinal)
+  return guessednamesfinal
+
+################################################################

pixelconversion.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+"""pixelconversion.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1hfdgkYOw8w6DdJqsZx8txmw8INUGxesl
+"""
+
+
+# pip install pymupdf -q
+
+"""### Imports"""
+
+import fitz
+from PIL import Image
+import numpy as np
+import cv2
+import db
+
+"""### Open PDF and draw a rectangle on it using Fitz"""
+def openDrawPDF(path):
+  doc = fitz.open(path)
+  page = doc[0]
+  pix = page.get_pixmap(dpi=200)  # render page to an image
+
+  if page.rect.height > page.rect.width:
+    rect =  fitz.Rect(10, 10, (10+page.rect.width-50),( 10+700))
+    rectText=fitz.Rect(300, 200, (10+page.rect.width-50),( 300+100))
+    rotate=90
+  else:
+    rect =  fitz.Rect(10, 10,( 10+page.rect.height-50),(10+700))
+    rectText=fitz.Rect(300, 200,(10+page.rect.height-50) ,( 300+100))
+    rotate=0
+  annot = page.add_rect_annot(rect)
+  annot.set_colors( fill=(75/255,0,130/255) ,stroke=(75/255,0,130/255) )
+  annot.set_opacity(0.9)
+  annot.set_border(border=None, width=0)
+  annot.update()
+  
+  text = """Scale Document"""
+  annot1=page.add_freetext_annot(rectText, text, fontsize=45, fontname='helv', border_color=(1,1,1), text_color=(1,1,1), rotate=rotate, align=1)
+  annot1.update()
+  perm = int(  # permissions bit flags
+    fitz.PDF_PERM_ACCESSIBILITY  #always use this
+    | fitz.PDF_PERM_PRINT # permits printing
+
+  )
+  encrypt = fitz.PDF_ENCRYPT_AES_256  # strongest algorithm
+  # Ndoc=doc.write(encryption=encrypt,permissions=perm)
+
+  return doc
+"""### Extract color"""
+
+def DetectColor(img,color=0):
+
+  imgCopy=img.copy()
+  imgCopy=cv2.cvtColor(imgCopy,cv2.COLOR_BGR2HSV)
+  tol=5 #tolerance
+  # color=hexRGB(color)
+  h,s,v = cv2.cvtColor(np.uint8([[[color[2],color[1],color[0]]]]),cv2.COLOR_BGR2HSV)[0][0]
+
+  lower =np.array( [h- tol, 100, 100 ], dtype='uint8')
+  upper = np.array( [h + tol, 255, 255],dtype='uint8')
+
+  mask = cv2.inRange(imgCopy, lower , upper)
+
+  detectedColors = cv2.bitwise_and(imgCopy,imgCopy, mask= mask)   # Bitwise-AND mask and original image
+
+  kernel=np.ones((3,3),np.uint8)
+  mask=cv2.dilate(mask,kernel, iterations=5)
+  mask=cv2.erode(mask,kernel, iterations=4)
+
+  detectedColors=cv2.dilate(detectedColors,kernel, iterations=5)
+  detectedColors=cv2.erode(detectedColors,kernel, iterations=4)
+
+  detectedColors=cv2.cvtColor(detectedColors,cv2.COLOR_HSV2BGR)
+  detectedColors=cv2.medianBlur(detectedColors,7)
+  # cv2_imshow(detectedColors)
+
+  return mask
+
+"""### For backend - calc area and perim"""
+
+def getAreaPerimeter(pdfpath, plan):
+  dbx=db.dropbox_connect()
+  md, res =dbx.files_download(path= pdfpath+plan)
+  data = res.content
+  doc=fitz.open("pdf", data)
+  for page in doc:
+      pix = page.get_pixmap(dpi=200)  # render page to an image
+      pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+      img=np.array(pl)
+      print(img.shape)
+      img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+  mask=DetectColor(img,color=(73,0,130)) #detect colored rect drawn on the pdf
+
+  contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+  for contour in contours:
+      area = cv2.contourArea(contour)
+      perimeter = cv2.arcLength(contour, True)
+  return area,perimeter

tameem3_2.py

@@ -0,0 +1,659 @@
+# -*- coding: utf-8 -*-
+"""3.2(Ready for new interface).ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/16maX93rvCuU14RBPDK60YxXqxv7aB4Jz
+
+# Libraries
+"""
+
+# from google.colab.patches import cv2_imshow
+import cv2
+import numpy as np
+import pandas as pd
+
+import statistics
+from statistics import mode
+
+from PIL import Image
+
+# !pip install easydev
+# !pip install colormap
+# !pip install extcolors
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+import extcolors
+
+from colormap import rgb2hex
+
+# !pip install pypdfium2
+
+import pypdfium2 as pdfium
+import math
+import fitz
+import db
+import pilecaps_adr
+"""# Reading Pdf file and returning image ready to use
+
+"""
+
+def convert2img(path):
+    pdf = pdfium.PdfDocument(path)
+    page = pdf.get_page(0)
+    pil_image = page.render().to_pil()
+    pl1=np.array(pil_image)
+    img = cv2.cvtColor(pl1, cv2.COLOR_RGB2BGR)
+    return img
+
+def readImgggg(img):
+  hsv  = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+  return hsv
+
+#change Background to red, this step before changing the gray shapes
+#This function helps in improving colour extraction later in the code
+def changeBackground(img):
+  imgCopy = img.copy()
+  hsv = cv2.cvtColor(imgCopy, cv2.COLOR_BGR2HSV)
+  white_range_low = np.array([0,0,250])
+  white_range_high = np.array([0,0,255])
+  mask2=cv2.inRange(hsv,white_range_low, white_range_high)
+  imgCopy[mask2>0]=(0,0,255)
+  return imgCopy
+
+#If there any gray shapes it will be changed to blue
+def changeGrayModify(img):
+  noGray = changeBackground(img)
+  hsv = cv2.cvtColor(noGray, cv2.COLOR_BGR2HSV)
+  gray_range_low = np.array([0,0,170])
+  gray_range_high = np.array([150,30,255])
+  mask=cv2.inRange(hsv,gray_range_low,gray_range_high)
+  noGray[mask>0]=(255,0,0)
+  return noGray
+
+#We may use this function to return background to white after changing the gray shapes to blue
+def returnWhite(img):
+  imgCopy = img.copy()
+  hsv = cv2.cvtColor(imgCopy, cv2.COLOR_BGR2HSV)
+  red_range_low = np.array([0,250,250])
+  red_range_high = np.array([0,255,255])
+  mask2=cv2.inRange(hsv,red_range_low, red_range_high)
+  imgCopy[mask2>0]=(255,255,255)
+  return imgCopy
+
+"""# Extracting colours for the next phase (preprocessing)"""
+
+#This function will take the image with red background and extract all the colours in the plan
+def extractClrs(medianF):
+  im = cv2.cvtColor(medianF, cv2.COLOR_BGR2RGB)
+  im = Image.fromarray(im)
+  colors_x = extcolors.extract_from_image(im,8,8)
+  listofTuples = []
+  for i in range(len(colors_x[0])):
+    listofTuples.append(colors_x[0][i][0])
+  rgb = []
+  for i in range(len(listofTuples)):
+    rgb.append([])
+  for i in range(len(listofTuples)):
+    for j in range(len(listofTuples[i])):
+      rgb[i].append(listofTuples[i][j])
+  rgb = np.uint8([[rgb]])
+  clr_hsv = []
+  for i in range(len(rgb)):
+    clr_hsv.append(cv2.cvtColor(rgb[i], cv2.COLOR_RGB2HSV))
+  return clr_hsv
+
+#Used to delete any gray or white colours detected
+def deleteZeroHue(clr_hsv):
+  clr_hsv_short = []
+  for i in range(len(clr_hsv[0][0])):
+    if clr_hsv[0][0][i][0] > 0:
+      clr_hsv_short.append(clr_hsv[0][0][i])
+  return clr_hsv_short
+
+#Saving the region of the different colours in the plan
+def dividingInput(clr_hsv_short):
+  hInput = []
+  sInput = []
+  vInput = []
+  for i in range(len(clr_hsv_short)):
+    hInput.append(clr_hsv_short[i][0])
+    sInput.append(clr_hsv_short[i][1])
+    vInput.append(clr_hsv_short[i][2])
+  return hInput, sInput, vInput
+
+#Setting the range of upper and lower range of the Hue of different colours
+#Will be used to separate each shape inside the plan in a different img due to their different colours
+def setRange(n, hInput):
+  lower = []
+  upper = []
+  for i in range(len(hInput)):
+    if (hInput[i] - n > 0):
+      lower.append(np.uint(hInput[i] - n))
+    else:
+      lower.append(np.uint(hInput[i]))
+    upper.append(np.uint(hInput[i] + n))
+  return lower, upper
+
+"""# Reading the image's colours"""
+
+#Saving all the hues, saturations, values of the plan
+def getColoursImage(hsv, img):
+  hue = hsv[:,:,0]
+  saturation = hsv[:,:,1]
+  value = hsv[:,:,2]
+  h=[]
+  s=[]
+  v=[]
+
+  for i in range(img.shape[1]):
+    for j in range(img.shape[0]):
+      if hue[j][i] > 0 :
+        h.append(hue[j][i])
+        s.append(saturation[j][i])
+        v.append(value[j][i])
+  return h,s,v
+
+#Putting different hues in different categories (each colour is a category)
+def categorizeV4(hsv, lower, upper, img):
+  h, s, v = getColoursImage(hsv, img)
+  groups = []
+  for i in range(len(lower)):
+    groups.append([])
+  for i in range(len(h)):
+    for j in range(len(lower)):
+      if h[i] in range(lower[j],upper[j]):
+        groups[j].append([h[i], s[i], v[i]])
+  return groups
+
+#Putting the hue, saturation, values in the categories
+def getHuesV3(categorey):
+  hues = []
+  for i in range(len(categorey)):
+    hues.append([])
+  for i in range(len(categorey)):
+    for j in range(len(categorey[i])):
+      hues[i].append(categorey[i][j][0])
+  return hues
+
+def getSaturationsV3(categorey):
+  saturations = []
+  for i in range(len(categorey)):
+    saturations.append([])
+  for i in range(len(categorey)):
+    for j in range(len(categorey[i])):
+      saturations[i].append(categorey[i][j][1])
+  return saturations
+
+def getValuesV3(categorey):
+  values = []
+  for i in range(len(categorey)):
+    values.append([])
+  for i in range(len(categorey)):
+    for j in range(len(categorey[i])):
+      values[i].append(categorey[i][j][2])
+  return values
+
+#Getting the maximum and minimum of each h,s,v of each category
+def setBoundaries(hues, saturations, values):
+
+  hueMin = []
+  hueMax = []
+  satMin = []
+  satMax = []
+  valMin = []
+  valMax = []
+
+  for i in range(len(hues)):
+    hueMin.append(min(hues[i]))
+    hueMax.append(max(hues[i]))
+
+  for i in range(len(saturations)):
+    satMin.append(min(saturations[i]))
+    satMax.append(max(saturations[i]))
+
+  for i in range(len(values)):
+    valMin.append(min(values[i]))
+    valMax.append(max(values[i]))
+  return hueMin, hueMax, satMin, satMax, valMin, valMax
+
+"""# Colour Segmentation"""
+
+#Producing List of images, each image contains a shape of different Colour (imgResult)
+def segment(hueMin, hueMax, satMin, satMax, valMin, valMax):
+  lowerRange = []
+  upperRange = []
+  for i in range(len(hueMin)):
+    #lowerRange.append([hueMin[i], satMin[i]  , valMin[i]])
+    lowerRange.append([hueMin[i], np.uint8(satMin[i] +15)  , valMin[i]])
+    upperRange.append([hueMax[i], satMax[i], valMax[i]])
+  lower_range = np.array(lowerRange)
+  upper_range = np.array(upperRange)
+  return lower_range, upper_range
+
+
+def masking(lower_range, upper_range, hsvMedian, img):
+  mask = []
+  imgResult = []
+  for i in range(len(lower_range)):
+    mask.append(cv2.inRange(hsvMedian, lower_range[i], upper_range[i]))
+  for j in range(len(lower_range)):
+    imgResult.append(cv2.bitwise_and(img, img, mask=mask[j]))
+  return imgResult
+
+"""# Preprocessing"""
+
+# Returning a Clean Image ready to be used in measurement
+def bluring(imgResult):
+  imgGray = []
+  imgBlur = []
+  for i in range(len(imgResult)):
+    imgGray.append(cv2.cvtColor(imgResult[i], cv2.COLOR_BGR2GRAY))
+  for i in range(len(imgGray)):
+    imgBlur.append(cv2.GaussianBlur(imgGray[i], (5,5),3))
+  return imgBlur
+
+def preprocessing(imgBlur):
+  imTT = []
+  th2 = []
+  for i in range(len(imgBlur)):
+    imTT.append([])
+  for k in range(len(imgBlur)):
+    for i in range(imgBlur[k].shape[1]):
+      for j in range(imgBlur[k].shape[0]):
+        if imgBlur[k][j][i] > 5:
+          imTT[k].append(imgBlur[k][j][i])
+  modd = []
+  for i in range(len(imTT)):
+    modd.append(mode(imTT[i]))
+  for i in range(len(imgBlur)):
+    th2.append(cv2.threshold(imgBlur[i],modd[i]-70,255,cv2.THRESH_BINARY))
+  return th2
+
+def is_contour_bad(c):
+	peri = cv2.arcLength(c, True)
+	approx = cv2.approxPolyDP(c, 0.02 * peri, True)
+	return  cv2.contourArea(c) < 1200
+
+def beforeCelaning(maskBad, th2):
+  imgb4Cleaned = []
+  for i in range(len(th2)):
+    imgb4Cleaned.append(th2[i][1].copy())
+  return imgb4Cleaned
+
+def badMask(imgResult, img):
+  maskBad = []
+  for i in range(len(imgResult)):
+    maskBad.append(np.ones(img.shape[:2], dtype="uint8") * 255)
+  return maskBad
+
+def applyBadContours(imgb4Cleaned, th2, maskBad):
+  imgCleaned = []
+  for j in range(len(th2)):
+    contours, hierarchy = cv2.findContours(image=th2[j][1], mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE)
+    for k, cnt in enumerate(contours):
+      if is_contour_bad(cnt):
+        cv2.drawContours(maskBad[j], [cnt], -1, 0, -1)
+    imgCleaned.append(cv2.bitwise_and(imgb4Cleaned[j], th2[j][1], mask=maskBad[j]))
+  return imgCleaned
+def morph(imgCleaned):
+  dilations = []
+  kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
+  for i in range(len(imgCleaned)):
+    dilations.append(cv2.dilate(imgCleaned[i], kernel, iterations=2))
+  return dilations
+
+"""# (optional) If we want to get those rectangle colours in producing Legends"""
+
+def extractNewRgb(imgResult):
+  im = cv2.cvtColor(imgResult, cv2.COLOR_BGR2RGB)
+  im = Image.fromarray(im)
+  colors_x = extcolors.extract_from_image(im,2,2)
+
+  listofTuples = []
+  for i in range(len(colors_x[0])):
+    listofTuples.append(colors_x[0][i][0])
+  rgb = []
+  for i in range(len(listofTuples)):
+    rgb.append([])
+  for i in range(len(listofTuples)):
+    for j in range(len(listofTuples[i])):
+      rgb[i].append(listofTuples[i][j])
+  return rgb
+
+def intRgb(imgResult):
+  list_keda = []
+  for i in range(len(imgResult)):
+    list_keda.append(extractNewRgb(imgResult[i]))
+  newRgb = []
+  for i in range(len(list_keda)):
+    newRgb.append(list_keda[i][1])
+
+  list_int = []
+  for i in range(len(newRgb)):
+    list_int.append([])
+
+  for i in range(len(newRgb)):
+    for j in range(len(newRgb[i])):
+      list_int[i].append(int(newRgb[i][j]))
+  return list_int
+
+def rgb2hexa(list_int):
+  x = []
+  for i in range(len(list_int)):
+    x.append(rgb2hex(list_int[i][0],list_int[i][1],list_int[i][2]))
+  return x
+
+# (optional) If we want to get those rectangle colours in producing Legends
+
+def extractNewRgb(imgResult):
+  im = cv2.cvtColor(imgResult, cv2.COLOR_BGR2RGB)
+  im = Image.fromarray(im)
+  colors_x = extcolors.extract_from_image(im,2,2)
+
+  listofTuples = []
+  for i in range(len(colors_x[0])):
+    listofTuples.append(colors_x[0][i][0])
+  rgb = []
+  for i in range(len(listofTuples)):
+    rgb.append([])
+  for i in range(len(listofTuples)):
+    for j in range(len(listofTuples[i])):
+      rgb[i].append(listofTuples[i][j])
+  return rgb
+
+def intRgb(imgResult):
+  list_keda = []
+  for i in range(len(imgResult)):
+    list_keda.append(extractNewRgb(imgResult[i]))
+  newRgb = []
+  for i in range(len(list_keda)):
+    newRgb.append(list_keda[i][1])
+
+  list_int = []
+  for i in range(len(newRgb)):
+    list_int.append([])
+
+  for i in range(len(newRgb)):
+    for j in range(len(newRgb[i])):
+      list_int[i].append(int(newRgb[i][j]))
+  return list_int
+
+def rgb2hexa(list_int):
+  x = []
+  for i in range(len(list_int)):
+    x.append(rgb2hex(list_int[i][0],list_int[i][1],list_int[i][2]))
+  return x
+
+
+"""# Measuring Area
+
+"""
+
+# Produce List of shape's area in PPIXELS
+def getArea(dilation):
+  contourzz, hierarchy = cv2.findContours(image=dilation, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  areaa = 0
+
+  for i, cnt3 in enumerate(contourzz):
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    area3 = cv2.contourArea(cnt3)
+    areaa = areaa+area3
+  return areaa
+
+def measure(dilations):
+  areas = []
+  for i in range(len(dilations)):
+    areas.append(getArea(dilations[i]))
+  return areas
+
+#Producing Image with drawing Contours and putting the number of areas as text on the shape
+def getDrawing(page,ratio,dilation, img ,areaRatio,perimRatio):
+
+  contourzz, hierarchy = cv2.findContours(image=dilation, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  areaa = 0
+  perimeter = 0
+  imgNew = img
+
+  for i, cnt3 in enumerate(contourzz):
+    shape=[]
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    area3 = cv2.contourArea(cnt3)
+    areaRatio1= area3*areaRatio
+    areaa = areaa+area3
+    perimeter3 = cv2.arcLength(cnt3, True)
+    perimeterRatio1=perimeter3*perimRatio
+    perimeterr = perimeter+perimeter3
+    approx = cv2.approxPolyDP(cnt3, 0.005 * perimeter3, True)
+    for point in approx:
+      x1, y1 = point[0] 
+      shape.append([int(x1*ratio),int(y1*ratio)])
+    #areaa = round(areaa * 15.25/13480.0, 3)
+
+
+    cv2.putText(imgNew, f'Area :{areaa}', (x2, y2), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+    imgNew = cv2.drawContours(img, [cnt3], -1, (0,255,255), 3)
+    annot = page.add_polygon_annot( points=shape )  # 'Polygon'
+    annot.set_border(width=0.3, dashes=[2])
+    annot.set_colors( fill=(  0 ,  1, 1 ) ) 
+    # annot.set_colors( fill=(1,0,1) )
+    annot.set_opacity(0.5)
+    annot.set_info(content='Area='+str(areaRatio1)+' m2' +'\n \nPerimeter='+str(perimeterRatio1)+' m',subject='ADR Team')#,title='uuum')
+    # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+    annot.update()
+  # doc.save('tameem.pdf', deflate=True)
+  return imgNew
+
+
+def exDraw(plan, dilations, img, pdfpath,areaRatio,perimRatio):
+  ## 
+  doc = fitz.open('dropbox_plans/3.2/'+plan)
+  page = doc[0]    
+  page.set_rotation(0)
+  pix=page.get_pixmap()
+  ratio =  pix.width/ img.shape[1] 
+  ###
+  print(pdfpath)
+  newImg = img
+  for i in range(len(dilations)):
+    newImg = (getDrawing(page,ratio, dilations[i], img ,areaRatio,perimRatio))
+  # doc.save('tameem.pdf', deflate=True)
+  pdflink= db.dropbox_upload_file(doc=doc,pdfname=plan,pdfpath=pdfpath)
+  
+  print(pdflink)
+  return newImg , pdflink
+# Perimeter
+
+def getPerimeter(dilation):
+  contourzz, hierarchy = cv2.findContours(image=dilation, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  perimeter = 0
+  for i, cnt3 in enumerate(contourzz):
+    #imgResult4 = img.copy()
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    perimeter3 = cv2.arcLength(cnt3, True)
+    perimeter = perimeter+perimeter3
+  return perimeter
+def measureP(dilations):
+  perimeters = []
+  for i in range(len(dilations)):
+    perimeters.append(getPerimeter(dilations[i]))
+  return perimeters
+
+# Number of Shapes
+
+
+def getNumber(dilation):
+  contourzz, hierarchy = cv2.findContours(image=dilation, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  n_shapes = 0
+  for i, cnt3 in enumerate(contourzz):
+    #imgResult4 = img.copy()
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    n_shapes = n_shapes + 1
+  return n_shapes
+
+def countShapes(dilations):
+  n_shapes = []
+  for i in range(len(dilations)):
+    n_shapes.append(getNumber(dilations[i]))
+  return n_shapes
+
+# Length
+
+
+def getLength(dilation):
+  contourzz, hierarchy = cv2.findContours(image=dilation, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  perimeter = 0
+  for i, cnt3 in enumerate(contourzz):
+    #imgResult4 = img.copy()
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    x, y, w, h = cv2.boundingRect(cnt3)
+  return w
+def measureL(dilations):
+  Length = []
+  for i in range(len(dilations)):
+    Length.append(getLength(dilations[i]))
+  return Length
+
+"""# Converting Pixels to M2
+
+"""
+
+#Producing Reference Object and calculating it's vale in PIXELS
+def calcRef(img):
+  blk = np.ones(img.shape, dtype="uint8") * [[[np.uint8(0), np.uint8(0), np.uint8(0)]]]
+
+  start_point = (50, 100)
+  end_point = (120, 200)
+  color = (255, 255, 255) # white BGR
+  thickness = -1 # Thickness of -1 will fill the entire shape
+
+  blk = cv2.rectangle(blk, start_point, end_point, color, thickness)
+
+  blk = cv2.cvtColor(blk, cv2.COLOR_BGR2GRAY)
+
+  contourzz, hierarchy = cv2.findContours(image=blk, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)
+  for i, cnt3 in enumerate(contourzz):
+    M = cv2.moments(cnt3)
+    if M['m00'] != 0.0:
+      x2 = int(M['m10']/M['m00'])
+      y2 = int(M['m01']/M['m00'])
+    area = cv2.contourArea(cnt3)
+    return area
+
+# Saving the Area of the Reference object in M2 that we get from the user
+def getRealRef(area):
+  areaFromUser = area
+  return areaFromUser
+
+# Calculating the M2 areas of each shape and saving them in a List
+# areaGotFromUser --> User will pass it after measuring the produced shape in BB
+# areaPixelRef --> will get it from calcRef() function
+# areas --> will get it from the measure() function in the "Measuring Area Cells"
+def m2R(PixelMetricRatio, areas):
+  mreal = []
+  for i in range(len(areas)):
+    mreal.append(areas[i] * PixelMetricRatio) 
+  return mreal
+
+"""# Another approach (Getting the display screen dimensions from user)"""
+
+def ppi_calculate(width, height, inch):
+  diagonal = math.sqrt((width**2 )+(height**2))
+  ppi = diagonal / inch
+  ppi2 = ppi * ppi
+  return ppi2
+def convertToMeterSQ(ratio, areas):
+  areaM2 = []
+  for i in range(len(areas)):
+    areaM2.append(round(areas[i] * ratio, 3)) # true value of area of any shape/ area px value of same shape
+  return areaM2
+
+"""# Main Function That calls all of the above functions"""
+
+def mainFunction(plan, areaRatio ,perimRatio, pdfpath):
+    plan1='dropbox_plans/3.2/'+str(plan)
+    img = convert2img(plan1)
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    imgChange = changeGrayModify(img)
+    hsv = readImgggg(imgChange)
+    clr_hsv = extractClrs(imgChange)
+    clr_hsv_short = deleteZeroHue(clr_hsv)
+    hInput, sInput, vInput = dividingInput(clr_hsv_short)
+    lower, upper = setRange(5, hInput)
+    cat2 = categorizeV4(hsv, lower, upper, img)
+    hues = getHuesV3(cat2)
+    values = getValuesV3(cat2)
+    saturations = getSaturationsV3(cat2)
+    hueMin, hueMax, satMin, satMax, valMin, valMax = setBoundaries(hues, saturations, values)
+    lower_range, upper_range = segment(hueMin, hueMax, satMin, satMax, valMin, valMax)
+    imgResult = masking(lower_range, upper_range, hsv, img)
+    ##For the Legend newRgb and hexClrs, make the main function returns one of the following two variables
+    ## newRgb or hexClrs
+    newRgb = intRgb(imgResult)
+    hexClrs = rgb2hexa(newRgb)
+    imgBlur = bluring(imgResult)
+    th2 = preprocessing(imgBlur)
+    maskBad = badMask(imgResult, img)
+    imgb4Cleaned = beforeCelaning(maskBad,th2)
+    imgCleaned = applyBadContours(imgb4Cleaned, th2, maskBad)
+    dilations = morph(imgCleaned)
+    # newImg , pdflink = exDraw(plan, dilations, img , pdfpath)
+    areas = measure(imgCleaned)
+    perimeters = measureP(imgCleaned)
+    quantites = countShapes(imgCleaned)
+    length = measureL(imgCleaned)
+
+    # area_ref_pixel, perimeter_ref_pixel = calcRef(img)
+
+    # area_ref_real = getRealRef(areaRef)
+    # perimeter_ref_real = getRealRefL(perimeterRef)
+    realArea = m2R(areaRatio, areas)
+    realPerimeter = m2R(perimRatio, perimeters)
+
+    newImg  , pdflink= exDraw(plan,dilations, img, pdfpath,areaRatio, perimRatio )
+    data = {
+        'Color' : newRgb,
+        'Occurences': quantites,
+        'Area':realArea,
+        'Total Area': realArea,
+        'Perimeter':perimeters,
+        'Total Perimeter': perimeters,
+        'Length': length,
+        'Total Length': length}
+    df = pd.DataFrame(data)
+    print(df)
+
+
+    gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr= pilecaps_adr.legendGoogleSheets(df,plan ,pdfpath)
+
+    dbx=db.dropbox_connect()
+
+    md, res =dbx.files_download(path= pdfpath+plan)
+    data = res.content
+
+    doc=fitz.open("pdf", data)
+    # list1=pd.DataFrame(columns=['content', 'creationDate', 'id', 'modDate', 'name', 'subject', 'title'])
+    list1=pd.DataFrame(columns=['content',  'id',  'subject'])
+    for page in doc:
+        for annot in page.annots():
+            list1.loc[len(list1)] =annot.info
+    print(list1)
+    return newImg, df , pdflink , spreadsheetId, spreadsheet_url   , list1