Is it possible to deactivate just 3d detection at runtime? We want to reduce cpu load while still beeing able to see if the eyes can be tracked live. We would like to calculate both 2d and 3d detection posthoc.

Thx

i added my changes to the ttl.py example you gave earlier, thats working now. i now added the function in line 30 in order to stop the 3d detector plugin - based on the example you linked above. aparently line 36 never executes, at least i cant see any printout in the command window. do you have time to assist with this code? i dont understand the structure of the pupil labs code, nor python syntax very well. thx.

i was suspecting load order, but i didnt get when this list was populated - thx a lot. its working now.

We have yet another problem that we cant seem to solve. we use the attached plugin. in line 59 we toggle the TTL for each received frame of eye 0 while self._recording is true. in some recordings it occures that we receive more TTL inputs at the TTL recording device than there are frames of eye0 in "eye0_timestamps.npy". i can explain that one more TTL than npy entry could occure.: if we record an uneven number of frames the TTL line is still high when the recording stops and the stop recording resets the TTL line back to 0 (a toggle) although there was no frame. that happens whenever the recording has an uneven number of frames. we can filter that out. our data however shows that it can occure, that there is an additional 1 to 4 TTL triggers recorded that we can not match to npy entries (there is simply 4 TTL toggles more than npy entries). by shifting the npy and the received TTL vectors against eachother and checking theire time values it becomes clear that the frames which are missing in the npy are the first few frames. i was under the assumption, that when "self._recording" is true every event in line 50 reaches the npy file of the corresponding eye. is there any possibility that this is not the case? how can i improove the filter condition in line 54 to be sure to only toggle the TTL when the frame will actually reach the npy?

if the numer of frames in the npy would be 1000 and there would be 1004 matching triggers we could just drop the initial 4 TTL triggers i guess. its still odd to me how this can happen.

Hi @user-aadbbd, moving the conversation here. Can you confirm that in your filter_gaze_on_surface.py script run from Psychopy, the key on line 37 is "gaze_on_surfaces" and not "gaze on surfaces"?

If you could provide the full traceback as well as the neighbouring source code of were the error appears, we might be able to help you. Also, are you subscribing to more topics than surface?

Please try changing the code to

try:
  gaze_positions = filtered_surface["gaze_on_surfaces"]
except KeyError as err:
  raise ValueError(f"surface={filtered_surface}") from err

This will print out the content of filtered_surface in case it does not contain the expected key

Interestingly, the PsychoPy Runner constantly prints "[]" when I run the unedited filter_gaze_on_surface.py...

I think my stuff solved itself by one of our bugs, sorry.

im not sure if anyone has had this issue before, and it's not a pupil related question (i figured i might ask here anyway), but for some reason when I have my vive headset on, and i run my project in editor, it seems that time moves at about a x0.5 scale

my fixed timestep is 0.05, and my vive cosmos runs at 90fps, and if i set the timeScale to 200/90 (where 200Hz corresponds to 0.05 fixed time step and 90 is the refresh rate of the headset), everything in my project seems to run as normal

Hi, when I try to do the calibration, only one circle displayed in the center of the screen, and no other circles showed in the corner of screen next, so I can not complete the calibration, what should I do?

Are you using the screen marker or the single marker calibration choreography?

Then it is likely that your scene camera is not correctly setup. Please make sure the screen is fully visible during the procedure. The marker's center will turn from red to green once the marker is being detected. If the marker is detected sufficiently long, the choreography will continue with the next marker.

In this case, I would also like to note that the correct setup of the eye cameras is crucial for the pupil detection and gaze estimation to work. See https://docs.pupil-labs.com/core/#_1-put-on-pupil-core and https://docs.pupil-labs.com/core/hardware/#headset-adjustments for details.

Is there anyway to save/load calibrations for the vive add-on? Also, is there anyway to load camera settings (ROI, 3D model, etc)?

Loading calibrations works by starting the corresponding gazer plugin (via the start_plugin notification) with the correct parameters. These are announced as a notification once the calibration was successful. Use this as an example on how to listen to notifications https://github.com/pupil-labs/hmd-eyes/blob/master/python_reference_client/filter_messages.py (I recommend disabling line 32)

The topics to look for are notify.calibration.successful and notify.calibration.result.v2.

Regarding camera settings: There is a variety of pupil detector settings you can retrieve and set via the pupil detector network api https://github.com/pupil-labs/pupil-helpers/blob/master/python/pupil_detector_network_api.py Unfortunately, setting the 3d model is not one of them. 😕

