@ssafy-mhk/e-ver 1.0.2 → 1.0.4

package/dist/garment/garmentFitProfile.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+export interface GarmentBoneBinding {
+    bone: THREE.Bone;
+    restQuaternion: THREE.Quaternion;
+    restScale: THREE.Vector3;
+    restWorldPosition?: THREE.Vector3;
+    restWorldQuaternion?: THREE.Quaternion;
+    restParentWorldQuaternion?: THREE.Quaternion;
+}
+export type GarmentBoneBindingMap = Map<string, GarmentBoneBinding[]>;
+export interface GarmentFitProfile {
+    anchor: THREE.Vector3;
+    shoulderCenter: THREE.Vector3;
+    hipCenter: THREE.Vector3;
+    referenceWidth: number;
+    referenceTorsoHeight: number;
+    trackingHeight: number;
+    boundsCenter: THREE.Vector3;
+    boundsSize: THREE.Vector3;
+    hasBoneAnchors: boolean;
+}
+export declare function captureBoneBinding(bone: THREE.Bone): GarmentBoneBinding;
+export declare function computeGarmentFitProfile(scene: THREE.Group, bones: GarmentBoneBindingMap, fallbackWidth?: number): GarmentFitProfile;
+export declare function resetBoneRotations(bones: GarmentBoneBindingMap): void;

package/dist/garment/poseApplication.d.ts

@@ -0,0 +1,18 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import { type MutableRefObject } from "react";
+import * as THREE from "three";
+import { type LandmarkCoordinateSpace } from "../pose/landmarkPoseSolver";
+import { type GarmentBoneBindingMap } from "./garmentFitProfile";
+export interface PoseApplicationRefs {
+    clockRef: MutableRefObject<THREE.Timer>;
+    prevRotationsRef: MutableRefObject<Map<string, THREE.Quaternion>>;
+}
+interface ApplyLandmarkPoseOptions {
+    coordinateSpace?: LandmarkCoordinateSpace;
+    excludeBones?: Set<string>;
+}
+export declare function usePoseApplicationRefs(): PoseApplicationRefs;
+export declare function applyLandmarkPoseToGarment(landmarks: NormalizedLandmark[], bones: GarmentBoneBindingMap, refs: PoseApplicationRefs, options?: ApplyLandmarkPoseOptions): void;
+export declare function resetPoseState(bones: GarmentBoneBindingMap, refs: PoseApplicationRefs): void;
+export declare function blendBonesToRest(bones: GarmentBoneBindingMap, factor: number, delta: number, onlyBones?: Set<string>): void;
+export {};

package/dist/garment/trackedGarmentMotion.d.ts

@@ -0,0 +1,32 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import * as THREE from "three";
+import { FacingDetector, type FacingState } from "../pose/facingDetector";
+import { YawFreezeController } from "../pose/yawFreezeController";
+import type { GarmentBoneBindingMap, GarmentFitProfile } from "./garmentFitProfile";
+import { type TrackedModelTransformScratch } from "./trackedModelTransform";
+import { type PoseApplicationRefs } from "./poseApplication";
+export interface TrackedGarmentMotionState {
+    transformScratch: TrackedModelTransformScratch;
+    facingDetector: FacingDetector;
+    yawFreezeController: YawFreezeController;
+    displayYaw: number | null;
+    lastFacingState: FacingState | null;
+    hasInitialPosition: boolean;
+}
+export interface UpdateTrackedGarmentMotionParams {
+    fitProfile: GarmentFitProfile;
+    garmentRoot: THREE.Group;
+    boneBindingMap: GarmentBoneBindingMap;
+    poseRefs: PoseApplicationRefs;
+    motionState: TrackedGarmentMotionState;
+    landmarks: NormalizedLandmark[] | null;
+    worldLandmarks?: NormalizedLandmark[] | null;
+    viewportWidth: number;
+    viewportHeight: number;
+    poseFrameWidth?: number;
+    poseFrameHeight?: number;
+    delta: number;
+}
+export declare function createTrackedGarmentMotionState(): TrackedGarmentMotionState;
+export declare function resetTrackedGarmentMotionState(state: TrackedGarmentMotionState): void;
+export declare function updateTrackedGarmentMotion({ fitProfile, garmentRoot, boneBindingMap, poseRefs, motionState, landmarks, worldLandmarks, viewportWidth, viewportHeight, poseFrameWidth, poseFrameHeight, delta, }: UpdateTrackedGarmentMotionParams): FacingState | null;

