Inheritance diagram for BioGTK.ImageView:

Public Types
enum	ViewMode { Raw , Filtered , RGBImage , Emission }

Public Member Functions
void	SetCoordinate (int z, int c, int t)

ZCT	GetCoordinate ()

void	AddImage (BioImage im)

SKImage	BitmapToSKImage (Bitmap bitmap)

void	UpdateImages ()
	It updates the images.

void	UpdateImage ()
	It updates the image.

void	UpdateGUI ()
	It updates the GUI to reflect the current state of the image.

void	CopySelection ()
	It takes the selected ROIs and copies them to the clipboard.

void	PasteSelection ()

int	LevelFromResolution (double Resolution)

void	UpdateStatus ()
	It updates the status of the user.

void	UpdateView ()
	It updates the view.

double	GetScale ()

List< ROI >	GetSelectedROIs ()

PointD	ImageToViewSpace (double x, double y)

RectangleD	ToViewSpace (RectangleD p)

PointF	ToViewSpace (Point p)

PointF	ToViewSpace (PointF p)

PointD	ToViewSpace (PointD p)

PointD	ToViewSpace (double x, double y)

RectangleD	ToViewSpace (double x, double y, double w, double h)

double	ToViewSizeH (double d)

double	ToViewW (double d)

double	ToViewH (double d)

PointD	ToScreenSpace (double x, double y)

PointD	ToScreenSpace (PointD p)

PointF	ToScreenSpace (PointF p)

PointF[]	ToScreenSpace (PointF[] p)

PointF	ToScreenSpace (Point3D p)

double	ToScreenScaleW (double x)

double	ToScreenScaleH (double y)

PointF	ToScreenScale (PointD p)

RectangleD	ToScreenRectF (double x, double y, double w, double h)

SKRect	ToScreenSpaceSK (double x, double y, double w, double h)

RectangleD	ToScreenSpace (RectangleD p)

RectangleD[]	ToScreenSpace (RectangleD[] p)

PointF[]	ToScreenSpace (PointD[] p)

void	GoToImage ()
	This function is used to go to the image at the specified index.

void	GoToImage (int i)

Static Public Member Functions
static ImageView	Create (BioImage bm)

static Cairo.Color	FromColor (Color color)

Public Attributes
List< BioImage >	Images = new List<BioImage>()

List< Bitmap >	Bitmaps = new List<Bitmap>()

List< SKImage >	SkImages = new List<SKImage>()

Gtk.Box	mainBox

Menu	contextMenu

bool	showRROIs = true

bool	showGROIs = true

bool	showBROIs = true

Static Public Attributes
static List< ROI >	selectedAnnotations = new List<ROI>()

static int	waitz = 1000

static int	waitc = 1000

static int	waitt = 1000

static int	startz = 0

static int	startc = 0

static int	startt = 0

static int	endz = 0

static int	endc = 0

static int	endt = 0

static Gdk.Key	keyDown = Gdk.Key.Key_3270_Test

static bool	x1State

static bool	x2State

static bool	mouseLeftState

static ModifierType	Modifiers

static PointD	mouseDown

static PointD	mouseUp

Protected Member Functions
	ImageView (Builder builder, IntPtr handle, BioImage im)

void	SetupHandlers ()
	Sets up the handlers.

Properties
double	PxWmicron `[get, set]`

double	PxHmicron `[get, set]`

bool	AllowNavigation `[get, set]`

static AForge.Bitmap	SelectedBuffer `[get]`

int	SelectedIndex `[get, set]`

bool	ShowOverview `[get, set]`

int?	MacroResolution `[get]`

int?	LabelResolution `[get]`

bool	OpenSlide `[get, set]`

static BioImage	SelectedImage `[get, set]`

ViewMode	Mode `[get, set]`

Channel	RChannel `[get]`

Channel	GChannel `[get]`

Channel	BChannel `[get]`

PointD	Origin `[get, set]`

PointD	TopRightOrigin `[get]`

PointD	PyramidalOriginTransformed `[get, set]`

PointD	PyramidalOrigin `[get, set]`

double	Resolution `[get, set]`

int	Level `[get]`

SizeF	Scale `[get, set]`

PointD	MouseDownInt `[get, set]`

PointD	MouseMoveInt `[get, set]`

PointD	MouseDown `[get, set]`

PointD	MouseMove `[get, set]`

Member Enumeration Documentation

◆ ViewMode

enum BioGTK.ImageView.ViewMode

Enumerator
Raw
Filtered
RGBImage
Emission

        {
            Raw,
            Filtered,
            RGBImage,
            Emission,
        }

Constructor & Destructor Documentation

◆ ImageView()

BioGTK.ImageView.ImageView	(	Builder	builder,
		IntPtr	handle,
		BioImage	im
	)

inlineprotected

                                                                         : base(handle)
        {
            _builder = builder;
            App.viewer = this;
            builder.Autoconnect(this);
            viewStack.Add(sk);
            viewStack.ShowAll();
            sk.Show();
            roi.Submenu = roiMenu;
            roi.ShowAll();
            AddImage(im);
            pxWmicron = SelectedImage.PhysicalSizeX;
            pxHmicron = SelectedImage.PhysicalSizeY;
            SetupHandlers();
            //pictureBox.WidthRequest = im.SizeX;
            //pictureBox.HeightRequest = im.SizeY;
            Function.InitializeContextMenu();
            this.Scale = new SizeF(1, 1);
            // Set the text column to display for comboboxs.
            var rendererr = new CellRendererText();
            rBox.PackStart(rendererr, false);
            rBox.AddAttribute(rendererr, "text", 0);
            var rendererg = new CellRendererText();
            gBox.PackStart(rendererg, false);
            gBox.AddAttribute(rendererg, "text", 0);
            var rendererb = new CellRendererText();
            bBox.PackStart(rendererb, false);
            bBox.AddAttribute(rendererb, "text", 0);
            App.ApplyStyles(this);
            if(im.Type == BioImage.ImageType.well)
            {
                Resolution = 0;
            }
            
        }

Member Function Documentation

◆ AddImage()

void BioGTK.ImageView.AddImage ( BioImage im )

