Update dxf__omar3_2.py

dxf__omar3_2.py

@@ -38,6 +38,7 @@ import random
 import pandas as pd
 import google_sheet_Legend
 import tsadropboxretrieval
+from ezdxf import bbox
 
 """## Notes"""
 
@@ -66,6 +67,111 @@ def pdftoimg(datadoc):
   img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
   return img
 
+
+# Standard ISO paper sizes in inches
+ISO_SIZES_INCHES = {
+    "A0": (33.11, 46.81),
+    "A1": (23.39, 33.11),
+    "A2": (16.54, 23.39),
+    "A3": (11.69, 16.54),
+    "A4": (8.27, 11.69),
+    "A5": (5.83, 8.27),
+    "A6": (4.13, 5.83),
+    "A7": (2.91, 4.13),
+    "A8": (2.05, 2.91),
+    "A9": (1.46, 2.05),
+    "A10": (1.02, 1.46)
+}
+
+def get_paper_size_in_inches(width, height):
+    """Find the closest matching paper size in inches."""
+    for size, (w, h) in ISO_SIZES_INCHES.items():
+        if (abs(w - width) < 0.1 and abs(h - height) < 0.1) or (abs(w - height) < 0.1 and abs(h - width) < 0.1):
+            return size
+    return "Unknown Size"
+
+def analyze_pdf(file_path):
+    # Open the PDF file
+    pdf_document = fitz.open(file_path)
+
+    # Iterate through pages and print their sizes
+    for page_number in range(len(pdf_document)):
+        page = pdf_document[page_number]
+        rect = page.rect
+        width_points, height_points = rect.width, rect.height
+
+        # Convert points to inches
+        width_inches, height_inches = width_points / 72, height_points / 72
+
+        paper_size = get_paper_size_in_inches(width_inches, height_inches)
+
+        print(f"Page {page_number + 1}: {width_inches:.2f} x {height_inches:.2f} inches ({paper_size})")
+
+    pdf_document.close()
+    return width_inches , height_inches , paper_size
+
+
+def get_dxfSize(dxfpath):
+
+  doc = ezdxf.readfile(dxfpath)
+  msp = doc.modelspace()
+  # Create a cache for bounding box calculations
+  # Get the overall bounding box for all entities in the modelspace
+  cache = bbox.Cache()
+  overall_bbox = bbox.extents(msp, cache=cache)
+  print("Overall Bounding Box:", overall_bbox)
+  print(overall_bbox.extmin[0]+overall_bbox.extmax[0], overall_bbox.extmin[1]+overall_bbox.extmax[1])
+
+  return overall_bbox.extmin[0]+overall_bbox.extmax[0], overall_bbox.extmin[1]+overall_bbox.extmax[1]
+
+
+
+def switch_case(argument):
+    switcher = {
+      "A0": 1.27,
+      "A1": 2.54,
+      "A2": 5.08,
+      "A3": 10.16,
+      "A4": 20.32,
+      "A5": 40.64,
+      "A6": 81.28,
+      "A7": 162.56,
+      "A8": 325.12,
+      "A9": 650.24,
+      "A10": 1300.48
+    }
+    # Get the value from the dictionary; if not found, return a default value
+    print("Final Ratio=",switcher.get(argument, 1))
+    return switcher.get(argument, 1)
+
+
+
+
+def RetriveRatio(pdfpath,dxfpath):
+
+  width,height,paper_size = analyze_pdf (pdfpath)
+
+  if(width > height ):
+    bigger=width
+  else:
+    bigger=height
+
+  width_dxf,height_dxf = get_dxfSize(dxfpath)
+
+  if(width_dxf > height_dxf ):
+    bigger_dxf=width_dxf
+  else:
+    bigger_dxf=height_dxf
+
+  if(0.2 < bigger_dxf/bigger < 1.2):
+    print("bigger_dxf/bigger",bigger/bigger_dxf)
+    argument = paper_size
+    FinalRatio=switch_case(argument)
+  else:
+    FinalRatio=1
+  return FinalRatio
+
+
 """Flips image
 DXF origin is at the bottom left while img origin is top left
 """
@@ -86,7 +192,7 @@ def flip(img):
 
 """### Hatched areas"""
 
