Upload 7 files

crop_tables.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+"""
+JSON Table to XML Converter
+Processes JSON files containing table data and corresponding PNG images
+to create cropped sub-table images and XML coordinate files for ALL tables found.
+"""
+
+import json
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+import os
+from typing import Dict, List, Tuple, Any, Optional
+
+class TableProcessor:
+    """Main class for processing table data from JSON to XML with image cropping"""
+    
+    def __init__(self, padding_ratio: float = 0.05):
+        """
+        Initialize the table processor
+        
+        Args:
+            padding_ratio: Padding around table as ratio of min(width, height)
+        """
+        self.padding_ratio = padding_ratio
+        self.DEFAULT_WIDTH = 100
+        self.DEFAULT_HEIGHT = 30
+    
+    def extract_tables_from_json(self, json_data: Any) -> List[Dict]:
+        """
+        Extract all table items from JSON data
+        
+        Args:
+            json_data: Parsed JSON data (dict or list)
+            
+        Returns:
+            List of table dictionaries
+        """
+        if isinstance(json_data, list):
+            # Filter items with type="table"
+            tables = [item for item in json_data if item.get("type") == "table"]
+        elif isinstance(json_data, dict) and json_data.get("type") == "table":
+            # Single table item
+            tables = [json_data]
+        else:
+            tables = []
+        
+        return tables
+    
+    def calculate_cell_coordinates(self, table_properties: Dict, table_x: float, table_y: float) -> Dict[Tuple[int, int], Dict]:
+        """
+        Calculate coordinates for all visible cells in the table
+        
+        Args:
+            table_properties: Table properties from JSON
+            table_x: Table X position in original image
+            table_y: Table Y position in original image
+            
+        Returns:
+            Dictionary mapping (row, col) to coordinate info
+        """
+        rows = table_properties.get("rows", 0)
+        columns = table_properties.get("columns", 0)
+        column_widths = table_properties.get("columnWidths", {})
+        row_heights = table_properties.get("rowHeights", {})
+        merged_cells = table_properties.get("mergedCells", {})
+        hidden_cells = table_properties.get("hiddenCells", {})
+
+        def get_col_width(col: int) -> int:
+            return column_widths.get(str(col), self.DEFAULT_WIDTH)
+
+        def get_row_height(row: int) -> int:
+            return row_heights.get(str(row), self.DEFAULT_HEIGHT)
+
+        # Build set of cells that are covered by merged cells (excluding origin)
+        merged_spanned_cells = set()
+        for cell_key, merge_info in merged_cells.items():
+            base_row, base_col = map(int, cell_key.split('-'))
+            rowspan = merge_info.get('rowspan', 1)
+            colspan = merge_info.get('colspan', 1)
+            
+            # Add all spanned cells except the origin cell
+            for r in range(base_row, base_row + rowspan):
+                for c in range(base_col, base_col + colspan):
+                    if (r, c) != (base_row, base_col):
+                        merged_spanned_cells.add((r, c))
+
+        cell_coords = {}
+
+        for row in range(rows):
+            for col in range(columns):
+                cell_key = f"{row}-{col}"
+                
+                # Skip hidden cells and cells covered by merges
+                if hidden_cells.get(cell_key) or (row, col) in merged_spanned_cells:
+                    continue
+
+                # Calculate position by summing previous column widths/row heights
+                x = sum(get_col_width(c) for c in range(col))
+                y = sum(get_row_height(r) for r in range(row))
+
+                # Check if this cell is a merge origin
+                if cell_key in merged_cells:
+                    merge_info = merged_cells[cell_key]
+                    colspan = merge_info.get("colspan", 1)
+                    rowspan = merge_info.get("rowspan", 1)
+                else:
+                    colspan = 1
+                    rowspan = 1
+
+                # Calculate cell dimensions
+                width = sum(get_col_width(c) for c in range(col, col + colspan))
+                height = sum(get_row_height(r) for r in range(row, row + rowspan))
+
+                # Store coordinates (with 2x scaling factor from original code)
+                cell_coords[(row, col)] = {
+                    "x":  (x + table_x),
+                    "y": (y + table_y),
+                    "width":  width,
+                    "height":  height,
+                    "colspan": colspan,
+                    "rowspan": rowspan
+                }
+
+        return cell_coords
+    
+    def determine_cell_borders(self, cell_data: Optional[Dict], table_properties: Dict) -> Tuple[int, int, int, int]:
+        """
+        Determine border visibility for each side of a cell
+        
+        Args:
+            cell_data: Individual cell data from JSON
+            table_properties: Global table properties
+            
+        Returns:
+            Tuple of (top, bottom, left, right) border flags (0 or 1)
+        """
+        # Get global border settings
+        cell_borders = table_properties.get("cellBorders", {})
+        has_global_borders = cell_borders.get("all", False)
+        
+        # Default borders based on global setting
+        borders = {
+            "top": 1 if has_global_borders else 0,
+            "bottom": 1 if has_global_borders else 0,
+            "left": 1 if has_global_borders else 0,
+            "right": 1 if has_global_borders else 0
+        }
+        
+        # Check for cell-specific border overrides
+        if cell_data and "cellStyle" in cell_data:
+            cell_style = cell_data["cellStyle"]
+            
+            # Border property mappings
+            border_mappings = {
+                "borderTopWidth": "top",
+                "borderBottomWidth": "bottom",
+                "borderLeftWidth": "left",
+                "borderRightWidth": "right"
+            }
+            
+            # If any border width property exists, this cell has custom borders
+            has_custom_borders = any(key in cell_style for key in border_mappings.keys())
+            
+            if has_custom_borders:
+                # Apply custom border settings for each side
+                for width_key, border_side in border_mappings.items():
+                    if width_key in cell_style:
+                        # Check border width
+                        width = cell_style[width_key]
+                        has_border = width > 0
+                        
+                        # Check border style if specified
+                        style_key = width_key.replace("Width", "Style")
+                        if style_key in cell_style:
+                            style = cell_style[style_key]
+                            if style == "none":
+                                has_border = False
+                        
+                        borders[border_side] = 1 if has_border else 0
+        
+        return borders["top"], borders["bottom"], borders["left"], borders["right"]
+    
+    def convert_table_to_xml(self, table_data: Dict, output_filename: str) -> Tuple[ET.Element, Dict]:
+        """
+        Convert a single table to XML format with crop information
+        
+        Args:
+            table_data: Single table data from JSON
+            output_filename: Filename to reference in XML
+            
+        Returns:
+            Tuple of (XML root element, crop info dictionary)
+        """
+        # Extract table properties
+        properties = table_data.get("properties", {})
+        table_x = table_data.get("x", 0)
+        table_y = table_data.get("y", 0)
+        table_width = table_data.get("width", properties.get("width", 0))
+        table_height = table_data.get("height", properties.get("height", 0))
+        
+        # Calculate padding based on table dimensions
+        min_dimension = min(table_width, table_height)
+        padding = int(min_dimension * self.padding_ratio)
+        
+        # Calculate crop area
+        crop_x = table_x - padding
+        crop_y = table_y - padding
+        crop_width = table_width + (2 * padding)
+        crop_height = table_height + (2 * padding)
+        
+        # Create XML structure
+        root = ET.Element("document", filename=output_filename)
+        table_elem = ET.SubElement(root, "table")
+        
+        # Add table coordinates relative to cropped image
+        table_x_in_crop = padding
+        table_y_in_crop = padding
+        table_coords = f"{table_x_in_crop},{table_y_in_crop} {table_x_in_crop + table_width},{table_y_in_crop} {table_x_in_crop + table_width},{table_y_in_crop + table_height} {table_x_in_crop},{table_y_in_crop + table_height}"
+        ET.SubElement(table_elem, "Coords", points=table_coords)
+        
+        # Get cell coordinates and data
+        cell_coords = self.calculate_cell_coordinates(properties, table_x, table_y)
+        cell_data = properties.get("cellData", {})
+        merged_cells = properties.get("mergedCells", {})
+        
+        # Create XML elements for each cell
+        for (row, col), coords in cell_coords.items():
+            cell_key = f"{row}-{col}"
+            current_cell_data = cell_data.get(cell_key, {})
+            
+            # Determine cell span (for merged cells)
+            end_row = row + coords["rowspan"] - 1
+            end_col = col + coords["colspan"] - 1
+            
+            # Create cell element
+            cell_elem = ET.SubElement(table_elem, "cell")
+            cell_elem.set("start-row", str(row))
+            cell_elem.set("end-row", str(end_row))
+            cell_elem.set("start-col", str(col))
+            cell_elem.set("end-col", str(end_col))
+            
+            # Convert coordinates to cropped image space
+            original_x1 = int(coords["x"])
+            original_y1 = int(coords["y"])
+            original_x2 = int(coords["x"] + coords["width"])
+            original_y2 = int(coords["y"] + coords["height"])
+            
+            # Transform to cropped coordinates
+            crop_x1 = original_x1 - int( crop_x)
+            crop_y1 = original_y1 - int( crop_y)
+            crop_x2 = original_x2 - int( crop_x)
+            crop_y2 = original_y2 - int( crop_y)
+            
+            cell_coords_str = f"{crop_x1},{crop_y1} {crop_x2},{crop_y1} {crop_x2},{crop_y2} {crop_x1},{crop_y2}"
+            ET.SubElement(cell_elem, "Coords", points=cell_coords_str)
+            
+            # Add border information
+            top, bottom, left, right = self.determine_cell_borders(current_cell_data, properties)
+            ET.SubElement(cell_elem, "Lines",
+                         top=str(top),
+                         bottom=str(bottom),
+                         left=str(left),
+                         right=str(right))
+        
+        # Prepare crop information
+        crop_info = {
+            "crop_x": crop_x,
+            "crop_y": crop_y,
+            "crop_width": crop_width,
+            "crop_height": crop_height,
+            "padding": padding,
+            "table_id": table_data.get("id", "unknown")
+        }
+        
+        return root, crop_info
+    
+    def save_xml(self, xml_root: ET.Element, output_path: str) -> bool:
+        """
+        Save XML to file with pretty formatting
+        
+        Args:
+            xml_root: XML root element
+            output_path: Path to save XML file
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Convert to pretty-formatted string
+            rough_string = ET.tostring(xml_root, encoding='unicode')
+            reparsed = minidom.parseString(rough_string)
+            pretty_xml = reparsed.toprettyxml(indent="    ")
+            
+            # Clean up extra whitespace lines
+            lines = [line for line in pretty_xml.split('\n') if line.strip()]
+            pretty_xml = '\n'.join(lines)
+            
+            # Write to file
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(pretty_xml)
+            
+            return True
+        except Exception as e:
+            print(f"❌ Error saving XML to {output_path}: {e}")
+            return False
+    
+    def crop_image(self, image_path: str, crop_info: Dict, output_path: str) -> bool:
+        """
+        Crop image based on crop information
+        
+        Args:
+            image_path: Path to original image
+            crop_info: Crop information dictionary
+            output_path: Path to save cropped image
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            from PIL import Image
+            
+            with Image.open(image_path) as img:
+                # Ensure crop coordinates are within image bounds
+                left = max(0, int(crop_info['crop_x']))
+                top = max(0, int(crop_info['crop_y']))
+                right = min(img.width, int(crop_info['crop_x'] + crop_info['crop_width']))
+                bottom = min(img.height, int(crop_info['crop_y'] + crop_info['crop_height']))
+                
+                # Crop and save
+                cropped_img = img.crop((left, top, right, bottom))
+                cropped_img.save(output_path)
+                
+                return True
+                
+        except ImportError:
+            print("❌ PIL/Pillow not installed. Run: pip install Pillow")
+            return False
+        except Exception as e:
+            print(f"❌ Error cropping image: {e}")
+            return False
+    
+    def generate_output_filenames(self, base_name: str, table_index: int, table_id: str, total_tables: int, output_dir: str) -> Tuple[str, str, str]:
+        """
+        Generate appropriate output filenames for XML and image files
+        
+        Args:
+            base_name: Base filename without extension
+            table_index: Index of current table
+            table_id: ID of the table from JSON
+            total_tables: Total number of tables in the file
+            output_dir: Output directory
+            
+        Returns:
+            Tuple of (xml_path, image_path, image_filename_for_xml)
+        """
+        if total_tables > 1:
+            # Multiple tables: add index and ID to filename
+            clean_table_id = table_id.replace('/', '_').replace('\\', '_')  # Clean ID for filename
+            xml_filename = f"{base_name}_table_{table_index}_{clean_table_id}.xml"
+            image_filename = f"{base_name}_table_{table_index}_{clean_table_id}.png"
+        else:
+            # Single table: use simple filename
+            xml_filename = f"{base_name}.xml"
+            image_filename = f"{base_name}_cropped.png"
+        
+        xml_path = os.path.join(output_dir, xml_filename)
+        image_path = os.path.join(output_dir, image_filename)
+        
+        return xml_path, image_path, image_filename
+    
+    def process_single_file(self, json_path: str, image_path: str, output_dir: str = "output") -> int:
+        """
+        Process a single JSON+PNG file pair to extract all tables
+        
+        Args:
+            json_path: Path to JSON file
+            image_path: Path to PNG image file
+            output_dir: Directory for output files
+            
+        Returns:
+            Number of tables successfully processed
+        """
+        try:
+            # Create output directory
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Read and parse JSON
+            with open(json_path, 'r', encoding='utf-8') as f:
+                json_data = json.load(f)
+            json_data = json_data.get('items')
+            # Extract all tables
+            tables = self.extract_tables_from_json(json_data)
+            
+            if not tables:
+                print(f"❌ No tables found in {json_path}")
+                return 0
+            
+            print(f"📋 Found {len(tables)} table(s) in {json_path}")
+            
+            base_name = os.path.splitext(os.path.basename(json_path))[0]
+            successful_count = 0
+            
+            # Process each table
+            for table_index, table_data in enumerate(tables):
+                try:
+                    table_id = table_data.get('id', f'table_{table_index}')
+                    print(f"   🔄 Processing table {table_index + 1}/{len(tables)} (id: {table_id})")
+                    
+                    # Generate filenames
+                    xml_path, image_output_path, image_filename = self.generate_output_filenames(
+                        base_name, table_index, table_id, len(tables), output_dir
+                    )
+                    
+                    # Convert table to XML
+                    xml_root, crop_info = self.convert_table_to_xml(table_data, image_filename)
+                    
+                    # Save XML file
+                    if not self.save_xml(xml_root, xml_path):
+                        continue
+                    
+                    # Crop and save image
+                    if not self.crop_image(image_path, crop_info, image_output_path):
+                        continue
+                    
+                    print(f"   ✅ Table {table_index + 1} completed:")
+                    print(f"      📄 XML: {xml_path}")
+                    print(f"      🖼️  Image: {image_output_path}")
+                    print(f"      📏 Padding: {crop_info['padding']}px ({self.padding_ratio:.1%})")
+                    
+                    successful_count += 1
+                    
+                except Exception as e:
+                    print(f"   ❌ Error processing table {table_index + 1}: {e}")
+                    continue
+            
+            print(f"✅ Successfully processed {successful_count}/{len(tables)} tables from {json_path}")
+            return successful_count
+            
+        except Exception as e:
+            print(f"❌ Error processing file {json_path}: {e}")
+            return 0
+    
+    def process_batch(self, input_dir: str, output_dir: str = "output") -> int:
+        """
+        Batch process all JSON+PNG pairs in a directory
+        
+        Args:
+            input_dir: Directory containing JSON and PNG files
+            output_dir: Directory for output files
+            
+        Returns:
+            Total number of tables processed across all files
+        """
+        try:
+            # Find all JSON files
+            json_files = [f for f in os.listdir(input_dir) if f.endswith('.json')]
+            
+            if not json_files:
+                print(f"❌ No JSON files found in {input_dir}")
+                return 0
+            
+            print(f"🗂️  Found {len(json_files)} JSON files to process")
+            
+            total_tables = 0
+            files_processed = 0
+            
+            for json_file in json_files:
+                # Look for corresponding PNG file
+                base_name = os.path.splitext(json_file)[0]
+                png_file = f"{base_name}.png"
+                
+                json_path = os.path.join(input_dir, json_file)
+                png_path = os.path.join(input_dir, png_file)
+                
+                if os.path.exists(png_path):
+                    print(f"\n📋 Processing file pair: {base_name}")
+                    tables_count = self.process_single_file(json_path, png_path, output_dir)
+                    if tables_count > 0:
+                        total_tables += tables_count
+                        files_processed += 1
+                else:
+                    print(f"⚠️  Warning: No corresponding PNG file found for {json_file}")
+            
+            print(f"\n🎉 Batch processing completed!")
+            print(f"   📁 Files processed: {files_processed}/{len(json_files)}")
+            print(f"   📊 Total tables processed: {total_tables}")
+            
+            return total_tables
+            
+        except Exception as e:
+            print(f"❌ Error in batch processing: {e}")
+            return 0
+
+
+def main():
+    """Main function with usage examples"""
+    
+    # Create processor instance
+    processor = TableProcessor(padding_ratio=0.02)  # 5% padding
+    
+    print("🔧 JSON Table to XML Converter")
+    print("=" * 50)
+    
+    # Example usage
+    print("\n📖 Usage Examples:")
+    print("1. Single file (all tables):")
+    print("   processor.process_single_file('page1.json', 'page1.png', 'output')")
+    
+    print("\n2. Batch processing (all files, all tables):")
+    print("   processor.process_batch('input_folder', 'output_folder')")
+    
+    print("\n3. Custom padding:")
+    print("   processor = TableProcessor(padding_ratio=0.08)  # 8% padding")
+    processor.process_batch('/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/40_page_70_110925', 'output_folder')
+    # processor.process_single_file('/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/page_39/39(draft 13).json', '/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/page_39/39(draft 13).png', 'output')
+if __name__ == "__main__":
+    main()