inline

It adds an image to the list of images, and then updates the GUI and the images

Parameters

BioImage a class that contains the image data and metadata

        {
            Images.Add(im);
            selectedIndex = Images.Count - 1;
            if(im.Resolutions[0].SizeX <= 1920 && im.Resolutions[0].SizeY <= 1080)
            {
                sk.WidthRequest = im.Resolutions[0].SizeX;
                sk.HeightRequest = im.Resolutions[0].SizeY;
            }
            else
            {
                sk.WidthRequest = 600;
                sk.HeightRequest = 400;
            }
            if(im.isPyramidal)
            {
                Initialize();
                InitPreview();
            }
            UpdateGUI();
            UpdateImages();
            GoToImage(Images.Count - 1);
        }

◆ BitmapToSKImage()

SKImage BioGTK.ImageView.BitmapToSKImage ( Bitmap bitmap )

inline

        {
            // Step 1: Create an SKBitmap from the System.Drawing.Bitmap
            var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
 
            var info = new SKImageInfo(bitmap.Width, bitmap.Height, SKColorType.Bgra8888, SKAlphaType.Premul);
            var skBitmap = new SKBitmap(info);
            skBitmap.InstallPixels(info, bitmapData.Scan0, bitmapData.Stride, delegate { bitmap.UnlockBits(bitmapData); }, null);
 
            // Step 2: Create an SKImage from the SKBitmap
            var skImage = SKImage.FromBitmap(skBitmap);
 
            return skImage;
        }

◆ CopySelection()

void BioGTK.ImageView.CopySelection ( )

inline

It takes the selected ROIs and copies them to the clipboard.

        {
            copys.Clear();
            string s = "";
            foreach (ROI item in SelectedImage.AnnotationsRGB)
            {
                if (item.Selected)
                {
                    copys.Add(item);
                    s += BioImage.ROIToString(item);
                }
            }
            Clipboard clipboard = Clipboard.Get(Gdk.Selection.Clipboard);
            clipboard.Text = s;
        }

◆ Create()

static ImageView BioGTK.ImageView.Create ( BioImage bm )

inlinestatic

The function creates an ImageView object using a BioImage object and returns it.

Parameters

BioImage The BioImage parameter is an object that represents an image in a biological context. It likely contains information about the image file, such as the filename, and possibly additional metadata related to the image.

Returns: The method is returning an instance of the ImageView class.

        {
            Console.WriteLine("Creating ImageView for " + bm.file);
            Builder builder = new Builder(new FileStream(System.IO.Path.GetDirectoryName(Environment.ProcessPath) + "/" + "Glade/ImageView.glade", FileMode.Open));
            ImageView v = new ImageView(builder, builder.GetObject("imageView").Handle, bm);
            v.Title = bm.Filename;
            return v;
        }

◆ FromColor()

static Cairo.Color BioGTK.ImageView.FromColor ( Color color )

inlinestatic

It takes a System.Drawing.Color and returns a Cairo.Color

Parameters

Color The color to convert

Returns: A Cairo.Color object.

        {
            return new Cairo.Color((double)color.R / 255, (double)color.G / 255, (double)color.B / 255);
        }

◆ GetCoordinate()

ZCT BioGTK.ImageView.GetCoordinate ( )

inline

It returns the coordinate of the selected image

Returns: The Coordinate property of the SelectedImage object.

        {
            return SelectedImage.Coordinate;
        }

◆ GetScale()

double BioGTK.ImageView.GetScale ( )

inline

        {
            return ToViewSizeW(ROI.selectBoxSize / Scale.Width);
        }

◆ GetSelectedROIs()

List< ROI > BioGTK.ImageView.GetSelectedROIs ( )

inline

        {
            List<ROI> roi = new List<ROI>();
            foreach (ROI r in SelectedImage.AnnotationsRGB)
            {
                if(r.Selected)
                {
                    roi.Add(r);
                }
            }
            return roi;
        }

◆ GoToImage() [1/2]

void BioGTK.ImageView.GoToImage ( )

inline

This function is used to go to the image at the specified index.

        {
            GoToImage(0);
        }

◆ GoToImage() [2/2]

void BioGTK.ImageView.GoToImage ( int i )

inline

It takes an image index and sets the origin and physical size of the image to the values of the image at that index

Parameters

i	the index of the image in the list

Returns: The method is returning the value of the variable "i"

        {
            if (Images.Count <= i)
                return;
            if(SelectedImage.Type == BioImage.ImageType.pyramidal)
            {
                if (SelectedImage.OpenSlideBase != null)
                {
                    if (MacroResolution.HasValue)
                    {
                        int lev = MacroResolution.Value - 2;
                        Resolution = _openSlideBase.Schema.Resolutions[lev].UnitsPerPixel;
                    }
                    else
                    {
                        Resolution = _openSlideBase.Schema.Resolutions[0].UnitsPerPixel;
                    }
                }
                else
                {
                    if (MacroResolution.HasValue)
                    {
                        int lev = MacroResolution.Value - 1;
                        Resolution = SelectedImage.GetLevelDownsamples()[lev];
                    }
                    else
                    {
                        Resolution = SelectedImage.GetLevelDownsamples()[SelectedImage.Resolutions.Count - 1];
                    }
                }
                return;
            }
            double dx = Images[i].Volume.Width / 2;
            double dy = Images[i].Volume.Height / 2;
            Origin = new PointD((Images[i].Volume.Location.X) - dx, (Images[i].Volume.Location.Y) - dy);
            PxWmicron = Images[i].PhysicalSizeX;
            PxHmicron = Images[i].PhysicalSizeY;
            if (Images[i].SizeX > 1080)
            {
                double w = (double)SelectedImage.SizeX / (double)Width;
                double h = (double)SelectedImage.SizeY / (double)Height;
                PxWmicron *= h;
                PxHmicron *= h;
            }
            UpdateView();
        }

◆ ImageToViewSpace()

PointD BioGTK.ImageView.ImageToViewSpace	(	double	x,
		double	y
	)

inline

It takes a point in the image space and returns the point in the view space

Parameters

