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

260 {
261 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null)
262 return;
263 Scripting.UpdateState(Scripting.State.GetDown(e, buts));
264 PointD p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
265 PointD roiPoint = GetAnnotationPoint(e);
266 if (currentTool.type == Tool.Type.line && buts == MouseButtons.Left)
267 {
268 if (anno.type != ROI.Type.Line)
269 {
270 anno = new ROI();
271 anno.type = ROI.Type.Line;
272 anno.AddPoint(roiPoint);
273 anno.AddPoint(roiPoint);
274 anno.coord = App.viewer.GetCoordinate();
275 ImageView.SelectedImage.Annotations.Add(anno);
276 RefreshRoiManager();
277 }
278 }
279 else
280 if (currentTool.type == Tool.Type.polygon && buts == MouseButtons.Left)
281 {
282 if (anno.type != ROI.Type.Polygon)
283 {
284 anno = new ROI();
285 anno.type = ROI.Type.Polygon;
286 anno.closed = false;
287 anno.AddPoint(roiPoint);
288 anno.coord = App.viewer.GetCoordinate();
289 ImageView.SelectedImage.Annotations.Add(anno);
290 RefreshRoiManager();
291 }
292 else
293 {
294 //If we click on a point 1 we close this polygon
295 double hitSize = App.viewer.GetSelectionBoxHitSize();
296 PointD firstPoint = anno.Points[0];
297 double dx = roiPoint.X - firstPoint.X;
298 double dy = roiPoint.Y - firstPoint.Y;
299 if ((dx * dx) + (dy * dy) <= (hitSize * hitSize))
300 {
301 anno.closed = true;
302 anno.UpdateBoundingBox();
303 RefreshRoiManager();
304 anno = new ROI();
305 }
306 else
307 {
308 anno.AddPoint(roiPoint);
309 RefreshRoiManager();
310 }
311 }
312 }
313 else
314 if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left)
315 {
316 if (anno.type != ROI.Type.Freeform)
317 {
318 anno = new ROI();
319 anno.type = ROI.Type.Freeform;
320 anno.closed = false;
321 anno.AddPoint(roiPoint);
322 anno.coord = App.viewer.GetCoordinate();
323 ImageView.SelectedImage.Annotations.Add(anno);
324 RefreshRoiManager();
325 }
326 else
327 {
328 anno.AddPoint(roiPoint);
329 RefreshRoiManager();
330 }
331 }
332 else
333 if (currentTool.type == Tool.Type.rect && buts == MouseButtons.Left)
334 {
335 anno = new ROI();
336 anno.type = ROI.Type.Rectangle;
337 rectStart = roiPoint;
338 anno.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, 0, 0);
339 anno.Validate();
340 anno.coord = App.viewer.GetCoordinate();
341 ImageView.SelectedImage.Annotations.Add(anno);
342 currentTool.Rectangle = anno.BoundingBox;
343 }
344 else
345 if (currentTool.type == Tool.Type.ellipse && buts == MouseButtons.Left)
346 {
347 anno = new ROI();
348 anno.type = ROI.Type.Ellipse;
349 rectStart = roiPoint;
350 anno.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, 0, 0);
351 anno.Validate();
352 anno.coord = App.viewer.GetCoordinate();
353 ImageView.SelectedImage.Annotations.Add(anno);
354 currentTool.Rectangle = anno.BoundingBox;
355 }
356 else
357 if (currentTool.type == Tool.Type.delete && buts == MouseButtons.Left)
358 {
359 for (int i = 0; i < ImageView.SelectedImage.Annotations.Count; i++)
360 {
361 ROI an = ImageView.SelectedImage.Annotations[i];
362 if (an.BoundingBox.IntersectsWith(new RectangleD(roiPoint.X, roiPoint.Y, 1, 1)))
363 {
364 if (an.selectedPoints.Count == 0)
365 {
366 ImageView.SelectedImage.Annotations.Remove(an);
367 RefreshRoiManager();
368 break;
369 }
370 else
371 if (an.selectedPoints.Count == 1 && !(an.type == ROI.Type.Polygon || an.type == ROI.Type.Polyline || an.type == ROI.Type.Freeform))
372 {
373 ImageView.SelectedImage.Annotations.Remove(an);
374 RefreshRoiManager();
375 break;
376 }
377 else
378 {
379 if (an.type == ROI.Type.Polygon ||
380 an.type == ROI.Type.Polyline ||
381 an.type == ROI.Type.Freeform)
382 {
383 an.closed = false;
384 an.RemovePoints(an.selectedPoints.ToArray());
385 break;
386 }
387 }
388 }
389 }
390 UpdateOverlay();
391 }
392 else
393 if (currentTool.type == Tool.Type.text && buts == MouseButtons.Left)
394 {
395 ROI an = new ROI();
396 an.type = ROI.Type.Label;
397 an.AddPoint(roiPoint);
398 an.coord = App.viewer.GetCoordinate();
399 TextInput ti = new TextInput("");
400 if (ti.ShowDialog() != DialogResult.OK)
401 return;
402 Font labelFont = ti.font ?? SystemFonts.DefaultFont;
403 string labelText = ti.TextValue ?? string.Empty;
404 System.Drawing.Size labelSize = TextRenderer.MeasureText(labelText, labelFont);
405 AForge.RectangleF labelBox = ImageView.SelectedImage.ToImageSpace(new RectangleD(0, 0, labelSize.Width, labelSize.Height));
406 an.family = labelFont.FontFamily.Name;
407 an.fontSize = labelFont.Size;
408 an.strokeColor = AForge.Color.FromArgb(ti.color.A, ti.color.R, ti.color.G, ti.color.B);
409 an.Text = labelText;
410 an.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, labelBox.Width, labelBox.Height);
411 ImageView.SelectedImage.Annotations.Add(an);
412 RefreshRoiManager();
413 }
414
415 if (buts == MouseButtons.Middle)
416 {
417 currentTool = GetTool(Tool.Type.pan);
418 UpdateSelected();
419 panPanel.BackColor = System.Drawing.Color.LightGray;
420 }
421
422
423 UpdateOverlay();
424 }
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 585 of file Tools.cs.