@user-28c35b Following up on https://discord.com/channels/285728493612957698/285728493612957698/862969137332092959

The issue is that the network API does not guarantee you an even sampling rate. You will need to buffer the samples and do some kind of matching.

Pupil Capture does that already for gaze data. So if you are looking for binocular pairs, I suggest subscribing to gaze (requires a valid calibration).

Generally, what you are trying to do is much easier when done post-hoc. Are you 100% sure you need to calculate this in real-time?

Yes, I am trying to calculate some metric (The Low/High Index of Pupillary Activity) in real time, I need diameter from both pupils for this.

Thank you for the help, I try to implement it this way. 👍

Hi, I have pupil core and i need to dynamically modify the minimum duration of the fixation detector, this parameter will depend on the person who will use the software. Is there a way to set it directly in python? using notification system or publishing on certain topics?

Yes, is like this one? {"subject": "start_plugin", "name": "...", "args": {...}}

I will try and i'll let you know, Thanks so much!!

How do I create a remote annotation based on a keypress?

You start by taking this remote annotations example https://github.com/pupil-labs/pupil-helpers/blob/master/python/remote_annotations.py and extend it to send annotations as soon as the user presses a key. (How to capture a keypress is highly dependent on the framework that you are using)

@papr This model confidence metric is a really timely update.'

In the next few days, we're going to hit you with a doc detailing our efforts to turn our segmentatnoi network into a Pupil Labs plugin.

Sneak-preview: A fixation-based assessmetn (9 point grid in VR) shows that it is very robust, very precise, but not very accurate.

We have spent long enough debugging htat we feel we might benefit from some input from the PL team, if they can offer it.

All our efforts will be open source.

Thanks 🙂

Haha. Yes, we know. In the end, it's a very complicated measure of "how elliptical is your mask?"

I know, a bit more complicated than that, but that captures the spirit of it.

@user-3cff0d should share his diagram of it with you - he spent quite a bit of time wrapping his head around the algorithm.

Oh, oh, sorry, no - and that's my fault.

Nevermind.

🙂 🙂

Yes, looking forward to playing with the new p3d model confidence metric (I was confusing it with the pupil confidence metric for a moment)

Long day.

Ah ok. No worries. 🙂 Feedback is welcome.

@papr Here is the flowchart in question. Does this line up with your understanding of the 2d detector's confidence algorithm? Please forgive me if some of the function names are inaccurate, they were based off of a recreation.

Sure, I would be okay with it

When I create a remote annotation, it does not load in Pupil Player (annotations.pldata is empty). Below is my relevant code, but it's largely just pupil helper code. I don't get any error messages either when running the program.

#set pupil time to psychopy time
pupil_time = core.Clock()
time_fn = pupil_time.getTime()
req.send_string("T" + str(time_fn))
print(req.recv_string())
# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__))
os.chdir(_thisDir)

def notify(pupil_remote, notification):
    """Sends ``notification`` to Pupil Remote"""
    topic = "notify." + notification["subject"]
    payload = serializer.dumps(notification, use_bin_type=True)
    pupil_remote.send_string(topic, flags=zmq.SNDMORE)
    pupil_remote.send(payload)
    return pupil_remote.recv_string()


def send_trigger(pub_socket, trigger):
    """Sends annotation via PUB port"""
    payload = serializer.dumps(trigger, use_bin_type=True)
    pub_socket.send_string(trigger["topic"], flags=zmq.SNDMORE)
    pub_socket.send(payload)


def new_trigger(label, duration, timestamp):
    """Creates a new trigger/annotation to send to Pupil Capture"""
    return {
        "topic": "annotation",
        "label": label,
        "timestamp": time_fn,
        "duration": duration,
    }

# Start the annotations plugin
notify(
        req,
        {"subject": "start_plugin", "name": "Annotation_Capture", "args": {}},
    )

#req.send_string('C')

#start recording
req.send_string('R')
req.recv_string()


label = "start experiment"
duration = 0.1
minimal_trigger = new_trigger(label, duration, pupil_time)
send_trigger(pub_socket, minimal_trigger)
sleep(1)  # sleep for a few seconds, can be less

This code follows the old time sync convention using the T command. I highly recommend switching to our new example https://github.com/pupil-labs/pupil-helpers/blob/master/python/remote_annotations.py

Independently, I think this line needs changing:

