BioLib.QuPath Class Reference

Classes
class	Channel
class	GeoJsonFeature
class	GeoJsonFeatureCollection
class	GeoJsonGeometry
class	GeoJsonLineString
class	GeoJsonPoint
class	GeoJsonPolygon
class	Image
class	Level
class	Metadata
class	PixelCalibration
class	PixelDimension
class	Project
class	Properties
class	ServerBuilder
class	ZSpacing

Static Public Member Functions
static PointD[]	GetPoints (GeoJsonGeometry p, BioImage b)
static void	SaveROI (string file, BioImage b)
static ROI[]	ReadROI (string filePath, BioImage b)
static Project	OpenProject (string file)

Member Function Documentation

GetPoints()

static PointD[] BioLib.QuPath.GetPoints ( GeoJsonGeometry p, BioImage b )

static

        {
            if (p.type == "Point")
            {
                List<PointD> points = new List<PointD>();
                double[] gs = JsonConvert.DeserializeObject<double[]>(p.coordinates.ToString());
                points.Add(new PointD(gs[0], gs[1]));
                for (int i = 0; i < points.Count; i++)
                {
                    points[i] = new PointD(b.StageSizeX + (points[i].X / b.SizeX) * b.Volume.Width, b.StageSizeY + (points[i].Y / b.SizeY) * b.Volume.Height);
                }
                return points.ToArray();
            }
            else if (p.type == "Polygon")
            {
                List<PointD> points = new List<PointD>();
                double[][][] gs = JsonConvert.DeserializeObject<double[][][]>(p.coordinates.ToString());
                foreach (double[] item in gs[0])
                {
                    points.Add(new PointD(item[0], item[1]));
                }
                for (int i = 0; i < points.Count; i++)
                {
                    points[i] = new PointD(b.StageSizeX + (points[i].X / b.SizeX) * b.Volume.Width, b.StageSizeY + (points[i].Y / b.SizeY) * b.Volume.Height);
                }
                return points.ToArray();
            }
            else
            {
                List<PointD> points = new List<PointD>();
                double[][] gs = JsonConvert.DeserializeObject<double[][]>(p.coordinates.ToString());
                foreach (double[] item in gs)
                {
                    points.Add(new PointD(item[0], item[1]));
                }
                for (int i = 0; i < points.Count; i++)
                {
                    points[i] = new PointD(b.StageSizeX + (points[i].X / b.SizeX) * b.Volume.Width, b.StageSizeY + (points[i].Y / b.SizeY) * b.Volume.Height);
                }
                return points.ToArray();
            }
        }

OpenProject()

static Project BioLib.QuPath.OpenProject ( string file )

static

        {
            try
            {
                return JsonConvert.DeserializeObject<QuPath.Project>(File.ReadAllText("D:\\QuPath\\project.qpproj"));
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return null;
        }

ReadROI()

static ROI[] BioLib.QuPath.ReadROI ( string filePath, BioImage b )

static

        {
            List<ROI> rois = new List<ROI>();
            string st = File.ReadAllText(filePath);
            GeoJsonFeatureCollection gs = JsonConvert.DeserializeObject<GeoJsonFeatureCollection>(st);
 
            foreach (GeoJsonFeature f in gs.features)
            {
                ROI r = new ROI();
                if (f.geometry.type == "Polygon")
                {
                    r.type = ROI.Type.Polygon;
                    r.closed = true;
                    r.AddPoints(GetPoints(f.geometry, b));
                    if (f.geometry.plane != null)
                        r.coord = f.geometry.GetZCT();
                }
                else if (f.geometry.type == "LineString")
                {
                    r.type = ROI.Type.Line;
                    r.AddPoints(GetPoints(f.geometry, b));
                    if (r.Points.Count > 2)
                        r.type = ROI.Type.Polyline;
                    if (f.geometry.plane != null)
                        r.coord = f.geometry.GetZCT();
                }
                else
                {
                    r.type = ROI.Type.Point;
                    r.AddPoints(GetPoints(f.geometry, b));
                    if (f.geometry.plane != null)
                        r.coord = f.geometry.GetZCT();
                }
                rois.Add(r);
            }
            return rois.ToArray();
        }

SaveROI()

static void BioLib.QuPath.SaveROI ( string file, BioImage b )

static

        {
            string j = "{ \"type\":\"FeatureCollection\",\"features\":[";
            int i = 0;
            foreach (ROI roi in b.Annotations)
            {
                if (i == 0)
                    j += "{\"type\":\"Feature\",\"geometry\":";
                else
                    j += ",{\"type\":\"Feature\",\"geometry\":";
                if (roi.type == ROI.Type.Point)
                {
                    GeoJsonPoint p = GeoJsonPoint.FromROI(roi, b);
                    j += JsonConvert.SerializeObject(p);
                }
                else if (roi.type == ROI.Type.Rectangle || (roi.type == ROI.Type.Polygon && roi.closed) || roi.type == ROI.Type.Freeform)
                {
                    GeoJsonPolygon p = GeoJsonPolygon.FromROI(roi, b);
                    j += JsonConvert.SerializeObject(p);
                }
                else if (roi.type == ROI.Type.Polyline || roi.type == ROI.Type.Line || roi.type == ROI.Type.Polygon)
                {
                    GeoJsonLineString p = GeoJsonLineString.FromROI(roi, b);
                    j += JsonConvert.SerializeObject(p);
                }
 
                j += ",\"properties\":{\"object_type\":\"annotation\",\"isLocked\":false}}";
                i++;
            }
            j += "]}";
            File.WriteAllText(file, j);
        }

---

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

• Source/QuPath.cs