x	the x coordinate of the point in the image
y	the y coordinate of the point in the image

Returns: The point in the image space that corresponds to the point in the view space.

        {
            if(SelectedImage.isPyramidal)
            {
                return new PointD((PyramidalOrigin.X + x) * Resolution, (PyramidalOrigin.Y + y) * Resolution);
            }
            double dx = ToViewW(SelectedImage.Volume.Width);
            double dy = ToViewH(SelectedImage.Volume.Height);
            //The origin is the middle of the screen we want the top left corner
            PointD torig = new PointD((Origin.X - ((Width / 2) * pxWmicron)), (Origin.Y - ((Height / 2) * pxHmicron)));
            PointD orig = new PointD(torig.X - SelectedImage.Volume.Location.X, torig.Y - SelectedImage.Volume.Location.Y);
            PointD diff = new PointD(ToViewW(orig.X), ToViewH(orig.Y));
            PointD f = new PointD((((x + diff.X)/ dx) * SelectedImage.Volume.Width),(((y + diff.Y) / dy) * SelectedImage.Volume.Height));
            PointD ff = new PointD(((SelectedImage.Volume.Location.X + SelectedImage.Volume.Width) + f.X), ((SelectedImage.Volume.Location.Y + SelectedImage.Volume.Height) + f.Y));
            return ff;
        }

◆ LevelFromResolution()

int BioGTK.ImageView.LevelFromResolution ( double Resolution )

inline

        {
            int lev;
            if (MacroResolution.HasValue)
            {
                if (Resolution >= MacroResolution.Value)
                {
                    int r = 0;
                    for (int i = 0; i < SelectedImage.Resolutions.Count; i++)
                    {
                        if (i <= Resolution - 1)
                            r = i;
                    }
                    if (r - 1 <= MacroResolution.Value)
                        lev = MacroResolution.Value - 1;
                    else
                        lev = r - 1;
                }
                else
                    return (int)Resolution;
            }
            else
            {
                int r = 0;
                for (int i = 0; i < SelectedImage.Resolutions.Count; i++)
                {
                    if (i <= Resolution - 1)
                        r = i;
                }
                lev = r;
            }
            if (!OpenSlide)
            {
                return lev;
            }
            else
            {
                if (MacroResolution.HasValue)
                {
                    if (lev >= MacroResolution.Value - 1)
                        return lev - 1;
                    else
                        return lev;
                }
                else
                {
                    return lev - 1;
                }
            }
        }

◆ PasteSelection()

void BioGTK.ImageView.PasteSelection ( )

inline

The function takes the text from the clipboard and splits it into lines. Each line is then converted into an ROI object and added to the list of annotations

        {
            Clipboard clipboard = Clipboard.Get(Gdk.Selection.Clipboard);
            string text = clipboard.WaitForText();
            string[] sts = text.Split(BioImage.NewLine);
            foreach (string line in sts)
            {
                if (line.Length > 8)
                {
                    ROI an = BioImage.StringToROI(line);
                    //We set the coordinates of the ROI's we are pasting
                    an.coord = GetCoordinate();
                    SelectedImage.Annotations.Add(an);
                }
            }
            UpdateView();
        }

◆ SetCoordinate()

void BioGTK.ImageView.SetCoordinate	(	int	z,
		int	c,
		int	t
	)

inline

        {
            if (SelectedImage == null)
                return;
            if (z > SelectedImage.SizeZ - 1 && SelectedImage.Type == BioImage.ImageType.well)
                zBar.Value = zBar.Adjustment.Upper;
            else
                zBar.Value = z;
            if (c > SelectedImage.SizeC - 1)
                cBar.Value = cBar.Adjustment.Upper;
            else
                cBar.Value = c;
            if (t > SelectedImage.SizeT - 1)
                tBar.Value = tBar.Adjustment.Upper;
            else
                tBar.Value = t;
            if (SelectedImage.Type == BioImage.ImageType.well)
                SelectedImage.Coordinate = new ZCT(0, (int)cBar.Value, (int)tBar.Value);
            else
                SelectedImage.Coordinate = new ZCT((int)zBar.Value, (int)cBar.Value, (int)tBar.Value);
            UpdateImage();
            UpdateView();
        }

◆ SetupHandlers()

void BioGTK.ImageView.SetupHandlers ( )

inlineprotected

Sets up the handlers.

        {
            zBar.ValueChanged += ValueChanged;
            cBar.ValueChanged += ValueChanged;
            tBar.ValueChanged += ValueChanged;
            zBar.ScrollEvent += ZBar_ScrollEvent;
            cBar.ScrollEvent += CBar_ScrollEvent;
            tBar.ScrollEvent += TBar_ScrollEvent;
            sk.MotionNotifyEvent += ImageView_MotionNotifyEvent;
            sk.ButtonPressEvent += ImageView_ButtonPressEvent;
            sk.ButtonReleaseEvent += ImageView_ButtonReleaseEvent;
            sk.ScrollEvent += ImageView_ScrollEvent;
            sk.PaintSurface += Render;
            sk.SizeAllocated += PictureBox_SizeAllocated;
            sk.AddEvents((int)
            (EventMask.ButtonPressMask
            | EventMask.ButtonReleaseMask
            | EventMask.KeyPressMask
            | EventMask.PointerMotionMask | EventMask.ScrollMask));
            this.KeyPressEvent += ImageView_KeyPressEvent;
            this.DeleteEvent += ImageView_DeleteEvent;
            rBox.Changed += RBox_Changed;
            gBox.Changed += GBox_Changed;
            bBox.Changed += BBox_Changed;
            //Context Menu
            goToImageMenu.ButtonPressEvent += GoToImageMenu_ButtonPressEvent;
            goToOriginMenu.ButtonPressEvent += GoToOriginMenu_ButtonPressEvent;
 
            roiDelete.ButtonPressEvent += RoiDelete_ButtonPressEvent;
            roiID.ButtonPressEvent += RoiID_ButtonPressEvent;
            copy.ButtonPressEvent += Copy_ButtonPressEvent;
            paste.ButtonPressEvent += Paste_ButtonPressEvent;
            draw.ButtonPressEvent += Draw_ButtonPressEvent;
            fill.ButtonPressEvent += Fill_ButtonPressEvent;
 
            play.ButtonPressEvent += Play_ButtonPressEvent;
            stop.ButtonPressEvent += Stop_ButtonPressEvent;
            playSpeed.ButtonPressEvent += PlaySpeed_ButtonPressEvent;
            setValueRange.ButtonPressEvent += SetValueRange_ButtonPressEvent;
            loop.ButtonPressEvent += Loop_ButtonPressEvent;
 
            zBar.ButtonPressEvent += ZBar_ButtonPressEvent;
            tBar.ButtonPressEvent += TBar_ButtonPressEvent;
            cBar.ButtonPressEvent += CBar_ButtonPressEvent;
 
        }

