BioImager  3.9.1
A .NET microscopy imaging library. Supports various microscopes by using imported libraries & GUI automation. Supported libraries include Prior® & Zeiss® & all devices supported by Micromanager 2.0 and python-microscope.
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Properties | List of all members
BioImager.Tools Class Reference
Inheritance diagram for BioImager.Tools:

Classes

class  Tool
 

Public Member Functions

void UpdateOverlay ()
 
void UpdateView ()
 
void UpdateSelected ()
 
void ToolDown (PointD e, MouseButtons buts)
 
void ToolUp (PointD e, MouseButtons buts)
 
void ToolMove (PointD e, MouseButtons buts)
 

Static Public Member Functions

static Tool GetTool (string name)
 
static Tool GetTool (Tool.Type typ)
 

Public Attributes

Font font
 

Static Public Attributes

static bool applyToStack = false
 
static ColorTool colorTool
 
static bool rEnabled = true
 
static bool gEnabled = true
 
static bool bEnabled = true
 
static System.Drawing.Rectangle selectionRectangle
 
static Hashtable tools = new Hashtable()
 
static Tool currentTool
 
static RectangleD selectionRect
 
static float selectBoxSize = ROI.selectBoxSize
 

Protected Member Functions

override void Dispose (bool disposing)
 Clean up any resources being used. More...
 

Properties

static ColorS DrawColor [get, set]
 
static ColorS EraseColor [get, set]
 
static int StrokeWidth [get, set]
 

Detailed Description

Definition at line 23 of file Tools.cs.

Constructor & Destructor Documentation

◆ Tools()

BioImager.Tools.Tools ( )

Definition at line 168 of file Tools.cs.

169 {
170 InitializeComponent();
171 Tool.Init();
172 ColorS col = new ColorS(ushort.MaxValue);
173 //We initialize the tools
174 currentTool = GetTool(Tool.Type.move);
175
176 floodFiller = null;
177 floodFiller = new QueueLinearFloodFiller(floodFiller);
178 }
BioImager.QueueLinearFloodFiller
Implements the QueueLinear flood fill algorithm using array-based pixel manipulation.
Definition: QueueLinearFloodFiller.cs:9

Member Function Documentation

◆ Dispose()

override void BioImager.Tools.Dispose ( bool  disposing)
protected

Clean up any resources being used.

Parameters
disposingtrue if managed resources should be disposed; otherwise, false.

Definition at line 14 of file Tools.Designer.cs.

15 {
16 if (disposing && (components != null))
17 {
18 components.Dispose();
19 }
20 base.Dispose(disposing);
21 }

◆ GetTool() [1/2]

static Tool BioImager.Tools.GetTool ( string  name)
static

Definition at line 180 of file Tools.cs.

181 {
182 return (Tool)tools[name];
183 }

◆ GetTool() [2/2]

static Tool BioImager.Tools.GetTool ( Tool.Type  typ)
static

Definition at line 184 of file Tools.cs.

185 {
186 return (Tool)tools[typ.ToString()];
187 }

◆ ToolDown()

void BioImager.Tools.ToolDown ( PointD  e,
MouseButtons  buts 
)

The function is called when the user clicks the mouse button.

The function checks if the user is using the line, polygon, freeform, rectangle, ellipse, delete, or text tool.

If the user is using the line tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the polygon tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the freeform tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the rectangle tool, the function creates a new ROI object and adds it to the image's annotations.

If the user is using the ellipse tool, the function creates a new ROI object and adds it to the image's annotations.

If

Parameters
PointDA point with double precision
MouseButtonsA set of values that indicate which mouse button was pressed.
Returns
The return type is void.

Definition at line 245 of file Tools.cs.

