@monkvision/inspection-capture-web 4.5.6 → 4.6.0

package/lib/VideoCapture/VideoCaptureProcessing/VideoCaptureProcessing.styles.js

@@ -0,0 +1,60 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVideoCaptureProcessingStyles = exports.styles = void 0;
+var common_1 = require("@monkvision/common");
+exports.styles = {
+    container: {
+        width: '100%',
+        display: 'flex',
+        alignSelf: 'stretch',
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+        flexDirection: 'column',
+    },
+    labelContainer: {
+        width: '80%',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        padding: '0 8px 8px 8px',
+        fontSize: 14,
+    },
+    percentage: {
+        fontFamily: 'monospace',
+    },
+    progressBarContainer: {
+        width: '80%',
+        borderRadius: 9999,
+        borderStyle: 'solid',
+        borderWidth: 1,
+    },
+    progressBar: {
+        height: 10,
+        borderRadius: 9999,
+    },
+    errorMessage: {
+        padding: '0 16px',
+        textAlign: 'center',
+    },
+};
+function useVideoCaptureProcessingStyles(progress) {
+    var palette = (0, common_1.useMonkTheme)().palette;
+    return {
+        containerStyle: __assign(__assign({}, exports.styles['container']), { color: palette.text.primary }),
+        progressBarContainerStyle: __assign(__assign({}, exports.styles['progressBarContainer']), { borderColor: palette.primary.dark }),
+        progressBarStyle: __assign(__assign({}, exports.styles['progressBar']), { backgroundColor: palette.primary.dark, width: "".concat(progress * 100, "%") }),
+    };
+}
+exports.useVideoCaptureProcessingStyles = useVideoCaptureProcessingStyles;

package/lib/VideoCapture/VideoCaptureProcessing/VideoCaptureProcessing.types.d.ts

@@ -0,0 +1,34 @@
+import { LoadingState } from '@monkvision/common';
+/**
+ * Props accepted by the VideoCaptureProcessing component.
+ */
+export interface VideoCaptureProcessingProps {
+    /**
+     * The inspection ID.
+     */
+    inspectionId: string;
+    /**
+     * The number of frames that have successfully been processed and added to the upload queue.
+     */
+    processedFrames: number;
+    /**
+     * The total number of frames added to the processing queue.
+     */
+    totalProcessingFrames: number;
+    /**
+     * The number of frames that have successfully been uploaded to the API.
+     */
+    uploadedFrames: number;
+    /**
+     * The total number of frames added to the uploading queue.
+     */
+    totalUploadingFrames: number;
+    /**
+     * Loading state for the done button.
+     */
+    loading: LoadingState;
+    /**
+     * Callback called when the user presses the confirm button.
+     */
+    onComplete?: () => void;
+}

package/lib/VideoCapture/VideoCaptureProcessing/VideoCaptureProcessing.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/VideoCapture/VideoCaptureProcessing/index.d.ts

@@ -0,0 +1,2 @@
+export { VideoCaptureProcessing } from './VideoCaptureProcessing';
+export { type VideoCaptureProcessingProps } from './VideoCaptureProcessing.types';

package/lib/VideoCapture/VideoCaptureProcessing/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCaptureProcessing = void 0;
+var VideoCaptureProcessing_1 = require("./VideoCaptureProcessing");
+Object.defineProperty(exports, "VideoCaptureProcessing", { enumerable: true, get: function () { return VideoCaptureProcessing_1.VideoCaptureProcessing; } });

package/lib/VideoCapture/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useVehicleWalkaround';
+export * from './useVideoRecording';
+export * from './useFrameSelection';
+export * from './useVideoUploadQueue';
+export * from './useFastMovementsDetection';

package/lib/VideoCapture/hooks/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useVehicleWalkaround"), exports);
+__exportStar(require("./useVideoRecording"), exports);
+__exportStar(require("./useFrameSelection"), exports);
+__exportStar(require("./useVideoUploadQueue"), exports);
+__exportStar(require("./useFastMovementsDetection"), exports);

package/lib/VideoCapture/hooks/useFastMovementsDetection/fastMovementsDetection.d.ts