◆ ToScreenRectF()

RectangleD BioGTK.ImageView.ToScreenRectF	(	double	x,
		double	y,
		double	w,
		double	h
	)

inline

The function converts a set of coordinates and dimensions from a mathematical coordinate system to a screen coordinate system and returns a rectangle with the converted values.

Parameters

x	The x-coordinate of the rectangle's top-left corner in world space.
y	The parameter "y" represents the y-coordinate of the top-left corner of the rectangle in the coordinate system of the screen.
w	The width of the rectangle in world space.
h	The parameter "h" represents the height of the rectangle.

Returns: The method is returning a RectangleD object.

        {
            PointD pf = ToScreenSpace(x, y);
            RectangleD rf = new RectangleD((float)pf.X, (float)pf.Y, (float)ToViewW(w), (float)ToViewH(h));
            return rf;
        }

◆ ToScreenScale()

PointF BioGTK.ImageView.ToScreenScale ( PointD p )

inline

The function takes a PointD object and returns a PointF object with the coordinates scaled to the screen.

Parameters

PointD PointD is a custom data type that represents a point in a two-dimensional space. It consists of two double values, X and Y, which represent the coordinates of the point.

Returns: The method is returning a PointF object, which represents a point in a two-dimensional plane with floating-point coordinates.

        {
            double x = ToScreenScaleW((float)p.X);
            double y = ToScreenScaleH((float)p.Y);
            return new PointF((float)x, (float)y);
        }

◆ ToScreenScaleH()

double BioGTK.ImageView.ToScreenScaleH ( double y )

inline

The function converts a given value to screen scale height based on the selected image's properties.

Parameters

y	The parameter "y" represents the vertical coordinate value that needs to be converted to screen scale.

Returns: The method is returning a double value.

        {
            if (SelectedImage.isPyramidal)
            {
                return y * Resolution;
            }
            return (y * PxHmicron) * Scale.Height;
        }

◆ ToScreenScaleW()

double BioGTK.ImageView.ToScreenScaleW ( double x )

inline

The function converts a given value to screen scale width based on the selected image's properties.

Parameters

x	The parameter "x" represents a value that needs to be converted to screen scale width.

Returns: The method is returning a double value.

        {
            if (SelectedImage.isPyramidal)
            {
                return x * Resolution;
            }
            return (x * PxWmicron) * Scale.Width;
        }

◆ ToScreenSpace() [1/8]

PointD BioGTK.ImageView.ToScreenSpace	(	double	x,
		double	y
	)

inline

The function converts coordinates from a Cartesian plane to screen space.

Parameters

x	The x-coordinate of the point in the coordinate system.
y	The parameter "y" represents the y-coordinate of a point in a coordinate system.

Returns: The method is returning a PointD object.

        {
            double fx = ToScreenScaleW(Origin.X - x);
            double fy = ToScreenScaleH(Origin.Y - y);
            return new PointD(fx, fy);
        }

◆ ToScreenSpace() [2/8]

PointF BioGTK.ImageView.ToScreenSpace ( Point3D p )

inline

The function converts a 3D point to screen space and returns it as a PointF object.

Parameters

Point3D The Point3D parameter represents a point in a three-dimensional space. It typically consists of three coordinates: X, Y, and Z.

Returns: The method is returning a PointF object.

        {
            PointD pd = ToScreenSpace(p.X, p.Y);
            return new PointF((float)pd.X, (float)pd.Y);
        }

◆ ToScreenSpace() [3/8]

PointD BioGTK.ImageView.ToScreenSpace ( PointD p )

inline

The function converts a point from a coordinate system to screen space.

Parameters

PointD The PointD class represents a point in a two-dimensional space. It typically has two properties, X and Y, which represent the coordinates of the point.

Returns: The method is returning a PointD object.

        {
            return ToScreenSpace(p.X, p.Y);
        }

◆ ToScreenSpace() [4/8]

PointF[] BioGTK.ImageView.ToScreenSpace ( PointD[] p )

inline

The function takes an array of PointD objects and converts them to an array of PointF objects in screen space.

Parameters

p	An array of PointD objects representing points in some coordinate system.

Returns: The method is returning an array of PointF objects.

        {
            PointF[] rs = new PointF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointD pd = ToScreenSpace(p[i]);
                rs[i] = new PointF((float)pd.X, (float)pd.Y);
            }
            return rs;
        }

◆ ToScreenSpace() [5/8]

PointF BioGTK.ImageView.ToScreenSpace ( PointF p )

inline

The function converts a PointF object from world space to screen space.

Parameters

PointF PointF is a structure in C# that represents a point in a two-dimensional space. It consists of two float values, X and Y, which represent the coordinates of the point.

Returns: The method is returning a PointF object.

        {
            PointD pd = ToScreenSpace(p.X, p.Y);
            return new PointF((float)pd.X, (float)pd.Y);
        }

◆ ToScreenSpace() [6/8]

PointF[] BioGTK.ImageView.ToScreenSpace ( PointF[] p )

inline

The function takes an array of PointF objects and converts them to screen space coordinates.

Parameters

p	An array of PointF objects representing points in some coordinate system.

Returns: The method is returning an array of PointF objects in screen space.

        {
            PointF[] pf = new PointF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                pf[i] = ToScreenSpace(p[i]);
            }
            return pf;
        }

◆ ToScreenSpace() [7/8]

