Update app.py

app.py

@@ -9,8 +9,15 @@ 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
 
 app = Flask(__name__)
 
@@ -18,6 +25,7 @@ out_file = open("static/data/myfile.json", "w")
 
 
 
+
 # @app.route("/")
 # def home():
 #     #lists of the projects el httb3t lel dropdowns w tro7 lel html through the return b nfs el esm hna w hnak
@@ -27,62 +35,44 @@ out_file = open("static/data/myfile.json", "w")
 #info from javascript to python
 @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
-    d =[ {'project':(jsdata , matches)}  ]
     
-    with open('static/data/myfile.json', 'w', encoding ='utf8') as json_file:
-        json.dump(d, json_file, ensure_ascii = False)
-
+    matches=update_dropdown(jsdata) #list f of projects
+    print(matches)
+    return jsonify (list(matches))
 
-    #get projects bl esm da ex: BMW job1
-   
-    
-    return  render_template("proposed-GUI.html",matches=matches)
-#info from python to js 
-@app.route('/getpythondata')
-def get_python_data():
-    SITE_ROOT = os.path.realpath(os.path.dirname(__file__))
-    json_url = os.path.join(SITE_ROOT, "static/data", "myfile.json")
-    data = json.load(open(json_url))
-    #data[0]['project']
-    #matches=update_dropdown(data[0]['project']) #list f of projects
-   
-    return  jsonify(data[0]['project'] )
     
 #get projects of 'project name'
-def update_dropdown(project):
-    
-    plans_inrepo=os.listdir('dropbox_plans')
+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')
+    else:
+        return ''
     #if 'foundation' in radio and project in plans_inrepo
     matches=[] 
-    if project==None:
+    if section==None:
         print('no proj')
        # drop=gr.Dropdown.update(choices=matches)
     else:
         for x in plans_inrepo:
-            if (project in x): #project name and section in a plan
+            # if (project in x): #project name and section in a plan
                 matches.append(x)
         print(matches)
         #drop=gr.Dropdown.update(choices=matches)     
     return matches
-#make the img global using(g) from flask
+
 # @app.before_request
-# def measureImg(img='aa'):
-#     if type(img) is str:
-#         g.img='aa'
-#         print('striiing')
-#         g.measuredimg='aa'
-#     else:
-#         imgPerimeter1,image_new1,SimilarAreaDictionary , colorsUsed=pilecaps_adr.drawAllContours(img,0,[],0,0,'area')
-        
-#         g.image_new1 =image_new1
-#         return image_new1
+# def load_user():
+#     g.doc='none'
+#     g.__doc__ = 'none'
     
 #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)
 
@@ -97,31 +87,31 @@ def hexRGB(color):
 @app.route('/projecttomeasure/<jsdata>',methods=["GET","POST"])
 def measureproject(jsdata):
     colorarr=[]
-    result = json.loads(jsdata) 
-    print('RESULT HEREEE',  result)
-
-    img = plan2img('dropbox_plans/'+str(result[0]) )
-    # g.img=img
-    for item in result[2]:
-        item1 ='#'+item
-        c=hexRGB(item1)
-        colorarr.append(c)
- 
-    imgPerimeter1,image_new1,SimilarAreaDictionary , colorsUsed,spreadsheet_url, spreadsheetId=pilecaps_adr.drawAllContours(img,int(result[1]),colorarr,1.11,25500,'area')
-
-    print('measuredddddd')
- 
-    # img2 = cv2.cvtColor(image_new1, cv2.COLOR_RGB2BGR)
-    _, buffer = cv2.imencode('.png', image_new1)
-
-   # return SimilarAreaDictionary.to_dict()
-    #return 
-    arr=[base64.b64encode(buffer).decode('utf-8'), SimilarAreaDictionary.to_dict() ,spreadsheet_url , spreadsheetId]
-    return  jsonify(arr)#'{}, {} '.format(base64.b64encode(buffer).decode('utf-8') ,  SimilarAreaDictionary )
-#     return Flask.jsonify(data=base64.b64encode(buffer).decode('utf-8'), data1=SimilarAreaDictionary)
-#    return str(measuredimg)
-#     return render_template("proposed-GUI.html")
     