@@ -0,0 +1,18 @@
+import { DeviceRotation } from '@monkvision/types';
+/**
+ * Enumeration of the different fast movements that can be detected.
+ */
+export declare enum FastMovementType {
+    /**
+     * The user is walking too fast around the vehicle.
+     */
+    WALKING_TOO_FAST = "walking_too_fast",
+    /**
+     * The user is shaking their phone too much.
+     */
+    PHONE_SHAKING = "phone_shaking"
+}
+/**
+ * Function used to detect fast user movements between DeviceOrientationEvent emissions.
+ */
+export declare function detectFastMovements(rotation: DeviceRotation, previousRotation: DeviceRotation): FastMovementType | null;

package/lib/VideoCapture/hooks/useFastMovementsDetection/fastMovementsDetection.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFastMovements = exports.FastMovementType = void 0;
+var SMOOTH_MOVEMENT_FACTOR = 0.98;
+var ALPHA_DETECTION_MIN = 2.5;
+var ALPHA_DETECTION_MAX = 179;
+var BETA_DETECTION_MIN = 4;
+var BETA_DETECTION_MAX = 89;
+var GAMMA_DETECTION_MIN = 4;
+var GAMMA_DETECTION_MAX = 89;
+/**
+ * Enumeration of the different fast movements that can be detected.
+ */
+var FastMovementType;
+(function (FastMovementType) {
+    /**
+     * The user is walking too fast around the vehicle.
+     */
+    FastMovementType["WALKING_TOO_FAST"] = "walking_too_fast";
+    /**
+     * The user is shaking their phone too much.
+     */
+    FastMovementType["PHONE_SHAKING"] = "phone_shaking";
+})(FastMovementType = exports.FastMovementType || (exports.FastMovementType = {}));
+/**
+ * Function used to detect fast user movements between DeviceOrientationEvent emissions.
+ */
+function detectFastMovements(rotation, previousRotation) {
+    var alpha = rotation.alpha, beta = rotation.beta, gamma = rotation.gamma;
+    var prevAlpha = previousRotation.alpha, prevBeta = previousRotation.beta, prevGamma = previousRotation.gamma;
+    var alphaSpeed = Math.abs(alpha - prevAlpha) * SMOOTH_MOVEMENT_FACTOR;
+    var betaSpeed = Math.abs(beta - prevBeta) * SMOOTH_MOVEMENT_FACTOR;
+    var gammaSpeed = Math.abs(gamma - prevGamma) * SMOOTH_MOVEMENT_FACTOR;
+    if (prevBeta !== 0 && betaSpeed > BETA_DETECTION_MIN && betaSpeed < BETA_DETECTION_MAX) {
+        return FastMovementType.PHONE_SHAKING;
+    }
+    if (prevGamma !== 0 && gammaSpeed > GAMMA_DETECTION_MIN && gammaSpeed < GAMMA_DETECTION_MAX) {
+        return FastMovementType.PHONE_SHAKING;
+    }
+    if (prevAlpha !== 0 && alphaSpeed > ALPHA_DETECTION_MIN && alphaSpeed < ALPHA_DETECTION_MAX) {
+        return FastMovementType.WALKING_TOO_FAST;
+    }
+    return null;
+}
+exports.detectFastMovements = detectFastMovements;

package/lib/VideoCapture/hooks/useFastMovementsDetection/index.d.ts

@@ -0,0 +1,2 @@
+export { FastMovementType } from './fastMovementsDetection';
+export * from './useFastMovementsDetection';

package/lib/VideoCapture/hooks/useFastMovementsDetection/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastMovementType = void 0;
+var fastMovementsDetection_1 = require("./fastMovementsDetection");
+Object.defineProperty(exports, "FastMovementType", { enumerable: true, get: function () { return fastMovementsDetection_1.FastMovementType; } });
+__exportStar(require("./useFastMovementsDetection"), exports);

package/lib/VideoCapture/hooks/useFastMovementsDetection/useFastMovementsDetection.d.ts