RectangleD BioGTK.ImageView.ToScreenSpace ( RectangleD p )

inline

The function converts a RectangleD object to screen space.

Parameters

RectangleD The RectangleD is a custom data type that represents a rectangle in 2D space. It typically has four properties: X (the x-coordinate of the top-left corner), Y (the y-coordinate of the top-left corner), W (the width of the rectangle), and H (the height of

Returns: The method is returning a RectangleD object.

        {
            return ToScreenRectF(p.X, p.Y, p.W, p.H);
        }

◆ ToScreenSpace() [8/8]

RectangleD[] BioGTK.ImageView.ToScreenSpace ( RectangleD[] p )

inline

The function takes an array of RectangleD objects and converts them to screen space.

Parameters

p	An array of RectangleD objects representing rectangles in some coordinate space.

Returns: The method is returning an array of RectangleD objects.

        {
            RectangleD[] rs = new RectangleD[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                rs[i] = ToScreenSpace(p[i]);
            }
            return rs;
        }

◆ ToScreenSpaceSK()

SKRect BioGTK.ImageView.ToScreenSpaceSK	(	double	x,
		double	y,
		double	w,
		double	h
	)

inline

The function converts a set of coordinates and dimensions from a mathematical coordinate system to a screen coordinate system and returns a rectangle with the converted values.

Parameters

x	The x-coordinate of the rectangle's top-left corner in world space.
y	The parameter "y" represents the y-coordinate of the top-left corner of the rectangle in the coordinate system of the screen.
w	The width of the rectangle in world space.
h	The parameter "h" represents the height of the rectangle.

Returns: The method is returning a RectangleD object.

        {
            PointD pf = ToViewSpace(x, y);
            SKRect rf = new SKRect
            {
                Location = new SKPoint((float)pf.X, (float)pf.Y),
                Size = new SKSize((float)ToViewSizeW(w), (float)ToViewSizeH(h)),
            };
            return rf;
        }

◆ ToViewH()

double BioGTK.ImageView.ToViewH ( double d )

inline

The function converts a given value from a specific unit to a view height value.

Parameters

d	The parameter "d" represents a value that needs to be converted to a different unit of measurement.

Returns: The method is returning a double value.

        {
            if (SelectedImage.isPyramidal)
            {
                return d / Resolution;
            }
            double y = (double)(d / PxHmicron) * Scale.Height;
            return y;
        }

◆ ToViewSizeH()

double BioGTK.ImageView.ToViewSizeH ( double d )

inline

The function converts a given value to a view size in the horizontal direction.

Parameters

d	The parameter "d" represents a value that needs to be converted to a view size.

Returns: The method is returning a double value.

        {
            if (SelectedImage.isPyramidal)
            {
                return d / Resolution;
            }
            double y = (double)(d / PxHmicron) * Scale.Height;
            return y;
        }

◆ ToViewSpace() [1/6]

PointD BioGTK.ImageView.ToViewSpace	(	double	x,
		double	y
	)

inline

The function converts coordinates from a given space to view space.

Parameters

x	The x-coordinate in the original coordinate system.
y	The parameter "y" represents the y-coordinate in the original coordinate system.

Returns: The method is returning a PointD object.

        {
            if (SelectedImage.isPyramidal)
            {
                double ddx = x / Resolution;
                double ddy = y / Resolution;
                return new PointD(ddx, ddy);
            }
            double dx = (ToViewSizeW(Origin.X - x)) * Scale.Width;
            double dy = (ToViewSizeH(Origin.Y - y)) * Scale.Height;
            return new PointD(dx, dy);
        }

◆ ToViewSpace() [2/6]

RectangleD BioGTK.ImageView.ToViewSpace	(	double	x,
		double	y,
		double	w,
		double	h
	)

inline

The function converts coordinates and sizes from a given space to a view space.

Parameters

x	The x-coordinate of the rectangle's top-left corner in world space.
y	The parameter "y" represents the y-coordinate of the rectangle in the original coordinate space.
w	The width of the rectangle in world space.
h	The parameter "h" represents the height of the rectangle in the original coordinate space.

Returns: The method is returning a RectangleD object.

        {
            PointD d = ToViewSpace(x, y);
            double dw = ToViewSizeW(w);
            double dh = ToViewSizeH(h);
            if (SelectedImage.isPyramidal)
            {
                return new RectangleD(d.X - PyramidalOrigin.X, d.Y - PyramidalOrigin.Y, dw, dh);
            }
            return new RectangleD(-d.X, -d.Y, dw, dh);
        }

◆ ToViewSpace() [3/6]

PointF BioGTK.ImageView.ToViewSpace ( Point p )

inline

The function converts a Point object to PointF object in view space.

Parameters

Point The Point class represents an ordered pair of integer x and y coordinates that define a point in a two-dimensional plane.

Returns: The method is returning a PointF object, which represents a point in 2D space with floating-point coordinates.

        {
            PointD d = ToViewSpace(p.X, p.Y);
            return new PointF((float)d.X, (float)d.Y);
        }

◆ ToViewSpace() [4/6]

PointD BioGTK.ImageView.ToViewSpace ( PointD p )

inline

The function converts a point from a coordinate system to view space.

Parameters

PointD The PointD class represents a point in a two-dimensional space. It typically has two properties: X and Y, which represent the coordinates of the point.

Returns: The method is returning a PointD object.

        {
            return ToViewSpace(p.X, p.Y); ;
        }

◆ ToViewSpace() [5/6]

PointF BioGTK.ImageView.ToViewSpace ( PointF p )

inline

The function converts a PointF object from world space to view space.

Parameters

PointF PointF is a structure in C# that represents a point in a two-dimensional space. It consists of two float values, X and Y, which represent the coordinates of the point.

Returns: The method is returning a PointF object.

        {
            PointD d = ToViewSpace(p.X, p.Y);
            return new PointF((float)d.X, (float)d.Y);
        }

◆ ToViewSpace() [6/6]

RectangleD BioGTK.ImageView.ToViewSpace ( RectangleD p )

inline

The function converts a rectangle from world space to view space.

Parameters

RectangleD The RectangleD is a custom data type that represents a rectangle in 2D space. It has four properties: X (the x-coordinate of the top-left corner), Y (the y-coordinate of the top-left corner), W (the width of the rectangle), and H (the height of the

Returns: The method is returning a RectangleD object.

        {
            PointD d = ToViewSpace(p.X, p.Y);
            double dx = ToScreenScaleW(p.W);
            double dy = ToScreenScaleH(p.H);
            return new RectangleD((float)d.X, (float)d.Y, (float)dx, (float)dy);
        }

◆ ToViewW()

double BioGTK.ImageView.ToViewW ( double d )

inline

The function converts a given value from microns to view width units, taking into account the scale and whether the image is pyramidal.

Parameters

d	The parameter "d" represents a value that needs to be converted to a view width.

Returns: The method is returning a double value.

        {
            if (SelectedImage.isPyramidal)
            {
                return d / Resolution;
            }
            double x = (double)(d / PxWmicron) * Scale.Width;
            return x;
        }

◆ UpdateGUI()

void BioGTK.ImageView.UpdateGUI ( )

inline

It updates the GUI to reflect the current state of the image.

        {
            cBar.Adjustment.Lower = 0;
            cBar.Adjustment.Upper = Images[selectedIndex].SizeC - 1;
            zBar.Adjustment.Lower = 0;
            zBar.Adjustment.Upper = Images[selectedIndex].SizeZ - 1;
            tBar.Adjustment.Lower = 0;
            tBar.Adjustment.Upper = Images[selectedIndex].SizeT - 1;
            if (endz == 0 || endz > Images[selectedIndex].SizeZ - 1)
                endz = Images[selectedIndex].SizeZ - 1;
            if (endc == 0 || endc > Images[selectedIndex].SizeC - 1)
                endc = Images[selectedIndex].SizeC - 1;
            if (endt == 0 || endt > Images[selectedIndex].SizeT - 1)
                endt = Images[selectedIndex].SizeT - 1;
            var store = new ListStore(typeof(string));
            foreach (Channel c in SelectedImage.Channels)
            {
                store.AppendValues(c.Name);
            }
            // Set the model for the ComboBox
            rBox.Model = store;
            gBox.Model = store;
            bBox.Model = store;
            if (SelectedImage.Channels.Count > 2)
            {
                rBox.Active = 0;
                gBox.Active = 1;
                bBox.Active = 2;
            }
            else
            if (SelectedImage.Channels.Count == 2)
            {
                rBox.Active = 0;
                gBox.Active = 1;
            }
            imagesMenu = new Menu();
            foreach (BioImage b in Images)
            {
                MenuItem mi = new MenuItem(b.Filename);
                mi.ButtonPressEvent += Mi_ButtonPressEvent;
                imagesMenu.Append(mi);
            }
            goToImageMenu.Submenu = imagesMenu;
            goToImageMenu.ShowAll();
        }

◆ UpdateImage()

void BioGTK.ImageView.UpdateImage ( )

inline

It updates the image.

        {
            UpdateImages();
        }

◆ UpdateImages()

void BioGTK.ImageView.UpdateImages ( )

inline

It updates the images.

        {
            if (SelectedImage == null)
                return;
            for (int i = 0; i < SkImages.Count; i++)
            {
                SkImages[i].Dispose();
            }
            SkImages.Clear();
           
            if (zBar.Adjustment.Upper != SelectedImage.SizeZ - 1 || tBar.Adjustment.Upper != SelectedImage.SizeT - 1)
            {
                UpdateGUI();
            }
            int bi = 0;
            if (SelectedImage.isPyramidal && sk.AllocatedHeight <= 1 || sk.AllocatedWidth <= 1)
                return;
            SelectedImage.PyramidalSize = new AForge.Size(sk.AllocatedWidth, sk.AllocatedHeight);
            if (SelectedImage.isPyramidal)
                SelectedImage.UpdateBuffersPyramidal();
            foreach (BioImage b in Images)
            {
                ZCT c = GetCoordinate();
                AForge.Bitmap bitmap = null;
                int index = b.Coords[c.Z, c.C, c.T];
                if (Mode == ViewMode.Filtered)
                {
                    bitmap = b.GetFiltered(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                else if (Mode == ViewMode.RGBImage)
                {
                    bitmap = b.GetRGBBitmap(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                else if (Mode == ViewMode.Raw)
                {
                    bitmap = b.Buffers[index];
                }
                else
                {
                    bitmap = b.GetEmission(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                if (bitmap == null)
                    return;
                SkImages.Add(BitmapToSKImage(bitmap.ImageRGB));
                bitmap.Dispose();
                bitmap = null;
                bi++;
            }
        }

◆ UpdateStatus()

void BioGTK.ImageView.UpdateStatus ( )

inline

It updates the status of the user.

        {
            if(SelectedImage.Type == BioImage.ImageType.well)
            {
                statusLabel.Text = (zBar.Value + 1) + "/" + (zBar.Adjustment.Upper + 1) + ", " + (cBar.Value + 1) + "/" + (cBar.Adjustment.Upper + 1) + ", " + (tBar.Value + 1) + "/" + (tBar.Adjustment.Upper + 1) + ", " +
                mousePoint + mouseColor + ", " + SelectedImage.Buffers[0].PixelFormat.ToString() + ", (" + SelectedImage.Volume.Location.X.ToString("N2") + ", " + SelectedImage.Volume.Location.Y.ToString("N2") + ") " 
                + Origin.X.ToString("N2") + "," + Origin.Y.ToString("N2") + " , Well:" + SelectedImage.Level;
            }
            else
            statusLabel.Text = (zBar.Value + 1) + "/" + (zBar.Adjustment.Upper + 1) + ", " + (cBar.Value + 1) + "/" + (cBar.Adjustment.Upper + 1) + ", " + (tBar.Value + 1) + "/" + (tBar.Adjustment.Upper + 1) + ", " +
                mousePoint + mouseColor + ", " + SelectedImage.Buffers[0].PixelFormat.ToString() + ", (" + SelectedImage.Volume.Location.X.ToString("N2") + ", " + SelectedImage.Volume.Location.Y.ToString("N2") + ") "
                + Origin.X.ToString("N2") + "," + Origin.Y.ToString("N2") + ", Res:" + Resolution;
        }

◆ UpdateView()

void BioGTK.ImageView.UpdateView ( )

inline

It updates the view.

        {
            if (SelectedImage.isPyramidal)
                sk.QueueDraw();
            else
            {
                sk.QueueDraw();
            }
        }

Member Data Documentation

◆ Bitmaps

List<Bitmap> BioGTK.ImageView.Bitmaps = new List<Bitmap>()

◆ contextMenu

Menu BioGTK.ImageView.contextMenu

◆ endc

int BioGTK.ImageView.endc = 0

static

◆ endt

int BioGTK.ImageView.endt = 0

static

◆ endz

int BioGTK.ImageView.endz = 0

static

◆ Images

List<BioImage> BioGTK.ImageView.Images = new List<BioImage>()

◆ keyDown

Gdk.Key BioGTK.ImageView.keyDown = Gdk.Key.Key_3270_Test

static

◆ mainBox

Gtk.Box BioGTK.ImageView.mainBox

◆ Modifiers

ModifierType BioGTK.ImageView.Modifiers

static

◆ mouseDown

PointD BioGTK.ImageView.mouseDown

static

◆ mouseLeftState

bool BioGTK.ImageView.mouseLeftState

static

◆ mouseUp

PointD BioGTK.ImageView.mouseUp

static

◆ selectedAnnotations

List<ROI> BioGTK.ImageView.selectedAnnotations = new List<ROI>()

static

◆ showBROIs

bool BioGTK.ImageView.showBROIs = true

◆ showGROIs

bool BioGTK.ImageView.showGROIs = true

◆ showRROIs

bool BioGTK.ImageView.showRROIs = true

◆ SkImages

List<SKImage> BioGTK.ImageView.SkImages = new List<SKImage>()

◆ startc

int BioGTK.ImageView.startc = 0

static

◆ startt

int BioGTK.ImageView.startt = 0

static

◆ startz

int BioGTK.ImageView.startz = 0

static

◆ waitc

int BioGTK.ImageView.waitc = 1000

static

◆ waitt

int BioGTK.ImageView.waitt = 1000

static

◆ waitz

int BioGTK.ImageView.waitz = 1000

static

◆ x1State

bool BioGTK.ImageView.x1State

static

◆ x2State

bool BioGTK.ImageView.x2State

static

Property Documentation

◆ AllowNavigation

bool BioGTK.ImageView.AllowNavigation

getset

        {
            get { return allowNavigation; }
            set { allowNavigation = value; }
        }

◆ BChannel

Channel BioGTK.ImageView.BChannel

get

        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[2]];
            }
        }

◆ GChannel

Channel BioGTK.ImageView.GChannel

get

        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[1]];
            }
        }

◆ LabelResolution

int? BioGTK.ImageView.LabelResolution

get

591{ get { return SelectedImage.LabelResolution; } }

BioGTK.BioImage.LabelResolution

int? LabelResolution

Definition Bio.cs:3175

◆ Level

int BioGTK.ImageView.Level

get

        {
            get
            {
                int l = 0;
                if(SelectedImage.isPyramidal)
                if (!openSlide)
                    l = OpenSlideGTK.TileUtil.GetLevel(_slideBase.Schema.Resolutions, Resolution);
                else
                    l = OpenSlideGTK.TileUtil.GetLevel(_openSlideBase.Schema.Resolutions, Resolution);
                return l;
            }
        }

◆ MacroResolution

int? BioGTK.ImageView.MacroResolution

get

590{ get { return SelectedImage.MacroResolution; } }

BioGTK.BioImage.MacroResolution

int? MacroResolution

Definition Bio.cs:3174

◆ Mode

ViewMode BioGTK.ImageView.Mode

getset

        {
            get
            {
                return viewMode;
            }
            set
            {
                viewMode = value;
                if (viewMode == ViewMode.RGBImage)
                {
                    rgbStack.VisibleChild = rgbStack.Children[1];
                }
                else
                if (viewMode == ViewMode.Filtered)
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                else
                if (viewMode == ViewMode.Raw)
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                else
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                UpdateImage();
                UpdateView();
            }
        }

◆ MouseDown

PointD BioGTK.ImageView.MouseDown

getset

        {
            get { return mouseDown; }
            set { mouseDown = value; }
        }

◆ MouseDownInt

PointD BioGTK.ImageView.MouseDownInt

getset

        {
            get { return mouseDownInt; }
            set { mouseDownInt = value; }
        }

◆ MouseMove

PointD BioGTK.ImageView.MouseMove

getset

        {
            get { return mouseMove; }
            set { mouseMove = value; }
        }

◆ MouseMoveInt

PointD BioGTK.ImageView.MouseMoveInt

getset

        {
            get { return mouseMoveInt; }
            set { mouseMoveInt = value; }
        }

◆ OpenSlide

bool BioGTK.ImageView.OpenSlide

getset

        {
            get { return openSlide; }
            set { openSlide = value; }
        }

◆ Origin

PointD BioGTK.ImageView.Origin

getset

        {
            get { return origin; }
            set
            {
                if(AllowNavigation)
                origin = value;
            }
        }

◆ PxHmicron

double BioGTK.ImageView.PxHmicron

getset

        {
            get
            {
                if (SelectedImage.Type == BioImage.ImageType.pyramidal)
                if (openSlide)
                {
                    int lev = OpenSlideGTK.TileUtil.GetLevel(_openSlideBase.Schema.Resolutions, Resolution);
                    return _openSlideBase.Schema.Resolutions[lev].UnitsPerPixel * pxHmicron;
                }
                else
                {
                    int lev = OpenSlideGTK.TileUtil.GetLevel(_slideBase.Schema.Resolutions, Resolution);
                    return _slideBase.Schema.Resolutions[lev].UnitsPerPixel * pxHmicron;
                }
                return pxHmicron;
            }
            set
            {
                pxHmicron = value;
            }
        }

◆ PxWmicron

double BioGTK.ImageView.PxWmicron

getset

        {
            get
            {
                if(SelectedImage.Type == BioImage.ImageType.pyramidal)
                if(openSlide)
                { 
                    int lev = OpenSlideGTK.TileUtil.GetLevel(_openSlideBase.Schema.Resolutions, Resolution);
                    return _openSlideBase.Schema.Resolutions[lev].UnitsPerPixel * pxWmicron;
                }
                else
                {
                    int lev = OpenSlideGTK.TileUtil.GetLevel(_slideBase.Schema.Resolutions, Resolution);
                    return _slideBase.Schema.Resolutions[lev].UnitsPerPixel * pxWmicron;
                }
 
                return pxWmicron;
            }
            set
            {
                pxWmicron = value;
            }
        }

◆ PyramidalOrigin

PointD BioGTK.ImageView.PyramidalOrigin

getset

        {
            get 
            {
                return SelectedImage.PyramidalOrigin;
            }
            set
            {
                if (!AllowNavigation)
                    return;
                SelectedImage.PyramidalOrigin = value;
                UpdateImage();
                UpdateView();
            }
        }

◆ PyramidalOriginTransformed

PointD BioGTK.ImageView.PyramidalOriginTransformed

getset

        {
            get { return new PointD(PyramidalOrigin.X * Resolution, PyramidalOrigin.Y * Resolution); }
            set { PyramidalOrigin = new PointD(value.X / Resolution, value.Y / Resolution); }
        }

◆ RChannel

Channel BioGTK.ImageView.RChannel

get

        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[0]];
            }
        }

