Initial deployment

algorithms/.env.production

@@ -0,0 +1,17 @@
+# Production Environment Configuration
+# Copy to .env for local production testing
+
+# API Server Configuration
+API_HOST=0.0.0.0
+API_PORT=7860
+
+# CORS Configuration (comma-separated origins)
+# Use * for development, specific domains for production
+CORS_ORIGINS=*
+
+# Logging
+LOG_LEVEL=INFO
+
+# Application Settings
+APP_TITLE="Land Redistribution Algorithm API"
+APP_VERSION=2.0.0

algorithms/DEPLOYMENT.md

@@ -0,0 +1,386 @@
+# Deployment Guide
+
+Complete guide for deploying the Land Redistribution Algorithm to production.
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Backend Deployment (Hugging Face Spaces)](#backend-deployment-hugging-face-spaces)
+- [Frontend Deployment (Streamlit Cloud)](#frontend-deployment-streamlit-cloud)
+- [Local Docker Testing](#local-docker-testing)
+- [Environment Variables](#environment-variables)
+- [Troubleshooting](#troubleshooting)
+
+## Prerequisites
+
+### For All Deployments
+- Git installed on your machine
+- GitHub account (for Streamlit Cloud)
+- Hugging Face account (for backend deployment)
+
+### For Local Testing
+- Docker and Docker Compose installed
+- Python 3.11+ (for non-Docker development)
+- Make (optional, for convenience commands)
+
+## Backend Deployment (Hugging Face Spaces)
+
+Hugging Face Spaces provides free hosting for ML applications with Docker support.
+
+### Step 1: Create a New Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click **"Create new Space"**
+3. Configure:
+   - **Space name**: `land-redistribution-api` (or your choice)
+   - **License**: MIT
+   - **Select the Space SDK**: Docker
+   - **Visibility**: Public or Private
+
+### Step 2: Prepare Backend Files
+
+The backend directory is already configured with:
+- ✅ `Dockerfile` - Multi-stage production build
+- ✅ `README_HF.md` - Hugging Face metadata
+- ✅ `requirements.txt` - Python dependencies
+- ✅ `.dockerignore` - Build optimization
+
+### Step 3: Deploy to Hugging Face
+
+#### Option A: Git Push (Recommended)
+
+```bash
+# Navigate to backend directory
+cd /Volumes/WorkSpace/Project/REMB/algorithms/backend
+
+# Initialize git (if not already)
+git init
+
+# Add Hugging Face remote using your space name
+git remote add hf https://huggingface.co/spaces/<YOUR_USERNAME>/<SPACE_NAME>
+
+# Rename README for Hugging Face
+cp README_HF.md README.md
+
+# Add and commit files
+git add .
+git commit -m "Initial deployment"
+
+# Push to Hugging Face
+git push hf main
+```
+
+#### Option B: Web Upload
+
+1. In your Space, click **"Files and versions"**
+2. Upload all files from `backend/` directory
+3. Ensure `README_HF.md` is renamed to `README.md`
+
+### Step 4: Wait for Build
+
+- Hugging Face will automatically build your Docker image
+- Build time: ~5-10 minutes
+- Monitor progress in the "Logs" tab
+
+### Step 5: Test Your Backend API
+
+Once deployed, your API will be available at:
+```
+https://<YOUR_USERNAME>-<SPACE_NAME>.hf.space
+```
+
+Test endpoints:
+```bash
+# Health check
+curl https://<YOUR_USERNAME>-<SPACE_NAME>.hf.space/health
+
+# API documentation
+open https://<YOUR_USERNAME>-<SPACE_NAME>.hf.space/docs
+```
+
+## Frontend Deployment (Streamlit Cloud)
+
+### Step 1: Push Frontend to GitHub
+
+```bash
+cd /Volumes/WorkSpace/Project/REMB/algorithms/frontend
+
+# Initialize git repository (if not already)
+git init
+
+# Add GitHub remote
+git remote add origin https://github.com/<YOUR_USERNAME>/land-redistribution-ui.git
+
+# Add all files
+git add .
+git commit -m "Initial commit"
+
+# Push to GitHub
+git branch -M main
+git push -u origin main
+```
+
+### Step 2: Deploy on Streamlit Cloud
+
+1. Go to [Streamlit Cloud](https://streamlit.io/cloud)
+2. Sign in with GitHub
+3. Click **"New app"**
+4. Configure:
+   - **Repository**: Select your frontend repository
+   - **Branch**: `main`
+   - **Main file path**: `app.py`
+
+### Step 3: Configure Environment Variables
+
+In Streamlit Cloud, add secrets:
+
+1. Go to your app settings
+2. Click **"Secrets"**
+3. Add:
+```toml
+API_URL = "https://<YOUR_HF_USERNAME>-<SPACE_NAME>.hf.space"
+```
+
+### Step 4: Deploy
+
+- Click **"Deploy"**
+- Streamlit Cloud will install dependencies and launch your app
+- Your app will be available at: `https://<APP_NAME>.streamlit.app`
+
+## Local Docker Testing
+
+Before deploying to production, test locally with Docker Compose.
+
+### Quick Start
+
+```bash
+# Navigate to algorithms directory
+cd /Volumes/WorkSpace/Project/REMB/algorithms
+
+# Build and start services
+make build
+make up
+
+# View logs
+make logs
+
+# Test services
+make health
+```
+
+### Manual Testing
+
+```bash
+# Build backend
+docker-compose build backend
+
+# Start all services
+docker-compose up -d
+
+# Check status
+docker-compose ps
+
+# View logs
+docker-compose logs -f
+
+# Test backend
+curl http://localhost:8000/health
+
+# Access frontend
+open http://localhost:8501
+
+# Stop services
+docker-compose down
+```
+
+### Testing the Backend Container Only
+
+```bash
+cd backend
+
+# Build image
+docker build -t land-redistribution-api .
+
+# Run container
+docker run -p 7860:7860 land-redistribution-api
+
+# Test in another terminal
+curl http://localhost:7860/health
+```
+
+## Environment Variables
+
+### Backend (.env or Hugging Face Secrets)
+
+```bash
+API_HOST=0.0.0.0
+API_PORT=7860
+CORS_ORIGINS=*
+LOG_LEVEL=INFO
+```
+
+### Frontend (.env or Streamlit Secrets)
+
+```bash
+# Development
+API_URL=http://localhost:8000
+
+# Production (use your actual Hugging Face Space URL)
+API_URL=https://<YOUR_HF_USERNAME>-<SPACE_NAME>.hf.space
+```
+
+## Troubleshooting
+
+### Backend Issues
+
+#### Build Fails on Hugging Face
+
+**Problem**: Docker build fails with dependency errors
+
+**Solution**:
+1. Check Dockerfile syntax
+2. Verify requirements.txt has pinned versions
+3. Check build logs in Hugging Face Space
+4. Test locally first: `docker build -t test ./backend`
+
+#### API Returns 500 Error
+
+**Problem**: Backend starts but API endpoints fail
+
+**Solution**:
+1. Check logs in Hugging Face Space
+2. Verify all imports work: Test locally with Docker
+3. Check CORS settings in `main.py`
+
+#### Slow Performance
+
+**Problem**: API is slow or times out
+
+**Solution**:
+- Reduce optimization parameters (population_size, generations)
+- Consider upgrading to Hugging Face paid tier for more resources
+- Add caching for common requests
+
+### Frontend Issues
+
+#### Cannot Connect to Backend
+
+**Problem**: Frontend shows "Cannot connect to API"
+
+**Solution**:
+1. Verify `API_URL` environment variable is set correctly in Streamlit Secrets
+2. Check backend is running: Visit backend URL directly
+3. Check CORS settings on backend
+4. Verify no typos in API_URL (should include https://)
+
+#### Streamlit Cloud Build Fails
+
+**Problem**: Deployment fails on Streamlit Cloud
+
+**Solution**:
+1. Check `requirements.txt` for incompatible versions
+2. Verify `app.py` has no syntax errors
+3. Check Streamlit Cloud build logs
+4. Test locally: `streamlit run app.py`
+
+### Docker Compose Issues
+
+#### Port Already in Use
+
+**Problem**: `Error: port is already allocated`
+
+**Solution**:
+```bash
+# Find process using port
+lsof -i :8000
+lsof -i :8501
+
+# Kill process
+kill -9 <PID>
+
+# Or change ports in docker-compose.yml
+```
+
+#### Container Crashes on Startup
+
+**Problem**: Service exits immediately
+
+**Solution**:
+```bash
+# Check logs
+docker-compose logs backend
+docker-compose logs frontend
+
+# Run container interactively
+docker run -it land-redistribution-api /bin/bash
+
+# Check health
+docker-compose ps
+```
+
+## Performance Optimization
+
+### Backend
+
+1. **Reduce CPU-intensive operations**:
+   - Lower default `population_size` and `generations`
+   - Add request timeouts
+   - Implement result caching
+
+2. **Optimize Docker image**:
+   - Use multi-stage builds (already implemented)
+   - Minimize layers
+   - Remove unnecessary dependencies
+
+### Frontend
+
+1. **Optimize Streamlit**:
+   - Use `@st.cache_data` for expensive computations
+   - Lazy load visualizations
+   - Reduce re-renders with `st.session_state`
+
+2. **Reduce API calls**:
+   - Cache results in session state
+   - Batch multiple requests
+
+## Monitoring
+
+### Hugging Face Spaces
+
+- View logs: Space → Logs tab
+- Check metrics: Space → Settings → Usage
+- Restart: Space → Settings → Factory reboot
+
+### Streamlit Cloud
+
+- View logs: App → Manage app → Logs
+- Check analytics: App → Analytics
+- Restart: App → Manage app → Reboot app
+
+## Security Considerations
+
+1. **Environment Variables**: Never commit `.env` files with secrets
+2. **CORS**: In production, replace `CORS_ORIGINS=*` with specific domains
+3. **Rate Limiting**: Consider adding rate limiting for public APIs
+4. **Input Validation**: Backend validates all inputs (already implemented)
+
+## Next Steps
+
+1. ✅ Test locally with Docker Compose
+2. ✅ Deploy backend to Hugging Face Spaces
+3. ✅ Deploy frontend to Streamlit Cloud
+4. ✅ Configure environment variables
+5. ✅ Test end-to-end flow
+6. 📝 Monitor performance and logs
+7. 🚀 Share with users!
+
+## Support
+
+For issues or questions:
+- Backend API: Check Hugging Face Space discussions
+- Frontend: Check Streamlit Community forum
+- General: Open an issue on GitHub
+
+## License
+
+MIT

algorithms/Makefile

@@ -0,0 +1,79 @@
+.PHONY: help build up down logs clean test-backend test-frontend restart
+
+help: ## Show this help message
+	@echo 'Usage: make [target]'
+	@echo ''
+	@echo 'Available targets:'
+	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+
+build: ## Build Docker images
+	@echo "Building backend Docker image..."
+	docker-compose build backend
+	@echo "✅ Build complete!"
+
+up: ## Start all services
+	@echo "Starting services..."
+	docker-compose up -d
+	@echo "✅ Services started!"
+	@echo "Backend API: http://localhost:8000"
+	@echo "Frontend UI: http://localhost:8501"
+	@echo "API Docs: http://localhost:8000/docs"
+
+down: ## Stop all services
+	@echo "Stopping services..."
+	docker-compose down
+	@echo "✅ Services stopped!"
+
+logs: ## View logs from all services
+	docker-compose logs -f
+
+logs-backend: ## View backend logs only
+	docker-compose logs -f backend
+
+logs-frontend: ## View frontend logs only
+	docker-compose logs -f frontend
+
+restart: ## Restart all services
+	@echo "Restarting services..."
+	docker-compose restart
+	@echo "✅ Services restarted!"
+
+clean: ## Stop services and remove volumes
+	@echo "Cleaning up..."
+	docker-compose down -v
+	@echo "✅ Cleanup complete!"
+
+test-backend: ## Test backend container
+	@echo "Testing backend..."
+	@docker build -t land-redistribution-test ./backend
+	@docker run --rm -p 7860:7860 -d --name backend-test land-redistribution-test
+	@sleep 5
+	@echo "Testing health endpoint..."
+	@curl -f http://localhost:7860/health || (docker stop backend-test && exit 1)
+	@echo "\n✅ Backend test passed!"
+	@docker stop backend-test
+
+dev-backend: ## Run backend in development mode (without Docker)
+	@echo "Starting backend in development mode..."
+	cd backend && uvicorn main:app --reload --port 8000
+
+dev-frontend: ## Run frontend in development mode (without Docker)
+	@echo "Starting frontend in development mode..."
+	cd frontend && streamlit run app.py --server.port 8501
+
+install-backend: ## Install backend dependencies
+	cd backend && pip install -r requirements.txt
+
+install-frontend: ## Install frontend dependencies
+	cd frontend && pip install -r requirements.txt
+
+install: install-backend install-frontend ## Install all dependencies
+
+status: ## Show status of services
+	docker-compose ps
+
+health: ## Check health of running services
+	@echo "Checking backend health..."
+	@curl -s http://localhost:8000/health | python -m json.tool || echo "❌ Backend not responding"
+	@echo "\nChecking frontend..."
+	@curl -s -o /dev/null -w "Status: %{http_code}\n" http://localhost:8501 || echo "❌ Frontend not responding"

algorithms/QUICK_START.md

@@ -0,0 +1,255 @@
+# 🚀 Quick Deployment Reference
+
+## Local Testing
+
+### Using Docker Compose (Recommended)
+```bash
+cd /Volumes/WorkSpace/Project/REMB/algorithms
+
+# Build images
+make build
+
+# Start services
+make up
+
+# View logs
+make logs
+
+# Check health
+make health
+
+# Access services
+# Backend:  http://localhost:8000
+# Frontend: http://localhost:8501
+# API Docs: http://localhost:8000/docs
+
+# Stop services
+make down
+```
+
+### Manual (Without Docker)
+```bash
+# Terminal 1: Backend
+cd /Volumes/WorkSpace/Project/REMB/algorithms/backend
+pip install -r requirements.txt
+uvicorn main:app --reload --port 8000
+
+# Terminal 2: Frontend
+cd /Volumes/WorkSpace/Project/REMB/algorithms/frontend
+pip install -r requirements.txt
+export API_URL=http://localhost:8000
+streamlit run app.py --server.port 8501
+```
+
+---
+
+## Production Deployment
+
+### Backend → Hugging Face Spaces
+
+```bash
+cd /Volumes/WorkSpace/Project/REMB/algorithms/backend
+
+# 1. Rename README for HF
+cp README_HF.md README.md
+
+# 2. Initialize git (if needed)
+git init
+
+# 3. Add HF remote (replace with your details)
+git remote add hf https://huggingface.co/spaces/<USERNAME>/<SPACE_NAME>
+
+# 4. Commit and push
+git add .
+git commit -m "Deploy to Hugging Face Spaces"
+git push hf main
+
+# 5. Monitor build at:
+# https://huggingface.co/spaces/<USERNAME>/<SPACE_NAME>
+```
+
+**Your API will be at**: `https://<USERNAME>-<SPACE_NAME>.hf.space`
+
+### Frontend → Streamlit Cloud
+
+```bash
+cd /Volumes/WorkSpace/Project/REMB/algorithms/frontend
+
+# 1. Push to GitHub
+git init
+git remote add origin https://github.com/<USERNAME>/<REPO_NAME>.git
+git add .
+git commit -m "Initial commit"
+git branch -M main
+git push -u origin main
+
+# 2. Go to Streamlit Cloud
+# https://streamlit.io/cloud
+
+# 3. Create new app:
+# - Repository: <USERNAME>/<REPO_NAME>
+# - Branch: main
+# - Main file: app.py
+
+# 4. Add secrets in Streamlit Cloud settings:
+# API_URL = "https://<HF_USERNAME>-<SPACE_NAME>.hf.space"
+
+# 5. Deploy!
+```
+
+**Your app will be at**: `https://<APP_NAME>.streamlit.app`
+
+---
+
+## Environment Variables
+
+### Backend (.env or HF Secrets)
+```bash
+API_HOST=0.0.0.0
+API_PORT=7860
+CORS_ORIGINS=*
+LOG_LEVEL=INFO
+```
+
+### Frontend (.env or Streamlit Secrets)
+```bash
+# Development
+API_URL=http://localhost:8000
+
+# Production
+API_URL=https://<HF_USERNAME>-<SPACE_NAME>.hf.space
+```
+
+---
+
+## Troubleshooting
+
+### Docker Build Fails
+```bash
+# Test build locally
+cd backend
+docker build -t test .
+
+# Check logs
+docker logs <container_id>
+
+# Run interactively
+docker run -it test /bin/bash
+```
+
+### Frontend Can't Connect
+1. Check `API_URL` environment variable
+2. Verify backend is running
+3. Check CORS settings in backend
+4. Test backend directly: `curl <API_URL>/health`
+
+### Port Already in Use
+```bash
+# Find process
+lsof -i :8000
+lsof -i :8501
+
+# Kill process
+kill -9 <PID>
+```
+
+---
+
+## Testing Deployed Services
+
+### Test Backend API
+```bash
+# Health check
+curl https://<USERNAME>-<SPACE_NAME>.hf.space/health
+
+# View API docs
+open https://<USERNAME>-<SPACE_NAME>.hf.space/docs
+
+# Test optimization endpoint
+curl -X POST https://<USERNAME>-<SPACE_NAME>.hf.space/api/optimize \
+  -H "Content-Type: application/json" \
+  -d '{
+    "config": {
+      "spacing_min": 20,
+      "spacing_max": 30,
+      "population_size": 20,
+      "generations": 50
+    },
+    "land_plots": [{
+      "type": "Polygon",
+      "coordinates": [[[0,0],[100,0],[100,100],[0,100],[0,0]]]
+    }]
+  }'
+```
+
+### Test Frontend
+1. Open `https://<APP_NAME>.streamlit.app`
+2. Select "Sample" → "Rectangle 100x100"
+3. Click "🚀 Run Optimization"
+4. Wait for results
+5. Download GeoJSON
+
+---
+
+## Useful Makefile Commands
+
+```bash
+make help           # Show all available commands
+make build          # Build Docker images
+make up             # Start services
+make down           # Stop services
+make logs           # View all logs
+make logs-backend   # View backend logs only
+make logs-frontend  # View frontend logs only
+make restart        # Restart all services
+make clean          # Stop and remove volumes
+make test-backend   # Test backend container
+make dev-backend    # Run backend without Docker
+make dev-frontend   # Run frontend without Docker
+make status         # Show service status
+make health         # Check service health
+```
+
+---
+
+## File Checklist
+
+Before deploying, ensure these files exist:
+
+**Backend**:
+- [x] `Dockerfile`
+- [x] `.dockerignore`
+- [x] `requirements.txt` (with production deps)
+- [x] `README_HF.md` (will become README.md)
+
+**Frontend**:
+- [x] `app.py` (with environment support)
+- [x] `requirements.txt` (with python-dotenv)
+- [x] `.streamlit/config.toml`
+
+**Root**:
+- [x] `docker-compose.yml`
+- [x] `Makefile`
+- [x] `.env.production` (template)
+- [x] `DEPLOYMENT.md`
+- [x] `README.md` (updated)
+
+---
+
+## Quick Links
+
+- 📖 **Full Guide**: [DEPLOYMENT.md](file:///Volumes/WorkSpace/Project/REMB/algorithms/DEPLOYMENT.md)
+- 🏠 **Main README**: [README.md](file:///Volumes/WorkSpace/Project/REMB/algorithms/README.md)
+- 🐳 **Backend Dockerfile**: [Dockerfile](file:///Volumes/WorkSpace/Project/REMB/algorithms/backend/Dockerfile)
+- 🎨 **Frontend App**: [app.py](file:///Volumes/WorkSpace/Project/REMB/algorithms/frontend/app.py)
+- 🔧 **Docker Compose**: [docker-compose.yml](file:///Volumes/WorkSpace/Project/REMB/algorithms/docker-compose.yml)
+
+---
+
+## Support
+
+- **Hugging Face Spaces**: https://huggingface.co/docs/hub/spaces
+- **Streamlit Cloud**: https://docs.streamlit.io/streamlit-community-cloud
+- **Docker**: https://docs.docker.com/
+
+**Next Step**: Follow the [DEPLOYMENT.md](file:///Volumes/WorkSpace/Project/REMB/algorithms/DEPLOYMENT.md) guide!

algorithms/README.md

@@ -30,22 +30,73 @@ algorithms/
 └── README.md
 ```
 
-## Installation
+## Quick Start
 
-### Backend
+### Option 1: Docker Compose (Recommended)
+
+Run both backend and frontend with a single command:
+
+```bash
+cd algorithms
+make build  # Build Docker images
+make up     # Start services
+```
+
+Services will be available at:
+- **Backend API**: http://localhost:8000
+- **Frontend UI**: http://localhost:8501
+- **API Docs**: http://localhost:8000/docs
+
+Stop services:
+```bash
+make down
+```
+
+### Option 2: Manual Installation
+
+#### Backend
 
 ```bash
 cd algorithms/backend
 pip install -r requirements.txt
 ```
 
-### Frontend
+#### Frontend
 
 ```bash
 cd algorithms/frontend
 pip install -r requirements.txt
 ```
 
+## Deployment
+
+### Production Deployment
+
+For deploying to production environments:
+
+- **Backend**: Deploy to [Hugging Face Spaces](https://huggingface.co/spaces) using Docker
+- **Frontend**: Deploy to [Streamlit Cloud](https://streamlit.io/cloud) or any hosting service
+
+📖 **See [DEPLOYMENT.md](DEPLOYMENT.md) for detailed deployment instructions**
+
+### Environment Variables
+
+Create a `.env` file (copy from `.env.production`):
+
+**Backend**:
+```bash
+API_HOST=0.0.0.0
+API_PORT=7860
+CORS_ORIGINS=*
+LOG_LEVEL=INFO
+```
+
+**Frontend**:
+```bash
+API_URL=http://localhost:8000  # Development
+# API_URL=https://your-space.hf.space  # Production
+```
+
 ## Running the Application
 
 ### Start Backend Server

algorithms/RUNNING.md

@@ -76,14 +76,16 @@ lsof -i :8502
 kill -9 <PID>
 ```
 
-## Restart Services
+# Restart Services
 
-```bash
 # Terminal 1: Backend
+# Kill existing backend process
+lsof -i :8000 | awk 'NR!=1 {print $2}' | xargs kill -9
 cd /Volumes/WorkSpace/Project/REMB/algorithms/backend
 ../../venv/bin/uvicorn main:app --reload --port 8000
 
 # Terminal 2: Frontend
+# Kill existing frontend process
+lsof -i :8502 | awk 'NR!=1 {print $2}' | xargs kill -9
 cd /Volumes/WorkSpace/Project/REMB/algorithms/frontend
 ../../venv/bin/streamlit run app.py --server.port 8502
-```

algorithms/backend/.dockerignore

@@ -0,0 +1,59 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+*.cover
+
+# Development
+.env
+.env.local
+*.log
+
+# Git
+.git/
+.gitignore
+.gitattributes
+
+# Documentation
+*.md
+!README_HF.md
+docs/
+
+# Test files
+test_*.py
+*_test.py
+tests/
+analyze_*.py
+debug_*.py
+compare_*.py
+
+# Sample data
+samples/
+examples/
+data/
+
+# OS
+.DS_Store
+Thumbs.db

algorithms/backend/Dockerfile

@@ -0,0 +1,58 @@
+# Multi-stage build for Land Redistribution API
+FROM python:3.11-slim as builder
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies required for scientific libraries
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    gcc \
+    g++ \
+    gfortran \
+    libopenblas-dev \
+    liblapack-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Final stage
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libopenblas0 \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy Python packages from builder
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN useradd -m -u 1000 appuser && \
+    chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Expose Hugging Face Spaces default port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')"
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

algorithms/backend/README_HF.md

@@ -0,0 +1,87 @@
+---
+title: Land Redistribution Algorithm API
+emoji: 🏘️
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Land Redistribution Algorithm API
+
+API for industrial park land subdivision and redistribution using advanced optimization algorithms.
+
+## Features
+
+- **Multi-stage Optimization**: NSGA-II genetic algorithm + OR-Tools constraint programming
+- **DXF Import**: Upload site boundaries from CAD files
+- **Automated Layout**: Grid optimization, block subdivision, and infrastructure planning
+- **Export Results**: Download results as GeoJSON
+
+## API Endpoints
+
+### Health Check
+```bash
+GET /health
+```
+
+### Full Optimization Pipeline
+```bash
+POST /api/optimize
+```
+
+Runs the complete 3-stage optimization:
+1. Grid Optimization (NSGA-II)
+2. Block Subdivision (OR-Tools)
+3. Infrastructure Planning
+
+### DXF Upload
+```bash
+POST /api/upload-dxf
+```
+
+Upload DXF file and extract boundary polygon.
+
+## Usage
+
+Visit the [interactive API documentation](/docs) for detailed endpoint specifications and to test the API directly.
+
+### Quick Example
+
+```python
+import requests
+
+url = "https://your-space-name.hf.space/api/optimize"
+payload = {
+    "config": {
+        "spacing_min": 20.0,
+        "spacing_max": 30.0,
+        "population_size": 50,
+        "generations": 100
+    },
+    "land_plots": [{
+        "type": "Polygon",
+        "coordinates": [[[0, 0], [100, 0], [100, 100], [0, 100], [0, 0]]]
+    }]
+}
+
+response = requests.post(url, json=payload)
+result = response.json()
+```
+
+## Frontend
+
+For a complete user interface, use the Streamlit frontend: [Link to your Streamlit app]
+
+## Technology Stack
+
+- **FastAPI**: High-performance Python web framework
+- **DEAP**: Genetic algorithms (NSGA-II)
+- **OR-Tools**: Constraint programming solver
+- **Shapely**: Geometric operations
+- **ezdxf**: DXF file parsing
+
+## License
+
+MIT

algorithms/backend/analyze_dxf_entities.py

@@ -0,0 +1,74 @@
+"""Investigate what entities are in these DXF files."""
+
+import ezdxf
+import tempfile
+import os
+
+files = [
+    "/Volumes/WorkSpace/Project/REMB/examples/663409.dxf",
+    "/Volumes/WorkSpace/Project/REMB/examples/930300.dxf"
+]
+
+for dxf_path in files:
+    print("=" * 70)
+    print(f"Analyzing: {dxf_path.split('/')[-1]}")
+    print("=" * 70)
+    
+    try:
+        doc = ezdxf.readfile(dxf_path)
+        msp = doc.modelspace()
+        
+        # Count all entity types
+        entity_types = {}
+        total = 0
+        
+        for entity in msp:
+            etype = entity.dxftype()
+            entity_types[etype] = entity_types.get(etype, 0) + 1
+            total += 1
+        
+        print(f"Total entities: {total}")
+        print(f"\nEntity breakdown:")
+        for etype, count in sorted(entity_types.items(), key=lambda x: -x[1]):
+            print(f"  {etype}: {count}")
+        
+        # Check for specific geometry types
+        print(f"\nGeometry analysis:")
+        
+        # Check for POINT entities
+        points = list(msp.query('POINT'))
+        if points:
+            print(f"  Found {len(points)} POINT entities")
+            print(f"    Sample: {points[0].dxf.location if points else 'N/A'}")
+        
+        # Check for CIRCLE entities
+        circles = list(msp.query('CIRCLE'))
+        if circles:
+            print(f"  Found {len(circles)} CIRCLE entities")
+            if circles:
+                c = circles[0]
+                print(f"    Sample: center={c.dxf.center}, radius={c.dxf.radius}")
+        
+        # Check for ARC entities
+        arcs = list(msp.query('ARC'))
+        if arcs:
+            print(f"  Found {len(arcs)} ARC entities")
+        
+        # Check for SPLINE entities
+        splines = list(msp.query('SPLINE'))
+        if splines:
+            print(f"  Found {len(splines)} SPLINE entities")
+        
+        # Check for TEXT entities
+        texts = list(msp.query('TEXT'))
+        if texts:
+            print(f"  Found {len(texts)} TEXT entities")
+            if texts:
+                print(f"    Sample text: '{texts[0].dxf.text}'")
+                
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print()

algorithms/backend/compare_methods.py

@@ -0,0 +1,40 @@
+"""Compare file read vs stream read"""
+
+import ezdxf
+
+dxf_path = "/Volumes/WorkSpace/Project/REMB/examples/663409.dxf"
+
+# Method 1: Direct readfile
+print("Method 1: Direct readfile()")
+doc1 = ezdxf.readfile(dxf_path)
+msp1 = doc1.modelspace()
+lines1 = len(list(msp1.query('LINE')))
+print(f"  LINE entities: {lines1}")
+
+# Method 2: Read bytes, decode, StringIO
+import io
+with open(dxf_path, 'rb') as f:
+    content = f.read()
+
+print("\nMethod 2: bytes -> latin-1 -> StringIO")
+text = content.decode('latin-1')
+stream = io.StringIO(text)
+doc2 = ezdxf.read(stream)
+msp2 = doc2.modelspace()
+lines2 = len(list(msp2.query('LINE')))
+print(f"  LINE entities: {lines2}")
+
+# Method 3: tempfile
+import tempfile
+import os
+
+print("\nMethod 3: bytes -> tempfile -> readfile()")
+with tempfile.NamedTemporaryFile(mode='wb', suffix='.dxf', delete=False) as tmp:
+    tmp.write(content)
+    tmp_path = tmp.name
+
+doc3 = ezdxf.readfile(tmp_path)
+msp3 = doc3.modelspace()
+lines3 = len(list(msp3.query('LINE')))
+print(f"  LINE entities: {lines3}")
+os.unlink(tmp_path)

algorithms/backend/debug_ezdxf.py

@@ -0,0 +1,40 @@
+"""Debug ezdxf behavior with Bel air file"""
+import ezdxf
+import io
+
+dxf_path = "/Volumes/WorkSpace/Project/REMB/examples/Lot Plan Bel air Technical Description.dxf"
+
+# Test 1: Direct file read
+print("Test 1: Direct file read")
+try:
+    doc = ezdxf.readfile(dxf_path)
+    print(f"✅ Success with readfile()")
+    print(f"   Entities: {len(list(doc.modelspace()))}")
+except Exception as e:
+    print(f"❌ Failed: {e}")
+
+# Test 2: Read through bytes
+print("\nTest 2: Read through bytes")
+with open(dxf_path, 'rb') as f:
+    content = f.read()
+
+# Try decoding
+for enc in ['utf-8', 'latin-1', 'cp1252']:
+    print(f"\n  Trying {enc}:")
+    try:
+        text = content.decode(enc)
+        stream = io.StringIO(text)
+        doc = ezdxf.read(stream)
+        print(f"  ✅ Success with {enc}")
+        break
+    except Exception as e:
+        print(f"  ❌ {type(e).__name__}: {str(e)[:100]}")
+
+# Test 3: Binary stream
+print("\nTest 3: Binary stream")
+try:
+    stream = io.BytesIO(content)
+    doc = ezdxf.read(stream)
+    print(f"✅ Success with binary stream")
+except Exception as e:
+    print(f"❌ Failed: {e}")

algorithms/backend/debug_validation.py

@@ -0,0 +1,71 @@
+"""Debug validation process for 663409.dxf"""
+
+import sys
+sys.path.insert(0, '/Volumes/WorkSpace/Project/REMB/algorithms/backend')
+
+import ezdxf
+import io
+import tempfile
+import os
+
+dxf_path = "/Volumes/WorkSpace/Project/REMB/examples/663409.dxf"
+
+with open(dxf_path, 'rb') as f:
+    dxf_content = f.read()
+
+print(f"File size: {len(dxf_content)} bytes")
+
+# Try to load with different methods
+encodings = ['utf-8', 'latin-1', 'cp1252', 'utf-16']
+doc = None
+
+for encoding in encodings:
+    print(f"\nTrying {encoding}...")
+    try:
+        text_content = dxf_content.decode(encoding)
+        text_stream = io.StringIO(text_content)
+        doc = ezdxf.read(text_stream)
+        print(f"  ✅ Success with {encoding}")
+        break
+    except Exception as e:
+        print(f"  ❌ {type(e).__name__}: {str(e)[:80]}")
+
+if doc is None:
+    print("\nTrying binary stream...")
+    try:
+        dxf_stream = io.BytesIO(dxf_content)
+        doc = ezdxf.read(dxf_stream)
+        print("  ✅ Success with binary stream")
+    except Exception as e:
+        print(f"  ❌ {type(e).__name__}: {str(e)[:80]}")
+
+if doc is None:
+    print("\nTrying tempfile...")
+    try:
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.dxf', delete=False) as tmp:
+            tmp.write(dxf_content)
+            tmp_path = tmp.name
+        
+        doc = ezdxf.readfile(tmp_path)
+        print(f"  ✅ Success with tempfile")
+        os.unlink(tmp_path)
+    except Exception as e:
+        print(f"  ❌ {type(e).__name__}: {str(e)[:80]}")
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+if doc:
+    msp = doc.modelspace()
+    lwpolylines = sum(1 for e in msp if e.dxftype() == 'LWPOLYLINE')
+    polylines = len(list(msp.query('POLYLINE')))
+    lines = len(list(msp.query('LINE')))
+    
+    print(f"\n✅ LOADED SUCCESSFULLY")
+    print(f"   LWPOLYLINE: {lwpolylines}")
+    print(f"   POLYLINE: {polylines}")
+    print(f"   LINE: {lines}")
+    print(f"   Total: {lwpolylines + polylines + lines}")
+else:
+    print("\n❌ FAILED TO LOAD")

algorithms/backend/requirements.txt

@@ -1,5 +1,5 @@
 fastapi==0.104.1
-uvicorn==0.24.0
+uvicorn[standard]==0.24.0
 pydantic==2.5.0
 numpy==1.26.2
 shapely==2.0.2
@@ -11,3 +11,5 @@ ezdxf==1.1.3
 scipy==1.11.4
 networkx==3.2.1
 scikit-learn==1.3.2
+python-dotenv==1.0.0
+gunicorn==21.2.0

algorithms/backend/test_additional_dxf.py

@@ -0,0 +1,47 @@
+"""Test additional DXF files."""
+
+import sys
+sys.path.insert(0, '/Volumes/WorkSpace/Project/REMB/algorithms/backend')
+
+from utils.dxf_utils import load_boundary_from_dxf, validate_dxf
+
+# Test both files
+files = [
+    "/Volumes/WorkSpace/Project/REMB/examples/663409.dxf",
+    "/Volumes/WorkSpace/Project/REMB/examples/930300.dxf"
+]
+
+for dxf_path in files:
+    print("=" * 70)
+    print(f"Testing: {dxf_path.split('/')[-1]}")
+    print("=" * 70)
+    
+    try:
+        with open(dxf_path, 'rb') as f:
+            content = f.read()
+        
+        print(f"File size: {len(content):,} bytes")
+        print(f"First 100 bytes: {content[:100]}")
+        
+        # Test validation
+        is_valid, message = validate_dxf(content)
+        print(f"\nValidation: {'✅' if is_valid else '❌'} {message}")
+        
+        # Test loading
+        if is_valid:
+            polygon = load_boundary_from_dxf(content)
+            if polygon:
+                print(f"\n✅ Polygon extracted successfully!")
+                print(f"   Area: {polygon.area/10000:.2f} ha")
+                print(f"   Bounds: {polygon.bounds}")
+            else:
+                print("\n❌ Failed to extract polygon")
+        
+    except FileNotFoundError:
+        print(f"❌ File not found: {dxf_path}")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print()

algorithms/backend/test_belair_dxf.py

@@ -0,0 +1,38 @@
+"""Test DXF loading with Bel air file."""
+
+import sys
+sys.path.insert(0, '/Volumes/WorkSpace/Project/REMB/algorithms/backend')
+
+from utils.dxf_utils import load_boundary_from_dxf, validate_dxf
+
+# Test with Bel air DXF file
+dxf_path = "/Volumes/WorkSpace/Project/REMB/examples/Lot Plan Bel air Technical Description.dxf"
+
+print(f"Testing file: {dxf_path}")
+
+with open(dxf_path, 'rb') as f:
+    content = f.read()
+    
+print(f"File size: {len(content)} bytes")
+print(f"First 200 bytes: {content[:200]}")
+print(f"\nIs binary? {content[:10]}")
+
+# Test validation
+try:
+    is_valid, message = validate_dxf(content)
+    print(f"\nValidation: {is_valid}")
+    print(f"Message: {message}")
+    
+    # Test loading
+    if is_valid:
+        polygon = load_boundary_from_dxf(content)
+        if polygon:
+            print(f"\n✅ Success!")
+            print(f"Polygon area: {polygon.area/10000:.2f} ha")
+            print(f"Bounds: {polygon.bounds}")
+        else:
+            print("\n❌ Failed to extract polygon")
+except Exception as e:
+    print(f"\n❌ Error: {e}")
+    import traceback
+    traceback.print_exc()

algorithms/backend/test_dxf.py

@@ -0,0 +1,30 @@
+"""Test DXF loading functionality."""
+
+import sys
+sys.path.insert(0, '/Volumes/WorkSpace/Project/REMB/algorithms/backend')
+
+from utils.dxf_utils import load_boundary_from_dxf, validate_dxf
+
+# Test with actual DXF file
+dxf_path = "/Volumes/WorkSpace/Project/REMB/examples/api-cw750-details.dxf"
+
+with open(dxf_path, 'rb') as f:
+    content = f.read()
+    
+print(f"File size: {len(content)} bytes")
+print(f"First 100 bytes: {content[:100]}")
+
+# Test validation
+is_valid, message = validate_dxf(content)
+print(f"\nValidation: {is_valid}")
+print(f"Message: {message}")
+
+# Test loading
+if is_valid:
+    polygon = load_boundary_from_dxf(content)
+    if polygon:
+        print(f"\n✅ Success!")
+        print(f"Polygon area: {polygon.area/10000:.2f} ha")
+        print(f"Bounds: {polygon.bounds}")
+    else:
+        print("\n❌ Failed to extract polygon")

algorithms/backend/utils/dxf_utils.py

@@ -1,16 +1,26 @@
-"""DXF file handling utilities for importing and exporting geometry."""
+"""DXF file handling utilities for importing and exporting geometry.
 
+Based on REMB_Production_Final_Reliable.ipynb converter logic.
+"""
+
+import logging
 import ezdxf
-from shapely.geometry import Polygon, mapping
-from shapely.ops import unary_union
+from shapely.geometry import Polygon, mapping, LineString
+from shapely.ops import unary_union, polygonize
 from typing import Optional, List, Tuple
 import io
 
+logger = logging.getLogger(__name__)
+
 
 def load_boundary_from_dxf(dxf_content: bytes) -> Optional[Polygon]:
     """
     Load site boundary from DXF file content.
     
+    Uses the same logic as notebook's load_boundary_from_dxf function:
+    - Looks for closed LWPOLYLINE entities
+    - Returns the largest valid polygon found
+    
     Args:
         dxf_content: Bytes content of DXF file
         
@@ -19,54 +29,149 @@ def load_boundary_from_dxf(dxf_content: bytes) -> Optional[Polygon]:
     """
     try:
         # Load DXF from bytes
-        dxf_stream = io.BytesIO(dxf_content)
-        doc = ezdxf.readfile(dxf_stream)
+        # For maximum compatibility, especially with old DXF formats (R11/R12),
+        # use tempfile approach as it preserves all entity data
+        import tempfile
+        import os
+        
+        doc = None
+        tmp_path = None
+        
+        try:
+            # Write bytes to temporary file
+            with tempfile.NamedTemporaryFile(mode='wb', suffix='.dxf', delete=False) as tmp:
+                tmp.write(dxf_content)
+                tmp_path = tmp.name
+            
+            # Read using ezdxf.readfile (most reliable method)
+            doc = ezdxf.readfile(tmp_path)
+            logger.info("Successfully loaded DXF using tempfile method")
+            
+        except Exception as e:
+            logger.warning(f"Tempfile method failed: {e}, trying stream methods")
+            
+            # Fallback: Try stream methods
+            encodings = ['utf-8', 'latin-1', 'cp1252', 'utf-16']
+            
+            for encoding in encodings:
+                try:
+                    text_content = dxf_content.decode(encoding)
+                    text_stream = io.StringIO(text_content)
+                    doc = ezdxf.read(text_stream)
+                    logger.info(f"Successfully loaded DXF with {encoding} encoding")
+                    break
+                except (UnicodeDecodeError, AttributeError):
+                    continue
+                except Exception:
+                    continue
+            
+            # Last resort: Binary stream
+            if doc is None:
+                try:
+                    dxf_stream = io.BytesIO(dxf_content)
+                    doc = ezdxf.read(dxf_stream)
+                    logger.info("Successfully loaded DXF in binary format")
+                except Exception as final_error:
+                    logger.error(f"Failed to load DXF in any format: {final_error}")
+                    return None
+        finally:
+            # Clean up temp file
+            if tmp_path and os.path.exists(tmp_path):
+                try:
+                    os.unlink(tmp_path)
+                except:
+                    pass
+        
+        if doc is None:
+            return None
+        
         msp = doc.modelspace()
         
-        polygons = []
-        
-        # Extract LWPOLYLINE and POLYLINE entities
-        for entity in msp.query('LWPOLYLINE, POLYLINE'):
-            if entity.is_closed:
-                points = list(entity.get_points())
-                if len(points) >= 3:
-                    coords = [(p[0], p[1]) for p in points]
-                    # Close the polygon
-                    if coords[0] != coords[-1]:
-                        coords.append(coords[0])
+        largest = None
+        max_area = 0.0
+        
+        # Extract LWPOLYLINE entities (matching notebook logic)
+        for entity in msp:
+            if entity.dxftype() == 'LWPOLYLINE' and entity.is_closed:
+                try:
+                    # Get points in xy format (matching notebook)
+                    pts = list(entity.get_points(format='xy'))
+                    
+                    if len(pts) >= 3:
+                        poly = Polygon(pts)
+                        
+                        if poly.is_valid and poly.area > max_area:
+                            max_area = poly.area
+                            largest = poly
+                            
+                except Exception as e:
+                    logger.warning(f"Failed to process LWPOLYLINE: {e}")
+                    continue
+        
+        # Also try POLYLINE entities as fallback
+        if not largest:
+            for entity in msp.query('POLYLINE'):
+                if entity.is_closed:
                     try:
-                        poly = Polygon(coords)
-                        if poly.is_valid:
-                            polygons.append(poly)
-                    except:
+                        points = list(entity.get_points())
+                        if len(points) >= 3:
+                            coords = [(p[0], p[1]) for p in points]
+                            poly = Polygon(coords)
+                            
+                            if poly.is_valid and poly.area > max_area:
+                                max_area = poly.area
+                                largest = poly
+                                
+                    except Exception as e:
+                        logger.warning(f"Failed to process POLYLINE: {e}")
                         continue
         
-        # Also try to extract from LINE entities forming closed loops
-        lines = list(msp.query('LINE'))
-        if lines and not polygons:
-            # Try to connect lines into closed loops
-            # This is a simplified approach - could be improved
-            for line in lines:
-                start = (line.dxf.start.x, line.dxf.start.y)
-                end = (line.dxf.end.x, line.dxf.end.y)
-                # Simple heuristic: if it looks like a rectangle
-                # You might need more sophisticated logic here
-        
-        if polygons:
-            # Union all polygons and take the largest one
-            if len(polygons) > 1:
-                union = unary_union(polygons)
-                if union.geom_type == 'Polygon':
-                    return union
-                elif union.geom_type == 'MultiPolygon':
-                    # Return the largest polygon
-                    return max(union.geoms, key=lambda p: p.area)
-            return polygons[0]
+        # Try to build polygons from LINE entities (for CAD files with separate lines)
+        if not largest:
+            try:
+                from shapely.ops import polygonize, unary_union
+                from shapely.geometry import MultiLineString
+                
+                lines = list(msp.query('LINE'))
+                if lines:
+                    logger.info(f"Attempting to build polygon from {len(lines)} LINE entities")
+                    
+                    # Convert LINE entities to shapely LineStrings
+                    line_segments = []
+                    for line in lines:
+                        start = (line.dxf.start.x, line.dxf.start.y)
+                        end = (line.dxf.end.x, line.dxf.end.y)
+                        line_segments.append(LineString([start, end]))
+                    
+                    # Use polygonize to find closed polygons from line network
+                    polygons = list(polygonize(line_segments))
+                    
+                    if polygons:
+                        logger.info(f"Found {len(polygons)} polygons from LINE entities")
+                        
+                        # Find the largest valid polygon
+                        for poly in polygons:
+                            if poly.is_valid and poly.area > max_area:
+                                max_area = poly.area
+                                largest = poly
+                    else:
+                        logger.warning("Could not create polygons from LINE entities")
+                        
+            except Exception as e:
+                logger.warning(f"Failed to process LINE entities: {e}")
+        
+        if largest:
+            # Scale coordinates by 1.5x for better visualization
+            from shapely import affinity
+            largest = affinity.scale(largest, xfact=1.5, yfact=1.5, origin='centroid')
+            logger.info(f"Boundary loaded and scaled 1.5x: {largest.area/10000:.2f} ha")
+            return largest
         
+        logger.warning("No valid closed polylines found in DXF")
         return None
         
     except Exception as e:
-        print(f"Error loading DXF: {e}")
+        logger.error(f"Error loading DXF: {e}")
         return None
 
 
@@ -87,10 +192,12 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
         msp = doc.modelspace()
         
         # Create layers
-        doc.layers.add('BLOCKS', color=5)  # Blue for blocks
-        doc.layers.add('LOTS', color=3)    # Green for lots
-        doc.layers.add('PARKS', color=2)   # Yellow for parks
-        doc.layers.add('BOUNDARY', color=7) # White for boundary
+        doc.layers.add('BLOCKS', color=5)      # Blue for blocks
+        doc.layers.add('LOTS', color=3)        # Green for lots
+        doc.layers.add('PARKS', color=2)       # Yellow for parks
+        doc.layers.add('SERVICE', color=4)     # Cyan for service
+        doc.layers.add('ROADS', color=8)       # Gray for roads
+        doc.layers.add('INFRASTRUCTURE', color=1)  # Red for infrastructure
         
         # Add geometries
         for item in geometries:
@@ -99,12 +206,19 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
             geom_type = props.get('type', 'lot')
             
             # Determine layer
-            if geom_type == 'block':
-                layer = 'BLOCKS'
-            elif geom_type == 'park':
-                layer = 'PARKS'
-            else:
-                layer = 'LOTS'
+            layer_map = {
+                'block': 'BLOCKS',
+                'park': 'PARKS',
+                'service': 'SERVICE',
+                'xlnt': 'SERVICE',
+                'road_network': 'ROADS',
+                'connection': 'INFRASTRUCTURE',
+                'transformer': 'INFRASTRUCTURE',
+                'drainage': 'INFRASTRUCTURE',
+                'lot': 'LOTS',
+                'setback': 'LOTS'
+            }
+            layer = layer_map.get(geom_type, 'LOTS')
             
             # Get coordinates
             if geom and 'coordinates' in geom:
@@ -120,6 +234,7 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
                             radius=2.0,
                             dxfattribs={'layer': layer}
                         )
+                        
                 elif geom_geom_type == 'LineString':
                     # LineString: [[x1, y1], [x2, y2], ...]
                     if isinstance(coords, list) and len(coords) > 0:
@@ -130,6 +245,7 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
                                     points_2d,
                                     dxfattribs={'layer': layer, 'closed': False}
                                 )
+                                
                 elif geom_geom_type == 'Polygon':
                     # Polygon: [[[x1, y1], [x2, y2], ...]]  (exterior ring)
                     if isinstance(coords, list) and len(coords) > 0:
@@ -155,7 +271,7 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
         return stream.getvalue().encode('utf-8')
         
     except Exception as e:
-        print(f"Error exporting DXF: {e}")
+        logger.error(f"Error exporting DXF: {e}")
         return b''
 
 
@@ -170,18 +286,63 @@ def validate_dxf(dxf_content: bytes) -> Tuple[bool, str]:
         (is_valid, message)
     """
     try:
-        dxf_stream = io.BytesIO(dxf_content)
-        doc = ezdxf.readfile(dxf_stream)
+        # Load DXF for validation
+        # Use tempfile method for maximum compatibility
+        import tempfile
+        import os
+        
+        doc = None
+        tmp_path = None
+        
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', suffix='.dxf', delete=False) as tmp:
+                tmp.write(dxf_content)
+                tmp_path = tmp.name
+            
+            doc = ezdxf.readfile(tmp_path)
+            
+        except Exception:
+            # Fallback to stream methods
+            encodings = ['utf-8', 'latin-1', 'cp1252', 'utf-16']
+            
+            for encoding in encodings:
+                try:
+                    text_content = dxf_content.decode(encoding)
+                    text_stream = io.StringIO(text_content)
+                    doc = ezdxf.read(text_stream)
+                    break
+                except (UnicodeDecodeError, AttributeError, Exception):
+                    continue
+            
+            if doc is None:
+                try:
+                    dxf_stream = io.BytesIO(dxf_content)
+                    doc = ezdxf.read(dxf_stream)
+                except Exception as e:
+                    return False, f"Failed to parse DXF: {str(e)}"
+        finally:
+            if tmp_path and os.path.exists(tmp_path):
+                try:
+                    os.unlink(tmp_path)
+                except:
+                    pass
         msp = doc.modelspace()
         
         # Count entities
-        polylines = len(list(msp.query('LWPOLYLINE, POLYLINE')))
+        lwpolylines = sum(1 for e in msp if e.dxftype() == 'LWPOLYLINE')
+        polylines = len(list(msp.query('POLYLINE')))
         lines = len(list(msp.query('LINE')))
         
-        if polylines == 0 and lines == 0:
+        total_entities = lwpolylines + polylines + lines
+        
+        if total_entities == 0:
             return False, "No polylines or lines found in DXF"
         
-        return True, f"Valid DXF: {polylines} polylines, {lines} lines"
+        # Check for closed polylines
+        closed_count = sum(1 for e in msp if e.dxftype() == 'LWPOLYLINE' and e.is_closed)
+        
+        msg = f"Valid DXF: {lwpolylines} LWPOLYLINE ({closed_count} closed), {polylines} POLYLINE, {lines} LINE"
+        return True, msg
         
     except Exception as e:
         return False, f"Invalid DXF: {str(e)}"

algorithms/docker-compose.yml

@@ -0,0 +1,48 @@
+version: '3.8'
+
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: land-redistribution-api
+    ports:
+      - "8000:7860"
+    environment:
+      - API_HOST=0.0.0.0
+      - API_PORT=7860
+      - CORS_ORIGINS=*
+      - LOG_LEVEL=INFO
+    healthcheck:
+      test: [ "CMD", "python", "-c", "import requests; requests.get('http://localhost:7860/health')" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+    restart: unless-stopped
+    networks:
+      - app-network
+
+  frontend:
+    image: python:3.11-slim
+    container_name: land-redistribution-ui
+    working_dir: /app
+    ports:
+      - "8501:8501"
+    environment:
+      - API_URL=http://backend:7860
+    volumes:
+      - ./frontend:/app
+    command: >
+      sh -c "pip install --no-cache-dir -r requirements.txt &&
+             streamlit run app.py --server.port 8501 --server.address 0.0.0.0"
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped
+    networks:
+      - app-network
+
+networks:
+  app-network:
+    driver: bridge

algorithms/frontend/.streamlit/config.toml

@@ -0,0 +1,20 @@
+[server]
+headless = true
+port = 8501
+enableCORS = false
+enableXsrfProtection = true
+
+[browser]
+gatherUsageStats = false
+serverAddress = "0.0.0.0"
+
+[theme]
+primaryColor = "#2E86AB"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"
+
+[client]
+showErrorDetails = true
+toolbarMode = "minimal"

algorithms/frontend/app.py

@@ -19,9 +19,15 @@ import numpy as np
 from plotly.subplots import make_subplots
 import pandas as pd
 from typing import Dict, Any
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configuration - Support both local and production deployment
+API_URL = os.getenv("API_URL", "http://localhost:8000")
 
-# Configuration
-API_URL = "http://localhost:8000"
 
 # Page config - Wide layout for one-page design
 st.set_page_config(
@@ -539,6 +545,26 @@ with col_result:
             Includes: Roads, Setbacks, Zoning, Loop Network, Transformers, Drainage.
             """
             try:
+                def plot_geometry(geom, **kwargs):
+                    """Helper to plot Polygon or MultiPolygon."""
+                    if geom.geom_type == 'Polygon':
+                        xs, ys = geom.exterior.xy
+                        ax.fill(xs, ys, **kwargs)
+                    elif geom.geom_type == 'MultiPolygon':
+                        for poly in geom.geoms:
+                            xs, ys = poly.exterior.xy
+                            ax.fill(xs, ys, **kwargs)
+                
+                def plot_outline(geom, **kwargs):
+                    """Helper to plot outline of Polygon or MultiPolygon."""
+                    if geom.geom_type == 'Polygon':
+                        xs, ys = geom.exterior.xy
+                        ax.plot(xs, ys, **kwargs)
+                    elif geom.geom_type == 'MultiPolygon':
+                        for poly in geom.geoms:
+                            xs, ys = poly.exterior.xy
+                            ax.plot(xs, ys, **kwargs)
+                
                 # Setup figure
                 fig, ax = plt.subplots(figsize=(12, 12))
                 ax.set_aspect('equal')
@@ -548,19 +574,11 @@ with col_result:
                 features = result_data.get('final_layout', {}).get('features', [])
                 
                 # 1. Draw Roads & Sidewalks (Layer 0)
-                # We specifically look for type='road_network' or we draw the inverse using plot background if needed
-                # But our backend now sends 'road_network' feature
                 for f in features:
                     if f['properties'].get('type') == 'road_network':
                         geom = shape(f['geometry'])
-                        if geom.is_empty: continue
-                        if geom.geom_type == 'Polygon':
-                            xs, ys = geom.exterior.xy
-                            ax.fill(xs, ys, color='#607d8b', alpha=0.3, label='Hạ tầng giao thông')
-                        elif geom.geom_type == 'MultiPolygon':
-                            for poly in geom.geoms:
-                                xs, ys = poly.exterior.xy
-                                ax.fill(xs, ys, color='#607d8b', alpha=0.3)
+                        if not geom.is_empty:
+                            plot_geometry(geom, color='#607d8b', alpha=0.3, label='Hạ tầng giao thông')
 
                 # 2. Draw Commercial Lots & Setbacks (Layer 1)
                 for f in features:
@@ -568,34 +586,29 @@ with col_result:
                     ftype = props.get('type')
                     
                     if ftype == 'lot':
-                        poly = shape(f['geometry'])
-                        xs, ys = poly.exterior.xy
-                        ax.plot(xs, ys, color='black', linewidth=0.5)
-                        ax.fill(xs, ys, color='#fff9c4', alpha=0.5) # Yellow
+                        geom = shape(f['geometry'])
+                        plot_outline(geom, color='black', linewidth=0.5)
+                        plot_geometry(geom, color='#fff9c4', alpha=0.5)
                     
                     elif ftype == 'setback':
-                        poly = shape(f['geometry'])
-                        xs, ys = poly.exterior.xy
-                        ax.plot(xs, ys, color='red', linestyle='--', linewidth=0.8, alpha=0.7)
+                        geom = shape(f['geometry'])
+                        plot_outline(geom, color='red', linestyle='--', linewidth=0.8, alpha=0.7)
 
                 # 3. Draw Service / Technical Areas (Layer 2)
                 for f in features:
                     props = f['properties']
                     ftype = props.get('type')
-                    poly = shape(f['geometry'])
+                    geom = shape(f['geometry'])
                     
                     if ftype == 'xlnt':
-                        xs, ys = poly.exterior.xy
-                        ax.fill(xs, ys, color='#b2dfdb', alpha=0.9) # Cyan/Blue
-                        ax.text(poly.centroid.x, poly.centroid.y, "XLNT", ha='center', fontsize=8, color='black', weight='bold')
+                        plot_geometry(geom, color='#b2dfdb', alpha=0.9)
+                        ax.text(geom.centroid.x, geom.centroid.y, "XLNT", ha='center', fontsize=8, color='black', weight='bold')
                     elif ftype == 'service':
-                        xs, ys = poly.exterior.xy
-                        ax.fill(xs, ys, color='#d1c4e9', alpha=0.9) # Purple
-                        ax.text(poly.centroid.x, poly.centroid.y, "Điều hành", ha='center', fontsize=8, color='black', weight='bold')
+                        plot_geometry(geom, color='#d1c4e9', alpha=0.9)
+                        ax.text(geom.centroid.x, geom.centroid.y, "Điều hành", ha='center', fontsize=8, color='black', weight='bold')
                     elif ftype == 'park':
-                        xs, ys = poly.exterior.xy
-                        ax.fill(xs, ys, color='#f6ffed', alpha=0.5) # Green
-                        ax.plot(xs, ys, color='green', linewidth=0.5, linestyle=':')
+                        plot_geometry(geom, color='#f6ffed', alpha=0.5)
+                        plot_outline(geom, color='green', linewidth=0.5, linestyle=':')
 
                 # 4. Draw Electrical Infrastructure (Loop)
                 for f in features:

algorithms/frontend/requirements.txt

@@ -7,3 +7,4 @@ pandas==2.1.4
 streamlit-drawable-canvas==0.9.3
 matplotlib==3.8.2
 shapely==2.0.2
+python-dotenv==1.0.0