delete_name.py

@@ -0,0 +1,12 @@
+import os
+
+folder = "output_folder"  # thay bằng path tới folder của bạn
+
+for filename in os.listdir(folder):
+    if "_cropped" in filename:
+        old_path = os.path.join(folder, filename)
+        new_filename = filename.replace("_cropped", "")
+        new_path = os.path.join(folder, new_filename)
+        os.rename(old_path, new_path)
+
+print("✅ Đã xoá '_cropped' khỏi tên file.")

json2txt.py

@@ -0,0 +1,31 @@
+import json 
+import cv2 
+import os 
+
+page70_folder = "/home/tuvu/Downloads/9_11_2025"
+save_folder = "vis_img"
+os.makedirs(save_folder, exist_ok=True)
+for name in os.listdir(page70_folder):
+    if name.endswith("json"):
+        json_name = os.path.join(page70_folder, name)
+        with open(json_name, "r") as f:
+            data = json.load(f)
+
+        items = data.get("items", [])
+        img_name = name.split('.')[0] + ".png"
+        print(img_name)
+        image = cv2.imread(os.path.join(page70_folder,img_name))
+        print(image.shape)
+        # Filter items where type == "label"
+        tables = [item for item in items if item.get("type") == "table"]
+        for table in tables:
+            x, y = 2 * int(table["x"]),2* int(table["y"])
+            w, h =2* table["width"], 2 * table["height"]
+
+            top_left = (x, y)
+            bottom_right = (x + w, y + h)
+            print(top_left, bottom_right)
+            cv2.rectangle(image, top_left, bottom_right, (0, 255, 0), 2)  # green box
+
+        # Save or show
+        cv2.imwrite(os.path.join(save_folder, img_name), image)

