Upload 8 files

data/csi_data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91454a2af39d397357330afabffd1b1ba5d59fabfa23c10bde8daa40448eccbd
+size 16281304

data/processed_data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20b8c44e02a8231803cf4f2088d1fddda85d4848defa96607da7786bb3e4dcf6
+size 59596932

data_process_example/README.md

@@ -0,0 +1,3 @@
+# How to Run
+
+You can run the code `process_csi1.py`, `process_csi2.py`, `process_csi2_magnitude_linear_inter.py`, `process_cv.py`, `combine_csi_cv.py` in order.

data_process_example/combine_csi_cv.py

@@ -0,0 +1,102 @@
+import pickle
+import numpy as np
+
+with open("./data_sequence.pkl", 'rb') as f:
+# with open("./data_sequence_linear.pkl", 'rb') as f:
+    data_csi = pickle.load(f)
+with open("./gt_data.pkl", 'rb') as f:
+    data_cv = pickle.load(f)
+
+data = []
+pad = -1000
+for k in range(len(data_csi)):
+    csi = data_csi[k]
+    cv = data_cv[k]
+
+    x = cv['x']
+    y = cv['y']
+    img_path = np.array(cv['img_path'])
+    time_cv = cv['timestamp']
+    print(cv['people_name'])
+
+    indices = np.argsort(time_cv)
+    x = x[indices]
+    y = y[indices]
+    img_path = img_path[indices]
+    time_cv = time_cv[indices]
+
+    print(x)
+    print(y)
+
+
+    csi_time = csi['global_time']
+    local_time = csi['time']
+    magnitude = csi['magnitude']
+    phase = csi['phase']
+    people = csi['people']
+
+    indices = np.argsort(csi_time)
+    local_time = local_time[indices]
+    magnitude = magnitude[indices]
+    csi_time = csi_time[indices]
+    phase = phase[indices]
+
+
+
+    x_list = []
+    y_list = []
+    path_list = []
+
+    i = 0
+    j = 0
+
+    print(csi_time)
+    print(time_cv)
+
+
+    while csi_time[i] < time_cv[j]:
+        i += 1
+        x_list.append(pad)
+        y_list.append(pad)
+        path_list.append(pad)
+
+
+    # print(len(csi_time))
+    # print(len(time_cv))
+    while i < len(csi_time):
+        while csi_time[i] > time_cv[j]:
+            j += 1
+            if j >= len(time_cv):
+                break
+        if j >= len(time_cv):
+            break
+        x_list.append(x[j])
+        y_list.append(y[j])
+        path_list.append(img_path[j])
+        i += 1
+
+    print(len(x_list))
+
+
+    if len(x_list) < len(csi_time):
+        num = len(csi_time) - len(x_list)
+        x_list = x_list + [pad] * num
+        y_list = y_list + [pad] * num
+        path_list = path_list + [pad] * num
+
+    data.append({
+        'magnitude': magnitude,
+        'phase': phase,
+        'x': x_list,
+        'y': y_list,
+        'img_path': path_list,
+        'time': local_time,
+        'people': people
+    })
+    print(people)
+    print(len(magnitude),len(phase),len(x_list),len(y_list),len(path_list),len(local_time))
+
+output_file = './wiloc.pkl'
+# output_file = './wiloc_linear.pkl'
+with open(output_file, 'wb') as f:
+    pickle.dump(data, f)

data_process_example/process_csi1.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pickle
+import os
+import pandas as pd
+
+# root="./csi"
+root="/home/chentingwei/LoFi/csi_csv"
+
+
+data=[]
+csi_vaid_subcarrier_index = range(0, 52)
+
+def handle_complex_data(x, valid_indices):
+    real_parts = []
+    imag_parts = []
+    for i in valid_indices:
+        real_parts.append(x[i * 2])
+        imag_parts.append(x[i * 2 - 1])
+    return np.array(real_parts) + 1j * np.array(imag_parts)
+
+people_id=0
+for people in os.listdir(root):
+    print(people)
+    path=os.path.join(root,people)
+
+    for file in os.listdir(path):
+        if file[-3:] != "csv":
+            continue
+        # print(file)
+        df = pd.read_csv(os.path.join(path,file))
+        df.dropna(inplace=True)
+        df['data'] = df['data'].apply(lambda x: eval(x))
+        complex_data = df['data'].apply(lambda x: handle_complex_data(x, csi_vaid_subcarrier_index))
+        magnitude = complex_data.apply(lambda x: np.abs(x))
+        phase = complex_data.apply(lambda x: np.angle(x, deg=True))
+        time = np.array(df['timestamp'])
+        local_time = np.array(df['local_timestamp'])
+
+        data.append({
+            'csi_time':time,
+            'csi_local_time':local_time,
+            'people_name': people,
+            'people': people_id,
+            'magnitude': np.array([np.array(a) for a in magnitude]),
+            'phase': np.array([np.array(a) for a in phase]),
+            'CSI': np.array([np.array(a) for a in complex_data])
+        })
+    people_id+=1
+
+
+output_file = './csi_data.pkl'
+with open(output_file, 'wb') as f:
+    pickle.dump(data, f)

