first

.dockerignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+.venv
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Git
+.git/
+.gitignore
+
+# Documentation
+README.md
+*.md
+!README_HUGGINGFACE.md
+
+# Scripts
+setup.sh
+run.sh
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Temporary files
+tmp/
+temp/
+

.gitignore

@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# Environment variables
+.env
+
+# SAM Model Checkpoints (large files)
+*.pth
+
+# Test images
+test_images/
+temp/
+uploads/
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+Thumbs.db
+

Dockerfile

@@ -0,0 +1,58 @@
+# Use Python 3.10 slim image for smaller size
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies required for OpenCV and other packages
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+# Install PyTorch CPU version to reduce image size (GPU not available on HF free tier)
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY main.py .
+
+# Download SAM model (using smaller vit_b model for HF)
+# You can change this to vit_h or vit_l if needed, but they're larger
+RUN wget -q https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth || \
+    echo "Warning: Could not download SAM model. App will run with fallback methods."
+
+# Update main.py to use the vit_b model if downloaded
+RUN if [ -f "sam_vit_b_01ec64.pth" ]; then \
+    sed -i 's/sam_vit_h_4b8939.pth/sam_vit_b_01ec64.pth/g' main.py && \
+    sed -i 's/vit_h/vit_b/g' main.py; \
+    fi
+
+# Create a non-root user for Hugging Face
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1
+
+# Hugging Face Spaces uses port 7860 by default
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')" || exit 1
+
+# Run the application on port 7860 (Hugging Face default)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+

Dockerfile.local

@@ -0,0 +1,42 @@
+# Dockerfile for local development and testing
+# This version uses the full GPU-enabled PyTorch and larger SAM model
+
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies with GPU support
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY main.py .
+
+# Download SAM model (using vit_h for best quality in local development)
+# Comment out if you want to mount the model from host
+RUN wget -q https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth || \
+    echo "Warning: Could not download SAM model. App will run with fallback methods."
+
+# Expose port 8000 for local development
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:8000/health')" || exit 1
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]
+

README.md

