2217 lines
90 KiB
C#
2217 lines
90 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Design;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Drawing.Drawing2D;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.NetworkInformation;
|
|
using System.Security.Cryptography;
|
|
using System.Security.Permissions;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
using AGVControl.Models;
|
|
using AR;
|
|
using static System.Net.Mime.MediaTypeNames;
|
|
|
|
namespace AGVControl
|
|
{
|
|
public class RFIDConnection
|
|
{
|
|
public uint StartRFID { get; set; }
|
|
public uint EndRFID { get; set; }
|
|
public bool IsBidirectional { get; set; }
|
|
public float Distance { get; set; }
|
|
public List<uint> IntermediateRFIDs { get; set; } = new List<uint>();
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj is RFIDConnection other)
|
|
{
|
|
return (StartRFID == other.StartRFID && EndRFID == other.EndRFID) ||
|
|
(IsBidirectional && other.IsBidirectional &&
|
|
StartRFID == other.EndRFID && EndRFID == other.StartRFID);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return StartRFID.GetHashCode() ^ EndRFID.GetHashCode();
|
|
}
|
|
}
|
|
public struct PathResult
|
|
|
|
{
|
|
public bool Success { get; set; }
|
|
public string Message { get; set; }
|
|
public List<Point> Path { get; set; }
|
|
}
|
|
|
|
public enum AGVMoveState
|
|
{
|
|
Stop = 0,
|
|
Run
|
|
}
|
|
|
|
public enum AGVActionReasonCode
|
|
{
|
|
Unknown = 0,
|
|
NoPosition, // 위치 미확정(처음 기동)
|
|
NoPath, // 경로 없음 또는 현재 위치 미확정
|
|
NotOnPath, // 현재 위치가 경로에 없음
|
|
Arrived, // 경로의 마지막 지점(목적지 도달)
|
|
Normal, // 정상(다음 RFID 있음)
|
|
NeedTurn,
|
|
NoTurnPoint,
|
|
}
|
|
|
|
public class AGVActionPrediction
|
|
{
|
|
public Direction Direction { get; set; }
|
|
public uint? NextRFID { get; set; }
|
|
public string Reason { get; set; }
|
|
public AGVActionReasonCode ReasonCode { get; set; }
|
|
public AGVMoveState MoveState { get; set; } // RUN 또는 STOP
|
|
}
|
|
|
|
public partial class MapControl : Control
|
|
{
|
|
#region 상수 정의
|
|
private const int SNAP_DISTANCE = 10; // 점 근접 거리
|
|
private const int LINE_WIDTH = 20; // 선 굵기
|
|
private const int TOOLBAR_WIDTH = 58; // 툴바 너비
|
|
private const int TOOLBAR_WIDTHR = 78; // 우측 툴바 너비
|
|
private const int TOOLBAR_BUTTON_HEIGHT = 40; // 툴바 버튼 높이
|
|
private const int TOOLBAR_MARGIN = 5; // 툴바 마진
|
|
private const int SELECTION_DISTANCE = 15; // 선택 가능 거리
|
|
#endregion
|
|
|
|
#region 멤버 변수
|
|
// 맵 데이터
|
|
private List<RFIDPoint> rfidPoints;
|
|
private List<MapText> mapTexts;
|
|
private List<CustomLine> customLines;
|
|
private List<RFIDLine> rfidLines;
|
|
private HashSet<RFIDConnection> rfidConnections;
|
|
public AGV agv;
|
|
|
|
// 화면 조작 관련
|
|
private float zoom = 1.0f;
|
|
private PointF offset = PointF.Empty;
|
|
private Point lastMousePosition;
|
|
private Point currentMousePosition;
|
|
private bool isDragging = false;
|
|
private Point? previewStartPoint = null;
|
|
private Point? lineStartPoint = null;
|
|
private Point? branchPoint = null;
|
|
|
|
// 모드 관련
|
|
private bool isAddingText = false;
|
|
private bool isAddingPoint = false;
|
|
private bool isDrawingCustomLine = false;
|
|
private bool isDrawingRFIDLine = false;
|
|
private bool isDeletingRFIDLine = false;
|
|
private bool isDrawingLine = false;
|
|
private bool isDraggingPoint = false;
|
|
private bool isDraggingText = false;
|
|
private Point dragOffset;
|
|
|
|
// 선택된 객체
|
|
private MapText selectedText = null;
|
|
private CustomLine selectedLine = null;
|
|
private RFIDPoint selectedRFID = null;
|
|
private RFIDLine selectedRFIDLine = null;
|
|
private Point? draggingPoint = null;
|
|
|
|
// 툴바 관련
|
|
private List<ToolBarItem> toolbarRects;
|
|
|
|
// RFID 관련
|
|
public string RFIDStartNo { get; set; } = string.Empty;
|
|
public int RFIDLastNumber = 0;
|
|
private string filename = string.Empty;
|
|
#endregion
|
|
|
|
#region 속성
|
|
public MapText SelectedText => selectedText;
|
|
public CustomLine SelectedLine => selectedLine;
|
|
public RFIDPoint SelectedRFID => selectedRFID;
|
|
public RFIDLine SelectedRFIDLine => selectedRFIDLine;
|
|
#endregion
|
|
|
|
#region 생성자 및 초기화
|
|
public MapControl()
|
|
{
|
|
this.DoubleBuffered = true;
|
|
rfidPoints = new List<RFIDPoint>();
|
|
mapTexts = new List<MapText>();
|
|
customLines = new List<CustomLine>();
|
|
rfidLines = new List<RFIDLine>();
|
|
rfidConnections = new HashSet<RFIDConnection>();
|
|
agv = new AGV();
|
|
|
|
UpdateToolbarRects();
|
|
}
|
|
#endregion
|
|
|
|
#region 이벤트 핸들러
|
|
public event EventHandler<MouseEventArgs> OnRightClick;
|
|
#endregion
|
|
|
|
#region OVERRIDE
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
base.OnMouseUp(e);
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
isDragging = false;
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
else if (e.Button == MouseButtons.Left)
|
|
{
|
|
isDragging = false;
|
|
isDraggingPoint = false;
|
|
isDraggingText = false;
|
|
}
|
|
}
|
|
protected override void OnMouseClick(MouseEventArgs e)
|
|
{
|
|
base.OnMouseClick(e);
|
|
var mapPoint = ScreenToMap(e.Location);
|
|
if (e.Button == MouseButtons.Right)
|
|
{
|
|
OnRightClick?.Invoke(this, e);
|
|
this.MouseMode = eMouseMode.Default;
|
|
}
|
|
else if (e.Button == MouseButtons.Left)
|
|
{
|
|
// 툴바 버튼 클릭 처리
|
|
var toolbar = toolbarRects.FirstOrDefault(t => t.Bounds.Contains(e.Location));
|
|
if (toolbar != null)
|
|
{
|
|
switch (toolbar.Title.ToLower())
|
|
{
|
|
case "+": ZoomIn(); break;
|
|
case "-": ZoomOut(); break;
|
|
case "1:1": ResetZoom(); break;
|
|
case "cut": MouseMode = (eMouseMode.rfidcut); break;
|
|
case "text": MouseMode = (eMouseMode.addtext); break;
|
|
case "line": MouseMode = (eMouseMode.addrfidline); break;
|
|
case "cline": MouseMode = (eMouseMode.addcustomline); break;
|
|
case "point": MouseMode = (eMouseMode.addrfidpoint); break;
|
|
case "path":
|
|
|
|
var input1 = AR.UTIL.InputBox("input start");
|
|
if (input1.Item1 == false) return;
|
|
var input2 = AR.UTIL.InputBox("input end");
|
|
if (input2.Item1 == false) return;
|
|
|
|
var startRFID = input1.Item2;
|
|
var endRFID = input2.Item2;
|
|
|
|
var valid1 = uint.TryParse(input1.Item2, out uint vstart);
|
|
var valid2 = uint.TryParse(input2.Item2, out uint vend);
|
|
|
|
if (valid1 == false || valid2 == false)
|
|
{
|
|
MessageBox.Show("RFID값은 정수로 입력하세요", "경로 계산", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
var rlt = CalculatePath(vstart, vend);
|
|
|
|
if (rlt.Success == false)
|
|
{
|
|
MessageBox.Show(rlt.Message, "경로 계산", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
SetCurrentPath(rlt.Path); //현재 경로로 설정함
|
|
MessageBox.Show($"경로가 계산되었습니다.\nRFID 순서: {string.Join(" -> ", rlt.Path)}",
|
|
"경로 계산", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
if (SetTargetPosition(vend) == false)
|
|
{
|
|
MessageBox.Show("목적지 설정 실패");
|
|
}
|
|
}
|
|
break;
|
|
case "pos":
|
|
var tag = AR.UTIL.InputBox("input rfid tag value");
|
|
if (tag.Item1 && tag.Item2 != "" && uint.TryParse(tag.Item2, out uint val) == true)
|
|
{
|
|
var targetRFID = SetCurrentPosition(val);
|
|
}
|
|
break;
|
|
case "save":
|
|
using (var od = new SaveFileDialog())
|
|
{
|
|
od.Filter = "path data|*.route";
|
|
od.FilterIndex = 0;
|
|
od.RestoreDirectory = true;
|
|
if (filename.isEmpty() == false)
|
|
{
|
|
od.FileName = System.IO.Path.GetFileName(filename);
|
|
od.InitialDirectory = System.IO.Path.GetDirectoryName(filename);
|
|
}
|
|
|
|
if (od.ShowDialog() == DialogResult.OK)
|
|
{
|
|
filename = od.FileName;
|
|
this.SaveToFile(filename);
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
break;
|
|
case "load":
|
|
using (var od = new OpenFileDialog())
|
|
{
|
|
od.Filter = "path data|*.route";
|
|
od.FilterIndex = 0;
|
|
|
|
|
|
if (string.IsNullOrEmpty(this.filename) == false)
|
|
{
|
|
od.FileName = System.IO.Path.GetFileName(this.filename);
|
|
od.InitialDirectory = System.IO.Path.GetDirectoryName(this.filename);
|
|
}
|
|
else
|
|
{
|
|
od.RestoreDirectory = true;
|
|
}
|
|
|
|
|
|
if (od.ShowDialog() == DialogResult.OK)
|
|
{
|
|
|
|
this.LoadFromFile(filename, out string errmsg);
|
|
if (errmsg.isEmpty() == false) UTIL.MsgE(errmsg);
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// RFID 포인트 선택
|
|
var clickedRFID = rfidPoints.FirstOrDefault(r => GetDistance(mapPoint, r.Location) <= SNAP_DISTANCE);
|
|
switch (mousemode)
|
|
{
|
|
case eMouseMode.rfidcut:
|
|
DeleteNearbyRFIDLine(mapPoint);
|
|
break;
|
|
case eMouseMode.addrfidpoint:
|
|
if (string.IsNullOrEmpty(this.RFIDStartNo) == false)
|
|
{
|
|
if (uint.TryParse(this.RFIDStartNo, out uint rfidvalue))
|
|
{
|
|
AddRFIDPoint(mapPoint, rfidvalue);
|
|
|
|
// 숫자로 끝나는 RFID 값인 경우 자동 증가
|
|
if (Regex.IsMatch(RFIDStartNo, @"^[A-Za-z]+\d+$"))
|
|
{
|
|
// 마지막 숫자 부분 추출
|
|
Match match = Regex.Match(RFIDStartNo, @"\d+$");
|
|
if (match.Success)
|
|
{
|
|
int currentNumber = int.Parse(match.Value);
|
|
if (currentNumber > this.RFIDLastNumber)
|
|
{
|
|
RFIDLastNumber = currentNumber;
|
|
}
|
|
RFIDLastNumber++;
|
|
|
|
// 숫자 부분을 새로운 번호로 교체
|
|
RFIDStartNo = RFIDStartNo.Substring(0, match.Index) + RFIDLastNumber.ToString("D4");
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case eMouseMode.addtext:
|
|
var text = new MapText
|
|
{
|
|
Location = mapPoint,
|
|
Text = "새 텍스트",
|
|
TextColor = Color.Black,
|
|
BackgroundColor = Color.Transparent,
|
|
Font = new Font("Arial", 12)
|
|
};
|
|
mapTexts.Add(text);
|
|
selectedText = text;
|
|
this.Invalidate();
|
|
break;
|
|
case eMouseMode.addcustomline:
|
|
if (previewStartPoint == null)
|
|
{
|
|
previewStartPoint = mapPoint;
|
|
}
|
|
else
|
|
{
|
|
var line = new CustomLine
|
|
{
|
|
StartPoint = previewStartPoint.Value,
|
|
EndPoint = mapPoint,
|
|
LineColor = Color.Red,
|
|
LineWidth = 2
|
|
};
|
|
customLines.Add(line);
|
|
selectedLine = line;
|
|
previewStartPoint = null;
|
|
this.Invalidate();
|
|
}
|
|
break;
|
|
case eMouseMode.addrfidline:
|
|
if (clickedRFID != null)
|
|
{
|
|
if (previewStartPoint == null)
|
|
{
|
|
previewStartPoint = clickedRFID.Location;
|
|
}
|
|
else
|
|
{
|
|
var startRFID = rfidPoints.FirstOrDefault(r => r.Location == previewStartPoint);
|
|
if (startRFID != null)
|
|
{
|
|
var line = new RFIDLine
|
|
{
|
|
StartPoint = previewStartPoint.Value,
|
|
EndPoint = clickedRFID.Location,
|
|
};
|
|
rfidLines.Add(line);
|
|
selectedRFIDLine = line;
|
|
|
|
// RFID 연결 정보 처리
|
|
ProcessRFIDConnections();
|
|
}
|
|
// 다음 라인을 위해 현재 클릭한 RFID를 시작점으로 설정
|
|
previewStartPoint = clickedRFID.Location;
|
|
}
|
|
this.Invalidate();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
protected override void OnMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
base.OnMouseDoubleClick(e);
|
|
|
|
if (e.Button == MouseButtons.Left)
|
|
{
|
|
var mapPoint = ScreenToMap(e.Location);
|
|
|
|
//RFID 포인트 찾기
|
|
var selected_rfid = rfidPoints.Where(t => t.Bounds.Expand(SELECTION_DISTANCE, SELECTION_DISTANCE).Contains(mapPoint)).FirstOrDefault();
|
|
if (selected_rfid != null)
|
|
{
|
|
UTIL.ShowPropertyDialog(selected_rfid);
|
|
this.Invalidate();
|
|
return;
|
|
}
|
|
|
|
// 텍스트 객체 찾기
|
|
var selected_txt = mapTexts.Where(t => t.Bounds.Expand(SELECTION_DISTANCE, SELECTION_DISTANCE).Contains(mapPoint)).FirstOrDefault();
|
|
if (selected_txt != null)
|
|
{
|
|
UTIL.ShowPropertyDialog(selected_txt);
|
|
this.Invalidate();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
base.OnResize(e);
|
|
UpdateToolbarRects();
|
|
this.Invalidate();
|
|
}
|
|
|
|
protected override void OnMouseWheel(MouseEventArgs e)
|
|
{
|
|
base.OnMouseWheel(e);
|
|
if (e.Delta > 0)
|
|
{
|
|
zoom *= 1.1f;
|
|
}
|
|
else
|
|
{
|
|
zoom /= 1.2f;
|
|
}
|
|
|
|
zoom = Math.Max(0.1f, Math.Min(10.0f, zoom));
|
|
this.Invalidate();
|
|
}
|
|
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
base.OnMouseDown(e);
|
|
lastMousePosition = e.Location;
|
|
var mapPoint = ScreenToMap(e.Location);
|
|
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
isDragging = true;
|
|
this.Cursor = Cursors.SizeAll;
|
|
}
|
|
else if (e.Button == MouseButtons.Left && !isAddingText && !isDrawingCustomLine && !isDrawingRFIDLine)
|
|
{
|
|
isDragging = true;
|
|
|
|
// 텍스트 선택 및 드래그 시작
|
|
foreach (var text in mapTexts)
|
|
{
|
|
var textSize = CreateGraphics().MeasureString(text.Text, text.Font);
|
|
var rect = new RectangleF(
|
|
text.Location.X - SELECTION_DISTANCE,
|
|
text.Location.Y - SELECTION_DISTANCE,
|
|
textSize.Width + SELECTION_DISTANCE * 2,
|
|
textSize.Height + SELECTION_DISTANCE * 2
|
|
);
|
|
|
|
if (rect.Contains(mapPoint))
|
|
{
|
|
selectedText = text;
|
|
isDraggingText = true;
|
|
// 드래그 시작점과 텍스트 위치의 차이를 저장
|
|
dragOffset = new Point(
|
|
text.Location.X - mapPoint.X,
|
|
text.Location.Y - mapPoint.Y
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// 커스텀 라인 선택 및 드래그 포인트 설정
|
|
foreach (var line in customLines)
|
|
{
|
|
float startDistance = GetDistance(mapPoint, line.StartPoint);
|
|
float endDistance = GetDistance(mapPoint, line.EndPoint);
|
|
|
|
if (startDistance < SELECTION_DISTANCE)
|
|
{
|
|
selectedLine = line;
|
|
draggingPoint = line.StartPoint;
|
|
isDraggingPoint = true;
|
|
return;
|
|
}
|
|
else if (endDistance < SELECTION_DISTANCE)
|
|
{
|
|
selectedLine = line;
|
|
draggingPoint = line.EndPoint;
|
|
isDraggingPoint = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
// RFID 포인트 선택
|
|
var clickedRFID = rfidPoints.FirstOrDefault(r =>
|
|
GetDistance(mapPoint, r.Location) <= SNAP_DISTANCE);
|
|
if (clickedRFID != null)
|
|
{
|
|
selectedRFID = clickedRFID;
|
|
draggingPoint = clickedRFID.Location;
|
|
isDraggingPoint = true;
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
base.OnMouseMove(e);
|
|
currentMousePosition = e.Location;
|
|
var mapPoint = ScreenToMap(e.Location);
|
|
|
|
if ((mousemode == eMouseMode.addcustomline || mousemode == eMouseMode.addrfidline) && branchPoint.HasValue)
|
|
{
|
|
UpdatePreviewLine(e.Location);
|
|
}
|
|
|
|
// 툴바 버튼 호버 상태 업데이트
|
|
var oldHovering = toolbarRects.OrderBy(t => t.Idx).Select(t => t.isHovering).ToArray();
|
|
|
|
//toolbar check
|
|
toolbarRects.ForEach(t => t.isHovering = t.Bounds.Contains(e.Location));
|
|
|
|
//hovering check
|
|
if (toolbarRects.Where(t => t.isHovering).Any())
|
|
{
|
|
this.Cursor = Cursors.Hand;
|
|
}
|
|
else if (isDeletingRFIDLine)
|
|
{
|
|
this.Cursor = GetScissorsCursor();
|
|
}
|
|
else
|
|
{
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
|
|
//hovering display update
|
|
if (toolbarRects.Where(t => t.Dirty).Any())
|
|
{
|
|
this.Invalidate();
|
|
}
|
|
|
|
if (isDragging)
|
|
{
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
offset = new PointF(
|
|
offset.X + (e.Location.X - lastMousePosition.X),
|
|
offset.Y + (e.Location.Y - lastMousePosition.Y)
|
|
);
|
|
}
|
|
else if (isDraggingText && selectedText != null)
|
|
{
|
|
// 텍스트 이동 - 드래그 오프셋 적용
|
|
selectedText.Location = new Point(
|
|
mapPoint.X + dragOffset.X,
|
|
mapPoint.Y + dragOffset.Y
|
|
);
|
|
}
|
|
else if (isDraggingPoint && draggingPoint.HasValue)
|
|
{
|
|
// 포인트 이동
|
|
var delta = new Point(
|
|
mapPoint.X - ScreenToMap(lastMousePosition).X,
|
|
mapPoint.Y - ScreenToMap(lastMousePosition).Y
|
|
);
|
|
|
|
if (selectedLine != null)
|
|
{
|
|
// 커스텀 라인 포인트 이동
|
|
if (draggingPoint.Value == selectedLine.StartPoint)
|
|
{
|
|
selectedLine.StartPoint = new Point(
|
|
selectedLine.StartPoint.X + delta.X,
|
|
selectedLine.StartPoint.Y + delta.Y
|
|
);
|
|
}
|
|
else if (draggingPoint.Value == selectedLine.EndPoint)
|
|
{
|
|
selectedLine.EndPoint = new Point(
|
|
selectedLine.EndPoint.X + delta.X,
|
|
selectedLine.EndPoint.Y + delta.Y
|
|
);
|
|
}
|
|
}
|
|
else if (selectedRFID != null) // RFID 포인트 이동
|
|
{
|
|
// RFID 포인트 위치 업데이트
|
|
selectedRFID.Location = new Point(
|
|
selectedRFID.Location.X + delta.X,
|
|
selectedRFID.Location.Y + delta.Y
|
|
);
|
|
|
|
// 연결된 RFID 라인 업데이트
|
|
foreach (var line in rfidLines)
|
|
{
|
|
if (line.StartPoint == draggingPoint.Value)
|
|
{
|
|
line.StartPoint = selectedRFID.Location;
|
|
}
|
|
if (line.EndPoint == draggingPoint.Value)
|
|
{
|
|
line.EndPoint = selectedRFID.Location;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
lastMousePosition = e.Location;
|
|
this.Invalidate();
|
|
}
|
|
|
|
// 미리보기 라인 업데이트를 위한 마우스 위치 저장
|
|
if (isDrawingRFIDLine || isDrawingCustomLine || previewStartPoint.HasValue)
|
|
{
|
|
currentMousePosition = mapPoint;
|
|
}
|
|
|
|
this.Invalidate();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 기타 메서드
|
|
private void UpdateToolbarRects()
|
|
{
|
|
int x, y, c, row;
|
|
var idx = 0;
|
|
|
|
if (this.toolbarRects == null) this.toolbarRects = new List<ToolBarItem>();
|
|
else this.toolbarRects.Clear();
|
|
|
|
//left toolbar
|
|
x = TOOLBAR_MARGIN;
|
|
y = 10;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "+", Bounds = new Rectangle(x, y, TOOLBAR_WIDTH - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "-", Bounds = new Rectangle(x, y, TOOLBAR_WIDTH - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "1:1", Bounds = new Rectangle(x, y, TOOLBAR_WIDTH - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Cut", Bounds = new Rectangle(x, y, TOOLBAR_WIDTH - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
|
|
//right toolbar
|
|
y = 10;
|
|
row = 0;
|
|
x = DisplayRectangle.Right - TOOLBAR_WIDTHR - TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Text", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Line", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Point", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Magnet", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Load", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Save", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Pos", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_MARGIN;
|
|
toolbarRects.Add(new ToolBarItem { Idx = idx++, Title = "Path", Bounds = new Rectangle(x, y, TOOLBAR_WIDTHR - 2 * TOOLBAR_MARGIN, TOOLBAR_BUTTON_HEIGHT) });
|
|
|
|
}
|
|
|
|
public void SetPreviewStartPoint(Point? point)
|
|
{
|
|
previewStartPoint = point;
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void UpdatePreviewLine(Point currentPosition)
|
|
{
|
|
currentMousePosition = currentPosition;
|
|
this.Invalidate();
|
|
}
|
|
|
|
private Point SnapToPoint(Point point)
|
|
{
|
|
// RFID 포인트와 근접한지 확인
|
|
foreach (var rfid in rfidPoints)
|
|
{
|
|
if (GetDistance(point, rfid.Location) <= SNAP_DISTANCE)
|
|
{
|
|
return rfid.Location;
|
|
}
|
|
}
|
|
|
|
return point;
|
|
}
|
|
|
|
|
|
public RFIDPoint FindRFIDPoint(uint rfidValue)
|
|
{
|
|
if (rfidPoints == null || rfidPoints.Any() == false) return null;
|
|
return rfidPoints.FirstOrDefault(r => r.RFIDValue == rfidValue);
|
|
}
|
|
|
|
public bool SetCurrentPosition(uint rfidValue)
|
|
{
|
|
var rfidPoint = FindRFIDPoint(rfidValue);
|
|
if (rfidPoint != null)
|
|
{
|
|
// 이전 위치 저장 (방향 검증용)
|
|
Point previousPosition = agv.CurrentPosition;
|
|
uint previousRFID = agv.CurrentRFID;
|
|
|
|
// AGV 위치 업데이트
|
|
agv.CurrentPosition = rfidPoint.Location;
|
|
agv.CurrentRFID = rfidValue;
|
|
|
|
// 이동 경로에 추가
|
|
agv.AddToMovementHistory(rfidValue, rfidPoint.Location);
|
|
|
|
// 목적지가 설정되어 있고 경로가 있는 경우 검증
|
|
if (agv.TargetPosition != Point.Empty && agv.CurrentPath.Count > 0)
|
|
{
|
|
// 현재 위치가 경로에 있는지 확인
|
|
bool isOnPath = agv.CurrentPath.Contains(agv.CurrentPosition);
|
|
|
|
if (!isOnPath)
|
|
{
|
|
// 경로를 벗어났으므로 새로운 경로 계산
|
|
var pathResult = CalculatePath(agv.CurrentRFID, agv.TargetRFID);
|
|
if (pathResult.Success)
|
|
{
|
|
SetCurrentPath(pathResult.Path);
|
|
}
|
|
}
|
|
|
|
// AGV의 방향 결정
|
|
if (agv.CurrentPath.Count > 0)
|
|
{
|
|
// 다음 목적지 찾기
|
|
var nextPoint = agv.CurrentPath[0];
|
|
|
|
// 회전 가능 여부를 고려하여 방향 결정
|
|
agv.TargetDirection = DetermineDirection(agv.CurrentPosition, nextPoint, agv.TargetPosition);
|
|
}
|
|
}
|
|
|
|
// 목적지 RFID에 도착했고, 해당 RFID에 고정방향이 있으면 TargetDirection을 강제 설정
|
|
if (agv.TargetRFID == rfidValue)
|
|
{
|
|
var destRFID = FindRFIDPoint(rfidValue);
|
|
if (destRFID != null && destRFID.FixedDirection.HasValue)
|
|
{
|
|
agv.TargetDirection = destRFID.FixedDirection.Value;
|
|
}
|
|
}
|
|
|
|
// 방향 검증 및 정정 (이전 위치가 있고 경로가 있는 경우)
|
|
if (previousRFID != 0 && agv.CurrentPath.Count > 0)
|
|
{
|
|
// RFID 연결 정보 기반 예상 방향 계산
|
|
Direction? expectedDirection = null;
|
|
int currentIdx = agv.CurrentPath.FindIndex(p => p == agv.CurrentPosition);
|
|
if (currentIdx >= 0 && currentIdx < agv.CurrentPath.Count - 1)
|
|
{
|
|
// 현재 위치와 다음 위치의 RFID 찾기
|
|
var currentRFIDPoint = FindRFIDPoint(agv.CurrentRFID);
|
|
var nextPoint = agv.CurrentPath[currentIdx + 1];
|
|
var nextRFIDPoint = rfidPoints.FirstOrDefault(p => p.Location == nextPoint);
|
|
|
|
if (currentRFIDPoint != null && nextRFIDPoint != null)
|
|
{
|
|
// rfidConnections에서 연결 정보 확인
|
|
var connection = rfidConnections.FirstOrDefault(c =>
|
|
(c.StartRFID == currentRFIDPoint.RFIDValue && c.EndRFID == nextRFIDPoint.RFIDValue) ||
|
|
(c.IsBidirectional && c.StartRFID == nextRFIDPoint.RFIDValue && c.EndRFID == currentRFIDPoint.RFIDValue));
|
|
|
|
if (connection != null)
|
|
{
|
|
// 연결된 경로이므로 방향 결정
|
|
if (connection.StartRFID == currentRFIDPoint.RFIDValue && connection.EndRFID == nextRFIDPoint.RFIDValue)
|
|
{
|
|
expectedDirection = Direction.Forward; // Start -> End 방향
|
|
}
|
|
else
|
|
{
|
|
expectedDirection = Direction.Backward; // End -> Start 방향
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (expectedDirection.HasValue)
|
|
{
|
|
bool directionValid = agv.ValidateAndCorrectDirectionByConnection(expectedDirection.Value, rfidConnections.ToList());
|
|
if (!directionValid)
|
|
{
|
|
// 방향이 정정되었음을 로그로 기록
|
|
Console.WriteLine($"AGV 방향 정정 (연결 정보 기반): 예상 {expectedDirection.Value} -> 실제 {agv.CurrentDirection}");
|
|
}
|
|
}
|
|
}
|
|
|
|
this.Invalidate();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool SetTargetPosition(uint rfidValue)
|
|
{
|
|
var rfidPoint = FindRFIDPoint(rfidValue);
|
|
if (rfidPoint != null)
|
|
{
|
|
agv.TargetPosition = rfidPoint.Location;
|
|
agv.TargetRFID = rfidValue;
|
|
this.Invalidate();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
private List<Point> CalculatePath(Point start, Point end)
|
|
{
|
|
var openList = new List<Point> { start };
|
|
var closedList = new List<Point>();
|
|
var cameFrom = new Dictionary<Point, Point>();
|
|
var gScore = new Dictionary<Point, float> { { start, 0 } };
|
|
var fScore = new Dictionary<Point, float> { { start, Heuristic(start, end) } };
|
|
|
|
while (openList.Count > 0)
|
|
{
|
|
var current = openList.OrderBy(p => fScore.ContainsKey(p) ? fScore[p] : float.MaxValue).First();
|
|
|
|
if (current == end)
|
|
{
|
|
return ReconstructPath(cameFrom, current);
|
|
}
|
|
|
|
openList.Remove(current);
|
|
closedList.Add(current);
|
|
|
|
foreach (var neighbor in GetNeighbors(current))
|
|
{
|
|
if (closedList.Contains(neighbor))
|
|
continue;
|
|
|
|
float tentativeGScore = gScore[current] + Distance(current, neighbor);
|
|
|
|
if (!openList.Contains(neighbor))
|
|
openList.Add(neighbor);
|
|
else if (tentativeGScore >= gScore[neighbor])
|
|
continue;
|
|
|
|
cameFrom[neighbor] = current;
|
|
gScore[neighbor] = tentativeGScore;
|
|
fScore[neighbor] = gScore[neighbor] + Heuristic(neighbor, end);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
private List<Point> ReconstructPath(Dictionary<Point, Point> cameFrom, Point current)
|
|
{
|
|
var path = new List<Point> { current };
|
|
while (cameFrom.ContainsKey(current))
|
|
{
|
|
current = cameFrom[current];
|
|
path.Insert(0, current);
|
|
}
|
|
return path;
|
|
}
|
|
private float Heuristic(Point a, Point b)
|
|
{
|
|
return (float)Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2));
|
|
}
|
|
|
|
|
|
private float Distance(Point a, Point b)
|
|
{
|
|
// RFID 라인을 통한 연결 확인
|
|
var rfidLines = GetRFIDLines();
|
|
var directConnection = rfidLines.FirstOrDefault(line =>
|
|
(line.StartPoint == a && line.EndPoint == b) ||
|
|
(line.StartPoint == b && line.EndPoint == a));
|
|
|
|
if (directConnection != null)
|
|
{
|
|
return directConnection.Distance;
|
|
}
|
|
|
|
// 직접 연결되지 않은 경우 매우 큰 값 반환
|
|
return float.MaxValue;
|
|
}
|
|
|
|
private List<Point> GetNeighbors(Point point)
|
|
{
|
|
var neighbors = new List<Point>();
|
|
var rfidLines = GetRFIDLines();
|
|
|
|
// RFID 라인에서 이웃 노드 찾기
|
|
foreach (var line in rfidLines)
|
|
{
|
|
if (line.StartPoint == point)
|
|
{
|
|
neighbors.Add(line.EndPoint);
|
|
}
|
|
else if (line.EndPoint == point)
|
|
{
|
|
// 양방향 연결인 경우에만 시작점을 이웃으로 추가
|
|
neighbors.Add(line.StartPoint);
|
|
}
|
|
}
|
|
|
|
return neighbors.Distinct().ToList();
|
|
}
|
|
public void SetPath(List<uint> rfids)
|
|
{
|
|
if (rfids == null || rfids.Count == 0)
|
|
return;
|
|
|
|
var path = new List<Point>();
|
|
foreach (var rfid in rfids)
|
|
{
|
|
var point = GetRFIDPoints().FirstOrDefault(p => p.RFIDValue == rfid);
|
|
if (point != null)
|
|
{
|
|
path.Add(point.Location);
|
|
}
|
|
}
|
|
|
|
if (path.Count > 0)
|
|
{
|
|
SetCurrentPath(path);
|
|
}
|
|
}
|
|
|
|
public PathResult CalculatePath(uint tagStrt, uint tagEnd)
|
|
{
|
|
var retval = new PathResult
|
|
{
|
|
Message = string.Empty,
|
|
Success = false,
|
|
Path = new List<Point>(),
|
|
};
|
|
|
|
var sp = tagStrt; //만약시작위치가 없다면 항상 충전기 기준으로 한다
|
|
var ep = tagEnd;
|
|
|
|
var startPoint = FindRFIDPoint(sp);
|
|
var endPoint = FindRFIDPoint(ep);
|
|
|
|
if (startPoint == null || endPoint == null)
|
|
{
|
|
retval.Message = "유효한 RFID 값을 입력해주세요.";
|
|
return retval;
|
|
}
|
|
|
|
retval.Path = CalculatePath(startPoint.Location, endPoint.Location);
|
|
if (retval.Path != null && retval.Path.Any())
|
|
{
|
|
//SetCurrentPath(retval.Path);
|
|
|
|
//// 경로 상의 모든 RFID 값을 가져옴
|
|
//var rfidPath = new List<uint>();
|
|
//foreach (var point in path)
|
|
//{
|
|
// var rfid = GetRFIDPoints()
|
|
// .FirstOrDefault(r => r.Location == point);
|
|
// if (rfid != null)
|
|
// {
|
|
// rfidPath.Add(rfid.RFIDValue);
|
|
// }
|
|
//}
|
|
retval.Success = true;
|
|
}
|
|
else
|
|
{
|
|
retval.Message = "경로를 찾을 수 없습니다";
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
private void AddNearbyRFIDPoints(RFIDLine line)
|
|
{
|
|
const float NEARBY_DISTANCE = 20.0f; // 근처로 간주하는 거리를 50에서 20으로 줄임
|
|
|
|
// 선 근처의 RFID 포인트들을 찾아서 거리에 따라 정렬
|
|
var nearbyPoints = new List<(RFIDPoint Point, float Distance, float ProjectionRatio)>();
|
|
|
|
foreach (var rfid in rfidPoints)
|
|
{
|
|
if (rfid.Location == line.StartPoint || rfid.Location == line.EndPoint)
|
|
continue;
|
|
|
|
// 선분과 RFID 포인트 사이의 최단 거리 계산
|
|
float distance = GetDistanceToLine(rfid.Location, line.StartPoint, line.EndPoint);
|
|
|
|
if (distance <= NEARBY_DISTANCE)
|
|
{
|
|
// 시작점으로부터의 투영 비율 계산 (0~1 사이 값)
|
|
float projectionRatio = GetProjectionRatio(rfid.Location, line.StartPoint, line.EndPoint);
|
|
if (projectionRatio >= 0 && projectionRatio <= 1) // 선분 위에 있는 점만 포함
|
|
{
|
|
nearbyPoints.Add((rfid, distance, projectionRatio));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 시작점에서 끝점 방향으로 정렬
|
|
nearbyPoints.Sort((a, b) => a.ProjectionRatio.CompareTo(b.ProjectionRatio));
|
|
|
|
// 이전 RFID 값과 위치를 저장
|
|
//uint prevRFID = line.StartRFID;
|
|
Point prevPoint = line.StartPoint;
|
|
|
|
// 정렬된 포인트들을 순차적으로 연결
|
|
foreach (var item in nearbyPoints)
|
|
{
|
|
var rfidLine = new RFIDLine
|
|
{
|
|
StartPoint = prevPoint,
|
|
EndPoint = item.Point.Location,
|
|
|
|
};
|
|
rfidLines.Add(rfidLine);
|
|
|
|
// 현재 포인트를 다음 선분의 시작점으로 설정
|
|
prevPoint = item.Point.Location;
|
|
}
|
|
|
|
// 마지막 포인트와 원래 선의 끝점을 연결
|
|
var finalLine = new RFIDLine
|
|
{
|
|
StartPoint = prevPoint,
|
|
EndPoint = line.EndPoint,
|
|
};
|
|
rfidLines.Add(finalLine);
|
|
|
|
// 원래 선은 제거
|
|
rfidLines.Remove(line);
|
|
}
|
|
|
|
|
|
public void SetRFIDPoints(List<RFIDPoint> points)
|
|
{
|
|
rfidPoints = points;
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void SetAGV(AGV vehicle)
|
|
{
|
|
agv = vehicle;
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void SetMapTexts(List<MapText> texts)
|
|
{
|
|
mapTexts = texts;
|
|
if (mapTexts == null) mapTexts = new List<MapText>();
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void SetCustomLines(List<CustomLine> lines)
|
|
{
|
|
customLines = lines;
|
|
if (customLines == null) customLines = new List<CustomLine>();
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void SetIsAddingText(bool value)
|
|
{
|
|
isAddingText = value;
|
|
isDrawingCustomLine = false;
|
|
this.Cursor = value ? Cursors.IBeam : Cursors.Default;
|
|
}
|
|
|
|
public void SetIsDrawingCustomLine(bool value)
|
|
{
|
|
isDrawingCustomLine = value;
|
|
isAddingText = false;
|
|
this.Cursor = value ? Cursors.Cross : Cursors.Default;
|
|
}
|
|
|
|
public void SetIsDrawingRFIDLine(bool value)
|
|
{
|
|
isDrawingRFIDLine = value;
|
|
isDrawingCustomLine = false;
|
|
isAddingText = false;
|
|
this.Cursor = value ? Cursors.Cross : Cursors.Default;
|
|
}
|
|
|
|
public void SetIsDeletingRFIDLine(bool value)
|
|
{
|
|
isDeletingRFIDLine = value;
|
|
isDrawingCustomLine = false;
|
|
isAddingText = false;
|
|
isDrawingRFIDLine = false;
|
|
this.Cursor = value ? GetScissorsCursor() : Cursors.Default;
|
|
}
|
|
|
|
public void SetIsDrawingLine(bool value)
|
|
{
|
|
isDrawingLine = value;
|
|
isDrawingCustomLine = false;
|
|
isAddingText = false;
|
|
isDrawingRFIDLine = false;
|
|
this.Cursor = value ? Cursors.Cross : Cursors.Default;
|
|
}
|
|
|
|
public enum eMouseMode : byte
|
|
{
|
|
Default = 0,
|
|
pan,
|
|
rfidcut,
|
|
addtext,
|
|
addcustomline,
|
|
addrfidpoint,
|
|
addrfidline,
|
|
}
|
|
|
|
private eMouseMode mousemode = eMouseMode.Default;
|
|
public eMouseMode MouseMode
|
|
{
|
|
get { return mousemode; }
|
|
set
|
|
{
|
|
if (this.mousemode == value) mousemode = eMouseMode.Default;
|
|
else this.mousemode = value;
|
|
switch (this.mousemode)
|
|
{
|
|
case eMouseMode.pan: this.Cursor = Cursors.Hand; break;
|
|
case eMouseMode.addrfidline: this.Cursor = Cursors.Default; break;
|
|
case eMouseMode.addrfidpoint: this.Cursor = Cursors.Default; break;
|
|
case eMouseMode.addtext: this.Cursor = Cursors.Default; break;
|
|
case eMouseMode.addcustomline: this.Cursor = Cursors.Default; break;
|
|
default: this.Cursor = Cursors.Default; break;
|
|
}
|
|
previewStartPoint = null;
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
public void SetIsAddingMagnet(bool value)
|
|
{
|
|
|
|
}
|
|
|
|
public void SetIsAddingPoint(bool value)
|
|
{
|
|
isDrawingCustomLine = false;
|
|
isDrawingLine = false;
|
|
isDrawingRFIDLine = false;
|
|
isAddingPoint = value;
|
|
this.Cursor = value ? Cursors.Cross : Cursors.Default;
|
|
}
|
|
|
|
private Cursor GetScissorsCursor()
|
|
{
|
|
// 가위 커서 아이콘 생성
|
|
using (var bitmap = new Bitmap(32, 32))
|
|
using (var g = Graphics.FromImage(bitmap))
|
|
{
|
|
g.Clear(Color.Transparent);
|
|
|
|
// 가위 모양 그리기
|
|
using (var pen = new Pen(Color.Black, 2))
|
|
{
|
|
// 가위 손잡이
|
|
g.DrawEllipse(pen, 12, 20, 8, 8);
|
|
g.DrawLine(pen, 16, 20, 16, 16);
|
|
|
|
// 가위 날
|
|
g.DrawLine(pen, 16, 16, 8, 8);
|
|
g.DrawLine(pen, 16, 16, 24, 8);
|
|
}
|
|
|
|
return new Cursor(bitmap.GetHicon());
|
|
}
|
|
}
|
|
|
|
public void SetCurrentPath(List<Point> path)
|
|
{
|
|
agv.CurrentPath = path;
|
|
this.Invalidate();
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
//base.OnPaint(e);
|
|
|
|
e.Graphics.TranslateTransform(offset.X, offset.Y);
|
|
e.Graphics.ScaleTransform(zoom, zoom);
|
|
|
|
DrawRFIDLines(e.Graphics);
|
|
DrawRFIDPoints(e.Graphics);
|
|
//DrawCustomLines(e.Graphics);
|
|
DrawMapTexts(e.Graphics);
|
|
|
|
DrawPath(e.Graphics);
|
|
DrawAGV(e.Graphics);
|
|
DrawTargetFlag(e.Graphics); // 목적지 깃발 그리기 추가
|
|
|
|
// 선택된 개체 강조 표시
|
|
if (selectedRFID != null)
|
|
{
|
|
using (Pen pen = new Pen(Color.Magenta, 2))
|
|
{
|
|
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
e.Graphics.DrawEllipse(pen,
|
|
selectedRFID.Location.X - 10,
|
|
selectedRFID.Location.Y - 10,
|
|
20, 20);
|
|
}
|
|
}
|
|
|
|
if (selectedRFIDLine != null)
|
|
{
|
|
using (Pen pen = new Pen(Color.Magenta, 2))
|
|
{
|
|
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
e.Graphics.DrawLine(pen, selectedRFIDLine.StartPoint, selectedRFIDLine.EndPoint);
|
|
}
|
|
}
|
|
|
|
// 미리보기 라인 그리기
|
|
if (previewStartPoint.HasValue)
|
|
{
|
|
using (Pen previewPen = new Pen(Color.FromArgb(180, Color.Yellow), LINE_WIDTH))
|
|
{
|
|
previewPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
e.Graphics.DrawLine(previewPen, previewStartPoint.Value, currentMousePosition);
|
|
}
|
|
}
|
|
|
|
// 그래픽스 변환 초기화
|
|
e.Graphics.ResetTransform();
|
|
|
|
// 툴바 버튼 그리기
|
|
foreach (var item in this.toolbarRects)
|
|
DrawToolbarButton(e.Graphics, item.Bounds, item.Title, item.isHovering);
|
|
}
|
|
|
|
private void DrawRFIDPoints(Graphics g)
|
|
{
|
|
// RFID 포인트 그리기
|
|
foreach (var rfid in rfidPoints)
|
|
{
|
|
var MarkerSize = 5;
|
|
var half = MarkerSize / 2f;
|
|
rfid.Bounds = new RectangleF(rfid.Location.X - half, rfid.Location.Y - half, MarkerSize, MarkerSize);
|
|
|
|
// 종단 RFID는 특별한 색상으로 표시
|
|
Color pointColor;
|
|
if (rfid.IsTerminal)
|
|
{
|
|
pointColor = Color.Orange; // 종단은 주황색
|
|
}
|
|
else if (rfid.IsRotatable)
|
|
{
|
|
pointColor = Color.Yellow; // 회전 가능은 노란색
|
|
}
|
|
else
|
|
{
|
|
pointColor = Color.Green; // 일반은 초록색
|
|
}
|
|
|
|
using (var brush = new SolidBrush(pointColor))
|
|
{
|
|
g.FillEllipse(brush, rfid.Bounds);
|
|
}
|
|
|
|
// 고정방향이 있으면 테두리 색상 표시
|
|
if (rfid.FixedDirection.HasValue)
|
|
{
|
|
Color borderColor = rfid.FixedDirection.Value == Direction.Forward ? Color.DeepSkyBlue : Color.Gold;
|
|
using (var pen = new Pen(borderColor, 2))
|
|
{
|
|
g.DrawEllipse(pen, rfid.Bounds.Expand(5,5));
|
|
}
|
|
}
|
|
|
|
// 종단 RFID는 특별한 테두리 표시
|
|
if (rfid.IsTerminal)
|
|
{
|
|
using (var pen = new Pen(Color.Red, 3))
|
|
{
|
|
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
g.DrawEllipse(pen, rfid.Bounds.Expand(8,8));
|
|
}
|
|
}
|
|
|
|
var str = rfid.RFIDValue.ToString();
|
|
g.DrawString(str, this.Font, Brushes.DarkGray, rfid.Bounds.X, rfid.Bounds.Y+5);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
private void DrawAGV(Graphics g)
|
|
{
|
|
var agvsize = 30;
|
|
var halfsize = (int)(agvsize / 2);
|
|
|
|
// AGV의 현재 위치를 중심으로 하는 원
|
|
var circleRect = new Rectangle(
|
|
agv.CurrentPosition.X - halfsize,
|
|
agv.CurrentPosition.Y - halfsize,
|
|
agvsize, agvsize);
|
|
|
|
// AGV 몸체 회전 각도 계산
|
|
float bodyRotation = 0f;
|
|
if (agv.CurrentPath != null && agv.CurrentPath.Count > 1)
|
|
{
|
|
// 현재 위치에서 다음 목적지 방향 계산
|
|
int currentIdx = agv.CurrentPath.FindIndex(p => p == agv.CurrentPosition);
|
|
if (currentIdx >= 0 && currentIdx < agv.CurrentPath.Count - 1)
|
|
{
|
|
Point nextPoint = agv.CurrentPath[currentIdx + 1];
|
|
float deltaX = nextPoint.X - agv.CurrentPosition.X;
|
|
float deltaY = nextPoint.Y - agv.CurrentPosition.Y;
|
|
bodyRotation = (float)Math.Atan2(deltaY, deltaX) * 180f / (float)Math.PI;
|
|
}
|
|
}
|
|
|
|
// 그래픽스 상태 저장
|
|
var originalTransform = g.Transform;
|
|
|
|
// AGV 위치로 이동하고 회전
|
|
g.TranslateTransform(agv.CurrentPosition.X, agv.CurrentPosition.Y);
|
|
g.RotateTransform(bodyRotation);
|
|
|
|
// 원 그리기 (회전된 상태)
|
|
Color bgcolor = agv.BatteryLevel > 80 ? Color.Lime : (agv.BatteryLevel > 60 ? Color.Gold : Color.Tomato);
|
|
using (var circleBrush = new SolidBrush(Color.FromArgb(150, bgcolor)))
|
|
g.FillEllipse(circleBrush, -halfsize, -halfsize, agvsize, agvsize);
|
|
using (var circlePen = new Pen(Color.Black, 2))
|
|
g.DrawEllipse(circlePen, -halfsize, -halfsize, agvsize, agvsize);
|
|
|
|
// 리프트 그리기 (회전된 상태, 항상 전진 방향쪽)
|
|
var liftWidth = circleRect.Width;
|
|
var liftHeight = (int)(circleRect.Height * 0.4);
|
|
var liftOffset = halfsize + 1;
|
|
|
|
var liftRect = new Rectangle(
|
|
-liftWidth / 2,
|
|
-halfsize - liftOffset,
|
|
liftWidth, liftHeight);
|
|
|
|
using (var liftBrush = new SolidBrush(Color.FromArgb(200, Color.DarkGray)))
|
|
g.FillRectangle(liftBrush, liftRect);
|
|
using (var liftPen = new Pen(Color.Black, 1))
|
|
g.DrawRectangle(liftPen, liftRect);
|
|
|
|
// 리프트 연결선 그리기
|
|
using (var connectionPen = new Pen(Color.Black, 2))
|
|
{
|
|
g.DrawLine(connectionPen, 0, -halfsize, 0, -halfsize - liftOffset);
|
|
}
|
|
|
|
// 그래픽스 상태 복원
|
|
g.Transform = originalTransform;
|
|
|
|
// 삼각형 화살표 그리기 (현재 이동 방향, 회전하지 않음)
|
|
Point[] trianglePoints = new Point[3];
|
|
var arrowSize = halfsize - 5;
|
|
|
|
// AGV의 현재 이동 방향에 따라 삼각형 포인트 계산
|
|
switch (agv.CurrentDirection)
|
|
{
|
|
case Direction.Forward:
|
|
trianglePoints[0] = new Point(agv.CurrentPosition.X, agv.CurrentPosition.Y - arrowSize);
|
|
trianglePoints[1] = new Point(agv.CurrentPosition.X - arrowSize, agv.CurrentPosition.Y + arrowSize);
|
|
trianglePoints[2] = new Point(agv.CurrentPosition.X + arrowSize, agv.CurrentPosition.Y + arrowSize);
|
|
break;
|
|
case Direction.Backward:
|
|
trianglePoints[0] = new Point(agv.CurrentPosition.X, agv.CurrentPosition.Y + arrowSize);
|
|
trianglePoints[1] = new Point(agv.CurrentPosition.X - arrowSize, agv.CurrentPosition.Y - arrowSize);
|
|
trianglePoints[2] = new Point(agv.CurrentPosition.X + arrowSize, agv.CurrentPosition.Y - arrowSize);
|
|
break;
|
|
}
|
|
|
|
using (var arrowBrush = new SolidBrush(Color.FromArgb(200, Color.White)))
|
|
g.FillPolygon(arrowBrush, trianglePoints);
|
|
using (var arrowPen = new Pen(Color.Black, 2))
|
|
g.DrawPolygon(arrowPen, trianglePoints);
|
|
|
|
//g.DrawImage(Properties.Resources.ico_navi_40, circleRect);
|
|
}
|
|
|
|
private void DrawCustomLines(Graphics g)
|
|
{
|
|
if (customLines == null) return;
|
|
foreach (var line in customLines)
|
|
{
|
|
using (Pen linePen = new Pen(line.LineColor, line.LineWidth))
|
|
{
|
|
g.DrawLine(linePen, line.StartPoint, line.EndPoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawMapTexts(Graphics g)
|
|
{
|
|
if (mapTexts == null) return;
|
|
foreach (var text in mapTexts)
|
|
{
|
|
var textSize = g.MeasureString(text.Text, text.Font);
|
|
if (text.Dirty)
|
|
{
|
|
text.Bounds = new RectangleF(
|
|
text.Location.X,
|
|
text.Location.Y,
|
|
textSize.Width,
|
|
textSize.Height
|
|
);
|
|
text.Dirty = false;
|
|
}
|
|
|
|
if (text.BackgroundColor != Color.Transparent)
|
|
{
|
|
using (var brush = new SolidBrush(text.BackgroundColor))
|
|
{
|
|
g.FillRectangle(brush, text.Bounds);
|
|
}
|
|
}
|
|
|
|
using (var brush = new SolidBrush(text.TextColor))
|
|
{
|
|
g.DrawString(text.Text, text.Font, brush, text.Location);
|
|
}
|
|
|
|
if (text == selectedText)
|
|
{
|
|
using (Pen pen = new Pen(Color.Blue, 1))
|
|
{
|
|
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
g.DrawRectangle(pen, text.Bounds.X, text.Bounds.Y, text.Bounds.Width, text.Bounds.Height);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawRFIDLines(Graphics g)
|
|
{
|
|
var idx = 0;
|
|
using (Font f = new Font("arial", 4))
|
|
{
|
|
foreach (var item in rfidLines)
|
|
{
|
|
var sp = item.StartPoint;
|
|
var ep = item.EndPoint;
|
|
using (var p = new Pen(Color.FromArgb(50, Color.White), 10))
|
|
{
|
|
g.DrawLine(p, sp, ep);
|
|
var x = sp.X;
|
|
var y = sp.Y;
|
|
g.DrawString($"{idx}", f, Brushes.Gold, x, y);
|
|
|
|
x = ep.X;
|
|
y = ep.Y;
|
|
g.DrawString($"{idx}", f, Brushes.Pink, x, y);
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
foreach (var connection in rfidConnections)
|
|
{
|
|
var startPoint = rfidPoints.FirstOrDefault(p => p.RFIDValue == connection.StartRFID)?.Location ?? Point.Empty;
|
|
var endPoint = rfidPoints.FirstOrDefault(p => p.RFIDValue == connection.EndRFID)?.Location ?? Point.Empty;
|
|
|
|
if (startPoint.IsEmpty || endPoint.IsEmpty) continue;
|
|
|
|
using (Pen linePen = new Pen(Color.FromArgb(50, Color.Wheat), 2))
|
|
{
|
|
if (connection.IsBidirectional)
|
|
{
|
|
// 단방향 화살표 그리기
|
|
var arrowSize = 10;
|
|
var angle = Math.Atan2(endPoint.Y - startPoint.Y, endPoint.X - startPoint.X);
|
|
var arrowPoint = new PointF(
|
|
endPoint.X - (float)(arrowSize * Math.Cos(angle)),
|
|
endPoint.Y - (float)(arrowSize * Math.Sin(angle))
|
|
);
|
|
g.DrawLine(linePen, startPoint, arrowPoint);
|
|
|
|
// 화살표 머리 그리기
|
|
var arrowAngle = Math.PI / 6;
|
|
var arrowLength = 15;
|
|
var arrow1 = new PointF(
|
|
arrowPoint.X - (float)(arrowLength * Math.Cos(angle - arrowAngle)),
|
|
arrowPoint.Y - (float)(arrowLength * Math.Sin(angle - arrowAngle))
|
|
);
|
|
var arrow2 = new PointF(
|
|
arrowPoint.X - (float)(arrowLength * Math.Cos(angle + arrowAngle)),
|
|
arrowPoint.Y - (float)(arrowLength * Math.Sin(angle + arrowAngle))
|
|
);
|
|
g.DrawLine(linePen, arrowPoint, arrow1);
|
|
g.DrawLine(linePen, arrowPoint, arrow2);
|
|
}
|
|
else
|
|
{
|
|
g.DrawLine(linePen, startPoint, endPoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 미리보기 라인 그리기
|
|
if (previewStartPoint.HasValue && isDrawingRFIDLine)
|
|
{
|
|
using (Pen previewPen = new Pen(Color.FromArgb(180, Color.Green), 2))
|
|
{
|
|
previewPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
var currentMapPosition = ScreenToMap(currentMousePosition);
|
|
g.DrawLine(previewPen, previewStartPoint.Value, currentMapPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawPath(Graphics g)
|
|
{
|
|
if (agv.CurrentPath == null || agv.CurrentPath.Count < 2)
|
|
return;
|
|
|
|
Color pathColor = Color.FromArgb(100, Color.Lime);
|
|
int pathWidth = 10;
|
|
|
|
using (Pen pathPen = new Pen(pathColor, pathWidth))
|
|
{
|
|
pathPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
for (int i = 0; i < agv.CurrentPath.Count - 1; i++)
|
|
{
|
|
g.DrawLine(pathPen, agv.CurrentPath[i], agv.CurrentPath[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<RFIDPoint> GetRFIDPoints()
|
|
{
|
|
return rfidPoints;
|
|
}
|
|
|
|
public List<RFIDLine> GetRFIDLines()
|
|
{
|
|
return rfidLines;
|
|
}
|
|
|
|
public void SetRFIDLines(List<RFIDLine> lines)
|
|
{
|
|
rfidLines = lines;
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void AddRFIDLine(Point startPoint, Point endPoint)
|
|
{
|
|
// 시작점과 끝점 사이의 모든 RFID 포인트 찾기
|
|
var allPoints = new List<(RFIDPoint Point, float Distance)>();
|
|
var lineVector = new Point(endPoint.X - startPoint.X, endPoint.Y - startPoint.Y);
|
|
var lineLength = (float)Math.Sqrt(lineVector.X * lineVector.X + lineVector.Y * lineVector.Y);
|
|
|
|
foreach (var rfid in rfidPoints)
|
|
{
|
|
if (rfid.Location == startPoint || rfid.Location == endPoint)
|
|
continue;
|
|
|
|
// RFID 포인트가 선 위에 있는지 확인
|
|
var pointVector = new Point(rfid.Location.X - startPoint.X, rfid.Location.Y - startPoint.Y);
|
|
var dotProduct = pointVector.X * lineVector.X + pointVector.Y * lineVector.Y;
|
|
var projectionLength = dotProduct / (lineLength * lineLength);
|
|
|
|
if (projectionLength >= 0 && projectionLength <= 1)
|
|
{
|
|
// 선과 RFID 포인트 사이의 거리 계산
|
|
var distance = GetDistanceToLine(rfid.Location, startPoint, endPoint);
|
|
if (distance <= SNAP_DISTANCE)
|
|
{
|
|
allPoints.Add((rfid, projectionLength));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 시작점에서 끝점 방향으로 정렬
|
|
allPoints.Sort((a, b) => a.Distance.CompareTo(b.Distance));
|
|
|
|
// 모든 연결 정보를 포함하는 RFID 라인 생성
|
|
var line = new RFIDLine
|
|
{
|
|
StartPoint = startPoint,
|
|
EndPoint = endPoint,
|
|
};
|
|
|
|
|
|
rfidLines.Add(line);
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void ClearMap()
|
|
{
|
|
rfidPoints.Clear();
|
|
mapTexts.Clear();
|
|
customLines.Clear();
|
|
rfidLines.Clear();
|
|
|
|
// 선택 상태도 초기화
|
|
selectedText = null;
|
|
selectedLine = null;
|
|
selectedRFID = null;
|
|
selectedRFIDLine = null;
|
|
draggingPoint = null;
|
|
|
|
// 미리보기 상태도 초기화
|
|
previewStartPoint = null;
|
|
|
|
// 화면 갱신
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void AddRFIDPoint(Point mapLocation, uint rfidValue)
|
|
{
|
|
var rfidPoint = new RFIDPoint
|
|
{
|
|
Location = mapLocation,
|
|
RFIDValue = rfidValue
|
|
};
|
|
|
|
rfidPoints.Add(rfidPoint);
|
|
this.Invalidate();
|
|
}
|
|
|
|
public void SaveToFile(string filename)
|
|
{
|
|
var lines = new List<string>();
|
|
|
|
// RFID 포인트 저장
|
|
lines.Add("[RFID_POINTS]");
|
|
foreach (var point in rfidPoints)
|
|
{
|
|
lines.Add($"{point.Location.X},{point.Location.Y},{point.RFIDValue},{point.IsRotatable},{point.FixedDirection},{point.IsTerminal}");
|
|
}
|
|
|
|
// RFID 라인 저장
|
|
lines.Add("[RFID_LINES]");
|
|
foreach (var connection in rfidConnections)
|
|
{
|
|
var startPoint = rfidPoints.First(p => p.RFIDValue == connection.StartRFID).Location;
|
|
var endPoint = rfidPoints.First(p => p.RFIDValue == connection.EndRFID).Location;
|
|
lines.Add($"{startPoint.X},{startPoint.Y},{endPoint.X},{endPoint.Y}," +
|
|
$"{connection.StartRFID},{connection.EndRFID},{connection.IsBidirectional},{connection.Distance}");
|
|
}
|
|
|
|
// 텍스트 저장
|
|
lines.Add("[MAP_TEXTS]");
|
|
foreach (var text in mapTexts)
|
|
{
|
|
lines.Add($"{text.Location.X},{text.Location.Y},{text.TextColor.ToArgb()},{text.BackgroundColor.ToArgb()},{text.Font.Name},{text.Font.Size},{text.Text}");
|
|
}
|
|
|
|
// 커스텀 라인 저장
|
|
lines.Add("[CUSTOM_LINES]");
|
|
foreach (var line in customLines)
|
|
{
|
|
lines.Add($"{line.StartPoint.X},{line.StartPoint.Y},{line.EndPoint.X},{line.EndPoint.Y},{line.LineColor.ToArgb()},{line.LineWidth}");
|
|
}
|
|
|
|
File.WriteAllLines(filename, lines);
|
|
this.filename = filename;
|
|
}
|
|
|
|
public bool LoadFromFile(string filename, out string message)
|
|
{
|
|
this.filename = filename;
|
|
message = string.Empty;
|
|
ClearMap();
|
|
|
|
var lines = File.ReadAllLines(filename);
|
|
var section = "";
|
|
|
|
var sb = new System.Text.StringBuilder();
|
|
|
|
foreach (var line in lines)
|
|
{
|
|
if (line.StartsWith("[") && line.EndsWith("]"))
|
|
{
|
|
section = line;
|
|
continue;
|
|
}
|
|
|
|
switch (section)
|
|
{
|
|
case "[RFID_POINTS]":
|
|
var rfidParts = line.Split(',');
|
|
if (rfidParts.Length >= 3)
|
|
{
|
|
var validX = int.TryParse(rfidParts[0], out int valX);
|
|
var validY = int.TryParse(rfidParts[1], out int valY);
|
|
var validN = uint.TryParse(rfidParts[2], out uint valRfid);
|
|
|
|
if (validX && validY && validN)
|
|
{
|
|
if (rfidPoints.Where(t => t.RFIDValue == valRfid).Any())
|
|
{
|
|
//이미존재한다
|
|
var newvalue =
|
|
sb.AppendLine($"rfid중복{valRfid}");
|
|
}
|
|
|
|
var rfidPoint = new RFIDPoint
|
|
{
|
|
Location = new Point(valX, valY),
|
|
RFIDValue = valRfid
|
|
};
|
|
|
|
// 추가 속성 로드 (기본값 처리)
|
|
if (rfidParts.Length >= 4)
|
|
{
|
|
bool isRotatable;
|
|
bool.TryParse(rfidParts[3], out isRotatable);
|
|
rfidPoint.IsRotatable = isRotatable;
|
|
}
|
|
if (rfidParts.Length >= 5 && !string.IsNullOrEmpty(rfidParts[4]))
|
|
rfidPoint.FixedDirection = (Direction)Enum.Parse(typeof(Direction), rfidParts[4]);
|
|
if (rfidParts.Length >= 6)
|
|
{
|
|
bool isTerminal;
|
|
bool.TryParse(rfidParts[5], out isTerminal);
|
|
rfidPoint.IsTerminal = isTerminal;
|
|
}
|
|
|
|
rfidPoints.Add(rfidPoint);
|
|
}
|
|
else sb.AppendLine($"[{section}] {line}");
|
|
}
|
|
break;
|
|
|
|
case "[RFID_LINES]":
|
|
var rfidLineParts = line.Split(',');
|
|
if (rfidLineParts.Length >= 8)
|
|
{
|
|
AddRFIDLine(
|
|
new Point(int.Parse(rfidLineParts[0]), int.Parse(rfidLineParts[1])),
|
|
new Point(int.Parse(rfidLineParts[2]), int.Parse(rfidLineParts[3]))
|
|
);
|
|
}
|
|
break;
|
|
|
|
case "[MAP_TEXTS]":
|
|
var textParts = line.Split(',');
|
|
if (textParts.Length >= 7)
|
|
{
|
|
var text = new MapText
|
|
{
|
|
Location = new Point(int.Parse(textParts[0]), int.Parse(textParts[1])),
|
|
TextColor = Color.FromArgb(int.Parse(textParts[2])),
|
|
BackgroundColor = Color.FromArgb(int.Parse(textParts[3])),
|
|
Font = new Font(textParts[4], float.Parse(textParts[5])),
|
|
Text = string.Join(",", textParts.Skip(6)) // 텍스트에 쉼표가 포함될 수 있으므로
|
|
};
|
|
mapTexts.Add(text);
|
|
}
|
|
break;
|
|
|
|
case "[CUSTOM_LINES]":
|
|
var customLineParts = line.Split(',');
|
|
if (customLineParts.Length >= 6)
|
|
{
|
|
var customLine = new CustomLine
|
|
{
|
|
StartPoint = new Point(int.Parse(customLineParts[0]), int.Parse(customLineParts[1])),
|
|
EndPoint = new Point(int.Parse(customLineParts[2]), int.Parse(customLineParts[3])),
|
|
LineColor = Color.FromArgb(int.Parse(customLineParts[4])),
|
|
LineWidth = int.Parse(customLineParts[5])
|
|
};
|
|
customLines.Add(customLine);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// RFID 연결 정보 처리
|
|
ProcessRFIDConnections();
|
|
|
|
this.Invalidate();
|
|
|
|
message = sb.ToString();
|
|
return true;
|
|
}
|
|
|
|
private void ProcessRFIDConnections()
|
|
{
|
|
rfidConnections.Clear();
|
|
var connectionSet = new HashSet<string>();
|
|
|
|
foreach (var line in rfidLines)
|
|
{
|
|
var start = line.StartPoint;
|
|
var end = line.EndPoint;
|
|
|
|
// 1. 선 위의 모든 RFID 포인트(시작, 끝 포함)를 projectionRatio로 정렬
|
|
var pointsOnThisLine = rfidPoints
|
|
.Where(p => IsPointOnLine(p.Location, start, end, 10f)) // 오차 허용치 넉넉히
|
|
.Select(p => new
|
|
{
|
|
RFID = p.RFIDValue,
|
|
Ratio = GetProjectionRatio(p.Location, start, end)
|
|
})
|
|
.ToList();
|
|
|
|
//// 2. 시작/끝 RFID가 목록에 없으면 강제로 추가
|
|
//if (!pointsOnThisLine.Any(p => p.RFID == line.StartRFID))
|
|
// pointsOnThisLine.Add(new { RFID = line.StartRFID, Ratio = 0f });
|
|
//if (!pointsOnThisLine.Any(p => p.RFID == line.EndRFID))
|
|
// pointsOnThisLine.Add(new { RFID = line.EndRFID, Ratio = 1f });
|
|
|
|
// 3. 정렬
|
|
pointsOnThisLine = pointsOnThisLine.OrderBy(p => p.Ratio).ToList();
|
|
|
|
// 4. 순서대로 1:1 연결
|
|
for (int i = 0; i < pointsOnThisLine.Count - 1; i++)
|
|
{
|
|
var from = pointsOnThisLine[i].RFID;
|
|
var to = pointsOnThisLine[i + 1].RFID;
|
|
var key = $"{Math.Min(from, to)}_{Math.Max(from, to)}";
|
|
if (connectionSet.Contains(key)) continue;
|
|
|
|
var fromPt = rfidPoints.FirstOrDefault(p => p.RFIDValue == from)?.Location ?? line.StartPoint;
|
|
var toPt = rfidPoints.FirstOrDefault(p => p.RFIDValue == to)?.Location ?? line.EndPoint;
|
|
|
|
rfidConnections.Add(new RFIDConnection
|
|
{
|
|
StartRFID = from,
|
|
EndRFID = to,
|
|
Distance = GetDistance(fromPt, toPt)
|
|
});
|
|
connectionSet.Add(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
// tolerance 인자를 받는 IsPointOnLine
|
|
private bool IsPointOnLine(Point point, Point lineStart, Point lineEnd, float tolerance = 10.0f)
|
|
{
|
|
var distance = GetDistanceToLine(point, lineStart, lineEnd);
|
|
if (distance > tolerance) return false;
|
|
|
|
var projectionRatio = Math.Round(GetProjectionRatio(point, lineStart, lineEnd), 2);
|
|
return projectionRatio >= 0 && projectionRatio <= 1.0;
|
|
}
|
|
|
|
private void DeleteNearbyRFIDLine(Point clickPoint)
|
|
{
|
|
const float DELETE_DISTANCE = 10.0f; // 클릭 지점으로부터의 허용 거리
|
|
RFIDLine lineToDelete = null;
|
|
float minDistance = float.MaxValue;
|
|
|
|
foreach (var line in rfidLines)
|
|
{
|
|
float distance = GetDistanceToLine(clickPoint, line.StartPoint, line.EndPoint);
|
|
if (distance < DELETE_DISTANCE && distance < minDistance)
|
|
{
|
|
minDistance = distance;
|
|
lineToDelete = line;
|
|
}
|
|
}
|
|
|
|
if (lineToDelete != null)
|
|
{
|
|
rfidLines.Remove(lineToDelete);
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
private void ZoomIn()
|
|
{
|
|
zoom *= 1.2f;
|
|
zoom = Math.Min(10.0f, zoom);
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void ZoomOut()
|
|
{
|
|
zoom /= 1.2f;
|
|
zoom = Math.Max(0.1f, zoom);
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void ResetZoom()
|
|
{
|
|
zoom = 1.0f;
|
|
offset = PointF.Empty;
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void DrawToolbarButton(Graphics g, Rectangle rect, string text, bool isHovering)
|
|
{
|
|
var color1 = isHovering ? Color.LightSkyBlue : Color.White;
|
|
var color2 = isHovering ? Color.DeepSkyBlue : Color.WhiteSmoke;
|
|
using (var brush = new LinearGradientBrush(rect, color1, color2, LinearGradientMode.Vertical))
|
|
using (var pen = new Pen(Color.Gray))
|
|
using (var font = new Font("Tahoma", 9, FontStyle.Bold))
|
|
using (var format = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center })
|
|
{
|
|
g.FillRectangle(Brushes.LightGray, rect.X + 2, rect.Y + 2, rect.Width, rect.Height);
|
|
g.FillRectangle(brush, rect);
|
|
g.DrawRectangle(pen, rect);
|
|
g.DrawString(text, font, Brushes.Black, rect, format);
|
|
}
|
|
}
|
|
|
|
private void DrawTargetFlag(Graphics g)
|
|
{
|
|
if (agv.TargetPosition == Point.Empty) return;
|
|
|
|
// 바닥에 흰색 원 그리기
|
|
using (var baseBrush = new SolidBrush(Color.Red))
|
|
using (var basePen = new Pen(Color.Black, 1))
|
|
{
|
|
var baseSize = 8;
|
|
g.FillEllipse(baseBrush,
|
|
agv.TargetPosition.X - baseSize / 2,
|
|
agv.TargetPosition.Y - baseSize / 2,
|
|
baseSize, baseSize);
|
|
g.DrawEllipse(basePen,
|
|
agv.TargetPosition.X - baseSize / 2,
|
|
agv.TargetPosition.Y - baseSize / 2,
|
|
baseSize, baseSize);
|
|
}
|
|
|
|
// 깃대 그리기 (길이를 2/3로 줄임)
|
|
using (var polePen = new Pen(Color.Brown, 3))
|
|
{
|
|
var poleLength = 27; // 40 * 2/3 ≈ 27
|
|
g.DrawLine(polePen,
|
|
agv.TargetPosition.X,
|
|
agv.TargetPosition.Y,
|
|
agv.TargetPosition.X,
|
|
agv.TargetPosition.Y - poleLength);
|
|
}
|
|
|
|
// 깃발 그리기
|
|
Point[] flagPoints = new Point[3];
|
|
flagPoints[0] = new Point(agv.TargetPosition.X, agv.TargetPosition.Y - 27); // 깃대 길이에 맞춤
|
|
flagPoints[1] = new Point(agv.TargetPosition.X + 20, agv.TargetPosition.Y - 22);
|
|
flagPoints[2] = new Point(agv.TargetPosition.X, agv.TargetPosition.Y - 17);
|
|
|
|
using (var flagBrush = new SolidBrush(Color.Red))
|
|
using (var flagPen = new Pen(Color.DarkRed, 1))
|
|
{
|
|
g.FillPolygon(flagBrush, flagPoints);
|
|
g.DrawPolygon(flagPen, flagPoints);
|
|
}
|
|
}
|
|
|
|
// 회전 가능 여부 토글 함수
|
|
public void ToggleRotatable(uint rfidValue)
|
|
{
|
|
var rfidPoint = FindRFIDPoint(rfidValue);
|
|
if (rfidPoint != null)
|
|
{
|
|
rfidPoint.IsRotatable = !rfidPoint.IsRotatable;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
// 회전 가능 여부 확인 함수
|
|
public bool IsPointRotatable(uint rfidValue)
|
|
{
|
|
var rfidPoint = FindRFIDPoint(rfidValue);
|
|
return rfidPoint?.IsRotatable ?? false;
|
|
}
|
|
|
|
// 경로 계산 시 회전 가능 여부를 고려하여 방향 결정
|
|
private Direction DetermineDirection(Point current, Point next, Point target)
|
|
{
|
|
// 현재 위치가 회전 가능한 구간인 경우
|
|
var currentRFID = rfidPoints.FirstOrDefault(p => p.Location == current);
|
|
if (currentRFID?.IsRotatable ?? false)
|
|
{
|
|
// 목적지 방향으로 직접 방향 결정
|
|
if (target.X > current.X) return Direction.Forward;
|
|
if (target.X < current.X) return Direction.Backward;
|
|
if (target.Y > current.Y) return Direction.Forward;
|
|
if (target.Y < current.Y) return Direction.Backward;
|
|
}
|
|
|
|
// 회전 불가능한 구간인 경우 현재 진행 방향 유지
|
|
return agv.CurrentDirection;
|
|
}
|
|
|
|
// AGV 행동 예측 함수
|
|
public AGVActionPrediction PredictNextAction()
|
|
{
|
|
// 1. 위치를 모를 때 (CurrentRFID가 0 또는 미설정)
|
|
if (agv.CurrentRFID == 0)
|
|
{
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = Direction.Backward,
|
|
NextRFID = null,
|
|
Reason = "AGV 위치 미확정(처음 기동)",
|
|
ReasonCode = AGVActionReasonCode.NoPosition,
|
|
MoveState = AGVMoveState.Run
|
|
};
|
|
}
|
|
|
|
// 2. 경로가 없거나 현재 위치가 경로에 없음
|
|
if (agv.CurrentPath == null || agv.CurrentPath.Count < 2 || agv.CurrentPosition == Point.Empty)
|
|
{
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = agv.CurrentDirection,
|
|
NextRFID = null,
|
|
Reason = "경로 없음 또는 현재 위치 미확정",
|
|
ReasonCode = AGVActionReasonCode.NoPath,
|
|
MoveState = AGVMoveState.Stop
|
|
};
|
|
}
|
|
|
|
// 3. 경로상에서 다음 RFID 예측
|
|
int idx = agv.CurrentPath.FindIndex(p => p == agv.CurrentPosition);
|
|
if (idx < 0)
|
|
{
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = agv.CurrentDirection,
|
|
NextRFID = null,
|
|
Reason = "현재 위치가 경로에 없음",
|
|
ReasonCode = AGVActionReasonCode.NotOnPath,
|
|
MoveState = AGVMoveState.Stop
|
|
};
|
|
}
|
|
|
|
// 4. 목적지 도달 전, 방향 미리 판단 및 회전 위치 예측
|
|
// 목적지 RFID 정보
|
|
var destPoint = agv.CurrentPath.Last();
|
|
var destRFID = rfidPoints.FirstOrDefault(r => r.Location == destPoint);
|
|
if (destRFID != null && destRFID.FixedDirection.HasValue)
|
|
{
|
|
// 목적지에 도달할 때의 방향 예측
|
|
if (agv.CurrentPath.Count >= 2)
|
|
{
|
|
// 목적지 바로 전 위치에서 목적지로 이동할 때의 방향
|
|
var beforeDest = agv.CurrentPath[agv.CurrentPath.Count - 2];
|
|
float arriveDeltaX = destPoint.X - beforeDest.X;
|
|
float arriveDeltaY = destPoint.Y - beforeDest.Y;
|
|
Direction arriveDir = (Math.Abs(arriveDeltaX) > Math.Abs(arriveDeltaY)) ?
|
|
(arriveDeltaX > 0 ? Direction.Forward : Direction.Backward) :
|
|
(arriveDeltaY > 0 ? Direction.Forward : Direction.Backward);
|
|
if (arriveDir != destRFID.FixedDirection.Value)
|
|
{
|
|
// 목적지 도달 전, 마지막 회전 가능한 RFID를 찾음
|
|
int lastRotatableIdx = -1;
|
|
for (int i = 0; i < agv.CurrentPath.Count - 1; i++)
|
|
{
|
|
var rfid = rfidPoints.FirstOrDefault(r => r.Location == agv.CurrentPath[i]);
|
|
if (rfid != null && rfid.IsRotatable)
|
|
lastRotatableIdx = i;
|
|
}
|
|
if (lastRotatableIdx >= 0)
|
|
{
|
|
// 회전 가능한 위치에 도달하면 NeedTurn 반환 (STOP)
|
|
if (idx == lastRotatableIdx)
|
|
{
|
|
var rfid = rfidPoints.FirstOrDefault(r => r.Location == agv.CurrentPath[lastRotatableIdx]);
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = agv.CurrentDirection,
|
|
NextRFID = rfid?.RFIDValue,
|
|
Reason = "목적지 진입방향 맞추기 위해 회전 필요",
|
|
ReasonCode = AGVActionReasonCode.NeedTurn,
|
|
MoveState = AGVMoveState.Stop
|
|
};
|
|
}
|
|
else if (idx < lastRotatableIdx)
|
|
{
|
|
// 회전 가능한 위치까지 이동 안내 (RUN)
|
|
var rfid = rfidPoints.FirstOrDefault(r => r.Location == agv.CurrentPath[lastRotatableIdx]);
|
|
float moveDeltaX = agv.CurrentPath[lastRotatableIdx].X - agv.CurrentPosition.X;
|
|
float moveDeltaY = agv.CurrentPath[lastRotatableIdx].Y - agv.CurrentPosition.Y;
|
|
Direction moveDir = (Math.Abs(moveDeltaX) > Math.Abs(moveDeltaY)) ?
|
|
(moveDeltaX > 0 ? Direction.Forward : Direction.Backward) :
|
|
(moveDeltaY > 0 ? Direction.Forward : Direction.Backward);
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = moveDir,
|
|
NextRFID = rfid?.RFIDValue,
|
|
Reason = "회전 가능한 위치로 이동 중",
|
|
ReasonCode = AGVActionReasonCode.Normal,
|
|
MoveState = AGVMoveState.Run
|
|
};
|
|
}
|
|
}
|
|
// 회전 가능한 위치가 없음 (STOP)
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = agv.CurrentDirection,
|
|
NextRFID = null,
|
|
Reason = "경로상에 회전 가능한 위치가 없음",
|
|
ReasonCode = AGVActionReasonCode.NoTurnPoint,
|
|
MoveState = AGVMoveState.Stop
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// 5. 목적지 도달 시(방향이 맞는 경우) (STOP)
|
|
if (idx == agv.CurrentPath.Count - 1)
|
|
{
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = agv.CurrentDirection,
|
|
NextRFID = null,
|
|
Reason = "경로의 마지막 지점(목적지 도달)",
|
|
ReasonCode = AGVActionReasonCode.Arrived,
|
|
MoveState = AGVMoveState.Stop
|
|
};
|
|
}
|
|
|
|
// 6. 일반 경로 주행 (RUN)
|
|
Point nextPoint = agv.CurrentPath[idx + 1];
|
|
var nextRFID = rfidPoints.FirstOrDefault(r => r.Location == nextPoint)?.RFIDValue;
|
|
|
|
// X, Y 좌표 모두 고려한 방향 판단
|
|
float deltaX = nextPoint.X - agv.CurrentPosition.X;
|
|
float deltaY = nextPoint.Y - agv.CurrentPosition.Y;
|
|
Direction nextDir = (Math.Abs(deltaX) > Math.Abs(deltaY)) ?
|
|
(deltaX > 0 ? Direction.Forward : Direction.Backward) :
|
|
(deltaY > 0 ? Direction.Forward : Direction.Backward);
|
|
|
|
return new AGVActionPrediction
|
|
{
|
|
Direction = nextDir,
|
|
NextRFID = nextRFID,
|
|
Reason = null,
|
|
ReasonCode = AGVActionReasonCode.Normal,
|
|
MoveState = AGVMoveState.Run
|
|
};
|
|
}
|
|
#endregion
|
|
|
|
#region 좌표 변환 및 계산
|
|
public float GetDistance(Point p1, Point p2)
|
|
{
|
|
float dx = p1.X - p2.X;
|
|
float dy = p1.Y - p2.Y;
|
|
return (float)Math.Sqrt(dx * dx + dy * dy); // double을 float로 명시적 캐스팅
|
|
}
|
|
|
|
// 화면 좌표를 실제 맵 좌표로 변환
|
|
public Point ScreenToMap(Point screenPoint)
|
|
{
|
|
int adjustedX = screenPoint.X;
|
|
return new Point(
|
|
(int)((adjustedX - offset.X) / zoom),
|
|
(int)((screenPoint.Y - offset.Y) / zoom)
|
|
);
|
|
}
|
|
|
|
|
|
private float GetProjectionRatio(Point point, Point lineStart, Point lineEnd)
|
|
{
|
|
float lineLength = GetDistance(lineStart, lineEnd);
|
|
if (lineLength == 0) return 0;
|
|
|
|
return ((point.X - lineStart.X) * (lineEnd.X - lineStart.X) +
|
|
(point.Y - lineStart.Y) * (lineEnd.Y - lineStart.Y)) / (lineLength * lineLength);
|
|
}
|
|
|
|
|
|
private float GetDistanceToLine(Point point, Point lineStart, Point lineEnd)
|
|
{
|
|
float lineLength = GetDistance(lineStart, lineEnd);
|
|
if (lineLength == 0) return GetDistance(point, lineStart);
|
|
|
|
float t = ((point.X - lineStart.X) * (lineEnd.X - lineStart.X) +
|
|
(point.Y - lineStart.Y) * (lineEnd.Y - lineStart.Y)) / (lineLength * lineLength);
|
|
|
|
t = Math.Max(0, Math.Min(1, t));
|
|
|
|
float projectionX = lineStart.X + t * (lineEnd.X - lineStart.X);
|
|
float projectionY = lineStart.Y + t * (lineEnd.Y - lineStart.Y);
|
|
|
|
return GetDistance(point, new Point((int)projectionX, (int)projectionY));
|
|
}
|
|
#endregion
|
|
}
|
|
}
|