+    result = json.loads(jsdata) 
+  
+    pdfpath='/'
+    for word in result[5]:
+        pdfpath+=word +'/'
+    print(pdfpath)
+    #result[3] ratio of area ,, result[4] ratio of perimeter
+    if result[5][2].startswith('1.0'):
+        img = plan2img('dropbox_plans/1.0/'+str(result[0]) )
+
+        # g.img=img
+        for item in result[2]:
+            item1 ='#'+item
+            c=hexRGB(item1)
+            colorarr.append(c)
+        # result[3],result[4]  (img,number,finalColorArray,ratioarea,ratioperim,flag , path,pdfpath):
+        imgPerimeter1,image_new1,SimilarAreaDictionary , colorsUsed,spreadsheet_url, spreadsheetId,list1, pdflink, areas_Perimeters =pilecaps_adr.drawAllContours(img,int(result[1]),colorarr,1.11/25500,0.1,'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]
+    elif result[5][2].startswith('3.2'): #section value
+        img = plan2img('dropbox_plans/3.2/'+str(result[0]) )
+        #call main function here
+    return  jsonify(arr )
 
 #retrieve all info of elements after clicking 'done' button
 @app.route("/forward/",methods=["GET", "POST"])
@@ -139,7 +129,7 @@ def move_forward():
 #####################
 #pdf to img
 def plan2img(path):
-   
+    
     doc = fitz.open(path)
     for page in doc:
         
@@ -154,8 +144,166 @@ def plan2img(path):
 def sendmctnametoLegend(jsdata):
     result = json.loads(jsdata)
     print(result)
-    pilecaps_adr.mapnametoLegend(result)
-    return jsdata
+    summaryid,guessednamesfinal=pilecaps_adr.mapnametoLegend(result)
+    
+    allreturns=[summaryid,guessednamesfinal]
+    return jsonify(allreturns)
+
+# #####################################
+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
+#    #################################################
+
+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
+
+
+
+
+@app.route("/pixelimg/<jsdata>",methods=["GET", "POST"])
+def getimg(jsdata):
+    
+    jsdata=eval(jsdata)
+    # img = plan2img('dropbox_plans/'+str(jsdata) )
+    if jsdata[1].startswith('1.0'):
+        doc = fitz.open('dropbox_plans/1.0/'+str(jsdata[0]) )
+    elif jsdata[1].startswith('3.2'):
+        doc = fitz.open('dropbox_plans/3.2/'+str(jsdata[0]) )
+    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)
+
+
+    areapixel,perimeterpixel , blkRectImg , imgcopy=modifyingcalcRefDynamic(img)
+    PIL_image = Image.fromarray(np.uint8(imgcopy))
+    PIL_image.save('toMeasure'+str(jsdata)+'.pdf')
+    
+    print(areapixel)
+    outputs=[areapixel,perimeterpixel]
+    return jsonify(outputs)
+
+
+@app.route('/_submission',methods=["GET", "POST"])
+def getnewlegend():
+    pdfpth=''
+    # SimilarAreaDictionary = request.args.get('dict')
+    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+='/'
+    
+    # res = ast.literal_eval(ini_list)
+
+    deletedrows1=pilecaps_adr.deletemarkups(list1=list1,pdfpath=pdfpth,path=path) 
+    print(deletedrows1)
+    arr1=[deletedrows1.to_dict()]
+    return jsonify(arr1)
+
+@app.route('/deletemarkupsroute',methods=["GET", "POST"])
+def dltmarkupslegend():
+
+    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')
+
+
+    myDict=eval(deletedrows)
+    print(type(myDict))
+    deletedrows=pd.DataFrame(myDict)
+    print(deletedrows,type(deletedrows))
+    print(type(SimilarAreaDictionary),type(deletedrows),type(path),type(spreadsheetId))
+    newlgnd=pilecaps_adr.deletefromlegend(deletedrows=deletedrows,SimilarAreaDictionarycopy=SimilarAreaDictionary, areaPermArr=areaPermArr)
+    try:
+        newlgnd1=pilecaps_adr.legendGoogleSheets(SimilarAreaDictionary=newlgnd,path=path, colorsUsed=[1,2,3],spreadsheetId=spreadsheetId) #new legend
+    except:
+        print("An exception occurred")
+        time.sleep(10)
+        newlgnd1=pilecaps_adr.legendGoogleSheets(SimilarAreaDictionary=newlgnd,path=path, colorsUsed=[1,2,3],spreadsheetId=spreadsheetId)
+
+    return jsonify('donee')
+
+
+@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)
+# @app.route('/uploadtodropboxPath/<jsdata>',methods=["GET", "POST"])
+# @app.teardown_request
+# def upload_GetPath(jsdata):
+#     print('ayhagaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa  ', jsdata)
+#     return  jsdata
+#         # db.dropbox_upload_file(doc=,pdfname=)
+
+@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()
+    return jsonify(titles,ids)
+
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)