json2xml.py

@@ -0,0 +1,243 @@
+import json
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+
+def get_visible_cell_coords(table_properties, table_x, table_y):
+    """Calculate coordinates for visible cells based on table properties"""
+    rows = table_properties.get("rows", 0)
+    columns = table_properties.get("columns", 0)
+    column_widths = table_properties.get("columnWidths", {})
+    row_heights = table_properties.get("rowHeights", {})
+    merged_cells = table_properties.get("mergedCells", {})
+    hidden_cells = table_properties.get("hiddenCells", {})
+
+    DEFAULT_WIDTH = 100
+    DEFAULT_HEIGHT = 30
+
+    def get_col_width(col):
+        return column_widths.get(str(col), DEFAULT_WIDTH)
+
+    def get_row_height(row):
+        return row_heights.get(str(row), DEFAULT_HEIGHT)
+
+    # Convert merge cell coordinates to set of all spanned cells (excluding top-left)
+    merged_spanned_cells = set()
+    for key, merge_info in merged_cells.items():
+        base_row, base_col = map(int, key.split('-'))
+        rowspan = merge_info.get('rowspan', 1)
+        colspan = merge_info.get('colspan', 1)
+        for r in range(base_row, base_row + rowspan):
+            for c in range(base_col, base_col + colspan):
+                if (r, c) != (base_row, base_col):
+                    merged_spanned_cells.add((r, c))
+
+    result = {}
+
+    for row in range(rows):
+        for col in range(columns):
+            coord_key = f"{row}-{col}"
+            if hidden_cells.get(coord_key):
+                continue  # Skip hidden cells
+            if (row, col) in merged_spanned_cells:
+                continue  # Skip cells covered by merged cells
+
+            # Calculate x by summing widths of all previous columns
+            x = sum(get_col_width(c) for c in range(col))
+            y = sum(get_row_height(r) for r in range(row))
+
+            # Check if it's a merged cell origin
+            if coord_key in merged_cells:
+                colspan = merged_cells[coord_key].get("colspan", 1)
+                rowspan = merged_cells[coord_key].get("rowspan", 1)
+            else:
+                colspan = 1
+                rowspan = 1
+
+            width = sum(get_col_width(c) for c in range(col, col + colspan))
+            height = sum(get_row_height(r) for r in range(row, row + rowspan))
+
+            result[(row, col)] = {
+                "x": 2 * (x + table_x),
+                "y": 2 * (y + table_y),
+                "width": 2 * width,
+                "height": 2 * height
+            }
+
+    return result
+
+def get_cell_borders(cell_data, table_properties):
+    """Extract border information for a cell"""
+    # Get global table border settings
+    cell_borders = table_properties.get("cellBorders", {})
+    has_global_borders = cell_borders.get("all", False)
+    
+    # Start with default border values
+    borders = {
+        "top": 1 if has_global_borders else 0,
+        "bottom": 1 if has_global_borders else 0,
+        "left": 1 if has_global_borders else 0,
+        "right": 1 if has_global_borders else 0
+    }
+    
+    # Check if cell has custom border styling
+    if cell_data and "cellStyle" in cell_data:
+        cell_style = cell_data["cellStyle"]
+        
+        # Check each border side if explicitly defined
+        border_mappings = {
+            "borderTopWidth": "top",
+            "borderBottomWidth": "bottom", 
+            "borderLeftWidth": "left",
+            "borderRightWidth": "right"
+        }
+        
+        style_mappings = {
+            "borderTopStyle": "top",
+            "borderBottomStyle": "bottom",
+            "borderLeftStyle": "left", 
+            "borderRightStyle": "right"
+        }
+        
+        # If any border width is defined, this cell has custom borders
+        has_custom_borders = any(key in cell_style for key in border_mappings.keys())
+        
+        if has_custom_borders:
+            # Apply custom border settings
+            for width_key, border_side in border_mappings.items():
+                if width_key in cell_style:
+                    # Check width
+                    width = cell_style[width_key]
+                    has_border = width > 0
+                    
+                    # Check style if defined
+                    style_key = width_key.replace("Width", "Style")
+                    if style_key in cell_style:
+                        style = cell_style[style_key]
+                        if style == "none":
+                            has_border = False
+                    
+                    borders[border_side] = 1 if has_border else 0
+    
+    return borders["top"], borders["bottom"], borders["left"], borders["right"]
+
+def convert_json_to_xml(json_data, filename="table.jpg"):
+    """Convert JSON table data to XML format"""
+    
+    # Parse JSON if it's a string
+    if isinstance(json_data, str):
+        data = json.loads(json_data)
+    else:
+        data = json_data
+    
+    # Handle list of tables (take first one)
+    if isinstance(data, list):
+        table_data = data[0]
+    else:
+        table_data = data
+    
+    # Extract table information
+    properties = table_data.get("properties", {})
+    table_x = table_data.get("x", 0)
+    table_y = table_data.get("y", 0) 
+    table_width = table_data.get("width", properties.get("width", 0))
+    table_height = table_data.get("height", properties.get("height", 0))
+    
+    # Create XML root structure
+    root = ET.Element("document", filename=filename)
+    table_elem = ET.SubElement(root, "table")
+    
+    # Add table coordinates (rectangle points)
+    x1, y1 = int(table_x), int(table_y)
+    x2, y2 = int(table_x + table_width), int(table_y + table_height)
+    table_coords = f"{x1},{y1} {x2},{y1} {x2},{y2} {x1},{y2}"
+    ET.SubElement(table_elem, "Coords", points=table_coords)
+    
+    # Get cell coordinates and data
+    cell_coords = get_visible_cell_coords(properties, table_x, table_y)
+    cell_data = properties.get("cellData", {})
+    merged_cells = properties.get("mergedCells", {})
+    
+    # Create XML elements for each visible cell
+    for (row, col), coords in cell_coords.items():
+        cell_key = f"{row}-{col}"
+        current_cell_data = cell_data.get(cell_key, {})
+        
+        # Calculate end positions for merged cells
+        if cell_key in merged_cells:
+            merge_info = merged_cells[cell_key]
+            end_row = row + merge_info.get("rowspan", 1) - 1
+            end_col = col + merge_info.get("colspan", 1) - 1
+        else:
+            end_row = row
+            end_col = col
+        
+        # Create cell XML element
+        cell_elem = ET.SubElement(table_elem, "cell")
+        cell_elem.set("start-row", str(row))
+        cell_elem.set("end-row", str(end_row))
+        cell_elem.set("start-col", str(col))
+        cell_elem.set("end-col", str(end_col))
+        
+        # Add cell coordinates
+        x1 = int(coords["x"])
+        y1 = int(coords["y"])
+        x2 = int(coords["x"] + coords["width"])
+        y2 = int(coords["y"] + coords["height"])
+        cell_coord_str = f"{x1},{y1} {x2},{y1} {x2},{y2} {x1},{y2}"
+        ET.SubElement(cell_elem, "Coords", points=cell_coord_str)
+        
+        # Add border information
+        top, bottom, left, right = get_cell_borders(current_cell_data, properties)
+        ET.SubElement(cell_elem, "Lines", 
+                     top=str(top), 
+                     bottom=str(bottom), 
+                     left=str(left), 
+                     right=str(right))
+    
+    return root
+
+def save_xml_to_file(xml_root, output_path):
+    """Save XML to file with pretty formatting"""
+    # Convert to pretty-formatted string
+    rough_string = ET.tostring(xml_root, encoding='unicode')
+    reparsed = minidom.parseString(rough_string)
+    pretty_xml = reparsed.toprettyxml(indent="    ")
+    
+    # Clean up extra whitespace lines
+    lines = [line for line in pretty_xml.split('\n') if line.strip()]
+    pretty_xml = '\n'.join(lines)
+    
+    # Write to file
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(pretty_xml)
+
+def convert_json_file_to_xml(json_file_path, xml_file_path, filename="table.jpg"):
+    """Convert JSON file to XML file"""
+    try:
+        # Read JSON file
+        with open(json_file_path, 'r', encoding='utf-8') as f:
+            json_data = json.load(f)
+        json_data = json_data.get('items')
+        # Convert to XML
+        xml_root = convert_json_to_xml(json_data, filename)
+        
+        # Save XML file
+        save_xml_to_file(xml_root, xml_file_path)
+        
+        print(f"✅ Successfully converted {json_file_path} to {xml_file_path}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error converting file: {e}")
+        return False
+
+# Example usage and testing
+if __name__ == "__main__":
+
+    import os
+    folder = "/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/test_json"
+    for name in os.listdir(folder):
+        if name.endswith('json'):
+            json_name = os.path.join(folder, name)
+            xml_name = name.replace('.json' , '.xml')
+            convert_json_file_to_xml(json_name,xml_name, xml_name.replace('.xml','.png'))