package/dist/garment/trackedModelTransform.d.ts

@@ -0,0 +1,40 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import * as THREE from "three";
+import type { GarmentFitProfile } from "./garmentFitProfile";
+export interface TrackedModelTransformScratch {
+    leftShoulder: THREE.Vector3;
+    rightShoulder: THREE.Vector3;
+    leftHip: THREE.Vector3;
+    rightHip: THREE.Vector3;
+    shoulderCenter: THREE.Vector3;
+    hipCenter: THREE.Vector3;
+    bodyTop: THREE.Vector3;
+    bodyBottom: THREE.Vector3;
+    anchor: THREE.Vector3;
+    scaledAnchor: THREE.Vector3;
+    position: THREE.Vector3;
+    scale: THREE.Vector3;
+    stabilizedBodyHeightScale: number | null;
+    missingBodyHeightFrames: number;
+    smoothedGlobalScale: number;
+    hasSmoothedGlobalScale: boolean;
+    effectiveYaw: number;
+    previousDepthProxy: number;
+    scaleVelocity: number;
+    smoothedXDeviation: number;
+    smoothedAnchor: THREE.Vector3;
+    hasSmoothedAnchor: boolean;
+}
+export interface TrackedModelTransformOptions {
+    scaleX?: number;
+    scaleY?: number;
+    scaleZ?: number;
+    scaleMultiplier?: number;
+    depthOffset?: number;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    bodyYaw?: number;
+    worldLandmarks?: NormalizedLandmark[] | null;
+}
+export declare function createTrackedModelTransformScratch(): TrackedModelTransformScratch;
+export declare function updateTrackedModelTransform(fitProfile: GarmentFitProfile, landmarks: NormalizedLandmark[], viewportWidth: number, viewportHeight: number, scratch: TrackedModelTransformScratch, options?: TrackedModelTransformOptions): boolean;

package/dist/hooks/useAvatarVariant.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+import { type VRMCompatHumanoid } from "../avatar/VRMCompat";
+import type { GarmentBoneBindingMap } from "../garment/garmentFitProfile";
+export interface UseAvatarVariantParams {
+    url: string;
+}
+export interface UseAvatarVariantResult {
+    scene: THREE.Group;
+    humanoid: VRMCompatHumanoid;
+    bones: GarmentBoneBindingMap;
+}
+export declare function useAvatarVariant({ url, }: UseAvatarVariantParams): UseAvatarVariantResult;

package/dist/hooks/useBodyMeasurer.d.ts

@@ -1,11 +1,20 @@
+export interface BodyMeasurerOptions {
+    wasmUrl?: string;
+    modelUrl?: string;
+    referenceHeightCm?: number;
+    weightKg?: number | null;
+    measurementIntervalMs?: number;
+}
 /**
  * Extracts silhouette, calculates body dimensions periodically (e.g. 1Hz).
  * Evaluates clothing fit.
+ *
+ * `wasmUrl` / `modelUrl` are reserved for future segmentation model integration.
  */