-def get_hatched_areas(filename):
+def get_hatched_areas(filename,FinalRatio):
       doc = ezdxf.readfile(filename)
       doc.header['$MEASUREMENT'] = 1
       msp = doc.modelspace()
@@ -104,7 +210,7 @@ def get_hatched_areas(filename):
             for path in entity.paths:
               if str(path.type)=='BoundaryPathType.POLYLINE':
                 print('First type of Hatch')
-                vertices = [(vertex[0], vertex[1])for vertex in path.vertices]
+                vertices = [(vertex[0]* (FinalRatio), vertex[1]* (FinalRatio))for vertex in path.vertices]
                 if(len(vertices)>3):
                  poly = ShapelyPolygon(vertices)
 
@@ -136,9 +242,9 @@ def get_hatched_areas(filename):
                   x,y=edge.start
                   x1,y1=edge.end
                   if(flag==0):
-                    vert=[(x,y),(x1,y1)]
-                  else:
-                      vert.append([x1,y1])
+                    vert=[(x* (FinalRatio),y* (FinalRatio)),(x1* (FinalRatio),y1* (FinalRatio))]
+                  else:m 
+                      vert.append([x1* (FinalRatio),y1* (FinalRatio)])
                   flag=1
                 poly = ShapelyPolygon(vert)
                 minx, miny, maxx, maxy = poly.bounds
@@ -159,7 +265,7 @@ def get_hatched_areas(filename):
                 print(path.type)
 
         elif entity.dxftype() == 'SOLID':
-            vertices = [entity.dxf.vtx0, entity.dxf.vtx1, entity.dxf.vtx2, entity.dxf.vtx3]
+            vertices = [entity.dxf.vtx0 * (FinalRatio), entity.dxf.vtx1* (FinalRatio), entity.dxf.vtx2* (FinalRatio), entity.dxf.vtx3* (FinalRatio)]
             poly = ShapelyPolygon(vertices)
             minx, miny, maxx, maxy = poly.bounds
 
@@ -178,7 +284,7 @@ def get_hatched_areas(filename):
            flag=0
 
            for i in range(len(points)):
-             vertices.append([points[i][0],points[i][1]])
+             vertices.append([points[i][0]* (FinalRatio),points[i][1]* (FinalRatio)])
            if(len(vertices)>3):
 
              if(vertices[0][0] == vertices[len(vertices)-1][0]  or vertices[0][1] == vertices[len(vertices)-1][1]):
@@ -203,7 +309,7 @@ def get_hatched_areas(filename):
         elif entity.dxftype() == 'POLYLINE':
 
           flag=0
-          vertices = [(v.dxf.location.x, v.dxf.location.y) for v in entity.vertices]
+          vertices = [(v.dxf.location.x * (FinalRatio), v.dxf.location.y * (FinalRatio)) for v in entity.vertices]
           print('Vertices:', vertices)
 
           if(len(vertices)>3):
@@ -232,7 +338,7 @@ def get_hatched_areas(filename):
           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]])
+              vertices.append([control_points[i][0]* (FinalRatio),control_points[i][1]* (FinalRatio)])
             poly=ShapelyPolygon(vertices)
 
             minx, miny, maxx, maxy = poly.bounds
@@ -305,9 +411,11 @@ def generate_color_array(length):
             colorRanges.append((r, g, b))
     return colorRanges
 
-def Create_DF(dxfpath):
-
-  hatched_areas = get_hatched_areas(dxfpath)
+def Create_DF(dxfpath,pdfpath):
+    
+  FinalRatio= RetriveRatio(pdfpath,dxfpath)
+    
+  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
   # 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','Comments'])
     
@@ -348,7 +456,8 @@ def Create_DF(dxfpath):
 """### Draw on Image and PDF"""
 
 def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
-  hatched_areas = get_hatched_areas(dxfpath)
+  FinalRatio= RetriveRatio(pdfpath,dxfpath)
+  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
   img=pdftoimg(datadoc)
   flipped_horizontal=flip(img)
   allcnts = []
@@ -371,7 +480,7 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
   allshapes=[]
   # Iterate through each polygon in metric units
   NewColors = []
-  SimilarAreaDictionary=Create_DF(dxfpath)
+  SimilarAreaDictionary=Create_DF(dxfpath,pdfpath)
   i=0