586 {
587 if (App.viewer == null)
588 return;
589 if (ImageView.SelectedImage == null)
590 return;
591 PointD p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
592 PointD roiPoint = GetAnnotationPoint(e);
593 if (Tools.currentTool.type == Tools.Tool.Type.pan && (buts.HasFlag(MouseButtons.Left) || buts.HasFlag(MouseButtons.Middle)))
594 {
595 if (ImageView.SelectedImage.isPyramidal)
596 {
597 if (App.viewer.MouseMoveInt.X != 0 || App.viewer.MouseMoveInt.Y != 0)
598 {
599 App.viewer.PyramidalOrigin = new PointD(
600 App.viewer.PyramidalOrigin.X + (ImageView.mouseDown.X - e.X),
601 App.viewer.PyramidalOrigin.Y + (ImageView.mouseDown.Y - e.Y));
602 App.viewer.UpdateImages();
603 }
604 }
605 else
606 {
607 PointD pf = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
608 App.viewer.Origin = new PointD(App.viewer.Origin.X + pf.X, App.viewer.Origin.Y + pf.Y);
609 App.viewer.UpdateView(false);
610 }
611 App.viewer.UpdateStatus();
612 return;
613 }
614
615 if (currentTool.type == Tool.Type.line && ImageView.down)
616 {
617 anno.UpdatePoint(roiPoint, 1);
618 UpdateOverlay();
619 }
620 else
621 if (currentTool.type == Tool.Type.freeform && ImageView.down)
622 {
623 if (anno.type != ROI.Type.Freeform)
624 {
625 anno = new ROI();
626 anno.type = ROI.Type.Freeform;
627 anno.closed = false;
628 anno.AddPoint(roiPoint);
629 anno.coord = App.viewer.GetCoordinate();
630 ImageView.SelectedImage.Annotations.Add(anno);
631 RefreshRoiManager();
632 }
633 else
634 {
635 anno.AddPoint(roiPoint);
636 RefreshRoiManager();
637 }
638 UpdateOverlay();
639 }
640 else
641
642 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle)
643 {
644 RectangleD rect;
645 double x = Math.Min(rectStart.X, roiPoint.X);
646 double y = Math.Min(rectStart.Y, roiPoint.Y);
647 double w = Math.Abs(roiPoint.X - rectStart.X);
648 double h = Math.Abs(roiPoint.Y - rectStart.Y);
649 rect = new RectangleD(x, y, w, h);
650 anno.BoundingBox = rect;
651 anno.Validate();
652 currentTool.Rectangle = rect;
653 UpdateOverlay();
654 }
655 else
656 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse)
657 {
658 RectangleD rect;
659 double x = Math.Min(rectStart.X, roiPoint.X);
660 double y = Math.Min(rectStart.Y, roiPoint.Y);
661 double w = Math.Abs(roiPoint.X - rectStart.X);
662 double h = Math.Abs(roiPoint.Y - rectStart.Y);
663 rect = new RectangleD(x, y, w, h);
664 anno.BoundingBox = rect;
665 anno.Validate();
666 currentTool.Rectangle = rect;
667 UpdateOverlay();
668 }
669 else
670 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left && ImageView.down)
671 {
672 PointD roiDown = GetAnnotationPoint(ImageView.mouseDown);
673 PointD d = new PointD(roiPoint.X - roiDown.X, roiPoint.Y - roiDown.Y);
674 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(roiDown.X, roiDown.Y, d.X, d.Y);
675 UpdateOverlay();
676 }
677 else
678 if (currentTool.type == Tool.Type.rectSel && ImageView.up)
679 {
680 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
681 }
682 else
683 if (Win32.GetKeyState(Keys.Delete))
684 {
685 foreach (ROI an in ImageView.selectedAnnotations)
686 {
687 if (an != null)
688 {
689 if (an.selectedPoints.Count == 0)
690 {
691 ImageView.SelectedImage.Annotations.Remove(an);
692 }
693 else
694 {
695 if (an.type == ROI.Type.Polygon ||
696 an.type == ROI.Type.Polyline ||
697 an.type == ROI.Type.Freeform)
698 {
699 an.closed = false;
700 an.RemovePoints(an.selectedPoints.ToArray());
701
702 }
703 }
704 }
705 }
706 UpdateOverlay();
707 }
708 /*
709 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
710 {
711 //First we draw the selection rectangle
712 PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
713 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
714 UpdateOverlay();
715 }
716 */
717 if (buts == MouseButtons.Left && currentTool.type == Tool.Type.eraser)
718 {
719 Graphics.Graphics g = Graphics.Graphics.FromImage(ImageView.SelectedBuffer);
720 Graphics.Pen pen = new Graphics.Pen(Tools.EraseColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel);
721 g.FillEllipse(new Rectangle((int)p.X, (int)p.Y, (int)width, (int)Tools.StrokeWidth), pen.color);
722 pen.Dispose();
723 App.viewer.UpdateImage();
724 }
725 }
BioImager.ImageView.UpdateImages
async void UpdateImages()
Definition ImageView.cs:1626
BioImager.ImageView.Origin
PointD Origin
A property of the class PointD. *‍/.
Definition ImageView.cs:942
BioImager.ImageView.PyramidalOrigin
PointD PyramidalOrigin
Setting the value of the pyramidalOrigin variable. *‍/.
Definition ImageView.cs:954
BioImager.ImageView.UpdateView
void UpdateView(bool refreshImages=true)
Definition ImageView.cs:1277
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 431 of file Tools.cs.

