neurotask 0.2.0__tar.gz

neurotask-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gianluca Capelo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neurotask-0.2.0/PKG-INFO

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: neurotask
+Version: 0.2.0
+Summary: A Python package for analyzing neuropsychological tasks data
+Author: NeuroLIAA
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NeuroLIAA/neurotask
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+  # Neurotask
+
+## Description
+
+**Neurotask** is a Python library designed to facilitate the analysis and processing of neuropsychological task data.
+
+## Installation
+
+You can install **neurotask** via pip:
+
+```bash
+pip install neurotask
+```
+
+or from the local repository (run from the repository root, where `pyproject.toml` is):
+
+```bash
+pip install .
+```
+
+If you're developing the package and want changes to the code to be immediately reflected without reinstalling, you can
+use the -e option to install the package in "editable" mode, including the development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage Example
+
+Here's a simple example of how to use the **neurotask** library to perform a Trail Making Test (TMT) analysis:
+
+```python
+from neurotask.tmt.tmt_analyzer import TMTAnalyzer
+from / path / to / your / custom_mapper
+import CustomMapper
+
+# Initialize the TMT Analyzer
+analysis = TMTAnalyzer(
+    mapper=CustomMapper(),
+    dataset_path="/path/to/your/dataset",
+    output_path="/path/to/save/results",
+    correct_targets_minimum=12,
+    consecutive_points=5
+)
+
+# Run the analysis
+analysis.run()
+
+# Retrieve and display metrics
+metrics_df = analysis.get_metrics_dataframe()
+print(metrics_df.head())
+
+# Retrive the experiment to access tmt model
+experiment_model = analysis.experiment
+```
+
+## CSV Output Format
+
+After running the TMT analysis, the results are saved as a CSV file. Each row in the CSV represents a trial (valid or
+invalid) and contains the following columns:
+
+| Column Name                  | Data Type      | Description                                                                                  |
+|------------------------------|----------------|----------------------------------------------------------------------------------------------|
+| **subject_id**               | String         | Unique identifier for the subject.                                                           |
+| **trial_id**                 | String         | Unique identifier for the trial.                                                             |
+| **trial_type**               | String         | The type of trial, represented by its name.                                                  |
+| **age**                      | Number         | Age of the subject (in years).                                                               |
+| **gender**                   | String         | Gender of the subject.                                                                       |
+| **is_valid**                 | Boolean        | Indicates whether the trial is valid (`True`) or invalid (`False`).                          |
+| **trial_order_of_appearance** | Integer        | The sequential order of the trial within the experiment.                                     |
+| **speed_threshold**          | Float          | The speed threshold calculated for the subject.                                              |
+| **total_distance**           | Float          | Total distance traveled by the cursor during the trial.                                      |
+| **rt**                       | Float          | Reaction time (total duration) of the trial.                                                 |
+| **inter_target_time**        | Float          | Total time outside targets during the trial.                                                 |
+| **intra_target_time**        | Float          | Total time inside targets during the trial.                                                                    |
+| **correct_targets_touches**  | Integer or NaN | Number of correct target touches. For invalid trials, this is set to `NaN`.                  |
+| **wrong_targets_touches**    | Integer or NaN | Number of wrong target touches. For invalid trials, this is set to `NaN`.                    |
+| **mean_speed**               | Float or NaN   | Average cursor speed during the trial.                                                       |
+| **std_speed**                | Float or NaN   | Standard deviation of the cursor speed.                                                      |
+| **peak_speed**               | Float or NaN   | Maximum cursor speed observed during the trial.                                              |
+| **mean_acceleration**        | Float or NaN   | Average acceleration of the cursor during the trial.                                         |
+| **std_acceleration**         | Float or NaN   | Standard deviation of the cursor acceleration.                                               |
+| **peak_acceleration**        | Float or NaN   | Maximum acceleration observed during the trial.                                              |
+| **mean_abs_acceleration**    | Float or NaN   | Average of the absolute acceleration values.                                                 |
+| **std_abs_acceleration**     | Float or NaN   | Standard deviation of the absolute acceleration values.                                      |
+| **peak_abs_acceleration**    | Float or NaN   | Maximum absolute acceleration observed.                                                      |
+| **mean_negative_acceleration** | Float or NaN   | Average of the negative acceleration values (deceleration).                                  |
+| **std_negative_acceleration** | Float or NaN   | Standard deviation of the negative acceleration values.                                      |
+| **peak_negative_acceleration** | Float or NaN   | Most negative acceleration value observed.                                                   |
+| **hesitation_distance**      | Float or NaN   | Distance over which hesitation was observed (if applicable).                                 |
+| **hesitation_time**          | Float or NaN   | Duration of hesitation (if applicable).                                                      |
+| **number_of_crosses**        | Integer or NaN | Number of crosses detected in the trial. Calculated only if enabled; otherwise, set to `NaN`. |
+| **invalid_cause**            | String         | For invalid trials, a description of why the trial was marked invalid.                       |
+
+> **Note:** For invalid trials, many of the metric columns (e.g., distances, speeds, accelerations) will be set to
+> default values or `NaN` to indicate that the trial did not pass validation checks.
+
+
+## Detailed Segment Data
+
+In addition to the aggregated metrics CSV, **neurotask** provides access to detailed segment data for each trial. This data includes information about the segments where correct and incorrect target touches occurred. The detailed segment data is exposed via the `get_segments_data()` method in the `TMTAnalyzer` class. This method returns a dictionary where each key is a `subject_id` and each value is a list of trial segment data for that subject.
+
+For each trial, the segment data includes:
+
+- **trial_id**: Unique identifier for the trial.
+- **correct_segments**: A list of dictionaries, each representing a segment where a correct target was touched.
+- **incorrect_segments**: A list of dictionaries, each representing a segment where an incorrect target was touched.
+
+### Segment Structure
+
+Each segment dictionary (in both `correct_segments` and `incorrect_segments`) includes the following keys:
+
+- **target**: Dictionary with details of the target, including:
+  - **content**: *String* — The content or label of the target.
+  - **position**: *Dictionary* — The position of the target.
+- **start_cursor**: Dictionary with details about the cursor when it first entered the target area, including:
+  - **position**: *Dictionary* — The starting cursor position.
+  - **time**: *Float* — The timestamp when the cursor entered the target area.
+- **end_cursor**: Dictionary with details about the cursor when it exited the target area, including:
+  - **position**: *Dictionary* — The ending cursor position.
+  - **time**: *Float* — The timestamp when the cursor exited the target area.
+
+**Position Dictionary Structure**:  
+For any dictionary that includes a `position` key, the structure is as follows:
+- **x**: *Float* — The x-coordinate.
+- **y**: *Float* — The y-coordinate.
+### Usage Example
+
+Below is an example of how to retrieve and work with the detailed segment data:
+
+```python
+from neurotask.tmt.tmt_analyzer import TMTAnalyzer
+from my_mapper import CustomMapper
+
+# Initialize the TMT Analyzer
+analyzer = TMTAnalyzer(
+    mapper=CustomMapper(),
+    dataset_path="path/to/your/dataset",
+    output_path="path/to/save/results"
+)
+
+# Run the analysis (override parameters as needed)
+analyzer.run(
+    correct_targets_minimum=12,
+    consecutive_points=5,
+    cut_criteria="MINIMUM_TARGETS",
+    calculate_crosses=True
+)
+
+# Retrieve the detailed segments data
+segments_data = analyzer.get_segments_data()
+
+# Example: Access data for a specific subject
+subject_id = "subject_1"
+if subject_id in segments_data:
+    for trial_data in segments_data[subject_id]:
+        print(f"Trial ID: {trial_data['trial_id']}")
+        print("Correct segments:", trial_data["correct_segments"])
+        print("Incorrect segments:", trial_data["incorrect_segments"])
+else:
+    print(f"No segment data found for {subject_id}")
+```
+
+### Example: Detailed Segment Data for a Single Trial
+
+Below is a sample JSON representation of the segment data for one trial of a given subject. In this example, the subject participated in trial `"trial_id_3"`. This example contains only one correct segment and one incorrect segment.
+
+```json
+{
+  "trial_id": "trial_id_3",
+  "correct_segments": [
+    {
+      "target": {
+        "content": "A",
+        "position": {
+          "x": 123.45,
+          "y": 67.89
+        }
+      },
+      "start_cursor": {
+        "position": {
+          "x": 120.00,
+          "y": 65.00
+        },
+        "time": 0.75
+      },
+      "end_cursor": {
+        "position": {
+          "x": 123.45,
+          "y": 67.89
+        },
+        "time": 1.25
+      }
+    }
+  ],
+  "incorrect_segments": [
+    {
+      "target": {
+        "content": "B",
+        "position": {
+          "x": 200.00,
+          "y": 150.00
+        }
+      },
+      "start_cursor": {
+        "position": {
+          "x": 195.00,
+          "y": 145.00
+        },
+        "time": 2.50
+      },
+      "end_cursor": {
+        "position": {
+          "x": 200.00,
+          "y": 150.00
+        },
+        "time": 3.00
+      }
+    }
+  ]
+}

neurotask-0.2.0/README.md

@@ -0,0 +1,221 @@
+  # Neurotask
+
+## Description
+
+**Neurotask** is a Python library designed to facilitate the analysis and processing of neuropsychological task data.
+
+## Installation
+
+You can install **neurotask** via pip:
+
+```bash
+pip install neurotask
+```
+
+or from the local repository (run from the repository root, where `pyproject.toml` is):
+
+```bash
+pip install .
+```
+
+If you're developing the package and want changes to the code to be immediately reflected without reinstalling, you can
+use the -e option to install the package in "editable" mode, including the development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage Example
+
+Here's a simple example of how to use the **neurotask** library to perform a Trail Making Test (TMT) analysis:
+
+```python
+from neurotask.tmt.tmt_analyzer import TMTAnalyzer
+from / path / to / your / custom_mapper
+import CustomMapper
+
+# Initialize the TMT Analyzer
+analysis = TMTAnalyzer(
+    mapper=CustomMapper(),
+    dataset_path="/path/to/your/dataset",
+    output_path="/path/to/save/results",
+    correct_targets_minimum=12,
+    consecutive_points=5
+)
+
+# Run the analysis
+analysis.run()
+
+# Retrieve and display metrics
+metrics_df = analysis.get_metrics_dataframe()
+print(metrics_df.head())
+
+# Retrive the experiment to access tmt model
+experiment_model = analysis.experiment
+```
+
+## CSV Output Format
+
+After running the TMT analysis, the results are saved as a CSV file. Each row in the CSV represents a trial (valid or
+invalid) and contains the following columns:
+
+| Column Name                  | Data Type      | Description                                                                                  |
+|------------------------------|----------------|----------------------------------------------------------------------------------------------|
+| **subject_id**               | String         | Unique identifier for the subject.                                                           |
+| **trial_id**                 | String         | Unique identifier for the trial.                                                             |
+| **trial_type**               | String         | The type of trial, represented by its name.                                                  |
+| **age**                      | Number         | Age of the subject (in years).                                                               |
+| **gender**                   | String         | Gender of the subject.                                                                       |
+| **is_valid**                 | Boolean        | Indicates whether the trial is valid (`True`) or invalid (`False`).                          |
+| **trial_order_of_appearance** | Integer        | The sequential order of the trial within the experiment.                                     |
+| **speed_threshold**          | Float          | The speed threshold calculated for the subject.                                              |
+| **total_distance**           | Float          | Total distance traveled by the cursor during the trial.                                      |
+| **rt**                       | Float          | Reaction time (total duration) of the trial.                                                 |
+| **inter_target_time**        | Float          | Total time outside targets during the trial.                                                 |
+| **intra_target_time**        | Float          | Total time inside targets during the trial.                                                                    |
+| **correct_targets_touches**  | Integer or NaN | Number of correct target touches. For invalid trials, this is set to `NaN`.                  |
+| **wrong_targets_touches**    | Integer or NaN | Number of wrong target touches. For invalid trials, this is set to `NaN`.                    |
+| **mean_speed**               | Float or NaN   | Average cursor speed during the trial.                                                       |
+| **std_speed**                | Float or NaN   | Standard deviation of the cursor speed.                                                      |
+| **peak_speed**               | Float or NaN   | Maximum cursor speed observed during the trial.                                              |
+| **mean_acceleration**        | Float or NaN   | Average acceleration of the cursor during the trial.                                         |
+| **std_acceleration**         | Float or NaN   | Standard deviation of the cursor acceleration.                                               |
+| **peak_acceleration**        | Float or NaN   | Maximum acceleration observed during the trial.                                              |
+| **mean_abs_acceleration**    | Float or NaN   | Average of the absolute acceleration values.                                                 |
+| **std_abs_acceleration**     | Float or NaN   | Standard deviation of the absolute acceleration values.                                      |
+| **peak_abs_acceleration**    | Float or NaN   | Maximum absolute acceleration observed.                                                      |
+| **mean_negative_acceleration** | Float or NaN   | Average of the negative acceleration values (deceleration).                                  |
+| **std_negative_acceleration** | Float or NaN   | Standard deviation of the negative acceleration values.                                      |
+| **peak_negative_acceleration** | Float or NaN   | Most negative acceleration value observed.                                                   |
+| **hesitation_distance**      | Float or NaN   | Distance over which hesitation was observed (if applicable).                                 |
+| **hesitation_time**          | Float or NaN   | Duration of hesitation (if applicable).                                                      |
+| **number_of_crosses**        | Integer or NaN | Number of crosses detected in the trial. Calculated only if enabled; otherwise, set to `NaN`. |
+| **invalid_cause**            | String         | For invalid trials, a description of why the trial was marked invalid.                       |
+
+> **Note:** For invalid trials, many of the metric columns (e.g., distances, speeds, accelerations) will be set to
+> default values or `NaN` to indicate that the trial did not pass validation checks.
+
+
+## Detailed Segment Data
+
+In addition to the aggregated metrics CSV, **neurotask** provides access to detailed segment data for each trial. This data includes information about the segments where correct and incorrect target touches occurred. The detailed segment data is exposed via the `get_segments_data()` method in the `TMTAnalyzer` class. This method returns a dictionary where each key is a `subject_id` and each value is a list of trial segment data for that subject.
+
+For each trial, the segment data includes:
+
+- **trial_id**: Unique identifier for the trial.
+- **correct_segments**: A list of dictionaries, each representing a segment where a correct target was touched.
+- **incorrect_segments**: A list of dictionaries, each representing a segment where an incorrect target was touched.
+
+### Segment Structure
+
+Each segment dictionary (in both `correct_segments` and `incorrect_segments`) includes the following keys:
+
+- **target**: Dictionary with details of the target, including:
+  - **content**: *String* — The content or label of the target.
+  - **position**: *Dictionary* — The position of the target.
+- **start_cursor**: Dictionary with details about the cursor when it first entered the target area, including:
+  - **position**: *Dictionary* — The starting cursor position.
+  - **time**: *Float* — The timestamp when the cursor entered the target area.
+- **end_cursor**: Dictionary with details about the cursor when it exited the target area, including:
+  - **position**: *Dictionary* — The ending cursor position.
+  - **time**: *Float* — The timestamp when the cursor exited the target area.
+
+**Position Dictionary Structure**:  
+For any dictionary that includes a `position` key, the structure is as follows:
+- **x**: *Float* — The x-coordinate.
+- **y**: *Float* — The y-coordinate.
+### Usage Example
+
+Below is an example of how to retrieve and work with the detailed segment data:
+
+```python
+from neurotask.tmt.tmt_analyzer import TMTAnalyzer
+from my_mapper import CustomMapper
+
+# Initialize the TMT Analyzer
+analyzer = TMTAnalyzer(
+    mapper=CustomMapper(),
+    dataset_path="path/to/your/dataset",
+    output_path="path/to/save/results"
+)
+
+# Run the analysis (override parameters as needed)
+analyzer.run(
+    correct_targets_minimum=12,
+    consecutive_points=5,
+    cut_criteria="MINIMUM_TARGETS",
+    calculate_crosses=True
+)
+
+# Retrieve the detailed segments data
+segments_data = analyzer.get_segments_data()
+
+# Example: Access data for a specific subject
+subject_id = "subject_1"
+if subject_id in segments_data:
+    for trial_data in segments_data[subject_id]:
+        print(f"Trial ID: {trial_data['trial_id']}")
+        print("Correct segments:", trial_data["correct_segments"])
+        print("Incorrect segments:", trial_data["incorrect_segments"])
+else:
+    print(f"No segment data found for {subject_id}")
+```
+
+### Example: Detailed Segment Data for a Single Trial
+
+Below is a sample JSON representation of the segment data for one trial of a given subject. In this example, the subject participated in trial `"trial_id_3"`. This example contains only one correct segment and one incorrect segment.
+
+```json
+{
+  "trial_id": "trial_id_3",
+  "correct_segments": [
+    {
+      "target": {
+        "content": "A",
+        "position": {
+          "x": 123.45,
+          "y": 67.89
+        }
+      },
+      "start_cursor": {
+        "position": {
+          "x": 120.00,
+          "y": 65.00
+        },
+        "time": 0.75
+      },
+      "end_cursor": {
+        "position": {
+          "x": 123.45,
+          "y": 67.89
+        },
+        "time": 1.25
+      }
+    }
+  ],
+  "incorrect_segments": [
+    {
+      "target": {
+        "content": "B",
+        "position": {
+          "x": 200.00,
+          "y": 150.00
+        }
+      },
+      "start_cursor": {
+        "position": {
+          "x": 195.00,
+          "y": 145.00
+        },
+        "time": 2.50
+      },
+      "end_cursor": {
+        "position": {
+          "x": 200.00,
+          "y": 150.00
+        },
+        "time": 3.00
+      }
+    }
+  ]
+}