◆ Resolution

double BioGTK.ImageView.Resolution

getset

        {
            get
            {
                return SelectedImage.Resolution;
            }
            set
            {
                if(SelectedImage.Type == BioImage.ImageType.well && value > SelectedImage.Resolutions.Count - 1)
                    return;
                else
                if (openSlide)
                {
                    double dp = Resolution / value;
                    PyramidalOrigin = new PointD((dp * PyramidalOrigin.X), (dp * PyramidalOrigin.Y));
                }
                SelectedImage.Resolution = value;
                if(SelectedImage.Type == BioImage.ImageType.well)
                SelectedImage.Level = (int)value;
                // update ui on main UI thread
                Application.Invoke(delegate
                {
                    UpdateImage();
                    UpdateView();
                });
            }
        }

◆ Scale

SizeF BioGTK.ImageView.Scale

getset

        {
            get
            {
                return scale;
            }
            set
            {
                scale = value;
                // update ui on main UI thread
                Application.Invoke(delegate
                {
                    UpdateView();
                });
            }
        }

◆ SelectedBuffer

AForge.Bitmap BioGTK.ImageView.SelectedBuffer

staticget

        {
            get
            {
                int ind = SelectedImage.Coords[SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T];
                return SelectedImage.Buffers[ind];
            }
        }

