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;
 
  /// Diastolic blood pressure, mmHg
  double? dbp;
 
  bool? isSmoker;
  HypertensionTreatment? 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;
 
  /// Physical activity level
  PhysicalActivity? physicalActivity;
 
  /// Triglyceride level, mg/dL
  double? triglyceride;
 
  /// Fasting glucose level, mg/dL
  double? fastingGlucose;
 
  bool? vegetableFruitDiet;
 
  bool? historyOfHighGlucose;
 
  bool? historyOfHypertension;
 
  ParentalHistory? parentalHypertension;
 
  FamilyHistory? familyDiabetes;
}
 
enum Gender {
  MALE(0),
  FEMALE(1),
  OTHER(2);
}
 
enum Race {
  WHITE(0),
  AFRICAN_AMERICAN(1),
  OTHER(2);
}
 
enum PhysicalActivity {
  SEDENTARY(0),
  LIGHTLY_ACTIVE(1),
  MODERATELY(2),
  VERY_ACTIVE(3),
  EXTRA_ACTIVE(4);
}
 
enum HypertensionTreatment {
  NOT_NEEDED(0),
  NO(1),
  YES(2);
}
 
enum ParentalHistory {
  NONE(0),
  ONE(1),
  BOTH(2);
}
 
enum FamilyHistory {
  NONE(0),
  NONE_FIRST_DEGREE(1),
  FIRST_DEGREE(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;
 
  /** Diastolic blood pressure, mmHg */
  dbp?: number;
 
  isSmoker?: boolean;
  hypertensionTreatment?: HypertensionTreatment;
  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;
 
  /** Physical activity level */
  physicalActivity?: PhysicalActivity;
 
  vegetableFruitDiet?: boolean;
  historyOfHypertension?: boolean;
  historyOfHighGlucose?: boolean;
  /** Fasting glucose level, mg/dL */
  fastingGlucose?: number;
  /** Triglyceride level, mg/dL */
  triglyceride?: number;
  parentalHypertension?: ParentalHistory;
  familyDiabetes?: FamilyHistory;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}
 
const enum PhysicalActivity {
  SEDENTARY = 0,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE,
}
 
const enum HypertensionTreatment {
  NOT_NEEDED = 0,
  NO,
  YES,
}
 
const enum ParentalHistory {
  NONE = 0,
  ONE,
  BOTH,
}
 
const enum FamilyHistory {
  NONE = 0,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE,
}

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<Float> dbp;            // mmHg
 
  public Optional<Boolean> isSmoker;
  public Optional<HypertensionTreatment> 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 Optional<PhysicalActivity> physicalActivity;
 
  public Optional<ParentalHistory> parentalHypertension;
  public Optional<FamilyHistory> familyDiabetes;
  public Optional<Float> triglyceride;    // mg/dL
  public Optional<Float> fastingGlucose;  // mg/dL
  public Optional<Boolean> vegetableFruitDiet;
  public Optional<Boolean> historyOfHighGlucose;
  public Optional<Boolean> historyOfHypertension;
}
 
public enum Gender {
  MALE,
  FEMALE,
  OTHER
}
 
public enum Race {
  WHITE,
  AFRICAN_AMERICAN,
  OTHER
}
 
public enum PhysicalActivity {
  SEDENTARY,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE
}
 
public enum HypertensionTreatment {
  NOT_NEEDED,
  NO,
  YES
}
 
public enum ParentalHistory {
  NONE,
  ONE,
  BOTH
}
 
public enum FamilyHistory {
  NONE,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE
}

interface RisksFactors {
  age?: number;                  // years
  cholesterol?: number;          // mg/dL
  cholesterolHdl?: number;       // mg/dL
  sbp?: number;                  // mmHg
  dbp?: number;                  // mmHg
 
  isSmoker?: boolean;
  hypertensionTreatment?: HypertensionTreatment;
  hasDiabetes?: boolean;
 
  bodyHeight?: number;           // centimeters
  bodyWeight?: number;           // kilograms
  waistCircumference?: number;   // centimeters
 
  gender?: Gender;
  country?: string;              // 2-letter ISO code, e.g. "US"
  race?: Race;
 
  physicalActivity?: PhysicalActivity;
 
  vegetableFruitDiet?: boolean;
  historyOfHypertension?: boolean;
  historyOfHighGlucose?: boolean;
  fastingGlucose?: number;    // mmHg
  triglyceride?: number;      // mmHg
  parentalHypertension?: ParentalHistory;
  familyDiabetes?: FamilyHistory;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}
 
const enum PhysicalActivity {
  SEDENTARY = 0,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE,
}
 
const enum HypertensionTreatment {
  NOT_NEEDED = 0,
  NO,
  YES,
}
 
