BioLib.Napari Class Reference

Parser for Napari CSV format ROI files. Handles both Points.csv and Shapes.csv formats. More...

Static Public Member Functions
static void	Initialize (double physicalX, double physicalY, bool hasTime)
static List< ROI >	ParsePointsFile (string filePath)
	Parse a Points CSV file and return ROIs.
static List< ROI >	ParseShapesFile (string filePath)
	Parse a Shapes CSV file and return ROIs.
static List< ROI >	ParseNapariFiles (string pointsPath, string shapesPath)
	Parse both Points and Shapes files and combine results.
static void	WritePointsFile (string filePath, List< ROI > rois)
	Write Point ROIs to a Napari Points.csv file.
static void	WriteShapesFile (string filePath, List< ROI > rois)
	Write Shape ROIs to a Napari Shapes.csv file.
static void	WriteNapariFiles (string pointsPath, string shapesPath, List< ROI > rois)
	Write both Points and Shapes files from a list of ROIs.

Static Public Attributes
static bool	HasTime = false
static double	PhysicalX
static double	PhysicalY

Properties
static bool	Initialized [get]

Detailed Description

Parser for Napari CSV format ROI files. Handles both Points.csv and Shapes.csv formats.

Member Function Documentation

Initialize()

static void BioLib.Napari.Initialize ( double physicalX, double physicalY, bool hasTime )

static

        {
            PhysicalX = physicalX;
            PhysicalY = physicalY;
            HasTime = hasTime;
        }

ParseNapariFiles()

static List< ROI > BioLib.Napari.ParseNapariFiles ( string pointsPath, string shapesPath )

static

Parse both Points and Shapes files and combine results.

        {
            List<ROI> allRois = new List<ROI>();
 
            // Stage: Parse points file if it exists
            if (File.Exists(pointsPath))
            {
                List<ROI> pointRois = ParsePointsFile(pointsPath);
                allRois.AddRange(pointRois);
            }
 
            // Stage: Parse shapes file if it exists
            if (File.Exists(shapesPath))
            {
                List<ROI> shapeRois = ParseShapesFile(shapesPath);
                allRois.AddRange(shapeRois);
            }
 
            Recorder.Record($"Napari.ParseNapariFiles(\"{pointsPath}\", \"{shapesPath}\");");
            return allRois;
        }

ParsePointsFile()

static List< ROI > BioLib.Napari.ParsePointsFile ( string filePath )

static

Parse a Points CSV file and return ROIs.

        {
            List<ROI> rois = new List<ROI>();
 
            // Stage: Read and validate file
            if (!File.Exists(filePath))
                throw new FileNotFoundException($"Points file not found: {filePath}");
 
            string[] lines = File.ReadAllLines(filePath);
            if (lines.Length < 2)
                return rois; // Empty or header-only file
 
            // Stage: Parse each point row
            for (int i = 1; i < lines.Length; i++) // Skip header
            {
                string line = lines[i].Trim();
                if (string.IsNullOrEmpty(line))
                    continue;
 
                CsvRow row = ParsePointRow(line);
                if (row != null)
                {
                    ROI roi = CreatePointRoi(row);
                    rois.Add(roi);
                }
            }
 
            Recorder.Record($"Napari.ParsePointsFile(\"{filePath}\");");
            return rois;
        }

ParseShapesFile()

static List< ROI > BioLib.Napari.ParseShapesFile ( string filePath )

static

Parse a Shapes CSV file and return ROIs.

        {
            List<ROI> rois = new List<ROI>();
 
            // Stage: Read and validate file
            if (!File.Exists(filePath))
                throw new FileNotFoundException($"Shapes file not found: {filePath}");
 
            string[] lines = File.ReadAllLines(filePath);
            if (lines.Length < 2)
                return rois; // Empty or header-only file
 
            // Stage: Parse all rows
            List<CsvRow> allRows = new List<CsvRow>();
            for (int i = 1; i < lines.Length; i++) // Skip header
            {
                string line = lines[i].Trim();
                if (string.IsNullOrEmpty(line))
                    continue;
 
                CsvRow row = ParseShapeRow(line);
                if (row != null)
                    allRows.Add(row);
            }
 
            // Stage: Group vertices by shape index
            Dictionary<double, ShapeGroup> shapeGroups = GroupShapesByIndex(allRows);
 
            // Stage: Create ROIs from grouped shapes
            foreach (ShapeGroup group in shapeGroups.Values.OrderBy(g => g.Index))
            {
                ROI roi = CreateShapeRoi(group);
                if (roi != null)
                    rois.Add(roi);
            }
 
            Recorder.Record($"Napari.ParseShapesFile(\"{filePath}\");");
            return rois;
        }

WriteNapariFiles()

static void BioLib.Napari.WriteNapariFiles ( string pointsPath, string shapesPath, List< ROI > rois )

static

Write both Points and Shapes files from a list of ROIs.

        {
            // Stage: Write points if any exist
            List<ROI> pointRois = rois.Where(r => r.type == ROI.Type.Point).ToList();
            if (pointRois.Count > 0)
            {
                WritePointsFile(pointsPath, rois);
            }
 
            // Stage: Write shapes if any exist
            List<ROI> shapeRois = rois.Where(r =>
                r.type != ROI.Type.Point &&
                r.type != ROI.Type.Label &&
                r.type != ROI.Type.Mask).ToList();
            if (shapeRois.Count > 0)
            {
                WriteShapesFile(shapesPath, rois);
            }
 
            Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, pointsPath, shapesPath, rois.Count);
        }

WritePointsFile()

static void BioLib.Napari.WritePointsFile ( string filePath, List< ROI > rois )

static

Write Point ROIs to a Napari Points.csv file.

        {
            // Stage: Filter to only Point type ROIs
            List<ROI> pointRois = rois.Where(r => r.type == ROI.Type.Point).ToList();
 
            if (pointRois.Count == 0)
                return; // No points to write
 
            // Stage: Determine format (4-axis or 5-axis)
            bool hasTimeData = HasTime;
            // Stage: Build CSV content
            List<string> lines = new List<string>();
 
            // Header
            if (hasTimeData)
                lines.Add("index,axis-0,axis-1,axis-2,axis-3,axis-4");
            else
                lines.Add("index,axis-0,axis-1,axis-2,axis-3");
 
            // Data rows
            for (int i = 0; i < pointRois.Count; i++)
            {
                string line = FormatPointRow(pointRois[i], i, hasTimeData);
                lines.Add(line);
            }
 
            // Stage: Write to file
            File.WriteAllLines(filePath, lines);
        }

WriteShapesFile()

static void BioLib.Napari.WriteShapesFile ( string filePath, List< ROI > rois )

static

Write Shape ROIs to a Napari Shapes.csv file.

        {
            // Stage: Filter to only shape type ROIs (exclude Point and Label)
            List<ROI> shapeRois = rois.Where(r =>
                r.type != ROI.Type.Point &&
                r.type != ROI.Type.Label &&
                r.type != ROI.Type.Mask).ToList();
 
            if (shapeRois.Count == 0)
                return; // No shapes to write
 
            // Stage: Determine format (4-axis or 5-axis)
            bool hasTimeData = HasTime;
 
            // Stage: Build CSV content
            List<string> lines = new List<string>();
 
            // Header
            if (hasTimeData)
                lines.Add("index,shape-type,vertex-index,axis-0,axis-1,axis-2,axis-3,axis-4");
            else
                lines.Add("index,shape-type,vertex-index,axis-0,axis-1,axis-2,axis-3");
 
            // Data rows
            for (int i = 0; i < shapeRois.Count; i++)
            {
                List<string> shapeLines = FormatShapeRows(shapeRois[i], i, hasTimeData);
                lines.AddRange(shapeLines);
            }
 
            // Stage: Write to file
            File.WriteAllLines(filePath, lines);
        }

Member Data Documentation

HasTime

bool BioLib.Napari.HasTime = false

static

PhysicalX

double BioLib.Napari.PhysicalX

static

PhysicalY

double BioLib.Napari.PhysicalY

static

Property Documentation

Initialized

bool BioLib.Napari.Initialized

staticget

---

The documentation for this class was generated from the following file:

• BioLib/Source/Napari.cs