@@ -1,10 +1,326 @@
----
-title: Wallpaint
-emoji: 🌖
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Wall Color Visualizer - Backend
+
+A FastAPI backend service that uses Meta's Segment Anything Model (SAM) for intelligent wall segmentation and color visualization.
+
+## Features
+
+- **AI-Powered Segmentation**: Uses Meta's SAM model for accurate object segmentation
+- **Fallback Support**: Traditional CV methods when SAM is unavailable
+- **Color Application**: Real-time color overlay with adjustable opacity
+- **REST API**: Clean and well-documented API endpoints
+- **CORS Enabled**: Ready for cross-origin requests from Flutter app
+
+## Prerequisites
+
+- Python 3.8 or higher
+- CUDA-capable GPU (optional, for faster processing)
+- At least 8GB RAM
+- 5GB free disk space (for SAM model)
+
+## Installation
+
+### 1. Clone or Navigate to Backend Directory
+
+```bash
+cd /media/aliroohan/hello/MAD/project/backend
+```
+
+### 2. Create Virtual Environment
+
+```bash
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+### 3. Install Dependencies
+
+```bash
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+
+### 4. Download SAM Model
+
+Download the SAM model checkpoint (choose one based on your needs):
+
+**Option 1: Largest and Most Accurate (vit_h - 2.4GB)**
+```bash
+wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
+```
+
+**Option 2: Medium (vit_l - 1.2GB)**
+```bash
+wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth
+```
+
+**Option 3: Smallest and Fastest (vit_b - 375MB)**
+```bash
+wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth
+```
+
+If using a different model, update `sam_checkpoint` and `model_type` in `main.py`.
+
+### 5. Quick Setup (All-in-One)
+
+Alternatively, run the setup script:
+
+```bash
+chmod +x setup.sh
+./setup.sh
+```
+
+## Running the Server
+
+### Development Mode
+
+```bash
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+### Production Mode
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+The server will start at `http://localhost:8000`
+
+## API Endpoints
+
+### Health Check
+
+**GET** `/health`
+
+Check if the server and SAM model are loaded.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "device": "cuda",
+  "sam_model_loaded": true
+}
+```
+
+### Automatic Segmentation
+
+**POST** `/segment-automatic`
+
+Automatically segments all objects in the image.
+
+**Request:**
+- Content-Type: `multipart/form-data`
+- Body: `file` (image file)
+
+**Response:**
+```json
+{
+  "success": true,
+  "num_masks": 5,
+  "masks": [
+    {
+      "id": 0,
+      "mask_base64": "...",
+      "area": 50000,
+      "bbox": [x, y, width, height]
+    }
+  ],
+  "image_base64": "..."
+}
+```
+
+### Simple Segmentation (Fallback)
+
+**POST** `/simple-segment`
+
+Uses traditional CV methods for segmentation.
+
+Same request/response format as `/segment-automatic`.
+
+### Point-Based Segmentation
+
+**POST** `/segment-point`
+
+Segments object at a specific point in the image.
+
+**Request:**
+```json
+{
+  "image_base64": "...",
+  "point_x": 100.5,
+  "point_y": 200.5
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "mask_base64": "...",
+  "score": 0.95
+}
+```
+
+### Apply Color
+
+**POST** `/apply-color`
+
+Applies color to a masked region.
+
+**Request:**
+```json
+{
+  "image_base64": "...",
+  "mask_base64": "...",
+  "color_hex": "#FF5733",
+  "opacity": 0.8
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "result_base64": "..."
+}
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file (see `.env.example`):
+
+```env
+HOST=0.0.0.0
+PORT=8000
+SAM_CHECKPOINT=sam_vit_h_4b8939.pth
+MODEL_TYPE=vit_h
+DEVICE=cuda  # or 'cpu'
+```
+
+### Model Selection
+
+In `main.py`, modify:
+
+```python
+sam_checkpoint = "sam_vit_h_4b8939.pth"  # Path to model
+model_type = "vit_h"  # vit_h, vit_l, or vit_b
+device = "cuda"  # cuda or cpu
+```
+
+## Troubleshooting
+
+### CUDA Out of Memory
+
+If you encounter CUDA memory errors:
+
+1. Use a smaller model (vit_b)
+2. Reduce image size in Flutter app
+3. Use CPU instead: `device = "cpu"`
+
+### Model Not Loading
+
+1. Verify checkpoint file exists in the correct location
+2. Check file integrity (download again if needed)
+3. Ensure sufficient RAM/VRAM
+
+### Slow Performance
+
+- Use GPU (CUDA) instead of CPU
+- Reduce image resolution
+- Use smaller model (vit_b)
+
+## Testing
+
+### Test with cURL
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# Upload and segment
+curl -X POST -F "file=@test_image.jpg" \
+  http://localhost:8000/segment-automatic
+```
+
+### Test with Python
+
+```python
+import requests
+
+# Health check
+response = requests.get('http://localhost:8000/health')
+print(response.json())
+
+# Segment image
+with open('test_image.jpg', 'rb') as f:
+    files = {'file': f}
+    response = requests.post(
+        'http://localhost:8000/segment-automatic',
+        files=files
+    )
+    print(response.json())
+```
+
+## Performance
+
+### With CUDA (GPU)
+- Segmentation: 2-5 seconds per image
+- Color application: < 1 second
+
+### Without CUDA (CPU)
+- Segmentation: 10-30 seconds per image
+- Color application: < 1 second
+
+## Network Configuration
+
+### For Android Emulator
+Use: `http://10.0.2.2:8000`
+
+### For iOS Simulator
+Use: `http://localhost:8000`
+
+### For Real Devices
+1. Find your computer's IP address:
+   ```bash
+   # Linux/Mac
+   ip addr show
+   # or
+   ifconfig
+   
+   # Windows
+   ipconfig
+   ```
+
+2. Use: `http://YOUR_IP:8000`
+3. Ensure firewall allows port 8000
+
+## Dependencies
+
+- **fastapi**: Web framework
+- **uvicorn**: ASGI server
+- **segment-anything**: Meta's SAM model
+- **torch**: PyTorch for deep learning
+- **opencv-python**: Image processing
+- **pillow**: Image manipulation
+- **numpy**: Numerical operations
+
+## License
+
+This project uses Meta's Segment Anything Model. See SAM's license for details.
+
+## Support
+
+For issues or questions:
+1. Check the troubleshooting section
+2. Verify all dependencies are installed
+3. Ensure the model is downloaded correctly
+4. Check server logs for detailed error messages
+
+## Credits
+
+- Meta AI for the Segment Anything Model
+- FastAPI framework
+- OpenCV community
+

README_HUGGINGFACE.md

