public ActiveLaser(RichPictureBox richPictureBox) : base()
{
this.FlashTimer.Interval = 1000;
this.richPictureBox = richPictureBox;
activeCircle = new ActiveCircle(richPictureBox, this);
this.GraphicsProperties.GraphicsPropertiesChangedHandler += GraphicsPropertiesChangedHandler;
}
public override void Draw(Graphics g, RichPictureBox richPictureBox)
{
g.CompositingQuality = CompositingQuality.HighQuality;
g.SmoothingMode = SmoothingMode.AntiAlias;
SolidBrush brush = new SolidBrush(this.GraphicsProperties.Color);
GraphicsPath path1 = new GraphicsPath();
GraphicsPath path2 = new GraphicsPath();
Region region1 = new Region();
Region region2 = new Region();
for (int i = 0; i < count; i++)
{
path1.AddEllipse(OutterCircles[i].Rectangle.X, OutterCircles[i].Rectangle.Y,
OutterCircles[i].Rectangle.Width, OutterCircles[i].Rectangle.Height);
path2.AddEllipse(InnerCircles[i].Rectangle.X, InnerCircles[i].Rectangle.Y,
InnerCircles[i].Rectangle.Width, InnerCircles[i].Rectangle.Height);
if (i == 0)
{
region1 = new Region(path1);
region2 = new Region(path2);
}
region1.Union(new Region(path1));
region2.Union(new Region(path2));
}
region1.Exclude(region2);
g.FillRegion(brush, region1);
brush.Dispose();
path1.Dispose();
path2.Dispose();
region1.Dispose();
}
public override void Move(RichPictureBox richPictureBox, int deltaX, int deltaY)
{
Point s = Point.Ceiling(startDataPoint), e = Point.Ceiling(endDataPoint);
startDataPoint = new Point(s.X + deltaX, s.Y + deltaY);
endDataPoint = new Point(e.X + deltaX, e.Y + deltaY);
}
public override void Draw(Graphics g, RichPictureBox richPictureBox)
{
if (OutterCircle == null)
{
OutterCircle = new Circle(CenterPoint, OutterCircleSize);
}
if (InnerCircle == null)
{
InnerCircle = new Circle(CenterPoint, InnerCircleSize);
}
//path for the outer and inner circles
g.CompositingQuality = CompositingQuality.HighQuality;
g.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath path = new GraphicsPath())
{
if (Flashing)
{
brush = new SolidBrush(this.flickCount % 2 == 1 ? this.GraphicsProperties.Color : Color.LightSalmon);
}
else
{
brush = new SolidBrush(this.GraphicsProperties.Color);
}
path.AddEllipse(OutterCircle.Rectangle.X, OutterCircle.Rectangle.Y,
OutterCircle.Rectangle.Width, OutterCircle.Rectangle.Height);
path.AddEllipse(InnerCircle.Rectangle.X, InnerCircle.Rectangle.Y,
InnerCircle.Rectangle.Width, InnerCircle.Rectangle.Height);
g.FillPath(brush, path);
}
DrawCross(g);
brush.Dispose();
}
public DrawPolyLine(RichPictureBox richPictureBox, int x1, int y1, int x2, int y2)
: base(richPictureBox, x1, y1, x2, y2)
{
InitializeGraphicsProperties();
this.RegisterUpdateStatisticsHandler();
this.GraphicsProperties.GraphicsPropertiesChangedHandler += richPictureBox.GraphicsPropertiesChangedHandler;
}
public void Draw(Graphics g, RichPictureBox richPictureBox)
{
int n = graphicsList.Count;
DrawObject o;
// Enumerate list in reverse order to get first
// object on the top of Z-order.
for (int i = n - 1; i >= 0; i--)
{
if (richPictureBox == null)
{
break;
}
o = graphicsList[i];
g.ScaleTransform(richPictureBox.Zoom, richPictureBox.Zoom);
g.TranslateTransform(richPictureBox.OffsetX, richPictureBox.OffsetY);
o.Draw(g, richPictureBox);
o.DrawText(g, richPictureBox);
if (o.Selected)
{
o.DrawTracker(g, richPictureBox);
}
g.ResetTransform();
}
}
public override void OnMouseUp(RichPictureBox richPictureBox, MouseEventArgs e)
{
newPolygon.Creating = false;
newPolygon = null;
base.OnMouseUp(richPictureBox, e);
}
/// <summary>
/// draw line graphic
/// </summary>
/// <param name="g"></param>
/// <param name="richPictureBox"></param>
public override void Draw(Graphics g, RichPictureBox richPictureBox)
{
g.SmoothingMode = SmoothingMode.AntiAlias;
double CurrentAngle = new SEGMENT((int)startDataPoint.X, (int)startDataPoint.Y, (int)endDataPoint.X, (int)endDataPoint.Y).SegmentDirection();
CurrentAngle = CvRadToDeg(CurrentAngle);
if (CurrentAngle > 180)
{
CurrentAngle = CurrentAngle - 360;
}
using (Pen pen = new Pen(Color.FromArgb(GraphicsProperties.Alpha, GraphicsProperties.Color), GraphicsProperties.PenWidth))
{
if (IsMoving)
{
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
pen.DashPattern = new float[] { 4.0F, 2.8F };
}
g.DrawLine(pen, startDataPoint.X + MovingOffset.X, startDataPoint.Y + MovingOffset.Y,
endDataPoint.X + MovingOffset.X, endDataPoint.Y + MovingOffset.Y);
int OriginCrossArmLength = 20;
PointF origin = new PointF(startDataPoint.X + MovingOffset.X, startDataPoint.Y + MovingOffset.Y);
PointF last = new PointF(endDataPoint.X + MovingOffset.X, endDataPoint.Y + MovingOffset.Y);
g.DrawLine(pen, origin.X - OriginCrossArmLength, origin.Y, origin.X + OriginCrossArmLength, origin.Y);
g.DrawLine(pen, origin.X, origin.Y - OriginCrossArmLength, origin.X, origin.Y + OriginCrossArmLength);
g.DrawArc(pen, origin.X - OriginCrossArmLength, origin.Y - OriginCrossArmLength, 2 * OriginCrossArmLength, 2 * OriginCrossArmLength, 0, Convert.ToInt32(-CurrentAngle));
angle = strCutDecimals(CurrentAngle, 1) + "°";
//DrawAngle(g, richPictureBox, CurrentAngle, origin, last);
}
}
public override void OnMouseDown(RichPictureBox richPictureBox, MouseEventArgs e)
{
if (richPictureBox.RestrictArea.CheckPointInRegion(e.Location))
{
return;
}
richPictureBox.DrawObject = null;
clickCount++;
if (clickCount % 2 == 1)
{
//base.OnMouseDown(richPictureBox, e);
startPoint = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
drawObject = new DrawEllipse(richPictureBox, startPoint.X, startPoint.Y, startPoint.X, startPoint.Y, 0.6);
AddNewObject(richPictureBox, drawObject);
}
else
{
endPoint = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
Rectangle rectangle = new Rectangle(new Point(startPoint.X - 1, startPoint.Y - 1), new Size(2, 2));
if (rectangle.Contains(endPoint))
{
richPictureBox.GraphicsList.DeleteDrawObject(drawObject);
richPictureBox.Invalidate();
}
}
}
protected override bool CheckHandleRegion(RichPictureBox richPictureBox, int handleNumber, Point point)
{
Rectangle rectangle = GetHandleRectangle(richPictureBox, handleNumber);
rectangle.Offset(-richPictureBox.OffsetX, -richPictureBox.OffsetY);
return(rectangle.Contains(point));
}
public override void OnMouseUp(RichPictureBox richPictureBox, MouseEventArgs e)
{
if (richPictureBox.RestrictArea.CheckPointInRegion(e.Location))
{
return;
}
if (clickCount % 2 == 0)
{
endPoint = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
Rectangle rectangle = new Rectangle(new Point(startPoint.X - 1, startPoint.Y - 1), new Size(2, 2));
if (rectangle.Contains(endPoint))
{
richPictureBox.GraphicsList.DeleteDrawObject(drawObject);
richPictureBox.Invalidate();
}
else
{
//richPictureBox.GraphicsList[0].UpdateStatisticsInformation();
if (richPictureBox.GraphicsList[0] != null)
{
richPictureBox.GraphicsList[0].Creating = false;
}
//richPictureBox.ActiveTool = DrawToolType.Pointer;
}
}
}
public override void OnMouseMove(RichPictureBox richPictureBox, MouseEventArgs e)
{
if (richPictureBox.RestrictArea.CheckPointInRegion(e.Location))
{
return;
}
richPictureBox.Cursor = Cursor;
if (clickCount % 2 == 1)
{
var p = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
Rectangle rectangle = new Rectangle(new Point(startPoint.X - 1, startPoint.Y - 1), new Size(2, 2));
if (rectangle.Contains(p))
{
return;
}
base.OnMouseMove(richPictureBox, e);
Point point = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
if (richPictureBox.GraphicsList != null && richPictureBox.GraphicsList.Count > 0)
{
richPictureBox.GraphicsList[0].MoveHandleTo(richPictureBox, point, 5);
richPictureBox.Invalidate();
}
}
}
public HitTestResult HitTest(RichPictureBox richPictureBox, Point point, bool forSelection, bool hitTestHandle = true)
{
if (Selected && hitTestHandle)
{
for (int i = 1; i <= HandleCount; i++)
{
if (CheckHandleRegion(richPictureBox, i, point))
{
return(new HitTestResult(ElementType.Handle, i));
}
}
}
UpdateHitTestRegions();
if (forSelection)
{
return(HitTestForSelection(richPictureBox, point));
}
else
{
for (int i = 0; i < GateCount; i++)
{
PointF dataPoint = point;
if (HitTest(i, dataPoint))
{
return(new HitTestResult(ElementType.Gate, i));
}
}
return(new HitTestResult(ElementType.Nothing, -1));
}
}
/// <summary>
/// draw object
/// </summary>
/// <param name="g"></param>
/// <param name="richPictureBox"></param>
public override void Draw(Graphics g, RichPictureBox richPictureBox)
{
Point p1 = Point.Empty; // previous point
Point p2 = Point.Empty; // current point
g.SmoothingMode = SmoothingMode.AntiAlias;
using (Pen pen = new Pen(GraphicsProperties.Color, GraphicsProperties.PenWidth))
{
PointFEnumerator enumerator = pointArray.GetEnumerator();
if (enumerator.MoveNext())
{
p1 = Point.Ceiling(enumerator.Current);
p1.Offset(MovingOffset);
}
while (enumerator.MoveNext())
{
p2 = Point.Ceiling(enumerator.Current);
p2.Offset(MovingOffset);
g.DrawLine(pen, p1, p2);
p1 = p2;
}
enumerator.Reset();
if (enumerator.MoveNext())
{
p2 = Point.Ceiling(enumerator.Current);
p2.Offset(MovingOffset);
g.DrawLine(pen, p1, p2);
}
}
}
/// <summary>
/// 创建预设屏幕4点坐标
/// </summary>
/// <param name="index"></param>
/// <param name="pictureBoxSize"></param>
/// <returns></returns>
private Point CreatePresetScreenPoint(int index, RichPictureBox richPictureBox, int thisAttempt = 0)
{
Point psp = Point.Empty;
Rectangle bounds = new Rectangle(0, 0, richPictureBox.RealSize.Width, richPictureBox.RealSize.Height);
int offSetX = /*(richPictureBox.Width - richPictureBox.RealSize.Width) / 2*/ 0;
int offsetY = /*(richPictureBox.Height - richPictureBox.RealSize.Height) / 2*/ 0;
switch (index)
{
case 3:
psp = new Point(offSetX + bounds.Width - 200 - thisAttempt * 50, offsetY + bounds.Height / 2);
break;
case 4:
psp = new Point(offSetX + bounds.Width / 2, offsetY + bounds.Height - 200 - thisAttempt * 50);
break;
case 5:
psp = new Point(offSetX + 200 + thisAttempt * 50, offsetY + bounds.Height / 2);
break;
case 6:
psp = new Point(offSetX + bounds.Width / 2, offsetY + 200 + thisAttempt * 50);
break;
}
//check point in legal region
return(psp);
}
public override void OnMouseMove(RichPictureBox richPictureBox, MouseEventArgs e)
{
richPictureBox.Cursor = Cursor;
if (e.Button != MouseButtons.Left)
{
return;
}
if (newPolygon == null)
{
return;
}
Point point = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
int distance = (point.X - lastX) * (point.X - lastX) + (point.Y - lastY) * (point.Y - lastY);
if (distance < minDistance)
{
// Distance between last two points is less than minimum -
// move last point
newPolygon.MoveHandleTo(richPictureBox, point, newPolygon.PointCount);
}
else
{
// Add new point
newPolygon.AddPoint(richPictureBox, point, false);
lastX = point.X;
lastY = point.Y;
}
richPictureBox.Invalidate();
}
public DrawLine(RichPictureBox richPictureBox, int x1, int y1, int x2, int y2) : this()
{
this.richPictureBox = richPictureBox;
startDataPoint = new Point(x1, y1);
endDataPoint = new Point(x2, y2);
this.GraphicsProperties.GraphicsPropertiesChangedHandler += richPictureBox.GraphicsPropertiesChangedHandler;
}
public override void MoveHandleTo(RichPictureBox richPictureBox, Point point, int handleNumber)
{
OutterCircles.Clear();
InnerCircles.Clear();
EndCenterPoint = point;
float dx = EndCenterPoint.X - StartCenterPoint.X;
float dy = EndCenterPoint.Y - StartCenterPoint.Y;
var k = dy / dx;
var length = Math.Sqrt(dx * dx + dy * dy);
OutterCircles.Add(new Circle(StartCenterPoint, OutterCircleSize));
InnerCircles.Add(new Circle(StartCenterPoint, InnerCircleSize));
for (int i = 1; i < count; i++)
{
float x = 0;
float y = 0;
if (dx == 0)
{
x = StartCenterPoint.X;
if (dx < 0)
{
y = StartCenterPoint.Y - 20 * i;
}
else
{
y = StartCenterPoint.Y + 20 * i;
}
}
else if (dy == 0)
{
if (dy < 0)
{
x = StartCenterPoint.X - 20 * i;
}
else
{
x = StartCenterPoint.X + 20 * i;
}
y = StartCenterPoint.Y;
}
else
{
if ((dx > 0 && dy > 0) || (dx > 0 && dy < 0))
{
x = (float)(StartCenterPoint.X + 20 * i / Math.Sqrt(1 + k * k));
y = (float)(StartCenterPoint.Y + k * 20 * i / Math.Sqrt(1 + k * k));
}
else if ((dx < 0 && dy < 0) || (dx < 0 && dy > 0))
{
x = (float)(StartCenterPoint.X - 20 * i / Math.Sqrt(1 + k * k));
y = (float)(StartCenterPoint.Y - k * 20 * i / Math.Sqrt(1 + k * k));
}
}
OutterCircles.Add(new Circle(new PointF(x, y), OutterCircleSize));
InnerCircles.Add(new Circle(new PointF(x, y), InnerCircleSize));
}
}
public static LaserFactory GetInstance(RichPictureBox richPictureBox)
{
if (factory == null)
{
factory = new LaserFactory(richPictureBox);
}
return(factory);
}
/// <summary>
/// call when press "Escape" key
/// </summary>
/// <param name="drawArea"></param>
/// <param name="cancelSelection"></param>
public override void OnCancel(RichPictureBox richPictureBox, bool cancelSelection)
{
// cancel adding
if (richPictureBox.GraphicsList.Count > 0 && richPictureBox.GraphicsList[0].Creating)
{
richPictureBox.GraphicsList.DeleteLastAddedObject();
}
}
public RestrictArea(RichPictureBox picturebox)
{
this.picturebox = picturebox;
InitializeOriginalMotorPoints();
drawRestrict = false;
}
public DrawPolygon(RichPictureBox richPictureBox, int x1, int y1, int x2, int y2) : this()
{
this.richPictureBox = richPictureBox;
pointArray = new PointFList();
pointArrayProportion = new PointFList();
AddPoint(richPictureBox, new Point(x1, y1), false);
AddPoint(richPictureBox, new Point(x2, y2), false);
}
/// <summary>
/// add new object to picturebox
/// </summary>
/// <param name="richPictureBox"></param>
/// <param name="o"></param>
protected void AddNewObject(RichPictureBox richPictureBox, DrawObject o)
{
richPictureBox.GraphicsList.UnselectAll();
o.Selected = true;
o.Creating = true;
richPictureBox.GraphicsList.Add(o);
}
public DrawRectangle(RichPictureBox richPictureBox, int x, int y, int width, int height) : this()
{
this.richPictureBox = richPictureBox;
InitializeGraphicsProperties();
this.ObjectType = ObjectType.Rectangle;
rectangle = new Rectangle(x, y, width, height);
SetRectangle(rectangle);
this.GraphicsProperties.GraphicsPropertiesChangedHandler += richPictureBox.GraphicsPropertiesChangedHandler;
}
public LaserFactory(RichPictureBox richPictureBox)
{
this.richPictureBox = richPictureBox;
this.fixedLaser = new FixedLaser(richPictureBox);
this.activeLaser = new ActiveLaser(richPictureBox);
this.alignLaser = new AlignLaser(richPictureBox);
this.alignLaser.ZoomHandler += richPictureBox.ZoomHandler;
alignLaser.ButtonStateHandler += Program.EntryForm.ButtonStateHandler;
}
public override void Move(RichPictureBox richPictureBox, int deltaX, int deltaY)
{
PointF ps = ellipseForDraw.StartPoint;
PointF pe = ellipseForDraw.EndPoint;
ellipseForDraw.StartPoint = new PointF(ps.X + deltaX, ps.Y + deltaY);
ellipseForDraw.EndPoint = new PointF(pe.X + deltaX, pe.Y + deltaY);
UpdateEllipseForHit();
}
public AlignLaser(RichPictureBox richPictureBox) : base()
{
this.richPictureBox = richPictureBox;
circles = new List <Circle>();
string jsonConfig = JsonFile.ReadJsonConfigString();
circles = JsonFile.GetConfigFromJsonText <List <Circle> >(jsonConfig);
this.ZoomView = true;
}
public override void OnMouseDown(RichPictureBox richPictureBox, MouseEventArgs e)
{
Point point = new Point((int)(e.X / richPictureBox.Zoom - richPictureBox.OffsetX), (int)(e.Y / richPictureBox.Zoom - richPictureBox.OffsetY));
newPolygon = new DrawPolygon(richPictureBox, point.X, point.Y, point.X + 1, point.Y + 1);
AddNewObject(richPictureBox, newPolygon);
lastX = point.X;
lastY = point.Y;
}
public virtual void DrawText(Graphics g, RichPictureBox richPictureBox)
{
SolidBrush brush = new SolidBrush(Program.SysConfig.GraphicsPropertiesManager.GetPropertiesByName("Text").Color);
RectangleF r = GetTextF(this.Name, g, this.ID);
r.Offset(MovingOffset);
g.DrawString(this.Name, this.Font, brush, r);
brush.Dispose();
}
public FixedLaser(RichPictureBox richPictureBox) : base()
{
this.richPictureBox = richPictureBox;
float pulseSize = Program.SysConfig.LaserConfig.PulseSize;
OutterCircleSize = new SizeF(pulseSize + this.GraphicsProperties.ExclusionSize,
pulseSize + this.GraphicsProperties.ExclusionSize);
InnerCircleSize = new SizeF(pulseSize, pulseSize);
this.GraphicsProperties.GraphicsPropertiesChangedHandler += GraphicsPropertiesChangedHandler;
}