432 {
433 PointD p = new PointD();
434 if (ImageView.SelectedImage == null)
435 return;
436 p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
437 PointD roiPoint = GetAnnotationPoint(e);
438 if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null || anno == null)
439 return;
440 Scripting.UpdateState(Scripting.State.GetUp(e, buts));
441 if (currentTool.type == Tool.Type.point && buts == MouseButtons.Left)
442 {
443 ROI an = new ROI();
444 an.AddPoint(roiPoint);
445 an.type = ROI.Type.Point;
446 an.coord = App.viewer.GetCoordinate();
447 ImageView.SelectedImage.Annotations.Add(an);
448 }
449 else
450 if (currentTool.type == Tool.Type.line && anno.type == ROI.Type.Line && buts == MouseButtons.Left)
451 {
452 if (anno.GetPointCount() > 0)
453 {
454 anno.UpdatePoint(roiPoint, 1);
455 anno.UpdateBoundingBox();
456 RefreshRoiManager();
457 anno = new ROI();
458 }
459 }
460 else
461 if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle && buts == MouseButtons.Left)
462 {
463 currentTool.Rectangle = new RectangleD(0, 0, 0, 0);
464 anno = new ROI();
465 rectStart = new PointD();
466 }
467 else
468 if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse && buts == MouseButtons.Left)
469 {
470 currentTool.Rectangle = new RectangleD(0, 0, 0, 0);
471 anno = new ROI();
472 rectStart = new PointD();
473 }
474 else
475 if (currentTool.type == Tool.Type.freeform && anno.type == ROI.Type.Freeform && buts == MouseButtons.Left)
476 {
477 anno.closed = true;
478 anno.UpdateBoundingBox();
479 RefreshRoiManager();
480 anno = new ROI();
481 }
482 else
483 if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left)
484 {
485 if (!Win32.GetKeyState(Keys.LControlKey))
486 ImageView.selectedAnnotations.Clear();
487 RectangleD r = GetTool(Tool.Type.rectSel).Rectangle;
488 double hitSize = App.viewer.GetSelectionBoxHitSize();
489 foreach (ROI an in App.viewer.AnnotationsRGB)
490 {
491 if (an.GetSelectBound(hitSize, hitSize).ToRectangleF().IntersectsWith(r.ToRectangleF()))
492 {
493 if(!Win32.GetKeyState(Keys.LControlKey))
494 an.selectedPoints.Clear();
495 ImageView.selectedAnnotations.Add(an);
496 an.Selected = true;
497 RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
498 for (int i = 0; i < sels.Length; i++)
499 {
500 if (sels[i].IntersectsWith(r))
501 {
502 an.selectedPoints.Add(i);
503 }
504 }
505 }
506 else
507 an.Selected = false;
508 }
509 Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
510 }
511 else
512 if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
513 {
514 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));
515 AForge.RectangleF rr = ImageView.SelectedImage.ToImageSpace(r);
516 ZCT coord = App.viewer.GetCoordinate();
517 Bitmap bf;
518 if (ImageView.SelectedImage.Buffers[0].RGBChannelsCount > 1)
519 bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[1].Range, ImageView.SelectedBuffer.Stats[2].Range);
520 else
521 bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range);
522 bf.Crop(rr.ToRectangleInt());
523 Statistics[] sts = Statistics.FromBytes(bf);
524 Statistics st = sts[0];
525 int th = 0;
526 if (magicSel.Numeric)
527 {
528 th = magicSel.Threshold;
529 }
530 else
531 if (magicSel.Index == 2)
532 th = (int)(st.Min + st.Mean);
533 else
534 if (magicSel.Index == 1)
535 th = (int)st.Median;
536 else
537 th = (int)st.Min;
538 Bitmap det;
539 if (bf.BitsPerPixel > 8)
540 {
541 bf.To8Bit();
542 det = bf;
543 //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));
544 }
545 else
546 {
547 //blobCounter.BackgroundThreshold = AForge.Color.FromArgb((int)th, (int)th, (int)th);
548 det = bf;
549 }
550 BlobCounter blobCounter = new BlobCounter(det);
551 blobCounter.FilterBlobs = true;
552 blobCounter.MinWidth = 2;
553 blobCounter.MinHeight = 2;
554 blobCounter.CoupledSizeFiltering = true;
555 Blob[] blobs = blobCounter.GetObjects(det, true);
556 double px = ImageView.SelectedImage.PhysicalSizeX;
557 double py = ImageView.SelectedImage.PhysicalSizeY;
558 foreach (Blob blob in blobs)
559 {
560 AForge.RectangleD rd = new RectangleD(blob.Rectangle.X * px, blob.Rectangle.Y * py, blob.Rectangle.Width * px, blob.Rectangle.Height * py);
561 PointD loc = new PointD(r.X + rd.X, r.Y + rd.Y);
562 ROI an = ROI.CreateRectangle(coord, loc.X, loc.Y, rd.W, rd.H);
563 ImageView.SelectedImage.Annotations.Add(an);
564 }
565 }
566 else
567 if (Tools.currentTool.type == Tools.Tool.Type.bucket && buts == MouseButtons.Left)
568 {
569 ZCT coord = App.viewer.GetCoordinate();
570 floodFiller.FillColor = DrawColor;
571 floodFiller.Tolerance = currentTool.tolerance;
572 floodFiller.Bitmap = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.C, coord.Z, coord.T]];
573 floodFiller.FloodFill(new AForge.Point((int)p.X, (int)p.Y));
574 App.viewer.UpdateImages();
575 }
576 else
577 if (Tools.currentTool.type == Tools.Tool.Type.dropper && buts == MouseButtons.Left)
578 {
579 DrawColor = ImageView.SelectedBuffer.GetPixel((int)p.X, (int)p.Y);
580 UpdateGUI();
581 }
582 UpdateOverlay();
583 }
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: