Integrating Health Indices

If you are using our embedded UX flow (the “Full UX flow” described here), the Health Indices are automatically integrated. You don’t need to do anything special to show or compute them— the user is guided to enter their risk factors and the results are displayed in the SDK’s UI.
The instructions below are only relevant if you want to compute health indices through the API—for example, if you are using the Health Indices completely standalone, independently of the video measurement.

Providing User Risk Factors

You should construct a RisksFactors object (or equivalent structure in your platform) and pass it to the risk-computation function. If certain data is missing, the relevant risks will not be computed. The following fields are available:

class RisksFactors {
  /// Age, in years
  int? age;
 
  /// Total cholesterol, mg/dL
  double? cholesterol;
 
  /// HDL cholesterol, mg/dL
  double? cholesterolHdl;
 
  /// Systolic blood pressure, mmHg
  double? sbp;
 
  bool? isSmoker;
  bool? hypertensionTreatment;
  bool? hasDiabetes;
 
  /// Body height, centimeters
  double? bodyHeight;
 
  /// Body weight, kilograms
  double? bodyWeight;
 
  /// Waist circumference, centimeters
  double? waistCircumference;
 
  Gender? gender;
 
  /// Two-letter ISO country code, e.g. "US"
  String? country;
 
  Race? race;
}
 
enum Gender {
  MALE(0),
  FEMALE(1),
  OTHER(2);
}
 
enum Race {
  WHITE(0),
  AFRICAN_AMERICAN(1),
  OTHER(2);
}

interface RisksFactors {
  /** Age, in years */
  age?: number;
  /** Total cholesterol, mg/dL */
  cholesterol?: number;
  /** HDL cholesterol, mg/dL */
  cholesterolHdl?: number;
  /** Systolic blood pressure, mmHg */
  sbp?: number;
 
  isSmoker?: boolean;
  hypertensionTreatment?: boolean;
  hasDiabetes?: boolean;
 
  /** Body height, centimeters */
  bodyHeight?: number;
  /** Body weight, kilograms */
  bodyWeight?: number;
  /** Waist circumference, centimeters */
  waistCircumference?: number;
 
  gender?: Gender;
  /** Two-letter ISO country code, e.g. "US" */
  country?: string;
  race?: Race;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}

public class RisksFactors {
  public Optional<Integer> age;           // years
  public Optional<Float> cholesterol;     // mg/dL
  public Optional<Float> cholesterolHdl;  // mg/dL
  public Optional<Float> sbp;            // mmHg
 
  public Optional<Boolean> isSmoker;
  public Optional<Boolean> hypertensionTreatment;
  public Optional<Boolean> hasDiabetes;
 
  public Optional<Float> bodyHeight;         // centimeters
  public Optional<Float> bodyWeight;         // kilograms
  public Optional<Float> waistCircumference; // centimeters
 
  public Optional<Gender> gender;
  public String country; // 2-letter ISO code, e.g. "US"
  public Optional<Race> race;
}
 
public enum Gender {
  MALE,
  FEMALE,
  OTHER
}
 
public enum Race {
  WHITE,
  AFRICAN_AMERICAN,
  OTHER
}

interface RisksFactors {
  age?: number;                  // years
  cholesterol?: number;          // mg/dL
  cholesterolHdl?: number;       // mg/dL
  sbp?: number;                  // mmHg
 
  isSmoker?: boolean;
  hypertensionTreatment?: boolean;
  hasDiabetes?: boolean;
 
  bodyHeight?: number;           // centimeters
  bodyWeight?: number;           // kilograms
  waistCircumference?: number;   // centimeters
 
  gender?: Gender;
  country?: string;              // 2-letter ISO code, e.g. "US"
  race?: Race;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}

class RisksFactors : NSObject {
  var age: NSNumber?              // years
  var cholesterol: NSNumber?      // mg/dL
  var cholesterolHDL: NSNumber?   // mg/dL
  var sbp: NSNumber?              // mmHg
 
  var isSmoker: NSNumber?
  var hypertensionTreatment: NSNumber?
  var hasDiabetes: NSNumber?
 
  var bodyHeight: NSNumber?       // centimeters
  var bodyWeight: NSNumber?       // kilograms
  var waistCircumference: NSNumber? // centimeters
 
  var gender: Gender?
  var country: String?  // 2-letter ISO code, e.g. "US"
  var race: Race?
}
 
