AccelerationFeatures.fromAccelerometerReadings constructor

AccelerationFeatures.fromAccelerometerReadings(List<UserAccelerometerEvent> readings)

Implementation

factory AccelerationFeatures.fromAccelerometerReadings(
  List<UserAccelerometerEvent> readings,
) {
  final n = readings.length;

  final List<num> xList = readings.map((event) => event.x).toList();
  final List<num> yList = readings.map((event) => event.y).toList();
  final List<num> zList = readings.map((event) => event.z).toList();

  final xStatistics = xList.statistics;
  final yStatistics = yList.statistics;
  final zStatistics = zList.statistics;

  final xStats = Stats(xList);
  final yStats = Stats(yList);
  final zStats = Stats(zList);

  var features = AccelerationFeatures()
        ..count = n
        // mean
        ..xMean = xStatistics.mean
        ..yMean = yStatistics.mean
        ..zMean = zStatistics.mean
        // std dev
        ..xStd = xStatistics.standardDeviation
        ..yStd = yStatistics.standardDeviation
        ..zStd = zStatistics.standardDeviation
        //min
        ..xMin = xStatistics.min
        ..yMin = yStatistics.min
        ..zMin = zStatistics.min
        // max
        ..xMax = xStatistics.max
        ..yMax = yStatistics.max
        ..zMax = zStatistics.max
        //max-min diff
        ..xMaxMinDiff = xStatistics.max - xStatistics.min
        ..yMaxMinDiff = yStatistics.max - yStatistics.min
        ..zMaxMinDiff = zStatistics.max - zStatistics.min
        // median
        ..xMedian = xStatistics.median
        ..yMedian = yStatistics.median
        ..zMedian = zStatistics.median
        // energy
        ..xEnergy = xStatistics.squaresSum / n
        ..yEnergy = yStatistics.squaresSum / n
        ..zEnergy = zStatistics.squaresSum / n
      //
      ;

  // positive count
  features.xPosCount = xList.where((x) => x > 0).length;
  features.yPosCount = yList.where((y) => y > 0).length;
  features.zPosCount = zList.where((z) => z > 0).length;

  // negative count
  features.xNegCount = xList.where((x) => x < 0).length;
  features.yNegCount = yList.where((y) => y < 0).length;
  features.zNegCount = zList.where((z) => z < 0).length;

  // inter-quartile range
  features.xIqr = xStats.quartile3 - xStats.quartile1;
  features.yIqr = yStats.quartile3 - yStats.quartile1;
  features.zIqr = zStats.quartile3 - zStats.quartile1;

  // values above mean
  features.xAboveMean = xList.where((x) => x > xStatistics.mean).length;
  features.yAboveMean = yList.where((y) => y > yStatistics.mean).length;
  features.zAboveMean = zList.where((z) => z > zStatistics.mean).length;

  // average absolute diff (AAD)
  // median abs dev (MAD)
  // average results
  // signal magnitude area (SMA)
  List<num> ar = [];
  num xSma = 0, ySma = 0, zSma = 0;
  List<num> xAad = [], yAad = [], zAad = [];
  List<num> xMad = [], yMad = [], zMad = [];
  for (var r in readings) {
    xAad.add((r.x - xStatistics.mean).abs());
    yAad.add((r.y - yStatistics.mean).abs());
    zAad.add((r.z - zStatistics.mean).abs());

    xMad.add((r.x - xStatistics.median).abs());
    yMad.add((r.y - yStatistics.median).abs());
    zMad.add((r.z - zStatistics.median).abs());

    ar.add(math.sqrt(math.pow(r.x, 2) + math.pow(r.y, 2) + math.pow(r.z, 2)));

    xSma += r.x.abs() / n;
    ySma += r.y.abs() / n;
    zSma += r.z.abs() / n;
  }
  features.xAad = xAad.mean;
  features.yAad = yAad.mean;
  features.zAad = zAad.mean;
  features.xMad = xMad.median;
  features.yMad = yMad.median;
  features.zMad = zMad.median;
  features.avgResultAcceleration = ar.mean;
  features.signalMagnitudeArea = xSma + ySma + zSma;

  return features;
}