Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,564 @@
-import altair as alt
+import streamlit as st
+import cv2
 import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
 import pandas as pd
-import streamlit as st
+from cryptography.fernet import Fernet
+import io
+import base64
+from PIL import Image
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import plotly.express as px
+
+# Page configuration
+st.set_page_config(
+    page_title="Kolam Design Analyzer",
+    page_icon="🎨",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for professional styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #FF6B35 0%, #F7931E 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        color: white;
+        text-align: center;
+    }
+    
+    .metric-card {
+        background: white;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #FF6B35;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        margin: 0.5rem 0;
+    }
+    
+    .analysis-section {
+        background: #f8f9fa;
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    
+    .upload-section {
+        border: 2px dashed #FF6B35;
+        padding: 2rem;
+        border-radius: 10px;
+        text-align: center;
+        margin: 1rem 0;
+        background: #fff9f7;
+    }
+    
+    .stButton > button {
+        background: linear-gradient(90deg, #FF6B35 0%, #F7931E 100%);
+        color: white;
+        border: none;
+        border-radius: 5px;
+        padding: 0.5rem 2rem;
+        font-weight: bold;
+        transition: all 0.3s;
+    }
+    
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Title and header
+st.markdown("""
+<div class="main-header">
+    <h1>🎨 Kolam Design Analyzer</h1>
+    <h3>Smart India Hackathon 2024 - AI-Powered Traditional Art Analysis</h3>
+    <p>Discover the mathematical principles and geometric patterns behind traditional Kolam designs</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Sidebar
+with st.sidebar:
+    st.markdown("### 🔧 Analysis Parameters")
+    
+    image_size = st.slider("Image Processing Size", 128, 512, 256, step=64)
+    threshold_value = st.slider("Binary Threshold", 50, 200, 127)
+    canny_low = st.slider("Canny Low Threshold", 10, 100, 30)
+    canny_high = st.slider("Canny High Threshold", 50, 200, 100)
+    max_corners = st.slider("Maximum Corners", 50, 200, 100)
+    min_line_length = st.slider("Minimum Line Length", 3, 20, 5)
+    
+    st.markdown("---")
+    st.markdown("### 📊 About This Tool")
+    st.info("This application uses computer vision and graph theory to analyze traditional Kolam designs, extracting geometric patterns and design principles.")
+
+class KolamAnalyzer:
+    def __init__(self):
+        self.cipher = None
+        self.encryption_key = None
+        
+    def generate_encryption_key(self):
+        """Generate encryption key for graph data"""
+        self.encryption_key = Fernet.generate_key()
+        self.cipher = Fernet(self.encryption_key)
+        return self.encryption_key.decode()
+        
+    def preprocess_image(self, image, size, threshold_val, canny_low, canny_high):
+        """Preprocess uploaded image"""
+        # Convert PIL image to OpenCV format
+        img_array = np.array(image)
+        if len(img_array.shape) == 3:
+            img_gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+        else:
+            img_gray = img_array
+            
+        # Resize image
+        img_resized = cv2.resize(img_gray, (size, size))
+        
+        # Apply binary threshold
+        _, thresh = cv2.threshold(img_resized, threshold_val, 255, cv2.THRESH_BINARY_INV)
+        
+        # Edge detection
+        edges = cv2.Canny(thresh, canny_low, canny_high)
+        
+        return img_resized, thresh, edges
+    
+    def detect_nodes(self, edges, max_corners):
+        """Detect corner points as graph nodes"""
+        corners = cv2.goodFeaturesToTrack(
+            edges, 
+            maxCorners=max_corners, 
+            qualityLevel=0.01, 
+            minDistance=5
+        )
+        if corners is None:
+            return []
+        return [tuple(pt.ravel()) for pt in corners.astype(int)]
+    
+    def detect_edges(self, edges, nodes, min_line_length):
+        """Detect lines and create graph edges"""
+        lines = cv2.HoughLinesP(
+            edges, 
+            1, 
+            np.pi/180, 
+            threshold=30, 
+            minLineLength=min_line_length, 
+            maxLineGap=10
+        )
+        
+        graph_edges = []
+        if lines is not None:
+            for x1, y1, x2, y2 in lines[:,0]:
+                if len(nodes) > 0:
+                    n1 = min(range(len(nodes)), 
+                           key=lambda i: np.linalg.norm(np.array(nodes[i]) - np.array([x1,y1])))
+                    n2 = min(range(len(nodes)), 
+                           key=lambda i: np.linalg.norm(np.array(nodes[i]) - np.array([x2,y2])))
+                    if n1 != n2 and (n1, n2) not in graph_edges and (n2, n1) not in graph_edges:
+                        graph_edges.append((n1, n2))
+        
+        # Fallback: connect nearby nodes if no lines detected
+        if len(graph_edges) == 0:
+            graph_edges = self.connect_nearby_nodes(nodes, max_distance=30)
+            
+        return graph_edges
+    
+    def connect_nearby_nodes(self, nodes, max_distance=30):
+        """Connect nearby nodes as fallback"""
+        edges = []
+        for i, (x1, y1) in enumerate(nodes):
+            for j, (x2, y2) in enumerate(nodes):
+                if i < j:
+                    distance = np.linalg.norm(np.array([x1, y1]) - np.array([x2, y2]))
+                    if distance <= max_distance:
+                        edges.append((i, j))
+        return edges
+    
+    def build_graph(self, nodes, edges):
+        """Build NetworkX graph from nodes and edges"""
+        G = nx.Graph()
+        for idx, node in enumerate(nodes):
+            G.add_node(idx, pos=node)
+        for n1, n2 in edges:
+            G.add_edge(n1, n2)
+        return G
+    
+    def extract_graph_features(self, G):
+        """Extract mathematical features from the graph"""
+        num_nodes = G.number_of_nodes()
+        num_edges = G.number_of_edges()
+        degrees = [d for _, d in G.degree()]
+        avg_degree = np.mean(degrees) if degrees else 0
+        max_degree = max(degrees) if degrees else 0
+        min_degree = min(degrees) if degrees else 0
+        
+        # Calculate cycles
+        try:
+            num_cycles = sum(1 for c in nx.cycle_basis(G))
+        except:
+            num_cycles = 0
+            
+        # Calculate connectivity
+        is_connected = nx.is_connected(G) if num_nodes > 0 else False
+        num_components = nx.number_connected_components(G)
+        
+        # Calculate centrality measures
+        try:
+            betweenness = nx.betweenness_centrality(G)
+            avg_betweenness = np.mean(list(betweenness.values())) if betweenness else 0
+            
+            closeness = nx.closeness_centrality(G)
+            avg_closeness = np.mean(list(closeness.values())) if closeness else 0
+        except:
+            avg_betweenness = 0
+            avg_closeness = 0
+        
+        return {
+            "num_nodes": num_nodes,
+            "num_edges": num_edges,
+            "avg_degree": round(avg_degree, 2),
+            "max_degree": max_degree,
+            "min_degree": min_degree,
+            "num_cycles": num_cycles,
+            "is_connected": is_connected,
+            "num_components": num_components,
+            "avg_betweenness": round(avg_betweenness, 4),
+            "avg_closeness": round(avg_closeness, 4),
+            "density": round(nx.density(G), 4) if num_nodes > 1 else 0
+        }
+    
+    def encrypt_graph(self, G):
+        """Encrypt graph data for security"""
+        if not self.cipher:
+            self.generate_encryption_key()
+        
+        adj_matrix = nx.to_numpy_array(G)
+        adj_bytes = adj_matrix.tobytes()
+        encrypted = self.cipher.encrypt(adj_bytes)
+        return encrypted
+    
+    def create_interactive_graph(self, G):
+        """Create interactive graph visualization using Plotly"""
+        pos = nx.get_node_attributes(G, 'pos')
+        
+        if not pos:
+            # If no positions, use spring layout
+            pos = nx.spring_layout(G)
+        
+        # Extract edges
+        edge_x = []
+        edge_y = []
+        for edge in G.edges():
+            x0, y0 = pos[edge[0]]
+            x1, y1 = pos[edge[1]]
+            edge_x.extend([x0, x1, None])
+            edge_y.extend([y0, y1, None])
+        
+        # Create edge trace
+        edge_trace = go.Scatter(
+            x=edge_x, y=edge_y,
+            line=dict(width=2, color='#FF6B35'),
+            hoverinfo='none',
+            mode='lines'
+        )
+        
+        # Extract nodes
+        node_x = []
+        node_y = []
+        node_text = []
+        node_degree = []
+        
+        for node in G.nodes():
+            x, y = pos[node]
+            node_x.append(x)
+            node_y.append(y)
+            degree = G.degree(node)
+            node_degree.append(degree)
+            node_text.append(f'Node {node}<br>Degree: {degree}')
+        
+        # Create node trace
+        node_trace = go.Scatter(
+            x=node_x, y=node_y,
+            mode='markers',
+            hoverinfo='text',
+            text=node_text,
+            marker=dict(
+                size=[max(10, d*3) for d in node_degree],
+                color=node_degree,
+                colorscale='Viridis',
+                colorbar=dict(
+                    thickness=15,
+                    len=0.5,
+                    x=1.02,
+                    title="Node Degree"
+                ),
+                line=dict(width=2, color='white')
+            )
+        )
+        
+        # Create figure
+        fig = go.Figure(data=[edge_trace, node_trace],
+                       layout=go.Layout(
+                            title='Interactive Kolam Graph Structure',
+                            titlefont_size=16,
+                            showlegend=False,
+                            hovermode='closest',
+                            margin=dict(b=20,l=5,r=5,t=40),
+                            annotations=[ dict(
+                                text="Node size represents degree centrality",
+                                showarrow=False,
+                                xref="paper", yref="paper",
+                                x=0.005, y=-0.002,
+                                xanchor="left", yanchor="bottom",
+                                font=dict(size=12)
+                            )],
+                            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            plot_bgcolor='white'
+                       ))
+        
+        return fig
+
+# Initialize analyzer
+analyzer = KolamAnalyzer()
+
+# Main content area
+col1, col2 = st.columns([1, 2])
+
+try:
+    import pandas as pd
+    PANDAS_AVAILABLE = True
+except ImportError as e:
+    st.warning("⚠️ Pandas not available due to NumPy compatibility. Using basic data structures.")
+    PANDAS_AVAILABLE = False
+
+try:
+    import plotly.graph_objects as go
+    import plotly.express as px
+    PLOTLY_AVAILABLE = True
+except ImportError as e:
+    st.warning("⚠️ Plotly not available due to NumPy compatibility. Using matplotlib for visualizations.")
+    PLOTLY_AVAILABLE = False
+
+try:
+    from cryptography.fernet import Fernet
+    CRYPTO_AVAILABLE = True
+except ImportError as e:
+    st.warning("⚠️ Cryptography not available. Encryption features disabled.")
+    CRYPTO_AVAILABLE = False
+
+with col1:
+    st.markdown("### 📤 Upload Kolam Image")
+    
+    uploaded_file = st.file_uploader(
+        "Choose a Kolam image...",
+        type=["png", "jpg", "jpeg"],
+        help="Upload a clear image of a Kolam design for analysis"
+    )
+    
+    if uploaded_file:
+        # Display uploaded image
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Uploaded Kolam", use_column_width=True)
+        
+        # Analysis button
+        if st.button("🔍 Analyze Kolam Design", type="primary"):
+            with st.spinner("Analyzing Kolam design..."):
+                # Process image
+                original, thresh, edges = analyzer.preprocess_image(
+                    image, image_size, threshold_value, canny_low, canny_high
+                )
+                
+                # Detect nodes and edges
+                nodes = analyzer.detect_nodes(edges, max_corners)
+                graph_edges = analyzer.detect_edges(edges, nodes, min_line_length)
+                
+                # Build graph
+                G = analyzer.build_graph(nodes, graph_edges)
+                
+                # Extract features
+                features = analyzer.extract_graph_features(G)
+                
+                # Store results in session state
+                st.session_state.analysis_complete = True
+                st.session_state.original_img = original
+                st.session_state.thresh_img = thresh
+                st.session_state.edges_img = edges
+                st.session_state.nodes = nodes
+                st.session_state.graph = G
+                st.session_state.features = features
+                
+                # Generate encryption key
+                encryption_key = analyzer.generate_encryption_key()
+                st.session_state.encryption_key = encryption_key
+                
+                st.success("✅ Analysis completed successfully!")
+
+with col2:
+    st.markdown("### 📊 Analysis Results")
+    
+    if hasattr(st.session_state, 'analysis_complete') and st.session_state.analysis_complete:
+        
+        # Create tabs for different visualizations
+        tab1, tab2, tab3, tab4 = st.tabs(["🖼️ Image Processing", "📈 Graph Analysis", "📊 Features", "🔐 Security"])
+        
+        with tab1:
+            st.markdown("#### Image Processing Pipeline")
+            
+            # Create subplot for processed images
+            fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+            
+            axes[0].imshow(st.session_state.original_img, cmap='gray')
+            axes[0].set_title('Original Grayscale', fontsize=12, fontweight='bold')
+            axes[0].axis('off')
+            
+            axes[1].imshow(st.session_state.thresh_img, cmap='gray')
+            axes[1].set_title('Binary Threshold', fontsize=12, fontweight='bold')
+            axes[1].axis('off')
+            
+            axes[2].imshow(st.session_state.edges_img, cmap='gray')
+            axes[2].set_title('Edge Detection', fontsize=12, fontweight='bold')
+            axes[2].axis('off')
+            
+            plt.tight_layout()
+            st.pyplot(fig)
+            
+            # Show detected nodes
+            st.markdown("#### Detected Corner Points")
+            img_with_nodes = st.session_state.original_img.copy()
+            for x, y in st.session_state.nodes:
+                cv2.circle(img_with_nodes, (int(x), int(y)), 3, (255), -1)
+            
+            fig_nodes, ax_nodes = plt.subplots(1, 1, figsize=(8, 8))
+            ax_nodes.imshow(img_with_nodes, cmap='gray')
+            ax_nodes.set_title(f'Detected Nodes: {len(st.session_state.nodes)}', 
+                              fontsize=14, fontweight='bold')
+            ax_nodes.axis('off')
+            st.pyplot(fig_nodes)
+        
+        with tab2:
+            st.markdown("#### Interactive Graph Visualization")
+            
+            # Create interactive graph
+            if st.session_state.graph.number_of_nodes() > 0:
+                fig_interactive = analyzer.create_interactive_graph(st.session_state.graph)
+                st.plotly_chart(fig_interactive, use_container_width=True)
+            else:
+                st.warning("No graph structure detected in the image.")
+            
+            # Graph statistics
+            col_a, col_b = st.columns(2)
+            with col_a:
+                st.metric("Total Nodes", st.session_state.features['num_nodes'])
+                st.metric("Total Edges", st.session_state.features['num_edges'])
+                st.metric("Graph Density", st.session_state.features['density'])
+            
+            with col_b:
+                st.metric("Average Degree", st.session_state.features['avg_degree'])
+                st.metric("Number of Cycles", st.session_state.features['num_cycles'])
+                st.metric("Connected Components", st.session_state.features['num_components'])
+        
+        with tab3:
+            st.markdown("#### Mathematical Properties")
+            
+            # Create metrics dataframe
+            features_df = pd.DataFrame([
+                {"Property": "Nodes", "Value": st.session_state.features['num_nodes']},
+                {"Property": "Edges", "Value": st.session_state.features['num_edges']},
+                {"Property": "Average Degree", "Value": st.session_state.features['avg_degree']},
+                {"Property": "Maximum Degree", "Value": st.session_state.features['max_degree']},
+                {"Property": "Minimum Degree", "Value": st.session_state.features['min_degree']},
+                {"Property": "Cycles", "Value": st.session_state.features['num_cycles']},
+                {"Property": "Graph Density", "Value": st.session_state.features['density']},
+                {"Property": "Average Betweenness", "Value": st.session_state.features['avg_betweenness']},
+                {"Property": "Average Closeness", "Value": st.session_state.features['avg_closeness']},
+                {"Property": "Connected", "Value": "Yes" if st.session_state.features['is_connected'] else "No"},
+                {"Property": "Components", "Value": st.session_state.features['num_components']}
+            ])
+            
+            st.dataframe(features_df, use_container_width=True)
+            
+            # Visualize degree distribution
+            if st.session_state.graph.number_of_nodes() > 0:
+                degrees = [d for _, d in st.session_state.graph.degree()]
+                fig_hist = px.histogram(
+                    x=degrees, 
+                    title="Degree Distribution",
+                    labels={'x': 'Node Degree', 'y': 'Frequency'},
+                    color_discrete_sequence=['#FF6B35']
+                )
+                fig_hist.update_layout(
+                    plot_bgcolor='white',
+                    paper_bgcolor='white'
+                )
+                st.plotly_chart(fig_hist, use_container_width=True)
+        
+        with tab4:
+            st.markdown("#### Security & Data Protection")
+            
+            if CRYPTO_AVAILABLE:
+                # Encrypt graph
+                encrypted_data = analyzer.encrypt_graph(st.session_state.graph)
+                
+                if encrypted_data:
+                    col_x, col_y = st.columns(2)
+                    with col_x:
+                        st.success(f"🔐 Graph data encrypted successfully!")
+                        st.info(f"Encrypted data size: {len(encrypted_data)} bytes")
+                        
+                    with col_y:
+                        if hasattr(st.session_state, 'encryption_key'):
+                            st.code(f"Encryption Key:\n{st.session_state.encryption_key}", language="text")
+                else:
+                    st.error("Failed to encrypt graph data")
+            else:
+                st.warning("🔒 Encryption not available due to package compatibility issues.")
+                st.info("Graph data will be stored in plain text format.")
+                
+            # Download options
+            st.markdown("#### 📥 Download Results")
+            
+            col_dl1, col_dl2 = st.columns(2)
+            with col_dl1:
+                # Prepare features for download
+                if PANDAS_AVAILABLE:
+                    features_json = pd.DataFrame([st.session_state.features]).to_json(orient='records')
+                else:
+                    import json
+                    features_json = json.dumps([st.session_state.features], indent=2)
+                    
+                st.download_button(
+                    "📊 Download Features (JSON)",
+                    data=features_json,
+                    file_name="kolam_features.json",
+                    mime="application/json"
+                )
+            
+            with col_dl2:
+                # Prepare adjacency matrix
+                adj_matrix = nx.to_numpy_array(st.session_state.graph)
+                adj_buffer = io.BytesIO()
+                np.save(adj_buffer, adj_matrix)
+                st.download_button(
+                    "🔢 Download Adjacency Matrix",
+                    data=adj_buffer.getvalue(),
+                    file_name="kolam_adjacency.npy",
+                    mime="application/octet-stream"
+                )
+    else:
+        st.info("👆 Please upload a Kolam image and click 'Analyze' to see results")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #666; padding: 1rem;">
+    <p><strong>Kolam Design Analyzer</strong> | Smart India Hackathon 2024</p>
+    <p>Preserving traditional art through modern technology 🎨✨</p>
+</div>
+""", unsafe_allow_html=True)