Create app.py

app.py

@@ -0,0 +1,410 @@
+# app.py - Hugging Face Spaces Carpet Weaving Map Generator
+import gradio as gr
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image, ImageFilter, ImageEnhance, ImageDraw, ImageFont
+import io
+from sklearn.cluster import KMeans
+import pandas as pd
+import tempfile
+import os
+
+class CarpetWeavingMap:
+    def __init__(self):
+        self.original_image = None
+        self.knot_map = None
+        self.color_palette = None
+        self.grid_pattern = None
+        
+    def extract_color_palette(self, image, n_colors=16):
+        """Extract dominant colors for carpet knots using K-means clustering"""
+        # Convert image to RGB array
+        img_array = np.array(image)
+        pixels = img_array.reshape(-1, 3)
+        
+        # Use K-means to find dominant colors
+        kmeans = KMeans(n_clusters=n_colors, random_state=42, n_init=10)
+        kmeans.fit(pixels)
+        
+        # Get the colors and sort by frequency
+        colors = kmeans.cluster_centers_.astype(int)
+        labels = kmeans.labels_
+        
+        # Count frequency of each color
+        unique_labels, counts = np.unique(labels, return_counts=True)
+        
+        # Sort colors by frequency (most common first)
+        sorted_indices = np.argsort(counts)[::-1]
+        self.color_palette = colors[sorted_indices]
+        
+        return self.color_palette
+    
+    def create_knot_grid(self, image, knots_per_cm=10, carpet_width_cm=100, carpet_height_cm=150):
+        """Create a grid pattern showing individual knot colors"""
+        # Calculate grid dimensions
+        grid_width = carpet_width_cm * knots_per_cm
+        grid_height = carpet_height_cm * knots_per_cm
+        
+        # Resize image to match grid dimensions
+        resized_image = image.resize((grid_width, grid_height), Image.Resampling.LANCZOS)
+        img_array = np.array(resized_image)
+        
+        # Extract color palette
+        self.extract_color_palette(resized_image)
+        
+        # Create knot map by mapping each pixel to nearest palette color
+        self.knot_map = np.zeros((grid_height, grid_width, 3), dtype=np.uint8)
+        
+        for y in range(grid_height):
+            for x in range(grid_width):
+                pixel = img_array[y, x]
+                # Find closest color in palette
+                distances = np.sqrt(np.sum((self.color_palette - pixel)**2, axis=1))
+                closest_color_idx = np.argmin(distances)
+                self.knot_map[y, x] = self.color_palette[closest_color_idx]
+        
+        self.knots_per_cm = knots_per_cm
+        self.carpet_width_cm = carpet_width_cm
+        self.carpet_height_cm = carpet_height_cm
+        
+        return self.knot_map
+    
+    def draw_grid_overlay(self, knot_map, grid_spacing=10):
+        """Draw grid lines over the knot map"""
+        grid_image = Image.fromarray(knot_map)
+        draw = ImageDraw.Draw(grid_image)
+        
+        height, width = knot_map.shape[:2]
+        
+        # Draw vertical lines (every grid_spacing knots)
+        for x in range(0, width, grid_spacing):
+            draw.line([(x, 0), (x, height)], fill='black', width=1)
+        
+        # Draw horizontal lines (every grid_spacing knots)
+        for y in range(0, height, grid_spacing):
+            draw.line([(0, y), (width, y)], fill='black', width=1)
+        
+        return np.array(grid_image)
+    
+    def create_technical_specifications(self):
+        """Create technical specifications dictionary"""
+        specs = {
+            'Carpet Dimensions': f"{self.carpet_width_cm} x {self.carpet_height_cm} cm",
+            'Knot Density': f"{self.knots_per_cm} knots per cm",
+            'Total Knots Width': f"{self.carpet_width_cm * self.knots_per_cm} knots",
+            'Total Knots Height': f"{self.carpet_height_cm * self.knots_per_cm} knots",
+            'Total Knots': f"{self.carpet_width_cm * self.carpet_height_cm * self.knots_per_cm**2:,} knots",
+            'Color Palette Size': f"{len(self.color_palette)} colors",
+            'Grid Sections (10x10)': f"{(self.carpet_width_cm * self.knots_per_cm)//10} x {(self.carpet_height_cm * self.knots_per_cm)//10}"
+        }
+        return specs
+    
+    def create_visualization(self, show_grid=True, grid_spacing=10):
+        """Create the complete carpet weaving map visualization"""
+        if self.knot_map is None:
+            return None, None, None
+        
+        # Create figure with subplots
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(20, 15))
+        
+        # Main knot map
+        if show_grid:
+            display_map = self.draw_grid_overlay(self.knot_map, grid_spacing)
+        else:
+            display_map = self.knot_map
+            
+        ax1.imshow(display_map)
+        ax1.set_title(f'Carpet Weaving Map ({self.knots_per_cm} knots/cm)', fontsize=16, fontweight='bold')
+        ax1.set_xlabel('Knots (Width)')
+        ax1.set_ylabel('Knots (Height)')
+        
+        # Add scale markings
+        width_knots = self.carpet_width_cm * self.knots_per_cm
+        height_knots = self.carpet_height_cm * self.knots_per_cm
+        
+        # X-axis ticks every 10 cm
+        x_ticks = np.arange(0, width_knots + 1, 10 * self.knots_per_cm)
+        x_labels = [f"{int(x/(self.knots_per_cm))}cm" for x in x_ticks]
+        ax1.set_xticks(x_ticks)
+        ax1.set_xticklabels(x_labels)
+        
+        # Y-axis ticks every 10 cm
+        y_ticks = np.arange(0, height_knots + 1, 10 * self.knots_per_cm)
+        y_labels = [f"{int(y/(self.knots_per_cm))}cm" for y in y_ticks]
+        ax1.set_yticks(y_ticks)
+        ax1.set_yticklabels(y_labels)
+        
+        # Original image
+        ax2.imshow(self.original_image)
+        ax2.set_title('Original Image', fontsize=14, fontweight='bold')
+        ax2.axis('off')
+        
+        # Color palette
+        self.display_color_palette_in_subplot(ax3)
+        
+        # Technical specifications
+        self.display_specifications_in_subplot(ax4)
+        
+        plt.tight_layout()
+        
+        # Save the figure
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png', dir=tempfile.gettempdir())
+        plt.savefig(temp_file.name, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return temp_file.name
+    
+    def display_color_palette_in_subplot(self, ax):
+        """Display color palette in a subplot"""
+        if self.color_palette is None:
+            return
+            
+        n_colors = len(self.color_palette)
+        cols = 4
+        rows = (n_colors + cols - 1) // cols
+        
+        for i, color in enumerate(self.color_palette):
+            row = i // cols
+            col = i % cols
+            
+            rect = plt.Rectangle((col, rows - row - 1), 0.8, 0.8, 
+                               facecolor=color/255.0, edgecolor='black', linewidth=1)
+            ax.add_patch(rect)
+            
+            # Add color number
+            ax.text(col + 0.4, rows - row - 0.5, f"C{i+1:02d}", 
+                   ha='center', va='center', fontsize=10, fontweight='bold')
+        
+        ax.set_xlim(0, cols)
+        ax.set_ylim(0, rows)
+        ax.set_aspect('equal')
+        ax.axis('off')
+        ax.set_title('Color Palette', fontsize=12, fontweight='bold')
+    
+    def display_specifications_in_subplot(self, ax):
+        """Display technical specifications in a subplot"""
+        specs = self.create_technical_specifications()
+        
+        ax.axis('off')
+        ax.set_title('Technical Specifications', fontsize=12, fontweight='bold')
+        
+        y_pos = 0.9
+        for key, value in specs.items():
+            ax.text(0.1, y_pos, f"{key}:", fontsize=10, fontweight='bold')
+            ax.text(0.6, y_pos, value, fontsize=10)
+            y_pos -= 0.12
+        
+        ax.set_xlim(0, 1)
+        ax.set_ylim(0, 1)
+    
+    def export_pattern_files(self):
+        """Export pattern data as downloadable files"""
+        if self.knot_map is None:
+            return None, None
+        
+        # Create color mapping
+        color_map = {}
+        for i, color in enumerate(self.color_palette):
+            color_map[f"C{i+1:02d}"] = f"RGB({color[0]},{color[1]},{color[2]})"
+        
+        # Create pattern grid with color codes
+        height, width = self.knot_map.shape[:2]
+        pattern_grid = np.zeros((height, width), dtype='U4')
+        
+        for y in range(height):
+            for x in range(width):
+                pixel = self.knot_map[y, x]
+                # Find matching color in palette
+                for i, color in enumerate(self.color_palette):
+                    if np.array_equal(pixel, color):
+                        pattern_grid[y, x] = f"C{i+1:02d}"
+                        break
+        
+        # Save pattern grid as CSV
+        csv_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', mode='w', dir=tempfile.gettempdir())
+        np.savetxt(csv_file.name, pattern_grid, delimiter=',', fmt='%s')
+        csv_file.close()
+        
+        # Save color mapping as text file
+        txt_file = tempfile.NamedTemporaryFile(delete=False, suffix='.txt', mode='w', dir=tempfile.gettempdir())
+        txt_file.write("Carpet Pattern Color Mapping\n")
+        txt_file.write("=" * 30 + "\n\n")
+        for code, rgb in color_map.items():
+            txt_file.write(f"{code}: {rgb}\n")
+        txt_file.write(f"\nSpecifications:\n")
+        specs = self.create_technical_specifications()
+        for key, value in specs.items():
+            txt_file.write(f"{key}: {value}\n")
+        txt_file.close()
+        
+        return csv_file.name, txt_file.name
+
+def process_image(image, knots_per_cm, carpet_width_cm, carpet_height_cm, n_colors, show_grid):
+    """Main processing function for Gradio interface"""
+    if image is None:
+        return None, None, None, "Please upload an image first."
+    
+    try:
+        # Create mapper instance
+        mapper = CarpetWeavingMap()
+        mapper.original_image = Image.fromarray(image).convert('RGB')
+        
+        # Create knot grid
+        mapper.create_knot_grid(
+            mapper.original_image, 
+            knots_per_cm=knots_per_cm,
+            carpet_width_cm=carpet_width_cm, 
+            carpet_height_cm=carpet_height_cm
+        )
+        
+        # Extract color palette
+        mapper.extract_color_palette(mapper.original_image, n_colors=n_colors)
+        
+        # Create visualization
+        visualization_path = mapper.create_visualization(show_grid=show_grid)
+        
+        # Export pattern files
+        csv_path, txt_path = mapper.export_pattern_files()
+        
+        # Create specifications text
+        specs = mapper.create_technical_specifications()
+        specs_text = "CARPET WEAVING SPECIFICATIONS:\n" + "="*40 + "\n"
+        for key, value in specs.items():
+            specs_text += f"{key}: {value}\n"
+        
+        return visualization_path, csv_path, txt_path, specs_text
+        
+    except Exception as e:
+        return None, None, None, f"Error processing image: {str(e)}"
+
+# Gradio Interface
+def create_gradio_interface():
+    """Create the Gradio interface"""
+    
+    title = "🧶 Carpet Weaving Map Generator"
+    description = """
+    Convert any image into a technical carpet weaving pattern with precise knot mapping and color specifications.
+    
+    **Features:**
+    - Generate grid-based knot patterns
+    - Customizable knot density (4-20 knots/cm)
+    - Color palette extraction and mapping
+    - Exportable CSV pattern files
+    - Technical specifications for weavers
+    
+    **Instructions:**
+    1. Upload your image
+    2. Adjust carpet dimensions and knot density
+    3. Set number of colors for the palette
+    4. Download the pattern files for weaving
+    """
+    
+    with gr.Blocks(title=title, theme=gr.themes.Soft()) as interface:
+        gr.Markdown(f"# {title}")
+        gr.Markdown(description)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input controls
+                image_input = gr.Image(
+                    label="Upload Image",
+                    type="numpy"
+                )
+                
+                with gr.Row():
+                    knots_per_cm = gr.Slider(
+                        minimum=4, maximum=20, value=10, step=1,
+                        label="Knots per CM (density)"
+                    )
+                    n_colors = gr.Slider(
+                        minimum=8, maximum=32, value=16, step=1,
+                        label="Number of Colors"
+                    )
+                
+                with gr.Row():
+                    carpet_width = gr.Number(
+                        value=80, label="Carpet Width (cm)", precision=0
+                    )
+                    carpet_height = gr.Number(
+                        value=120, label="Carpet Height (cm)", precision=0
+                    )
+                
+                show_grid = gr.Checkbox(
+                    value=True, label="Show Grid Lines"
+                )
+                
+                process_btn = gr.Button("Generate Carpet Pattern", variant="primary")
+            
+            with gr.Column(scale=2):
+                # Output displays
+                output_image = gr.Image(
+                    label="Carpet Weaving Map",
+                    type="filepath"
+                )
+                
+                specifications = gr.Textbox(
+                    label="Technical Specifications",
+                    lines=10,
+                    max_lines=15
+                )
+        
+        with gr.Row():
+            # Download files
+            csv_download = gr.File(
+                label="Download Pattern Grid (CSV)",
+                visible=True
+            )
+            txt_download = gr.File(
+                label="Download Color Mapping (TXT)",
+                visible=True
+            )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["examples/example1.jpg", 10, 80, 120, 16, True],
+                ["examples/example2.jpg", 15, 60, 90, 20, True],
+                ["examples/example3.jpg", 6, 100, 150, 12, False],
+            ],
+            inputs=[image_input, knots_per_cm, carpet_width, carpet_height, n_colors, show_grid],
+            label="Example Settings"
+        )
+        
+        # Processing function
+        process_btn.click(
+            fn=process_image,
+            inputs=[image_input, knots_per_cm, carpet_width, carpet_height, n_colors, show_grid],
+            outputs=[output_image, csv_download, txt_download, specifications]
+        )
+        
+        # Footer information
+        gr.Markdown("""
+        ### Knot Density Guide:
+        - **Fine Persian Carpets**: 15-20 knots/cm (very detailed)
+        - **Standard Quality**: 8-12 knots/cm (good balance)
+        - **Rustic/Tribal**: 4-6 knots/cm (traditional style)
+        
+        ### File Outputs:
+        - **CSV File**: Grid pattern with color codes for each knot position
+        - **TXT File**: Color mapping with RGB values and specifications
+        - **PNG Image**: Visual weaving map with grid overlay
+        """)
+    
+    return interface
+
+# Create and launch the interface
+if __name__ == "__main__":
+    interface = create_gradio_interface()
+    interface.launch()
+
+# Requirements for requirements.txt:
+"""
+gradio>=3.40.0
+opencv-python>=4.8.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+Pillow>=10.0.0
+scikit-learn>=1.3.0
+pandas>=2.0.0
+"""