BioImager  4.9.0
A .NET microscopy imaging application based on Bio library. Supports various microscopes by using imported libraries & GUI automation. Supports XInput game controllers to move stage, take images, run ImageJ macros on images or Bio C# scripts.
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 = 1
 

Protected Member Functions

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

Properties

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

Detailed Description

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

Constructor & Destructor Documentation

◆ Tools()

BioImager.Tools.Tools ( )

Definition at line 171 of file Tools.cs.

172 {
173 InitializeComponent();
174 Tool.Init();
175 ColorS col = new ColorS(ushort.MaxValue);
176 //We initialize the tools
177 currentTool = GetTool(Tool.Type.move);
178 ROI.selectBoxSize = 1;
179 floodFiller = null;
180 floodFiller = new QueueLinearFloodFiller(floodFiller);
181 }
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 183 of file Tools.cs.

184 {
185 return (Tool)tools[name];
186 }

◆ GetTool() [2/2]

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

Definition at line 187 of file Tools.cs.

188 {
189 return (Tool)tools[typ.ToString()];
190 }

◆ 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 248 of file Tools.cs.

249 {
250 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null)
251 return;
252 Scripting.UpdateState(Scripting.State.GetDown(e, buts));
253 PointD p;
254 if(ImageView.SelectedImage!=null)
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.Points[0]))
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.BoundingBox = 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.BoundingBox = 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(new RectangleD(e.X, e.Y, 1, 1)))
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.family = font.FontFamily.Name;
372 an.fontSize = ti.font.Size;
373 an.strokeColor = AForge.Color.FromArgb(ti.color.A, ti.color.R, ti.color.G, ti.color.B);
374 an.Text = ti.TextValue;
375 ImageView.SelectedImage.Annotations.Add(an);
376 }
377
378 if (buts == MouseButtons.Middle)
379 {
380 currentTool = GetTool(Tool.Type.pan);
381 UpdateSelected();
382 panPanel.BackColor = System.Drawing.Color.LightGray;
383 }
384
385
386 UpdateOverlay();
387 }
BioImager.ImageView
ImageView control for image stacks, pyramidal and whole-slide-images.
Definition ImageView.designer.cs:5
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.Designer.cs:4
BioImager.Tools.UpdateSelected
void UpdateSelected()
Definition Tools.cs:201

◆ ToolMove()

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

Definition at line 543 of file Tools.cs.

544 {
545 if (App.viewer == null)
546 return;
547 if (ImageView.SelectedImage == null)
548 return;
549 PointD p = ImageView.SelectedImage.ToImageSpace(e);
550 if (Tools.currentTool.type == Tools.Tool.Type.pan && (buts.HasFlag(MouseButtons.Left) || buts.HasFlag(MouseButtons.Middle)))
551 {
552 if (ImageView.SelectedImage.isPyramidal)
553 {
554 if (App.viewer.MouseMoveInt.X != 0 || App.viewer.MouseMoveInt.Y != 0)
555 {
556 App.viewer.PyramidalOriginTransformed = new PointD(App.viewer.PyramidalOriginTransformed.X + (ImageView.mouseDown.X - e.X), App.viewer.PyramidalOriginTransformed.Y + (ImageView.mouseDown.Y - e.Y));
557 App.viewer.UpdateImages();
558 }
559 }
560 else
561 {
562 PointD pf = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
563 App.viewer.Origin = new PointD(App.viewer.Origin.X + pf.X, App.viewer.Origin.Y + pf.Y);
564 }
565 UpdateView();
566 }
567
568
569 if (currentTool.type == Tool.Type.line && ImageView.down)
570 {
571 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
572 UpdateOverlay();
573 }
574 else
575 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left && ImageView.down)
576 {
577 if (anno.GetPointCount() == 0)
578 {
579 anno.type = ROI.Type.Freeform;
580 anno.AddPoint(new PointD(e.X, e.Y));
581 anno.coord = App.viewer.GetCoordinate();
582 anno.closed = true;
583 ImageView.SelectedImage.Annotations.Add(anno);
584 }
585 else
586 {
587 anno.AddPoint(new PointD(e.X, e.Y));
588 }
589 UpdateOverlay();
590 }
591 else
592
593 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle)
594 {
595 if (anno.GetPointCount() == 4)
596 {
597 anno.BoundingBox = new RectangleD(anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
598 UpdateOverlay();
599 }
600 }
601 else
602 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse)
603 {
604 if (anno.GetPointCount() == 4)
605 {
606 anno.BoundingBox = new RectangleD(anno.X, anno.Y, e.X - anno.X, e.Y - anno.Y);
607 UpdateOverlay();
608 }
609 }
610 else
611 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left && ImageView.down)
612 {
613 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
614 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
615 RectangleD r = Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle;
616 foreach (ROI an in App.viewer.AnnotationsRGB)
617 {
618 if (an.GetSelectBound(App.viewer.GetScale(), App.viewer.GetScale()).IntersectsWith(r))
619 {
620 if (!Win32.GetKeyState(Keys.LControlKey))
621 an.selectedPoints.Clear();
622 ImageView.selectedAnnotations.Add(an);
623 an.Selected = true;
624 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
625 for (int i = 0; i < sels.Length; i++)
626 {
627 if (sels[i].IntersectsWith(r))
628 {
629 an.selectedPoints.Add(i);
630 }
631 }
632 }
633 else if (!Win32.GetKeyState(Keys.LControlKey))
634 an.Selected = false;
635 }
636 UpdateOverlay();
637 }
638 else
639 if (currentTool.type == Tool.Type.rectSel && ImageView.up)
640 {
641 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
642 }
643 else
644 if (Win32.GetKeyState(Keys.Delete))
645 {
646 foreach (ROI an in ImageView.selectedAnnotations)
647 {
648 if (an != null)
649 {
650 if (an.selectedPoints.Count == 0)
651 {
652 ImageView.SelectedImage.Annotations.Remove(an);
653 }
654 else
655 {
656 if (an.type == ROI.Type.Polygon ||
657 an.type == ROI.Type.Polyline ||
658 an.type == ROI.Type.Freeform)
659 {
660 an.closed = false;
661 an.RemovePoints(an.selectedPoints.ToArray());
662
663 }
664 }
665 }
666 }
667 UpdateOverlay();
668 }
669 if (currentTool.type == Tool.Type.rectSel && buts.HasFlag(MouseButtons.Left))
670 {
671 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
672 Tools.GetTool(Tools.Tool.Type.select).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, Math.Abs(d.X), Math.Abs(d.Y));
673 RectangleD r = Tools.GetTool(Tools.Tool.Type.select).Rectangle;
674 List<ROI> rois = ImageView.SelectedImage.Annotations;
675 foreach (ROI an in rois)
676 {
677 if (an.GetSelectBound(ROI.selectBoxSize * ImageView.SelectedImage.PhysicalSizeX, ROI.selectBoxSize * ImageView.SelectedImage.PhysicalSizeY).IntersectsWith(r))
678 {
679 if(!Win32.GetKeyState(Keys.LControlKey))
680 an.selectedPoints.Clear();
681 an.Selected = true;
682 RectangleD[] sels = an.GetSelectBoxes();
683 for (int i = 0; i < sels.Length; i++)
684 {
685 if (sels[i].IntersectsWith(r))
686 {
687 an.selectedPoints.Add(i);
688 }
689 }
690 }
691 }
692 App.viewer.UpdateView();
693 }
694 /*
695 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
696 {
697 //First we draw the selection rectangle
698 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
699 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
700 UpdateOverlay();
701 }
702 */
703 if (buts == MouseButtons.Left && currentTool.type == Tool.Type.eraser)
704 {
705 Graphics.Graphics g = Graphics.Graphics.FromImage(ImageView.SelectedBuffer);
706 Graphics.Pen pen = new Graphics.Pen(Tools.EraseColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel);
707 g.FillEllipse(new Rectangle((int)p.X, (int)p.Y, (int)width, (int)Tools.StrokeWidth), pen.color);
708 pen.Dispose();
709 App.viewer.UpdateImage();
710 }
711 }
BioImager.ImageView.Origin
PointD Origin
A property of the class PointD. *‍/.
Definition ImageView.cs:727
BioImager.ImageView.UpdateImages
async void UpdateImages(bool updatePyramidal=false)
Definition ImageView.cs:1291
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 394 of file Tools.cs.

395 {
396 PointD p = new PointD();
397 if (ImageView.SelectedImage == null)
398 return;
399 p = ImageView.SelectedImage.ToImageSpace(e);
400 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null || anno == null)
401 return;
402 Scripting.UpdateState(Scripting.State.GetUp(e, buts));
403 if (currentTool.type == Tool.Type.point && buts == MouseButtons.Left)
404 {
405 ROI an = new ROI();
406 an.AddPoint(new PointD(e.X, e.Y));
407 an.type = ROI.Type.Point;
408 an.coord = App.viewer.GetCoordinate();
409 ImageView.SelectedImage.Annotations.Add(an);
410 }
411 else
412 if (currentTool.type == Tool.Type.line && anno.type == ROI.Type.Line && buts == MouseButtons.Left)
413 {
414 if (anno.GetPointCount() > 0)
415 {
416 anno.UpdatePoint(new PointD(e.X, e.Y), 1);
417 anno = new ROI();
418 }
419 }
420 else
421 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle && buts == MouseButtons.Left)
422 {
423 if (anno.GetPointCount() == 4)
424 {
425 anno = new ROI();
426 }
427 }
428 else
429 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse && buts == MouseButtons.Left)
430 {
431 if (anno.GetPointCount() == 4)
432 {
433 anno = new ROI();
434 }
435 }
436 else
437 if (currentTool.type == Tool.Type.freeform && anno.type == ROI.Type.Freeform && buts == MouseButtons.Left)
438 {
439 anno = new ROI();
440 }
441 else
442 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left)
443 {
444 if (!Win32.GetKeyState(Keys.LControlKey))
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 if(!Win32.GetKeyState(Keys.LControlKey))
452 an.selectedPoints.Clear();
453 ImageView.selectedAnnotations.Add(an);
454 an.Selected = true;
455 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
456 for (int i = 0; i < sels.Length; i++)
457 {
458 if (sels[i].IntersectsWith(r))
459 {
460 an.selectedPoints.Add(i);
461 }
462 }
463 }
464 else
465 an.Selected = false;
466 }
467 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
468 }
469 else
470 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
471 {
472 RectangleD r = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, Math.Abs(ImageView.mouseUp.X - ImageView.mouseDown.X), Math.Abs(ImageView.mouseUp.Y - ImageView.mouseDown.Y));
473 AForge.RectangleF rr = ImageView.SelectedImage.ToImageSpace(r);
474 ZCT coord = App.viewer.GetCoordinate();
475 Bitmap bf;
476 if (ImageView.SelectedImage.Buffers[0].RGBChannelsCount > 1)
477 bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[1].Range, ImageView.SelectedBuffer.Stats[2].Range);
478 else
479 bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range);
480 bf.Crop(rr.ToRectangleInt());
481 Statistics[] sts = Statistics.FromBytes(bf);
482 Statistics st = sts[0];
483 int th = 0;
484 if (magicSel.Numeric)
485 {
486 th = magicSel.Threshold;
487 }
488 else
489 if (magicSel.Index == 2)
490 th = (int)(st.Min + st.Mean);
491 else
492 if (magicSel.Index == 1)
493 th = (int)st.Median;
494 else
495 th = (int)st.Min;
496 Bitmap det;
497 if (bf.BitsPerPixel > 8)
498 {
499 bf.To8Bit();
500 det = bf;
501 //blobCounter.BackgroundThreshold = AForge.Color.FromArgb((int)(((float)th / (float)ushort.MaxValue) * 255), (int)(((float)th / (float)ushort.MaxValue) * 255), (int)(((float)th / (float)ushort.MaxValue) * 255));
502 }
503 else
504 {
505 //blobCounter.BackgroundThreshold = AForge.Color.FromArgb((int)th, (int)th, (int)th);
506 det = bf;
507 }
508 BlobCounter blobCounter = new BlobCounter(det);
509 blobCounter.FilterBlobs = true;
510 blobCounter.MinWidth = 2;
511 blobCounter.MinHeight = 2;
512 blobCounter.CoupledSizeFiltering = true;
513 Blob[] blobs = blobCounter.GetObjects(det, true);
514 double px = ImageView.SelectedImage.PhysicalSizeX;
515 double py = ImageView.SelectedImage.PhysicalSizeY;
516 foreach (Blob blob in blobs)
517 {
518 AForge.RectangleD rd = new RectangleD(blob.Rectangle.X * px, blob.Rectangle.Y * py, blob.Rectangle.Width * px, blob.Rectangle.Height * py);
519 PointD loc = new PointD(r.X + rd.X, r.Y + rd.Y);
520 ROI an = ROI.CreateRectangle(coord, loc.X, loc.Y, rd.W, rd.H);
521 ImageView.SelectedImage.Annotations.Add(an);
522 }
523 }
524 else
525 if (Tools.currentTool.type == Tools.Tool.Type.bucket && buts == MouseButtons.Left)
526 {
527 ZCT coord = App.viewer.GetCoordinate();
528 floodFiller.FillColor = DrawColor;
529 floodFiller.Tolerance = currentTool.tolerance;
530 floodFiller.Bitmap = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.C, coord.Z, coord.T]];
531 floodFiller.FloodFill(new AForge.Point((int)p.X, (int)p.Y));
532 App.viewer.UpdateImages();
533 }
534 else
535 if (Tools.currentTool.type == Tools.Tool.Type.dropper && buts == MouseButtons.Left)
536 {
537 DrawColor = ImageView.SelectedBuffer.GetPixel((int)p.X, (int)p.Y);
538 UpdateGUI();
539 }
540 UpdateOverlay();
541 }
BioImager.Scripting.State.GetUp
static State GetUp(PointD pf, MouseButtons mb)
Definition Scripting.cs:171

