Upload render.py

render.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""
+Table Canvas Renderer
+Renders all tables from JSON data onto a single white canvas with specified dimensions
+"""
+
+import json
+import os
+from typing import Dict, List, Tuple, Any, Optional
+from PIL import Image, ImageDraw, ImageFont
+import argparse
+
+class TableCanvasRenderer:
+    """Renders multiple tables from JSON data onto a canvas"""
+    
+    def __init__(self):
+        """Initialize the table canvas renderer"""
+        self.DEFAULT_FONT_SIZE = 11
+        self.CELL_PADDING = 4
+        self.DEFAULT_BORDER_WIDTH = 1
+        self.DEFAULT_BORDER_COLOR = "#000000"
+        self.DEFAULT_BACKGROUND_COLOR = "#ffffff"
+    
+    def get_font(self, font_family: str = None, font_size: int = None, font_weight: str = "normal"):
+        """Get PIL font object with fallbacks"""
+        if font_size is None:
+            font_size = self.DEFAULT_FONT_SIZE
+            
+        # Try to load the specified font
+        font_paths = []
+        
+        if font_family:
+            if font_family.lower() == "ms gothic":
+                # Common paths for MS Gothic on different systems
+                font_paths.extend([
+                    "C:/Windows/Fonts/msgothic.ttc",
+                    "/System/Library/Fonts/Hiragino Sans GB.ttc",
+                    "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf"
+                ])
+            else:
+                font_paths.append(font_family)
+        
+        # Fallback fonts
+        font_paths.extend([
+            "arial.ttf", "Arial.ttf",
+            "/System/Library/Fonts/Arial.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+        ])
+        
+        for font_path in font_paths:
+            try:
+                font = ImageFont.truetype(font_path, font_size)
+                # For bold text, try to find bold variant
+                if font_weight == "bold":
+                    bold_path = font_path.replace("Regular", "Bold").replace(".ttf", "b.ttf")
+                    try:
+                        font = ImageFont.truetype(bold_path, font_size)
+                    except:
+                        pass  # Use regular font if bold not available
+                return font
+            except (OSError, IOError):
+                continue
+        
+        # Ultimate fallback to default PIL font
+        try:
+            return ImageFont.load_default()
+        except:
+            return None
+    
+    def hex_to_rgb(self, hex_color: str) -> Tuple[int, int, int, int]:
+        """Convert hex color to RGBA tuple"""
+        if not hex_color or hex_color == "transparent":
+            return (255, 255, 255, 0)  # Transparent
+        
+        hex_color = hex_color.lstrip('#')
+        if len(hex_color) == 6:
+            return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4)) + (255,)
+        return (255, 255, 255, 255)  # Default white
+    
+    def extract_tables_from_json(self, json_data: Any) -> List[Dict]:
+        """Extract all table items from JSON data"""
+        if isinstance(json_data, list):
+            tables = [item for item in json_data if item.get("type") == "table"]
+        elif isinstance(json_data, dict) and json_data.get("type") == "table":
+            tables = [json_data]
+        else:
+            tables = []
+        return tables
+    
+    def calculate_cell_coordinates(self, table_properties: Dict) -> Dict[Tuple[int, int], Dict]:
+        """Calculate coordinates for all visible cells in the table"""
+        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), 100)
+
+        def get_row_height(row: int) -> int:
+            return row_heights.get(str(row), 30)
+
+        # 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))
+
+                cell_coords[(row, col)] = {
+                    "x": x,
+                    "y": 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"""
+        # 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 draw_table_on_canvas(self, draw: ImageDraw.Draw, table_data: Dict):
+        """Draw a single table on the canvas"""
+        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", 800))
+        table_height = table_data.get("height", properties.get("height", 600))
+        
+        # Calculate cell coordinates
+        cell_coords = self.calculate_cell_coordinates(properties)
+        
+        # Get table styling
+        font_size = properties.get("fontSize", self.DEFAULT_FONT_SIZE)
+        font_family = properties.get("fontFamily", "Arial")
+        table_bg_color = self.hex_to_rgb(properties.get("backgroundColor", self.DEFAULT_BACKGROUND_COLOR))
+        
+        # Draw table background if specified
+        if table_bg_color != (255, 255, 255, 255):  # If not default white
+            draw.rectangle([
+                (table_x, table_y),
+                (table_x + table_width, table_y + table_height)
+            ], fill=table_bg_color)
+        
+        # Get cell data and styling
+        cell_data = properties.get("cellData", {})
+        header_bg_color = self.hex_to_rgb(properties.get("headerBackgroundColor", "#e8f7f0"))
+        
+        # Draw cells
+        for (row, col), coords in cell_coords.items():
+            cell_key = f"{row}-{col}"
+            current_cell_data = cell_data.get(cell_key, {})
+            
+            # Calculate cell position on canvas
+            cell_x = table_x + coords["x"]
+            cell_y = table_y + coords["y"]
+            cell_w = coords["width"]
+            cell_h = coords["height"]
+            
+            # Get cell styling
+            cell_style = current_cell_data.get("cellStyle", {})
+            cell_bg_color = cell_style.get("backgroundColor")
+            
+            # Use header background for header rows if no specific background
+            if row == 0 and not cell_bg_color:
+                cell_bg_color = properties.get("headerBackgroundColor", "#e8f7f0")
+            elif not cell_bg_color:
+                cell_bg_color = properties.get("backgroundColor", self.DEFAULT_BACKGROUND_COLOR)
+            
+            # Draw cell background
+            if cell_bg_color and cell_bg_color != "transparent":
+                bg_color = self.hex_to_rgb(cell_bg_color)
+                draw.rectangle([
+                    (cell_x, cell_y),
+                    (cell_x + cell_w, cell_y + cell_h)
+                ], fill=bg_color)
+            
+            # Draw cell borders
+            top, bottom, left, right = self.determine_cell_borders(current_cell_data, properties)
+            border_color = self.hex_to_rgb(
+                cell_style.get("borderBottomColor", 
+                cell_style.get("borderColor", self.DEFAULT_BORDER_COLOR))
+            )[:3]  # Remove alpha for line drawing
+            
+            border_width = max(1, cell_style.get("borderWidth", self.DEFAULT_BORDER_WIDTH))
+            
+            if top:
+                draw.line([(cell_x, cell_y), (cell_x + cell_w, cell_y)], 
+                         fill=border_color, width=border_width)
+            if bottom:
+                draw.line([(cell_x, cell_y + cell_h), (cell_x + cell_w, cell_y + cell_h)], 
+                         fill=border_color, width=border_width)
+            if left:
+                draw.line([(cell_x, cell_y), (cell_x, cell_y + cell_h)], 
+                         fill=border_color, width=border_width)
+            if right:
+                draw.line([(cell_x + cell_w, cell_y), (cell_x + cell_w, cell_y + cell_h)], 
+                         fill=border_color, width=border_width)
+            
+            # Draw cell text
+            cell_value = current_cell_data.get("value", "")
+            if cell_value:
+                # Get text styling
+                text_color = self.hex_to_rgb(
+                    cell_style.get("color", 
+                    properties.get("color", "#000000"))
+                )[:3]  # Remove alpha
+                
+                font_weight = cell_style.get("fontWeight", "normal")
+                if row == 0:  # Header row
+                    font_weight = properties.get("headerFontWeight", "bold")
+                
+                text_align = cell_style.get("textAlign", "left")
+                cell_font_size = cell_style.get("fontSize", font_size)
+                
+                # Get font
+                font = self.get_font(font_family, cell_font_size, font_weight)
+                
+                # Calculate text position
+                try:
+                    text_bbox = draw.textbbox((0, 0), str(cell_value), font=font)
+                    text_width = text_bbox[2] - text_bbox[0]
+                    text_height = text_bbox[3] - text_bbox[1]
+                except:
+                    # Fallback for older PIL versions
+                    text_width, text_height = draw.textsize(str(cell_value), font=font)
+                
+                # Position based on alignment
+                if text_align == "center":
+                    text_x = cell_x + (cell_w - text_width) // 2
+                elif text_align == "right":
+                    text_x = cell_x + cell_w - text_width - self.CELL_PADDING
+                else:  # left
+                    text_x = cell_x + self.CELL_PADDING
+                
+                text_y = cell_y + (cell_h - text_height) // 2
+                
+                # Draw text
+                draw.text((text_x, text_y), str(cell_value), 
+                         fill=text_color, font=font)
+    
+    def render_tables_to_canvas(self, json_data: Any, canvas_width: int, canvas_height: int) -> Image.Image:
+        """
+        Render all tables from JSON data onto a white canvas
+        
+        Args:
+            json_data: JSON data containing table definitions
+            canvas_width: Width of the canvas
+            canvas_height: Height of the canvas
+            
+        Returns:
+            PIL Image with all tables rendered
+        """
+        # Create white canvas
+        canvas = Image.new('RGBA', (canvas_width, canvas_height), (255, 255, 255, 255))
+        draw = ImageDraw.Draw(canvas)
+        
+        # Extract all tables from JSON
+        tables = self.extract_tables_from_json(json_data)
+        
+        if not tables:
+            print("No tables found in JSON data")
+            return canvas
+        
+        print(f"Found {len(tables)} table(s) to render")
+        
+        # Draw each table on the canvas
+        for i, table_data in enumerate(tables):
+            try:
+                table_id = table_data.get("id", f"table_{i}")
+                print(f"  Drawing table {i+1}/{len(tables)} (id: {table_id})")
+                self.draw_table_on_canvas(draw, table_data)
+            except Exception as e:
+                print(f"  Error drawing table {i+1}: {e}")
+                continue
+        
+        print("Canvas rendering complete")
+        return canvas
+    
+    def render_from_file(self, json_file: str, canvas_width: int, canvas_height: int, output_file: str = None) -> Image.Image:
+        """
+        Render tables from JSON file to canvas
+        
+        Args:
+            json_file: Path to JSON file
+            canvas_width: Width of the canvas
+            canvas_height: Height of the canvas
+            output_file: Optional path to save the rendered canvas
+            
+        Returns:
+            PIL Image with all tables rendered
+        """
+        # Read JSON data
+        try:
+            with open(json_file, 'r', encoding='utf-8') as f:
+                json_data = json.load(f)
+        except Exception as e:
+            print(f"Error reading JSON file: {e}")
+            return None
+        
+        # Render to canvas
+        canvas = self.render_tables_to_canvas(json_data, canvas_width, canvas_height)
+        
+        # Save if output file specified
+        if output_file:
+            try:
+                canvas.save(output_file)
+                print(f"Canvas saved to: {output_file}")
+            except Exception as e:
+                print(f"Error saving canvas: {e}")
+        
+        return canvas
+
+
+def main():
+    """Main function for command line usage"""
+    parser = argparse.ArgumentParser(description="Render tables from JSON data to canvas")
+    parser.add_argument("json_file", help="Path to JSON file containing table data")
+    parser.add_argument("width", type=int, help="Canvas width in pixels")
+    parser.add_argument("height", type=int, help="Canvas height in pixels")
+    parser.add_argument("--output", "-o", help="Output image file path (optional)")
+    
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if args.width <= 0 or args.height <= 0:
+        print("Canvas width and height must be positive integers")
+        return
+    
+    if not os.path.exists(args.json_file):
+        print(f"JSON file not found: {args.json_file}")
+        return
+    
+    # Generate output filename if not provided
+    output_file = args.output
+    if not output_file:
+        base_name = os.path.splitext(os.path.basename(args.json_file))[0]
+        output_file = f"{base_name}_canvas_{args.width}x{args.height}.png"
+    
+    # Create renderer and process file
+    renderer = TableCanvasRenderer()
+    canvas = renderer.render_from_file(args.json_file, args.width, args.height, output_file)
+    
+    if canvas is None:
+        print("Failed to render canvas")
+        return 1
+    
+    print(f"Successfully rendered {args.width}x{args.height} canvas")
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())