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

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

@@ -0,0 +1,611 @@
+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([]);
+  });
+});