246 {
247 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null)
248 return;
249 Scripting.UpdateState(Scripting.State.GetDown(e, buts));
250 PointD p;
251 if(ImageView.SelectedImage!=null)
252 if (App.viewer.HardwareAcceleration)
253 p = ImageView.SelectedImage.ToImageSpace(new PointD(ImageView.SelectedImage.Volume.Width - e.X, ImageView.SelectedImage.Volume.Height - e.Y));
254 else
255 p = ImageView.SelectedImage.ToImageSpace(e);
256 if (currentTool.type == Tool.Type.line && buts == MouseButtons.Left)
257 {
258 if (anno.GetPointCount() == 0)
259 {
260 anno = new ROI();
261 anno.type = ROI.Type.Line;
262 anno.AddPoint(new PointD(e.X, e.Y));
263 anno.AddPoint(new PointD(e.X, e.Y));
264 anno.coord = App.viewer.GetCoordinate();
265 ImageView.SelectedImage.Annotations.Add(anno);
266 }
267 }
268 else
269 if (currentTool.type == Tool.Type.polygon && buts == MouseButtons.Left)
270 {
271 if (anno.GetPointCount() == 0)
272 {
273 anno = new ROI();
274 anno.type = ROI.Type.Polygon;
275 anno.AddPoint(new PointD(e.X, e.Y));
276 anno.coord = App.viewer.GetCoordinate();
277 ImageView.SelectedImage.Annotations.Add(anno);
278 }
279 else
280 {
281 //If we click on a point 1 we close this polygon
282 RectangleD d = new RectangleD(e.X, e.Y, ROI.selectBoxSize, ROI.selectBoxSize);
283 if (d.IntersectsWith(anno.Point))
284 {
285 anno.closed = true;
286 anno = new ROI();
287 }
288 else
289 {
290 anno.AddPoint(new PointD(e.X, e.Y));
291 }
292 }
293 }
294 else
295 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left)
296 {
297 if (anno.GetPointCount() == 0)
298 {
299 anno = new ROI();
300 anno.type = ROI.Type.Freeform;
301 anno.AddPoint(new PointD(e.X, e.Y));
302 anno.coord = App.viewer.GetCoordinate();
303 anno.closed = true;
304 ImageView.SelectedImage.Annotations.Add(anno);
305 }
306 else
307 {
308 anno.AddPoint(new PointD(e.X, e.Y));
309 }
310 }
311 else
312 if (currentTool.type == Tool.Type.rect && buts == MouseButtons.Left)
313 {
314 anno.type = ROI.Type.Rectangle;
315 anno.Rect = new RectangleD(e.X, e.Y, 1, 1);
316 anno.coord = App.viewer.GetCoordinate();
317 ImageView.SelectedImage.Annotations.Add(anno);
318 }
319 else
320 if (currentTool.type == Tool.Type.ellipse && buts == MouseButtons.Left)
321 {
322 anno.type = ROI.Type.Ellipse;
323 anno.Rect = new RectangleD(e.X, e.Y, 1, 1);
324 anno.coord = App.viewer.GetCoordinate();
325 ImageView.SelectedImage.Annotations.Add(anno);
326 }
327 else
328 if (currentTool.type == Tool.Type.delete && buts == MouseButtons.Left)
329 {
330 for (int i = 0; i < ImageView.SelectedImage.Annotations.Count; i++)
331 {
332 ROI an = ImageView.SelectedImage.Annotations[i];
333 if (an.BoundingBox.IntersectsWith(e.X, e.Y))
334 {
335 if (an.selectedPoints.Count == 0)
336 {
337 ImageView.SelectedImage.Annotations.Remove(an);
338 break;
339 }
340 else
341 if (an.selectedPoints.Count == 1 && !(an.type == ROI.Type.Polygon || an.type == ROI.Type.Polyline || an.type == ROI.Type.Freeform))
342 {
343 ImageView.SelectedImage.Annotations.Remove(an);
344 break;
345 }
346 else
347 {
348 if (an.type == ROI.Type.Polygon ||
349 an.type == ROI.Type.Polyline ||
350 an.type == ROI.Type.Freeform)
351 {
352 an.closed = false;
353 an.RemovePoints(an.selectedPoints.ToArray());
354 break;
355 }
356 }
357 }
358 }
359 UpdateOverlay();
360 }
361 else
362 if (currentTool.type == Tool.Type.text && buts == MouseButtons.Left)
363 {
364 ROI an = new ROI();
365 an.type = ROI.Type.Label;
366 an.AddPoint(new PointD(e.X, e.Y));
367 an.coord = App.viewer.GetCoordinate();
368 TextInput ti = new TextInput("");
369 if (ti.ShowDialog() != DialogResult.OK)
370 return;
371 an.font = new Font(ti.font.FontFamily, ti.font.Size);
372 an.strokeColor = ti.color;
373 an.Text = ti.TextValue;
374 ImageView.SelectedImage.Annotations.Add(an);
375 }
376 else
377 if (buts == MouseButtons.Middle || currentTool.type == Tool.Type.pan)
378 {
379 currentTool = GetTool(Tool.Type.pan);
380 UpdateSelected();
381 panPanel.BackColor = System.Drawing.Color.LightGray;
382 Cursor.Current = Cursors.Hand;
383 }
384
385 UpdateOverlay();
386 }
BioImager.BioImage.ToImageSpace
PointD ToImageSpace(PointD p)
Definition: Bio.cs:3322
BioImager.ImageView
ImageView control for image stacks, pyramidal and whole-slide-images.
Definition: ImageView.cs:19
BioImager.ImageView.HardwareAcceleration
bool HardwareAcceleration
Whether or not Hardware Acceleration should be used for rendering.
Definition: ImageView.cs:796
BioImager.ROI.RemovePoints
void RemovePoints(int[] indexs)
Definition: Bio.cs:972
BioImager.ROI.GetPointCount
int GetPointCount()
Definition: Bio.cs:992
BioImager.ROI.AddPoint
void AddPoint(PointD p)
Definition: Bio.cs:934
BioImager.Scripting.State.GetDown
static State GetDown(PointD pf, MouseButtons mb)
Definition: Scripting.cs:186
BioImager.Scripting.UpdateState
static void UpdateState(State s)
Definition: Scripting.cs:261
BioImager.TextInput
Definition: TextInput.cs:14
BioImager.Tools.UpdateSelected
void UpdateSelected()
Definition: Tools.cs:198

