using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using WIDESEAWCS_Common;
|
|
public class ContainerPlacer
|
{
|
// 容器尺寸常量
|
private const int ContainerY = 2800; // 长度方向(Y轴)
|
private const int ContainerX = 600; // 宽度方向(X轴)
|
private const int ContainerZ = 500; // 高度方向(Z轴)
|
|
// 系统参数
|
private const int SafetySpacing = 10; // 安全间距
|
private const int YAxisMaxPlace = 880;// 放置Y坐标最大值
|
private const int SuctionSpacing = 660; // 吸盘间距
|
|
// 吸盘尺寸配置（横向/纵向）
|
private static readonly (int x, int y)[] SuctionSizes =
|
{
|
(530, 130), // 0度横向
|
(130, 530) // 90度纵向
|
};
|
|
/// <summary>
|
/// 主计算方法
|
/// </summary>
|
public SuctionInfo CalculatePlacement(Block newBlock, List<Block> existingBlocks)
|
{
|
// 获取所有支撑面并按高度排序
|
var supportSurfaces = GetSupportSurfaces(existingBlocks)
|
.OrderBy(s => s.Z)
|
.ToList();
|
|
foreach (var surface in supportSurfaces)
|
{
|
// 尝试所有有效旋转组合
|
foreach (var rotation in GetValidRotations(newBlock))
|
{
|
// 计算实际放置尺寸
|
//var (placeW, placeL) = GetPlacementDimensions(newBlock, rotation);
|
|
// 跳过尺寸不符的表面
|
if (!CanPlaceOnSurface(newBlock.W, newBlock.L, surface, newBlock.H)) continue;
|
|
// 搜索可用位置
|
var position = FindPosition(newBlock.W, newBlock.L, surface, existingBlocks);
|
if (!position.HasValue) continue;
|
|
// 计算吸盘参数
|
var suction = CalculateSuctionParams(newBlock, position.Value,
|
surface.Z, rotation, newBlock.W, newBlock.L);
|
|
suction.Point = position.Value;
|
|
// 最终验证
|
if (ValidatePlacement(suction, existingBlocks))
|
{
|
return suction;
|
}
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取支撑面列表（容器底部+现有木块顶面）
|
/// </summary>
|
private List<SupportSurface> GetSupportSurfaces(List<Block> blocks)
|
{
|
var surfaces = new List<SupportSurface> {
|
new SupportSurface { // 容器底部
|
Z = 0, X = 0, Y = 0,
|
AvailableX = ContainerX, AvailableY = ContainerY
|
}
|
};
|
|
// 添加现有木块顶面
|
surfaces.AddRange(blocks.Select(b => new SupportSurface
|
{
|
Z = b.Z + b.H,
|
X = b.X,
|
Y = b.Y,
|
AvailableX = b.W,
|
AvailableY = b.L
|
}));
|
|
return surfaces;
|
}
|
|
/// <summary>
|
/// 表面可行性检查
|
/// </summary>
|
private bool CanPlaceOnSurface(int placeW, int placeL,
|
SupportSurface surface, int blockH)
|
{
|
return surface.AvailableX >= placeW &&
|
surface.AvailableY >= placeL &&
|
surface.Z + blockH <= ContainerZ;
|
}
|
|
/// <summary>
|
/// 获取有效旋转角度（考虑规则5）
|
/// </summary>
|
private IEnumerable<int> GetValidRotations(Block block)
|
{
|
// 0°/180°横向双吸盘（规则5）
|
if (block.L > 920 && block.W >= 100 || block.L < 450)
|
{
|
yield return 0;
|
yield return 180;
|
}
|
|
// 90°/270°纵向双吸盘（无条件允许）
|
yield return 90;
|
yield return 270;
|
}
|
|
/// <summary>
|
/// 计算实际放置尺寸（考虑旋转）
|
/// </summary>
|
private (int w, int l) GetPlacementDimensions(Block b, int rotation)
|
{
|
return rotation % 180 == 0 ? (b.W, b.L) : (b.L, b.W);
|
}
|
|
/// <summary>
|
/// 位置搜索算法（带安全间距）
|
/// </summary>
|
private Point? FindPosition(int placeW, int placeL,
|
SupportSurface surface, List<Block> existing)
|
{
|
// 搜索步长设置为安全间距
|
const int step = 10;
|
|
for (int x = surface.X; x + placeW <= surface.X + surface.AvailableX; x += step)
|
{
|
for (int y = surface.Y; y + placeL <= surface.Y + surface.AvailableY; y += step)
|
{
|
if (IsPositionValid(x, y, placeW, placeL, surface.Z, existing))
|
{
|
return new Point(x, y);
|
}
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 位置有效性验证（含安全间距）
|
/// </summary>
|
private bool IsPositionValid(int x, int y, int w, int l,
|
int z, List<Block> existing)
|
{
|
// 创建带安全间距的检测区域
|
var newArea = new Rectangle(
|
x - SafetySpacing,
|
y - SafetySpacing,
|
x + w + SafetySpacing,
|
y + l + SafetySpacing);
|
|
var a = existing.Where(block =>
|
block.Z + block.H - z > 1).ToList();
|
|
// 碰撞检测
|
foreach (var b in a)
|
{
|
var existArea = new Rectangle(
|
b.X - SafetySpacing,
|
b.Y - SafetySpacing,
|
b.X + b.W + SafetySpacing,
|
b.Y + b.L + SafetySpacing);
|
|
if (newArea.Intersects(existArea)) return false;
|
}
|
|
// 容器边界检查
|
return x >= 0 && x + w <= ContainerX &&
|
y >= 0 && y + l <= ContainerY;
|
}
|
|
/// <summary>
|
/// 计算吸盘参数（核心算法）
|
/// </summary>
|
private SuctionInfo CalculateSuctionParams(Block block, Point position,
|
int surfaceZ, int rotation, int placeW, int placeL)
|
{
|
var info = new SuctionInfo { Rotation = rotation };
|
var suctionType = rotation % 180 == 0 ? 0 : 1;
|
|
// 计算理论放置中心
|
info.PlaceCenter = new int[3] {
|
position.X + placeW/2,
|
position.Y + placeL/2,
|
surfaceZ + block.H
|
};
|
|
// 先应用规则6：放置位置调整
|
if (ApplyRule6Adjustment(info, suctionType))
|
{
|
// 调整后需要重新计算抓取点
|
ApplyRule7Adjustment(info, block, suctionType);
|
}
|
else
|
{
|
// 未触发规则6时直接应用规则7
|
ApplyRule7Adjustment(info, block, suctionType);
|
}
|
|
// 应用旋转调整
|
//ApplyRotationAdjustment(info, rotation, block);
|
|
return info;
|
}
|
|
/// <summary>
|
/// 应用规则6调整：放置位置超过880mm时边缘抓取
|
/// </summary>
|
private bool ApplyRule6Adjustment(SuctionInfo info, int suctionType)
|
{
|
if (info.PlaceCenter[1] <= YAxisMaxPlace) return false;
|
|
// 计算吸盘尺寸
|
int suctionSize = SuctionSizes[suctionType].y;
|
|
// 计算调整后的放置位置（规则6）
|
info.PlaceCenter[1] = YAxisMaxPlace - suctionSize / 2;
|
info.Rotation += 180; // 添加旋转标记
|
|
return true;
|
}
|
|
/// <summary>
|
/// 应用规则7调整：抓取点尽量靠近中心
|
/// </summary>
|
private void ApplyRule7Adjustment(SuctionInfo info, Block block, int suctionType)
|
{
|
// 计算理论最大行程
|
int maxTravel = YAxisMaxPlace - SuctionSizes[suctionType].y / 2;
|
|
// 计算理想抓取点
|
info.PickCenter = new int[3] {
|
block.W / 2,
|
Math.Min(block.L / 2, maxTravel), // Y方向尽量接近中心
|
block.H
|
};
|
}
|
|
/// <summary>
|
/// 应用旋转调整（180/270度）
|
/// </summary>
|
private void ApplyRotationAdjustment(SuctionInfo info, int rotation, Block block)
|
{
|
if (rotation == 180 || info.Rotation == 180)
|
{
|
// Y轴镜像
|
info.PickCenter[1] = block.L - info.PickCenter[1];
|
info.PlaceCenter[1] = ContainerY - info.PlaceCenter[1];
|
}
|
else if (rotation == 270 || info.Rotation == 270)
|
{
|
// X轴镜像
|
info.PickCenter[0] = ContainerX - info.PickCenter[0];
|
info.PlaceCenter[0] = ContainerX - info.PlaceCenter[0];
|
}
|
}
|
|
/// <summary>
|
/// 最终放置验证
|
/// </summary>
|
private bool ValidatePlacement(SuctionInfo info, List<Block> existing)
|
{
|
// 空间边界检查
|
if (info.PlaceCenter[0] < 0 || info.PlaceCenter[0] > ContainerX) return false;
|
if (info.PlaceCenter[1] < 0 || info.PlaceCenter[1] > YAxisMaxPlace) return false;
|
if (info.PlaceCenter[2] > ContainerZ) return false;
|
|
// 吸盘投影覆盖检查
|
var suctionType = info.Rotation % 180 == 0 ? 0 : 1;
|
var (sx, sy) = SuctionSizes[suctionType];
|
|
var projection = new Rectangle(
|
info.PlaceCenter[0] - sx / 2,
|
info.PlaceCenter[1] - sy / 2,
|
info.PlaceCenter[0] + sx / 2,
|
info.PlaceCenter[1] + sy / 2
|
);
|
|
// 检查是否完全在支撑面内
|
return existing.All(b => !projection.Intersects(new Rectangle(
|
b.X - SafetySpacing,
|
b.Y - SafetySpacing,
|
b.X + b.W + SafetySpacing,
|
b.Y + b.L + SafetySpacing
|
)));
|
}
|
}
|
|
// 辅助类定义--------------------------------------------
|
public class SupportSurface
|
{
|
public int X { get; set; }
|
public int Y { get; set; }
|
public int Z { get; set; }
|
public int AvailableX { get; set; }
|
public int AvailableY { get; set; }
|
}
|
|
|
public class Rectangle
|
{
|
public int Left { get; }
|
public int Top { get; }
|
public int Right { get; }
|
public int Bottom { get; }
|
|
public Rectangle(int x1, int y1, int x2, int y2)
|
{
|
Left = Math.Min(x1, x2);
|
Right = Math.Max(x1, x2);
|
Top = Math.Min(y1, y2);
|
Bottom = Math.Max(y1, y2);
|
}
|
|
public bool Intersects(Rectangle other)
|
{
|
return !(Right < other.Left ||
|
Left > other.Right ||
|
Bottom < other.Top ||
|
Top > other.Bottom);
|
}
|
}
|
|
#region
|
//using System;
|
//using System.Collections.Generic;
|
//using System.Linq;
|
//using WIDESEAWCS_Common;
|
|
|
|
//public class ContainerPlacer
|
//{
|
// // 容器尺寸常量
|
// private const int ContainerY = 2800; // 长度方向(Y轴)
|
// private const int ContainerX = 700; // 宽度方向(X轴)
|
// private const int ContainerZ = 500; // 高度方向(Z轴)
|
|
// // 系统参数
|
// private const int SafetySpacing = 10; // 安全间距
|
// private const int YAxisMax = 880; // Y坐标最大值
|
// private const int SuctionSpacing = 660; // 吸盘间距
|
|
// // 吸盘尺寸配置（横向/纵向）
|
// private static readonly (int x, int y)[] SuctionSizes =
|
// {
|
// (530, 130), // 0度横向
|
// (130, 530) // 90度纵向
|
// };
|
|
// /// <summary>
|
// /// 主计算方法
|
// /// </summary>
|
// public SuctionInfo CalculatePlacement(Block newBlock, List<Block> existingBlocks)
|
// {
|
// // 获取所有支撑面并按高度排序
|
// var supportSurfaces = GetSupportSurfaces(existingBlocks)
|
// .OrderBy(s => s.Z)
|
// .ToList();
|
|
// foreach (var surface in supportSurfaces)
|
// {
|
// // 尝试所有有效旋转组合
|
// foreach (var rotation in GetValidRotations(newBlock))
|
// {
|
// // 计算实际放置尺寸
|
// var (placeW, placeL) = GetPlacementDimensions(newBlock, rotation);
|
|
// // 跳过尺寸不符的表面
|
// if (!CanPlaceOnSurface(placeW, placeL, surface, newBlock.H)) continue;
|
|
// // 搜索可用位置
|
// var position = FindPosition(placeW, placeL, surface, existingBlocks);
|
// if (!position.HasValue) continue;
|
|
// // 计算吸盘参数
|
// var suction = CalculateSuctionParams(newBlock, position.Value,
|
// surface.Z, rotation, placeW, placeL);
|
|
// // 最终验证
|
// if (ValidatePlacement(suction, existingBlocks))
|
// {
|
// return suction;
|
// }
|
// }
|
// }
|
// return null;
|
// }
|
|
// /// <summary>
|
// /// 获取支撑面列表（容器底部+现有木块顶面）
|
// /// </summary>
|
// private List<SupportSurface> GetSupportSurfaces(List<Block> blocks)
|
// {
|
// var surfaces = new List<SupportSurface> {
|
// new SupportSurface { // 容器底部
|
// Z = 0, X = 0, Y = 0,
|
// AvailableX = ContainerX, AvailableY = ContainerY
|
// }
|
// };
|
|
// // 添加现有木块顶面
|
// surfaces.AddRange(blocks.Select(b => new SupportSurface
|
// {
|
// Z = b.Z + b.H,
|
// X = b.X,
|
// Y = b.Y,
|
// AvailableX = b.W,
|
// AvailableY = b.L
|
// }));
|
|
// return surfaces;
|
// }
|
|
// /// <summary>
|
// /// 表面可行性检查
|
// /// </summary>
|
// private bool CanPlaceOnSurface(int placeW, int placeL,
|
// SupportSurface surface, int blockH)
|
// {
|
// return surface.AvailableX >= placeW &&
|
// surface.AvailableY >= placeL &&
|
// surface.Z + blockH <= ContainerZ;
|
// }
|
|
// /// <summary>
|
// /// 获取有效旋转角度（考虑规则5）
|
// /// </summary>
|
// private IEnumerable<int> GetValidRotations(Block block)
|
// {
|
// // 0°/180°横向双吸盘（规则5）
|
// if (block.L > 920 && block.W >= 300)
|
// {
|
// yield return 0;
|
// yield return 180;
|
// }
|
|
// // 90°/270°纵向双吸盘（无条件允许）
|
// yield return 90;
|
// yield return 270;
|
// }
|
|
// /// <summary>
|
// /// 计算实际放置尺寸（考虑旋转）
|
// /// </summary>
|
// private (int w, int l) GetPlacementDimensions(Block b, int rotation)
|
// {
|
// return rotation % 180 == 0 ? (b.W, b.L) : (b.L, b.W);
|
// }
|
|
// /// <summary>
|
// /// 位置搜索算法（带安全间距）
|
// /// </summary>
|
// private Point? FindPosition(int placeW, int placeL,
|
// SupportSurface surface, List<Block> existing)
|
// {
|
// // 搜索步长设置为安全间距
|
// const int step = 10;
|
|
// for (int x = surface.X; x + placeW <= surface.X + surface.AvailableX; x += step)
|
// {
|
// for (int y = surface.Y; y + placeL <= surface.Y + surface.AvailableY; y += step)
|
// {
|
// if (IsPositionValid(x, y, placeW, placeL, surface.Z, existing))
|
// {
|
// return new Point(x, y);
|
// }
|
// }
|
// }
|
// return null;
|
// }
|
|
// /// <summary>
|
// /// 位置有效性验证（含安全间距）
|
// /// </summary>
|
// private bool IsPositionValid(int x, int y, int w, int l,
|
// int z, List<Block> existing)
|
// {
|
// // 创建带安全间距的检测区域
|
// var newArea = new Rectangle(
|
// x - SafetySpacing,
|
// y - SafetySpacing,
|
// x + w + SafetySpacing,
|
// y + l + SafetySpacing);
|
|
// // 碰撞检测
|
// foreach (var b in existing.Where(block =>
|
// Math.Abs(block.Z + block.H - z) < 0.001)) // 同平面检测
|
// {
|
// var existArea = new Rectangle(
|
// b.X - SafetySpacing,
|
// b.Y - SafetySpacing,
|
// b.X + b.W + SafetySpacing,
|
// b.Y + b.L + SafetySpacing);
|
|
// if (newArea.Intersects(existArea)) return false;
|
// }
|
|
// // 容器边界检查
|
// return x >= 0 && x + w <= ContainerX &&
|
// y >= 0 && y + l <= ContainerY;
|
// }
|
|
// /// <summary>
|
// /// 计算吸盘参数（核心算法）
|
// /// </summary>
|
// private SuctionInfo CalculateSuctionParams(Block block, Point position,
|
// int surfaceZ, int rotation, int placeW, int placeL)
|
// {
|
// var info = new SuctionInfo { Rotation = rotation };
|
// var suctionType = rotation % 180 == 0 ? 0 : 1;
|
|
// // 计算理论中心点
|
// info.PlaceCenter = new int[3] {
|
// position.X + placeW/2,
|
// position.Y + placeL/2,
|
// surfaceZ + block.H
|
// };
|
|
// // 计算初始抓取中心
|
// CalculateInitialPickCenter(info, block, rotation, suctionType);
|
|
// // 应用行程调整（规则6、7）
|
// ApplyTravelAdjustment(info, suctionType);
|
|
// // 应用旋转调整（180/270度）
|
// ApplyRotationAdjustment(info, rotation, block);
|
|
// return info;
|
// }
|
|
// /// <summary>
|
// /// 计算初始抓取中心点
|
// /// </summary>
|
// private void CalculateInitialPickCenter(SuctionInfo info, Block block,
|
// int rotation, int suctionType)
|
// {
|
// switch (rotation % 360)
|
// {
|
// case 0: // 横向双吸盘
|
// case 180:
|
// info.PickCenter = new int[3] {
|
// block.W / 2, // X中心
|
// block.L / 2, // Y中心
|
// block.H // Z坐标
|
// };
|
// break;
|
|
// case 90: // 纵向双吸盘
|
// case 270:
|
// info.PickCenter = new int[3] {
|
// block.W / 2, // X中心
|
// block.L / 2, // Y中心
|
// block.H // Z坐标
|
// };
|
// break;
|
// }
|
// }
|
|
// /// <summary>
|
// /// 应用行程调整（规则6、7）
|
// /// </summary>
|
// private void ApplyTravelAdjustment(SuctionInfo info, int suctionType)
|
// {
|
// // 计算理论行程需求
|
// int requiredTravel = info.PickCenter[1];
|
|
// // 当超过最大允许行程时进行调整
|
// if (requiredTravel > YAxisMax)
|
// {
|
// // 计算吸盘尺寸
|
// int suctionSize = SuctionSizes[suctionType].y;
|
|
// // 计算调整后的抓取位置（尽量靠近中心）
|
// int adjustedPickY = info.PlaceCenter[1] > YAxisMax
|
// ? YAxisMax - suctionSize / 2 // 抓取远端
|
// : suctionSize / 2; // 抓取近端
|
|
// // 更新抓取中心并标记旋转
|
// info.PlaceCenter[1] = adjustedPickY;
|
// info.Rotation += 180;
|
// }
|
// }
|
|
// /// <summary>
|
// /// 应用旋转调整（180/270度）
|
// /// </summary>
|
// private void ApplyRotationAdjustment(SuctionInfo info, int rotation, Block block)
|
// {
|
// if (rotation == 180)
|
// {
|
// // Y轴镜像
|
// info.PickCenter[1] = block.L - info.PickCenter[1];
|
// info.PlaceCenter[1] = ContainerY - info.PlaceCenter[1];
|
// }
|
// else if (rotation == 270)
|
// {
|
// // X轴镜像
|
// info.PickCenter[0] = ContainerX - info.PickCenter[0];
|
// info.PlaceCenter[0] = ContainerX - info.PlaceCenter[0];
|
// }
|
// }
|
|
// /// <summary>
|
// /// 最终放置验证
|
// /// </summary>
|
// private bool ValidatePlacement(SuctionInfo info, List<Block> existing)
|
// {
|
// // 空间边界检查
|
// if (info.PlaceCenter[0] < 0 || info.PlaceCenter[0] > ContainerX) return false;
|
// if (info.PlaceCenter[1] < 0 || info.PlaceCenter[1] > YAxisMax) return false;
|
// if (info.PlaceCenter[2] > ContainerZ) return false;
|
|
// // 投影覆盖检查
|
// var projection = new Rectangle(
|
// info.PlaceCenter[0] - SuctionSizes[info.Rotation % 180 == 0 ? 0 : 1].x / 2,
|
// info.PlaceCenter[1] - SuctionSizes[info.Rotation % 180 == 0 ? 0 : 1].y / 2,
|
// info.PlaceCenter[0] + SuctionSizes[info.Rotation % 180 == 0 ? 0 : 1].x / 2,
|
// info.PlaceCenter[1] + SuctionSizes[info.Rotation % 180 == 0 ? 0 : 1].y / 2
|
// );
|
|
// // 检查是否完全在支撑面内
|
// return existing.All(b => !projection.Intersects(new Rectangle(
|
// b.X - SafetySpacing,
|
// b.Y - SafetySpacing,
|
// b.X + b.W + SafetySpacing,
|
// b.Y + b.L + SafetySpacing
|
// )));
|
// }
|
//}
|
|
//// 辅助类定义--------------------------------------------
|
//public class SupportSurface
|
//{
|
// public int X { get; set; }
|
// public int Y { get; set; }
|
// public int Z { get; set; }
|
// public int AvailableX { get; set; }
|
// public int AvailableY { get; set; }
|
//}
|
|
//public struct Point
|
//{
|
// public int X { get; }
|
// public int Y { get; }
|
// public Point(int x, int y) => (X, Y) = (x, y);
|
//}
|
|
//public class Rectangle
|
//{
|
// public int Left { get; }
|
// public int Top { get; }
|
// public int Right { get; }
|
// public int Bottom { get; }
|
|
// public Rectangle(int x1, int y1, int x2, int y2)
|
// {
|
// Left = Math.Min(x1, x2);
|
// Right = Math.Max(x1, x2);
|
// Top = Math.Min(y1, y2);
|
// Bottom = Math.Max(y1, y2);
|
// }
|
|
// public bool Intersects(Rectangle other)
|
// {
|
// return !(Right < other.Left ||
|
// Left > other.Right ||
|
// Bottom < other.Top ||
|
// Top > other.Bottom);
|
// }
|
//}
|
#endregion
|