rename.py

@@ -0,0 +1,10 @@
+import os
+folder_json = "/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/40_page_70_110925"
+
+for name in os.listdir(folder_json):
+    if name.endswith('.png'):
+        new_name = name.split('-')[0] + '.png'
+        os.rename(os.path.join(folder_json, name), os.path.join(folder_json, new_name))
+    elif name.endswith('.json'):
+        new_name = name.split('-')[1] + '.json'
+        os.rename(os.path.join(folder_json, name), os.path.join(folder_json, new_name))

resize.py

@@ -0,0 +1,26 @@
+from PIL import Image
+import os
+
+# Input and output folders
+input_folder = "/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/page_39"
+output_folder = "/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/train_table_1209"
+
+os.makedirs(output_folder, exist_ok=True)
+
+# Loop through all files in the folder
+for filename in os.listdir(input_folder):
+    file_path = os.path.join(input_folder, filename)
+
+    # Skip non-image files
+    if not filename.lower().endswith((".png", ".jpg", ".jpeg", ".bmp", ".gif")):
+        continue
+
+    # Open and resize
+    with Image.open(file_path) as img:
+        w, h = img.size
+        resized = img.resize((w // 2, h // 2), Image.LANCZOS)
+
+        # Save to output folder
+        resized.save(os.path.join(output_folder, filename))
+
+print("✅ Done! All images resized to half.")

vis_json_cell.py

@@ -0,0 +1,103 @@
+import json 
+import cv2
+import os
+
+def get_visible_cell_coords(table_properties, table_x, table_y):
+    rows = table_properties.get("rows", 0)
+    columns = table_properties.get("columns", 0)
+    column_widths = table_properties.get("columnWidths", {})
+    row_heights = table_properties.get("rowHeights", {})
+    merged_cells = table_properties.get("mergedCells", {})
+    hidden_cells = table_properties.get("hiddenCells", {})
+
+    DEFAULT_WIDTH = 100
+    DEFAULT_HEIGHT = 30
+
+    def get_col_width(col):
+        return column_widths.get(str(col), DEFAULT_WIDTH)
+
+    def get_row_height(row):
+        return row_heights.get(str(row), DEFAULT_HEIGHT)
+
+    # Convert merge cell coordinates to set of all spanned cells (excluding top-left)
+    merged_spanned_cells = set()
+    for key, merge_info in merged_cells.items():
+        base_row, base_col = map(int, key.split('-'))
+        rowspan = merge_info.get('rowspan', 1)
+        colspan = merge_info.get('colspan', 1)
+        for r in range(base_row, base_row + rowspan):
+            for c in range(base_col, base_col + colspan):
+                if (r, c) != (base_row, base_col):
+                    merged_spanned_cells.add((r, c))
+
+    result = {}
+
+    for row in range(rows):
+        for col in range(columns):
+            coord_key = f"{row}-{col}"
+            if hidden_cells.get(coord_key):
+                continue  # Skip hidden cells
+            if (row, col) in merged_spanned_cells:
+                continue  # Skip cells covered by merged cells
+
+            # Calculate x by summing widths of all previous columns
+            x = sum(get_col_width(c) for c in range(col))
+            y = sum(get_row_height(r) for r in range(row))
+
+            # Check if it's a merged cell origin
+            if coord_key in merged_cells:
+                colspan = merged_cells[coord_key].get("colspan", 1)
+                rowspan = merged_cells[coord_key].get("rowspan", 1)
+            else:
+                colspan = 1
+                rowspan = 1
+
+            width = sum(get_col_width(c) for c in range(col, col + colspan))
+            height = sum(get_row_height(r) for r in range(row, row + rowspan))
+
+            result[(row, col)] = {
+                "x":  int(x + table_x),
+                "y":  int(y + table_y),
+                "width":  int(width),
+                "height":  int(height)
+            }
+
+    return result
+
+folder_path = "/Users/tuvn18/Desktop/tuvn18/dev/KIAI/dev/trace/train_table_1209"
+save_folder = "cell_vis"
+os.makedirs(save_folder, exist_ok=True)
+for name in os.listdir(folder_path):
+    if name.endswith("json"):
+        json_file = os.path.join(folder_path, name)
+        with open(json_file, "r") as f:
+            data = json.load(f)
+            
+        img_name = name.split('.')[0] + ".png"
+        print(img_name)
+        image = cv2.imread(os.path.join(folder_path,img_name))
+        items = data.get('items')
+        for index in range(len(items)):
+
+            table = items[index]
+            if table.get('type') != 'table':
+                continue
+            table_x = table.get('x')
+            table_y = table.get('y')
+
+            table_prob = table.get('properties')
+            boxes = get_visible_cell_coords(table_prob, table_x, table_y)
+
+            for key, box in boxes.items():
+                row, col = key
+                x, y, w, h = int(box["x"]), int(box["y"]), int(box["width"]), int(box["height"])
+
+                top_left = (x, y)
+                bottom_right = (x + w, y + h)
+
+                cv2.rectangle(image, top_left, bottom_right, (0, 255, 0), 2)
+                # cv2.putText(image, f"{row},{col}", (x + 5, y + 20),
+                #             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+
+            # Save or show
+            cv2.imwrite(os.path.join(save_folder, img_name), image)