:py:mod:`traccuracy.loaders` ============================ .. py:module:: traccuracy.loaders .. autoapi-nested-parse:: Subpackage for loading tracking data into memory This subpackage contains functions for loading ground truth or tracking method outputs into memory as TrackingGraph objects. Each loading function must return one TrackingGraph object which has a track graph and optionally contains a corresponding segmentation. Package Contents ---------------- Functions ~~~~~~~~~ .. autoapisummary:: traccuracy.loaders.load_ctc_data traccuracy.loaders.load_tiffs traccuracy.loaders.load_geff_data traccuracy.loaders.load_point_data .. py:function:: load_ctc_data(data_dir: str, track_path: str | None = None, name: str | None = None, run_checks: bool = True) -> traccuracy._tracking_graph.TrackingGraph Read the CTC segmentations and track file and create a TrackingGraph. :param data_dir: Path to directory containing CTC tiffs. :type data_dir: str :param track_path: Path to CTC track file. If not passed, finds `*_track.txt` in data_dir. :type track_path: optional, str :param name: Name of data to store in TrackingGraph :type name: optional, str :param run_checks: If set to `True` (default), runs checks on the data to ensure valid CTC format. :type run_checks: optional, bool :returns: TrackingGraph object containing segmentations and graph. :rtype: traccuracy.TrackingGraph :raises ValueError: If the tracks file is not found. If `run_checks` is True, whenever any of the CTC format checks are violated. If `run_checks` is False, whenever any other Exception occurs while creating the graph. .. py:function:: load_tiffs(data_dir: str) -> numpy.ndarray Load a directory of individual frames into a stack. :param data_dir: Path to directory of tiff files :type data_dir: str :raises FileNotFoundError: No tif files found in data_dir :returns: 4D array with dims TYXC :rtype: np.array .. py:function:: load_geff_data(geff_path: str, load_geff_seg: bool = False, seg_path: str | None = None, seg_property: str | None = None, name: str | None = None, load_all_props: bool = False) -> traccuracy._tracking_graph.TrackingGraph Load a graph into memory from a geff file Segmentations can be optionally loaded either from a related object specified in the geff (`load_geff_seg=True`) or with a path to a zarr array `seg_path` and `seg_property` :param geff_path: Path to a geff group inside of a zarr, :type geff_path: str :param load_geff_seg: Load segmentation based on a geff metadata of related segmentation. Defaults to False. :type load_geff_seg: bool, optional :param seg_path: Path to a zarr array containing segmentation data. We assume that the axes order in your segmentation array matches the axes in your geff. If this is not true please load the segmentation yourself and add it to TrackingGraph.segmentation. Defaults to None. :type seg_path: str | None, optional :param seg_property: If seg_path provided, this is the corresponding property on the geff graph that contains the segmentation key. Defaults to None. :type seg_property: str | None, optional :param name: Optional name to store on TrackingGraph for identification. Defaults to None. :type name: str | None, optional :param load_all_props: If True, load all node and edge properties on the graph. Defaults to False and only spatiotemporal and segmentation node properties are loaded. :type load_all_props: bool, optional .. py:function:: load_point_data(path: str | None = None, df: Optional[pandas.DataFrame] = None, parent_column: str = 'parent', id_column: str = 'node_id', pos_columns: tuple[str, Ellipsis] = ('z', 'y', 'x'), time_column: str = 't', seg_id_column: str | None = None, name: str | None = None, sep: str | None = None) -> traccuracy._tracking_graph.TrackingGraph Load point-based tracking data into a TrackingGraph from a csv-like file Assumes each row contains: - time - position, e.g. three columns 'z', 'y', 'x' - parent, a reference to the node in the previous time frame. A node without a parent can be indicated by -1 :param path: Path to the csv-like file to load. Defaults to None. :type path: str | None, optional :param df: A dataframe that has already been loaded. Defaults to None. :type df: pd.DataFrame | None, optional :param parent_column: A reference to the parent node in the previous time frame. Defaults to "parent". :type parent_column: str | None, optional :param id_column: Column used to specify node ids. Node IDs should be unique positive integers. Defaults to 'node_id' :type id_column: str, optional :param pos_columns: A tuple of columns to use for position. Defaults to ("z", "y", "x"). :type pos_columns: tuple[str], optional :param time_column: The column to use for time. Defaults to "t". :type time_column: str, optional :param seg_id_column: Name of an optional column containing a segmentation label id. Defaults to None. :type seg_id_column: str | None, optional :param name: Optional string to name/describe the dataset. Defaults to None. :type name: str | None, optional :param sep: Passed to pd.read_csv to set the sep kwarg. Defaults to None. :type sep: str | None, optional :raises ValueError: Must provide either a path or a dataframe :raises ValueError: parent_column not present in data :raises ValueError: id_column not present in data :raises ValueError: id_column does not contain positive integers :raises ValueError: id_column does not contain unique values :raises ValueError: pos_columns not present in data :raises ValueError: time_column not present in data :raises ValueError: seg_id_column not present in data :returns: TrackingGraph