Update mdr_pdf_parser.py

mdr_pdf_parser.py

@@ -46,6 +46,7 @@ from transformers import LayoutLMv3ForTokenClassification
 import onnxruntime
 # --- HUGGING FACE HUB IMPORT ONLY BECAUSE RUNNING IN SPACES NOT NECESSARY IN PROD ---
 from huggingface_hub import hf_hub_download, HfHubDownloadError
+import time # Added for example usage timing
 
 # --- External Dependencies ---
 try:
@@ -59,7 +60,7 @@ except ImportError:
     print("Warning: Could not import LatexOCR from pix2tex.cli. LaTeX extraction will fail.")
     LatexOCR = None
 try:
-    pass # from struct_eqtable import build_model
+    pass # from struct_eqtable import build_model # Keep commented as per original
 except ImportError:
     print("Warning: Could not import build_model from struct_eqtable. Table parsing might fail.")
 
@@ -303,12 +304,12 @@ def mdr_check_text_similarity(t1: str, t2: str) -> tuple[float, int]:
 # --- MDR Geometry Processing ---
 class MDRRotationAdjuster:
   """Adjusts point coordinates based on image rotation."""
-  
+
   def __init__(self, origin_size: tuple[int, int], new_size: tuple[int, int], rotation: float, to_origin_coordinate: bool):
     fs, ts = (new_size, origin_size) if to_origin_coordinate else (origin_size, new_size)
     self._rot = rotation if to_origin_coordinate else -rotation
     self._c_off = (fs[0]/2.0, fs[1]/2.0); self._n_off = (ts[0]/2.0, ts[1]/2.0)
-  
+
   def adjust(self, point: MDRPoint) -> MDRPoint:
     x, y = point[0]-self._c_off[0], point[1]-self._c_off[1]
     if x!=0 or y!=0: cos_r, sin_r = cos(self._rot), sin(self._rot); x, y = x*cos_r-y*sin_r, x*sin_r+y*cos_r
@@ -362,7 +363,7 @@ def mdr_calculate_rectangle_rotation(rect: MDRRectangle) -> tuple[float, float]:
 # --- MDR ONNX OCR Internals ---
 class _MDR_PredictBase:
   """Base class for ONNX model prediction components."""
-  
+
   def get_onnx_session(self, model_path: str, use_gpu: bool):
     try:
         sess_opts = onnxruntime.SessionOptions(); sess_opts.log_severity_level = 3
@@ -375,32 +376,32 @@ class _MDR_PredictBase:
         if use_gpu and 'CUDAExecutionProvider' not in onnxruntime.get_available_providers():
              print("  CUDAExecutionProvider not available. Check ONNXRuntime-GPU installation and CUDA setup.")
         raise e
-  
+
   def get_output_name(self, sess: onnxruntime.InferenceSession) -> List[str]: return [n.name for n in sess.get_outputs()]
-  
+
   def get_input_name(self, sess: onnxruntime.InferenceSession) -> List[str]: return [n.name for n in sess.get_inputs()]
-  
+
   def get_input_feed(self, names: List[str], img_np: np.ndarray) -> Dict[str, np.ndarray]: return {name: img_np for name in names}
 
 # --- MDR ONNX OCR Internals ---
 class _MDR_NormalizeImage:
-  
+
   def __init__(self, scale=None, mean=None, std=None, order='chw', **kwargs):
     self.scale = np.float32(eval(scale) if isinstance(scale, str) else (scale if scale is not None else 1.0 / 255.0))
     mean = mean if mean is not None else [0.485, 0.456, 0.406]; std = std if std is not None else [0.229, 0.224, 0.225]
     shape = (3, 1, 1) if order == 'chw' else (1, 1, 3); self.mean = np.array(mean).reshape(shape).astype('float32'); self.std = np.array(std).reshape(shape).astype('float32')
-  
+
   def __call__(self, data): img = data['image']; img = np.array(img) if isinstance(img, Image) else img; data['image'] = (img.astype('float32') * self.scale - self.mean) / self.std; return data
 
 class _MDR_DetResizeForTest:
-  
+
   def __init__(self, **kwargs):
     self.resize_type = 0; self.keep_ratio = False
     if 'image_shape' in kwargs: self.image_shape = kwargs['image_shape']; self.resize_type = 1; self.keep_ratio = kwargs.get('keep_ratio', False)
     elif 'limit_side_len' in kwargs: self.limit_side_len = kwargs['limit_side_len']; self.limit_type = kwargs.get('limit_type', 'min')
     elif 'resize_long' in kwargs: self.resize_type = 2; self.resize_long = kwargs.get('resize_long', 960)
     else: self.limit_side_len = 736; self.limit_type = 'min'
-  
+
   def __call__(self, data):
     img = data['image']; src_h, src_w, _ = img.shape
     if src_h + src_w < 64: img = self._pad(img)
@@ -409,23 +410,23 @@ class _MDR_DetResizeForTest:
     else: img, ratios = self._resize1(img)
     if img is None: return None
     data['image'] = img; data['shape'] = np.array([src_h, src_w, ratios[0], ratios[1]]); return data
-  
+
   def _pad(self, im, v=0): h,w,c=im.shape; p=np.zeros((max(32,h),max(32,w),c),np.uint8)+v; p[:h,:w,:]=im; return p
-  
-  def _resize1(self, img): rh,rw=self.image_shape; oh,ow=img.shape[:2]; if self.keep_ratio: rw=ow*rh/oh; N=math.ceil(rw/32); rw=N*32; r_h,r_w=float(rh)/oh,float(rw)/ow; img=cv2.resize(img,(int(rw),int(rh))); return img,[r_h,r_w]
-  
+
+  def _resize1(self, img): rh,rw=self.image_shape; oh,ow=img.shape[:2]; if self.keep_ratio: rw=ow*rh/oh; N=ceil(rw/32); rw=N*32; r_h,r_w=float(rh)/oh,float(rw)/ow; img=cv2.resize(img,(int(rw),int(rh))); return img,[r_h,r_w]
+
   def _resize0(self, img): lsl=self.limit_side_len; h,w,_=img.shape; r=1.0; if self.limit_type=='max': r=float(lsl)/max(h,w) if max(h,w)>lsl else 1.0; elif self.limit_type=='min': r=float(lsl)/min(h,w) if min(h,w)<lsl else 1.0; elif self.limit_type=='resize_long': r=float(lsl)/max(h,w); else: raise Exception('Unsupported'); rh,rw=int(h*r),int(w*r); rh=max(int(round(rh/32)*32),32); rw=max(int(round(rw/32)*32),32); if int(rw)<=0 or int(rh)<=0: return None,(None,None); img=cv2.resize(img,(int(rw),int(rh))); r_h,r_w=rh/float(h),rw/float(w); return img,[r_h,r_w]
-  
+
   def _resize2(self, img): h,w,_=img.shape; rl=self.resize_long; r=float(rl)/max(h,w); rh,rw=int(h*r),int(w*r); ms=128; rh=(rh+ms-1)//ms*ms; rw=(rw+ms-1)//ms*ms; img=cv2.resize(img,(int(rw),int(rh))); r_h,r_w=rh/float(h),rw/float(w); return img,[r_h,r_w]
 
 class _MDR_ToCHWImage:
-  
+
   def __call__(self, data): img=data['image']; img=np.array(img) if isinstance(img,Image) else img; data['image']=img.transpose((2,0,1)); return data
 
 class _MDR_KeepKeys:
-  
+
   def __init__(self, keep_keys, **kwargs): self.keep_keys=keep_keys
-  
+
   def __call__(self, data): return [data[key] for key in self.keep_keys]
 
 def mdr_ocr_transform(data, ops=None):
@@ -445,11 +446,11 @@ def mdr_ocr_create_operators(op_param_list, global_config=None):
   return ops
 
 class _MDR_DBPostProcess:
-  
+
   def __init__(self, thresh=0.3, box_thresh=0.7, max_candidates=1000, unclip_ratio=1.5, use_dilation=False, score_mode="fast", box_type='quad', **kwargs):
     self.thresh, self.box_thresh, self.max_cand = thresh, box_thresh, max_candidates; self.unclip_r, self.min_sz, self.score_m, self.box_t = unclip_ratio, 3, score_mode, box_type
     assert score_mode in ["slow", "fast"]; self.dila_k = np.array([[1,1],[1,1]], dtype=np.uint8) if use_dilation else None
-  
+
   def _polygons_from_bitmap(self, pred, bmp, dw, dh):
     h, w = bmp.shape; boxes, scores = [], []
     contours, _ = cv2.findContours((bmp*255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
@@ -466,7 +467,7 @@ class _MDR_DBPostProcess:
       box = np.array(box); box[:,0]=np.clip(np.round(box[:,0]/w*dw),0,dw); box[:,1]=np.clip(np.round(box[:,1]/h*dh),0,dh)
       boxes.append(box.tolist()); scores.append(score)
     return boxes, scores
-  
+
   def _boxes_from_bitmap(self, pred, bmp, dw, dh):
     h, w = bmp.shape; contours, _ = cv2.findContours((bmp*255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
     num_contours = min(len(contours), self.max_cand); boxes, scores = [], []
@@ -482,30 +483,30 @@ class _MDR_DBPostProcess:
       box = np.array(box); box[:,0]=np.clip(np.round(box[:,0]/w*dw),0,dw); box[:,1]=np.clip(np.round(box[:,1]/h*dh),0,dh)
       boxes.append(box.astype("int32")); scores.append(score)
     return np.array(boxes, dtype="int32"), scores
-  
+
   def _unclip(self, box, ratio):
     poly = Polygon(box); dist = poly.area*ratio/poly.length; offset = pyclipper.PyclipperOffset(); offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
     expanded = offset.Execute(dist);
     if not expanded: raise ValueError("Unclip failed"); return np.array(expanded[0])
-  
+
   def _get_mini_boxes(self, contour):
     bb = cv2.minAreaRect(contour); pts = sorted(list(cv2.boxPoints(bb)), key=lambda x:x[0])
     i1,i4 = (0,1) if pts[1][1]>pts[0][1] else (1,0); i2,i3 = (2,3) if pts[3][1]>pts[2][1] else (3,2)
     box = [pts[i1], pts[i2], pts[i3], pts[i4]]; return box, min(bb[1])
-  
+
   def _box_score_fast(self, bmp, box):
     h,w = bmp.shape[:2]; xmin=np.clip(np.floor(box[:,0].min()).astype("int32"),0,w-1); xmax=np.clip(np.ceil(box[:,0].max()).astype("int32"),0,w-1)
     ymin=np.clip(np.floor(box[:,1].min()).astype("int32"),0,h-1); ymax=np.clip(np.ceil(box[:,1].max()).astype("int32"),0,h-1)
     mask = np.zeros((ymax-ymin+1, xmax-xmin+1), dtype=np.uint8); box[:,0]-=xmin; box[:,1]-=ymin
     cv2.fillPoly(mask, box.reshape(1,-1,2).astype("int32"), 1);
     return cv2.mean(bmp[ymin:ymax+1, xmin:xmax+1], mask)[0] if np.sum(mask)>0 else 0.0
-  
+
   def _box_score_slow(self, bmp, contour): # Not used if fast
     h,w = bmp.shape[:2]; contour = np.reshape(contour.copy(),(-1,2)); xmin=np.clip(np.min(contour[:,0]),0,w-1); xmax=np.clip(np.max(contour[:,0]),0,w-1)
     ymin=np.clip(np.min(contour[:,1]),0,h-1); ymax=np.clip(np.max(contour[:,1]),0,h-1); mask=np.zeros((ymax-ymin+1,xmax-xmin+1),dtype=np.uint8)
     contour[:,0]-=xmin; contour[:,1]-=ymin; cv2.fillPoly(mask, contour.reshape(1,-1,2).astype("int32"), 1);
     return cv2.mean(bmp[ymin:ymax+1, xmin:xmax+1], mask)[0] if np.sum(mask)>0 else 0.0
-  
+
   def __call__(self, outs_dict, shape_list):
     pred = outs_dict['maps'][:,0,:,:]; seg = pred > self.thresh; boxes_batch = []
     for batch_idx in range(pred.shape[0]):
@@ -517,7 +518,7 @@ class _MDR_DBPostProcess:
     return boxes_batch
 
 class _MDR_TextDetector(_MDR_PredictBase):
-  
+
   def __init__(self, args):
     super().__init__(); self.args = args
     pre_ops = [{'DetResizeForTest': {'limit_side_len': args.det_limit_side_len, 'limit_type': args.det_limit_type}}, {'NormalizeImage': {'std': [0.229,0.224,0.225], 'mean': [0.485,0.456,0.406], 'scale': '1./255.', 'order': 'hwc'}}, {'ToCHWImage': None}, {'KeepKeys': {'keep_keys': ['image', 'shape']}}]
@@ -526,15 +527,15 @@ class _MDR_TextDetector(_MDR_PredictBase):
     self.post_op = _MDR_DBPostProcess(**post_params)
     self.sess = self.get_onnx_session(args.det_model_dir, args.use_gpu)
     self.input_name = self.get_input_name(self.sess); self.output_name = self.get_output_name(self.sess)
-  
+
   def _order_pts(self, pts): r=np.zeros((4,2),dtype="float32"); s=pts.sum(axis=1); r[0]=pts[np.argmin(s)]; r[2]=pts[np.argmax(s)]; tmp=np.delete(pts,(np.argmin(s),np.argmax(s)),axis=0); d=np.diff(np.array(tmp),axis=1); r[1]=tmp[np.argmin(d)]; r[3]=tmp[np.argmax(d)]; return r
-  
+
   def _clip_pts(self, pts, h, w): pts[:,0]=np.clip(pts[:,0],0,w-1); pts[:,1]=np.clip(pts[:,1],0,h-1); return pts
-  
+
   def _filter_quad(self, boxes, shape): h,w=shape[0:2]; new_boxes=[]; for box in boxes: box=np.array(box) if isinstance(box,list) else box; box=self._order_pts(box); box=self._clip_pts(box,h,w); rw=int(np.linalg.norm(box[0]-box[1])); rh=int(np.linalg.norm(box[0]-box[3])); if rw<=3 or rh<=3: continue; new_boxes.append(box); return np.array(new_boxes)
-  
+
   def _filter_poly(self, boxes, shape): h,w=shape[0:2]; new_boxes=[]; for box in boxes: box=np.array(box) if isinstance(box,list) else box; box=self._clip_pts(box,h,w); if Polygon(box).area<10: continue; new_boxes.append(box); return np.array(new_boxes)
-  
+
   def __call__(self, img):
     ori_im = img.copy(); data = {"image": img}; data = mdr_ocr_transform(data, self.pre_op)
     if data is None: return None; img, shape_list = data;
@@ -544,27 +545,27 @@ class _MDR_TextDetector(_MDR_PredictBase):
     return self._filter_poly(boxes, ori_im.shape) if self.args.det_box_type=='poly' else self._filter_quad(boxes, ori_im.shape)
 
 class _MDR_ClsPostProcess:
-  
+
   def __init__(self, label_list=None, **kwargs): self.labels = label_list if label_list else {0:'0', 1:'180'}
-  
+
   def __call__(self, preds, label=None, *args, **kwargs):
     preds = np.array(preds) if not isinstance(preds, np.ndarray) else preds; idxs = preds.argmax(axis=1)
     return [(self.labels[idx], float(preds[i,idx])) for i,idx in enumerate(idxs)]
 
 class _MDR_TextClassifier(_MDR_PredictBase):
-  
+
   def __init__(self, args):
     super().__init__(); self.shape = tuple(map(int, args.cls_image_shape.split(','))) if isinstance(args.cls_image_shape, str) else args.cls_image_shape
     self.batch_num = args.cls_batch_num; self.thresh = args.cls_thresh; self.post_op = _MDR_ClsPostProcess(label_list=args.label_list)
     self.sess = self.get_onnx_session(args.cls_model_dir, args.use_gpu); self.input_name = self.get_input_name(self.sess); self.output_name = self.get_output_name(self.sess)
-  
+
   def _resize_norm(self, img):
-    imgC,imgH,imgW = self.shape; h,w = img.shape[:2]; r=w/float(h) if h>0 else 0; rw=int(math.ceil(imgH*r)); rw=min(rw,imgW)
+    imgC,imgH,imgW = self.shape; h,w = img.shape[:2]; r=w/float(h) if h>0 else 0; rw=int(ceil(imgH*r)); rw=min(rw,imgW)
     resized = cv2.resize(img,(rw,imgH)); resized = resized.astype("float32")
     if imgC==1: resized = resized/255.0; resized = resized[np.newaxis,:]
     else: resized = resized.transpose((2,0,1))/255.0
     resized -= 0.5; resized /= 0.5; padding = np.zeros((imgC,imgH,imgW),dtype=np.float32); padding[:,:,0:rw]=resized; return padding
-  
+
   def __call__(self, img_list):
     if not img_list: return img_list, []; img_list_cp = copy.deepcopy(img_list); num = len(img_list_cp)
     ratios = [img.shape[1]/float(img.shape[0]) if img.shape[0]>0 else 0 for img in img_list_cp]; indices = np.argsort(np.array(ratios))
@@ -581,7 +582,7 @@ class _MDR_TextClassifier(_MDR_PredictBase):
     return img_list, results
 
 class _MDR_BaseRecLabelDecode:
-  
+
   def __init__(self, char_path=None, use_space=False):
     self.beg, self.end, self.rev = "sos", "eos", False; self.chars = []
     if char_path is None: self.chars = list("0123456789abcdefghijklmnopqrstuvwxyz")
@@ -592,13 +593,13 @@ class _MDR_BaseRecLabelDecode:
         if any("\u0600"<=c<="\u06FF" for c in self.chars): self.rev=True
       except FileNotFoundError: print(f"Warn: Dict not found {char_path}"); self.chars=list("0123456789abcdefghijklmnopqrstuvwxyz"); if use_space: self.chars.append(" ")
     d_char = self.add_special_char(list(self.chars)); self.dict={c:i for i,c in enumerate(d_char)}; self.character=d_char
-  
+
   def add_special_char(self, chars): return chars
-  
+
   def get_ignored_tokens(self): return []
-  
+
   def _reverse(self, pred): res=[]; cur=""; for c in pred: if not re.search("[a-zA-Z0-9 :*./%+-]",c): res.extend([cur,c] if cur!="" else [c]); cur="" else: cur+=c; if cur!="": res.append(cur); return "".join(res[::-1])
-  
+
   def decode(self, idxs, probs=None, remove_dup=False):
     res=[]; ignored=self.get_ignored_tokens(); bs=len(idxs)
     for b_idx in range(bs):
@@ -628,17 +629,17 @@ class _MDR_TextRecognizer(_MDR_PredictBase):
     self.batch_num=getattr(args,'rec_batch_num',6); self.algo=getattr(args,'rec_algorithm','SVTR_LCNet')
     self.post_op=_MDR_CTCLabelDecode(char_path=args.rec_char_dict_path, use_space=getattr(args,'use_space_char',True))
     self.sess=self.get_onnx_session(args.rec_model_dir, args.use_gpu); self.input_name=self.get_input_name(self.sess); self.output_name=self.get_output_name(self.sess)
-  
+
   def _resize_norm(self, img, max_r):
     imgC,imgH,imgW = self.shape; h,w = img.shape[:2];
     if h==0 or w==0: return np.zeros((imgC,imgH,imgW),dtype=np.float32)
-    r=w/float(h); tw=min(imgW, int(math.ceil(imgH*max(r,max_r)))); tw=max(1,tw)
+    r=w/float(h); tw=min(imgW, int(ceil(imgH*max(r,max_r)))); tw=max(1,tw)
     resized=cv2.resize(img,(tw,imgH)); resized=resized.astype("float32")
     if imgC==1 and len(resized.shape)==3: resized=cv2.cvtColor(resized,cv2.COLOR_BGR2GRAY); resized=resized[:,:,np.newaxis]
     if len(resized.shape)==2: resized=resized[:,:,np.newaxis]
     resized=resized.transpose((2,0,1))/255.0; resized-=0.5; resized/=0.5
     padding=np.zeros((imgC,imgH,imgW),dtype=np.float32); padding[:,:,0:tw]=resized; return padding
-  
+
   def __call__(self, img_list):
     if not img_list: return []; num=len(img_list); ratios=[img.shape[1]/float(img.shape[0]) if img.shape[0]>0 else 0 for img in img_list]
     indices=np.argsort(np.array(ratios)); results=[["",0.0]]*num; batch_n=self.batch_num
@@ -654,7 +655,7 @@ class _MDR_TextRecognizer(_MDR_PredictBase):
 
 # --- MDR ONNX OCR System ---
 class _MDR_TextSystem:
-  
+
   def __init__(self, args):
     class ArgsObject: # Helper to access dict args with dot notation
         def __init__(self, **entries): self.__dict__.update(entries)
@@ -666,13 +667,13 @@ class _MDR_TextSystem:
     self.drop_score = getattr(args, 'drop_score', 0.5)
     self.classifier = _MDR_TextClassifier(args) if self.use_cls else None
     self.crop_idx = 0; self.save_crop = getattr(args, 'save_crop_res', False); self.crop_dir = getattr(args, 'crop_res_save_dir', "./output/mdr_crop_res")
-  
+
   def _sort_boxes(self, boxes):
     if boxes is None or len(boxes)==0: return []
     def key(box): min_y=min(p[1] for p in box); min_x=min(p[0] for p in box); return (min_y, min_x)
     try: return list(sorted(boxes, key=key))
     except: return list(boxes) # Fallback
-  
+
   def __call__(self, img, classify=True):
     ori_im = img.copy(); boxes = self.detector(img)
     if boxes is None or len(boxes)==0: return [], []
@@ -694,7 +695,7 @@ class _MDR_TextSystem:
         if score >= self.drop_score: final_boxes.append(box); final_rec.append(res)
     if self.save_crop: self._save_crops(crops, rec_res)
     return final_boxes, final_rec
-  
+
   def _save_crops(self, crops, recs):
       mdr_ensure_directory(self.crop_dir); num = len(crops)
       for i in range(num): txt, score = recs[i]; safe=re.sub(r'\W+', '_', txt)[:20]; fname=f"crop_{self.crop_idx+i}_{safe}_{score:.2f}.jpg"; cv2.imwrite(os.path.join(self.crop_dir, fname), crops[i])
@@ -722,7 +723,7 @@ def mdr_get_min_area_crop(img, points):
 _MDR_INCLUDES_MIN_RATE = 0.99
 
 class _MDR_OverlapMatrixContext:
-  
+
   def __init__(self, layouts: list[MDRLayoutElement]):
     length = len(layouts); self.polys: list[Polygon|None] = []
     for l in layouts:
@@ -736,7 +737,7 @@ class _MDR_OverlapMatrixContext:
         p2 = self.polys[j];
         if p2 is None: continue
         r_ij = self._rate(p1, p2); r_ji = self._rate(p2, p1); self.matrix[i][j]=r_ij; self.matrix[j][i]=r_ji
-  
+
   def _rate(self, p1: Polygon, p2: Polygon) -> float: # Rate p1 covers p2
       try: inter = p1.intersection(p2);
       except: return 0.0
@@ -745,11 +746,11 @@ class _MDR_OverlapMatrixContext:
       _, _, px1, py1 = p2.bounds; pw, ph = px1-p2.bounds[0], py1-p2.bounds[1]
       if pw < 1e-6 or ph < 1e-6: return 0.0
       wr = min(iw/pw, 1.0); hr = min(ih/ph, 1.0); return (wr+hr)/2.0
-  
+
   def others(self, idx: int):
     for i, r in enumerate(self.matrix[idx]):
       if i != idx and i not in self.removed: yield r
-  
+
   def includes(self, idx: int): # Layouts included BY idx
     for i, r in enumerate(self.matrix[idx]):
       if i != idx and i not in self.removed and r >= _MDR_INCLUDES_MIN_RATE:
@@ -864,17 +865,17 @@ class _MDR_ONNXParams: # Simplified container
 
 class MDROcrEngine:
   """Handles OCR detection and recognition using ONNX models."""
-  
+
   def __init__(self, device: Literal["cpu", "cuda"], model_dir_path: str):
     self._device = device; self._model_dir = mdr_ensure_directory(model_dir_path)
     self._text_system: _MDR_TextSystem | None = None; self._onnx_params: _MDR_ONNXParams | None = None
     self._ensure_models(); self._get_system() # Init on creation
-  
+
   def _ensure_models(self):
     for key, parts in _MDR_OCR_MODELS.items():
         fp = Path(self._model_dir) / Path(*parts)
         if not fp.exists(): print(f"Downloading MDR OCR model: {fp.name}..."); url = _MDR_OCR_URL_BASE + "/".join(parts); mdr_download_model(url, fp)
-  
+
   def _get_system(self) -> _MDR_TextSystem | None:
     if self._text_system is None:
         paths = {k: str(Path(self._model_dir)/Path(*p)) for k,p in _MDR_OCR_MODELS.items()}
@@ -882,7 +883,7 @@ class MDROcrEngine:
         try: self._text_system = _MDR_TextSystem(self._onnx_params); print(f"MDR OCR System initialized.")
         except Exception as e: print(f"ERROR initializing MDR OCR System: {e}"); self._text_system = None
     return self._text_system
-  
+
   def find_text_fragments(self, image_np: np.ndarray) -> Generator[MDROcrFragment, None, None]:
     """Finds and recognizes text fragments in a NumPy image (BGR)."""
     system = self._get_system()
@@ -895,7 +896,7 @@ class MDROcrEngine:
       if not txt or mdr_is_whitespace(txt) or conf < 0.1: continue
       pts = [(float(p[0]), float(p[1])) for p in box_pts]
       if len(pts)==4: r=MDRRectangle(lt=pts[0], rt=pts[1], rb=pts[2], lb=pts[3]); if r.is_valid and r.area>1: yield MDROcrFragment(order=-1, text=txt, rank=float(conf), rect=r)
-  
+
   def _preprocess(self, img: np.ndarray) -> np.ndarray:
     if len(img.shape)==3 and img.shape[2]==4: a=img[:,:,3]/255.0; bg=(255,255,255); new=np.zeros_like(img[:,:,:3]); [setattr(new[:,:,i], 'flags.writeable', True) for i in range(3)]; [np.copyto(new[:,:,i], (bg[i]*(1-a)+img[:,:,i]*a)) for i in range(3)]; img=new.astype(np.uint8)
     elif len(img.shape)==2: img=cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
@@ -936,11 +937,11 @@ class _MDR_ReaderBBox: layout_index: int; fragment_index: int; virtual: bool; or
 
 class MDRLayoutReader:
   """Determines reading order of layout elements using LayoutLMv3."""
-  
+
   def __init__(self, model_path: str):
     self._model_path = model_path; self._model: LayoutLMv3ForTokenClassification | None = None
     self._device = "cuda" if torch.cuda.is_available() else "cpu"
-  
+
   def _get_model(self) -> LayoutLMv3ForTokenClassification | None:
     if self._model is None:
       cache = mdr_ensure_directory(self._model_path); name = "microsoft/layoutlmv3-base"; h_path = os.path.join(cache, "models--hantian--layoutreader")
@@ -950,7 +951,7 @@ class MDRLayoutReader:
         self._model.to(self._device); self._model.eval(); print(f"MDR LayoutReader loaded on {self._device}.")
       except Exception as e: print(f"ERROR loading MDR LayoutReader: {e}"); self._model = None
     return self._model
-  
+
   def determine_reading_order(self, layouts: list[MDRLayoutElement], size: tuple[int, int]) -> list[MDRLayoutElement]:
     w, h = size;
     if w<=0 or h<=0 or not layouts: return layouts;
@@ -977,7 +978,7 @@ class MDRLayoutReader:
     if len(orders) != len(bbox_list): print("MDR LayoutReader order mismatch"); return layouts # Fallback
     for i, order_idx in enumerate(orders): bbox_list[i].order = order_idx
     return self._apply_order(layouts, bbox_list)
-  
+
   def _prepare_bboxes(self, layouts: list[MDRLayoutElement], w: int, h: int) -> list[_MDR_ReaderBBox] | None:
     line_h = self._estimate_line_h(layouts); bbox_list = []
     for i, l in enumerate(layouts):
@@ -985,7 +986,7 @@ class MDRLayoutReader:
       else: bbox_list.extend(self._gen_virtual(l, i, line_h, w, h))
     if len(bbox_list) > _MDR_MAX_LEN: print(f"Too many boxes ({len(bbox_list)}>{_MDR_MAX_LEN})"); return None
     bbox_list.sort(key=lambda b: (b.value[1], b.value[0])); return bbox_list
-  
+
   def _apply_order(self, layouts: list[MDRLayoutElement], bbox_list: list[_MDR_ReaderBBox]) -> list[MDRLayoutElement]:
     layout_map = defaultdict(list); [layout_map[b.layout_index].append(b) for b in bbox_list]
     layout_orders = [(idx, self._median([b.order for b in bboxes])) for idx, bboxes in layout_map.items() if bboxes]
@@ -999,11 +1000,11 @@ class MDRLayoutReader:
         else: frags.sort(key=lambda f: (f.rect.lt[1], f.rect.lt[0]))
         for frag in frags: frag.order = nfo; nfo += 1
     return sorted_layouts
-  
+
   def _estimate_line_h(self, layouts: list[MDRLayoutElement]) -> float:
     heights = [f.rect.size[1] for l in layouts for f in l.fragments if f.rect.size[1]>0]
     return self._median(heights) if heights else 15.0
-  
+
   def _gen_virtual(self, l: MDRLayoutElement, l_idx: int, line_h: float, pw: int, ph: int) -> Generator[_MDR_ReaderBBox, None, None]:
     x0,y0,x1,y1 = l.rect.wrapper; lh,lw = y1-y0,x1-x0
     if lh<=0 or lw<=0 or line_h<=0: yield _MDR_ReaderBBox(l_idx,-1,True,-1,(x0,y0,x1,y1)); return
@@ -1018,7 +1019,7 @@ class MDRLayoutReader:
       ly0,ly1 = max(0,min(ph,cur_y)), max(0,min(ph,cur_y+act_line_h)); lx0,lx1 = max(0,min(pw,x0)), max(0,min(pw,x1))
       if ly1>ly0 and lx1>lx0: yield _MDR_ReaderBBox(l_idx,-1,True,-1,(lx0,ly0,lx1,ly1))
       cur_y += act_line_h
-  
+
   def _median(self, nums: list[float|int]) -> float:
     if not nums: return 0.0; s_nums = sorted(nums); n = len(s_nums)
     return float(s_nums[n//2]) if n%2==1 else float((s_nums[n//2-1]+s_nums[n//2])/2.0)
@@ -1026,11 +1027,11 @@ class MDRLayoutReader:
 # --- MDR LaTeX Extractor ---
 class MDRLatexExtractor:
   """Extracts LaTeX from formula images using pix2tex."""
-  
+
   def __init__(self, model_path: str):
     self._model_path = model_path; self._model: LatexOCR | None = None
     self._device = "cuda" if torch.cuda.is_available() else "cpu"
-  
+
   def extract(self, image: Image) -> str | None:
     if LatexOCR is None: return None;
     image = mdr_expand_image(image, 0.1); model = self._get_model()
@@ -1038,7 +1039,7 @@ class MDRLatexExtractor:
     try:
         with torch.no_grad(): img_rgb = image.convert('RGB') if image.mode!='RGB' else image; latex = model(img_rgb); return latex if latex else None
     except Exception as e: print(f"MDR LaTeX error: {e}"); return None
-  
+
   def _get_model(self) -> LatexOCR | None:
     if self._model is None and LatexOCR is not None:
       mdr_ensure_directory(self._model_path); wp, rp, cp = Path(self._model_path)/"weights.pth", Path(self._model_path)/"image_resizer.pth", Path(self._model_path)/"config.yaml"
@@ -1047,7 +1048,7 @@ class MDRLatexExtractor:
       try: args = Munch({"config":str(cp), "checkpoint":str(wp), "device":self._device, "no_cuda":self._device=="cpu", "no_resize":False, "temperature":0.0}); self._model = LatexOCR(args); print(f"MDR LaTeX loaded on {self._device}.")
       except Exception as e: print(f"ERROR initializing MDR LatexOCR: {e}"); self._model = None
     return self._model
-  
+
   def _download(self):
     tag = "v0.0.1"; base = f"https://github.com/lukas-blecher/LaTeX-OCR/releases/download/{tag}/"; files = {"weights.pth": base+"weights.pth", "image_resizer.pth": base+"image_resizer.pth"}
     mdr_ensure_directory(self._model_path); [mdr_download_model(url, Path(self._model_path)/name) for name, url in files.items() if not (Path(self._model_path)/name).exists()]
@@ -1057,13 +1058,13 @@ MDRTableOutputFormat = Literal["latex", "markdown", "html"]
 
 class MDRTableParser:
   """Parses table structure/content from images using StructTable model."""
-  
+
   def __init__(self, device: Literal["cpu", "cuda"], model_path: str):
     self._model: Any | None = None; self._model_path = mdr_ensure_directory(model_path)
     self._device = device if torch.cuda.is_available() and device=="cuda" else "cpu"
     self._disabled = self._device == "cpu"
     if self._disabled: print("Warning: MDR Table parsing requires CUDA. Disabled.")
-  
+
   def parse_table_image(self, image: Image, format: MDRTableLayoutParsedFormat) -> str | None:
     if self._disabled: return None;
     fmt: MDRTableOutputFormat | None = None
@@ -1078,7 +1079,7 @@ class MDRTableParser:
         with torch.no_grad(): results = model([img_rgb], output_format=fmt)
         return results[0] if results else None
     except Exception as e: print(f"MDR Table parsing error: {e}"); return None
-  
+
   def _get_model(self):
     if self._model is None and not self._disabled:
       try:
@@ -1099,23 +1100,23 @@ class _MDR_RotationContext: to_origin: MDRRotationAdjuster; to_new: MDRRotationA
 
 class MDRImageOptimizer:
   """Handles image rotation detection and coordinate adjustments."""
-  
+
   def __init__(self, raw_image: Image, adjust_points: bool):
     self._raw = raw_image; self._image = raw_image; self._adjust_points = adjust_points
     self._fragments: list[MDROcrFragment] = []; self._rotation: float = 0.0; self._rot_ctx: _MDR_RotationContext | None = None
-  
+
   @property
   def image(self) -> Image: return self._image
-  
+
   @property
   def adjusted_image(self) -> Image | None: return self._image if self._rot_ctx is not None else None
-  
+
   @property
   def rotation(self) -> float: return self._rotation
-  
+
   @property
   def image_np(self) -> np.ndarray: img_rgb = np.array(self._raw.convert("RGB")); return cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
-  
+
   def receive_fragments(self, fragments: list[MDROcrFragment]):
     self._fragments = fragments;
     if not fragments: return;
@@ -1130,7 +1131,7 @@ class MDRImageOptimizer:
         to_new=MDRRotationAdjuster(orig_sz, new_sz, self._rotation, False),
         to_origin=MDRRotationAdjuster(orig_sz, new_sz, self._rotation, True))
     adj = self._rot_ctx.to_new; [setattr(f, 'rect', MDRRectangle(lt=adj.adjust(r.lt), rt=adj.adjust(r.rt), lb=adj.adjust(r.lb), rb=adj.adjust(r.rb))) for f in fragments if (r:=f.rect)]
-  
+
   def finalize_layout_coords(self, layouts: list[MDRLayoutElement]):
     if self._rot_ctx is None or self._adjust_points: return
     if len(self._fragments) == len(self._rot_ctx.fragment_origin_rectangles): [setattr(f, 'rect', orig_r) for f, orig_r in zip(self._fragments, self._rot_ctx.fragment_origin_rectangles)]
@@ -1166,7 +1167,7 @@ def mdr_plot_layout(image: Image, layouts: Iterable[MDRLayoutElement]) -> None:
   if not layouts: return;
   try: l_font, f_font = load_default(size=25), load_default(size=15); draw = ImageDraw.Draw(image, mode="RGBA")
   except Exception as e: print(f"MDR Plot init error: {e}"); return
-  
+
   def _draw_num(pos: MDRPoint, num: int, font: FreeTypeFont, color: _MDR_RGBA):
     try: x,y=pos; txt=str(num); txt_pos=(round(x)+3, round(y)+1); bbox=draw.textbbox(txt_pos,txt,font=font); bg_rect=(bbox[0]-2,bbox[1]-1,bbox[2]+2,bbox[3]+1); bg_color=(color[0],color[1],color[2],180); draw.rectangle(bg_rect,fill=bg_color); draw.text(txt_pos,txt,font=font,fill=(255,255,255,255))
     except Exception as e: print(f"MDR Draw num error: {e}")
@@ -1181,7 +1182,7 @@ def mdr_plot_layout(image: Image, layouts: Iterable[MDRLayoutElement]) -> None:
 # --- MDR Extraction Engine ---
 class MDRExtractionEngine:
   """Core engine for extracting structured information from a document image."""
-  
+
   def __init__(self, model_dir_path: str, device: Literal["cpu", "cuda"]="cpu", ocr_for_each_layouts: bool=True, extract_formula: bool=True, extract_table_format: MDRTableLayoutParsedFormat|None=None):
     self._model_dir = model_dir_path # Base directory for all models
     self._device = device if torch.cuda.is_available() else "cpu"
@@ -1236,7 +1237,7 @@ class MDRExtractionEngine:
         print("MDR YOLOv10 class not available. Layout detection skipped.")
 
     return self._yolo
-      
+
   def analyze_image(self, image: Image, adjust_points: bool=False) -> MDRExtractionResult:
     """Analyzes a single page image to extract layout and content."""
     print("  Engine: Analyzing image..."); optimizer = MDRImageOptimizer(image, adjust_points)
@@ -1256,7 +1257,7 @@ class MDRExtractionEngine:
     print("  Engine: Finalizing coords..."); optimizer.finalize_layout_coords(layouts)
     print("  Engine: Analysis complete.")
     return MDRExtractionResult(rotation=optimizer.rotation, layouts=layouts, extracted_image=image, adjusted_image=optimizer.adjusted_image)
-      
+
   def _run_yolo_detection(self, img: Image, yolo: YOLOv10) -> Generator[MDRLayoutElement, None, None]:
     img_rgb = img.convert("RGB"); res = yolo.predict(source=img_rgb, imgsz=1024, conf=0.2, device=self._device, verbose=False)
     if not res or not hasattr(res[0], 'boxes') or res[0].boxes is None: return
@@ -1270,7 +1271,7 @@ class MDRExtractionEngine:
             if cls == MDRLayoutClass.TABLE: yield MDRTableLayoutElement(cls=cls, rect=rect, fragments=[], parsed=None)
             elif cls == MDRLayoutClass.ISOLATE_FORMULA: yield MDRFormulaLayoutElement(cls=cls, rect=rect, fragments=[], latex=None)
             elif cls in MDRPlainLayoutElement.__annotations__['cls'].__args__: yield MDRPlainLayoutElement(cls=cls, rect=rect, fragments=[])
-  
+
   def _match_fragments_to_layouts(self, frags: list[MDROcrFragment], layouts: list[MDRLayoutElement]) -> list[MDRLayoutElement]:
     if not frags or not layouts: return layouts
     layout_polys = [(Polygon(l.rect) if l.rect.is_valid else None) for l in layouts]
@@ -1290,13 +1291,13 @@ class MDRExtractionEngine:
             layouts[best_idx].fragments.append(frag)
     for l in layouts: l.fragments.sort(key=lambda f: (f.rect.lt[1], f.rect.lt[0]))
     return layouts
-  
+
   def _run_ocr_correction(self, img: Image, layouts: list[MDRLayoutElement]):
     for i, l in enumerate(layouts):
         if l.cls == MDRLayoutClass.FIGURE: continue
         try: mdr_correct_layout_fragments(self._ocr_engine, img, l)
         except Exception as e: print(f"  Engine: OCR correction error layout {i}: {e}")
-  
+
   def _parse_special_layouts(self, layouts: list[MDRLayoutElement], optimizer: MDRImageOptimizer):
     img_to_clip = optimizer.image
     for l in layouts:
@@ -1307,7 +1308,7 @@ class MDRExtractionEngine:
             try: t_img = mdr_clip_from_image(img_to_clip, l.rect); parsed = self._table_parser.parse_table_image(t_img, self._ext_table) if t_img.width>1 and t_img.height>1 else None
             except Exception as e: print(f"  Engine: Table parse error: {e}"); parsed = None
             if parsed: l.parsed = (parsed, self._ext_table)
-  
+
   def _should_keep_layout(self, l: MDRLayoutElement) -> bool:
     if l.fragments and not all(mdr_is_whitespace(f.text) for f in l.fragments): return True
     return l.cls in [MDRLayoutClass.FIGURE, MDRLayoutClass.TABLE, MDRLayoutClass.ISOLATE_FORMULA]
@@ -1315,25 +1316,25 @@ class MDRExtractionEngine:
 # --- MDR Page Section Linking ---
 class _MDR_LinkedShape:
   """Internal helper for managing layout linking across pages."""
-  
+
   def __init__(self, layout: MDRLayoutElement): self.layout=layout; self.pre:list[MDRLayoutElement|None]=[None,None]; self.nex:list[MDRLayoutElement|None]=[None,None]
-  
+
   @property
   def distance2(self) -> float: x,y=self.layout.rect.lt; return x*x+y*y
 
 class MDRPageSection:
   """Represents a page's layouts for framework detection via linking."""
-  
+
   def __init__(self, page_index: int, layouts: Iterable[MDRLayoutElement]):
     self._page_index = page_index; self._shapes = [_MDR_LinkedShape(l) for l in layouts]; self._shapes.sort(key=lambda s: (s.layout.rect.lt[1], s.layout.rect.lt[0]))
-  
+
   @property
   def page_index(self) -> int: return self._page_index
-  
+
   def find_framework_elements(self) -> list[MDRLayoutElement]:
     """Identifies framework layouts based on links to other pages."""
     return [s.layout for s in self._shapes if any(s.pre) or any(s.nex)]
-  
+
   def link_to_next(self, next_section: 'MDRPageSection', offset: int) -> None:
     """Links matching shapes between this section and the next."""
     if offset not in (1,2): return
@@ -1364,12 +1365,12 @@ class MDRPageSection:
       if max_sim > 0.75: matches += 1; if best_j != -1: used_f2[best_j] = True
     max_c = max(c1, c2); rate_frags = matches / max_c
     return self._check_match_threshold(rate_frags, max_c, (0.0, 0.45, 0.45, 0.6, 0.8, 0.95))
-  
+
   def _fragment_sim(self, l1: MDRLayoutElement, l2: MDRLayoutElement, f1: MDROcrFragment, f2: MDROcrFragment) -> float:
       r1_rel = self._relative_rect(l1.rect.lt, f1.rect); r2_rel = self._relative_rect(l2.rect.lt, f2.rect)
       geom_sim = self._symmetric_iou(r1_rel, r2_rel); text_sim, _ = mdr_check_text_similarity(f1.text, f2.text)
       return (geom_sim + text_sim) / 2.0
-      
+
   def _find_origin_pair(self, matches_matrix: list[list[_MDR_LinkedShape]], next_shapes: list[_MDR_LinkedShape]) -> tuple[_MDR_LinkedShape, _MDR_LinkedShape] | None:
       best_pair, min_dist2 = None, float('inf')
       for i, s1 in enumerate(self._shapes):
@@ -1377,13 +1378,13 @@ class MDRPageSection:
           if not match_list: continue
           for s2 in match_list: dist2 = s1.distance2 + s2.distance2; if dist2 < min_dist2: min_dist2, best_pair = dist2, (s1, s2)
       return best_pair
-      
+
   def _check_match_threshold(self, rate: float, count: int, thresholds: Sequence[float]) -> bool:
       if not thresholds: return False; idx = min(count, len(thresholds)-1); return rate >= thresholds[idx]
-          
+
   def _relative_rect(self, origin: MDRPoint, rect: MDRRectangle) -> MDRRectangle:
       ox, oy = origin; r=rect; return MDRRectangle(lt=(r.lt[0]-ox, r.lt[1]-oy), rt=(r.rt[0]-ox, r.rt[1]-oy), lb=(r.lb[0]-ox, r.lb[1]-oy), rb=(r.rb[0]-ox, r.rb[1]-oy))
-      
+
   def _symmetric_iou(self, r1: MDRRectangle, r2: MDRRectangle) -> float:
       try: p1, p2 = Polygon(r1), Polygon(r2);
       except: return 0.0
@@ -1400,19 +1401,19 @@ _MDR_CONTEXT_PAGES = 2 # Look behind/ahead pages for context
 class MDRProcessingParams:
   """Parameters for processing a document."""
   pdf: str | FitzDocument; page_indexes: Iterable[int] | None; report_progress: MDRProgressReportCallback | None
-    
+
 class MDRDocumentIterator:
   """Iterates through document pages, handles context, and calls the extraction engine."""
-    
+
   def __init__(self, device: Literal["cpu", "cuda"], model_dir_path: str, ocr_level: MDROcrLevel, extract_formula: bool, extract_table_format: MDRTableLayoutParsedFormat | None, debug_dir_path: str | None):
     self._debug_dir = debug_dir_path
     self._engine = MDRExtractionEngine(device=device, model_dir_path=model_dir_path, ocr_for_each_layouts=(ocr_level==MDROcrLevel.OncePerLayout), extract_formula=extract_formula, extract_table_format=extract_table_format)
-  
+
   def iterate_sections(self, params: MDRProcessingParams) -> Generator[tuple[int, MDRExtractionResult, list[MDRLayoutElement]], None, None]:
     """Yields page index, extraction result, and content layouts for each requested page."""
     for res, sec in self._process_and_link_sections(params):
       framework = set(sec.find_framework_elements()); content = [l for l in res.layouts if l not in framework]; yield sec.page_index, res, content
-        
+
   def _process_and_link_sections(self, params: MDRProcessingParams) -> Generator[tuple[MDRExtractionResult, MDRPageSection], None, None]:
     queue: list[tuple[MDRExtractionResult, MDRPageSection]] = []
     for page_idx, res in self._run_extraction_on_pages(params):
@@ -1423,7 +1424,7 @@ class MDRDocumentIterator:
       queue.append((res, cur_sec))
       if len(queue) > _MDR_CONTEXT_PAGES: yield queue.pop(0)
     for res, sec in queue: yield res, sec
-        
+
   def _run_extraction_on_pages(self, params: MDRProcessingParams) -> Generator[tuple[int, MDRExtractionResult], None, None]:
     if self._debug_dir: mdr_ensure_directory(self._debug_dir)
     doc, should_close = None, False
@@ -1446,7 +1447,7 @@ class MDRDocumentIterator:
         except Exception as e: print(f"  Iterator: Page {page_idx+1} processing error: {e}")
     finally:
       if should_close and doc: doc.close()
-          
+
   def _get_page_ranges(self, doc: FitzDocument, idxs: Iterable[int]|None) -> tuple[Sequence[int], Sequence[int]]:
     count = doc.page_count;
     if idxs is None: all_p = list(range(count)); return all_p, all_p
@@ -1454,11 +1455,11 @@ class MDRDocumentIterator:
     for i in idxs:
       if 0<=i<count: enable.add(i); [scan.add(j) for j in range(max(0, i-_MDR_CONTEXT_PAGES), min(count, i+_MDR_CONTEXT_PAGES+1))]
     return sorted(list(scan)), sorted(list(enable))
-      
+
   def _render_page_image(self, page: FitzPage, dpi: int) -> Image:
     mat = FitzMatrix(dpi/72.0, dpi/72.0); pix = page.get_pixmap(matrix=mat, alpha=False)
     return frombytes("RGB", (pix.width, pix.height), pix.samples)
-      
+
   def _save_debug_plot(self, img: Image, idx: int, res: MDRExtractionResult, path: str):
     try: plot_img = res.adjusted_image.copy() if res.adjusted_image else img.copy(); mdr_plot_layout(plot_img, res.layouts); plot_img.save(os.path.join(path, f"mdr_plot_page_{idx+1}.png"))
     except Exception as e: print(f"  Iterator: Plot generation error page {idx+1}: {e}")
@@ -1469,7 +1470,7 @@ class MagicPDFProcessor:
   Main class for processing PDF documents to extract structured data blocks
   using the MagicDataReadiness pipeline.
   """
-    
+
   def __init__(self, device: Literal["cpu", "cuda"]="cuda", model_dir_path: str="./mdr_models", ocr_level: MDROcrLevel=MDROcrLevel.Once, extract_formula: bool=True, extract_table_format: MDRExtractedTableFormat|None=None, debug_dir_path: str|None=None):
     """
     Initializes the MagicPDFProcessor.
@@ -1546,22 +1547,68 @@ class MagicPDFProcessor:
     self._assign_relative_font_sizes(temp_store);
     return [block for _, block in temp_store]
 
+  # --- START REFACTORED METHOD ---
   def _analyze_paragraph_structure(self, blocks: list[MDRStructuredBlock]):
-      """Calculates indentation and line-end heuristics for MDRTextBlocks."""
-      page_h, page_x1, page_x2 = self._calculate_text_range((b for b in blocks if isinstance(b, MDRTextBlock) and b.kind!=MDRTextKind.ABANDON))
-      if page_h <= 1e-6: return # Avoid calculations if no valid text height
-      for b in blocks:
-          if not isinstance(b, MDRTextBlock) or b.kind==MDRTextKind.ABANDON or not b.texts: continue
-          h, x1, x2 = page_h, page_x1, page_x2; first_t, last_t = b.texts[0], b.texts[-1]
-          try: # Add try-except for robustness
-              first_x = (first_t.rect.lt[0]+first_t.rect.lb[0])/2; first_delta = first_x - x1
-              b.has_paragraph_indentation = first_delta > h * 1.0 # Heuristic threshold
-              last_x = (last_t.rect.rt[0]+last_t.rect.rb[0])/2; last_delta = x2 - last_x
-              b.last_line_touch_end = last_delta < h * 1.0 # Heuristic threshold
+      """
+      Calculates indentation and line-end heuristics for MDRTextBlocks
+      based on page-level text boundaries and average line height.
+      """
+      # Define constants for clarity and maintainability
+      MIN_VALID_HEIGHT = 1e-6
+      # Heuristic: Indent if first line starts more than 1.0 * avg line height from page text start
+      INDENTATION_THRESHOLD_FACTOR = 1.0
+      # Heuristic: Last line touches end if it ends less than 1.0 * avg line height from page text end
+      LINE_END_THRESHOLD_FACTOR = 1.0
+
+      # Calculate average line height and text boundaries for the relevant text blocks on the page
+      page_avg_line_height, page_min_x, page_max_x = self._calculate_text_range(
+          (b for b in blocks if isinstance(b, MDRTextBlock) and b.kind != MDRTextKind.ABANDON)
+      )
+
+      # Avoid calculations if page metrics are invalid (e.g., no text, zero height)
+      if page_avg_line_height <= MIN_VALID_HEIGHT:
+          return
+
+      # Iterate through each block to determine its paragraph properties
+      for block in blocks:
+          # Process only valid text blocks with actual text content
+          if not isinstance(block, MDRTextBlock) or block.kind == MDRTextKind.ABANDON or not block.texts:
+              continue
+
+          # Use calculated page-level metrics for consistency in thresholds
+          avg_line_height = page_avg_line_height
+          page_text_start_x = page_min_x
+          page_text_end_x = page_max_x
+
+          # Get the first and last text spans (assumed to be lines after merging) within the block
+          first_text_span = block.texts[0]
+          last_text_span = block.texts[-1]
+
+          try:
+              # --- Calculate Indentation ---
+              # Estimate the starting x-coordinate of the first line (average of left top/bottom)
+              first_line_start_x = (first_text_span.rect.lt[0] + first_text_span.rect.lb[0]) / 2.0
+              # Calculate the difference between the first line's start and the page's text start boundary
+              indentation_delta = first_line_start_x - page_text_start_x
+              # Determine indentation based on the heuristic threshold relative to average line height
+              block.has_paragraph_indentation = indentation_delta > (avg_line_height * INDENTATION_THRESHOLD_FACTOR)
+
+              # --- Calculate Last Line End ---
+              # Estimate the ending x-coordinate of the last line (average of right top/bottom)
+              last_line_end_x = (last_text_span.rect.rt[0] + last_text_span.rect.rb[0]) / 2.0
+              # Calculate the difference between the page's text end boundary and the last line's end
+              line_end_delta = page_text_end_x - last_line_end_x
+              # Determine if the last line reaches near the end based on the heuristic threshold
+              block.last_line_touch_end = line_end_delta < (avg_line_height * LINE_END_THRESHOLD_FACTOR)
+
           except Exception as e:
+              # Handle potential errors during calculation (e.g., invalid rect data)
               print(f"Warn: Error calculating paragraph structure for block: {e}")
-              b.has_paragraph_indentation = False; b.last_line_touch_end = False
+              # Default to False if calculation fails to ensure attributes are set
+              block.has_paragraph_indentation = False
+              block.last_line_touch_end = False # Removed semicolon from original
 
+  # --- END REFACTORED METHOD ---
 
   def _calculate_text_range(self, blocks_iter: Iterable[MDRStructuredBlock]) -> tuple[float, float, float]:
     """Calculates average line height and min/max x-coordinates for text."""
@@ -1639,7 +1686,19 @@ if __name__ == '__main__':
 
     # Path to the PDF file you want to process
     # IMPORTANT: Place a PDF file here for testing!
+    # Create a dummy PDF if it doesn't exist for the example to run
     MDR_INPUT_PDF = "example_input.pdf" # <--- CHANGE THIS
+    if not Path(MDR_INPUT_PDF).exists():
+        try:
+            print(f"Creating dummy PDF: {MDR_INPUT_PDF}")
+            doc = fitz.new_document()
+            page = doc.new_page()
+            page.insert_text((72, 72), "This is a dummy PDF for testing.")
+            doc.save(MDR_INPUT_PDF)
+            doc.close()
+        except Exception as e:
+            print(f"Warning: Could not create dummy PDF: {e}")
+
 
     # Optional: Directory to save debug plots (set to None to disable)
     MDR_DEBUG_DIRECTORY = "./mdr_debug_output"
@@ -1718,7 +1777,7 @@ if __name__ == '__main__':
                 info = f"  - Block {block_idx+1}: {type(block).__name__}"
                 if isinstance(block, MDRTextBlock):
                     preview = block.texts[0].content[:70].replace('\n',' ') + "..." if block.texts else "[EMPTY]"
-                    info += f" (Kind: {block.kind.name}, FontSz: {block.font_size:.2f}) | Text: '{preview}'"
+                    info += f" (Kind: {block.kind.name}, FontSz: {block.font_size:.2f}, Indent: {block.has_paragraph_indentation}, EndTouch: {block.last_line_touch_end}) | Text: '{preview}'" # Added indent/endtouch
                 elif isinstance(block, MDRTableBlock):
                     info += f" (Format: {block.format.name}, HasContent: {bool(block.content)}, FontSz: {block.font_size:.2f})"
                     # if block.content: print(f"    Content:\n{block.content}") # Uncomment to see content