data_process_example/process_csi2.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pickle
+
+
+result=[]
+pad=[-1000]*52
+loacl_gap=10000
+
+def process_time(timestamp):
+    t = timestamp.split()
+    # print(t)
+    t = t[-1].split(":")
+    h = float(t[0])
+    m = float(t[1])
+    t = t[-1].split(".")
+    s = float(t[0])
+    ms = float(t[1])
+    # print(h,m,s,ms)
+    return h * 60 * 60 * 100 + m * 60 * 100 + s * 100 + ms
+
+
+with open("./csi_data.pkl", 'rb') as f:
+    csi = pickle.load(f)
+
+for data in csi:
+    csi_time=data['csi_time']
+    local_time=data['csi_local_time']
+    magnitude=data['magnitude']
+    phase=data['phase']
+    people=data['people']
+
+    last_local=None
+    last_glob=None
+    current_magnitude=[]
+    current_phase=[]
+    current_timestamp=[]
+    global_timestamp=[]
+    for i in range(len(csi_time)):
+        if last_local is None:
+            last_local=local_time[i]
+            last_glob=process_time(csi_time[i])
+            current_magnitude.append(magnitude[i])
+            current_phase.append(phase[i])
+            current_timestamp.append(local_time[i])
+        else:
+            local = local_time[i]
+            glob = process_time(csi_time[i])
+            num=round((local-last_local-loacl_gap)/loacl_gap)
+            if num>0:
+                delta=(local-last_local)/(num+1)
+                delta_glob=(glob-last_glob)/(num+1)
+                for j in range(num):
+                    current_magnitude.append(pad)
+                    current_phase.append(pad)
+                    current_timestamp.append(current_timestamp[-1] + delta)
+                    global_timestamp.append(global_timestamp[-1]+delta_glob)
+            current_magnitude.append(magnitude[i])
+            current_phase.append(phase[i])
+            current_timestamp.append(local)
+            global_timestamp.append(glob)
+            last_local = local
+            last_glob = glob
+
+    print(len(current_magnitude))
+    # print(np.max(global_timestamp))
+    result.append({
+        'time': np.array(current_timestamp),
+        'global_time': np.array(global_timestamp),
+        'people': people,
+        'magnitude': np.array(current_magnitude),
+        'phase': np.array(current_phase)
+    })
+
+output_file = './data_sequence.pkl'
+with open(output_file, 'wb') as f:
+    pickle.dump(result, f)

data_process_example/process_csi2_magnitude_linear_inter.py

@@ -0,0 +1,91 @@
+import numpy as np
+import pickle
+import pandas as pd
+
+
+result=[]
+pad=[-1000]*52
+loacl_gap=10000
+
+def process_time(timestamp):
+    t = timestamp.split()
+    t = t[-1].split(":")
+    h = float(t[0])
+    m = float(t[1])
+    t = t[-1].split(".")
+    s = float(t[0])
+    ms = float(t[1])
+    return h * 60 * 60 * 100 + m * 60 * 100 + s * 100 + ms
+
+def interpolate_data(original_data):
+    data_interpolate = np.copy(original_data)
+
+    # 对数据进行插值处理
+    for j in range(original_data.shape[1]):
+        series = pd.Series(original_data[:, j])
+        series.interpolate(method='linear', inplace=True)
+        data_interpolate[:, j] = series.values
+
+    return data_interpolate
+
+
+with open("./csi_data.pkl", 'rb') as f:
+    csi = pickle.load(f)
+
+for data in csi:
+    csi_time=data['csi_time']
+    local_time=data['csi_local_time']
+    magnitude=data['magnitude']
+    phase=data['phase']
+    people=data['people']
+
+    last_local=None
+    last_glob=None
+    current_magnitude=[]
+    current_phase=[]
+    current_timestamp=[]
+    global_timestamp=[]
+    for i in range(len(csi_time)):
+        if last_local is None:
+            last_local=local_time[i]
+            last_glob=process_time(csi_time[i])
+            current_magnitude.append(magnitude[i])
+            current_phase.append(phase[i])
+            current_timestamp.append(local_time[i])
+        else:
+            local = local_time[i]
+            glob = process_time(csi_time[i])
+            num=round((local-last_local-loacl_gap)/loacl_gap)
+            if num>0:
+                delta=(local-last_local)/(num+1)
+                delta_glob=(glob-last_glob)/(num+1)
+                for j in range(num):
+                    current_magnitude.append(pad)
+                    current_phase.append(pad)
+                    current_timestamp.append(current_timestamp[-1] + delta)
+                    global_timestamp.append(global_timestamp[-1]+delta_glob)
+            current_magnitude.append(magnitude[i])
+            current_phase.append(phase[i])
+            current_timestamp.append(local)
+            global_timestamp.append(glob)
+            last_local = local
+            last_glob = glob
+
+
+    current_magnitude = np.array(current_magnitude)
+    current_magnitude[current_magnitude == -1000] = np.nan
+    current_magnitude = interpolate_data(current_magnitude)
+    print(len(current_magnitude))
+
+
+    result.append({
+        'time': np.array(current_timestamp),
+        'global_time': np.array(global_timestamp),
+        'people': people,
+        'magnitude': current_magnitude,
+        'phase': np.array(current_phase)
+    })
+
+output_file = './data_sequence_linear.pkl'
+with open(output_file, 'wb') as f:
+    pickle.dump(result, f)