neurotask-0.2.0/neurotask/neurotask/tmt/config.py

@@ -0,0 +1,8 @@
+"""
+Centralized configuration for TMT analysis.
+"""
+
+# Maximum valid speed threshold (in pixels/millisecond).
+# Speeds above this value are considered measurement errors.
+INVALID_SPEED_THRESHOLD = 8.0
+

neurotask-0.2.0/neurotask/neurotask/tmt/crosses/crosses.py

@@ -0,0 +1,131 @@
+from typing import List, Tuple
+
+from ..model.tmt_model import TMTTrial, Coordinate
+
+def calculate_crosses_for_trial(
+    trial: TMTTrial,
+    crosses_time_threshold: float,
+) -> Tuple[int, List[Tuple[Tuple[Coordinate, Coordinate], Tuple[Coordinate, Coordinate], float]]]:
+    """
+    Calculates the number of times the cursor trail crosses itself, excluding segments that are very near in time.
+
+    Parameters:
+    - trial: TMTTrial object containing the cursor_trail.
+    - crosses_time_threshold: float, the minimum time gap (in milliseconds) between segments to consider them for intersection.
+      Segments with gap < threshold are excluded as "too close in time".
+
+    Returns:
+    - num_crosses: int, the number of times the cursor trail crosses itself.
+    - cross_segments: list of tuples: (seg1, seg2, time_gap) for each detected crossing.
+      time_gap is in milliseconds.
+    """
+    cursor_trail = trial.get_cursor_trail_from_start()
+
+    # Not enough points to form non-adjacent segments
+    if len(cursor_trail) < 4:
+        return 0, []
+
+    # Build segments with endpoint times
+    segments: List[Tuple[Tuple[Coordinate, float], Tuple[Coordinate, float]]] = []
+    for i in range(len(cursor_trail) - 1):
+        p1 = cursor_trail[i].position
+        p2 = cursor_trail[i + 1].position
+        t1 = cursor_trail[i].time
+        t2 = cursor_trail[i + 1].time
+        segments.append(((p1, t1), (p2, t2)))
+
+    num_crosses = 0
+    cross_segments: List[Tuple[Tuple[Coordinate, Coordinate], Tuple[Coordinate, Coordinate], float]] = []
+
+    for i in range(len(segments)):
+        for j in range(i + 1, len(segments)):
+            # Skip adjacent segments (they share a point)
+            if j == i + 1:
+                continue
+
+            # Time interval for each segment
+            t_start_i = min(segments[i][0][1], segments[i][1][1])
+            t_end_i   = max(segments[i][0][1], segments[i][1][1])
+            t_start_j = min(segments[j][0][1], segments[j][1][1])
+            t_end_j   = max(segments[j][0][1], segments[j][1][1])
+
+            # Compute gap between time intervals (0 if overlapping)
+            if t_end_i < t_start_j:
+                time_gap = t_start_j - t_end_i
+            elif t_end_j < t_start_i:
+                time_gap = t_start_i - t_end_j
+            else:
+                time_gap = 0.0
+
+            # Skip if segments are too close in time
+            if time_gap < crosses_time_threshold:
+                continue
+
+            seg1 = (segments[i][0][0], segments[i][1][0])
+            seg2 = (segments[j][0][0], segments[j][1][0])
+
+            if segments_intersect(seg1[0], seg1[1], seg2[0], seg2[1]):
+                num_crosses += 1
+                cross_segments.append((seg1, seg2, time_gap))
+
+    return num_crosses, cross_segments
+
+
+
+def orientation(p: Coordinate, q: Coordinate, r: Coordinate) -> int:
+    """
+    Determines the orientation of the triplet (p, q, r).
+
+    Returns:
+    - 0 : Colinear
+    - 1 : Clockwise
+    - 2 : Counterclockwise
+    """
+    val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
+    if abs(val) < 1e-10:
+        return 0  # Colinear
+    elif val > 0:
+        return 1  # Clockwise
+    else:
+        return 2  # Counterclockwise
+
+
+def on_segment(p: Coordinate, q: Coordinate, r: Coordinate) -> bool:
+    """
+    Checks if point q lies on segment pr.
+    """
+    if min(p.x, r.x) <= q.x <= max(p.x, r.x) and \
+            min(p.y, r.y) <= q.y <= max(p.y, r.y):
+        return True
+    return False
+
+
+def segments_intersect(p1: Coordinate, q1: Coordinate, p2: Coordinate, q2: Coordinate) -> bool:
+    """
+    Checks if two line segments (p1,q1) and (p2,q2) intersect.
+    """
+    # Find the four orientations needed for general and special cases
+    o1 = orientation(p1, q1, p2)
+    o2 = orientation(p1, q1, q2)
+    o3 = orientation(p2, q2, p1)
+    o4 = orientation(p2, q2, q1)
+
+    # General case
+    if o1 != o2 and o3 != o4:
+        return True
+
+    # Special Cases
+    # p1, q1 and p2 are colinear and p2 lies on segment p1q1
+    if o1 == 0 and on_segment(p1, p2, q1):
+        return True
+    # p1, q1 and q2 are colinear and q2 lies on segment p1q1
+    if o2 == 0 and on_segment(p1, q2, q1):
+        return True
+    # p2, q2 and p1 are colinear and p1 lies on segment p2q2
+    if o3 == 0 and on_segment(p2, p1, q2):
+        return True
+    # p2, q2 and q1 are colinear and q1 lies on segment p2q2
+    if o4 == 0 and on_segment(p2, q1, q2):
+        return True
+
+    return False

neurotask-0.2.0/neurotask/neurotask/tmt/crosses/crosses_metric_calculator.py

@@ -0,0 +1,20 @@
+import numpy as np
+from neurotask.tmt.crosses.crosses import calculate_crosses_for_trial
+from neurotask.tmt.metrics.base_metric import BaseMetricCalculator
+from neurotask.tmt.model.tmt_model import TMTTrial, TMTSubject, TMTTarget, CursorInfo
+
+
+class CrossesMetricCalculator(BaseMetricCalculator):
+    def add_metrics(self, metrics: dict, trial: TMTTrial, subject: TMTSubject,
+                    trails_between_targets: list[tuple[TMTTarget, list[CursorInfo]]], calculate_crosses: bool,
+                    speed_threshold, consecutive_points, target_radius_multiplier: float,
+                    crosses_time_threshold: float) -> dict:
+        metric_key = self.get_metric_name("number_of_crosses")
+
+        if calculate_crosses:
+            num_crosses, _ = calculate_crosses_for_trial(trial, crosses_time_threshold)
+            metrics[metric_key] = num_crosses
+        else:
+            metrics[metric_key] = np.nan
+
+        return metrics

neurotask-0.2.0/neurotask/neurotask/tmt/cut_criteria/cut_criteria.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class CutCriteria(Enum):
+
+    MINIMUM_TARGETS = "MINIMUM_TARGETS"