react-native-nitro-pose-exercises 1.1.7 → 1.1.9

package/android/src/main/java/com/margelo/nitro/nitroposeexercises/NitroPoseExercises.kt

@@ -292,19 +292,23 @@ private fun processExerciseLogic() {
   val config = exerciseConfig ?: return
   if (_landmarks.isEmpty()) return
 
-  // Posture gate with hysteresis
-  if (!isPostureValid(config.postureFamily)) {
-    consecutivePostureFailures++
-    if (consecutivePostureFailures >= postureFailureThreshold) {
-      if (!postureWasLost) {
-        postureWasLost = true
-        onPostureLost?.invoke()
-      }
-      _currentPhase = ExercisePhase.UNKNOWN
-      phaseHistory.clear()
+val failureThreshold = if (config.type == ExerciseType.HOLD)
+  postureFailureThreshold * 3
+else
+  postureFailureThreshold
+
+if (!isPostureValid(config.postureFamily, config.visibilityThreshold)) {
+  consecutivePostureFailures++
+  if (consecutivePostureFailures >= failureThreshold) {
+    if (!postureWasLost) {
+      postureWasLost = true
+      onPostureLost?.invoke()
     }
-    return
+    _currentPhase = ExercisePhase.UNKNOWN
+    phaseHistory.clear()
   }
+  return
+}
 
   consecutivePostureFailures = 0
   if (postureWasLost) {
@@ -549,83 +553,6 @@ private fun processExerciseLogic() {
     onSessionComplete?.invoke(result)
   }
 
-  // ═══════════════════════════════════════════════════════════
-// Orientation Helpers
-// ═══════════════════════════════════════════════════════════
-
-private fun rotationDegreesFromFrame(frame: HybridFrameSpec): Int {
-  return when (frame.orientation.name.lowercase()) {
-    "up" -> 0
-    "right" -> 90
-    "down" -> 180
-    "left" -> 270
-    else -> 0
-  }
-}
-
-// ═══════════════════════════════════════════════════════════
-// Posture Gates
-// ═══════════════════════════════════════════════════════════
-
-private func isPostureValid(_ family: String) -> Bool {
-  guard _landmarks.count >= 33 else { return false }
-  
-  let visThreshold = exerciseConfig?.visibilityThreshold ?? 0.3
-  
-  if (_landmarks.size < 33) return false
-
-  val ls = _landmarks[11]; val rs = _landmarks[12]
-  val lh = _landmarks[23]; val rh = _landmarks[24]
-  val lk = _landmarks[25]; val rk = _landmarks[26]
-  val la = _landmarks[27]; val ra = _landmarks[28]
-
-  val keyVisible = ls.visibility > 0.3 && rs.visibility > 0.3 &&
-                   lh.visibility > 0.3 && rh.visibility > 0.3
-  if (!keyVisible) return false
-
-  val shoulderY = (ls.y + rs.y) / 2
-  val hipY = (lh.y + rh.y) / 2
-  val shoulderX = (ls.x + rs.x) / 2
-  val hipX = (lh.x + rh.x) / 2
-
-  val kneesVisible = lk.visibility > 0.3 && rk.visibility > 0.3
-  val anklesVisible = la.visibility > 0.3 && ra.visibility > 0.3
-  val kneeY = if (kneesVisible) (lk.y + rk.y) / 2 else hipY
-  val ankleY = if (anklesVisible) (la.y + ra.y) / 2 else kneeY
-
-  return when (family) {
-    "horizontalProne" -> {
-      val ys = listOf(shoulderY, hipY, ankleY)
-      (ys.max() - ys.min()) < 0.25
-    }
-    "standingUpright" -> {
-      if (!kneesVisible) false
-      else shoulderY < hipY - 0.08 &&
-           hipY < kneeY + 0.05 &&
-           (if (anklesVisible) kneeY < ankleY else true)
-    }
-    "seated" -> {
-      if (!kneesVisible) false
-      else shoulderY < hipY - 0.05 && kotlin.math.abs(hipY - kneeY) < 0.20
-    }
-    "supine" -> {
-      val ys = listOf(shoulderY, hipY, ankleY)
-      (ys.max() - ys.min()) < 0.25
-    }
-    "sidePlank" -> {
-      val ySpread = kotlin.math.abs(shoulderY - hipY)
-      val shoulderHipDx = kotlin.math.abs(shoulderX - hipX)
-      ySpread < 0.20 && shoulderHipDx < 0.15
-    }
-    "inverted" -> {
-      if (!anklesVisible) false
-      else hipY < shoulderY && hipY < ankleY
-    }
-    "none" -> true
-    else -> true
-  }
-}
-
   // ═══════════════════════════════════════════════════════════
   // Countdown
   // ═══════════════════════════════════════════════════════════
@@ -665,9 +592,77 @@ private func isPostureValid(_ family: String) -> Bool {
     countdownSeconds = 0.0
     frameCount = 0
     consecutivePostureFailures = 0
-postureWasLost = false
+    postureWasLost = false
     synchronized(landmarkLock) {
       cachedLandmarks = emptyArray()
     }
   }
+
+  // ═══════════════════════════════════════════════════════════
+  // Orientation Helpers
+  // ═══════════════════════════════════════════════════════════
+
+  private fun rotationDegreesFromFrame(frame: HybridFrameSpec): Int {
+    return when (frame.orientation.name.lowercase()) {
+      "up" -> 0
+      "right" -> 90
+      "down" -> 180
+      "left" -> 270
+      else -> 0
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════
+  // Posture Gates
+  // ═══════════════════════════════════════════════════════════
+
+ private fun isPostureValid(family: PostureFamily, threshold: Double): Boolean {
+    if (_landmarks.size < 33) return false
+
+    val ls = _landmarks[11]; val rs = _landmarks[12]
+    val lh = _landmarks[23]; val rh = _landmarks[24]
+    val lk = _landmarks[25]; val rk = _landmarks[26]
+    val la = _landmarks[27]; val ra = _landmarks[28]
+
+    val keyVisible = ls.visibility > threshold && rs.visibility > threshold &&
+                     lh.visibility > threshold && rh.visibility > threshold
+    if (!keyVisible) return false
+
+    val shoulderY = (ls.y + rs.y) / 2
+    val hipY = (lh.y + rh.y) / 2
+    val shoulderX = (ls.x + rs.x) / 2
+    val hipX = (lh.x + rh.x) / 2
+
+    val kneesVisible = lk.visibility > threshold && rk.visibility > threshold
+    val anklesVisible = la.visibility > threshold && ra.visibility > threshold
+    val kneeY = if (kneesVisible) (lk.y + rk.y) / 2 else hipY
+    val ankleY = if (anklesVisible) (la.y + ra.y) / 2 else kneeY
+
+   return when (family) {
+  PostureFamily.HORIZONTAL_PRONE, PostureFamily.SUPINE -> {
+    val ys = listOf(shoulderY, hipY, ankleY)
+    (ys.max() - ys.min()) < 0.25
+  }
+  PostureFamily.STANDING_UPRIGHT -> {
+    if (!kneesVisible) false
+    else shoulderY < hipY - 0.08 &&
+         hipY < kneeY + 0.05 &&
+         (if (anklesVisible) kneeY < ankleY else true)
+  }
+  PostureFamily.SEATED -> {
+    if (!kneesVisible) false
+    else shoulderY < hipY - 0.05 && kotlin.math.abs(hipY - kneeY) < 0.20
+  }
+  PostureFamily.SIDE_PLANK -> {
+    val ySpread = kotlin.math.abs(shoulderY - hipY)
+    val shoulderHipDx = kotlin.math.abs(shoulderX - hipX)
+    ySpread < 0.20 && shoulderHipDx < 0.15
+  }
+  PostureFamily.INVERTED -> {
+    if (!anklesVisible) false
+    else hipY < shoulderY && hipY < ankleY
+  }
+  PostureFamily.NONE -> true
+}
+  }
 }

package/ios/NitroPoseExercises.swift

@@ -118,7 +118,7 @@ private var postureWasLost = false
   func isReady() throws -> Bool {
   guard let config = exerciseConfig else { return false }
   guard !_landmarks.isEmpty else { return false }
-  return isPostureValid(config.postureFamily)
+return isPostureValid(family: config.postureFamily, threshold: config.visibilityThreshold)
 }
 
   // ═══════════════════════════════════════════════════════════
@@ -268,14 +268,19 @@ private static func cgOrientation(orientation: CameraOrientation, isMirrored: Bo
   // ═══════════════════════════════════════════════════════════
 
 private func processExerciseLogic() {
-
   guard let config = exerciseConfig else { return }
   guard !_landmarks.isEmpty else { return }
 
+  // Hold exercises get 3x more tolerance — stationary poses suffer from
+  // visibility flicker more than active reps.
+  let failureThreshold = config.type == .hold
+    ? postureFailureThreshold * 3
+    : postureFailureThreshold
+
   // Posture gate with hysteresis
   if !isPostureValid(family: config.postureFamily, threshold: config.visibilityThreshold) {
     consecutivePostureFailures += 1
-    if consecutivePostureFailures >= postureFailureThreshold {
+    if consecutivePostureFailures >= failureThreshold {
       if !postureWasLost {
         postureWasLost = true
         onPostureLost?()
@@ -287,67 +292,60 @@ private func processExerciseLogic() {
   }
 
   consecutivePostureFailures = 0
-  
   if postureWasLost {
     postureWasLost = false
     onPostureRegained?()
   }
 
-    var currentAngles: [String: Double] = [:]
-    var angleSnapshots: [AngleSnapshot] = []
-
-   let visThreshold = config.visibilityThreshold
+  // Angle calculation
+  let visThreshold = config.visibilityThreshold
+  var currentAngles: [String: Double] = [:]
+  var angleSnapshots: [AngleSnapshot] = []
 
-    for angleDef in config.angles {
-      let a = Int(angleDef.landmarkA)
-      let b = Int(angleDef.landmarkB)
-      let c = Int(angleDef.landmarkC)
+  for angleDef in config.angles {
+    let a = Int(angleDef.landmarkA)
+    let b = Int(angleDef.landmarkB)
+    let c = Int(angleDef.landmarkC)
 
-      guard a < _landmarks.count, b < _landmarks.count, c < _landmarks.count else { continue }
+    guard a < _landmarks.count, b < _landmarks.count, c < _landmarks.count else { continue }
 
-      guard _landmarks[a].visibility > visThreshold,
-            _landmarks[b].visibility > visThreshold,
-            _landmarks[c].visibility > visThreshold else { continue }
+    guard _landmarks[a].visibility > visThreshold,
+          _landmarks[b].visibility > visThreshold,
+          _landmarks[c].visibility > visThreshold else { continue }
 
+    let angle = calculateAngle(
+      pointA: _landmarks[a],
+      vertex: _landmarks[b],
+      pointC: _landmarks[c]
+    )
 
-      let angle = calculateAngle(
-        pointA: _landmarks[a],
-        vertex: _landmarks[b],
-        pointC: _landmarks[c]
-      )
-
-      currentAngles[angleDef.name] = angle
-      angleSnapshots.append(AngleSnapshot(name: angleDef.name, value: angle))
-    }
-
-    repAngleSnapshots = angleSnapshots
+    currentAngles[angleDef.name] = angle
+    angleSnapshots.append(AngleSnapshot(name: angleDef.name, value: angle))
+  }
 
-    // Debug logging — uncomment to see angles
-    // for (name, angle) in currentAngles {
-    //   print("[PoseExercise] Angle \(name): \(String(format: "%.1f", angle))°")
-    // }
+  repAngleSnapshots = angleSnapshots
 
-    let detectedPhase = determinePhase(from: currentAngles, config: config)
+  let detectedPhase = determinePhase(from: currentAngles, config: config)
 
-    if detectedPhase != _currentPhase && detectedPhase != .unknown {
-      let previousPhase = _currentPhase
-      _currentPhase = detectedPhase
-      onPhaseChange?(detectedPhase)
-      handlePhaseTransition(from: previousPhase, to: detectedPhase, config: config)
-    }
+  if detectedPhase != _currentPhase && detectedPhase != .unknown {
+    let previousPhase = _currentPhase
+    _currentPhase = detectedPhase
+    onPhaseChange?(detectedPhase)
+    handlePhaseTransition(from: previousPhase, to: detectedPhase, config: config)
+  }
 
-    checkFormRules(currentAngles: currentAngles, config: config)
+  checkFormRules(currentAngles: currentAngles, config: config)
 
-    if config.type == .hold {
-      handleHoldProgress(currentAngles: currentAngles, config: config)
-    }
+  if config.type == .hold {
+    handleHoldProgress(currentAngles: currentAngles, config: config)
   }
+}
 
   // ═══════════════════════════════════════════════════════════
 // MARK: - Posture Gates
 // ═══════════════════════════════════════════════════════════
 
-private func isPostureValid(_ family: String) -> Bool {
+private func isPostureValid(family: PostureFamily, threshold: Double) -> Bool  {
   guard _landmarks.count >= 33 else { return false }
 
   let ls = _landmarks[11], rs = _landmarks[12]
@@ -369,41 +367,28 @@ private func isPostureValid(_ family: String) -> Bool {
   let ankleY = anklesVisible ? (la.y + ra.y) / 2 : kneeY
 
   switch family {
-  case "horizontalProne":
+  case .horizontalprone, .supine:
     let ys = [shoulderY, hipY, ankleY]
-    let spread = (ys.max() ?? 0) - (ys.min() ?? 0)
-    return spread < 0.25
+    return ((ys.max() ?? 0) - (ys.min() ?? 0)) < 0.25
 
-  case "standingUpright":
+  case .standingupright:
     guard kneesVisible else { return false }
-    return shoulderY < hipY - 0.08
-        && hipY < kneeY + 0.05
-        && (anklesVisible ? kneeY < ankleY : true)
+    return shoulderY < hipY - 0.08 && hipY < kneeY + 0.05 && (anklesVisible ? kneeY < ankleY : true)
 
-  case "seated":
+  case .seated:
     guard kneesVisible else { return false }
-    return shoulderY < hipY - 0.05
-        && abs(hipY - kneeY) < 0.20
+    return shoulderY < hipY - 0.05 && Swift.abs(hipY - kneeY) < 0.20
 
-  case "supine":
-    let ys = [shoulderY, hipY, ankleY]
-    let spread = (ys.max() ?? 0) - (ys.min() ?? 0)
-    return spread < 0.25
-
-  case "sidePlank":
-    let ys = [shoulderY, hipY]
-    let ySpread = (ys.max() ?? 0) - (ys.min() ?? 0)
-    let shoulderHipDx = abs(shoulderX - hipX)
+  case .sideplank:
+    let ySpread = Swift.abs(shoulderY - hipY)
+    let shoulderHipDx = Swift.abs(shoulderX - hipX)
     return ySpread < 0.20 && shoulderHipDx < 0.15
 
-  case "inverted":
+  case .inverted:
     guard anklesVisible else { return false }
     return hipY < shoulderY && hipY < ankleY
 
-  case "none":
-    return true
-
-  default:
+  case .none:
     return true
   }
 }
@@ -662,7 +647,7 @@ private func isPostureValid(_ family: String) -> Bool {
     countdownSeconds = 0
     countdownTimer?.invalidate()
     countdownTimer = nil
-    frameCount = 0,
+    frameCount = 0
     consecutivePostureFailures = 0
     postureWasLost = false
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-pose-exercises",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Real-time on-device exercise tracking for React Native. Rep counting, form validation, and skeleton overlay powered by Apple Vision (iOS) and Google ML Kit (Android) with VisionCamera v5 via Nitro Modules.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",