Update app.py

app.py

@@ -1,58 +1,357 @@
-import copy_of_xorPileCaps 
-    # copy_of_xorPileCaps.Pick
-
+import numpy as np 
+import cv2 
 import gradio as gr
+import fitz
+import pandas as pd
+from PIL import Image
+import os
+from db import dropbox_upload_file
+from pathlib import Path
+from PreprocessingFoundation import rmv_text,rmv_dashedLines
+
+#############################################################################################
+
+'''push output to dropbox'''
+#os.remove('dropbox_plans/Trees.pdf')
+
+
+def pushToDropbox(plan1,area,perim,df):
+    plan=Path(os.path.split(plan1)[1]).stem
+    p=dropbox_upload_file('.',local_file=perim,dropbox_file_path='/savedMeasurements/'+plan+'perim.png') 
+    a=dropbox_upload_file('.',local_file=area,dropbox_file_path='/savedMeasurements/'+plan+'area.png')
+    d=dropbox_upload_file('.',local_file=df,dropbox_file_path='/savedMeasurements/'+plan+'summary.csv')
+    #print(f)
+
+def auth(username,password):
+   if username=="alaa" and password=="1234":
+       return True
+      
+   
+
+############################################################################################
+
+def plan2img(plan):
+    if 'foundation' in plan.lower():
+         noTextImg=rmv_text(plan)
+         clean_img=rmv_dashedLines(noTextImg)
+         return clean_img
+    
+    else:
+        fname = plan
+        #op='pictures/found.png'
+        doc = fitz.open(fname)  # open document
+        for page in doc:
+            pix = page.get_pixmap()  # render page to an image
+            pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+            pl1=np.array(pl)
+        return pl1
+   
+
+    
+    
+    
+    
+
+##################################################################################################3
+
+def detectCircles(imagesliced ):
+  copy=imagesliced.copy()
+  imgGry1 = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY)
+  gray_blurred = cv2.medianBlur(imgGry1, 1)
+  # gray_blurred = cv2.blur(imgGry1, (9,9 ))
+  kernel=np.ones((2,2),np.uint8)
+  er1=cv2.erode(gray_blurred,kernel, iterations=3)
+  # Apply Hough transform on the blurred image.
+   # min distance between circles,  Upper threshold for the internal Canny edge detector.
+  detected_circles = cv2.HoughCircles( er1, cv2.HOUGH_GRADIENT, 1, 100, param1 = 300,
+                    param2 = 16, minRadius = 15, maxRadius = 50) #18 param2
+    
+  # Draw circles that are detected.
+  if detected_circles is not None:
+      # Convert the circle parameters a, b and r to integers.
+      detected_circles = np.uint16(np.around(detected_circles))
+      detected_circles = np.round(detected_circles[0, :]).astype("int")
+    
+      for (x, y, r) in detected_circles:
+        cv2.circle(copy, (x, y), r, (0, 255, 0), 4)
+  # cv2_imshow(copy)
+  if detected_circles is not None:
+    return len(detected_circles)
+
+
+''' call if pile caps plans are chosen'''
+def PileCaps(img):
+  
+  imgGry = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+  blur = cv2.medianBlur(imgGry, 3)
+  kernel=np.ones((3,4),np.uint8)
+  er2=cv2.dilate(blur,kernel, iterations=2)
+  ret3, thresh = cv2.threshold(er2, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+
+  imgArea= img.copy()
+  imgPerimeter=img.copy()
+  imgtransparent=img.copy()
+
+  imgHeight,imgWidth,_=img.shape
+  count1=0
+  count2=0
+  count3=0
+  count4=0
+  count5=0
+  count6=0
+
+  Array1area=[]
+  Array2area=[]
+  Array3area=[]
+  Array4area=[]
+  Array5area=[]
+  Array6area=[]
+
+  Array1Perimeter=[]
+  Array2Perimeter=[]
+  Array3Perimeter=[]
+  Array4Perimeter=[]
+  Array5Perimeter=[]
+  Array6Perimeter=[]
+    
+  
+  #getcontours
+  contours , hier = cv2.findContours(thresh , mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_NONE)
+  for contour in contours:
+    area = cv2.contourArea(contour)
+    perimeter = cv2.arcLength(contour, True)  
+    x, y , width, height = cv2.boundingRect(contour) 
+    if area > 1500 :# and height > 50:
+      approx = cv2.approxPolyDP(contour, 0.01*cv2.arcLength(contour, True), True)
+      # cv2.drawContours(imgArea, [contour], 0, (0, 0, 255), 5)
+      # cv2.drawContours(imgPerimeter, [contour], 0, (0, 0, 255), 10)
+
+      aspectRatio= float(width) / height
+      imagesliced = imgArea[ y:y+height , x:x+width ]
+      circles=detectCircles(imagesliced)
+      if len(approx) >= 4 and len(approx) <= 8:
+        # if aspectRatio >=0.9 and aspectRatio <= 1.1:
+        if circles == 1:
+          count1+=1
+          cv2.drawContours(imgArea,  [contour], 0, (240, 213,  175), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (240, 213,  175), 3 )
+          Array1area.append(area)
+          Array1Perimeter.append(perimeter)
+        elif circles == 2:
+          count2+=1
+          cv2.drawContours(imgArea,  [contour], 0, (50, 200,  20), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (50, 200,  20), 3 )
+          Array2area.append(area)
+          Array2Perimeter.append(perimeter)
+        elif circles == 3:
+          count3+=1
+          cv2.drawContours(imgArea,  [contour], 0, (0, 150,  255), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (0, 150,  255), 3 )
+          Array3area.append(area)
+          Array3Perimeter.append(perimeter)
+        elif circles ==4:
+          count4+=1
+          cv2.drawContours(imgArea,  [contour], 0, (240, 213,  0), -1 )
+          cv2.drawContours(imgPerimeter, [contour], 0, (240, 213,  0), 3)
+          Array4area.append(area)
+          Array4Perimeter.append(perimeter)
+        elif circles==5:
+          count5+=1
+          cv2.drawContours(imgArea,  [contour], 0, (200, 20,  100), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (200, 20,  100), 3 )
+          Array5area.append(area)
+          Array5Perimeter.append(perimeter)
+        elif circles==6:
+          count6+=1
+          cv2.drawContours(imgArea,  [contour], 0, (240, 0,  0), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (240, 0,  0), 3 )
+          Array6area.append(area)
+          Array6Perimeter.append(perimeter)
+        else:
+          cv2.putText(imgArea,str(len(approx)), (x+20,y-20)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, 	(0,0,128), 2)
+          cv2.drawContours(imgArea,  [contour], 0, (180, 100,  0), -1 )
+          cv2.drawContours(imgPerimeter,  [contour], 0, (180, 100,  0), 3 )
+      else:
+        cv2.putText(imgArea,str(len(approx)), (x+20,y-20)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, 	(0,0,128), 2)
+        cv2.drawContours(imgArea,  [contour], 0, (180, 100,  200), -1 )
+        cv2.drawContours(imgPerimeter,  [contour], 0, (180, 100,  200), 3 )        
+
+      alpha = 0.4  # Transparency factor.
+      image_new = cv2.addWeighted(imgArea, alpha,  imgtransparent, 1 - alpha, 0)
+
+      cv2.putText(imgArea,'Area= ' + str(area) + ' px', (x+50,y-50)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, 	(0,0,128), 2)
+      cv2.putText(imgPerimeter,'Perimeter= '+str(round(perimeter, 2)) + ' px', (x+50,y-50)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+  
+  #dataframe for counts, areas, perimeter
+  data = {'Number of Piles':['1','2','3','4','5','6'],'Count': [count1,count2,count3,count4,count5,count6], 'Areas' : [avg(Array1area),avg(Array2area),avg(Array3area),avg(Array4area),avg(Array5area),avg(Array6area)], 'Perimeter': [avg(Array1Perimeter), avg(Array2Perimeter), avg(Array3Perimeter), avg(Array4Perimeter), avg(Array5Perimeter),avg(Array6Perimeter)] }
+  df= pd.DataFrame(data)
+
+  return image_new, imgPerimeter, df
+
+
+''' call if foundation plans are chosen'''
+def IsolatedFoundations(img1):
+  img=cv2.cvtColor(img1, cv2.COLOR_RGB2BGR)
+  arrayAreaSquares=[]
+  arrayAreaGB1=[]
+  arrayAreaGB2=[]
+
+  arrayPerimeterSquares=[]
+  arrayPerimeterGB1=[]
+  arrayPerimeterGB2=[]
+
 
+  countSquares=0
+  countGB1=0
+  countGB2=0
 
-with gr.Blocks() as mainBlock:
-  # def switch(s: int):
-  #     """Textbox visibility is turned off when s = 0, and is on otherwise.""" 
-  #     return gr.ColorPicker.update(visible=True)
-  with gr.Row():
-    out1=0
-    with gr.Column():
-    #  inputs0 = [
-      in1=gr.Image(label="icon", type="pil", image_mode="RGBA")
-      # gr.Textbox(label="Number of Levels"),
-      # gr.ColorPicker(label="color"),
-      in2=gr.Radio(label="Measurement",choices=["Measure Full Image", "Measure Specified Regions"])
-      in3=gr.Radio(label="Area or Perimeter",choices=["Area", "Perimeter"])   
-      with gr.Row():
-        in4=gr.ColorPicker(label="color" )
-        in5=gr.ColorPicker(label="color" )
-        in6=gr.ColorPicker(label="color" )
-        in7=gr.ColorPicker(label="color" )
-        in8=gr.ColorPicker(label="color" )
-        in9=gr.ColorPicker(label="color" )
-        in10=gr.ColorPicker(label="color" )
-        in11=gr.ColorPicker(label="color" )
-       # updating a should update o
-      # a's visibility depends on s
-      # in4.change(switch, , a)
-
-
-    with gr.Column():
-      out1 = gr.Image(label="Image", type="pil", image_mode="RGBA")
-                  #gr.Dataframe(label='Dictionary' ),  # row_count = (5, "fixed")
-        # ]
-  btn1 = gr.Button("Submit")
-
-
-  with gr.Row():#(visible=False) as output_col:
-    # def submit(in1, in2, in3):
-    #   drawnimg=PickColorContours(in1,in2,in3)
-    #   return  drawnimg, { output_col: gr.update(visible=True) }
-    with gr.Column():
-      num1=gr.Number(label='Real value')
-      num2=gr.Number(label='Pixel value')
-      dp=gr.Dropdown(["m", "cm", "mm"])
-      btn = gr.Button("Submit Ratio")
-    with gr.Column():
-      outputs1 = [
-                gr.Image(label="Image", type="pil", image_mode="RGBA"),
-                gr.Dataframe(label='Dictionary' ),  # row_count = (5, "fixed")
-      ]
-  btn1.click(fn=PickColorContours, inputs=[dp,in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11], outputs=out1)
-  btn.click(fn=PickColorContours, inputs=[dp,in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,num1,num2], outputs=outputs1)
+  #preprocessing
   
-mainBlock.launch(debug=True)
+  imgGry = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+  blur = cv2.medianBlur(imgGry,1)
+  kernel = np.array([[1,4,6,4,1], [4,16,24,16,4], [6,24,-476,24,6],[4,16,24,16,4],[1,4,6,4,1]])  * (-1/256) #unsharp masking kernel 
+  sharpen = cv2.filter2D(blur, -1, kernel)
+  eroded = cv2.erode(sharpen, kernel,iterations =4)
+  dilated= cv2.dilate(eroded, kernel, iterations= 4)
+  kernel1 = np.array([[1,4,6,4,1], [4,16,24,16,4], [6,24,-476,24,6],[4,16,24,16,4],[1,4,6,4,1]])  * (-1/256) #unsharp masking kernel 
+  sharpen1 = cv2.filter2D(dilated, -1, kernel1)
+  ret, thresh = cv2.threshold(sharpen1, 195, 255, cv2.THRESH_BINARY)
+
+  #getContours
+  contours , hier = cv2.findContours(thresh , mode=cv2.RETR_LIST, method=cv2.CHAIN_APPROX_NONE)
+  
+  #drawContours
+  imgArea= img.copy()
+  imgPerimeter=img.copy()
+
+  for contour in contours:
+    x, y , width, height = cv2.boundingRect(contour) 
+    area = cv2.contourArea(contour)
+    # perimeter = cv2.arcLength(contour, True)
+    perimeter=round(cv2.arcLength(contour, True),2)  
+    aspectRatio = float(width)/height
+    #GB1 
+    if  (height >= 70 and height <= 90 ) or (width >=70 and width <=90):
+        if aspectRatio >= 0.9 and aspectRatio <= 1.1  :
+            continue
+        else:
+            countGB1+=1
+            cv2.drawContours(imgArea, [contour], 0, (221, 160, 221), 2)
+            cv2.drawContours(imgPerimeter, [contour], 0, (221, 160, 221), 2)
+            cv2.putText(imgArea,'Area= ' + str(area) + ' px', (x+20,y+30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (221, 160, 221), 2)
+            cv2.putText(imgPerimeter,('Perimeter=' + str(perimeter)+ ' px'), (x,y-10)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+            arrayAreaGB1.append(area)
+            arrayPerimeterGB1.append(perimeter)           
+    #GB2 - red
+    if area > 1700 and area < 1000000 :
+        if (height >= 70 and height <= 90 ) or (width >=70 and width <=90):
+          continue 
+        else:
+            if height > 1020 or width <150:
+              if aspectRatio >= 0.9 and aspectRatio <= 1.1  :
+                continue
+              else:
+                countGB2+=1
+                cv2.drawContours(imgArea, [contour], 0, (0,0,255), 2)
+                cv2.drawContours(imgPerimeter, [contour], 0, (0, 0, 255), 2)
+                cv2.putText(imgArea,'Area=' + str(area) + ' px', (x+20,y+30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+                cv2.putText(imgPerimeter,('Perimeter=' + str(perimeter) + ' px'), (x,y-10)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+                arrayAreaGB2.append(area)
+                arrayPerimeterGB2.append(perimeter)
+          
+    #squares - blue
+    if (area > 2200 ):
+      approx = cv2.approxPolyDP(contour, 0.01*cv2.arcLength(contour, True), True)
+      if len(contour) >= 4:
+        sqarea= float(width)*float(height)
+        
+        if aspectRatio >= 0.95 and aspectRatio <= 1.05 :
+          countSquares+=1
+          cv2.rectangle(imgArea, (x, y), (x + width, y + height), (255,0,0), 2) # square blue
+          cv2.putText(imgArea,'Area= '+ str(sqarea) + ' px', (x+20,y+30)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
+          cv2.rectangle(imgPerimeter, (x, y), (x + width, y + height), (255,0,0), 2) # square blue
+          cv2.putText(imgPerimeter,('Perimeter=' + str(perimeter) + ' px'), (x,y-10)  ,cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
+          arrayAreaSquares.append(area)
+          arrayPerimeterSquares.append(perimeter)
+  
+  #dataframe for counts, areas, perimeter
+  data = {'Type':['Isolated Foundations', 'GB1' , 'GB2'],'Count': [countSquares,countGB1,countGB2], 'Areas' : [avg(arrayAreaSquares),avg(arrayAreaGB1),avg(arrayAreaGB2)], 'Perimeter': [avg(arrayPerimeterSquares), avg(arrayPerimeterGB1), avg(arrayPerimeterGB2)] }
+  df= pd.DataFrame(data)
+    
+  return imgArea,imgPerimeter,df  
+
+
+def avg(arr):
+  if len(arr)==0:
+    return round(sum(arr),2)
+  return round(sum(arr)/ len(arr),2)
+
+
+
+''' General measurement function'''
+def getMeasurement(plan,SaveOP):
+    if plan==None:
+        area,perim,df=None,None,None
+    elif 'foundation' in plan:
+        plan1='dropbox_plans/'+str(plan)
+        img=plan2img(plan1)
+        area,perim,df=IsolatedFoundations(img)
+        #area,perim,df=img,None,None
+    elif 'piles' or 'pc' in plan: #any pile cap
+        plan1='dropbox_plans/'+str(plan)
+        img=plan2img(plan1)
+        area,perim,df=PileCaps(img)
+    if SaveOP:
+        pushToDropbox(plan,area,perim,df)
+
+    return area,perim,df
+##########################################################
+def update_dropdown(project):
+    
+    plans_inrepo=os.listdir('dropbox_plans')
+    #if 'foundation' in radio and project in plans_inrepo
+    matches=[]
+    if project==None:
+        drop=gr.Dropdown.update(choices=matches)
+    else:
+        for x in plans_inrepo:
+            if (project in x): #project name and section in a plan
+                matches.append(x)
+        drop=gr.Dropdown.update(choices=matches)
+            
+    return drop
+        
+######################################################################################
+def clear(demo):
+   return None,None,None,None
+    
+
+
+
+
+
+#############################################################################################################################3
+with gr.Blocks(css="#search {background: orangered}") as demo:
+    with gr.Row():
+            with gr.Column():
+                project=gr.Dropdown(choices=['BMW job1','BMW job2','Project C'],interactive=True,label='Projects')
+                drop=gr.Dropdown(choices=None,interactive=True,label='project parts')
+                radio_button = gr.Dropdown(choices=['foundation','external','interior'], value=None, interactive=True,label='sections')
+               
+                check=gr.Checkbox(label='SaveOutput')
+                show_button = gr.Button(value="Measure",elem_id='search')
+                clr_btn=gr.Button(value='Clear')
+            with gr.Column():
+                img1=gr.Image()
+                img2=gr.Image()
+                df=gr.Dataframe()
+                
+                
+               
+                
+                
+            show_button.click(fn=getMeasurement,inputs=[drop,check],outputs=[img1,img2,df])
+            clr_btn.click(fn=clear,outputs=[project,radio_button,check,drop])
+            project.change(fn=update_dropdown, inputs=[project], outputs=drop)
+demo.launch(debug=True)
+