- time_fn = pupil_time.getTime()
+ time_fn = pupil_time.getTime
- req.send_string("T" + str(time_fn))
+ req.send_string("T" + str(time_fn()))
...
-        "timestamp": time_fn,
+        "timestamp": timestamp,
...
- minimal_trigger = new_trigger(label, duration, pupil_time)
+ minimal_trigger = new_trigger(label, duration, pupil_time())

time_fn needs to be a function that can be called over and over again. In your example, it is a measured timestamp instead. As a result, all your annotations get the same timestamp assigned. Instead, you want to call the time function when you want to measure time. The linked example above should make this more clear as well.

My bad!

- minimal_trigger = new_trigger(label, duration, pupil_time)
+ minimal_trigger = new_trigger(label, duration, time_fn())

time_fn() instead of pupil_time(). The naming of the latter is not quite good as it is actually a local clock instance which has a get_time() function

Are you getting the confirmation that you have received an annotation?

Can you confirm that the annotation plugin and recording are started?

The plugin has a menu entry on the right. If the menu is present, the plugin is running

What is your code for pub_socket?

Again, if you have the time, I highly recommend switching the time sync strategy

It is more than just copying some code from the example, I am afraid. Please try to understand what the code is doing such that you can apply it correctly to your experiment. See also https://github.com/pupil-labs/pupil-helpers/blob/master/python/simple_realtime_time_sync.py for more context.

local_clock can be time_fn / core.Clock().getTime

Is there a way to instruct Player to perform its gaze detection, and instruct it to perform an export (like an 'e' press) through the Network API?

Is it a common issue to have one screen go dark after calibrating when using a dual monitor setup? Specifically, I have Pupil running on one screen, and then calibration dots will appear on the other. Then, the screen that has the calibration dots turns black after calibration is complete.

Hi @papr , may I ask if there is a way to obtain the location of the surface marker as to the frame capture by the world camera?

Please see this tutorial https://github.com/pupil-labs/pupil-tutorials/blob/master/04_visualize_surface_positions_in_world_camera_pixel_space.ipynb

Thanks a lot!

I've figured it out, but I have to modify the surface_tracker.py

yes, add

"surf_to_dist_img_trans": surface.surf_to_dist_img_trans.tolist(),

after line 491

That will be nice. Thanks!

Hi all. I'm hoping you can help. I'm looking for a hardware-software combination that can give me realtime values of independent left and right pupil positions. The context here is that I have strabismus and would like to develop (for myself) a feedback loop that allows me to determine, during an eye exercise, if I've correctly aligned my eyes.

A provisional poke around various webcam-based open source solutions suggest they're not accurate enough and could give a lot of false positives.

Is this kind of thing viable with Pupil? A superficial scan of the docs suggests (at least from an API perspective) "yes" but I'm wondering if the system as a whole would be good at this task?

Edit: note that this requirement means I need to determine the degree of deviation of both pupils from where they "should" be. I suspect this presents a problem in that heads aren't symmetric and the real-world target I'm testing my eyes against may not be perfectly aligned. So chances are fundamentally this isn't practical outside VR.

Hi, i'm developing an application in unity and i'm using c#. I imported the packages and tested the demo scenes following your documentation and everything works. I also tried the connection with Pupil Capture and following some examples i was able to create some test scenes. Now i need to read data related to fixations on surfaces but i have a problem with data structure. void receiveCustomData(string topic, Dictionary<string, object> dictionary, byte[] thirdFrame = null) Inside this function i was able to read dictionary["fixations_on_surfaces"] but then how can i access the dictionary inside? The one with "topic", "normpos", "confidence", etc.. I can easily read the other data like "name" or "timestamp". Using python i had no problem.

The challenge is that you need to perform a calibration in order to get comparable gaze direction estimates from both eyes. And the default calibration assumes that you are able to fixate the calibration target with both eyes at the same time. You would need to develop a calibration choreography plugin that supports collecting eye data from one eye at a time.

@user-a09f5d has been doing work/research in this regard. Maybe they can share their experiences.

I checked the data structure from here: https://docs.pupil-labs.com/developer/core/overview/#surface-datum-format

If you use these dual-monocular gaze estimators [1], you can receive gaze direction estimates for both eyes independently via our real-time network API (some delay due to data transfer included of course)

[1] https://gist.github.com/papr/5e1f0fc9ef464691588b3f3e0e95f350

Could you confirm that you only need help with understanding the inner structure of this dictionary? Or do you also need help accessing it using c# syntax?

I also have a more general question: Are your performing eye tracking in a VR or an AR environment? And if yes, which of both?

