Extended Reality Infrastructure

import numpy as np
import asyncio
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
from scipy.spatial.transform import Rotation
import uuid
import time

@dataclass
class SpatialAnchor:
    id: str
    position: np.ndarray  # 3D world position
    orientation: np.ndarray  # Quaternion
    confidence: float
    timestamp: float
    creator_id: str
    shared: bool = False
    expiry_time: Optional[float] = None

@dataclass
class SpatialQuery:
    position: np.ndarray
    radius: float
    max_results: int = 50
    min_confidence: float = 0.7

class ARCloudSpatialService:
    def __init__(self, grid_size: float = 10.0):
        self.grid_size = grid_size
        self.spatial_grid: Dict[Tuple[int, int, int], List[SpatialAnchor]] = {}
        self.anchors: Dict[str, SpatialAnchor] = {}
        self.user_sessions: Dict[str, Dict] = {}
        
    def _get_grid_cell(self, position: np.ndarray) -> Tuple[int, int, int]:
        """Convert world position to spatial grid cell"""
        return tuple((position / self.grid_size).astype(int))
    
    def _get_nearby_cells(self, center_cell: Tuple[int, int, int], 
                         radius: int = 1) -> List[Tuple[int, int, int]]:
        """Get all grid cells within radius of center cell"""
        cells = []
        cx, cy, cz = center_cell
        for dx in range(-radius, radius + 1):
            for dy in range(-radius, radius + 1):
                for dz in range(-radius, radius + 1):
                    cells.append((cx + dx, cy + dy, cz + dz))
        return cells
    
    async def create_anchor(self, position: np.ndarray, orientation: np.ndarray,
                          confidence: float, creator_id: str,
                          shared: bool = False, ttl_hours: Optional[float] = None) -> str:
        """Create a new spatial anchor"""
        anchor_id = str(uuid.uuid4())
        current_time = time.time()
        
        expiry_time = None
        if ttl_hours:
            expiry_time = current_time + (ttl_hours * 3600)
        
        anchor = SpatialAnchor(
            id=anchor_id,
            position=position,
            orientation=orientation,
            confidence=confidence,
            timestamp=current_time,
            creator_id=creator_id,
            shared=shared,
            expiry_time=expiry_time
        )
        
        # Store in main registry
        self.anchors[anchor_id] = anchor
        
        # Add to spatial grid for efficient queries
        grid_cell = self._get_grid_cell(position)
        if grid_cell not in self.spatial_grid:
            self.spatial_grid[grid_cell] = []
        self.spatial_grid[grid_cell].append(anchor)
        
        return anchor_id
    
    async def query_anchors(self, query: SpatialQuery, 
                          user_id: str) -> List[SpatialAnchor]:
        """Query spatial anchors near a given position"""
        results = []
        center_cell = self._get_grid_cell(query.position)
        
        # Calculate search radius in grid cells
        search_radius = int(np.ceil(query.radius / self.grid_size))
        nearby_cells = self._get_nearby_cells(center_cell, search_radius)
        
        for cell in nearby_cells:
            if cell in self.spatial_grid:
                for anchor in self.spatial_grid[cell]:
                    # Skip expired anchors
                    if (anchor.expiry_time and 
                        time.time() > anchor.expiry_time):
                        continue
                    
                    # Skip private anchors from other users
                    if not anchor.shared and anchor.creator_id != user_id:
                        continue
                    
                    # Check distance constraint
                    distance = np.linalg.norm(anchor.position - query.position)
                    if distance <= query.radius:
                        # Check confidence constraint
                        if anchor.confidence >= query.min_confidence:
                            results.append((anchor, distance))
        
        # Sort by distance and apply limit
        results.sort(key=lambda x: x[1])
        return [anchor for anchor, _ in results[:query.max_results]]
    
    async def update_anchor_pose(self, anchor_id: str, user_id: str,
                               new_position: np.ndarray, 
                               new_orientation: np.ndarray,
                               confidence: float) -> bool:
        """Update anchor pose with collaborative refinement"""
        if anchor_id not in self.anchors:
            return False
        
        anchor = self.anchors[anchor_id]
        
        # Only owner or high-confidence updates allowed
        if (anchor.creator_id != user_id and 
            confidence <= anchor.confidence + 0.1):
            return False
        
        # Remove from old grid cell
        old_cell = self._get_grid_cell(anchor.position)
        if old_cell in self.spatial_grid:
            self.spatial_grid[old_cell].remove(anchor)
        
        # Update anchor
        anchor.position = new_position
        anchor.orientation = new_orientation
        anchor.confidence = max(anchor.confidence, confidence)
        anchor.timestamp = time.time()
        
        # Add to new grid cell
        new_cell = self._get_grid_cell(new_position)
        if new_cell not in self.spatial_grid:
            self.spatial_grid[new_cell] = []
        self.spatial_grid[new_cell].append(anchor)
        
        return True
    
    async def create_shared_space(self, anchors: List[str], 
                                space_name: str, creator_id: str) -> str:
        """Create a shared spatial context from multiple anchors"""
        space_id = str(uuid.uuid4())
        
        # Validate all anchors exist and are accessible
        space_anchors = []
        for anchor_id in anchors:
            if anchor_id in self.anchors:
                anchor = self.anchors[anchor_id]
                if anchor.shared or anchor.creator_id == creator_id:
                    space_anchors.append(anchor)
        
        if not space_anchors:
            raise ValueError("No valid anchors for shared space")
        
        # Calculate space centroid and bounds
        positions = np.array([anchor.position for anchor in space_anchors])
        centroid = np.mean(positions, axis=0)
        bounds_radius = np.max(np.linalg.norm(positions - centroid, axis=1))
        
        # Store shared space metadata
        space_metadata = {
            'id': space_id,
            'name': space_name,
            'creator_id': creator_id,
            'anchor_ids': anchors,
            'centroid': centroid,
            'radius': bounds_radius,
            'created_at': time.time(),
            'active_users': set()
        }
        
        return space_id
    
    def calculate_pose_interpolation(self, anchor1: SpatialAnchor, 
                                   anchor2: SpatialAnchor,
                                   user_position: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
        """Interpolate pose between two anchors based on user position"""
        # Calculate weights based on distance
        dist1 = np.linalg.norm(user_position - anchor1.position)
        dist2 = np.linalg.norm(user_position - anchor2.position)
        
        total_dist = dist1 + dist2
        if total_dist == 0:
            return anchor1.position, anchor1.orientation
        
        w1 = dist2 / total_dist  # Inverse distance weighting
        w2 = dist1 / total_dist
        
        # Interpolate position
        interpolated_position = w1 * anchor1.position + w2 * anchor2.position
        
        # Interpolate orientation using SLERP
        q1 = Rotation.from_quat(anchor1.orientation)
        q2 = Rotation.from_quat(anchor2.orientation)
        
        # Spherical linear interpolation
        interpolated_rotation = q1.slerp(q2, w2)
        interpolated_orientation = interpolated_rotation.as_quat()
        
        return interpolated_position, interpolated_orientation
    
    async def cleanup_expired_anchors(self):
        """Remove expired anchors from the system"""
        current_time = time.time()
        expired_anchors = []
        
        for anchor_id, anchor in self.anchors.items():
            if anchor.expiry_time and current_time > anchor.expiry_time:
                expired_anchors.append(anchor_id)
        
        for anchor_id in expired_anchors:
            anchor = self.anchors[anchor_id]
            
            # Remove from spatial grid
            grid_cell = self._get_grid_cell(anchor.position)
            if grid_cell in self.spatial_grid:
                self.spatial_grid[grid_cell].remove(anchor)
                
                # Clean up empty cells
                if not self.spatial_grid[grid_cell]:
                    del self.spatial_grid[grid_cell]
            
            # Remove from main registry
            del self.anchors[anchor_id]
        
        return len(expired_anchors)

# Usage example
async def demonstrate_ar_cloud():
    ar_cloud = ARCloudSpatialService(grid_size=5.0)
    
    # Create some spatial anchors
    anchor1_id = await ar_cloud.create_anchor(
        position=np.array([10.0, 2.0, 5.0]),
        orientation=np.array([0, 0, 0, 1]),  # Identity quaternion
        confidence=0.85,
        creator_id="user123",
        shared=True
    )
    
    anchor2_id = await ar_cloud.create_anchor(
        position=np.array([15.0, 2.5, 8.0]),
        orientation=np.array([0, 0.1, 0, 0.995]),
        confidence=0.92,
        creator_id="user456",
        shared=True
    )
    
    # Query nearby anchors
    query = SpatialQuery(
        position=np.array([12.0, 2.2, 6.0]),
        radius=10.0,
        max_results=10
    )
    
    nearby_anchors = await ar_cloud.query_anchors(query, "user789")
    print(f"Found {len(nearby_anchors)} nearby anchors")
    
    # Demonstrate pose interpolation
    user_pos = np.array([12.5, 2.1, 6.5])
    if len(nearby_anchors) >= 2:
        interpolated_pos, interpolated_orient = ar_cloud.calculate_pose_interpolation(
            nearby_anchors[0], nearby_anchors[1], user_pos
        )
        print(f"Interpolated position: {interpolated_pos}")
    
    # Clean up expired anchors
    expired_count = await ar_cloud.cleanup_expired_anchors()
    print(f"Cleaned up {expired_count} expired anchors")

if __name__ == "__main__":
    asyncio.run(demonstrate_ar_cloud())

import WebSocket from 'ws';
import { EventEmitter } from 'events';

interface RenderRequest {
  sessionId: string;
  userId: string;
  viewMatrix: number[];
  projectionMatrix: number[];
  frustum: Frustum;
  timestamp: number;
  qualityProfile: QualityProfile;
}

interface QualityProfile {
  targetFrameRate: number;
  maxLatency: number;
  resolutionScale: number;
  lodBias: number;
  enableRayTracing: boolean;
  enableFoveation: boolean;
}

interface Frustum {
  left: number;
  right: number;
  top: number;
  bottom: number;
  near: number;
  far: number;
}

interface RenderNode {
  id: string;
  location: string;
  gpuCount: number;
  gpuMemory: number;
  currentLoad: number;
  latency: number;
  isAvailable: boolean;
}

class EdgeRenderingService extends EventEmitter {
  private renderNodes: Map<string, RenderNode> = new Map();
  private activeSessions: Map<string, RenderSession> = new Map();
  private loadBalancer: RenderLoadBalancer;
  private qualityManager: AdaptiveQualityManager;

  constructor() {
    super();
    this.loadBalancer = new RenderLoadBalancer();
    this.qualityManager = new AdaptiveQualityManager();
    this.startHealthChecks();
  }

  async processRenderRequest(request: RenderRequest): Promise<void> {
    try {
      // Get or create session
      let session = this.activeSessions.get(request.sessionId);
      if (!session) {
        session = await this.createRenderSession(request.sessionId, request.userId);
        this.activeSessions.set(request.sessionId, session);
      }

      // Update session state
      session.updateViewState(request.viewMatrix, request.projectionMatrix);
      session.updateQualityProfile(request.qualityProfile);

      // Select optimal render node
      const renderNode = await this.loadBalancer.selectRenderNode(
        request.userId,
        session.requirements
      );

      if (!renderNode) {
        throw new Error('No available render nodes');
      }

      // Perform culling and LOD selection
      const renderData = await this.performCulling(
        session.sceneGraph,
        request.frustum,
        request.qualityProfile
      );

      // Submit render job
      const renderJob = await this.submitRenderJob(
        renderNode,
        renderData,
        request.qualityProfile
      );

      // Stream results back to client
      await this.streamRenderResults(session, renderJob);

    } catch (error) {
      console.error('Render request failed:', error);
      this.handleRenderError(request.sessionId, error as Error);
    }
  }

  private async createRenderSession(sessionId: string, userId: string): Promise<RenderSession> {
    const session = new RenderSession(sessionId, userId);
    
    // Initialize session with user's spatial context
    await session.loadSpatialContext();
    await session.loadContentAssets();
    
    // Set up quality adaptation
    this.qualityManager.initializeSession(session);
    
    return session;
  }

  private async performCulling(
    sceneGraph: SceneNode[],
    frustum: Frustum,
    qualityProfile: QualityProfile
  ): Promise<RenderBatch> {
    const visibleObjects: RenderObject[] = [];
    const lodCalculator = new LODCalculator(qualityProfile.lodBias);

    for (const node of sceneGraph) {
      // Frustum culling
      if (this.isInFrustum(node.boundingBox, frustum)) {
        // Occlusion culling (simplified)
        if (!this.isOccluded(node)) {
          // LOD selection
          const lod = lodCalculator.calculateLOD(
            node.position,
            frustum,
            node.lodLevels
          );

          visibleObjects.push({
            node,
            lod,
            priority: this.calculateRenderPriority(node, frustum)
          });
        }
      }
    }

    // Sort by priority for rendering optimization
    visibleObjects.sort((a, b) => b.priority - a.priority);

    return {
      objects: visibleObjects,
      lightData: this.gatherLightData(frustum),
      materialData: this.gatherMaterialData(visibleObjects),
      timestamp: Date.now()
    };
  }

  private async submitRenderJob(
    renderNode: RenderNode,
    renderData: RenderBatch,
    qualityProfile: QualityProfile
  ): Promise<RenderJob> {
    const renderCommand = {
      id: this.generateJobId(),
      nodeId: renderNode.id,
      renderData,
      qualityProfile,
      timestamp: Date.now()
    };

    // Send render command to selected node
    const renderJob = await this.sendRenderCommand(renderNode, renderCommand);
    
    // Track job performance
    renderJob.startTime = Date.now();
    
    return renderJob;
  }

  private async streamRenderResults(session: RenderSession, renderJob: RenderJob): Promise<void> {
    const stream = renderJob.getResultStream();
    
    stream.on('frame', (frameData: FrameData) => {
      // Apply post-processing if needed
      const processedFrame = this.applyPostProcessing(
        frameData,
        session.postProcessingSettings
      );

      // Encode for streaming
      const encodedFrame = this.encodeFrame(
        processedFrame,
        session.encodingSettings
      );

      // Send to client
      session.sendFrame(encodedFrame);
      
      // Update quality metrics
      this.qualityManager.recordFrameMetrics(session.id, {
        renderTime: Date.now() - renderJob.startTime,
        frameSize: encodedFrame.length,
        quality: frameData.quality
      });
    });

    stream.on('complete', () => {
      this.qualityManager.onRenderComplete(session.id);
    });

    stream.on('error', (error: Error) => {
      this.handleRenderError(session.id, error);
    });
  }

  private startHealthChecks(): void {
    setInterval(async () => {
      const healthChecks = Array.from(this.renderNodes.values()).map(
        node => this.checkNodeHealth(node)
      );
      
      await Promise.allSettled(healthChecks);
    }, 5000); // Check every 5 seconds
  }

  private async checkNodeHealth(node: RenderNode): Promise<void> {
    try {
      const startTime = Date.now();
      const healthStatus = await this.pingRenderNode(node.id);
      const latency = Date.now() - startTime;

      node.latency = latency;
      node.currentLoad = healthStatus.cpuUsage;
      node.isAvailable = healthStatus.isHealthy;

      if (!healthStatus.isHealthy) {
        console.warn(`Render node ${node.id} is unhealthy`);
        this.failoverSessions(node.id);
      }
    } catch (error) {
      console.error(`Health check failed for node ${node.id}:`, error);
      node.isAvailable = false;
      this.failoverSessions(node.id);
    }
  }

  private async failoverSessions(failedNodeId: string): Promise<void> {
    const affectedSessions = Array.from(this.activeSessions.values())
      .filter(session => session.renderNodeId === failedNodeId);

    for (const session of affectedSessions) {
      try {
        // Find alternative render node
        const alternativeNode = await this.loadBalancer.selectRenderNode(
          session.userId,
          session.requirements,
          [failedNodeId] // Exclude failed node
        );

        if (alternativeNode) {
          await session.migrateToNode(alternativeNode.id);
          console.log(`Migrated session ${session.id} to node ${alternativeNode.id}`);
        } else {
          console.error(`No alternative node available for session ${session.id}`);
          session.terminate('No available render nodes');
        }
      } catch (error) {
        console.error(`Failover failed for session ${session.id}:`, error);
        session.terminate('Failover failed');
      }
    }
  }

  // Helper methods
  private isInFrustum(boundingBox: BoundingBox, frustum: Frustum): boolean {
    // Frustum culling implementation
    return true; // Simplified
  }

  private isOccluded(node: SceneNode): boolean {
    // Occlusion culling implementation
    return false; // Simplified
  }

  private calculateRenderPriority(node: SceneNode, frustum: Frustum): number {
    // Calculate priority based on distance, size, and importance
    const distance = this.calculateDistance(node.position, frustum);
    const size = node.boundingBox.getSize();
    const importance = node.renderPriority || 1.0;
    
    return (importance * size) / Math.max(distance, 1.0);
  }

  private generateJobId(): string {
    return `job_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  private gatherLightData(frustum: Frustum): LightData {
    // Gather relevant lighting information
    return { lights: [], shadowMaps: [] };
  }

  private gatherMaterialData(objects: RenderObject[]): MaterialData {
    // Gather material and texture data
    return { materials: [], textures: [] };
  }

  private applyPostProcessing(
    frameData: FrameData,
    settings: PostProcessingSettings
  ): ProcessedFrameData {
    // Apply tone mapping, anti-aliasing, etc.
    return frameData as ProcessedFrameData;
  }

  private encodeFrame(
    frameData: ProcessedFrameData,
    settings: EncodingSettings
  ): EncodedFrame {
    // Encode frame for streaming
    return { data: Buffer.alloc(0), metadata: {} } as EncodedFrame;
  }

  private handleRenderError(sessionId: string, error: Error): void {
    const session = this.activeSessions.get(sessionId);
    if (session) {
      session.handleError(error);
    }
    this.emit('renderError', { sessionId, error });
  }
}

class RenderLoadBalancer {
  async selectRenderNode(
    userId: string,
    requirements: RenderRequirements,
    excludeNodes: string[] = []
  ): Promise<RenderNode | null> {
    // Implement load balancing logic
    return null; // Simplified
  }
}

class AdaptiveQualityManager {
  initializeSession(session: RenderSession): void {
    // Initialize quality adaptation for session
  }

  recordFrameMetrics(sessionId: string, metrics: FrameMetrics): void {
    // Record performance metrics
  }

  onRenderComplete(sessionId: string): void {
    // Handle render completion
  }
}

// Type definitions
interface RenderSession {
  id: string;
  userId: string;
  renderNodeId?: string;
  requirements: RenderRequirements;
  sceneGraph: SceneNode[];
  postProcessingSettings: PostProcessingSettings;
  encodingSettings: EncodingSettings;
  
  updateViewState(viewMatrix: number[], projectionMatrix: number[]): void;
  updateQualityProfile(profile: QualityProfile): void;
  loadSpatialContext(): Promise<void>;
  loadContentAssets(): Promise<void>;
  sendFrame(frame: EncodedFrame): void;
  migrateToNode(nodeId: string): Promise<void>;
  terminate(reason: string): void;
  handleError(error: Error): void;
}

interface RenderRequirements {
  minGpuMemory: number;
  preferredLatency: number;
  requiredFeatures: string[];
}

export { EdgeRenderingService };