const enum ParentalHistory {
  NONE = 0,
  ONE,
  BOTH,
}
 
const enum FamilyHistory {
  NONE = 0,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE,
}

class RisksFactors : NSObject {
  var age: NSNumber?              // years
  var cholesterol: NSNumber?      // mg/dL
  var cholesterolHDL: NSNumber?   // mg/dL
  var sbp: NSNumber?              // mmHg
  var dbp: NSNumber?              // mmHg
 
  var isSmoker: NSNumber?
  var hypertensionTreatment: HypertensionTreatment?
  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?
 
  var physicalActivity: PhysicalActivity?
 
  var vegetableFruitDiet: NSNumber?
  var historyOfHypertension: NSNumber?
  var historyOfHighGlucose: NSNumber?
  var fastingGlucose: NSNumber?    // mmHg
  var triglyceride: NSNumber?      // mmHg
  var parentalHypertension: ParentalHistory?
  var familyDiabetes: FamilyHistory?
}
 
enum Gender {
  case male
  case female
  case other
}
 
enum Race {
  case white
  case africanAmerican
  case other
}
 
enum PhysicalActivity {
  case sedentary
  case lightlyActive
  case moderately
  case veryActive
  case extraActive
}
 
enum HypertensionTreatment {
  case notNeeded
  case no
  case yes
}
 
enum FamilyHistory {
  case none
  case noneFirstDegree
  case firstDegree
}
 
enum ParentalHistory {
  case none
  case one
  case both
}

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;
 
  /// Computed body roundness index (BRI)
  double? bodyRoundnessIndex;
 
  /// Computed a body shape index (ABSI)
  double? aBodyShapeIndex;
 
  /// Computed conicity index (CI)
  double? conicityIndex;
 
  /// Computed total daily energy expenditure (TDEE)
  double? totalDailyEnergyExpenditure;
 
  /// Computed wellness score (WS)
  double? wellnessScore;
 
  RisksFactorsScores scores;
 
  /// Computed hypertension risk
  double? hypertensionRisk;
 
  /// Computed diabeted risk
  double? diabetesRisk;
 
  /// Computed non alcoholic fatty liver disease risk
  NAFLDRisk? nonAlcoholicFattyLiverDiseaseRisk;
}

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;
  bodyRoundnessIndex: number | null;
  aBodyShapeIndex: number | null;
  conicityIndex: number | null;
  totalDailyEnergyExpenditure: number | null;
  wellnessScore: number | null;
  scores: RisksFactorsScores;
  hypertensionRisk?: number | null;
  diabetesRisk?: number | null;
  nonAlcoholicFattyLiverDiseaseRisk?: NAFLDRisk | null;
}

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 Optional<Float> bodyRoundnessIndex;
  public Optional<Float> aBodyShapeIndex;
  public Optional<Float> conicityIndex;
  public Optional<Float> totalDailyEnergyExpenditure;
  public Optional<Float> wellnessScore;
  public RisksFactorsScores scores;
  public Optional<Float> hypertensionRisk;
  public Optional<Float> diabetesRisk;
  public Optional<NAFLDRisk> nonAlcoholicFattyLiverDiseaseRisk; 
}

computeHealthRisks: (factors: RisksFactors) => HealthRisks;
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  bodyRoundnessIndex: number | null;
  aBodyShapeIndex: number | null;
  conicityIndex: number | null;
  totalDailyEnergyExpenditure: number | null;
  wellnessScore: number | null;
  scores: RisksFactorsScores;
  hypertensionRisk?: number | null;
  diabetesRisk?: number | null;
  nonAlcoholicFattyLiverDiseaseRisk?: NAFLDRisk | null;
}

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 bodyRoundnessIndex: NSNumber?           // e.g. 4.7
  var aBodyShapeIndex: NSNumber?              // e.g. 0.087
  var conicityIndex: NSNumber?                // e.g. 1.28
  var totalDailyEnergyExpenditure: NSNumber?  // e.g. 2200
  var wellnessScore: NSNumber?                // e.g. 78
  var scores: RisksFactorsScores
  var hypertensionRisk: NSNumber?
  var diabetesRisk: NSNumber?
  var nonAlcoholicFattyLiverDiseaseRisk: NAFLDRisk
}

Substructures

The HealthRisks object contains multiple substructures:

enum NAFLDRisk {
  low,
  moderate,
  high,
}
 
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;
}

const enum NAFLDRisk {
  LOW = 0,
  MODERATE,
  HIGH,
}
 
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 enum NAFLDRisk {
  LOW,
  MODERATE,
  HIGH
}
 
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;
}

const enum NAFLDRisk {
  LOW = 0,
  MODERATE,
  HIGH,
}
 
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;
}

enum NAFLDRisk {
  case low
  case moderate
  case high
}
 
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 Customizable Health Indices