◆ UpdateOverlay()

void BioImager.Tools.UpdateOverlay ( )

Definition at line 191 of file Tools.cs.

192 {
193 App.viewer.UpdateOverlay();
194 }

◆ 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 201 of file Tools.cs.

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

◆ UpdateView()

void BioImager.Tools.UpdateView ( )

Definition at line 195 of file Tools.cs.

196 {
197 App.viewer.UpdateView();
198 }

Member Data Documentation

◆ applyToStack

bool BioImager.Tools.applyToStack = false
static

Definition at line 27 of file Tools.cs.

◆ bEnabled

bool BioImager.Tools.bEnabled = true
static

Definition at line 31 of file Tools.cs.

◆ colorTool

ColorTool BioImager.Tools.colorTool
static

Definition at line 28 of file Tools.cs.

◆ currentTool

Tool BioImager.Tools.currentTool
static

Definition at line 131 of file Tools.cs.

◆ font

Font BioImager.Tools.font

Definition at line 169 of file Tools.cs.

◆ gEnabled

bool BioImager.Tools.gEnabled = true
static

Definition at line 30 of file Tools.cs.

◆ rEnabled

bool BioImager.Tools.rEnabled = true
static

Definition at line 29 of file Tools.cs.

◆ selectBoxSize

float BioImager.Tools.selectBoxSize = 1
static

Definition at line 220 of file Tools.cs.

◆ selectionRect

RectangleD BioImager.Tools.selectionRect
static

Definition at line 168 of file Tools.cs.

◆ selectionRectangle

System.Drawing.Rectangle BioImager.Tools.selectionRectangle
static

Definition at line 36 of file Tools.cs.

◆ tools

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

Definition at line 37 of file Tools.cs.

Property Documentation

◆ DrawColor

ColorS BioImager.Tools.DrawColor
staticgetset

Definition at line 132 of file Tools.cs.

133 {
134 get
135 {
136 return drawColor;
137 }
138 set
139 {
140 drawColor = value;
141 }
142 }

◆ EraseColor

ColorS BioImager.Tools.EraseColor
staticgetset

Definition at line 143 of file Tools.cs.

144 {
145 get
146 {
147 return eraseColor;
148 }
149 set
150 {
151 eraseColor = value;
152 }
153 }

◆ StrokeWidth

int BioImager.Tools.StrokeWidth
staticgetset

Definition at line 155 of file Tools.cs.

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