◆ SelectedImage

BioImage BioGTK.ImageView.SelectedImage

staticgetset

        {
            get
            {
                if (App.viewer == null)
                    return null;
                if(App.viewer.Images.Count == 0)
                    return null;
                return App.viewer.Images[App.viewer.SelectedIndex];
            }
            set
            {
                App.viewer.Images[App.viewer.SelectedIndex] = value;
            }
        }

◆ SelectedIndex

int BioGTK.ImageView.SelectedIndex

getset

        {
            get { return selectedIndex; }
            set { selectedIndex = value;
                Images[selectedIndex] = SelectedImage;
            }
        }

◆ ShowOverview

bool BioGTK.ImageView.ShowOverview

getset

        {
            get { return showOverview; }
            set
            {
                showOverview = value;
                UpdateView();
            }
        }

◆ TopRightOrigin

PointD BioGTK.ImageView.TopRightOrigin

get

        {
            get 
            {
                return new PointD((Origin.X - ((sk.AllocatedWidth / 2) * pxWmicron)), (Origin.Y - ((sk.AllocatedHeight / 2) * pxHmicron)));
            }
        }

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

D:/Kari/repos/BioGTK/Source/ImageView.cs

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Properties

Member Enumeration Documentation

◆ ViewMode

Constructor & Destructor Documentation