References BioImager.ROI.AddPoint(), BioImager.ImageView.GetCoordinate(), BioImager.Scripting.State.GetDown(), BioImager.ROI.GetPointCount(), BioImager.ImageView.HardwareAcceleration, BioImager.ROI.RemovePoints(), BioImager.BioImage.ToImageSpace(), BioImager.Tools.UpdateSelected(), and BioImager.Scripting.UpdateState().

◆ ToolMove()

void BioImager.Tools.ToolMove ( PointD  e,
MouseButtons  buts 
)

Definition at line 550 of file Tools.cs.

551 {
552 if (App.viewer == null)
553 return;
554 Scripting.UpdateState(Scripting.State.GetMove(e, buts));
555 if (Tools.currentTool.type == Tools.Tool.Type.pan && buts == MouseButtons.Left || buts == MouseButtons.Middle)
556 {
557 PointD pf = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
558 App.viewer.Origin = new PointD(App.viewer.Origin.X + pf.X, App.viewer.Origin.Y + pf.Y);
559 UpdateView();
560 }
561 if (ImageView.SelectedImage == null)
562 return;
563 PointD p;
564 if (App.viewer.HardwareAcceleration)
565 p = ImageView.SelectedImage.ToImageSpace(new PointD(ImageView.SelectedImage.Volume.Width - e.X, ImageView.SelectedImage.Volume.Height - e.Y));
566 else
567 p = ImageView.SelectedImage.ToImageSpace(e);
568 if (currentTool.type == Tool.Type.line && ImageView.down)
569 {
570 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
571 UpdateOverlay();
572 }
573 else
574 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left && ImageView.down)
575 {
576 if (anno.GetPointCount() == 0)
577 {
578 anno.type = ROI.Type.Freeform;
579 anno.AddPoint(new PointD(e.X, e.Y));
580 anno.coord = App.viewer.GetCoordinate();
581 anno.closed = true;
582 ImageView.SelectedImage.Annotations.Add(anno);
583 }
584 else
585 {
586 anno.AddPoint(new PointD(e.X, e.Y));
587 }
588 UpdateOverlay();
589 }
590 else
591
592 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle)
593 {
594 if (anno.GetPointCount() == 4)
595 {
596 anno.Rect = new RectangleD(anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
597 UpdateOverlay();
598 }
599 }
600 else
601 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse)
602 {
603 if (anno.GetPointCount() == 4)
604 {
605 anno.Rect = new RectangleD(anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
606 UpdateOverlay();
607 }
608 }
609 else
610 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left && ImageView.down)
611 {
612 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
613 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
614 RectangleD r = Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle;
615 foreach (ROI an in App.viewer.AnnotationsRGB)
616 {
617 if (an.GetSelectBound(App.viewer.GetScale(), App.viewer.GetScale()).IntersectsWith(r))
618 {
619 an.selectedPoints.Clear();
620 ImageView.selectedAnnotations.Add(an);
621 an.selected = true;
622 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
623 for (int i = 0; i < sels.Length; i++)
624 {
625 if (sels[i].IntersectsWith(r))
626 {
627 an.selectedPoints.Add(i);
628 }
629 }
630 }
631 else
632 an.selected = false;
633 }
634 UpdateOverlay();
635 }
636 else
637 if (currentTool.type == Tool.Type.rectSel && ImageView.up)
638 {
639 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
640 }
641 else
642 if (Win32.GetKeyState(Keys.Delete))
643 {
644 foreach (ROI an in ImageView.selectedAnnotations)
645 {
646 if (an != null)
647 {
648 if (an.selectedPoints.Count == 0)
649 {
650 ImageView.SelectedImage.Annotations.Remove(an);
651 }
652 else
653 {
654 if (an.type == ROI.Type.Polygon ||
655 an.type == ROI.Type.Polyline ||
656 an.type == ROI.Type.Freeform)
657 {
658 an.closed = false;
659 an.RemovePoints(an.selectedPoints.ToArray());
660
661 }
662 }
663 }
664 }
665 UpdateOverlay();
666 }
667
668 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
669 {
670 //First we draw the selection rectangle
671 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
672 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
673 UpdateOverlay();
674 }
675
676 if (buts == MouseButtons.Left && currentTool.type == Tool.Type.eraser)
677 {
678 Graphics.Graphics g = Graphics.Graphics.FromImage(ImageView.SelectedBuffer);
679 Graphics.Pen pen = new Graphics.Pen(Tools.EraseColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel);
680 g.FillEllipse(new Rectangle((int)p.X, (int)p.Y, (int)width, (int)Tools.StrokeWidth), pen.color);
681 pen.Dispose();
682 App.viewer.UpdateImage();
683 }
684 }
BioImager.ImageView.Origin
PointD Origin
A property of the class PointD. *‍/.
Definition: ImageView.cs:644
BioImager.ROI.UpdatePoint
void UpdatePoint(PointD p, int i)
Definition: Bio.cs:894
BioImager.ROI.GetSelectBound
RectangleD GetSelectBound(double scaleX, double scaleY)
Definition: Bio.cs:724
BioImager.ROI.GetSelectBoxes
RectangleD[] GetSelectBoxes()
Definition: Bio.cs:734
BioImager.Scripting.State.GetMove
static State GetMove(PointD pf, MouseButtons mb)
Definition: Scripting.cs:201
BioImager.Win32.GetKeyState
static bool GetKeyState(System.Windows.Forms.Keys vKey)
Definition: Win32.cs:24