-export declare const useBodyMeasurer: () => {
+export declare const useBodyMeasurer: (_options?: BodyMeasurerOptions) => {
     dimensions: {
-        shoulder: number;
-        chest: number;
-        waist: number;
+        shoulder: number | null;
+        chest: number | null;
+        waist: number | null;
     } | null;
 };

package/dist/hooks/useBodyMeasurer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useBodyPresetSelection.d.ts

@@ -0,0 +1,3 @@
+import type { BodyMeasurements } from "../types/measurement";
+import type { BodyPresetSelectionState, UseBodyPresetSelectionOptions } from "../types/bodyPreset";
+export declare function useBodyPresetSelection(measurements: BodyMeasurements | null, options?: UseBodyPresetSelectionOptions): BodyPresetSelectionState;

package/dist/hooks/useEverFitting.d.ts

@@ -0,0 +1,51 @@
+import type { UseBodyPresetSelectionOptions } from "../types/bodyPreset";
+import type { BodyMorphResult, FitType } from "../types/fitting";
+import type { GarmentScaleParams, MeasurementConfig } from "../types/measurement";
+import { useBodyPresetSelection } from "./useBodyPresetSelection";
+import { useMeasurement } from "./useMeasurement";
+import { type PoseTrackerOptions, usePoseTracker } from "./usePoseTracker";
+import { type UseWebcamOptions, useWebcam } from "./useWebcam";
+export interface EverFittingOptions extends Pick<UseWebcamOptions, "width" | "height" | "facingMode" | "enabled" | "mockMode">, Pick<PoseTrackerOptions, "modelComplexity" | "numPoses" | "minDetectionConfidence" | "minTrackingConfidence" | "outputSegmentationMasks" | "viewportWidth" | "viewportHeight"> {
+    measurementEnabled?: boolean;
+    autoStartMeasurement?: boolean;
+    measurementConfig?: Partial<MeasurementConfig>;
+    bodyPresetOptions?: UseBodyPresetSelectionOptions;
+    fitType?: FitType;
+    garmentScaleHint?: number | null;
+}
+export interface EverFittingResult {
+    videoRef: ReturnType<typeof useWebcam>["videoRef"];
+    webcamReady: boolean;
+    webcamError: string | null;
+    startWebcam: ReturnType<typeof useWebcam>["start"];
+    stopWebcam: ReturnType<typeof useWebcam>["stop"];
+    isTrackerReady: ReturnType<typeof usePoseTracker>["isTrackerReady"];
+    landmarks: ReturnType<typeof usePoseTracker>["landmarks"];
+    worldLandmarks: ReturnType<typeof usePoseTracker>["worldLandmarks"];
+    poseRig: ReturnType<typeof usePoseTracker>["poseRig"];
+    confidence: number;
+    fps: number;
+    isTracking: boolean;
+    drawLandmarks: ReturnType<typeof usePoseTracker>["drawLandmarks"];
+    silhouetteWidths: ReturnType<typeof usePoseTracker>["silhouetteWidths"];
+    poseFrameWidth: number;
+    poseFrameHeight: number;
+    detectedPersonCount: number;
+    lockedPersonId: string | null;
+    trackingQuality: ReturnType<typeof usePoseTracker>["trackingQuality"];
+    config: ReturnType<typeof useMeasurement>["config"];
+    measurements: ReturnType<typeof useMeasurement>["measurements"];
+    sizeRecommendation: ReturnType<typeof useMeasurement>["sizeRecommendation"];
+    garmentScale: ReturnType<typeof useMeasurement>["garmentScale"];
+    finalGarmentScale: GarmentScaleParams;
+    bodyMorphResult: BodyMorphResult | null;
+    isMeasuring: boolean;
+    canMeasure: boolean;
+    startMeasurement: ReturnType<typeof useMeasurement>["startMeasurement"];
+    updateConfig: ReturnType<typeof useMeasurement>["updateConfig"];
+    bodyPresetSelection: ReturnType<typeof useBodyPresetSelection>["selection"];
+    bodyPresetLoading: boolean;
+    bodyPresetError: string | null;
+}
+export type EverFittingRuntimeState = EverFittingResult;
+export declare function useEverFitting(options?: EverFittingOptions): EverFittingResult;

package/dist/hooks/useEverFitting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useEverGeneration.d.ts

@@ -1,13 +1,12 @@
-import { type BodyPresetMatchRequest, type GarmentData } from "../api/EverClient";
+import { type EverClientOptions, type BodyPresetMatchRequest, type GarmentData } from "../api/EverClient";
 export type GenerationStatus = "idle" | "uploading" | "processing" | "ready" | "error";
 /**
  * Coordinates backend-backed model acquisition for the SDK demo flows.
  *
- * `generateAvatar` keeps the legacy call signature for compatibility, but the
- * backend currently exposes body preset matching rather than photo-based avatar
- * synthesis. Blob input therefore resolves to a default preset match.
+ * Accepts an optional `EverClientOptions` to configure apiKey / baseUrl.
+ * For backward compatibility, a plain `string` baseUrl is still accepted.
  */
-export declare function useEverGeneration(baseUrl?: string): {
+export declare function useEverGeneration(options?: string | EverClientOptions): {
     status: GenerationStatus;
     resultUrl: string | null;
     error: string | null;

package/dist/hooks/useEverGeneration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useMeasurement.d.ts

@@ -0,0 +1,19 @@
+import { type BodyMeasurements, type GarmentScaleParams, type MeasurementConfig, type SilhouetteWidths, type SizeRecommendation } from "../types/measurement";
+import type { PoseLandmarkLike } from "../types/pose";
+interface MeasurementInputOptions {
+    silhouetteWidths?: SilhouetteWidths | null;
+    imageWidth?: number;
+    imageHeight?: number;
+}
+interface UseMeasurementResult {
+    measure: (landmarks: PoseLandmarkLike[], options?: MeasurementInputOptions) => void;
+    startMeasurement: () => void;
+    measurements: BodyMeasurements | null;
+    sizeRecommendation: SizeRecommendation | null;
+    garmentScale: GarmentScaleParams | null;
+    isMeasuring: boolean;
+    updateConfig: (config: Partial<MeasurementConfig>) => void;
+    config: MeasurementConfig;
+}
+export declare function useMeasurement(): UseMeasurementResult;
+export type { UseMeasurementResult, MeasurementInputOptions };

package/dist/hooks/usePoseMapper.d.ts

@@ -1,7 +1,8 @@
 import * as THREE from "three";
+import { type PoseLandmarkLike } from "../types/pose";
 /**
  * Custom hook to map MediaPipe 2D/3D landmarks to 3D bones (Quaternions).
  */
 export declare const usePoseMapper: () => {
-    mapPoseToBones: (landmarks: any[], targetBones: Record<string, THREE.Bone>) => void;
+    mapPoseToBones: (landmarks: PoseLandmarkLike[], targetBones: Record<string, THREE.Bone>) => void;
 };

package/dist/hooks/usePoseTracker.d.ts

@@ -1,7 +1,25 @@
-/**
- * Initializes MediaPipe Pose Landmarker (Lite).
- * Connects to the user's webcam feed and outputs real-time skeletal landmarks to the store.
- */
-export declare const usePoseTracker: (videoRef: React.RefObject<HTMLVideoElement | null>) => {
+import { type ModelComplexity } from "../pose/landmarkerFactory";
+import { type PoseState } from "../types/pose";
+import { type TrackingRuntimeState } from "../types/tracking";
+import type { SilhouetteWidths } from "../types/measurement";
+export interface PoseTrackerOptions {
+    enabled?: boolean;
+    modelComplexity?: ModelComplexity;
+    numPoses?: number;
+    minDetectionConfidence?: number;
+    minTrackingConfidence?: number;
+    outputSegmentationMasks?: boolean;
+    viewportWidth?: number;
+    viewportHeight?: number;
+}
+export interface PoseTrackerResult extends PoseState {
     isTrackerReady: boolean;
-};
+    drawLandmarks: (canvas: HTMLCanvasElement) => void;
+    silhouetteWidths: SilhouetteWidths | null;
+    poseFrameWidth: number;
+    poseFrameHeight: number;
+    detectedPersonCount: number;
+    lockedPersonId: string | null;
+    trackingQuality: TrackingRuntimeState["trackingQuality"];
+}
+export declare const usePoseTracker: (videoRef: React.RefObject<HTMLVideoElement | null>, options?: PoseTrackerOptions) => PoseTrackerResult;

package/dist/hooks/usePoseTracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useWebcam.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from "react";
+export interface UseWebcamOptions {
+    width?: number;
+    height?: number;
+    facingMode?: "user" | "environment";
+    enabled?: boolean;
+    mockMode?: boolean;
+    videoRef?: RefObject<HTMLVideoElement | null>;
+    onReadyChange?: (ready: boolean) => void;
+    onErrorChange?: (message: string | null) => void;
+}
+export interface UseWebcamResult {
+    videoRef: RefObject<HTMLVideoElement | null>;
+    isReady: boolean;
+    error: string | null;
+    start: () => Promise<void>;
+    stop: () => void;
+}
+export declare function useWebcam(options?: UseWebcamOptions): UseWebcamResult;

package/dist/hooks/useWebcam.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,11 +1,56 @@
 export * from "./store/useEverStore";
 export * from "./components/EverProvider";
+export * from "./components/ever-context";
 export * from "./components/EverCanvas";
+export * from "./components/EverFittingScene";
+export * from "./components/EverTrackedGarment";
 export * from "./components/CameraView";
 export * from "./components/AvatarModel";
 export * from "./components/GarmentModel";
+export * from "./components/TrackedGarmentPoseDriver";
+export * from "./components/WebcamPlaneBackground";
 export * from "./hooks/usePoseTracker";
 export * from "./hooks/usePoseMapper";
 export * from "./hooks/useBodyMeasurer";
+export * from "./hooks/useMeasurement";
+export * from "./hooks/useWebcam";
+export * from "./hooks/useEverFitting";
+export * from "./hooks/useAvatarVariant";
+export * from "./hooks/useBodyPresetSelection";
 export * from "./api/EverClient";
 export * from "./hooks/useEverGeneration";
+export * from "./types/measurement";
+export * from "./types/pose";
+export * from "./types/tracking";
+export * from "./types/fitting";
+export type { BodyPresetGender, BodyPresetSelectionSource, BodyPresetTaxonomy, BodyPresetMetrics, BodyPresetSelection, BodyPresetSelectionState, BodyPresetSummary, UseBodyPresetSelectionOptions, } from "./types/bodyPreset";
+export * from "./measurement/scaleCalculator";
+export * from "./measurement/sizeRecommender";
+export * from "./measurement/garmentScaler";
+export * from "./measurement/silhouetteExtractor";
+export * from "./bodyPreset/presetSelection";
+export * from "./fitting/bodyFirstFitting";
+export * from "./garment/garmentFitProfile";
+export * from "./garment/fitMotion";
+export * from "./garment/trackedModelTransform";
+export * from "./garment/constants";
+export * from "./garment/poseApplication";
+export * from "./garment/trackedGarmentMotion";
+export * from "./avatar/avatarLoader";
+export * from "./avatar/VRMCompat";
+export * from "./avatar/humanoidBindings";
+export * from "./compositing/videoCover";
+export * from "./pose/coordinateTransform";
+export * from "./pose/landmarkPoseSolver";
+export * from "./pose/poseSolver";
+export * from "./pose/smoothing";
+export * from "./pose/interpolation";
+export * from "./pose/landmarkerFactory";
+export * from "./pose/segmentation";
+export * from "./pose/boneMapping";
+export * from "./pose/facingDetector";
+export * from "./pose/yawFreezeController";
+export * from "./pose/yawDirectionStabilizer";
+export * from "./tracking/personLock";
+export * from "./tracking/trackingState";
+export * from "./tracking/trackingStability";