Upload dxf__omar3_2.py

dxf__omar3_2.py

@@ -0,0 +1,433 @@
+# -*- coding: utf-8 -*-
+"""Version to be deployed of 3.2 Calculating area/perimeter
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1XPeCoTBgWSNBYZ3aMKBteP4YG3w4bORs
+"""
+
+# pip install ezdxf[draw]
+
+# pip install --upgrade ezdxf
+
+# pip install pymupdf #==1.22.5
+
+# pip install PyPDF2
+
+# pip install ezdxf scipy
+
+"""## Imports"""
+
+import numpy as np
+import cv2
+from matplotlib import pyplot as plt
+import math
+from PIL import Image  , ImageDraw, ImageFont , ImageColor
+import fitz
+import ezdxf as ez
+import sys
+from ezdxf import units
+from ezdxf.math import OCS, Matrix44, Vec3
+import ezdxf
+import matplotlib.pyplot as plt
+from matplotlib.patches import Polygon
+from shapely.geometry import Polygon as ShapelyPolygon
+from ezdxf.math import Vec2
+import random
+import pandas as pd
+import google_sheet_Legend
+
+"""## Notes"""
+
+#new approach to get width and height of dxf plan
+'''
+This portion is used to convert vertices read from dxf to pixels in order to accurately locate shapes in the image and pdf
+  ratio :
+  MeasuredMetric* PixelValue/ DxfMetric = MeasuredPixel
+  PixelValue: get from pixel conversion code , second number in the bracker represents the perimeter
+  DxfMetric: measured perimeter from foxit
+
+  divide pixelvalue by dxfmetric, will give u a ratio , this is ur dxfratio
+
+
+'''
+
+
+"""PDF to image"""
+
+def pdftoimg(datadoc):
+  doc = fitz.open('pdf',datadoc)
+  page=doc[0]
+  pix = page.get_pixmap()  # render page to an image
+  pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+  img=np.array(pl)
+  img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+  return img
+
+"""Flips image
+DXF origin is at the bottom left while img origin is top left
+"""
+
+def flip(img):
+  height, width = img.shape[:2]
+
+  # Define the rotation angle (clockwise)
+  angle = 180
+
+  # Calculate the rotation matrix
+  rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), angle, 1)
+
+  # Rotate the image
+  rotated_image = cv2.warpAffine(img, rotation_matrix, (width, height))
+  flipped_horizontal = cv2.flip(rotated_image, 1)
+  return flipped_horizontal
+
+"""### Hatched areas"""
+
+def get_hatched_areas(filename):
+    doc = ezdxf.readfile(filename)
+    doc.header['$MEASUREMENT'] = 1
+    msp = doc.modelspace()
+    trial=0
+    hatched_areas = []
+
+    for entity in msp:
+        # print(entity.dxftype())
+        if entity.dxftype() == 'HATCH':
+            flag=0
+            trial=0
+            # print("Gowa el hatch")
+            for path in entity.paths:
+              # print("gowa el for")
+              try:
+                vertices = [(vertex[0], vertex[1])for vertex in path.vertices]
+                if(len(vertices)>3):
+
+                 poly = ShapelyPolygon(vertices)
+
+                 if poly.area > 0.5:
+                   area1 = round(poly.area,3)
+                   perimeter = round (poly.length,3)
+
+                   if trial==0:
+                     hatched_areas.append([vertices,area1,perimeter])
+                     trial=1
+                    #  print("hatched_areas = ", hatched_areas)
+
+                   else:
+
+                        for i in range(len(hatched_areas)):
+
+                            if(area1 == hatched_areas[i][1]):
+                              flag=1
+
+                        # if(flag==0):
+                        #     hatched_areas.append([vertices,area1])
+
+                  #  hatched_areas.append([vertices,area1])
+                # print("Gowa el hatch2")
+
+
+
+                #  print("Gowa el if ely b3d el hatch")
+
+                # if entity.area > 0.5:
+                #   hatched_areas.append([entity.area])
+
+              except:
+                # print("in except")
+                vert=[]
+                flag=0
+                flag2=0
+                for edge in path.edges:
+                  x,y=edge.start
+                  x1,y1=edge.end
+                  # print(edge.start)
+                  # print(edge.end)
+                  if(flag==0):
+                    vert=[(x,y),(x1,y1)]
+                  else:
+                      vert.append([x1,y1])
+                  flag=1
+                # print(vert)
+                poly = ShapelyPolygon(vert)
+                # print("New Hatch Area = ",poly.area)
+
+                if (poly.area > 0.5):
+                   area1= round(poly.area,3)
+                   perimeter = round (poly.length,3)
+
+                   for i in range(len(hatched_areas)):
+
+                      if(area1 == hatched_areas[i][1]):
+                        flag2=1
+
+                   if(flag2==0):
+                       hatched_areas.append([vert,area1,perimeter])
+                  #  hatched_areas.append([vert,area1])
+                # # hatched_areas.append(vertices)
+                # continue
+
+        elif entity.dxftype() == 'SOLID':
+
+            vertices = [entity.dxf.vtx0, entity.dxf.vtx1, entity.dxf.vtx2, entity.dxf.vtx3]
+            poly = ShapelyPolygon(vertices)
+            # print("Gowa el solid")
+
+
+            if poly.area > 0.5:
+             hatched_areas.append([vertices,poly.area,poly.length])
+            #  print("Gowa el if ely b3d el solid")
+
+
+        elif entity.dxftype() == 'LWPOLYLINE':
+
+           vertices=[]
+           lwpolyline = entity
+           points = lwpolyline.get_points()
+           flag=0
+
+           for i in range(len(points)):
+             vertices.append([points[i][0],points[i][1]])
+           if(len(vertices)>3):
+
+             if(vertices[0][0] == vertices[len(vertices)-1][0]  or vertices[0][1] == vertices[len(vertices)-1][1]):
+
+               poly=ShapelyPolygon(vertices)
+              #  print("vertices==",vertices)
+
+               if poly.area > 0.5:
+
+                area1 = round(poly.area,3)
+                perimeter = round (poly.length,3)
+
+                for i in range(len(hatched_areas)):
+
+                  if(area1 == hatched_areas[i][1]):
+                     flag=1
+
+                if(flag==0):
+                   hatched_areas.append([vertices,area1,perimeter])
+
+
+
+        elif entity.dxftype() == 'SPLINE':
+
+          spline_entity = entity
+
+          vertices = []
+
+          control_points = spline_entity.control_points
+
+
+          if(len(control_points)>3):
+
+            for i in range(len(control_points)):
+              vertices.append([control_points[i][0],control_points[i][1]])
+
+
+
+            poly=ShapelyPolygon(vertices)
+
+
+
+
+            if poly.area > 0.5:
+
+                area1 = round(poly.area,3)
+                perimeter = round (poly.length,3)
+
+                hatched_areas.append([vertices,area1,perimeter])
+    return hatched_areas
+
+"""### Rotate polygon"""
+
+from math import sin, cos, radians
+
+def rotate_point(point, angle,pdfrotation,pdfsize, center_point=(0, 0)):
+    """Rotates a point around center_point(origin by default)
+    Angle is in degrees.
+    Rotation is counter-clockwise
+    """
+    angle_rad = radians(angle % 360)
+    # Shift the point so that center_point becomes the origin
+    new_point = (point[0] - center_point[0], point[1] - center_point[1])
+    new_point = (new_point[0] * cos(angle_rad) - new_point[1] * sin(angle_rad),
+                 new_point[0] * sin(angle_rad) + new_point[1] * cos(angle_rad))
+    # Reverse the shifting we have done
+    if pdfrotation!=0:
+
+      new_point = (new_point[0]+pdfsize[2] + center_point[0], new_point[1]  + center_point[1]) #pdfsize[2] is the same as +width
+    else:
+
+      new_point = (new_point[0] + center_point[0], new_point[1]+ pdfsize[3]  + center_point[1]) # pdfsize[3] is the same as +height
+    # new_point = (new_point[0] + center_point[0], new_point[1] + center_point[1])
+    return new_point
+
+
+def rotate_polygon(polygon, angle, pdfrotation,pdfsize,center_point=(0, 0)):
+    """Rotates the given polygon which consists of corners represented as (x,y)
+    around center_point (origin by default)
+    Rotation is counter-clockwise
+    Angle is in degrees
+    """
+    rotated_polygon = []
+    for corner in polygon:
+        rotated_corner = rotate_point(corner, angle,pdfrotation,pdfsize, center_point)
+        rotated_polygon.append(rotated_corner)
+    return rotated_polygon
+
+#create a dataframe containing color , count(how many times is this object found in the plan), area of 1 of these shapes, total area
+#perimeter, totat perimeter, length, total length
+#import pandas as pd
+#SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
+#loop 3la hatched areas and count the occurences of each shape w create a table bl hagat di
+
+def generate_color_array(length):
+    colorRanges = []
+    while len(colorRanges) < length:
+        # Generate random RGB values
+        r = random.randint(0, 255)
+        g = random.randint(0, 255)
+        b = random.randint(0, 255)
+        # Ensure no duplicate colors
+        if (r, g, b) not in colorRanges:
+            colorRanges.append((r, g, b))
+    return colorRanges
+
+def Create_DF(dxfpath):
+
+  hatched_areas = get_hatched_areas(dxfpath)
+  # SimilarAreaDictionary= pd.DataFrame(columns=['Area', 'Total Area', 'Perimeter', 'Total Perimeter', 'Occurences', 'Color'])
+  SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','Texts'])
+    
+  colorRanges=generate_color_array(300)
+  TotalArea=0
+  TotalPerimeter=0
+  for i in range(len(hatched_areas)):
+      area = hatched_areas[i][1]  # area
+      perimeter = hatched_areas[i][2]  # perimeter
+      color = colorRanges[i]
+      TotalArea = area
+      TotalPerimeter = perimeter
+      tol=1
+      condition1 = (SimilarAreaDictionary['Area'] >= area - tol) & (SimilarAreaDictionary['Area'] <= area +tol)
+      condition2 = (SimilarAreaDictionary['Perimeter'] >= perimeter -tol) & (SimilarAreaDictionary['Perimeter'] <= perimeter +tol)
+      combined_condition = condition1 & condition2
+
+      if any(combined_condition):
+          index = np.where(combined_condition)[0][0]
+          SimilarAreaDictionary.at[index, 'Occurences'] += 1
+          SimilarAreaDictionary.at[index, 'Total Area'] = SimilarAreaDictionary.at[index, 'Area'] * SimilarAreaDictionary.at[index, 'Occurences']
+          SimilarAreaDictionary.at[index, 'Total Perimeter'] = SimilarAreaDictionary.at[index, 'Perimeter'] * SimilarAreaDictionary.at[index, 'Occurences']
+      else:
+          TotalArea=area
+          TotalPerimeter=perimeter
+          new_data = {'Area': area, 'Total Area': TotalArea ,'Perimeter': perimeter, 'Total Perimeter': TotalPerimeter, 'Occurences': 1, 'Color':color} #add color here and read color to insert in
+          SimilarAreaDictionary = pd.concat([SimilarAreaDictionary, pd.DataFrame([new_data])], ignore_index=True)
+
+  # print(SimilarAreaDictionary)
+  return SimilarAreaDictionary
+"""### Draw on Image and PDF"""
+
+def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
+
+  hatched_areas = get_hatched_areas(dxfpath)
+  img=pdftoimg(datadoc)
+  flipped_horizontal=flip(img)
+  allcnts = []
+  imgg = flipped_horizontal
+  imgtransparent1=imgg.copy()
+  doc = fitz.open('pdf',datadoc)
+  page2 = doc[0]
+  rotationOld=page2.rotation
+  derotationMatrix=page2.derotation_matrix
+  pix=page2.get_pixmap()
+  if page2.rotation!=0:
+
+    rotationangle = page2.rotation
+    page2.set_rotation(0)
+    ratio =  pix.width/ img.shape[0]
+  else:
+    ratio =  pix.width/ img.shape[1]
+    rotationangle = 270
+
+  allshapes=[]
+  # Iterate through each polygon in metric units
+  NewColors = []
+  SimilarAreaDictionary=Create_DF(dxfpath)
+  i=0
+
+
+  for polygon in hatched_areas:
+      cntPoints = []
+      cntPoints1 = []
+      shapee = []
+      # Convert each vertex from metric to pixel coordinates
+      for vertex in polygon[0]:
+          x = (vertex[0]) *dxfratio
+          y = (vertex[1]) *dxfratio
+          if rotationangle==0:
+            if y<0:
+              y=y*-1
+          cntPoints.append([int(x), int(y)])
+          cntPoints1.append([x, y])
+
+      
+
+      for poi in np.array(cntPoints1):
+          x1, y1 = poi
+          p1 = fitz.Point(x1,y1)
+          # p1 = fitz.Point(x1,y1)
+          p1=p1*derotationMatrix
+          shapee.append([p1[0],p1[1]])
+
+      shapee=np.flip(shapee,1)
+      shapee=rotate_polygon(shapee,rotationangle,rotationOld,page2.mediabox)
+
+      
+      tol=1
+      condition1 = (SimilarAreaDictionary['Area'] >= polygon[1] - tol) & (SimilarAreaDictionary['Area'] <= polygon[1] +tol)
+      condition2 = (SimilarAreaDictionary['Perimeter'] >= polygon[2] -tol) & (SimilarAreaDictionary['Perimeter'] <= polygon[2] +tol)
+      combined_condition = condition1 & condition2
+
+      if any(combined_condition):
+
+          index = np.where(combined_condition)[0][0]
+          # print(SimilarAreaDictionary.at[index, 'Color'])
+          NewColors=SimilarAreaDictionary.at[index, 'Color']
+      else:
+        NewColors=SimilarAreaDictionary.at[i, 'Color']
+  
+      # cv2.drawContours(imgg, [np.array(cntPoints)], -1, (NewColors), thickness=2)
+      cv2.drawContours(imgg, [np.array(cntPoints)], -1, ([NewColors[2],NewColors[1],NewColors[0]]), thickness=-1)
+      annot11 = page2.add_polygon_annot( points=shapee)  # 'Polygon'
+      annot11.set_border(width=0.2)
+      annot11.set_colors(stroke=(int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255), fill= (int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255) )
+      annot11.set_info(content='Area='+str(polygon[1])+' m^2',subject='ADR Team')
+      annot11.set_opacity(0.8)
+      # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+      annot11.update()
+
+
+
+      annot12 = page2.add_polygon_annot( points=shapee)  # 'Polygon'
+      annot12.set_border(width=0.2)
+      annot12.set_colors(stroke=(int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255))
+      annot12.set_info(content='Perimeter='+str(polygon[2])+' m',subject='ADR Team')
+      annot12.set_opacity(0.8)
+      # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
+      annot12.update()
+      i += 1
+  alpha = 0.8  # Transparency factor.
+  
+  page2.set_rotation(rotationOld)
+  Correct_img=flip(imgg)
+
+  image_new1 = cv2.addWeighted(Correct_img, alpha,  img, 1 - alpha, 0)
+  SimilarAreaDictionary = SimilarAreaDictionary.fillna(' ')
+  gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr=google_sheet_Legend.legendGoogleSheets(SimilarAreaDictionary , pdfname,pdfpath)
+  
+  return doc,image_new1, SimilarAreaDictionary ,spreadsheetId, spreadsheet_url , namepathArr
+