data_process_example/process_cv.py

@@ -0,0 +1,112 @@
+import os
+import tqdm
+import cv2
+import numpy as np
+import pickle
+
+# root="./cv"
+root="/home/chentingwei/LoFi/lofi"
+
+
+# 加载 YOLO 模型
+net = cv2.dnn.readNet("./model/yolov3.weights", "./model/yolov3.cfg")
+# 获取输出层的名称
+layer_names = net.getLayerNames()
+output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]
+
+src_points = np.array([[0, 0], [180, 0], [0, 480], [180, 480]], dtype="float32") # real world
+dst_points = np.array([[222, 210], [374, 209], [65, 458], [495, 451]], dtype="float32") # image world
+
+
+M = cv2.getPerspectiveTransform(src_points, dst_points)
+
+data=[]
+
+def get_gt(img_path,net):
+    image = cv2.imread(img_path)
+    # 加载图像
+    height, width, channels = image.shape
+
+    # 准备输入图像
+    blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
+    net.setInput(blob)
+    outs = net.forward(output_layers)
+
+    # 解析 YOLO 输出，找到人体边界框
+    class_ids = []
+    confidences = []
+    boxes = []
+
+    for out in outs:
+        for detection in out:
+            scores = detection[5:]
+            class_id = np.argmax(scores)
+            confidence = scores[class_id]
+            if confidence > 0.5:  # 置信度阈值
+                center_x = int(detection[0] * width)
+                center_y = int(detection[1] * height)
+                w = int(detection[2] * width)
+                h = int(detection[3] * height)
+                x = int(center_x - w / 2)
+                y = int(center_y - h / 2)
+                boxes.append([x, y, w, h])
+                confidences.append(float(confidence))
+                class_ids.append(class_id)
+
+    # 如果检测到了多个框，只保留置信度最高的那个框
+    if len(boxes) > 0:
+        max_confidence_idx = np.argmax(confidences)
+        boxes = [boxes[max_confidence_idx]]
+    x, y, w, h = boxes[0]
+    foot_position_image = (x + w // 2, y + h)
+
+    person_img_coords = np.array([[foot_position_image[0], foot_position_image[1]]],
+                                 dtype="float32")
+    actual_coords = cv2.perspectiveTransform(np.array([person_img_coords]), np.linalg.inv(M))
+    return actual_coords[0,0,0],actual_coords[0,0,1]
+
+
+people_id=0
+for people in os.listdir(root):
+    print(people)
+    path=os.path.join(root,people)
+
+    pbar = tqdm.tqdm(os.listdir(path))
+
+    x_list = []
+    y_list = []
+    img_path_list = []
+    time_list = []
+
+    for pic in pbar:
+        if "color" not in pic:
+            continue
+
+        # print(pic)
+        timestamp = pic.split("_")
+        timestamp = timestamp[-1].split(".")
+        timestamp = timestamp[0]
+        timestamp = timestamp.split("-")
+        # print(timestamp)
+        timestamp = float(timestamp[0]) * 60 * 60 * 100 + float(timestamp[1]) * 60 * 100 + float(timestamp[2]) * 100 + float(timestamp[3])
+
+        img_path = os.path.join(path, pic)
+        x, y = get_gt(img_path, net)
+        x_list.append(x)
+        y_list.append(y)
+        img_path_list.append(img_path)
+        time_list.append(timestamp)
+
+    data.append({
+        'timestamp': np.array(time_list),
+        'people_name': people,
+        'people': people_id,
+        'x': np.array(x_list),
+        'y': np.array(y_list),
+        'img_path': img_path_list
+    })
+    people_id += 1
+
+output_file = './gt_data.pkl'
+with open(output_file, 'wb') as f:
+    pickle.dump(data, f)