facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/services/pose-detection/reference-pose.service.ts

@@ -0,0 +1,271 @@
+import { Injectable } from '@angular/core';
+import { OpenposeService, PoseKeypoints } from './openpose.service';
+
+export interface ReferencePose {
+  keypoints: PoseKeypoints;
+  imageData: string; // base64 image
+  timestamp: number;
+  poseDescription: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ReferencePoseService {
+  private referencePose: ReferencePose | null = null;
+
+  constructor(private openposeService: OpenposeService) {}
+
+  /**
+   * Extract pose from uploaded reference image
+   */
+  async extractPoseFromImage(imageFile: File): Promise<ReferencePose> {
+    try {
+      console.log('[Reference Pose] Extracting pose from uploaded image...');
+
+      // Convert file to base64
+      const base64Image = await this.fileToBase64(imageFile);
+
+      // Detect pose in the image
+      const poseKeypoints = await this.openposeService.detectPoseFromBase64(base64Image);
+
+      if (!poseKeypoints) {
+        throw new Error('No pose detected in the uploaded image');
+      }
+
+      // Validate that the pose has visible key points
+      const validation = this.validateReferencePose(poseKeypoints);
+      if (!validation.isValid) {
+        throw new Error(validation.message);
+      }
+
+      // Create reference pose object
+      const referencePose: ReferencePose = {
+        keypoints: poseKeypoints,
+        imageData: base64Image,
+        timestamp: Date.now(),
+        poseDescription: this.generatePoseDescription(poseKeypoints)
+      };
+
+      this.referencePose = referencePose;
+      console.log('[Reference Pose] Pose extracted successfully:', referencePose.poseDescription);
+
+      return referencePose;
+    } catch (error: any) {
+      console.error('[Reference Pose] Failed to extract pose:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Extract pose from base64 image string
+   */
+  async extractPoseFromBase64(base64Image: string): Promise<ReferencePose> {
+    try {
+      console.log('[Reference Pose] Extracting pose from base64 image...');
+
+      // Detect pose in the image
+      const poseKeypoints = await this.openposeService.detectPoseFromBase64(base64Image);
+
+      if (!poseKeypoints) {
+        throw new Error('No pose detected in the image');
+      }
+
+      // Validate that the pose has visible key points
+      const validation = this.validateReferencePose(poseKeypoints);
+      if (!validation.isValid) {
+        throw new Error(validation.message);
+      }
+
+      // Create reference pose object
+      const referencePose: ReferencePose = {
+        keypoints: poseKeypoints,
+        imageData: base64Image,
+        timestamp: Date.now(),
+        poseDescription: this.generatePoseDescription(poseKeypoints)
+      };
+
+      this.referencePose = referencePose;
+      console.log('[Reference Pose] Pose extracted successfully:', referencePose.poseDescription);
+
+      return referencePose;
+    } catch (error: any) {
+      console.error('[Reference Pose] Failed to extract pose:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Validate reference pose has required keypoints
+   */
+  private validateReferencePose(pose: PoseKeypoints): { isValid: boolean; message: string } {
+    // Check overall pose score (lowered threshold for more lenient validation)
+    if (pose.score < 0.15) {
+      return {
+        isValid: false,
+        message: 'Pose detection confidence is too low. Please upload a clearer image showing your full upper body.'
+      };
+    }
+
+    // Check if head keypoints are visible (with lower threshold)
+    const head = this.openposeService.getHeadKeypoints(pose);
+    const headVisible = this.openposeService.isKeypointVisible(head.nose, 0.15) ||
+                       (this.openposeService.isKeypointVisible(head.leftEye, 0.15) &&
+                        this.openposeService.isKeypointVisible(head.rightEye, 0.15));
+
+    if (!headVisible) {
+      return {
+        isValid: false,
+        message: 'Face not clearly visible in the image. Please ensure your face is visible.'
+      };
+    }
+
+    // Check if at least one shoulder OR hand is visible (more lenient - allows hand gestures)
+    const shoulders = this.openposeService.getShoulderKeypoints(pose);
+    // Use lower threshold (0.15) for hand detection
+    const leftWrist = this.openposeService.getKeypoint(pose, 'left_wrist');
+    const rightWrist = this.openposeService.getKeypoint(pose, 'right_wrist');
+    const handsVisible = this.openposeService.isKeypointVisible(leftWrist, 0.15) ||
+                        this.openposeService.isKeypointVisible(rightWrist, 0.15);
+
+    const shouldersVisible = this.openposeService.isKeypointVisible(shoulders.leftShoulder, 0.15) ||
+                            this.openposeService.isKeypointVisible(shoulders.rightShoulder, 0.15);
+
+    // Log detected keypoints for debugging
+    console.log('[Reference Pose] Keypoint visibility:', {
+      headVisible,
+      shouldersVisible,
+      handsVisible,
+      leftWristScore: leftWrist?.score?.toFixed(3),
+      rightWristScore: rightWrist?.score?.toFixed(3),
+      leftShoulderScore: shoulders.leftShoulder?.score?.toFixed(3),
+      rightShoulderScore: shoulders.rightShoulder?.score?.toFixed(3)
+    });
+
+    // Accept pose if either shoulders OR hands are visible (allows close-up hand gestures)
+    if (!shouldersVisible && !handsVisible) {
+      return {
+        isValid: false,
+        message: 'Upper body not clearly visible. Please upload a photo showing your shoulders and arms. Note: MoveNet detects body positions, not hand gestures.'
+      };
+    }
+
+    return {
+      isValid: true,
+      message: handsVisible ? 'Valid pose detected with arms visible' : 'Valid pose detected (shoulders only)'
+    };
+  }
+
+  /**
+   * Generate human-readable pose description
+   */
+  private generatePoseDescription(pose: PoseKeypoints): string {
+    const head = this.openposeService.getHeadKeypoints(pose);
+    const shoulders = this.openposeService.getShoulderKeypoints(pose);
+    const elbows = this.openposeService.getElbowKeypoints(pose);
+
+    // Use lower threshold for wrist detection
+    const leftWrist = this.openposeService.getKeypoint(pose, 'left_wrist');
+    const rightWrist = this.openposeService.getKeypoint(pose, 'right_wrist');
+    const leftWristVisible = this.openposeService.isKeypointVisible(leftWrist, 0.15);
+    const rightWristVisible = this.openposeService.isKeypointVisible(rightWrist, 0.15);
+
+    const descriptions: string[] = [];
+
+    // Check head visibility
+    if (this.openposeService.isKeypointVisible(head.nose, 0.15)) {
+      descriptions.push('Face visible');
+    }
+
+    // Check hand positions with more detail
+    if (leftWristVisible || rightWristVisible) {
+      const handPositions = this.analyzeHandPositionsDetailed(pose, leftWrist, rightWrist, leftWristVisible, rightWristVisible);
+      if (handPositions) {
+        descriptions.push(handPositions);
+      }
+    } else {
+      // Check if shoulders/elbows are visible even without wrists
+      const leftShoulderVisible = this.openposeService.isKeypointVisible(shoulders.leftShoulder, 0.15);
+      const rightShoulderVisible = this.openposeService.isKeypointVisible(shoulders.rightShoulder, 0.15);
+
+      if (leftShoulderVisible || rightShoulderVisible) {
+        descriptions.push('Upper body visible');
+      }
+    }
+
+    return descriptions.length > 0 ? descriptions.join(', ') : 'Pose detected';
+  }
+
+  /**
+   * Analyze hand positions with more detail
+   */
+  private analyzeHandPositionsDetailed(
+    pose: PoseKeypoints,
+    leftWrist: any,
+    rightWrist: any,
+    leftWristVisible: boolean,
+    rightWristVisible: boolean
+  ): string {
+    const shoulders = this.openposeService.getShoulderKeypoints(pose);
+    const elbows = this.openposeService.getElbowKeypoints(pose);
+    const positions: string[] = [];
+
+    // Check left hand position
+    if (leftWristVisible && leftWrist) {
+      if (shoulders.leftShoulder && leftWrist.y < shoulders.leftShoulder.y) {
+        positions.push('Left arm raised');
+      } else if (elbows.leftElbow && leftWrist.y < elbows.leftElbow.y) {
+        positions.push('Left arm extended');
+      } else {
+        positions.push('Left wrist visible');
+      }
+    }
+
+    // Check right hand position
+    if (rightWristVisible && rightWrist) {
+      if (shoulders.rightShoulder && rightWrist.y < shoulders.rightShoulder.y) {
+        positions.push('Right arm raised');
+      } else if (elbows.rightElbow && rightWrist.y < elbows.rightElbow.y) {
+        positions.push('Right arm extended');
+      } else {
+        positions.push('Right wrist visible');
+      }
+    }
+
+    return positions.length > 0 ? positions.join(', ') : '';
+  }
+
+  /**
+   * Get the stored reference pose
+   */
+  getReferencePose(): ReferencePose | null {
+    return this.referencePose;
+  }
+
+  /**
+   * Clear the stored reference pose
+   */
+  clearReferencePose(): void {
+    this.referencePose = null;
+    console.log('[Reference Pose] Reference pose cleared');
+  }
+
+  /**
+   * Convert File to base64 string
+   */
+  private fileToBase64(file: File): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+
+      reader.onload = () => {
+        resolve(reader.result as string);
+      };
+
+      reader.onerror = () => {
+        reject(new Error('Failed to read file'));
+      };
+
+      reader.readAsDataURL(file);
+    });
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/pose-selection.service.spec.ts

@@ -0,0 +1,183 @@
+import { TestBed } from '@angular/core/testing';
+
+import { PoseSelectionService } from './pose-selection.service';
+import { POSE_DEFINITIONS } from '../models/constants/pose-definitions.constant';
+import type { PoseCategory } from '../types/pose-category.type';
+import type { PoseDifficulty } from '../types/pose-difficulty.type';
+import type { DetectionStrategy } from '../types/detection-strategy.type';
+
+describe('PoseSelectionService', () => {
+  let service: PoseSelectionService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [PoseSelectionService]
+    });
+    service = TestBed.inject(PoseSelectionService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('getAllPoses returns all pose definitions', () => {
+    const poses = service.getAllPoses();
+    expect(poses).toEqual(POSE_DEFINITIONS);
+    expect(poses.length).toBeGreaterThan(0);
+  });
+
+  it('getPosesByCategory filters by category', () => {
+    const facePoses = service.getPosesByCategory('face' as PoseCategory);
+    expect(facePoses.every((p) => p.category === 'face')).toBe(true);
+    expect(facePoses.length).toBeLessThanOrEqual(POSE_DEFINITIONS.length);
+  });
+
+  it('getPosesByDifficulty filters by difficulty', () => {
+    const easyPoses = service.getPosesByDifficulty('easy' as PoseDifficulty);
+    expect(easyPoses.every((p) => p.difficulty === 'easy')).toBe(true);
+  });
+
+  it('getPosesByDetectionStrategy filters by strategy', () => {
+    const faceApiPoses = service.getPosesByDetectionStrategy('face-api' as DetectionStrategy);
+    expect(faceApiPoses.every((p) => p.detectionStrategy === 'face-api')).toBe(true);
+  });
+
+  it('selectPose by ID returns true when pose exists', () => {
+    const poseId = POSE_DEFINITIONS[0].id;
+    const result = service.selectPose(poseId);
+    expect(result).toBe(true);
+    const selected = service.getSelectedPose();
+    expect(selected).toBeTruthy();
+    expect(selected!.pose.id).toBe(poseId);
+  });
+
+  it('selectPose by ID returns false when pose not found', () => {
+    const result = service.selectPose(99999);
+    expect(result).toBe(false);
+  });
+
+  it('selectPoseByObject sets selected pose', () => {
+    const pose = POSE_DEFINITIONS[0];
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected).toBeTruthy();
+    expect(selected!.pose).toEqual(pose);
+    expect(selected!.imageUrl).toBe(pose.imagePath);
+  });
+
+  it('getSelectedPose returns null when nothing selected', () => {
+    service.clearSelection();
+    expect(service.getSelectedPose()).toBeNull();
+  });
+
+  it('clearSelection clears the selection', () => {
+    service.selectPose(POSE_DEFINITIONS[0].id);
+    service.clearSelection();
+    expect(service.getSelectedPose()).toBeNull();
+  });
+
+  it('hasSelection returns true when pose selected', () => {
+    service.selectPose(POSE_DEFINITIONS[0].id);
+    expect(service.hasSelection()).toBe(true);
+  });
+
+  it('hasSelection returns false when no selection', () => {
+    service.clearSelection();
+    expect(service.hasSelection()).toBe(false);
+  });
+
+  it('getRandomPose returns a pose from definitions', () => {
+    const pose = service.getRandomPose();
+    expect(pose).toBeTruthy();
+    expect(POSE_DEFINITIONS).toContain(pose);
+  });
+
+  it('getRandomPoses returns requested count', () => {
+    const poses = service.getRandomPoses(3);
+    expect(poses.length).toBe(3);
+    poses.forEach((p) => expect(POSE_DEFINITIONS).toContain(p));
+  });
+
+  it('getRandomPoses caps at available count', () => {
+    const poses = service.getRandomPoses(9999);
+    expect(poses.length).toBeLessThanOrEqual(POSE_DEFINITIONS.length);
+  });
+
+  it('getEasyPoses returns face/head poses with easy difficulty', () => {
+    const poses = service.getEasyPoses();
+    expect(poses.every((p) => p.difficulty === 'easy')).toBe(true);
+    expect(poses.every((p) => p.category === 'face' || p.category === 'head')).toBe(true);
+  });
+
+  it('getAdvancedPoses returns gesture or combined poses', () => {
+    const poses = service.getAdvancedPoses();
+    expect(poses.every((p) => p.category === 'gesture' || p.category === 'combined')).toBe(true);
+  });
+
+  it('searchPoses finds by name', () => {
+    const query = POSE_DEFINITIONS[0].name.toLowerCase().split(' ')[0];
+    const poses = service.searchPoses(query);
+    expect(poses.length).toBeGreaterThan(0);
+    expect(poses.some((p) => p.name.toLowerCase().includes(query))).toBe(true);
+  });
+
+  it('searchPoses finds by description', () => {
+    const poses = service.searchPoses('smile');
+    expect(poses.some((p) => p.description.toLowerCase().includes('smile') || p.name.toLowerCase().includes('smile'))).toBe(true);
+  });
+
+  it('selectedPose$ emits when selection changes', (done) => {
+    service.selectedPose$.subscribe((selected) => {
+      if (selected) {
+        expect(selected.pose.id).toBe(POSE_DEFINITIONS[0].id);
+        done();
+      }
+    });
+    service.selectPose(POSE_DEFINITIONS[0].id);
+  });
+
+  it('selectPoseByObject resolves raw base64 PNG to data URI', () => {
+    const pose = { ...POSE_DEFINITIONS[0], imagePath: 'iVBORw0KGgoAAAANSUhEUg==' };
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe('data:image/png;base64,iVBORw0KGgoAAAANSUhEUg==');
+  });
+
+  it('selectPoseByObject resolves raw base64 JPEG to data URI', () => {
+    const pose = { ...POSE_DEFINITIONS[0], imagePath: '/9j/4AAQSkZJRg==' };
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe('data:image/jpeg;base64,/9j/4AAQSkZJRg==');
+  });
+
+  it('selectPoseByObject passes through data URI unchanged', () => {
+    const dataUri = 'data:image/png;base64,iVBORw0KGgo==';
+    const pose = { ...POSE_DEFINITIONS[0], imagePath: dataUri };
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe(dataUri);
+  });
+
+  it('selectPoseByObject passes through asset paths unchanged', () => {
+    const pose = POSE_DEFINITIONS[0];
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe(pose.imagePath);
+  });
+
+  it('selectPoseByObject passes through http URLs unchanged', () => {
+    const url = 'https://example.com/image.png';
+    const pose = { ...POSE_DEFINITIONS[0], imagePath: url };
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe(url);
+  });
+
+  it('selectPoseByObject prefers imageBlobUrl over imagePath', () => {
+    const blobUrl = 'blob:http://localhost/abc-123';
+    const pose = { ...POSE_DEFINITIONS[0], imageBlobUrl: blobUrl };
+    service.selectPoseByObject(pose);
+    const selected = service.getSelectedPose();
+    expect(selected!.imageUrl).toBe(blobUrl);
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/pose-selection.service.ts

@@ -0,0 +1,179 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { PoseDefinition } from '../interfaces/pose-definition.interface';
+import { PoseCategory } from '../types/pose-category.type';
+import { PoseDifficulty } from '../types/pose-difficulty.type';
+import { DetectionStrategy } from '../types/detection-strategy.type';
+import { POSE_DEFINITIONS } from '../models/constants/pose-definitions.constant';
+import { getPoseById } from '../models/utils/pose.utils';
+
+export interface SelectedPoseInfo {
+  pose: PoseDefinition;
+  imageUrl: string;
+  timestamp: Date;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PoseSelectionService {
+  private selectedPoseSubject = new BehaviorSubject<SelectedPoseInfo | null>(null);
+  public selectedPose$: Observable<SelectedPoseInfo | null> = this.selectedPoseSubject.asObservable();
+
+  constructor() {}
+
+  /**
+   * Get all available poses
+   */
+  getAllPoses(): PoseDefinition[] {
+    return POSE_DEFINITIONS;
+  }
+
+  /**
+   * Get poses filtered by category
+   */
+  getPosesByCategory(category: PoseCategory): PoseDefinition[] {
+    return POSE_DEFINITIONS.filter(pose => pose.category === category);
+  }
+
+  /**
+   * Get poses filtered by difficulty
+   */
+  getPosesByDifficulty(difficulty: PoseDifficulty): PoseDefinition[] {
+    return POSE_DEFINITIONS.filter(pose => pose.difficulty === difficulty);
+  }
+
+  /**
+   * Get poses filtered by detection strategy
+   */
+  getPosesByDetectionStrategy(strategy: DetectionStrategy): PoseDefinition[] {
+    return POSE_DEFINITIONS.filter(pose => pose.detectionStrategy === strategy);
+  }
+
+  /**
+   * Select a pose by ID
+   */
+  selectPose(poseId: number): boolean {
+    const pose = getPoseById(poseId);
+
+    if (!pose) {
+      console.error('[PoseSelectionService] Pose not found:', poseId);
+      return false;
+    }
+
+    const selectedPoseInfo: SelectedPoseInfo = {
+      pose,
+      imageUrl: this.resolveImageUrl(pose.imageBlobUrl || pose.imagePath),
+      timestamp: new Date()
+    };
+
+    this.selectedPoseSubject.next(selectedPoseInfo);
+    return true;
+  }
+
+  /**
+   * Select a pose by object
+   */
+  selectPoseByObject(pose: PoseDefinition): void {
+    const selectedPoseInfo: SelectedPoseInfo = {
+      pose,
+      imageUrl: this.resolveImageUrl(pose.imageBlobUrl || pose.imagePath),
+      timestamp: new Date()
+    };
+
+    this.selectedPoseSubject.next(selectedPoseInfo);
+  }
+
+  /**
+   * Resolve an image source to a renderable URL.
+   * Handles: full URLs, data URIs, relative asset paths, and raw base64 strings.
+   */
+  private resolveImageUrl(src: string): string {
+    if (!src) return '';
+    if (src.startsWith('data:') || src.startsWith('blob:') || src.startsWith('http://') || src.startsWith('https://') || src.startsWith('./')) {
+      return src;
+    }
+    const base64Match = this.detectBase64Mime(src);
+    if (base64Match) {
+      return `data:${base64Match};base64,${src}`;
+    }
+    return src;
+  }
+
+  private detectBase64Mime(src: string): string | null {
+    if (src.startsWith('iVBOR')) return 'image/png';
+    if (src.startsWith('/9j/')) return 'image/jpeg';
+    if (src.startsWith('R0lGOD')) return 'image/gif';
+    if (src.startsWith('UklGR')) return 'image/webp';
+    if (src.length > 100 && /^[A-Za-z0-9+/=]+$/.test(src.substring(0, 64))) return 'image/png';
+    return null;
+  }
+
+  /**
+   * Get currently selected pose
+   */
+  getSelectedPose(): SelectedPoseInfo | null {
+    return this.selectedPoseSubject.value;
+  }
+
+  /**
+   * Clear selected pose
+   */
+  clearSelection(): void {
+    this.selectedPoseSubject.next(null);
+  }
+
+  /**
+   * Check if a pose is currently selected
+   */
+  hasSelection(): boolean {
+    return this.selectedPoseSubject.value !== null;
+  }
+
+  /**
+   * Get random pose
+   */
+  getRandomPose(): PoseDefinition {
+    const randomIndex = Math.floor(Math.random() * POSE_DEFINITIONS.length);
+    return POSE_DEFINITIONS[randomIndex];
+  }
+
+  /**
+   * Get random poses by count
+   */
+  getRandomPoses(count: number): PoseDefinition[] {
+    const shuffled = [...POSE_DEFINITIONS].sort(() => 0.5 - Math.random());
+    return shuffled.slice(0, Math.min(count, POSE_DEFINITIONS.length));
+  }
+
+  /**
+   * Get poses suitable for easy verification
+   */
+  getEasyPoses(): PoseDefinition[] {
+    return POSE_DEFINITIONS.filter(
+      pose => pose.difficulty === 'easy' &&
+      (pose.category === 'face' || pose.category === 'head')
+    );
+  }
+
+  /**
+   * Get poses suitable for advanced verification
+   */
+  getAdvancedPoses(): PoseDefinition[] {
+    return POSE_DEFINITIONS.filter(
+      pose => pose.category === 'gesture' || pose.category === 'combined'
+    );
+  }
+
+  /**
+   * Search poses by name or description
+   */
+  searchPoses(query: string): PoseDefinition[] {
+    const lowerQuery = query.toLowerCase();
+    return POSE_DEFINITIONS.filter(
+      pose =>
+        pose.name.toLowerCase().includes(lowerQuery) ||
+        pose.description.toLowerCase().includes(lowerQuery)
+    );
+  }
+}