@@ -0,0 +1,34 @@
+import { VideoCaptureAppConfig } from '@monkvision/types';
+import { FastMovementType } from './fastMovementsDetection';
+/**
+ * Params accepted by the useFastMovementsDetection hook.
+ */
+export interface UseFastMovementsDetectionParams extends Required<Pick<VideoCaptureAppConfig, 'enableFastWalkingWarning' | 'enablePhoneShakingWarning' | 'fastWalkingWarningCooldown' | 'phoneShakingWarningCooldown'>> {
+    /**
+     * Boolean indicating if the video is currently recording or not.
+     */
+    isRecording: boolean;
+}
+/**
+ * Handle used to manage the fast movements warning displayed on the screen to the user.
+ */
+export interface FastMovementsDetectionHandle {
+    /**
+     * Event listener for DeviceOrientationEvents.
+     */
+    onDeviceOrientationEvent: (event: DeviceOrientationEvent) => void;
+    /**
+     * The type of fast movements warning that should be displayed to the user. If this value is null, no warning should
+     * be displayed.
+     */
+    fastMovementsWarning: FastMovementType | null;
+    /**
+     * Callback called when the user dismisses the currently displayed fast movements warning.
+     */
+    onWarningDismiss: () => void;
+}
+/**
+ * Custom hook used to display warnings to the user when they walk too fast around the car or shake their phone too
+ * much.
+ */
+export declare function useFastMovementsDetection({ isRecording, enableFastWalkingWarning, enablePhoneShakingWarning, fastWalkingWarningCooldown, phoneShakingWarningCooldown, }: UseFastMovementsDetectionParams): FastMovementsDetectionHandle;

package/lib/VideoCapture/hooks/useFastMovementsDetection/useFastMovementsDetection.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFastMovementsDetection = void 0;
+var react_1 = require("react");
+var common_1 = require("@monkvision/common");
+var fastMovementsDetection_1 = require("./fastMovementsDetection");
+/**
+ * Custom hook used to display warnings to the user when they walk too fast around the car or shake their phone too
+ * much.
+ */
+function useFastMovementsDetection(_a) {
+    var _b;
+    var isRecording = _a.isRecording, enableFastWalkingWarning = _a.enableFastWalkingWarning, enablePhoneShakingWarning = _a.enablePhoneShakingWarning, fastWalkingWarningCooldown = _a.fastWalkingWarningCooldown, phoneShakingWarningCooldown = _a.phoneShakingWarningCooldown;
+    var _c = (0, react_1.useState)(null), fastMovementsWarning = _c[0], setFastMovementsWarning = _c[1];
+    var lastRotation = (0, react_1.useRef)({ alpha: 0, beta: 0, gamma: 0 });
+    var warningTimestamps = (0, react_1.useRef)((_b = {},
+        _b[fastMovementsDetection_1.FastMovementType.WALKING_TOO_FAST] = 0,
+        _b[fastMovementsDetection_1.FastMovementType.PHONE_SHAKING] = 0,
+        _b));
+    var isWarningEnabled = (0, react_1.useCallback)(function (type) {
+        switch (type) {
+            case fastMovementsDetection_1.FastMovementType.WALKING_TOO_FAST:
+                return enableFastWalkingWarning;
+            case fastMovementsDetection_1.FastMovementType.PHONE_SHAKING:
+                return enablePhoneShakingWarning;
+            default:
+                return false;
+        }
+    }, [enableFastWalkingWarning, enablePhoneShakingWarning]);
+    var getWarningCooldown = (0, react_1.useCallback)(function (type) {
+        switch (type) {
+            case fastMovementsDetection_1.FastMovementType.WALKING_TOO_FAST:
+                return fastWalkingWarningCooldown;
+            case fastMovementsDetection_1.FastMovementType.PHONE_SHAKING:
+                return phoneShakingWarningCooldown;
+            default:
+                return Infinity;
+        }
+    }, [fastWalkingWarningCooldown, phoneShakingWarningCooldown]);
+    var onDeviceOrientationEvent = (0, react_1.useCallback)(function (event) {
+        var _a, _b, _c;
+        var alpha = (_a = event.alpha) !== null && _a !== void 0 ? _a : 0;
+        var beta = (_b = event.beta) !== null && _b !== void 0 ? _b : 0;
+        var gamma = (_c = event.gamma) !== null && _c !== void 0 ? _c : 0;
+        if (isRecording) {
+            var now = Date.now();
+            var type = (0, fastMovementsDetection_1.detectFastMovements)({ alpha: alpha, beta: beta, gamma: gamma }, lastRotation.current);
+            if (type &&
+                isWarningEnabled(type) &&
+                Date.now() - warningTimestamps.current[type] > getWarningCooldown(type)) {
+                setFastMovementsWarning(type);
+                warningTimestamps.current[type] = now;
+            }
+        }
+        lastRotation.current = { alpha: alpha, beta: beta, gamma: gamma };
+    }, [isRecording, isWarningEnabled, getWarningCooldown]);
+    var onWarningDismiss = (0, react_1.useCallback)(function () { return setFastMovementsWarning(null); }, []);
+    return (0, common_1.useObjectMemo)({
+        onDeviceOrientationEvent: onDeviceOrientationEvent,
+        fastMovementsWarning: fastMovementsWarning,
+        onWarningDismiss: onWarningDismiss,
+    });
+}
+exports.useFastMovementsDetection = useFastMovementsDetection;

package/lib/VideoCapture/hooks/useFrameSelection/index.d.ts

@@ -0,0 +1 @@
+export * from './useFrameSelection';

package/lib/VideoCapture/hooks/useFrameSelection/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useFrameSelection"), exports);

package/lib/VideoCapture/hooks/useFrameSelection/laplaceScores.d.ts

@@ -0,0 +1,16 @@
+export interface LaplaceScores {
+    mean: number;
+    std: number;
+}
+/**
+ * This function calculates the Laplace Scores for a given pixel array. This score can be used to get a rough estimate
+ * of the blurriness of the picture.
+ *
+ * Picture A is less blurry than picture B if :
+ *   calculateLaplaceScores(A).std > calculateLaplaceScores(B).std
+ *
+ * ***WARNING : To save up memory space, the pixels of the array are modified in place!! Before using this function, be
+ * sure to make a copy of the array using the `array.slice()` method (you might have performance issues if you use any
+ * other method for the duplication of the array).***
+ */
+export declare function calculateLaplaceScores(pixels: Uint8ClampedArray, width: number, height: number): LaplaceScores;

package/lib/VideoCapture/hooks/useFrameSelection/laplaceScores.js

@@ -0,0 +1,62 @@
+"use strict";
+/* eslint-disable no-param-reassign */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateLaplaceScores = void 0;
+/**
+ * This function calculates the Laplace Scores for a given pixel array. This score can be used to get a rough estimate
+ * of the blurriness of the picture.
+ *
+ * Picture A is less blurry than picture B if :
+ *   calculateLaplaceScores(A).std > calculateLaplaceScores(B).std
+ *
+ * ***WARNING : To save up memory space, the pixels of the array are modified in place!! Before using this function, be
+ * sure to make a copy of the array using the `array.slice()` method (you might have performance issues if you use any
+ * other method for the duplication of the array).***
+ */
+function calculateLaplaceScores(pixels, width, height) {
+    for (var i = 0; i < pixels.length; i += 4) {
+        pixels[i] = 127;
+        pixels[i + 2] = 0;
+    }
+    var kernel = [
+        [0, 1, 0],
+        [1, -4, 1],
+        [0, 1, 0],
+    ];
+    var squareSize = Math.round((0.8 * Math.min(height, width)) / 2) * 2;
+    var yMin = (height - squareSize) / 2;
+    var xMin = (width - squareSize) / 2;
+    for (var y = yMin + 1; y < yMin + squareSize - 1; y++) {
+        for (var x = xMin + 1; x < xMin + squareSize - 1; x++) {
+            var sum = 127;
+            var i = (y * width + x) * 4;
+            for (var ky = -1; ky <= 1; ky++) {
+                for (var kx = -1; kx <= 1; kx++) {
+                    var neighborIndex = ((y + ky) * width + (x + kx)) * 4;
+                    var neighborGreen = pixels[neighborIndex + 1];
+                    sum += kernel[ky + 1][kx + 1] * neighborGreen;
+                }
+            }
+            pixels[i] = sum;
+        }
+    }
+    var laplaceSum = 0;
+    for (var y = yMin + 1; y < yMin + squareSize - 1; y++) {
+        for (var x = xMin + 1; x < xMin + squareSize - 1; x++) {
+            var i = (y * width + x) * 4;
+            laplaceSum += pixels[i];
+        }
+    }
+    var laplaceMean = laplaceSum / ((squareSize - 2) * (squareSize - 2));
+    var se = 0;
+    for (var y = yMin + 1; y < yMin + squareSize - 1; y++) {
+        for (var x = xMin + 1; x < xMin + squareSize - 1; x++) {
+            var i = (y * width + x) * 4;
+            var diff = pixels[i] - laplaceMean;
+            se += diff * diff;
+        }
+    }
+    var laplaceStd = Math.sqrt(se / ((squareSize - 2) * (squareSize - 2)));
+    return { mean: laplaceMean, std: laplaceStd };
+}
+exports.calculateLaplaceScores = calculateLaplaceScores;