◆ ToolUp()

void BioImager.Tools.ToolUp ( PointD  e,
MouseButtons  buts 
)

The function ToolUp() is called when the mouse button is released

Parameters
PointDX,Y
MouseButtonsLeft, Right, Middle, XButton1, XButton2
Returns
a RectangleF.

Definition at line 393 of file Tools.cs.

394 {
395 PointD p = new PointD();
396 if(ImageView.SelectedImage != null)
397 if (App.viewer.HardwareAcceleration)
398 p = ImageView.SelectedImage.ToImageSpace(new PointD(ImageView.SelectedImage.Volume.Width - e.X, ImageView.SelectedImage.Volume.Height - e.Y));
399 else
400 p = ImageView.SelectedImage.ToImageSpace(e);
401 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null || anno == null)
402 return;
403 Scripting.UpdateState(Scripting.State.GetUp(e, buts));
404 if (currentTool.type == Tool.Type.point && buts == MouseButtons.Left)
405 {
406 ROI an = new ROI();
407 an.AddPoint(new PointD(e.X, e.Y));
408 an.type = ROI.Type.Point;
409 an.coord = App.viewer.GetCoordinate();
410 ImageView.SelectedImage.Annotations.Add(an);
411 }
412 else
413 if (currentTool.type == Tool.Type.line && anno.type == ROI.Type.Line && buts == MouseButtons.Left)
414 {
415 if (anno.GetPointCount() > 0)
416 {
417 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
418 anno = new ROI();
419 }
420 }
421 else
422 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle && buts == MouseButtons.Left)
423 {
424 if (anno.GetPointCount() == 4)
425 {
426 anno = new ROI();
427 }
428 }
429 else
430 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse && buts == MouseButtons.Left)
431 {
432 if (anno.GetPointCount() == 4)
433 {
434 anno = new ROI();
435 }
436 }
437 else
438 if (currentTool.type == Tool.Type.freeform && anno.type == ROI.Type.Freeform && buts == MouseButtons.Left)
439 {
440 anno = new ROI();
441 }
442 else
443 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left)
444 {
445 ImageView.selectedAnnotations.Clear();
446 RectangleD r = GetTool(Tool.Type.rectSel).Rectangle;
447 foreach (ROI an in App.viewer.AnnotationsRGB)
448 {
449 if (an.GetSelectBound(App.viewer.GetScale(), App.viewer.GetScale()).ToRectangleF().IntersectsWith(r.ToRectangleF()))
450 {
451 an.selectedPoints.Clear();
452 ImageView.selectedAnnotations.Add(an);
453 an.selected = true;
454 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
455 for (int i = 0; i < sels.Length; i++)
456 {
457 if (sels[i].IntersectsWith(r))
458 {
459 an.selectedPoints.Add(i);
460 }
461 }
462 }
463 else
464 an.selected = false;
465 }
466 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
467 }
468 else
469 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
470 {
471 PointD pf = new PointD(ImageView.mouseUp.X - ImageView.mouseDown.X, ImageView.mouseUp.Y - ImageView.mouseDown.Y);
472 ZCT coord = App.viewer.GetCoordinate();
473
474 Rectangle r = new Rectangle((int)ImageView.mouseDown.X, (int)ImageView.mouseDown.Y, (int)(ImageView.mouseUp.X - ImageView.mouseDown.X), (int)(ImageView.mouseUp.Y - ImageView.mouseDown.Y));
475 if (r.Width <= 2 || r.Height <= 2)
476 return;
477 Bitmap bf = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.Z, coord.C, coord.T]].GetCropBuffer(r);
478 Statistics[] sts = Statistics.FromBytes(bf);
479 Statistics st = sts[0];
480 Threshold th;
481 if (magicSel.Numeric)
482 {
483 th = new Threshold((int)magicSel.Threshold);
484 }
485 else
486 if (magicSel.Index == 2)
487 th = new Threshold((int)(st.Min + st.Mean));
488 else
489 if (magicSel.Index == 1)
490 th = new Threshold((int)st.Median);
491 else
492 th = new Threshold(st.Min);
493 th.ApplyInPlace((Bitmap)bf.Image);
494 Invert inv = new Invert();
495 Bitmap det;
496 if (bf.BitsPerPixel > 8)
497 det = AForge.Imaging.Image.Convert16bppTo8bpp((Bitmap)bf.Image);
498 else
499 det = (Bitmap)bf.Image;
500 BlobCounter blobCounter = new BlobCounter();
501 blobCounter.ProcessImage(det);
502 Blob[] blobs = blobCounter.GetObjectsInformation();
503 // create convex hull searching algorithm
504 GrahamConvexHull hullFinder = new GrahamConvexHull();
505 // lock image to draw on it
506 // process each blob
507 foreach (Blob blob in blobs)
508 {
509 if (blob.Rectangle.Width < magicSel.Max && blob.Rectangle.Height < magicSel.Max)
510 continue;
511 List<IntPoint> leftPoints = new List<IntPoint>();
512 List<IntPoint> rightPoints = new List<IntPoint>();
513 List<IntPoint> edgePoints = new List<IntPoint>();
514 List<IntPoint> hull = new List<IntPoint>();
515 // get blob's edge points
516 blobCounter.GetBlobsLeftAndRightEdges(blob,
517 out leftPoints, out rightPoints);
518 edgePoints.AddRange(leftPoints);
519 edgePoints.AddRange(rightPoints);
520 // blob's convex hull
521 hull = hullFinder.FindHull(edgePoints);
522 PointD[] pfs = new PointD[hull.Count];
523 for (int i = 0; i < hull.Count; i++)
524 {
525 pfs[i] = new PointD(r.X + hull[i].X, r.Y + hull[i].Y);
526 }
527 ROI an = ROI.CreateFreeform(coord, pfs);
528 ImageView.SelectedImage.Annotations.Add(an);
529 }
530 }
531 else
532 if (Tools.currentTool.type == Tools.Tool.Type.bucket && buts == MouseButtons.Left)
533 {
534 ZCT coord = App.viewer.GetCoordinate();
535 floodFiller.FillColor = DrawColor;
536 floodFiller.Tolerance = currentTool.tolerance;
537 floodFiller.Bitmap = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.C, coord.Z, coord.T]];
538 floodFiller.FloodFill(new AForge.Point((int)p.X, (int)p.Y));
539 App.viewer.UpdateImages();
540 }
541 else
542 if (Tools.currentTool.type == Tools.Tool.Type.dropper && buts == MouseButtons.Left)
543 {
544 DrawColor = ImageView.SelectedBuffer.GetPixel((int)p.X, (int)p.Y);
545 UpdateGUI();
546 }
547 UpdateOverlay();
548 }
BioImager.ROI.CreateFreeform
static ROI CreateFreeform(ZCT coord, PointD[] pts)
Definition: Bio.cs:863
BioImager.Scripting.State.GetUp
static State GetUp(PointD pf, MouseButtons mb)
Definition: Scripting.cs:171

