using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.ComponentModel.DataAnnotations;
|
using System.ComponentModel.Design;
|
using System.Data;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using Model.ModelDto.BllSoDto;
|
using Model.ModelDto.SysDto;
|
using Serilog;
|
using SqlSugar;
|
using WMS.Entity.BllAsnEntity;
|
using WMS.Entity.BllCheckEntity;
|
using WMS.Entity.BllQualityEntity;
|
using WMS.Entity.BllSoEntity;
|
using WMS.Entity.Context;
|
using WMS.Entity.LogEntity;
|
using WMS.Entity.SysEntity;
|
|
|
namespace WMS.DAL
|
{
|
public class Common
|
{
|
//public static readonly DataContext Db = new DataContext();
|
|
|
/// <summary>
|
/// 获取深度为1的储位号（根据深度为2的储位号）
|
/// </summary>
|
/// <param name="houseNo">仓库号</param>
|
/// <param name="locateNo">储位号</param>
|
/// <returns></returns>
|
public SysStorageLocat GetLocateNoDepth1(string houseNo, string locateNo)
|
{
|
try
|
{
|
var Db = DataContext.Db;
|
//获取储位信息
|
//var sql = $@"select * from SysStorageLocat where WareHouseNo = '{houseNo}' and LocatNo = '{locateNo}'; ";
|
var locate = Db.Queryable<SysStorageLocat>().Where(s => s.WareHouseNo == houseNo && s.LocatNo == locateNo).First();
|
if (locate == null)
|
{
|
throw new Exception($"未查询到仓库号为{houseNo}、储位号为{locateNo}的信息");
|
}
|
//获取深度为2的储位信息
|
//var sql2 = $@"select * from SysStorageLocat where WareHouseNo = '{houseNo}' and row = {locate.Row} and [Column] = {locate.Column} and Layer = {locate.Layer} and Depth = '01'; ";
|
//var data = Db.Ado.SqlQuery<SysStorageLocat>(sql2).First();
|
var data = Db.Queryable<SysStorageLocat>().Where(s => s.WareHouseNo == houseNo && s.Row == locate.Row && s.Column == locate.Column && s.Layer == locate.Layer && s.Depth == "01").First();
|
if (data == null)
|
{
|
throw new Exception($"未查询到仓库号为{houseNo}、储位号为{locateNo}的里面储位信息");
|
}
|
|
return data;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
/// <summary>
|
/// 获取深度为2的储位号（根据深度为1的储位号）
|
/// </summary>
|
/// <param name="houseNo">仓库号</param>
|
/// <param name="locateNo">储位号</param>
|
/// <returns></returns>
|
public SysStorageLocat GetLocateNoDepth2(string houseNo, string locateNo)
|
{
|
try
|
{
|
var Db = DataContext.Db;
|
//获取储位信息
|
//var sql = $@"select * from SysStorageLocat where WareHouseNo = '{houseNo}' and LocatNo = '{locateNo}'; ";
|
//var locate = Db.Ado.SqlQuery<SysStorageLocat>(sql).First();
|
var locate = Db.Queryable<SysStorageLocat>().Where(s => s.WareHouseNo == houseNo && s.LocatNo == locateNo).First();
|
if (locate == null)
|
{
|
throw new Exception($"未查询到仓库号为{houseNo}、储位号为{locateNo}的信息");
|
}
|
//获取深度为2的储位信息
|
//var sql2 = $@"select * from SysStorageLocat where WareHouseNo = '{houseNo}' and row = {locate.Row} and [Column] = {locate.Column} and Layer = {locate.Layer} and Depth = '02'; ";
|
//var data = Db.Ado.SqlQuery<SysStorageLocat>(sql2).First();
|
var data = Db.Queryable<SysStorageLocat>().Where(s => s.WareHouseNo == houseNo && s.Row == locate.Row && s.Column == locate.Column && s.Layer == locate.Layer && s.Depth == "02").First();
|
if (data == null)
|
{
|
throw new Exception($"未查询到仓库号为{houseNo}、储位号为{locateNo}的里面储位信息");
|
}
|
return data;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 获取移库目标库位
|
/// </summary>
|
/// <param name="oldAddress">需要移动的库位地址</param>
|
/// <param name="roadWay">巷道</param>
|
/// <param name="skuNo">物料编码</param>
|
/// <returns>目标库位地址 为"" 直接下发两次出库指令</returns>
|
public string MoveAddress(string oldAddress, string roadWay, string skuNo)//01020201 排-列-层-深度
|
{
|
string nowAddress = "";
|
var Db = DataContext.Db;
|
//根据物料编码获取对应区域
|
var skuCategoryNo = Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.SkuNo == skuNo).Select(a => a.CategoryNo).First();
|
var category = Db.Queryable<SysMaterialCategory>().First(a => a.IsDel == "0" && a.CategoryNo == skuCategoryNo);
|
|
// 获取移库目标储位
|
var row = int.Parse(oldAddress.Substring(0, 2));
|
var lie = int.Parse(oldAddress.Substring(2, 2));
|
var ceng = int.Parse(oldAddress.Substring(4, 2));
|
|
//var sqlString = $@"select LocatNo,[Row],[Column],Layer, (ABS(Row-{row}) + ABS([Column]-{lie}) + ABS(Layer-{ceng})) as distNum from SysStorageLocat where Flag = '0' and Status = '0' and Depth = '02' and RoadwayNo = '{roadWay}' and AreaNo in ('{category.AreaNo}') order by distNum;";
|
|
//var addressModels = Db.Ado.SqlQuery<AddressCls>(sqlString).ToList();
|
var listArea = category.AreaNo.Split(',');
|
var addressModels = Db.Queryable<SysStorageLocat>()
|
.Where(s => s.Flag == "0" && s.Status == "0" && s.Depth == "02" && s.RoadwayNo == roadWay && listArea.Contains(s.AreaNo))
|
.Select(s => new AddressCls()
|
{
|
LocatNo = s.LocatNo,
|
Row = s.Row,
|
Column = s.Column,
|
Layer = s.Layer,
|
DistNum = SqlFunc.Abs(s.Row - row) + SqlFunc.Abs(s.Column - lie) + SqlFunc.Abs(s.Layer - ceng)
|
})
|
.OrderBy(s => s.DistNum)
|
.ToList();
|
if (addressModels.Count > 0) // 判断同巷道内排空库位
|
{
|
var listLocaete = new List<string>();
|
foreach (var item in addressModels)
|
{
|
// 目标内库位对应的外库位
|
string addressee = item.LocatNo.Substring(0, 6) + "01";
|
|
// 判断目标库位的外库位是否存在货物 (正常情况下正在移入情况不存在，因为移库先移入里面，后移入外面)
|
//SlotStatus 0: 空储位 1：有货 2：正在入库 3：正在出库 4：正在移入 5：正在移出
|
//sqlString = $"select count(*) from SysStorageLocat where LocatNo = '{addressee}' and Status = '0' and Flag in ('0','1') ; ";
|
//var rowNum = Db.Ado.SqlQuery<int>(sqlString).First();
|
var rowNum = Db.Queryable<SysStorageLocat>().Count(s => s.LocatNo == addressee && s.Status == "0" && (s.Flag == "0" || s.Flag == "1"));
|
if (rowNum == 0)
|
{
|
continue;
|
}
|
else
|
{
|
nowAddress = item.LocatNo;
|
break;
|
}
|
}
|
}
|
if (nowAddress == "")
|
{
|
// 判断同巷道外排空库位
|
//sqlString = $@"select LocatNo,[Row],[Column],Layer, (ABS(Row-{row}) + ABS([Column]-{lie}) + ABS(Layer-{ceng})) as distNum
|
// from SysStorageLocat
|
// where Flag = '0' and Status = '0' and Depth = '01' and RoadwayNo = '{roadWay}' and AreaNo in '{category}'
|
// order by distNum;";
|
//var adderModeling = Db.Ado.SqlQuery<AddressCls>(sqlString).ToList();
|
var adderModeling = Db.Queryable<SysStorageLocat>()
|
.Where(s => s.Flag == "0" && s.Status == "0" && s.Depth == "01" && s.RoadwayNo == roadWay && listArea.Contains(s.AreaNo))
|
.Select(s => new AddressCls()
|
{
|
LocatNo = s.LocatNo,
|
Row = s.Row,
|
Column = s.Column,
|
Layer = s.Layer,
|
DistNum = SqlFunc.Abs(s.Row - row) + SqlFunc.Abs(s.Column - lie) + SqlFunc.Abs(s.Layer - ceng)
|
})
|
.OrderBy(s => s.DistNum)
|
.ToList();
|
if (adderModeling.Count > 0)
|
{
|
nowAddress = adderModeling[0].LocatNo;
|
}
|
else
|
{
|
// 库内不存在空储位
|
nowAddress = "";
|
}
|
}
|
|
|
return nowAddress;
|
}
|
|
/// <summary>
|
/// 根据前缀获取最大单据号
|
/// </summary>
|
/// <param name="codeFlag">单据前缀</param>
|
/// <returns></returns>
|
public string GetMaxNo(string codeFlag)
|
{
|
try
|
{
|
var maxNo = "";
|
//获取异常号
|
maxNo = SelectMaxNo(codeFlag);
|
if (!string.IsNullOrEmpty(maxNo))
|
{
|
maxNo = maxNo.Substring(codeFlag.Length);
|
}
|
//获取数据库时间八位
|
string date = DateTime.Now.ToString("yyyyMMdd").Trim();
|
string no = "";
|
if (string.IsNullOrEmpty(maxNo))
|
{
|
no = codeFlag + date + "00001";
|
}
|
else
|
{
|
if (maxNo.Substring(0, 8) == date)
|
{
|
int lastNo = Convert.ToInt32(maxNo.Substring(8, 5)) + 1;
|
no = codeFlag + date + (lastNo.ToString().PadLeft(5, '0'));
|
}
|
else
|
{
|
no = codeFlag + date + "00001";
|
}
|
}
|
return no;
|
}
|
catch (Exception e)
|
{
|
Console.WriteLine(e);
|
throw;
|
}
|
}
|
/// <summary>
|
/// 根据前缀判断出当前最大单据号
|
/// </summary>
|
/// <param name="codeFlag">单据前缀</param>
|
/// <returns></returns>
|
public string SelectMaxNo(string codeFlag)
|
{
|
try
|
{
|
string orderNo = "";
|
if (codeFlag == InOutFlag.SO.ToString())//出库
|
{
|
var list = DataContext.Db.Queryable<BllExportNotice>().Where(m => m.SONo.StartsWith("SO")).ToList();
|
orderNo = list.Max(a => a.SONo);
|
}
|
if (codeFlag == InOutFlag.WSO.ToString())//波次出库
|
{
|
var list = DataContext.Db.Queryable<BllWaveMage>().Where(m => m.WaveNo.StartsWith("WSO")).ToList();
|
orderNo = list.Select(a => a.WaveNo).Max();
|
}
|
else if (codeFlag == InOutFlag.ASN.ToString())//入库
|
{
|
var list = DataContext.Db.Queryable<BllArrivalNotice>().Where(m => m.ASNNo.StartsWith("ASN")).ToList();
|
orderNo = list.Select(a => a.ASNNo).Max();
|
}
|
else if (codeFlag == InOutFlag.PM.ToString())//移库
|
{
|
}
|
else if (codeFlag == InOutFlag.CR.ToString())//盘点
|
{
|
var list = DataContext.Db.Queryable<BllStockCheck>().Where(m => m.CRNo.StartsWith("CR")).ToList();
|
orderNo = list.Select(a => a.CRNo).Max();
|
}
|
else if (codeFlag == InOutFlag.TK.ToString())//任务
|
{
|
var list = DataContext.Db.Queryable<LogTask>().Where(m => m.TaskNo.StartsWith("TK")).ToList();
|
orderNo = list.Max(m => m.TaskNo);
|
}
|
else if (codeFlag == InOutFlag.EX.ToString())//异常
|
{
|
var list = DataContext.Db.Queryable<SysException>().Where(m => m.ExceptionNo.StartsWith("EX")).ToList();
|
orderNo = list.Max(a => a.ExceptionNo);
|
}
|
else if (codeFlag == InOutFlag.QC.ToString())//质检请验单
|
{
|
var list = DataContext.Db.Queryable<BllQualityInspectionRequest>().Where(m => m.QcNo.StartsWith("QC")).ToList();
|
orderNo = list.Max(a => a.QcNo);
|
}
|
|
return orderNo;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 执行sql语句获取行数
|
/// </summary>
|
/// <param name="sqlString">查询语句</param>
|
/// <returns>行数</returns>
|
public int GetRowCount(string sqlString)
|
{
|
try
|
{
|
var db = DataContext.Db;
|
var rowCount = db.Ado.GetInt(sqlString);
|
|
return rowCount;
|
}
|
catch (Exception ex)
|
{
|
throw new Exception(ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// 判断托盘是否在入库中
|
/// </summary>
|
/// <param name="palletNo">托盘号</param>
|
/// <returns></returns>
|
public LogTask GetImTask(string palletNo)
|
{
|
try
|
{
|
var db = DataContext.Db;
|
//查询托盘是否有正在入库的任务
|
var imTask = db.Queryable<LogTask>().First(m => m.PalletNo == palletNo && m.IsDel == "0" && m.Status == "1");
|
|
return imTask;
|
}
|
catch (Exception ex)
|
{
|
throw new Exception(ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// //获取包装信息 托盘内数、箱内数
|
/// </summary>
|
/// <param name="packNo"></param>
|
/// <param name="pNum">托盘包装数</param>
|
/// <param name="bNum">箱包装数</param>
|
public void GetPackQtyInfo(string packNo, ref int pNum, ref int bNum)
|
{
|
try
|
{
|
var db = DataContext.Db;
|
var pack = db.Queryable<SysPackag>().First(m => m.PackagNo == packNo);
|
if (pack != null)
|
{
|
if (pack.L5Num.HasValue)
|
{
|
pNum = Convert.ToInt32(pack.L5Num);
|
bNum = Convert.ToInt32(pack.L4Num);
|
}
|
else if (pack.L4Num.HasValue)
|
{
|
pNum = Convert.ToInt32(pack.L4Num);
|
bNum = Convert.ToInt32(pack.L3Num);
|
}
|
else if (pack.L3Num.HasValue)
|
{
|
pNum = Convert.ToInt32(pack.L3Num);
|
bNum = Convert.ToInt32(pack.L2Num);
|
}
|
else if (pack.L2Num.HasValue)
|
{
|
pNum = Convert.ToInt32(pack.L2Num);
|
bNum = Convert.ToInt32(pack.L1Num);
|
}
|
else if (pack.L1Num.HasValue)
|
{
|
pNum = Convert.ToInt32(pack.L1Num);
|
bNum = Convert.ToInt32(pack.L1Num);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 获取系统功能设定小数位数设定值，默认为4位
|
/// </summary>
|
/// <returns></returns>
|
public double GetSysDecimalDigit()
|
{
|
try
|
{
|
var db = DataContext.Db;
|
var funSet = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "小数点位数" && m.IsEnable == "NO");
|
|
|
var allotSet = 4;//分配规则设定
|
|
if (funSet != null)
|
{
|
switch (funSet.SetValue)
|
{
|
case "1":
|
allotSet = 1;
|
break;
|
case "2":
|
allotSet = 2;
|
break;
|
case "3":
|
allotSet = 3;
|
break;
|
case "4":
|
allotSet = 4;
|
break;
|
default:
|
allotSet = 4;// 默认：4
|
break;
|
}
|
}
|
|
return allotSet;
|
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 根据小数位数值转换展示值
|
/// </summary>
|
/// <param name="digit"></param>
|
/// <param name="val"></param>
|
/// <returns></returns>
|
public double GetViewVal(int digit, decimal? val)
|
{
|
try
|
{
|
if (val == null)
|
{
|
throw new Exception("val值为空，请核实");
|
}
|
decimal s = (decimal)val;
|
string r = "0";
|
double data;
|
//decimal data2 = 0.00M;
|
switch (digit)
|
{
|
case 1:
|
r = s.ToString("0.0");
|
data = Math.Round(double.Parse(r), 1);
|
break;
|
case 2:
|
r = s.ToString("0.00");
|
data = Math.Round(double.Parse(r), 2);
|
break;
|
case 3:
|
r = s.ToString("0.000");
|
data = Math.Round(double.Parse(r), 3);
|
break;
|
case 4:
|
r = s.ToString("0.0000");
|
//var ss = double.Parse(r);
|
data = Math.Round(double.Parse(r), 4);
|
//data2 = Math.Round(decimal.Parse(r), 4);
|
break;
|
default:
|
throw new Exception("功能设定小数位数值错误");
|
}
|
|
//var db = DataContext.Db;
|
//var detail = db.Queryable<BllExportNoticeDetail>().First(m => m.SONo == "SO2024040100001");
|
|
//detail.Qty = data2;
|
//var x = db.Updateable(detail).ExecuteCommand();
|
return data;
|
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 获取小车路径
|
/// </summary>
|
/// <param name="startLocation">起始位置</param>
|
/// <param name="endLocation">目标位置</param>
|
/// <param name="moveType">移动类型 0:移动 1:取货 2:放货</param>
|
/// <param name="isLoad">是否载货0：未载货 1：已载货</param>
|
/// <returns></returns>
|
public static List<CarModel> GetCarPath(string startLocation, string endLocation, int moveType, string isLoad = "0")
|
{
|
var _db = DataContext.Db;
|
if (string.IsNullOrEmpty(startLocation) || string.IsNullOrEmpty(endLocation))
|
{
|
return null;
|
}
|
|
// 起始位置
|
CarModel start = new CarModel()
|
{
|
X = int.Parse(startLocation.Substring(0, 2)),
|
Y = int.Parse(startLocation.Substring(2, 2)),
|
Z = int.Parse(startLocation.Substring(4, 2)),
|
NodeCom = 0
|
};
|
|
// 目标位置
|
CarModel end = new CarModel()
|
{
|
X = int.Parse(endLocation.Substring(0, 2)),
|
Y = int.Parse(endLocation.Substring(2, 2)),
|
Z = int.Parse(endLocation.Substring(4, 2)),
|
NodeCom = 0
|
};
|
|
// 获取储位表信息存储到集合里
|
var layer = int.Parse(startLocation.Substring(4, 2));
|
|
// 获取当前层储位信息
|
var locationModels = _db.Queryable<WCSStorageLocat>()
|
.Where(m => m.WareHouseNo == "W01" && m.Layer == layer && m.IsDelete == false)
|
.ToList();
|
|
#region 不用绘制地图，直接根据储位表计算 liudl
|
// 绘制仓库地图 -1:不可用 0：主通道 1：子通道
|
//int[,] warehouseMap = new int[maxRow, maxColumn];
|
//for (int row = 0; row < maxRow; row++)
|
//{
|
// for (int column = 0; column < maxColumn; column++)
|
// {
|
// // 获取当前位置储位信息
|
// var locationModel = locationModels.First(it => it.Row == row && it.Column == column);
|
|
// // 不存在此位置信息
|
// if (locationModel == null)
|
// {
|
// warehouseMap[row, column] = -1;
|
// continue;
|
// }
|
|
// // 储位状态为损坏不可通行 储位状态为屏蔽为可通行不可存储托盘
|
// if (locationModel.Flag == "2")
|
// {
|
// warehouseMap[row, column] = -1;
|
// continue;
|
// }
|
|
// warehouseMap[row, column] = int.Parse(locationModel.Make);
|
// }
|
//}
|
#endregion
|
|
#region 使用算法计算小车路径
|
try
|
{
|
// 定义开发列表存储路径节点
|
var openSet = new SortedSet<(int fscore, CarModel pos)>();
|
// 定义关闭节点字典
|
var closeSet = new Dictionary<CarModel, CarModel>();
|
// 定义上一位置与目标位置字典
|
var cameFrom = new Dictionary<CarModel, CarModel>();
|
// 定义上一位置与目标位置的实际距离字典
|
var gScore = new Dictionary<CarModel, int>();
|
// 定义上一位置与目标位置的预估距离字典
|
var fScore = new Dictionary<CarModel, int>();
|
|
// 存储最优距离，及起始节点
|
openSet.Add((Heuristic(start, end), start));
|
gScore[start] = 0;
|
fScore[start] = Heuristic(start, end);
|
|
// 循环查找路径
|
while (openSet.Count > 0)
|
{
|
var current = openSet.Min.pos;
|
openSet.Remove(openSet.Min);
|
|
if (current.Equals(end))
|
{
|
Log.Error(ReconstructPath(cameFrom, current).ToString());
|
return ReconstructPath(cameFrom, current);
|
}
|
|
// 存储小车可运行的方向
|
var validDirections = new List<CarModel>();
|
var currentLocation = locationModels.FirstOrDefault(m => m.Row == current.X && m.Column == current.Y);
|
if (currentLocation.Make == "0")
|
{
|
// 主通道
|
validDirections.Add(new CarModel() { X = 1, Y = 0 }); // 右
|
validDirections.Add(new CarModel() { X = -1, Y = 0 }); // 左
|
validDirections.Add(new CarModel() { X = 0, Y = 1 }); // 下
|
validDirections.Add(new CarModel() { X = 0, Y = -1 }); // 上
|
}
|
|
if (currentLocation.Make == "1" )
|
{
|
// 子通道
|
// 先拆分出口
|
var outNode = currentLocation.AisleOne;
|
if (string.IsNullOrEmpty(outNode))
|
{
|
throw new Exception("当前位置没有维护出口！");
|
}
|
int outX = int.Parse(outNode.Substring(0, 2));
|
int outY = int.Parse(outNode.Substring(2, 2));
|
if (current.X == outX)
|
{
|
validDirections.Add(new CarModel() { X = 0, Y = 1 }); // 下
|
validDirections.Add(new CarModel() { X = 0, Y = -1 }); // 上
|
|
}
|
else
|
{
|
validDirections.Add(new CarModel() { X = 1, Y = 0 }); // 右
|
validDirections.Add(new CarModel() { X = -1, Y = 0 }); // 左
|
}
|
}
|
|
// 循环连接节点。
|
bool isNextNode = false;
|
foreach (var dir in validDirections)
|
{
|
CarModel neighbor = new CarModel() { X = current.X + dir.X, Y = current.Y + dir.Y ,Z=layer};
|
|
// 验证下一节点位置是否可通行并且判断是否被其他小车占用
|
|
|
// 判断下一节点是否关闭
|
if (closeSet.ContainsKey(neighbor))
|
{
|
closeSet[neighbor] = neighbor;
|
}
|
|
// 当前节点
|
var currentModel = locationModels.FirstOrDefault(it => it.Row == current.X && it.Column == current.Y);
|
// 下一节点
|
var locationModel = locationModels.FirstOrDefault(it => it.Row == neighbor.X && it.Column == neighbor.Y);
|
|
// 不存在此位置信息
|
if (locationModel == null)
|
{
|
closeSet[neighbor] = neighbor;
|
continue;
|
}
|
// 储位状态为损坏不可通行 储位状态为屏蔽为可通行不可存储托盘
|
if (locationModel.Flag == "2")
|
{
|
closeSet[neighbor] = neighbor;
|
continue;
|
}
|
// 判断下一节点上是否有托盘
|
if (!string.IsNullOrEmpty(locationModel.PalletNo))
|
{
|
// 判断小车是否载托盘盘
|
if (isLoad == "1")
|
{
|
closeSet[neighbor] = neighbor;
|
// 小车上载托盘不可通行跳过
|
continue;
|
}
|
}
|
// 优化项，验证下一节点是否被别的小车占用 liudl：在此添加优化代码
|
|
// 更新实际距离
|
int tentativeGScore = gScore[current] + 1;
|
// 判断位置是否已包含在路径内 且 是否更近节点
|
if (!gScore.ContainsKey(neighbor) || tentativeGScore < gScore[neighbor])
|
{
|
neighbor.IsSendPlc = false;
|
// 补充参数
|
if (neighbor.Equals(end))
|
{
|
neighbor.NodeCom = moveType;
|
neighbor.IsSendPlc = true;
|
}
|
else if (currentModel.Make != locationModel.Make)
|
{
|
if (current.X == neighbor.X)
|
{
|
neighbor.NodeCom = 3;
|
}
|
else if (current.Y == neighbor.Y)
|
{
|
neighbor.NodeCom = 2;
|
}
|
|
neighbor.IsSendPlc = true;
|
}
|
|
// 更新实际距离与预估距离
|
cameFrom[neighbor] = current;
|
gScore[neighbor] = tentativeGScore;
|
fScore[neighbor] = tentativeGScore + Heuristic(neighbor, end);
|
openSet.Add((fScore[neighbor], neighbor));
|
isNextNode = true;
|
}
|
}
|
|
if (!isNextNode)
|
{
|
closeSet[current] = current;
|
}
|
}
|
#endregion
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
|
|
return null;
|
}
|
|
/// <summary>
|
/// 计算曼哈顿距离
|
/// </summary>
|
/// <param name="start">起始位置</param>
|
/// <param name="end">目标位置</param>
|
/// <returns>位置距离</returns>
|
private static int Heuristic(CarModel start, CarModel end)
|
{
|
return Math.Abs(start.X - end.X) + Math.Abs(start.Y - end.Y);
|
}
|
|
/// <summary>
|
/// 重构完整路径
|
/// </summary>
|
/// <param name="cameFrom"></param>
|
/// <param name="current"></param>
|
/// <returns></returns>
|
private static List<CarModel> ReconstructPath(Dictionary<CarModel, CarModel> cameFrom, CarModel current)
|
{
|
var path = new List<CarModel> { current };
|
while (cameFrom.ContainsKey(current))
|
{
|
current = cameFrom[current];
|
path.Insert(0, current);
|
}
|
return path;
|
}
|
|
}
|
public enum InOutFlag
|
{
|
/// <summary>
|
/// 入库单
|
/// </summary>
|
[Description("入库单")]
|
ASN,
|
/// <summary>
|
/// 出库单
|
/// </summary>
|
[Description("出库单")]
|
SO,
|
/// <summary>
|
/// 波次出库单
|
/// </summary>
|
[Description("波次出库单")]
|
WSO,
|
/// <summary>
|
/// 出库单
|
/// </summary>
|
[Description("盘点单")]
|
CR,
|
/// <summary>
|
/// 移库单
|
/// </summary>
|
[Description("移库单")]
|
PM,
|
|
/// <summary>
|
/// 任务
|
/// </summary>
|
[Description("任务")]
|
TK,
|
/// <summary>
|
/// 异常号
|
/// </summary>
|
[Description("异常")]
|
EX,
|
/// <summary>
|
/// 质检请验单
|
/// </summary>
|
[Description("质检请验单")]
|
QC
|
}
|
|
public class CarModel : IComparable<CarModel>
|
{
|
/// <summary>
|
/// 行=X
|
/// </summary>
|
public int X { get; set; }
|
|
/// <summary>
|
/// 列=Y
|
/// </summary>
|
public int Y { get; set; }
|
|
/// <summary>
|
/// 层=Z
|
/// </summary>
|
public int Z { get; set; }
|
|
/// <summary>
|
/// 节点命令 1:顶货 2:子通道运行 3:主通道运行 4:放货
|
/// </summary>
|
public int NodeCom { get; set; }
|
|
/// <summary>
|
/// 是否下发plc
|
/// </summary>
|
public bool IsSendPlc { get; set; }
|
|
public int CompareTo(CarModel other)
|
{
|
if (other == null)
|
return 1;
|
|
// 这里根据 X、Y、Z 坐标进行比较
|
int result = X.CompareTo(other.X);
|
if (result != 0)
|
return result;
|
|
result = Y.CompareTo(other.Y);
|
if (result != 0)
|
return result;
|
|
return Z.CompareTo(other.Z);
|
}
|
|
// 重写 Equals 方法
|
public override bool Equals(object obj)
|
{
|
if (obj == null || GetType() != obj.GetType())
|
return false;
|
|
CarModel other = (CarModel)obj;
|
return X == other.X && Y == other.Y && Z == other.Z;
|
}
|
|
// 重写 GetHashCode 方法
|
public override int GetHashCode()
|
{
|
return HashCode.Combine(X, Y, Z);
|
}
|
}
|
|
}
|
