@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.2

package/src/camera/test/polygon.test.ts

@@ -1,611 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-// Ersetze dies durch deine tatsächlichen Importe
-// import { areDetectionsValid } from './your-module';
-
-// Type definitions
-type ObjectClass = 'person' | 'vehicle' | 'animal' | 'motion' | 'other';
-type ZoneType = 'intersect' | 'contain';
-type ZoneFilter = 'include' | 'exclude';
-type BoundingBox = [number, number, number, number];
-type Point = [number, number];
-
-interface Detection {
-  id?: string;
-  label: ObjectClass;
-  confidence: number;
-  boundingBox: BoundingBox;
-  inputWidth: number;
-  inputHeight: number;
-  origWidth: number;
-  origHeight: number;
-}
-
-interface DetectionZone {
-  name: string;
-  points: Point[];
-  type: ZoneType;
-  filter: ZoneFilter;
-  classes: ObjectClass[];
-  isPrivacyMask: boolean;
-  color: string;
-}
-
-interface CameraDetectionSettings {
-  object: {
-    confidence: number;
-  };
-}
-
-// Mock-Hilfsfunktionen für Tests, angepasst für die neuen Tests
-const convertBoundingBoxToPixels = (detection: Detection): Detection => {
-  // Vereinfacht für Tests
-  return detection;
-};
-
-const convertZonePointsToPixels = (zone: DetectionZone, detection: Detection): DetectionZone => {
-  // Vereinfacht für Tests
-  return zone;
-};
-
-const isBoxContainedInPolygon = (box: BoundingBox, polygon: Point[]): boolean => {
-  // Für Testzwecke: Box innerhalb eines Polygons basierend auf Markerpunkten
-  const centerX = (box[0] + box[2]) / 2;
-  const centerY = (box[1] + box[3]) / 2;
-
-  // Box in Include-Zone (enthalten)
-  if (polygon.some((p) => p[0] === 100 && p[1] === 100)) {
-    return centerX >= 90 && centerX <= 110 && centerY >= 90 && centerY <= 110;
-  }
-
-  // Box in Exclude-Zone (enthalten)
-  else if (polygon.some((p) => p[0] === 200 && p[1] === 200)) {
-    return centerX >= 190 && centerX <= 210 && centerY >= 190 && centerY <= 210;
-  }
-
-  // Box in Privacy-Mask (enthalten)
-  else if (polygon.some((p) => p[0] === 300 && p[1] === 300)) {
-    return centerX >= 290 && centerX <= 310 && centerY >= 290 && centerY <= 310;
-  }
-
-  return false;
-};
-
-const doPolygonsIntersect = (box: BoundingBox, polygon: Point[]): boolean => {
-  // Für Testzwecke: Größerer Bereich für Schnitttest
-  const centerX = (box[0] + box[2]) / 2;
-  const centerY = (box[1] + box[3]) / 2;
-
-  // Für Include-Zone (größerer Bereich für Schnitt)
-  if (polygon.some((p) => p[0] === 100 && p[1] === 100)) {
-    return centerX >= 70 && centerX <= 130 && centerY >= 70 && centerY <= 130;
-  }
-
-  // Für Exclude-Zone (größerer Bereich für Schnitt)
-  else if (polygon.some((p) => p[0] === 200 && p[1] === 200)) {
-    return centerX >= 170 && centerX <= 230 && centerY >= 170 && centerY <= 230;
-  }
-
-  // Für Privacy-Mask
-  else if (polygon.some((p) => p[0] === 300 && p[1] === 300)) {
-    return centerX >= 280 && centerX <= 320 && centerY >= 280 && centerY <= 320;
-  }
-
-  return false;
-};
-
-const isBoxCompletelyOutsidePolygon = (box: BoundingBox, polygon: Point[]): boolean => {
-  // Umkehrung von doPolygonsIntersect
-  return !doPolygonsIntersect(box, polygon);
-};
-
-// Implementation der korrigierten Funktion
-const areDetectionsValid = (detections: Detection[], zones: DetectionZone[], activitySettings: CameraDetectionSettings): Detection[] => {
-  if (zones.length === 0) {
-    return [];
-  }
-
-  // Sammle alle gültigen Klassen
-  const validClasses = new Set<ObjectClass>();
-  for (const zone of zones) {
-    if (zone.classes.length > 0) {
-      zone.classes.forEach((cls) => validClasses.add(cls));
-    }
-  }
-
-  return detections.filter((detection) => {
-    // Prüfe, ob die Detection eine gültige Konfidenz hat
-    if (detection.confidence < activitySettings.object.confidence) {
-      return false;
-    }
-
-    // Prüfe, ob die Detection überhaupt eine gültige Klasse hat
-    // (nur wenn es definierte Klassen gibt)
-    if (!validClasses.has(detection.label)) {
-      return false;
-    }
-
-    const convertedDetection = convertBoundingBoxToPixels(detection);
-
-    // Check if detection is inside a privacy mask
-    for (const zone of zones) {
-      if (!zone.isPrivacyMask) continue;
-
-      const convertedZone = convertZonePointsToPixels(zone, convertedDetection);
-      if (isBoxContainedInPolygon(convertedDetection.boundingBox, convertedZone.points)) {
-        return false;
-      }
-    }
-
-    let hasIncludeZone = false;
-    let isValidForInclude = false;
-    let shouldExclude = false;
-
-    for (const zone of zones) {
-      if (zone.isPrivacyMask) continue;
-
-      if (zone.classes.length > 0 && !zone.classes.includes(detection.label)) {
-        continue;
-      }
-
-      const convertedZone = convertZonePointsToPixels(zone, convertedDetection);
-      const intersects = doPolygonsIntersect(convertedDetection.boundingBox, convertedZone.points);
-      const contained = isBoxContainedInPolygon(convertedDetection.boundingBox, convertedZone.points);
-
-      if (zone.filter === 'include') {
-        hasIncludeZone = true;
-        if ((zone.type === 'contain' && contained) || (zone.type === 'intersect' && (intersects || contained))) {
-          isValidForInclude = true;
-          break;
-        }
-      } else {
-        // exclude
-        if (zone.type === 'contain') {
-          if (!isBoxCompletelyOutsidePolygon(convertedDetection.boundingBox, convertedZone.points)) {
-            shouldExclude = true;
-            break;
-          }
-        } else {
-          // intersect
-          if (intersects || contained) {
-            shouldExclude = true;
-            break;
-          }
-        }
-      }
-    }
-
-    // Wenn die Detection ausgeschlossen werden soll, überspringe sie
-    if (shouldExclude) {
-      return false;
-    }
-
-    // Wenn es Include-Zonen gibt, muss die Detection mindestens eine erfüllen
-    // Wenn es keine Include-Zonen gibt, ist die Detection gültig (da sie nicht ausgeschlossen wurde)
-    return !hasIncludeZone || isValidForInclude;
-  });
-};
-
-describe('Object Detection Validation', () => {
-  let activitySettings: CameraDetectionSettings;
-
-  // Zones
-  let includeContainZone: DetectionZone;
-  let includeIntersectZone: DetectionZone;
-  let excludeContainZone: DetectionZone;
-  let excludeIntersectZone: DetectionZone;
-  let privacyMask: DetectionZone;
-
-  // Detections
-  let personDetectionInInclude: Detection;
-  let animalDetectionNearInclude: Detection;
-  let vehicleDetectionInExclude: Detection;
-  let motionDetectionNearExclude: Detection;
-  let personDetectionInPrivacy: Detection;
-  let otherDetectionHighConfidence: Detection;
-  let otherDetectionLowConfidence: Detection;
-
-  beforeEach(() => {
-    // Setup activity settings
-    activitySettings = {
-      object: {
-        confidence: 0.5,
-      },
-    };
-
-    // Setup zones
-    includeContainZone = {
-      name: 'Include Contain Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ], // Last point is a marker
-      type: 'contain',
-      filter: 'include',
-      classes: ['person', 'vehicle'],
-      isPrivacyMask: false,
-      color: 'green',
-    };
-
-    includeIntersectZone = {
-      name: 'Include Intersect Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ], // Last point is a marker
-      type: 'intersect',
-      filter: 'include',
-      classes: ['animal', 'motion'],
-      isPrivacyMask: false,
-      color: 'blue',
-    };
-
-    excludeContainZone = {
-      name: 'Exclude Contain Zone',
-      points: [
-        [190, 190],
-        [210, 190],
-        [210, 210],
-        [190, 210],
-        [190, 190],
-        [200, 200],
-      ], // Last point is a marker
-      type: 'contain',
-      filter: 'exclude',
-      classes: ['person', 'vehicle'],
-      isPrivacyMask: false,
-      color: 'red',
-    };
-
-    excludeIntersectZone = {
-      name: 'Exclude Intersect Zone',
-      points: [
-        [190, 190],
-        [210, 190],
-        [210, 210],
-        [190, 210],
-        [190, 190],
-        [200, 200],
-      ], // Last point is a marker
-      type: 'intersect',
-      filter: 'exclude',
-      classes: ['animal', 'motion'],
-      isPrivacyMask: false,
-      color: 'orange',
-    };
-
-    privacyMask = {
-      name: 'Privacy Mask',
-      points: [
-        [290, 290],
-        [310, 290],
-        [310, 310],
-        [290, 310],
-        [290, 290],
-        [300, 300],
-      ], // Last point is a marker
-      type: 'contain',
-      filter: 'include',
-      classes: [],
-      isPrivacyMask: true,
-      color: 'black',
-    };
-
-    // Setup detections
-    personDetectionInInclude = {
-      id: '1',
-      label: 'person',
-      confidence: 0.8,
-      boundingBox: [95, 95, 105, 105],
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    animalDetectionNearInclude = {
-      id: '2',
-      label: 'animal',
-      confidence: 0.7,
-      boundingBox: [75, 75, 85, 85], // Near include zone, should be detected by intersect
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    vehicleDetectionInExclude = {
-      id: '3',
-      label: 'vehicle',
-      confidence: 0.9,
-      boundingBox: [195, 195, 205, 205],
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    motionDetectionNearExclude = {
-      id: '4',
-      label: 'motion',
-      confidence: 0.6,
-      boundingBox: [175, 175, 185, 185], // Near exclude zone, should be detected by intersect
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    personDetectionInPrivacy = {
-      id: '5',
-      label: 'person',
-      confidence: 0.95,
-      boundingBox: [295, 295, 305, 305],
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    otherDetectionHighConfidence = {
-      id: '6',
-      label: 'other',
-      confidence: 0.85,
-      boundingBox: [50, 50, 60, 60],
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    otherDetectionLowConfidence = {
-      id: '7',
-      label: 'other',
-      confidence: 0.3, // Below threshold
-      boundingBox: [150, 150, 160, 160],
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-  });
-
-  it('should return empty array when no zones are provided', () => {
-    const result = areDetectionsValid([personDetectionInInclude], [], activitySettings);
-    expect(result).toEqual([]);
-  });
-
-  it('should filter out detections below confidence threshold', () => {
-    const result = areDetectionsValid([otherDetectionLowConfidence], [includeContainZone], activitySettings);
-    expect(result).toEqual([]);
-  });
-
-  it('should only include detections with classes defined in zones', () => {
-    const result = areDetectionsValid([otherDetectionHighConfidence, personDetectionInInclude], [includeContainZone], activitySettings);
-
-    // Only the person detection should be valid, not "other"
-    expect(result.length).toBe(1);
-    expect(result[0].id).toBe('1'); // person detection
-  });
-
-  it('should filter out detections in privacy mask', () => {
-    const result = areDetectionsValid([personDetectionInPrivacy], [privacyMask, includeContainZone], activitySettings);
-    expect(result).toEqual([]);
-  });
-
-  it('should include detections contained in include+contain zone', () => {
-    const result = areDetectionsValid([personDetectionInInclude], [includeContainZone], activitySettings);
-    expect(result.length).toBe(1);
-    expect(result[0].id).toBe('1');
-  });
-
-  it('should include detections intersecting with include+intersect zone', () => {
-    const result = areDetectionsValid([animalDetectionNearInclude], [includeIntersectZone], activitySettings);
-    expect(result.length).toBe(1);
-    expect(result[0].id).toBe('2');
-  });
-
-  it('should exclude detections contained in exclude+contain zone', () => {
-    const result = areDetectionsValid([vehicleDetectionInExclude], [excludeContainZone, includeContainZone], activitySettings);
-    expect(result).toEqual([]);
-  });
-
-  it('should exclude detections intersecting with exclude+intersect zone', () => {
-    const result = areDetectionsValid([motionDetectionNearExclude], [excludeIntersectZone, includeIntersectZone], activitySettings);
-    expect(result).toEqual([]);
-  });
-
-  it('should correctly handle scenario with no include zones', () => {
-    // With only exclude zones, valid classes should still be checked
-    const result = areDetectionsValid(
-      [otherDetectionHighConfidence, personDetectionInInclude],
-      [excludeContainZone], // Only exclude zone with person/vehicle classes
-      activitySettings,
-    );
-
-    // Only person should be valid (in valid classes but not in exclude zone)
-    // "other" should be invalid because it's not in valid classes
-    expect(result.length).toBe(1);
-    expect(result[0].id).toBe('1');
-  });
-
-  it('should correctly handle complex scenario with multiple zones and detections', () => {
-    const zones = [includeContainZone, includeIntersectZone, excludeContainZone, excludeIntersectZone, privacyMask];
-
-    const detections = [
-      personDetectionInInclude, // Valid: in include zone
-      animalDetectionNearInclude, // Valid: intersects with include
-      vehicleDetectionInExclude, // Invalid: in exclude zone
-      motionDetectionNearExclude, // Invalid: intersects with exclude
-      personDetectionInPrivacy, // Invalid: in privacy mask
-      otherDetectionHighConfidence, // Invalid: not in valid classes
-      otherDetectionLowConfidence, // Invalid: below confidence threshold
-    ];
-
-    const result = areDetectionsValid(detections, zones, activitySettings);
-
-    // Only person in include and animal near include should be valid
-    expect(result.length).toBe(2);
-    const ids = result.map((d) => d.id);
-    expect(ids).toContain('1'); // person in include
-    expect(ids).toContain('2'); // animal near include
-  });
-
-  it('should handle empty classes arrays correctly', () => {
-    // Create a zone with no class restrictions
-    const noClassZone: DetectionZone = {
-      name: 'No Class Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ],
-      type: 'contain',
-      filter: 'include',
-      classes: [],
-      isPrivacyMask: false,
-      color: 'purple',
-    };
-
-    const result = areDetectionsValid([otherDetectionHighConfidence], [noClassZone], activitySettings);
-
-    // Should include "other" since no class restrictions
-    expect(result.length).toBe(1);
-    expect(result[0].id).toBe('6');
-  });
-
-  it('should respect include zone type when determining validity', () => {
-    // Create a special include zone that only works with "contain" not "intersect"
-    const strictIncludeZone: DetectionZone = {
-      name: 'Strict Include Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ],
-      type: 'contain', // This is strict - must be contained, not just intersect
-      filter: 'include',
-      classes: ['animal'],
-      isPrivacyMask: false,
-      color: 'yellow',
-    };
-
-    // This detection is near but not contained in the zone
-    const result = areDetectionsValid([animalDetectionNearInclude], [strictIncludeZone], activitySettings);
-
-    // Should not include the animal since it only intersects but doesn't contain
-    expect(result).toEqual([]);
-  });
-
-  it('should correctly handle combined class filters from multiple zones', () => {
-    // Create zones with different class filters
-    const personZone: DetectionZone = {
-      name: 'Person Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ],
-      type: 'contain',
-      filter: 'include',
-      classes: ['person'],
-      isPrivacyMask: false,
-      color: 'blue',
-    };
-
-    const vehicleZone: DetectionZone = {
-      name: 'Vehicle Zone',
-      points: [
-        [120, 120],
-        [140, 120],
-        [140, 140],
-        [120, 140],
-        [120, 120],
-        [130, 130],
-      ],
-      type: 'contain',
-      filter: 'include',
-      classes: ['vehicle'],
-      isPrivacyMask: false,
-      color: 'green',
-    };
-
-    // Test with a detection that doesn't match any zone's position criteria
-    // but has a label that is in the combined valid classes
-    const vehicleDetectionOutsideZones: Detection = {
-      id: '8',
-      label: 'vehicle',
-      confidence: 0.75,
-      boundingBox: [50, 50, 60, 60], // Outside both zones
-      inputWidth: 320,
-      inputHeight: 320,
-      origWidth: 640,
-      origHeight: 360,
-    };
-
-    const result = areDetectionsValid([otherDetectionHighConfidence, vehicleDetectionOutsideZones], [personZone, vehicleZone], activitySettings);
-
-    // Should not include any detections since neither is in a zone,
-    // and both zones are "include" zones requiring detection to be in the zone
-    expect(result).toEqual([]);
-  });
-
-  it('should prioritize exclude zones over include zones', () => {
-    // Create an overlapping include and exclude zone
-    const overlapZoneInclude: DetectionZone = {
-      name: 'Overlap Include Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ],
-      type: 'contain',
-      filter: 'include',
-      classes: ['person'],
-      isPrivacyMask: false,
-      color: 'green',
-    };
-
-    const overlapZoneExclude: DetectionZone = {
-      name: 'Overlap Exclude Zone',
-      points: [
-        [90, 90],
-        [110, 90],
-        [110, 110],
-        [90, 110],
-        [90, 90],
-        [100, 100],
-      ],
-      type: 'contain',
-      filter: 'exclude',
-      classes: ['person'],
-      isPrivacyMask: false,
-      color: 'red',
-    };
-
-    // A person detection in the overlapping zone
-    const result = areDetectionsValid([personDetectionInInclude], [overlapZoneInclude, overlapZoneExclude], activitySettings);
-
-    // Should exclude the person since exclude takes priority
-    expect(result).toEqual([]);
-  });
-});