References BioImager.ROI.AddPoint(), BioImager.ROI.CreateFreeform(), BioImager.ImageView.GetCoordinate(), BioImager.ROI.GetPointCount(), BioImager.ImageView.GetScale(), BioImager.ROI.GetSelectBound(), BioImager.ROI.GetSelectBoxes(), BioImager.Scripting.State.GetUp(), BioImager.ImageView.HardwareAcceleration, BioImager.BioImage.ToImageSpace(), BioImager.ImageView.UpdateImages(), BioImager.ROI.UpdatePoint(), and BioImager.Scripting.UpdateState().

◆ UpdateOverlay()

void BioImager.Tools.UpdateOverlay ( )

Definition at line 188 of file Tools.cs.

189 {
190 App.viewer.UpdateOverlay();
191 }

◆ UpdateSelected()

void BioImager.Tools.UpdateSelected ( )

It loops through all the controls in the form and if the control has a tag of "tool" it sets the background color to white

Definition at line 198 of file Tools.cs.

199 {
200 foreach (Control item in this.Controls)
201 {
202 if (item.Tag != null)
203 if (item.Tag.ToString() == "tool")
204 item.BackColor = System.Drawing.Color.White;
205 }
206 }

Referenced by BioImager.Tools.ToolDown().

◆ UpdateView()

void BioImager.Tools.UpdateView ( )

Definition at line 192 of file Tools.cs.

193 {
194 App.viewer.UpdateView();
195 }

Member Data Documentation

◆ applyToStack

bool BioImager.Tools.applyToStack = false
static

Definition at line 25 of file Tools.cs.

◆ bEnabled

bool BioImager.Tools.bEnabled = true
static

Definition at line 29 of file Tools.cs.

◆ colorTool

ColorTool BioImager.Tools.colorTool
static

Definition at line 26 of file Tools.cs.

◆ currentTool

Tool BioImager.Tools.currentTool
static

Definition at line 128 of file Tools.cs.

◆ font

Font BioImager.Tools.font

Definition at line 166 of file Tools.cs.

◆ gEnabled

bool BioImager.Tools.gEnabled = true
static

Definition at line 28 of file Tools.cs.

◆ rEnabled

bool BioImager.Tools.rEnabled = true
static

Definition at line 27 of file Tools.cs.

◆ selectBoxSize

float BioImager.Tools.selectBoxSize = ROI.selectBoxSize
static

Definition at line 217 of file Tools.cs.

◆ selectionRect

RectangleD BioImager.Tools.selectionRect
static

Definition at line 165 of file Tools.cs.

◆ selectionRectangle

System.Drawing.Rectangle BioImager.Tools.selectionRectangle
static

Definition at line 34 of file Tools.cs.

◆ tools

Hashtable BioImager.Tools.tools = new Hashtable()
static

Definition at line 35 of file Tools.cs.

Property Documentation

◆ DrawColor

ColorS BioImager.Tools.DrawColor
staticgetset

Definition at line 129 of file Tools.cs.

130 {
131 get
132 {
133 return drawColor;
134 }
135 set
136 {
137 drawColor = value;
138 }
139 }

◆ EraseColor

ColorS BioImager.Tools.EraseColor
staticgetset

Definition at line 140 of file Tools.cs.

141 {
142 get
143 {
144 return eraseColor;
145 }
146 set
147 {
148 eraseColor = value;
149 }
150 }

◆ StrokeWidth

int BioImager.Tools.StrokeWidth
staticgetset

Definition at line 152 of file Tools.cs.

153 {
154 get
155 {
156 return width;
157 }
158 set
159 {
160 width = value;
161 App.tools.UpdateGUI();
162 }
163 }
The documentation for this class was generated from the following files: