import os import numpy as np import pandas as pd from deepcell_tracking.trk_io import load_trks from skimage.io import imsave import tifffile def convert_to_ctc_format(data_dir, output_dir): """ Convert DynamicNuclearNet tracking data to CTC format CTC format requires: - SEG/ folder with segmentation masks (man_seg####.tif) - TRA/ folder with tracking masks (man_track####.tif) - res_track.txt file with tracking results """ # Load the tracking data data = load_trks(os.path.join(data_dir, 'test.trks')) X = data['X'] # Image data y = data['y'] # Segmentation masks lineages = data['lineages'] # Tracking information # Load metadata data_source = np.load(os.path.join(data_dir, 'data-source.npz'), allow_pickle=True) meta = pd.DataFrame(data_source['test'], columns=['filename', 'experiment', 'pixel_size', 'screening_passed', 'time_step', 'specimen']) # Create output directories seg_dir = os.path.join(output_dir, 'SEG') tra_dir = os.path.join(output_dir, 'TRA') os.makedirs(seg_dir, exist_ok=True) os.makedirs(tra_dir, exist_ok=True) # Process each sequence tracking_results = [] for seq_idx in range(len(X)): print(f"Processing sequence {seq_idx + 1}/{len(X)}") sequence_images = X[seq_idx] # Shape: (T, H, W, C) sequence_masks = y[seq_idx] # Shape: (T, H, W, 1) sequence_lineages = lineages[seq_idx] # Remove channel dimension from masks if present if sequence_masks.ndim == 4: sequence_masks = sequence_masks.squeeze(-1) num_frames = sequence_masks.shape[0] # Create tracking masks and collect lineage information for t in range(num_frames): # Save segmentation mask seg_filename = f"man_seg{t:04d}.tif" seg_path = os.path.join(seg_dir, seg_filename) tifffile.imwrite(seg_path, sequence_masks[t].astype(np.uint16)) # Create tracking mask (same as segmentation for this format) tra_filename = f"man_track{t:04d}.tif" tra_path = os.path.join(tra_dir, tra_filename) tifffile.imwrite(tra_path, sequence_masks[t].astype(np.uint16)) # Extract tracking information for this frame frame_mask = sequence_masks[t] unique_cells = np.unique(frame_mask) unique_cells = unique_cells[unique_cells > 0] # Remove background for cell_id in unique_cells: # Find lineage information for this cell cell_lineage = None for lineage in sequence_lineages: if cell_id in lineage.get('label', []): cell_lineage = lineage break if cell_lineage: parent_id = cell_lineage.get('parent', 0) generation = cell_lineage.get('generation', 0) # CTC format: [cell_id, start_frame, end_frame, parent_id] # We need to determine start and end frames for each cell cell_frames = [] for frame_idx in range(num_frames): if cell_id in np.unique(sequence_masks[frame_idx]): cell_frames.append(frame_idx) if cell_frames: start_frame = min(cell_frames) end_frame = max(cell_frames) tracking_results.append([ cell_id, start_frame, end_frame, parent_id ]) # Save tracking results in CTC format tracking_df = pd.DataFrame(tracking_results, columns=['L', 'B', 'E', 'P']) tracking_df = tracking_df.drop_duplicates().sort_values('L') # Write res_track.txt file res_track_path = os.path.join(output_dir, 'res_track.txt') with open(res_track_path, 'w') as f: for _, row in tracking_df.iterrows(): f.write(f"{int(row['L'])} {int(row['B'])} {int(row['E'])} {int(row['P'])}\n") print(f"CTC format conversion completed!") print(f"Segmentation masks saved to: {seg_dir}") print(f"Tracking masks saved to: {tra_dir}") print(f"Tracking results saved to: {res_track_path}") return tracking_df # Alternative function for batch processing all .trks files def convert_all_trks_to_ctc(data_dir, output_base_dir): """ Convert all .trks files (train, test, val) to CTC format """ trks_files = ['train.trks', 'test.trks', 'val.trks'] for trks_file in trks_files: if os.path.exists(os.path.join(data_dir, trks_file)): dataset_name = trks_file.split('.')[0] output_dir = os.path.join(output_base_dir, dataset_name) print(f"\nConverting {trks_file} to CTC format...") # Load data data = load_trks(os.path.join(data_dir, trks_file)) # Create output directory os.makedirs(output_dir, exist_ok=True) # Convert each sequence in the dataset for seq_idx in range(len(data['X'])): seq_output_dir = os.path.join(output_dir, f"sequence_{seq_idx:03d}") # Create single sequence data single_seq_data = { 'X': [data['X'][seq_idx]], 'y': [data['y'][seq_idx]], 'lineages': [data['lineages'][seq_idx]] } # Convert this sequence convert_single_sequence_to_ctc(single_seq_data, seq_output_dir) def trk_to_isbi(track, path=None): """Convert a lineage track into an ISBI formatted text file. Args: track (dict): Cell lineage object. path (str): Path to save the .txt file. Returns: pd.DataFrame: DataFrame of ISBI data for each label. """ isbi = [] for label in track: first_frame = min(track[label]['frames']) last_frame = max(track[label]['frames']) parent = track[label]['parent'] parent = 0 if parent is None else parent if parent: parent_frames = track[parent]['frames'] if parent_frames[-1] != first_frame - 1: parent = 0 isbi_dict = {'Cell_ID': label, 'Start': first_frame, 'End': last_frame, 'Parent_ID': parent} isbi.append(isbi_dict) if path is not None: with open(path, 'w') as text_file: for cell in isbi: # Fixed: iterate over isbi list, not isbi_dict line = '{cell_id} {start} {end} {parent}\n'.format( cell_id=cell['Cell_ID'], start=cell['Start'], end=cell['End'], parent=cell['Parent_ID'] ) text_file.write(line) df = pd.DataFrame(isbi) return df def convert_single_sequence_to_ctc(data, output_dir): """ Convert a single sequence to CTC format """ X = data['X'][0] # Single sequence y = data['y'][0] # Single sequence masks lineages = data['lineages'][0] # Single sequence lineages # Debug: Print lineage structure print(f"Lineages type: {type(lineages)}") print(f"Lineages shape/length: {len(lineages) if hasattr(lineages, '__len__') else 'N/A'}") if len(lineages) > 0: if isinstance(lineages, dict): first_key = list(lineages.keys())[0] print(f"First lineage key: {first_key}") print(f"First lineage value type: {type(lineages[first_key])}") print(f"First lineage value: {lineages[first_key]}") print(f"All keys (first 10): {list(lineages.keys())[:10]}") else: print(f"First lineage item type: {type(lineages[0])}") print(f"First lineage item: {lineages[0]}") # Create output directories seg_dir = os.path.join(output_dir, 'SEG') tra_dir = os.path.join(output_dir, 'TRA') os.makedirs(seg_dir, exist_ok=True) os.makedirs(tra_dir, exist_ok=True) # Remove channel dimension if present if y.ndim == 4: y = y.squeeze(-1) # Process each frame - save segmentation and tracking masks for t in range(y.shape[0]): # Save segmentation mask seg_filename = f"man_seg{t:04d}.tif" tifffile.imwrite(os.path.join(seg_dir, seg_filename), y[t].astype(np.uint16)) # Save tracking mask (same as segmentation) tra_filename = f"man_track{t:04d}.tif" tifffile.imwrite(os.path.join(tra_dir, tra_filename), y[t].astype(np.uint16)) # Convert lineages to CTC format using the trk_to_isbi function res_track_path = os.path.join(output_dir, 'res_track.txt') # Use the trk_to_isbi function to convert lineages isbi_df = trk_to_isbi(lineages, res_track_path) print(f"Converted {len(isbi_df)} cell tracks to CTC format") return isbi_df # Usage example: if __name__ == "__main__": data_dir = '/l/users/sahal.mullappilly/Komal/documents/Cell/DEEPCELL/DynamicNuclearNet-tracking-v1_0' # Path to your DynamicNuclearNet data output_dir = '/l/users/sahal.mullappilly/Komal/documents/Cell/DEEPCELL/CTCformat' # Where to save CTC format # Convert all datasets convert_all_trks_to_ctc(data_dir, output_dir) # Or convert just the test set # convert_to_ctc_format(data_dir, os.path.join(output_dir, 'test'))