Record videosand save depth maps in same script

ferrari19

Hi,

I'm trying to save videos and then save the depth maps frame by frame but I get errors with the devices
My codes work individually but when I put them together the recording works fine and then when I try to get the depth maps I get a "no available devices" error. I tried to close the device after recording so that it's available for saving the depth maps so I tried to call my function to record inside the

with dai.Device(pipeline) as device:

I get this error: record.start(), "pipeline already running"

What I would want is change this function

def run():

with contextlib.ExitStack() as stack:

# Record from all available devices

device_infos = dai.Device.getAllAvailableDevices()

if len(device_infos) == 0:

raise RuntimeError("No devices found!")

else:

print("Found", len(device_infos), "devices")
devices = []

# TODO: allow users to specify which available devices should record

for device_info in device_infos:

openvino_version = dai.OpenVINO.Version.VERSION_2021_4

device = stack.enter_context(dai.Device(openvino_version, device_info, usb2Mode=False))
# Create recording object for this device

recording = Record(save_path, device, args)

# Set recording configuration # TODO: add support for specifying resolution recording.setTimelapse(args.timelapse)

recording.setRecordStreams(args.save)

recording.setQuality(args.quality)

recording.setMcap(args.mcap)
devices.append(recording)

for recording in devices:

recording.start() # Start recording

timelapse = 0

def roundUp(value, divisibleBy: float):

return int(divisibleBy * math.ceil(value / divisibleBy))

# If H265, we want to start recording with the keyframe (default keyframe freq is 30 frames)

SKIP_FRAMES = roundUp(1.5* args.fps, 30 if args.quality == "LOW" else 1)

args.frame_cnt += SKIP_FRAMES
# Terminate app handler

quitEvent = threading.Event()

signal.signal(signal.SIGTERM, lambda *_args: quitEvent.set())

print("\nRecording started. Press 'Ctrl+C' to stop.")
while not quitEvent.is_set():

try:

for recording in devices:

if 0 < args.timelapse and time.time() - timelapse < args.timelapse:

continue

# Loop through device streams

for q in recording.queues:

new_msg = q['q'].tryGet()

if new_msg is not None:

q['msgs'].append(new_msg)

if checkSync(recording.queues, new_msg.getSequenceNum()):

# Wait for Auto focus/exposure/white-balance

recording.frameCntr += 1

if recording.frameCntr <= SKIP_FRAMES: # 1.5 sec

continue

# Timelapse

if 0 < args.timelapse: timelapse = time.time()

if args.frame_cnt == recording.frameCntr:

quitEvent.set()
frames = dict()

for stream in recording.queues:

frames[stream['name']] = stream['msgs'].pop(0)

recording.frame_q.put(frames)
time.sleep(0.001) # 1ms, avoid lazy looping

except KeyboardInterrupt:

break
print('') # For new line in terminal

for recording in devices:

recording.frame_q.put(None)

recording.process.join() # Terminate the process

print("All recordings have stopped successfuly. Exiting the app.")

it is from luxonis/depthai-experimentsblob/master/gen2-record-replay/record.py

what I would want is call this function in my other script after this line

with dai.Device(pipeline) as device:

if name == 'main':

run(device)

so that it doesn't search for available devices but rather takes the device that is already being used

is it possible?

Thank you in advance

jakaskerl

Hi @ferrari19
Something like this? (GPT)

Integrating the recording function directly within another script that utilizes the same device (especially with DepthAI and the OAK-D cameras) can lead to conflicts if the device is not properly managed between tasks. The error "pipeline already running" occurs because the DepthAI pipeline is designed to be started once per device session; attempting to start a new pipeline on a device that already has a running pipeline will result in this error.

To achieve the desired functionality where you want to record videos and then save the depth maps frame by frame without searching for available devices again, you will need to modify your approach to ensure that the device and pipeline management accommodates sequential operations without conflicting resource access. Here’s a conceptual approach to achieve this:

Step 1: Modify the Recording Function to Accept an Existing Device

You need to modify the run() function (or create a new version of it) that accepts an already initialized dai.Device object instead of searching for and initializing a new device. This requires changing the function signature and removing the part where it searches for available devices.

Here's a conceptual modification to your run() function to accept an existing device:

def run_with_existing_device(device, save_path, args):
    # Assuming device is an already initialized dai.Device object
    # and other necessary arguments like save_path and args are provided

    # Create recording object for this device
    recording = Record(save_path, device, args)
    # Set recording configuration
    recording.setTimelapse(args.timelapse)
    recording.setRecordStreams(args.save)
    recording.setQuality(args.quality)
    recording.setMcap(args.mcap)

    # Start recording
    recording.start()

    # The rest of your logic here, modified as necessary to accommodate
    # the changes in how the device is managed.

Step 2: Integrate the Modified Recording Function

After modifying the recording function, you can call it directly after your existing device operations, passing the already initialized device. This assumes that your device pipeline is compatible with both the recording operation and whatever operations you perform before calling run_with_existing_device().

Here's how you might integrate this into your main script:

if __name__ == '__main__':
    # Setup your pipeline here
    pipeline = dai.Pipeline()

    # Other pipeline configuration...

    # Initialize the device with the pipeline
    with dai.Device(pipeline) as device:
        # Perform initial operations...

        # Now call the modified recording function with the existing device
        run_with_existing_device(device, save_path, args)

Thanks,
Jaka

ferrari19

Thank you for your answer! that's what I was trying to do but I got the error "pipeline is already running" for the line recording.start() so I removed it and now I have this error "Record object has no attribute queues" and so I'm not sure what do now

heres' my run method

Thank you in advance

jakaskerl

Hi @ferrari19
Record class constructor looks like this:

class Record:
    """
    This class records depthai streams from OAK cameras into different formats.
    It will also save calibration .json, so depth reconstruction will be possible.
    """

    def __init__(self, path: Path, record_type: RecordType):
        """
        Args:
            path (Path): Path to the recording folder
            record_type (RecordType): Recording type
        """

Then when you want to start recording (with an existing device) you can call recording.start(device):

    def start(self, device: dai.Device, xouts: List[XoutFrames]):
        """
        Start recording process. This will create and start the pipeline,
        start recording threads, and initialize all queues.
        """
        self.mxid = device.getMxId()
        self.path = self._create_folder(self.folder, self.mxid)
        calib_data = device.readCalibration()
        calib_data.eepromToJsonFile(str(self.path / "calib.json"))

        self.recorder.update(self.path, device, xouts)

        self.frame_q = Queue(maxsize=20)
        self.process = Thread(target=_run, args=(self.recorder, self.frame_q))
        self.process.start()

might require a different version though.

Thanks,
Jaka

ferrari19

I had tried this also butI got this error

TypeError: Record.start() takes 1 positional argument but 2 were given

a different version of depthai you mean?

Thank you in advance