dictionary["fixations_on_surfaces"] is a list/array. Unfortunately, since I do not know c#, I cannot tell you why this would not cast.

Hi, i was thinking, is there a way to subscribe to a topic within a topic. For example I have a surface to track which is called "test". I am interested in the data only for the fixation on this surface. To read all the data I subscribe to the topic "surfaces.test"is there a way to subscribe directly to "surfaces.test.fixation_on_surfaces" topic?

Hi, @papr, here's the code we used to open, edit, and save the .pldata file. In this code, we're saving the edited pldata to a new file

Hi, I am using core, and I get the data subscribing to gaze. I need pupil size and blinks; I can get the pupil size with no problem, but I am not getting the blink data, even though I have turned on the setting for blinks in the pupil capture software. Is there something I am doing wrong? or maybe I have to subscribe to another topic?

Thank you! I didn't find it in the docs, maybe I wasn't looking in the right place 🙂

@papr Hi, if you have any suggestions for getting this to function as it should, please let us know!

Hello, is there any documentation for pye3d? I have looked everywhere but maybe I am missing something

https://docs.pupil-labs.com/developer/core/pye3d/#pye3d-pupil-detection

Unfortunately, not, no. The entry point for reading the source code would be: https://github.com/pupil-labs/pye3d-detector/blob/master/pye3d/detector_3d.py#L102

Thank you! This would suffice for my usage for now I guess

Hello, I'm using the pupil core eyetracker and would like to use the blink_detector pupillabs offers. Is it possible to export the blink data, as visible in pupil player, in a csv file when exporting? Thanks in advance!

Hello! Is there a C++ library for Pupil Core (mono) eye tracker?

Are you aware of the existing blink detector export data? Does it not provide what you need?

This is with Python, I need actually for my C++ project to integrate the eye-tracker. I see some random projects, however, not working.

Thanks. I will try then.

It does clarify the question, thank you!

However the timestamps do not correspond with the timestamps in the surface export. Are you referring to the fact that they do not match exactly or that they are off completely?

Is that normal? I figured the timestamps should match the gaze_timestamps in the surface export

You will have to assign the blink yes/no value for each surface-mapped gaze based on the condition if its timestamp falls into any of the blinks periods or not (blink_start_ts <= gaze_ts <= blink_end_ts)

Okay thanks a lot for the extra information!

sounds good, thank you!

Hi papr, my monitor turns off after calibration. Is there a way to fix this?

displays a black image. This only occurs when I have a dual monitor setup and they're displaying different things

The screen that the calibration appears on goes black. And then, when I close pupil, it opens again..

But this doesn't occur when I duplicate the displays and display the same information on both of them

https://github.com/pupil-labs/pupil/issues/2143#issue-894510320 Please use window instead of fullscreen mode to workaround this issue.

Yes, go to the calibration settings and disable the "use fullscreen" toggle

I'm trying to end a trial in PsychoPy if a participant looks away from a specified surface (usually monitor). However, it is often the case that the gaze will obviously not be on the monitor, as shown in the Pupil window, but this is not reflected in PsychoPy. I am wondering if I am using norm_gp_x and norm_gp_y wrong, and if they are only defined when the gaze is on the surface..is there a better way to tell if the gaze is on the surface?

#read from remote pupil data and check if they looking at the surface
        topic = sub.recv_string()
        msg = sub.recv()  # bytes
        surfaces = loads(msg, raw=False)
        filtered_surface = {
            k: v for k, v in surfaces.items() if surfaces["name"] == surface_name
        }

        is_gaze_on_surface = True

        try:
            # note that we may have more than one gaze position data point (this is expected behavior)
            gaze_positions = filtered_surface["gaze_on_surfaces"]
            for gaze_pos in gaze_positions:
                norm_gp_x, norm_gp_y = gaze_pos["norm_pos"]

                # only print normalized gaze positions within the surface bounds
                if 0 <= norm_gp_x <= 1 and 0 <= norm_gp_y <= 1:
                    is_gaze_on_surface = True
                else:
                    is_gaze_on_surface = False
                    print(norm_gp_x, norm_gp_y)
        except:
            pass
        if is_gaze_on_surface:
            continueRoutine = True
        else:
            continueRoutine = False #end the routine if they look away

I think the idea is correct, but the implementation can be improved: 1. Filter by confidence. Gaze with confidence < 0.6 can be inaccurate 2. In your implementation, only the last gaze item decides if the routine is stopped or not. You might want to break out of the loop as soon is_gaze_on_surface is true for the first time.

@papr, in your recent response to @user-3cff0d , you suggested that we could reduce error by creating a custom gaze class with a modified scene camera location. Two questions: 1) could you help us find the specific variables you are describing and, 2) If this produces successful recalibrations using our modified pupil detection method, would your team consider making those variables transparent in some way through pupil player?

This is why I love pupil labs. Thanks @papr !

If you have any quick pointers to get @user-3cff0d headed in the right direction, they would be much appreciated. He's quite capable.

You are a king.

Thanks so much!!

@user-3cff0d Could you please share an example VR recording with data@pupil-labs.com that includes reference locations already? I would give this a quick test before sharing.

Edit: Never mind, I roughly annotated a small recording by myself 🙂

👍

Hi @papr, for the line of code In [20] in the link you sent, are we supposed to serialize datum ourselves, or is serialized an attribute of datum? We keep receiving an error on that line.

Okay great, we got it working. We have successfully edited the .npy, .pldata, .json, and .mp4 files. Is editing the .size, .time, .raw, .intrinsics, .mjpeg, .time_aux,

and .bin files necessary for the purposes of our project?

Oh, you are editing pupil invisible recordings?

Do you still have access to the originals, before having them opened in Pupil Player for the first time?

Yes. In this case you would only need to slice the original files, and Player would take care of generating the correct pldata files. This is the PI recording format https://docs.google.com/spreadsheets/d/1e1Xc1FoQiyf_ZHkSUnVdkVjdIanOdzP0dgJdJgt0QZg/edit#gid=254480793

raw and time are just binary files that can be easily read and written with numpy.fromfile and numpy.ndarray.tofile. json I would only touch the info one to adjust start_time and duration. intrinsics is generated by player and does not need adjustments. mjpeg requires same handling as mp4. I would not touch time_aux

Please note, that PI uses nanoseconds since Unix epoch as time.

Sure thing, I'll send one over now

Sent!

@user-b14f98 @user-3cff0d Not sure if you are aware but this recording was recorded 2.1 and eye intrinsics were introduced in https://github.com/pupil-labs/pupil/releases/tag/v2.4 Have you downloaded the intrinsics from the release page? See the caveat for 200Hz Vive Add-on Recordings for more information.

@papr Thanks for reminding us. I'll have to take a look, but there's a chance we have not.

Do you want me to do the pupil detection myself and send over the results?

It would be using our plugin, so the 3d model would likely be better due to the more robust pupil detection in the vr headset.

Gotcha, that would be a correctable problem for future data collection

We do post-hoc pupil detection in Player, with our plugin installed

We've tried that in the past with not-so-great results, but that might have just been because we froze the model at a bad time. We'll give it another shot. Also, we're currently still on version 3.2. I tried to update to 3.4 and got a strange versioning error with one of the dependencies, where it seemed like 2 files required different versions of the same package or something like that

@user-3cff0d @user-b14f98 https://gist.github.com/papr/e57f55ddd02245bbfd99e072b4273fdf this is the current version. It runs without error, but the resulting gaze is all over the place (for your recording as well as mine). Something must still be going wrong very badly. I would appreciate your help with debugging this.

Install the plugin into your Pupil Player plugin folder and it should appear as a gazer option in the post-hoc calibration menu (next to 2d and 3d)

I'll give this a shot and get back to you

Hey, the recording we sent you already had eye intrinsic files. Am I missing something?

Perhaps we were using outdated default intrinsics?

Ok, thanks.

I don't on my person at the moment, no

I work remotely most of the time

Ok, I have everything needed at home but not setup. I can do the test, when I am back from vacation.

To verify the values, we need to run https://github.com/pupil-labs/hmd-eyes/blob/master/python_reference_client/notification_monitor.py + a hmd-eyes realtime calibration. Filtering for start_plugin and GazerHMD3D, we should be able to get the dynamically calculated eye_translations

@user-3cff0d I found the issue. The ref data required a flip of the y axis. Using the new version, I get a validation accuracy of 1.9 compared to 2.9 with the default 3d gaze mapper. /cc @user-92dca7

@user-b14f98 @user-3cff0d I updated the gist. This is the diff https://gist.github.com/papr/e57f55ddd02245bbfd99e072b4273fdf/revisions#diff-81827a6bee15b12e512a80c75d2b0270629db9e9eb5231bc73d7fcc79926cc0c

@user-d1efa8 The whole conversation above is highly relevant for you, too! Please take the time to read it, install the plugin, and give the plugin a try.