package/lib/VideoCapture/hooks/useFrameSelection/useFrameSelection.d.ts

@@ -0,0 +1,43 @@
+import { MonkPicture } from '@monkvision/types';
+import { CameraHandle } from '@monkvision/camera-web';
+/**
+ * Params accepted by the useFrameSelection hook.
+ */
+export interface UseFrameSelectionParams {
+    /**
+     * The camera handle.
+     */
+    handle: CameraHandle;
+    /**
+     * Interval (in milliseconds) at which camera frames should be taken.
+     */
+    frameSelectionInterval: number;
+    /**
+     * Callback called when a frame has been selected and should be uploaded to the API.
+     */
+    onFrameSelected?: (picture: MonkPicture) => void;
+}
+/**
+ * Handle used to manage the frame selection feature.
+ */
+export interface FrameSelectionHandle {
+    /**
+     * The number of frames that have successfully been processed and added to the upload queue.
+     */
+    processedFrames: number;
+    /**
+     * The total number of frames added to the processing queue.
+     */
+    totalProcessingFrames: number;
+    /**
+     * Callback called when a video frame should be captured.
+     */
+    onCaptureVideoFrame: () => void;
+}
+/**
+ * Custom hook used to manage the video frame selection. Basically, every time a camera screenshot is taken, it is added
+ * to the frame selection processing queue. The blurriness score of the screenshot is calculated, and the best video
+ * frame (the less blurry one) is always stored in memory. Finally, every `frameSelectionInterval` milliseconds, the
+ * best video frame is "selected" (to be uploaded to the API) and the process resets.
+ */
+export declare function useFrameSelection({ handle, frameSelectionInterval, onFrameSelected, }: UseFrameSelectionParams): FrameSelectionHandle;

package/lib/VideoCapture/hooks/useFrameSelection/useFrameSelection.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFrameSelection = void 0;
+var react_1 = require("react");
+var common_1 = require("@monkvision/common");
+var monitoring_1 = require("@monkvision/monitoring");
+var laplaceScores_1 = require("./laplaceScores");
+/**
+ * Custom hook used to manage the video frame selection. Basically, every time a camera screenshot is taken, it is added
+ * to the frame selection processing queue. The blurriness score of the screenshot is calculated, and the best video
+ * frame (the less blurry one) is always stored in memory. Finally, every `frameSelectionInterval` milliseconds, the
+ * best video frame is "selected" (to be uploaded to the API) and the process resets.
+ */
+function useFrameSelection(_a) {
+    var handle = _a.handle, frameSelectionInterval = _a.frameSelectionInterval, onFrameSelected = _a.onFrameSelected;
+    var bestScore = (0, react_1.useRef)(null);
+    var bestFrame = (0, react_1.useRef)(null);
+    var handleError = (0, monitoring_1.useMonitoring)().handleError;
+    var processingQueue = (0, common_1.useQueue)(function (image) {
+        return new Promise(function (resolve) {
+            // Note : Other array-copying methods might result in performance issues
+            var imagePixelsCopy = image.data.slice();
+            var laplaceScores = (0, laplaceScores_1.calculateLaplaceScores)(imagePixelsCopy, image.width, image.height);
+            if (bestScore.current === null || laplaceScores.std > bestScore.current) {
+                bestScore.current = laplaceScores.std;
+                bestFrame.current = image;
+            }
+            resolve();
+        });
+    }, { storeFailedItems: false });
+    var onCaptureVideoFrame = (0, react_1.useCallback)(function () {
+        processingQueue.push(handle.getImageData());
+    }, [processingQueue.push]);
+    (0, common_1.useInterval)(function () {
+        if (bestFrame.current !== null) {
+            handle
+                .compressImage(bestFrame.current)
+                .then(function (picture) { return onFrameSelected === null || onFrameSelected === void 0 ? void 0 : onFrameSelected(picture); })
+                .catch(handleError);
+        }
+        bestScore.current = null;
+        bestFrame.current = null;
+    }, frameSelectionInterval);
+    return (0, common_1.useObjectMemo)({
+        processedFrames: processingQueue.totalItems - processingQueue.processingCount,
+        totalProcessingFrames: processingQueue.totalItems,
+        onCaptureVideoFrame: onCaptureVideoFrame,
+    });
+}
+exports.useFrameSelection = useFrameSelection;