enum Gender {
  case male
  case female
  case other
}
 
enum Race {
  case white
  case africanAmerican
  case other
}

Computing Health Risks

Call the computeHealthRisks() function with the RisksFactors object to compute all the available risk indices and body composition metrics. The returned structure is HealthRisks.

If some data is not provided, then any risk requiring that data will not be computed.

static HealthRisks computeHealthRisks(RisksFactors factors);
 
class HealthRisks {
  HardAndFatalEventsRisks hardAndFatalEvents;
  CVDiseasesRisks cvDiseases;
  int? vascularAge;
 
  /// Computed waist-to-height ratio (WHtR)
  double? waistToHeightRatio;
 
  /// Computed body fat percentage (BFP)
  double? bodyFatPercentage;
 
  /// Computed basal metabolic rate (BMR)
  double? basalMetabolicRate;
 
  RisksFactorsScores scores;
}

import { computeHealthRisks, RisksFactors } from 'react-native-shenai-sdk';
 
async function computeHealthRisks(factors: RisksFactors): Promise<HealthRisks>;
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  scores: RisksFactorsScores;
}

public HealthRisks computeHealthRisks(RisksFactors factors);
 
public class HealthRisks {
  public HardAndFatalEventsRisks hardAndFatalEvents;
  public CVDiseasesRisks cvDiseases;
  public Optional<Integer> vascularAge;
  public Optional<Integer> waistToHeightRatio;
  public Optional<Integer> bodyFatPercentage;
  public Optional<Integer> basalMetabolicRate;
  public RisksFactorsScores scores;
}

computeHealthRisks: (factors: RisksFactors) => HealthRisks;
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  scores: RisksFactorsScores;
}

class ShenaiHealthRisks {
  func computeHealthRisks(_ factors: RisksFactors) -> HealthRisks
}
 
class HealthRisks {
  var hardAndFatalEvents: HardAndFatalEventsRisks
  var cvDiseases: CVDiseasesRisks
  var vascularAge: NSNumber?          // e.g. 52
  var waistToHeightRatio: NSNumber?   // e.g. 0.51
  var bodyFatPercentage: NSNumber?    // e.g. 24.0
  var basalMetabolicRate: NSNumber?   // e.g. 1435
  var scores: RisksFactorsScores
}

Substructures

The HealthRisks object contains multiple substructures:

class HardAndFatalEventsRisks {
  final double? coronaryDeathEventRisk;
  final double? fatalStrokeEventRisk;
  final double? totalCVMortalityRisk;
  final double? hardCVEventRisk;
}
 
class CVDiseasesRisks {
  final double? overallRisk;
  final double? coronaryHeartDiseaseRisk;
  final double? strokeRisk;
  final double? heartFailureRisk;
  final double? peripheralVascularDiseaseRisk;
}
 
class RisksFactorsScores {
  final int? ageScore;
  final int? sbpScore;
  final int? smokingScore;
  final int? diabetesScore;
  final int? bmiScore;
  final int? cholesterolScore;
  final int? cholesterolHdlScore;
  final int? totalScore;
}

interface HardAndFatalEventsRisks {
  coronaryDeathEventRisk: number | null;
  fatalStrokeEventRisk: number | null;
  totalCVMortalityRisk: number | null;
  hardCVEventRisk: number | null;
}
 
interface CVDiseasesRisks {
  overallRisk: number | null;
  coronaryHeartDiseaseRisk: number | null;
  strokeRisk: number | null;
  heartFailureRisk: number | null;
  peripheralVascularDiseaseRisk: number | null;
}
 
interface RisksFactorsScores {
  ageScore: number | null;
  sbpScore: number | null;
  smokingScore: number | null;
  diabetesScore: number | null;
  bmiScore: number | null;
  cholesterolScore: number | null;
  cholesterolHdlScore: number | null;
  totalScore: number | null;
}

public class HardAndFatalEventsRisks {
  public Optional<Float> coronaryDeathEventRisk;
  public Optional<Float> fatalStrokeEventRisk;
  public Optional<Float> totalCVMortalityRisk;
  public Optional<Float> hardCVEventRisk;
}
 
public class CVDiseasesRisks {
  public Optional<Float> overallRisk;
  public Optional<Float> coronaryHeartDiseaseRisk;
  public Optional<Float> strokeRisk;
  public Optional<Float> heartFailureRisk;
  public Optional<Float> peripheralVascularDiseaseRisk;
}
 
