Question

在我的应用程序中，我每隔<20>毫秒记录从设备的加速度计中获取的加速度数据。我有一个名为AccelerationData的类来存储这些值。我还记录每个读数的时间戳，以毫秒为单位。

class AccelerationData {
    var timestamp: Int64 = 0 // in milliseconds
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0

    var timestampDate: Date {
        return Date(milliseconds: timestamp)
    }

    var JSONDictionary: [String: Any] {
        let jsonDictionary: [String: Any] = [
            "X": x,
            "Y": y,
            "Z": z,
            "TIME": timestamp
        ]
        return jsonDictionary
    }
}

extension Date {

    var milliseconds: Int64 {
        return Int64(self.timeIntervalSince1970 * 1000)
    }

    init(milliseconds: Int64) {
        self = Date(timeIntervalSince1970: TimeInterval(milliseconds / 1000))
    }

}

录制结束后，我需要创建所有这些读数的JSON主体。我想要通过每500毫秒（0.5秒）发生的读数来过滤它，而不是取所有这些读数。

从研究found开始，您可以使用flatMap执行此类任务但我不确定如果涉及时间戳等动态值，如何应用此功能。

我很欣赏如何开始这方面的一些指导。

Answer 1

我会为此目的使用一个简单的for循环。假设数据按时间戳排序，它可能如下所示：

let measurements: [AccelerationData] = ... // your full array of acceleration data
var reducedMeasurements = [AccelerationData]()

var nextTimeStamp = measurements.first!.timestamp // Assuming that the array is not empty
for accData in measurements {
    if accData.timestamp >= nextTimeStamp {
        reducedMeasurements.append(accData)
        nextTimeStamp += 500 // add 0.5 seconds
    }
}

如果你“坚持”使用过滤器，这是一个可能的解决方案：

func timeFilter(delta: Int64) -> (Int64) -> Bool {
    var nextTimeStamp: Int64?
    return { timeStamp in
        if let next = nextTimeStamp {
            if timeStamp >= next {
                nextTimeStamp = next + delta
                return true
            } else {
                return false
            }
        } else {
            // First call:
            nextTimeStamp = timeStamp + delta
            return true
        }
    }
}

let measurements: [AccelerationData] = ...
let filter = timeFilter(delta: 500)
let reducedMeasurements = measurements.filter { filter($0.timestamp) }

timeFilter(delta: 500)创建一个使用捕获的闭包变量以跟踪下一个时间戳。代码很可能简化，但希望能够证明这一想法。

按时间间隔过滤数组

1 个答案: