EventSleep2/plot_ev_framesv2.py at main · ropertunizar/EventSleep2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import os
import numpy as np
import matplotlib.pyplot as plt


from events_to_frames import process_event_stream
import aedat
import pandas as pd
import csv
from pathlib import Path


def aedatevents_to_npyframes(root_dir, chunk_len_ms=150, k=1, max_time_ms=512, toy_data=True):


    f_name = f'{root_dir}/night_events.aedat4'

    # frames_dir = f'{Path(root_dir).parent.parent.as_posix()}/EventFrames'
    # if not os.path.exists(frames_dir):  os.makedirs(frames_dir)
    # out_dir = f'{frames_dir}/TEST_FULL_SEQUENCE'
    # if not os.path.exists(out_dir):  os.makedirs(out_dir)

    npy_name = f'{root_dir}/frames.npy'
    # labels_frames_f_name = f'{out_dir}/Labels_frames.csv'

    # labels_events_f_name = f'{root_dir}/Labels.csv'
    # all_labels = pd.read_csv(labels_events_f_name)
    # SCLabels = all_labels.query('Subject == @subject').query('Config == @config')

    minTime, maxTime = -1, max_time_ms * 1000
    chunk_len_us = chunk_len_ms * 1000
    height, width = 480, 640

    if minTime == -1: minTime = chunk_len_ms * 1000 / k

    decoder = aedat.Decoder(f_name)

    init_t = None
    # In case the event camera log also grayscale images
    total_events = np.empty((0, 4), dtype=np.uint)
    total_frames = np.empty((0, height, width, k, 2))
    # I = SCLabels.iloc[0]['TSInit'] * 1000
    # O = SCLabels.iloc[-1]['TSEnd'] * 1000

    frame_labels = []
    timestamps_ini = []
    timestamps_end = []
    for packet in decoder:
        if "events" in packet:
            events = packet['events']
            if not init_t: init_t = events['t'][0]
            events = np.array([events['x'], events['y'], events['t'], events['on']]).transpose()
            total_events = np.append(total_events, events, axis=0)
            min_t, max_t = total_events[:, 2].min(), total_events[:, 2].max()
            expected_max = min_t + chunk_len_us
            if max_t - min_t >= chunk_len_us:
                events_inds = total_events[:, 2] < expected_max
                frame_events = total_events[events_inds]
                total_events = total_events[~events_inds]

                # events_inds = I < frame_events[:, 2]
                # frame_events = frame_events[events_inds, :]
                # events_inds2 = frame_events[:, 2] < O
                # frame_events = frame_events[events_inds2, :]

                if total_frames.shape[0] == 104:
                    print('Frame shape:', total_frames.shape)
                    print('Frame events shape:', frame_events.shape)
                    print('Frame events:', frame_events)
                    print('Total events:', total_events.shape)
                    print('Total events:', total_events)

                if frame_events.size != 0:
                    max_ts_frame = frame_events[:, 2].max()
                    timestamps_ini.append(frame_events[:, 2].min())
                    timestamps_end.append(frame_events[:, 2].max()+1)
                    ev_frames, _ = process_event_stream(frame_events, height, width, chunk_len_us, k, minTime, maxTime)
                    ev_frames = ev_frames.astype(f'float32')
                    total_frames = np.vstack([total_frames, ev_frames])
                    # timestamps_ini.append(frame_events[0, 2])
                    # timestamps_end.append(frame_events[-1, 2])

                # if ev_frames.size != 0:
                    #     row = SCLabels[
                    #         (SCLabels['TSInit'] * 1000 <= max_ts_frame).values * (
                    #                 max_ts_frame < SCLabels['TSEnd'] * 1000).values]
                    #     frame_label = row['LabelF-G'].values[0]
                    #     frame_labels.append(int(frame_label))


    # file_exists = os.path.isfile(labels_frames_f_name)
    # with open(labels_frames_f_name, 'a', newline='') as file:
    #     writer = csv.writer(file)
    #     if not file_exists:
    #         writer.writerow(["Subject", "Config", "Label", "InitFrame", "EndFrame"])
    #     init = 0
    #     for j in range(1, len(frame_labels)):
    #         if frame_labels[j] != frame_labels[j-1]:
    #             end = j-1
    #             writer.writerow([subject, config, frame_labels[j-1], init, end])
    #             init = j
    #     writer.writerow([subject, config, frame_labels[j-1], init, j])
        # writer.close()
    np.save(npy_name, total_frames)
    # np.save(f'{root_dir}/timestamps.npy', np.array(timestamps))
    # Save also the timestamps in a csv file
    # pd_t = pd.DataFrame(timestamps_ini, timestamps_end, columns=['timestamp_ini', 'timestamp_end'])
    pd_t = pd.DataFrame({'timestamp_ini': timestamps_ini, 'timestamp_end': timestamps_end})
    pd_t.to_csv(f'{root_dir}/timestamps.csv', index=False)

root_dir_in = f'{os.path.dirname(os.path.abspath(__file__))}/DATA/Datasetv2'
root_dir_out = f'{os.path.dirname(os.path.abspath(__file__))}/DATA/out_frames'

# for folder in os.listdir(root_dir_in):
for folder in [ 'Noche_Carlos_IRSinBanda_19_03_2025']:
    if not os.path.exists(f'{root_dir_out}/{folder}'):
        os.makedirs(f'{root_dir_out}/{folder}')

    frame_id = 0
    # for subfolder in sorted(os.listdir(os.path.join(root_dir_in,folder))):
    # for subfolder in ['11']:
    # if not os.path.exists(f'{root_dir_in}/{folder}/frames.npy'):
    # print(f'Creating frames for {folder}/{subfolder}')
    aedatevents_to_npyframes(os.path.join(root_dir_in, folder), chunk_len_ms=150, k=1,
                             max_time_ms=512, toy_data=True)

    # if not os.path.exists(f'{root_dir_out}/{folder}/{subfolder}'):
    #     os.makedirs(f'{root_dir_out}/{folder}/{subfolder}')

    # frames = np.load(f'{root_dir_in}/{folder}/frames.npy')
    #
    # for i, frame in enumerate(frames):
    #     fig, axs = plt.subplots(1, 1)
    #     mpos = frame[:,:,0,0]
    #     mpos[mpos == 0] = np.nan
    #     mpos = mpos.astype(np.float32)
    #     axs.imshow(mpos, alpha=0.5, cmap='Reds')
    #
    #     mneg = frame[:,:,0,1]
    #     mneg[mneg == 0] = np.nan
    #     mneg = mneg.astype(np.float32)
    #     axs.imshow(mneg, alpha=0.5, cmap='Greens')
    #
    #     fig.savefig(f'{root_dir_out}/{folder}/frame_{frame_id:06d}.png')
    #     plt.close(fig)
    #     frame_id += 1