public class RisksFactorsScores {
  public Optional<Integer> ageScore;
  public Optional<Integer> sbpScore;
  public Optional<Integer> smokingScore;
  public Optional<Integer> diabetesScore;
  public Optional<Integer> bmiScore;
  public Optional<Integer> cholesterolScore;
  public Optional<Integer> cholesterolHdlScore;
  public Optional<Integer> totalScore;
}

interface HardAndFatalEventsRisks {
  coronaryDeathEventRisk: number | null;
  fatalStrokeEventRisk: number | null;
  totalCVMortalityRisk: number | null;
  hardCVEventRisk: number | null;
}
 
interface CVDiseasesRisks {
  overallRisk: number | null;
  coronaryHeartDiseaseRisk: number | null;
  strokeRisk: number | null;
  heartFailureRisk: number | null;
  peripheralVascularDiseaseRisk: number | null;
}
 
interface RisksFactorsScores {
  ageScore: number | null;
  sbpScore: number | null;
  smokingScore: number | null;
  diabetesScore: number | null;
  bmiScore: number | null;
  cholesterolScore: number | null;
  cholesterolHdlScore: number | null;
  totalScore: number | null;
}

class HardAndFatalEventsRisks {
  var coronaryDeathEventRisk: NSNumber?
  var fatalStrokeEventRisk: NSNumber?
  var totalCvMortalityRisk: NSNumber?
  var hardCvEventRisk: NSNumber?
}
 
class CVDiseasesRisks {
  var overallRisk: NSNumber?
  var coronaryHeartDiseaseRisk: NSNumber?
  var strokeRisk: NSNumber?
  var heartFailureRisk: NSNumber?
  var peripheralVascularDiseaseRisk: NSNumber?
}
 
class RisksFactorsScores {
  var ageScore: NSNumber?
  var sbpScore: NSNumber?
  var smokingScore: NSNumber?
  var diabetesScore: NSNumber?
  var bmiScore: NSNumber?
  var cholesterolScore: NSNumber?
  var cholesterolHdlScore: NSNumber?
  var totalScore: NSNumber?
}

Minimal, Maximal, and Reference Values

Different metrics have different ranges depending on the user’s risk factors. Shen.AI provides methods to retrieve minimal, maximal, and reference values for each risk.

static HealthRisks getMinimalHealthRisks(RisksFactors factors);
static HealthRisks getMaximalHealthRisks(RisksFactors factors);
static HealthRisks getReferenceHealthRisks(RisksFactors factors);

import {
  getMinimalRisks,
  getMaximalRisks,
  getReferenceRisks
} from 'react-native-shenai-sdk';
 
async function getMinimalRisks(factors: RisksFactors): Promise<HealthRisks>;
async function getMaximalRisks(factors: RisksFactors): Promise<HealthRisks>;
async function getReferenceRisks(factors: RisksFactors): Promise<HealthRisks>;

public HealthRisks getMinimalHealthRisks(RisksFactors factors);
public HealthRisks getMaximalHealthRisks(RisksFactors factors);
public HealthRisks getReferenceHealthRisks(RisksFactors factors);

getMinimalRisks: (factors: RisksFactors) => HealthRisks;
getMaximalRisks: (factors: RisksFactors) => HealthRisks;
getReferenceRisks: (factors: RisksFactors) => HealthRisks;

class ShenaiHealthRisks {
  func getMinimalHealthRisks(_ factors: RisksFactors) -> HealthRisks
  func getMaximalHealthRisks(_ factors: RisksFactors) -> HealthRisks
  func getReferenceHealthRisks(_ factors: RisksFactors) -> HealthRisks
}

Summary of Implementation Steps

Create a RisksFactors object with the user’s details (age, blood pressure, cholesterol, anthropometric data, etc.).
Invoke computeHealthRisks() to generate HealthRisks (including vascular age, CVD risk, event risk, waist-to-height ratio, body fat percentage, and basal metabolic rate).
Display the resulting risk values and any derived body composition metrics within your application.
Optionally, retrieve minimal, maximal, or reference risk profiles for additional insights.

This comprehensive approach lets you integrate Shen.AI’s cardiovascular risk calculations and body composition estimates in a straightforward way.

Overview Remote configuration