◆ ImageView()

Member Function Documentation

◆ AddImage()

◆ BitmapToSKImage()

◆ CopySelection()

◆ Create()

◆ FromColor()

◆ GetCoordinate()

◆ GetScale()

◆ GetSelectedROIs()

◆ GoToImage() [1/2]

◆ GoToImage() [2/2]

◆ ImageToViewSpace()

◆ LevelFromResolution()

◆ PasteSelection()

◆ SetCoordinate()

◆ SetupHandlers()

◆ ToScreenRectF()

◆ ToScreenScale()

◆ ToScreenScaleH()

◆ ToScreenScaleW()

◆ ToScreenSpace() [1/8]

◆ ToScreenSpace() [2/8]

◆ ToScreenSpace() [3/8]

◆ ToScreenSpace() [4/8]

◆ ToScreenSpace() [5/8]

◆ ToScreenSpace() [6/8]

◆ ToScreenSpace() [7/8]

◆ ToScreenSpace() [8/8]

◆ ToScreenSpaceSK()

◆ ToViewH()

◆ ToViewSizeH()

◆ ToViewSpace() [1/6]

◆ ToViewSpace() [2/6]

◆ ToViewSpace() [3/6]

◆ ToViewSpace() [4/6]

◆ ToViewSpace() [5/6]

◆ ToViewSpace() [6/6]

◆ ToViewW()

◆ UpdateGUI()

◆ UpdateImage()

◆ UpdateImages()

◆ UpdateStatus()

◆ UpdateView()

Member Data Documentation

◆ Bitmaps

◆ contextMenu

◆ endc

◆ endt

◆ endz

◆ Images

◆ keyDown

◆ mainBox

◆ Modifiers

◆ mouseDown

◆ mouseLeftState

◆ mouseUp

◆ selectedAnnotations

◆ showBROIs

◆ showGROIs

◆ showRROIs

◆ SkImages

◆ startc

◆ startt

◆ startz

◆ waitc

◆ waitt

◆ waitz

◆ x1State

◆ x2State