That's great! I'll give it a try asap.

How do I actually activate the plugin, or do I just do Post-Hoc Gaze Calibration as normal and it will automatically be used?

Gotcha, thank you

Yes, there is 2D, 3D, and Post-hoc HMD 3D

I'm getting some really bad gaze data with that, it's flying back and forth from frame-to-frame

Is that what you were observing before you applied the fix?

correct

1. Did you do post-hoc pupil detection to get pupil data for the annotated section?
2. Did you playback the gaze during the calibration? The few first seconds are noisy for me, too

However when I switched the setting back to 3D everything looked normal again

The only difference between our setups that I could imagine would be the version difference from 3.2->3.4

I did remove the flip and try again, and the results were even worse. Both have huge errors but without the flip is the worse of the two. I did recalculate both calibration + mapping for each attempt

This is on the same recording you shared with me, correct? Please share the offline_data folder with me. This way I should have the same post hoc pupil data etc like you

Ok, I can confirm that something is def. still going wrong. Only the gaze for the center point is accurate.

1.9° from 94 / 575 samples didn't see the 95/575 samples before 🙈

Ahh, okay

@user-3cff0d I am getting better results (as in: similar to the default headset calib.) when changing this line https://github.com/pupil-labs/pupil/blob/master/pupil_src/shared_modules/gaze_mapping/gazer_3d/calibrate_3d.py#L179

- scales = list(np.linspace(0.7, 10, 5))
+ scales = list(np.linspace(0.7, 100, 5))

Basically, the bundle adjustment tries different the z-depth-scalings and chooses the best one. 10 seems to be too small if the ref data is manually annotated.

@user-3cff0d @user-b14f98 The real-time hmd plugin is making too many assumptions that are not holding true for 2d annotated reference data. I started making some changes to simplify a post-hoc hmd calib: https://github.com/pupil-labs/pupil/pull/2176

It works the same way as the headset calibration but uses different initial eye translations and ref depths. Unfortunately, it yields less accurate gaze (3.5 instead of 2.9). We will have to investigate why.

The external plugin is no longer necessary.

@papr the 3D target locations are stored in this pickle of a dataframe. The most relevant columns are targetLocalPos (with subcolumns x,y,z) and azEst (with subcolumns az, el) . azEst are the cooresponding spherical target coordinates.

FYI, each row is a single trial in our assessment recording for this single subject.

We care only about trials where "trialType" is "CalibrationAssessment" and "targetType" is "fixation"

I am mostly interested in understanding if the camera intrinsics saved by unity are correct. 🙂 Thanks for sharing the data!

I think it would be beneficial if you could start having a look at the gazer code and combining it with https://gist.github.com/papr/48e98f9b46f6a0794345bd4322bbb607 This example shows how to fit a pye3d twosphere model to a set of hand selected pupil data points (e.g. top 10% confidence pupil data). This gives you more control over the model. Combining it with the gazer code, you can build a reproducible gaze estimation pipeline without running Pupil Player.

@papr Does this use recorded pupils ?

Is that the assumption?

It uses pupil player exported 2d pupil data, but you should be able to adjust convert_pupil_datum_observation to your own pipeline output

So, very useful.

No chance you guys have this pipeline already going in-house and are willing to share?

Or did you put the pieces in place, but haven't yet constructed the full offline pipeline?

No, we don't have that yet. That is why I was asking you to look into it 🙂 This is a piece that I built for @user-d1efa8

That looks great! I remember asking about triggering an export as well, but I think there's a method that does that

@papr @user-3cff0d @user-b14f98 yeah will do; I’ll try to get something next week for y’all. We’ve just been recording a lot data lately so I haven’t had any free time

@user-d1efa8 What lab are you with?

Oh, great. https://www.rit.edu/directory/gjdpci-gabriel-diaz

I am Gabriel Diaz. I've met Dora once or twice, in passing.

I'm Kevin Barkevich, I'm one of Dr. Diaz' grad students c:

Oh wow, that’s awesome haha

I’m Josh Calugay, nice to meet y’all

Not a grad student rn, but I will be in October 🙂

Excellent!

Just wondering, do you happen to know Greg DeAngelis ? We’ve been working with him to validate our eye tracking data

Yes, he's just down the road.

We're both members of URochester's Center for Vision Science (although I am actually faculty at RIT, down the road)

What a small world

Or a tight-knit field!

Indeed, the world of vision science is quite small, and collaborative.

I’m glad it is, because I definitely wouldn’t have been able to make it far with this project without help haha