package/lib/VideoCapture/hooks/useVehicleWalkaround.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Params passed to the useVehicleWalkaround hook.
+ */
+export interface UseVehicleWalkaroundParams {
+    /**
+     * The alpha value of the device orientation.
+     */
+    alpha: number;
+}
+/**
+ * Handle returned by the useVehicleWalkaround hook to manage the VehicleWalkaround feature.
+ */
+export interface VehicleWalkaroundHandle {
+    /**
+     * Callback called at the start of the recording, to set the initial alpha position of the user.
+     */
+    startWalkaround: () => void;
+    /**
+     * The current position of the user around the vehicle (between 0 and 360).
+     */
+    walkaroundPosition: number;
+}
+/**
+ * Custom hook used to manage the vehicle walkaround tracking.
+ */
+export declare function useVehicleWalkaround({ alpha, }: UseVehicleWalkaroundParams): VehicleWalkaroundHandle;

package/lib/VideoCapture/hooks/useVehicleWalkaround.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVehicleWalkaround = void 0;
+var react_1 = require("react");
+var common_1 = require("@monkvision/common");
+/**
+ * Custom hook used to manage the vehicle walkaround tracking.
+ */
+function useVehicleWalkaround(_a) {
+    var alpha = _a.alpha;
+    var _b = (0, react_1.useState)(null), startingAlpha = _b[0], setStartingAlpha = _b[1];
+    var _c = (0, react_1.useState)(45), checkpoint = _c[0], setCheckpoint = _c[1];
+    var _d = (0, react_1.useState)(90), nextCheckpoint = _d[0], setNextCheckpoint = _d[1];
+    var walkaroundPosition = (0, react_1.useMemo)(function () {
+        if (!startingAlpha) {
+            return 0;
+        }
+        var diff = startingAlpha - alpha;
+        var position = diff < 0 ? 360 + diff : diff;
+        var newWalkaroundPosition = position <= nextCheckpoint ? position : 0;
+        if (nextCheckpoint === 405 && newWalkaroundPosition < 180) {
+            return 359;
+        }
+        return newWalkaroundPosition;
+    }, [startingAlpha, alpha, nextCheckpoint]);
+    var startWalkaround = (0, react_1.useCallback)(function () {
+        setStartingAlpha(alpha);
+        setCheckpoint(45);
+        setNextCheckpoint(90);
+    }, [alpha]);
+    (0, react_1.useEffect)(function () {
+        if (walkaroundPosition >= checkpoint) {
+            setCheckpoint(nextCheckpoint);
+            setNextCheckpoint(function (value) { return value + 45; });
+        }
+    }, [walkaroundPosition, checkpoint, nextCheckpoint]);
+    return (0, common_1.useObjectMemo)({ startWalkaround: startWalkaround, walkaroundPosition: walkaroundPosition });
+}
+exports.useVehicleWalkaround = useVehicleWalkaround;