@@ -0,0 +1,181 @@
+# Wall Color Visualizer API - Hugging Face Deployment
+
+This guide explains how to deploy the Wall Color Visualizer API to Hugging Face Spaces.
+
+## 🚀 Quick Deployment
+
+### Option 1: Deploy via Hugging Face Web Interface
+
+1. **Create a new Space:**
+   - Go to https://huggingface.co/new-space
+   - Choose a name for your Space
+   - Select **Docker** as the Space SDK
+   - Choose **Public** or **Private**
+   - Click "Create Space"
+
+2. **Upload files:**
+   - Upload `Dockerfile`
+   - Upload `main.py`
+   - Upload `requirements.txt`
+   - The Space will automatically build and deploy
+
+3. **Access your API:**
+   - Your API will be available at: `https://YOUR-USERNAME-SPACENAME.hf.space`
+   - API docs: `https://YOUR-USERNAME-SPACENAME.hf.space/docs`
+
+### Option 2: Deploy via Git
+
+```bash
+# Clone your Hugging Face Space repository
+git clone https://huggingface.co/spaces/YOUR-USERNAME/YOUR-SPACE-NAME
+cd YOUR-SPACE-NAME
+
+# Copy the necessary files
+cp path/to/backend/Dockerfile .
+cp path/to/backend/main.py .
+cp path/to/backend/requirements.txt .
+
+# Commit and push
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+## 📋 Important Notes
+
+### Port Configuration
+- Hugging Face Spaces uses **port 7860** by default
+- The Dockerfile is already configured for this
+- Update your Flutter app's API URL to use the Hugging Face Space URL
+
+### Model Selection
+The Dockerfile uses the **SAM ViT-B** model (smallest, ~375MB) to fit within Hugging Face's constraints:
+- `sam_vit_b_01ec64.pth` - Base model (fastest, good quality)
+
+If you need better quality and have more resources, you can modify the Dockerfile to use:
+- `sam_vit_l_0b3195.pth` - Large model (~1.2GB)
+- `sam_vit_h_4b8939.pth` - Huge model (~2.4GB)
+
+### Hardware Requirements
+- **CPU Only**: The Dockerfile is configured for CPU inference (free tier)
+- **GPU**: Upgrade to GPU Space for better performance
+  - Go to Space Settings → Change Hardware → Select GPU
+
+### Resource Limits (Free Tier)
+- **CPU**: 2 vCPUs
+- **RAM**: 16 GB
+- **Storage**: 50 GB
+- **Timeout**: 60 seconds per request
+
+## 🔧 Configuration
+
+### Environment Variables
+You can add environment variables in the Space Settings:
+
+```bash
+# Optional: Set model type
+MODEL_TYPE=vit_b
+SAM_CHECKPOINT=sam_vit_b_01ec64.pth
+
+# Optional: Enable/disable features
+ENABLE_GPU=false
+```
+
+### Modify Dockerfile for GPU
+If you have a GPU Space, update the Dockerfile:
+
+```dockerfile
+# Change this line in the Dockerfile:
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+# To this for GPU support:
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cu118
+```
+
+## 🧪 Testing Your Deployment
+
+Once deployed, test your API:
+
+```bash
+# Health check
+curl https://YOUR-USERNAME-SPACENAME.hf.space/health
+
+# Root endpoint
+curl https://YOUR-USERNAME-SPACENAME.hf.space/
+```
+
+Or visit the API docs directly:
+```
+https://YOUR-USERNAME-SPACENAME.hf.space/docs
+```
+
+## 🔄 Updating Your API in Flutter App
+
+Update the API URL in your Flutter app's `lib/services/api_service.dart`:
+
+```dart
+class ApiService {
+  // Change from localhost to your Hugging Face Space URL
+  static const String baseUrl = 'https://YOUR-USERNAME-SPACENAME.hf.space';
+  
+  // Rest of your code...
+}
+```
+
+## 📊 Monitoring
+
+- **Logs**: View logs in the Space page under "Logs" tab
+- **Metrics**: Check Space settings for usage metrics
+- **Status**: Green dot indicates the Space is running
+
+## 🐛 Troubleshooting
+
+### Build Fails
+- Check logs in the "Logs" tab
+- Ensure all dependencies are in `requirements.txt`
+- Verify Python version compatibility
+
+### Out of Memory
+- Use the smaller SAM model (vit_b)
+- Reduce batch size or image size
+- Consider upgrading to a larger Space
+
+### Slow Response Times
+- First request is slower (model loading)
+- Consider persistent storage for models
+- Upgrade to GPU Space for faster inference
+
+### Connection Issues
+- Ensure port 7860 is exposed
+- Check CORS settings in `main.py`
+- Verify Space is in "Running" state
+
+## 💡 Optimization Tips
+
+1. **Use persistent storage** for SAM models to avoid downloading on every restart
+2. **Enable caching** for frequently processed images
+3. **Implement request queuing** for high traffic
+4. **Use smaller images** (resize before processing)
+5. **Upgrade to GPU Space** for production use
+
+## 📝 Additional Resources
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Docker Spaces Guide](https://huggingface.co/docs/hub/spaces-sdks-docker)
+- [FastAPI Documentation](https://fastapi.tiangolo.com/)
+- [Segment Anything Documentation](https://github.com/facebookresearch/segment-anything)
+
+## 🆘 Support
+
+If you encounter issues:
+1. Check the [Hugging Face Discord](https://discord.gg/hugging-face)
+2. Review [Spaces documentation](https://huggingface.co/docs/hub/spaces)
+3. Open an issue in your repository
+
+## 📜 License
+
+Make sure to comply with:
+- Segment Anything Model license
+- Your project license
+- Hugging Face Terms of Service
+

docker-build.sh

@@ -0,0 +1,180 @@
+#!/bin/bash
+
+# Docker Build and Test Script for Wall Color Visualizer API
+
+set -e  # Exit on error
+
+echo "🐳 Wall Color Visualizer - Docker Build Script"
+echo "=============================================="
+echo ""
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_success() {
+    echo -e "${GREEN}✓ $1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}✗ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠ $1${NC}"
+}
+
+print_info() {
+    echo -e "ℹ $1"
+}
+
+# Parse command line arguments
+BUILD_TYPE="${1:-huggingface}"  # Default to huggingface
+IMAGE_NAME="wall-color-api"
+CONTAINER_NAME="wall-color-api-test"
+
+case $BUILD_TYPE in
+    "huggingface"|"hf")
+        DOCKERFILE="Dockerfile"
+        PORT=7860
+        print_info "Building for Hugging Face (port $PORT)"
+        ;;
+    "local")
+        DOCKERFILE="Dockerfile.local"
+        PORT=8000
+        print_info "Building for local development (port $PORT)"
+        ;;
+    "compose")
+        print_info "Using Docker Compose"
+        echo ""
+        docker-compose up --build
+        exit 0
+        ;;
+    *)
+        print_error "Unknown build type: $BUILD_TYPE"
+        echo "Usage: $0 [huggingface|local|compose]"
+        exit 1
+        ;;
+esac
+
+echo ""
+
+# Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    print_error "Docker is not installed!"
+    echo "Please install Docker first: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+print_success "Docker is installed"
+
+# Check if Dockerfile exists
+if [ ! -f "$DOCKERFILE" ]; then
+    print_error "Dockerfile '$DOCKERFILE' not found!"
+    exit 1
+fi
+print_success "Dockerfile found: $DOCKERFILE"
+
+echo ""
+print_info "Step 1: Building Docker image..."
+echo ""
+
+# Build the Docker image
+if docker build -f "$DOCKERFILE" -t "$IMAGE_NAME:$BUILD_TYPE" .; then
+    print_success "Docker image built successfully!"
+else
+    print_error "Docker build failed!"
+    exit 1
+fi
+
+echo ""
+print_info "Step 2: Stopping any existing containers..."
+
+# Stop and remove existing container if running
+if docker ps -a | grep -q "$CONTAINER_NAME"; then
+    docker stop "$CONTAINER_NAME" 2>/dev/null || true
+    docker rm "$CONTAINER_NAME" 2>/dev/null || true
+    print_success "Cleaned up existing container"
+fi
+
+echo ""
+print_info "Step 3: Starting container..."
+echo ""
+
+# Run the container
+if docker run -d \
+    --name "$CONTAINER_NAME" \
+    -p "$PORT:$PORT" \
+    "$IMAGE_NAME:$BUILD_TYPE"; then
+    print_success "Container started successfully!"
+else
+    print_error "Failed to start container!"
+    exit 1
+fi
+
+echo ""
+print_info "Step 4: Waiting for API to be ready..."
+
+# Wait for the API to be ready
+MAX_ATTEMPTS=30
+ATTEMPT=0
+while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
+    if curl -s "http://localhost:$PORT/health" > /dev/null 2>&1; then
+        print_success "API is ready!"
+        break
+    fi
+    ATTEMPT=$((ATTEMPT + 1))
+    if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
+        print_error "API failed to start within 30 seconds"
+        echo ""
+        echo "Container logs:"
+        docker logs "$CONTAINER_NAME"
+        exit 1
+    fi
+    echo -n "."
+    sleep 1
+done
+
+echo ""
+echo ""
+print_success "Deployment successful!"
+echo ""
+echo "=============================================="
+echo "📊 Container Information:"
+echo "=============================================="
+echo "Container Name: $CONTAINER_NAME"
+echo "Image: $IMAGE_NAME:$BUILD_TYPE"
+echo ""
+echo "🌐 Access URLs:"
+echo "  - API Root:     http://localhost:$PORT/"
+echo "  - Health Check: http://localhost:$PORT/health"
+echo "  - API Docs:     http://localhost:$PORT/docs"
+echo ""
+echo "🔧 Useful Commands:"
+echo "  - View logs:    docker logs -f $CONTAINER_NAME"
+echo "  - Stop:         docker stop $CONTAINER_NAME"
+echo "  - Remove:       docker rm $CONTAINER_NAME"
+echo "  - Shell access: docker exec -it $CONTAINER_NAME /bin/bash"
+echo ""
+echo "=============================================="
+
+# Test the API
+echo ""
+print_info "Running quick API test..."
+echo ""
+
+HEALTH_RESPONSE=$(curl -s "http://localhost:$PORT/health")
+echo "Health check response:"
+echo "$HEALTH_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$HEALTH_RESPONSE"
+
+echo ""
+print_success "All tests passed!"
+echo ""
+print_warning "Press Ctrl+C to stop viewing logs, container will keep running"
+echo ""
+
+# Follow logs
+docker logs -f "$CONTAINER_NAME"
+

docker-compose.yml

@@ -0,0 +1,39 @@
+version: '3.8'
+
+services:
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile.local
+    container_name: wall-color-api
+    ports:
+      - "8000:8000"
+    volumes:
+      # Mount code for hot reload during development
+      - ./main.py:/app/main.py
+      # Mount SAM model if you have it locally (to avoid downloading)
+      # - ./sam_vit_h_4b8939.pth:/app/sam_vit_h_4b8939.pth
+    environment:
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped
+    # Uncomment the following lines if you have NVIDIA GPU
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - driver: nvidia
+    #           count: 1
+    #           capabilities: [gpu]
+
+  # Optional: Add nginx reverse proxy for production
+  # nginx:
+  #   image: nginx:alpine
+  #   container_name: wall-color-nginx
+  #   ports:
+  #     - "80:80"
+  #   volumes:
+  #     - ./nginx.conf:/etc/nginx/nginx.conf:ro
+  #   depends_on:
+  #     - api
+  #   restart: unless-stopped
+

main.py

@@ -0,0 +1,292 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+import numpy as np
+import cv2
+from PIL import Image
+import io
+import base64
+from typing import List, Optional
+import torch
+from segment_anything import sam_model_registry, SamAutomaticMaskGenerator, SamPredictor
+import uvicorn
+
+app = FastAPI(title="Wall Color Visualizer API")
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for SAM model
+sam_checkpoint = "sam_vit_h_4b8939.pth"
+model_type = "vit_h"
+device = "cuda" if torch.cuda.is_available() else "cpu"
+sam = None
+mask_generator = None
+predictor = None
+
+# Request models
+class SegmentRequest(BaseModel):
+    image_base64: str
+    point_x: Optional[float] = None
+    point_y: Optional[float] = None
+
+class ColorChangeRequest(BaseModel):
+    image_base64: str
+    mask_base64: str
+    color_hex: str
+    opacity: float = 0.8
+
+# Initialize SAM model
+def initialize_sam():
+    global sam, mask_generator, predictor
+    try:
+        print(f"Loading SAM model on {device}...")
+        sam = sam_model_registry[model_type](checkpoint=sam_checkpoint)
+        sam.to(device=device)
+        mask_generator = SamAutomaticMaskGenerator(sam)
+        predictor = SamPredictor(sam)
+        print("SAM model loaded successfully!")
+    except Exception as e:
+        print(f"Warning: Could not load SAM model: {e}")
+        print("The API will run but segmentation features will be limited.")
+
+@app.on_event("startup")
+async def startup_event():
+    initialize_sam()
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Wall Color Visualizer API",
+        "status": "running",
+        "sam_loaded": sam is not None
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "device": device,
+        "sam_model_loaded": sam is not None
+    }
+
+def decode_base64_image(base64_string: str) -> np.ndarray:
+    """Decode base64 string to numpy array image"""
+    try:
+        # Remove data URL prefix if present
+        if "base64," in base64_string:
+            base64_string = base64_string.split("base64,")[1]
+        
+        img_data = base64.b64decode(base64_string)
+        img = Image.open(io.BytesIO(img_data))
+        img_array = np.array(img.convert("RGB"))
+        return img_array
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid image data: {str(e)}")
+
+def encode_image_to_base64(image: np.ndarray) -> str:
+    """Encode numpy array image to base64 string"""
+    img = Image.fromarray(image.astype(np.uint8))
+    buffered = io.BytesIO()
+    img.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    return img_str
+
+def encode_mask_to_base64(mask: np.ndarray) -> str:
+    """Encode binary mask to base64 string"""
+    mask_uint8 = (mask * 255).astype(np.uint8)
+    img = Image.fromarray(mask_uint8)
+    buffered = io.BytesIO()
+    img.save(buffered, format="PNG")
+    mask_str = base64.b64encode(buffered.getvalue()).decode()
+    return mask_str
+
+def hex_to_rgb(hex_color: str) -> tuple:
+    """Convert hex color to RGB tuple"""
+    hex_color = hex_color.lstrip('#')
+    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+
+@app.post("/segment-automatic")
+async def segment_automatic(file: UploadFile = File(...)):
+    """Automatically segment all objects in the image"""
+    if sam is None:
+        raise HTTPException(status_code=503, detail="SAM model not loaded")
+    
+    try:
+        # Read and decode image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        image_np = np.array(image.convert("RGB"))
+        
+        # Generate masks
+        masks = mask_generator.generate(image_np)
+        
+        # Sort masks by area (largest first)
+        masks = sorted(masks, key=lambda x: x['area'], reverse=True)
+        
+        # Return top masks
+        result_masks = []
+        for i, mask_data in enumerate(masks[:10]):  # Return top 10 masks
+            mask = mask_data['segmentation']
+            result_masks.append({
+                "id": i,
+                "mask_base64": encode_mask_to_base64(mask),
+                "area": int(mask_data['area']),
+                "bbox": [int(x) for x in mask_data['bbox']]
+            })
+        
+        return {
+            "success": True,
+            "num_masks": len(result_masks),
+            "masks": result_masks,
+            "image_base64": encode_image_to_base64(image_np)
+        }
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Segmentation failed: {str(e)}")
+
+@app.post("/segment-point")
+async def segment_point(request: SegmentRequest):
+    """Segment object at a specific point in the image"""
+    if sam is None:
+        raise HTTPException(status_code=503, detail="SAM model not loaded")
+    
+    try:
+        # Decode image
+        image_np = decode_base64_image(request.image_base64)
+        
+        # Set image for predictor
+        predictor.set_image(image_np)
+        
+        # Use point prompt
+        if request.point_x is not None and request.point_y is not None:
+            point_coords = np.array([[request.point_x, request.point_y]])
+            point_labels = np.array([1])  # 1 = foreground point
+            
+            masks, scores, logits = predictor.predict(
+                point_coords=point_coords,
+                point_labels=point_labels,
+                multimask_output=True
+            )
+            
+            # Get the best mask (highest score)
+            best_mask_idx = np.argmax(scores)
+            best_mask = masks[best_mask_idx]
+            
+            return {
+                "success": True,
+                "mask_base64": encode_mask_to_base64(best_mask),
+                "score": float(scores[best_mask_idx])
+            }
+        else:
+            raise HTTPException(status_code=400, detail="Point coordinates required")
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Segmentation failed: {str(e)}")
+
+@app.post("/apply-color")
+async def apply_color(request: ColorChangeRequest):
+    """Apply color to masked region of the image"""
+    try:
+        # Decode image and mask
+        image_np = decode_base64_image(request.image_base64)
+        mask_np = decode_base64_image(request.mask_base64)
+        
+        # Convert mask to binary
+        if len(mask_np.shape) == 3:
+            mask_np = cv2.cvtColor(mask_np, cv2.COLOR_RGB2GRAY)
+        mask_binary = (mask_np > 128).astype(np.uint8)
+        
+        # Convert hex color to RGB
+        rgb_color = hex_to_rgb(request.color_hex)
+        
+        # Create colored overlay
+        colored_mask = np.zeros_like(image_np)
+        colored_mask[mask_binary == 1] = rgb_color
+        
+        # Blend with original image
+        result = image_np.copy().astype(float)
+        alpha = request.opacity
+        result[mask_binary == 1] = (
+            alpha * colored_mask[mask_binary == 1] + 
+            (1 - alpha) * image_np[mask_binary == 1]
+        )
+        result = result.astype(np.uint8)
+        
+        return {
+            "success": True,
+            "result_base64": encode_image_to_base64(result)
+        }
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Color application failed: {str(e)}")
+
+@app.post("/simple-segment")
+async def simple_segment(file: UploadFile = File(...)):
+    """Simple segmentation using traditional CV methods (fallback when SAM not available)"""
+    try:
+        # Read and decode image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        image_np = np.array(image.convert("RGB"))
+        
+        # Convert to different color spaces for better wall detection
+        hsv = cv2.cvtColor(image_np, cv2.COLOR_RGB2HSV)
+        gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+        
+        # Apply edge detection
+        edges = cv2.Canny(gray, 50, 150)
+        
+        # Dilate edges to create connected regions
+        kernel = np.ones((5, 5), np.uint8)
+        dilated = cv2.dilate(edges, kernel, iterations=2)
+        
+        # Find contours
+        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Create masks for largest contours
+        result_masks = []
+        h, w = image_np.shape[:2]
+        
+        # Sort by area
+        contours = sorted(contours, key=cv2.contourArea, reverse=True)
+        
+        for i, contour in enumerate(contours[:5]):  # Top 5 regions
+            area = cv2.contourArea(contour)
+            if area < (h * w * 0.01):  # Skip very small regions
+                continue
+            
+            mask = np.zeros((h, w), dtype=np.uint8)
+            cv2.drawContours(mask, [contour], -1, 255, -1)
+            
+            # Get bounding box
+            x, y, bw, bh = cv2.boundingRect(contour)
+            
+            result_masks.append({
+                "id": i,
+                "mask_base64": encode_mask_to_base64(mask / 255),
+                "area": int(area),
+                "bbox": [int(x), int(y), int(bw), int(bh)]
+            })
+        
+        return {
+            "success": True,
+            "num_masks": len(result_masks),
+            "masks": result_masks,
+            "image_base64": encode_image_to_base64(image_np),
+            "method": "traditional_cv"
+        }
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Segmentation failed: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+python-multipart
+pillow
+numpy
+opencv-python
+torch
+torchvision
+segment-anything
+pydantic
+python-jose[cryptography]
+

run.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Wall Color Visualizer Backend Runner Script
+
+echo "🎨 Starting Wall Color Visualizer Backend..."
+echo "==========================================="
+echo ""
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "❌ Virtual environment not found!"
+    echo "Please run setup.sh first:"
+    echo "  ./setup.sh"
+    exit 1
+fi
+
+# Activate virtual environment
+echo "📦 Activating virtual environment..."
+source venv/bin/activate
+
+# Check if SAM model exists
+if [ ! -f "sam_vit_h_4b8939.pth" ] && [ ! -f "sam_vit_l_0b3195.pth" ] && [ ! -f "sam_vit_b_01ec64.pth" ]; then
+    echo "⚠️  Warning: SAM model not found!"
+    echo "The API will work with fallback methods but won't have AI segmentation."
+    echo ""
+    echo "To download SAM model, run:"
+    echo "  wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth"
+    echo ""
+fi
+
+# Get local IP address
+LOCAL_IP=$(hostname -I | awk '{print $1}')
+
+echo "🚀 Starting FastAPI server..."
+echo ""
+echo "Server will be available at:"
+echo "  - Local:        http://localhost:8000"
+echo "  - Network:      http://$LOCAL_IP:8000"
+echo "  - Health Check: http://localhost:8000/health"
+echo "  - API Docs:     http://localhost:8000/docs"
+echo ""
+echo "For Flutter app configuration:"
+echo "  - Android Emulator: http://10.0.2.2:8000"
+echo "  - iOS Simulator:    http://localhost:8000"
+echo "  - Real Device:      http://$LOCAL_IP:8000"
+echo ""
+echo "Press Ctrl+C to stop the server"
+echo "==========================================="
+echo ""
+
+# Start server
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+

setup.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+echo "Setting up Wall Color Visualizer Backend..."
+
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate
+
+# Upgrade pip
+pip install --upgrade pip
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Download SAM model checkpoint (vit_h - largest and most accurate)
+echo "Downloading SAM model checkpoint..."
+wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
+
+# Alternative: Download smaller models if needed
+# wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth
+# wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth
+
+echo "Setup complete!"
+echo "To start the server, run: uvicorn main:app --reload --host 0.0.0.0 --port 8000"
+

test_api.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Test script for Wall Color Visualizer API
+"""
+
+import requests
+import base64
+import json
+from pathlib import Path
+
+# Configuration
+BASE_URL = "http://localhost:8000"
+
+def test_health():
+    """Test health endpoint"""
+    print("Testing health endpoint...")
+    try:
+        response = requests.get(f"{BASE_URL}/health")
+        print(f"Status: {response.status_code}")
+        print(f"Response: {json.dumps(response.json(), indent=2)}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def test_simple_segment(image_path):
+    """Test simple segmentation endpoint"""
+    print(f"\nTesting simple segmentation with {image_path}...")
+    
+    if not Path(image_path).exists():
+        print(f"Error: Image file not found: {image_path}")
+        return False
+    
+    try:
+        with open(image_path, 'rb') as f:
+            files = {'file': f}
+            response = requests.post(
+                f"{BASE_URL}/simple-segment",
+                files=files,
+                timeout=60
+            )
+        
+        print(f"Status: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Success: {data['success']}")
+            print(f"Number of masks: {data['num_masks']}")
+            print(f"Method: {data.get('method', 'N/A')}")
+            return True
+        else:
+            print(f"Error: {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def test_segment_automatic(image_path):
+    """Test automatic segmentation endpoint (requires SAM)"""
+    print(f"\nTesting automatic segmentation with {image_path}...")
+    
+    if not Path(image_path).exists():
+        print(f"Error: Image file not found: {image_path}")
+        return False
+    
+    try:
+        with open(image_path, 'rb') as f:
+            files = {'file': f}
+            response = requests.post(
+                f"{BASE_URL}/segment-automatic",
+                files=files,
+                timeout=60
+            )
+        
+        print(f"Status: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Success: {data['success']}")
+            print(f"Number of masks: {data['num_masks']}")
+            return True
+        else:
+            print(f"Error: {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def test_apply_color(image_path):
+    """Test color application (requires existing segmentation)"""
+    print(f"\nTesting color application...")
+    
+    # First, get a segmentation
+    if not Path(image_path).exists():
+        print(f"Error: Image file not found: {image_path}")
+        return False
+    
+    try:
+        # Get segmentation
+        with open(image_path, 'rb') as f:
+            files = {'file': f}
+            seg_response = requests.post(
+                f"{BASE_URL}/simple-segment",
+                files=files,
+                timeout=60
+            )
+        
+        if seg_response.status_code != 200:
+            print("Failed to get segmentation")
+            return False
+        
+        seg_data = seg_response.json()
+        if not seg_data['masks']:
+            print("No masks found")
+            return False
+        
+        # Apply color to first mask
+        image_base64 = seg_data['image_base64']
+        mask_base64 = seg_data['masks'][0]['mask_base64']
+        
+        color_request = {
+            'image_base64': image_base64,
+            'mask_base64': mask_base64,
+            'color_hex': '#FF5733',  # Orange-red color
+            'opacity': 0.8
+        }
+        
+        response = requests.post(
+            f"{BASE_URL}/apply-color",
+            json=color_request,
+            timeout=60
+        )
+        
+        print(f"Status: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Success: {data['success']}")
+            print("Color applied successfully!")
+            
+            # Optionally save result
+            if data.get('result_base64'):
+                result_bytes = base64.b64decode(data['result_base64'])
+                output_path = 'result_colored.png'
+                with open(output_path, 'wb') as f:
+                    f.write(result_bytes)
+                print(f"Result saved to: {output_path}")
+            
+            return True
+        else:
+            print(f"Error: {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("=" * 60)
+    print("Wall Color Visualizer API Test Suite")
+    print("=" * 60)
+    
+    results = {}
+    
+    # Test 1: Health check
+    results['health'] = test_health()
+    
+    # Ask for test image
+    print("\n" + "=" * 60)
+    image_path = input("Enter path to test image (or press Enter to skip): ").strip()
+    
+    if image_path and Path(image_path).exists():
+        # Test 2: Simple segmentation
+        results['simple_segment'] = test_simple_segment(image_path)
+        
+        # Test 3: Automatic segmentation (SAM)
+        results['auto_segment'] = test_segment_automatic(image_path)
+        
+        # Test 4: Color application
+        results['apply_color'] = test_apply_color(image_path)
+    else:
+        print("Skipping image-based tests...")
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("Test Results Summary")
+    print("=" * 60)
+    for test_name, passed in results.items():
+        status = "✓ PASSED" if passed else "✗ FAILED"
+        print(f"{test_name:20} : {status}")
+    
+    total = len(results)
+    passed = sum(results.values())
+    print(f"\nTotal: {passed}/{total} tests passed")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()
+