doctra 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

doctra/third_party/docres/utils.py

@@ -0,0 +1,464 @@
+from collections import OrderedDict
+import os
+import numpy as np
+import torch
+import torch.nn.functional as F
+import os 
+from skimage.filters import threshold_sauvola
+import cv2 
+
+def second2hours(seconds):
+    h = seconds//3600
+    seconds %= 3600
+    m = seconds//60
+    seconds %= 60
+
+    hms = '{:d} H : {:d} Min'.format(int(h),int(m))
+    return hms
+
+
+def dict2string(loss_dict):
+    loss_string = ''
+    for key, value in loss_dict.items():
+        loss_string += key+' {:.4f}, '.format(value)
+    return loss_string[:-2]
+def mkdir(dir):
+    if not os.path.exists(dir):
+        os.makedirs(dir)    
+
+def convert_state_dict(state_dict):
+    """Converts a state dict saved from a dataParallel module to normal 
+       module state_dict inplace
+       :param state_dict is the loaded DataParallel model_state
+    
+    """
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        name = k[7:] # remove `module.`
+        new_state_dict[name] = v
+    return new_state_dict
+
+
+def get_lr(optimizer):
+    for param_group in optimizer.param_groups:
+        return float(param_group['lr'])
+
+
+def torch2cvimg(tensor,min=0,max=1):
+    '''
+    input:
+        tensor -> torch.tensor BxCxHxW C can be 1,3
+    return
+        im -> ndarray uint8 HxWxC 
+    '''
+    im_list = []
+    for i in range(tensor.shape[0]):
+        im = tensor.detach().cpu().data.numpy()[i]
+        im = im.transpose(1,2,0)
+        im = np.clip(im,min,max)
+        im = ((im-min)/(max-min)*255).astype(np.uint8)
+        im_list.append(im)
+    return im_list
+def cvimg2torch(img,min=0,max=1):
+    '''
+    input:
+        im -> ndarray uint8 HxWxC 
+    return
+        tensor -> torch.tensor BxCxHxW 
+    '''
+    img = img.astype(float) / 255.0
+    img = img.transpose(2, 0, 1) # NHWC -> NCHW
+    img = np.expand_dims(img, 0)
+    img = torch.from_numpy(img).float()
+    return img
+
+
+def setup_seed(seed):
+    # np.random.seed(seed)
+    # random.seed(seed)
+    # torch.manual_seed(seed) #cpu
+    # torch.cuda.manual_seed_all(seed)  #并行gpu
+    torch.backends.cudnn.deterministic = True  #cpu/gpu结果一致
+    # torch.backends.cudnn.benchmark = False   #训练集变化不大时使训练加速
+
+def SauvolaModBinarization(image,n1=51,n2=51,k1=0.3,k2=0.3,default=True):
+    '''
+	 Binarization using Sauvola's algorithm
+		@name : SauvolaModBinarization
+	 parameters
+		@param image (numpy array of shape (3/1) of type np.uint8): color or gray scale image
+	 optional parameters
+		@param n1 (int) : window size for running sauvola during the first pass
+		@param n2 (int): window size for running sauvola during the second pass
+		@param k1 (float): k value corresponding to sauvola during the first pass
+		@param k2 (float): k value corresponding to sauvola during the second pass
+		@param default (bool) : bollean variable to set the above parameter as default. 
+			@param default is set to True : thus default values of the above optional parameters (n1,n2,k1,k2) are set to
+				n1 = 5 % of min(image height, image width)
+				n2 = 10 % of min(image height, image width)
+				k1 = 0.5
+				k2 = 0.5
+		Returns
+			@return A binary image of same size as @param image
+		
+		@cite https://drive.google.com/file/d/1D3CyI5vtodPJeZaD2UV5wdcaIMtkBbdZ/view?usp=sharing
+    '''
+
+    if(default):
+        n1 = int(0.05*min(image.shape[0],image.shape[1]))
+        if (n1%2==0):
+            n1 = n1+1
+        n2 = int(0.1*min(image.shape[0],image.shape[1]))
+        if (n2%2==0):
+            n2 = n2+1
+        k1 = 0.5
+        k2 = 0.5
+    if(image.ndim==3):
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = np.copy(image)
+    T1 = threshold_sauvola(gray, window_size=n1,k=k1)
+    max_val = np.amax(gray)
+    min_val = np.amin(gray)
+    C = np.copy(T1)
+    C = C.astype(np.float32)
+    C[gray > T1] = (gray[gray > T1] - T1[gray > T1])/(max_val - T1[gray > T1])
+    C[gray <= T1] = 0
+    C = C * 255.0
+    new_in = np.copy(C.astype(np.uint8))
+    T2 = threshold_sauvola(new_in, window_size=n2,k=k2)
+    binary = np.copy(gray)
+    binary[new_in <= T2] = 0
+    binary[new_in > T2] = 255
+    return binary,T2
+
+
+def getBasecoord(h,w):
+    base_coord0 = np.tile(np.arange(h).reshape(h,1),(1,w)).astype(np.float32)
+    base_coord1 = np.tile(np.arange(w).reshape(1,w),(h,1)).astype(np.float32)
+    base_coord = np.concatenate((np.expand_dims(base_coord1,-1),np.expand_dims(base_coord0,-1)),-1)
+    return base_coord
+
+
+
+
+
+
+import numpy as np
+from scipy import ndimage as ndi
+
+# lookup tables for bwmorph_thin
+
+G123_LUT = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
+       0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
+       1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+       0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1,
+       0, 0, 0], dtype=np.bool)
+
+G123P_LUT = np.array([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+       1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
+       0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0,
+       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
+       0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0], dtype=np.bool)
+
+def bwmorph(image, n_iter=None):
+    """
+    Perform morphological thinning of a binary image
+    
+    Parameters
+    ----------
+    image : binary (M, N) ndarray
+        The image to be thinned.
+    
+    n_iter : int, number of iterations, optional
+        Regardless of the value of this parameter, the thinned image
+        is returned immediately if an iteration produces no change.
+        If this parameter is specified it thus sets an upper bound on
+        the number of iterations performed.
+    
+    Returns
+    -------
+    out : ndarray of bools
+        Thinned image.
+    
+    See also
+    --------
+    skeletonize
+    
+    Notes
+    -----
+    This algorithm [1]_ works by making multiple passes over the image,
+    removing pixels matching a set of criteria designed to thin
+    connected regions while preserving eight-connected components and
+    2 x 2 squares [2]_. In each of the two sub-iterations the algorithm
+    correlates the intermediate skeleton image with a neighborhood mask,
+    then looks up each neighborhood in a lookup table indicating whether
+    the central pixel should be deleted in that sub-iteration.
+    
+    References
+    ----------
+    .. [1] Z. Guo and R. W. Hall, "Parallel thinning with
+           two-subiteration algorithms," Comm. ACM, vol. 32, no. 3,
+           pp. 359-373, 1989.
+    .. [2] Lam, L., Seong-Whan Lee, and Ching Y. Suen, "Thinning
+           Methodologies-A Comprehensive Survey," IEEE Transactions on
+           Pattern Analysis and Machine Intelligence, Vol 14, No. 9,
+           September 1992, p. 879
+    
+    Examples
+    --------
+    >>> square = np.zeros((7, 7), dtype=np.uint8)
+    >>> square[1:-1, 2:-2] = 1
+    >>> square[0,1] =  1
+    >>> square
+    array([[0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    >>> skel = bwmorph_thin(square)
+    >>> skel.astype(np.uint8)
+    array([[0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    # check parameters
+    if n_iter is None:
+        n = -1
+    elif n_iter <= 0:
+        raise ValueError('n_iter must be > 0')
+    else:
+        n = n_iter
+    
+    # check that we have a 2d binary image, and convert it
+    # to uint8
+    skel = np.array(image).astype(np.uint8)
+    
+    if skel.ndim != 2:
+        raise ValueError('2D array required')
+    if not np.all(np.in1d(image.flat,(0,1))):
+        raise ValueError('Image contains values other than 0 and 1')
+
+    # neighborhood mask
+    mask = np.array([[ 8,  4,  2],
+                     [16,  0,  1],
+                     [32, 64,128]],dtype=np.uint8)
+
+    # iterate either 1) indefinitely or 2) up to iteration limit
+    while n != 0:
+        before = np.sum(skel) # count points before thinning
+        
+        # for each subiteration
+        for lut in [G123_LUT, G123P_LUT]:
+            # correlate image with neighborhood mask
+            N = ndi.correlate(skel, mask, mode='constant')
+            # take deletion decision from this subiteration's LUT
+            D = np.take(lut, N)
+            # perform deletion
+            skel[D] = 0
+            
+        after = np.sum(skel) # coint points after thinning
+        
+        if before == after:
+            # iteration had no effect: finish
+            break
+            
+        # count down to iteration limit (or endlessly negative)
+        n -= 1
+    
+    return skel.astype(np.bool)
+    
+"""
+# here's how to make the LUTs
+def nabe(n):
+    return np.array([n>>i&1 for i in range(0,9)]).astype(np.bool)
+def hood(n):
+    return np.take(nabe(n), np.array([[3, 2, 1],
+                                      [4, 8, 0],
+                                      [5, 6, 7]]))
+def G1(n):
+    s = 0
+    bits = nabe(n)
+    for i in (0,2,4,6):
+        if not(bits[i]) and (bits[i+1] or bits[(i+2) % 8]):
+            s += 1
+    return s==1
+            
+g1_lut = np.array([G1(n) for n in range(256)])
+def G2(n):
+    n1, n2 = 0, 0
+    bits = nabe(n)
+    for k in (1,3,5,7):
+        if bits[k] or bits[k-1]:
+            n1 += 1
+        if bits[k] or bits[(k+1) % 8]:
+            n2 += 1
+    return min(n1,n2) in [2,3]
+g2_lut = np.array([G2(n) for n in range(256)])
+g12_lut = g1_lut & g2_lut
+def G3(n):
+    bits = nabe(n)
+    return not((bits[1] or bits[2] or not(bits[7])) and bits[0])
+def G3p(n):
+    bits = nabe(n)
+    return not((bits[5] or bits[6] or not(bits[3])) and bits[4])
+g3_lut = np.array([G3(n) for n in range(256)])
+g3p_lut = np.array([G3p(n) for n in range(256)])
+g123_lut  = g12_lut & g3_lut
+g123p_lut = g12_lut & g3p_lut
+"""
+
+"""
+author : Peb Ruswono Aryan
+
+metric for evaluating binarization algorithms
+implemented : 
+
+ * F-Measure
+ * pseudo F-Measure (as in H-DIBCO 2010 & 2012)
+ * Peak Signal to Noise Ratio (PSNR)
+ * Negative Rate Measure (NRM)
+ * Misclassification Penaltiy Measure (MPM)
+ * Distance Reciprocal Distortion (DRD)
+
+usage:
+	python metric.py test-image.png ground-truth-image.png
+"""
+
+
+def drd_fn(im, im_gt):
+	height, width = im.shape
+	neg = np.zeros(im.shape)
+	neg[im_gt!=im] = 1
+	y, x = np.unravel_index(np.flatnonzero(neg), im.shape)
+	
+	n = 2
+	m = n*2+1
+	W = np.zeros((m,m), dtype=np.uint8)
+	W[n,n] = 1.
+	W = cv2.distanceTransform(1-W, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+	W[n,n] = 1.
+	W = 1./W
+	W[n,n] = 0.
+	W /= W.sum()
+	
+	nubn = 0.
+	block_size = 8
+	for y1 in range(0, height, block_size):
+		for x1 in range(0, width, block_size):
+			y2 = min(y1+block_size-1,height-1)
+			x2 = min(x1+block_size-1,width-1)
+			block_dim = (x2-x1+1)*(y1-y1+1)
+			block = 1-im_gt[y1:y2, x1:x2]
+			block_sum = np.sum(block)
+			if block_sum>0 and block_sum<block_dim:
+				nubn += 1
+
+	drd_sum= 0.
+	tmp = np.zeros(W.shape)
+	for i in range(min(1,len(y))):
+		tmp[:,:] = 0 
+
+		x1 = max(0, x[i]-n)
+		y1 = max(0, y[i]-n)
+		x2 = min(width-1, x[i]+n)
+		y2 = min(height-1, y[i]+n)
+
+		yy1 = y1-y[i]+n
+		yy2 = y2-y[i]+n
+		xx1 = x1-x[i]+n
+		xx2 = x2-x[i]+n
+
+		tmp[yy1:yy2+1,xx1:xx2+1] = np.abs(im[y[i],x[i]]-im_gt[y1:y2+1,x1:x2+1])
+		tmp *= W
+
+		drd_sum += np.sum(tmp)
+	return drd_sum/nubn
+
+def bin_metric(im,im_gt):
+	height, width = im.shape
+	npixel = height*width
+
+	im[im>0] = 1
+	gt_mask = im_gt==0
+	im_gt[im_gt>0] = 1
+
+	sk = bwmorph(1-im_gt)
+	im_sk = np.ones(im_gt.shape)
+	im_sk[sk] = 0
+	
+	kernel = np.ones((3,3), dtype=np.uint8)
+	im_dil = cv2.erode(im_gt, kernel)
+	im_gtb = im_gt-im_dil
+	im_gtbd = cv2.distanceTransform(1-im_gtb, cv2.DIST_L2, 3)
+	
+	nd = im_gtbd.sum()
+
+	ptp = np.zeros(im_gt.shape)
+	ptp[(im==0) & (im_sk==0)] = 1
+	numptp = ptp.sum()
+
+	tp = np.zeros(im_gt.shape)
+	tp[(im==0) & (im_gt==0)] = 1
+	numtp = tp.sum()
+
+	tn = np.zeros(im_gt.shape)
+	tn[(im==1) & (im_gt==1)] = 1
+	numtn = tn.sum()
+
+	fp = np.zeros(im_gt.shape)
+	fp[(im==0) & (im_gt==1)] = 1
+	numfp = fp.sum()
+
+	fn = np.zeros(im_gt.shape)
+	fn[(im==1) & (im_gt==0)] = 1
+	numfn = fn.sum()
+
+	precision = numtp / (numtp + numfp)
+	recall = numtp / (numtp + numfn)
+	precall = numptp / np.sum(1-im_sk)
+	fmeasure = (2*recall*precision)/(recall+precision)
+	pfmeasure = (2*precall*precision)/(precall+precision)
+
+	mse = (numfp+numfn)/npixel
+	psnr = 10.*np.log10(1./mse)
+
+	nrfn = numfn / (numfn + numtp)
+	nrfp = numfp / (numfp + numtn)
+	nrm = (nrfn + nrfp)/2
+
+	im_dn = im_gtbd.copy()
+	im_dn[fn==0] = 0
+	dn = np.sum(im_dn)
+	mpfn = dn / nd
+
+	im_dp = im_gtbd.copy()
+	im_dp[fp==0] = 0
+	dp = np.sum(im_dp)
+	mpfp = dp / nd
+
+	mpm = (mpfp + mpfn) / 2
+	drd = drd_fn(im, im_gt)
+
+	return fmeasure, pfmeasure,psnr,nrm, mpm,drd
+	# print("F-measure\t: {0}\npF-measure\t: {1}\nPSNR\t\t: {2}\nNRM\t\t: {3}\nMPM\t\t: {4}\nDRD\t\t: {5}".format(fmeasure, pfmeasure, psnr, nrm, mpm, drd))

doctra/ui/app.py

@@ -17,13 +17,10 @@ def _gather_outputs(out_dir: Path, allowed_kinds: Optional[List[str]] = None, zi
 
     if out_dir.exists():
         if is_structured_parsing:
-            # For structured parsing, show ALL files in the directory
             for file_path in sorted(out_dir.rglob("*")):
                 if file_path.is_file():
                     file_paths.append(str(file_path))
         else:
-            # For full parsing, use the original logic
-            # Always add main output files (HTML, Markdown, etc.) regardless of allowed_kinds
             main_files = [
                 "result.html",
                 "result.md", 
@@ -36,22 +33,18 @@ def _gather_outputs(out_dir: Path, allowed_kinds: Optional[List[str]] = None, zi
                 if file_path.exists():
                     file_paths.append(str(file_path))
             
-            # Add image files based on allowed_kinds or all images if not specified
             if allowed_kinds:
                 for kind in allowed_kinds:
-                    # ChartTablePDFParser saves directly to charts/ and tables/ directories
                     p = out_dir / kind
                     if p.exists():
-                        for img in sorted(p.glob("*.png")):  # ChartTablePDFParser saves as .png
+                        for img in sorted(p.glob("*.png")):
                             file_paths.append(str(img))
                     
-                    # Also check images/ subdirectories (for StructuredPDFParser)
                     images_dir = out_dir / "images" / kind
                     if images_dir.exists():
-                        for img in sorted(images_dir.glob("*.jpg")):  # StructuredPDFParser saves as .jpg
+                        for img in sorted(images_dir.glob("*.jpg")):
                             file_paths.append(str(img))
             else:
-                # Fallback: look in both direct directories and images/ subdirectories
                 for p in (out_dir / "charts").glob("*.png"):
                     file_paths.append(str(p))
                 for p in (out_dir / "tables").glob("*.png"):
@@ -59,7 +52,6 @@ def _gather_outputs(out_dir: Path, allowed_kinds: Optional[List[str]] = None, zi
                 for p in (out_dir / "images").rglob("*.jpg"):
                     file_paths.append(str(p))
 
-            # Add Excel files based on extraction target (for structured parsing)
             if allowed_kinds:
                 if "charts" in allowed_kinds and "tables" in allowed_kinds:
                     excel_files = ["parsed_tables_charts.xlsx"]
@@ -77,30 +69,24 @@ def _gather_outputs(out_dir: Path, allowed_kinds: Optional[List[str]] = None, zi
 
     kinds = allowed_kinds if allowed_kinds else ["tables", "charts", "figures"]
     for sub in kinds:
-        # Look in both direct directories and images/ subdirectories
-        # First try direct directories (for ChartTablePDFParser)
         p = out_dir / sub
         if p.exists():
-            for img in sorted(p.glob("*.png")):  # ChartTablePDFParser saves as .png
+            for img in sorted(p.glob("*.png")):
                 gallery_items.append((str(img), f"{sub}: {img.name}"))
         
-        # Also try images/ subdirectories (for StructuredPDFParser)
         images_dir = out_dir / "images" / sub
         if images_dir.exists():
-            for img in sorted(images_dir.glob("*.jpg")):  # StructuredPDFParser saves as .jpg
+            for img in sorted(images_dir.glob("*.jpg")):
                 gallery_items.append((str(img), f"{sub}: {img.name}"))
 
     tmp_zip_dir = Path(tempfile.mkdtemp(prefix="doctra_zip_"))
     
-    # Use custom filename if provided, otherwise use default
     if zip_filename:
-        # Clean the filename to be safe for file systems
         safe_filename = re.sub(r'[<>:"/\\|?*]', '_', zip_filename)
         zip_base = tmp_zip_dir / safe_filename
     else:
         zip_base = tmp_zip_dir / "doctra_outputs"
     
-    # Create a filtered copy of the output directory excluding temp files
     filtered_dir = tmp_zip_dir / "filtered_outputs"
     shutil.copytree(out_dir, filtered_dir, ignore=shutil.ignore_patterns('~$*', '*.tmp', '*.temp'))
     
@@ -125,13 +111,10 @@ def _parse_markdown_by_pages(md_content: str) -> List[Dict[str, Any]]:
     while i < len(lines):
         line = lines[i].strip()
         
-        # Check for page header
         if line.startswith('## Page '):
-            # Save previous page if exists
             if current_page:
                 pages.append(current_page)
             
-            # Start new page
             page_num = line.replace('## Page ', '').strip()
             current_page = {
                 'page_num': page_num,
@@ -145,15 +128,12 @@ def _parse_markdown_by_pages(md_content: str) -> List[Dict[str, Any]]:
             i += 1
             continue
         
-        # Check for images (tables, charts, figures)
         if line.startswith('![') and '](images/' in line:
-            # Extract image info
             match = re.match(r'!\[([^\]]+)\]\(([^)]+)\)', line)
             if match:
                 caption = match.group(1)
                 img_path = match.group(2)
                 
-                # Categorize by type
                 if 'Table' in caption:
                     current_page['tables'].append({'caption': caption, 'path': img_path})
                 elif 'Chart' in caption:
@@ -163,18 +143,15 @@ def _parse_markdown_by_pages(md_content: str) -> List[Dict[str, Any]]:
                 
                 current_page['images'].append({'caption': caption, 'path': img_path})
                 
-                # Add to full content with proper markdown formatting
                 current_page['full_content'].append(f"![{caption}]({img_path})")
         
-        # Regular content
         elif current_page:
-            if line:  # Only add non-empty lines
+            if line:
                 current_page['content'].append(line)
             current_page['full_content'].append(line)
         
         i += 1
     
-    # Add the last page
     if current_page:
         pages.append(current_page)
     
@@ -198,12 +175,9 @@ def run_full_parse(
     if not pdf_file:
         return ("No file provided.", None, [], [], "")
 
-    # Extract filename from the uploaded file path
-    # Gradio provides the original filename in the file path
     original_filename = Path(pdf_file).stem
     
     tmp_dir = Path(tempfile.mkdtemp(prefix="doctra_"))
-    # Use original filename for temp file so parser creates correct output directory
     input_pdf = tmp_dir / f"{original_filename}.pdf"
     shutil.copy2(pdf_file, input_pdf)
 
@@ -295,7 +269,6 @@ def run_extract(
     original_filename = Path(pdf_file).stem
     
     tmp_dir = Path(tempfile.mkdtemp(prefix="doctra_"))
-    # Use original filename for temp file so parser creates correct output directory
     input_pdf = tmp_dir / f"{original_filename}.pdf"
     shutil.copy2(pdf_file, input_pdf)