public Bottle(uint pickId, BottleProperties bottleProp, CylPosition position)
{
PickId = pickId;
Profile = bottleProp.Profile;
Color = bottleProp.Color;
Position = position;
}
public Cylinder(uint pickId, CylinderProperties cylProperties, CylPosition cylPosition)
{
_pickId = pickId;
_radiusOuter = cylProperties.RadiusOuter;
_radiusInner = cylProperties.RadiusInner;
Height = cylProperties.Height;
ColorTop = cylProperties.ColorTop;
ColorWallOuter = cylProperties.ColorWallOuter;
ColorWallInner = cylProperties.ColorWallInner;
_cylPosition = cylPosition;
}
protected void AddPosition(HCylLayout layout, CylPosition pos)
{
Transform3D transfRot = Transform3D.Identity;
if (layout.Swapped)
{
Matrix4D matRot = new Matrix4D(
0.0, -1.0, 0.0, 0.0
, 1.0, 0.0, 0.0, 0.0
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0
);
Vector3D vTranslation = new Vector3D(layout.DimContainer.X, 0.0, 0.0);
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
transfRot = new Transform3D(matRot);
}
layout.Positions.Add(pos.Transform(Transform3D.Translation(layout.Offset) * transfRot));
}
public void AddPosition(CylLoad load, CylPosition pos)
{
Matrix4D matRot = Matrix4D.Identity;
Vector3D vTranslation = Vector3D.Zero;
if (_swapped)
{
matRot = new Matrix4D(
0.0, -1.0, 0.0, 0.0
, 1.0, 0.0, 0.0, 0.0
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0
);
vTranslation = new Vector3D(load.PalletLength, 0.0, 0.0);
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
}
load.Add(pos.Transform(new Transform3D(matRot)));
}
public override void Draw(Graphics3D graphics, Transform3D transform)
{
// clear list of picking box
ClearPickingBoxes();
if (null == Solution)
{
return;
}
AnalysisHomo analysis = Solution.Analysis;
if (analysis is AnalysisPackablePallet analysisPackablePallet)
{
// ### draw pallet
Pallet pallet = new Pallet(analysisPackablePallet.PalletProperties);
pallet.Draw(graphics, transform);
if (analysis is AnalysisCasePallet && -1 == Solution.SelectedLayerIndex)
{
// ### strappers
SolutionLayered sol = Solution;
foreach (var sd in sol.Strappers)
{
if (null != sd.Points && sd.Points.Count > 0)
{
Strapper s = new Strapper(
transform.transform(IntToAxis(sd.Strapper.Axis)),
sd.Strapper.Width,
sd.Strapper.Color,
sd.Points.ConvertAll(p => transform.transform(p)).ToList());
s.DrawBegin(graphics);
}
}
}
}
else if (analysis is AnalysisPackableCase analysisPackableCase)
{
// ### draw case (inside)
Case case_ = new Case(analysisPackableCase.CaseProperties);
case_.DrawInside(graphics, transform);
}
else if (analysis is AnalysisPackableTruck analysisPackableTruck)
{
// ### draw truck
Truck truck = new Truck(analysisPackableTruck.TruckProperties);
truck.DrawBegin(graphics);
}
else if (analysis is AnalysisPalletTruck analysisPalletTruck)
{
// ### draw truck
Truck truck = new Truck(analysisPalletTruck.TruckProperties);
truck.DrawBegin(graphics);
}
// ### draw solution
uint layerId = 0, pickId = 0;
List <ILayer> layers = Solution.Layers;
foreach (ILayer layer in layers)
{
bool aboveSelectedLayer = (Solution.SelectedLayerIndex != -1) && (layerId > Solution.SelectedLayerIndex);
Transform3D upTranslation = Transform3D.Translation(new Vector3D(0.0, 0.0, aboveSelectedLayer ? DistanceAboveSelectedLayer : 0.0));
BBox3D bbox = new BBox3D();
// ### layer of boxes
if (layer is Layer3DBox layerBox)
{
if (analysis.Content is LoadedPallet)
{
LoadedPallet loadedPallet = analysis.Content as LoadedPallet;
BBox3D solBBox = loadedPallet.ParentAnalysis.Solution.BBoxGlobal;
foreach (BoxPosition bPosition in layerBox)
{
var dim = solBBox.DimensionsVec;
graphics.AddImage(++pickId, new SubContent(loadedPallet.ParentAnalysis as AnalysisHomo), solBBox.DimensionsVec, bPosition.Transform(transform));
// bbox used for picking
bbox.Extend(new BBox3D(bPosition.Transform(transform), solBBox.DimensionsVec));
}
}
else if (analysis.Content is PackProperties packProperties)
{
foreach (BoxPosition bPosition in layerBox)
{
BoxPosition boxPositionModified = bPosition.Transform(transform * upTranslation);
graphics.AddImage(++pickId, new SubContent(packProperties), packProperties.OuterDimensions, boxPositionModified);
// bbox used for picking
bbox.Extend(new BBox3D(boxPositionModified, packProperties.OuterDimensions));
}
}
else if (analysis.Content is BagProperties bagProperties)
{
foreach (BoxPosition bPosition in layerBox)
{
BoxPosition boxPositionModified = bPosition.Transform(transform * upTranslation);
graphics.AddImage(++pickId, new SubContent(bagProperties), bagProperties.OuterDimensions, boxPositionModified);
// bbox used for picking
bbox.Extend(new BBox3D(boxPositionModified, bagProperties.OuterDimensions));
}
}
else
{
foreach (BoxPosition bPosition in layerBox)
{
BoxPosition boxPositionModified = bPosition.Transform(transform * upTranslation);
BoxGeneric b;
if (analysis.Content is BagProperties bagProp)
{
b = new BoxRounded(pickId++, bagProp.Length, bagProp.Width, bagProp.Height, bagProp.Radius, boxPositionModified)
{
ColorFill = bagProp.ColorFill
}
}
;
else
{
b = new Box(pickId++, analysis.Content as PackableBrick, boxPositionModified);
}
graphics.AddBox(b);
bbox.Extend(b.BBox);
}
}
}
else if (layer is Layer3DBoxIndexed layerBoxIndexed)
{
foreach (var bpi in layerBoxIndexed)
{
BoxPosition boxPositionModified = bpi.BPos.Transform(transform * upTranslation);
var bProperties = analysis.Content as PackableBrick;
BoxGeneric b = new Box(pickId++, analysis.Content as PackableBrick, boxPositionModified);
graphics.AddBox(b);
// bbox used for picking
bbox.Extend(new BBox3D(boxPositionModified, bProperties.OuterDimensions));
}
}
else if (layer is Layer3DCyl layerCyl)
{
foreach (Vector3D vPos in layerCyl)
{
CylPosition cylPosition = new CylPosition(transform.transform(vPos), HalfAxis.HAxis.AXIS_Z_P);
CylPosition cylPositionModified = cylPosition.Transform(transform * upTranslation);
Cyl cyl = null;
if (analysis.Content is CylinderProperties cylProp)
{
cyl = new Cylinder(pickId++, cylProp, cylPositionModified);
}
else if (analysis.Content is BottleProperties bottleProperties)
{
cyl = new Bottle(pickId++, bottleProperties, cylPositionModified);
}
graphics.AddCylinder(cyl);
bbox.Extend(cyl.BBox);
}
}
// ### interlayer
else if (layer is InterlayerPos interlayerPos)
{
InterlayerProperties interlayerProp = Solution.Interlayers[interlayerPos.TypeId];
if (null != interlayerProp)
{
BoxPosition bPosition = new BoxPosition(
new Vector3D(
analysis.Offset.X + 0.5 * (analysis.ContainerDimensions.X - interlayerProp.Length)
, analysis.Offset.Y + 0.5 * (analysis.ContainerDimensions.Y - interlayerProp.Width)
, interlayerPos.ZLow
), HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
BoxPosition boxPositionModified = bPosition.Transform(transform * upTranslation);
Box box = new Box(pickId++, interlayerProp, boxPositionModified);
if (analysis.Content is PackProperties)
{
graphics.AddImage(pickId, new SubContent(interlayerProp), interlayerProp.Dimensions, boxPositionModified);
}
else
{
graphics.AddBox(box);
}
bbox.Extend(box.BBox);
}
}
if (layer is Layer3DBox || layer is Layer3DCyl)
{
// add layer BBox
AddPickingBox(bbox, layerId);
// draw bounding box around selected layer
if (layerId == Solution.SelectedLayerIndex)
{
DrawLayerBoundingBox(graphics, bbox);
}
++layerId;
}
}
BBox3D loadBBox = Solution.BBoxLoad;
BBox3D loadBBoxWDeco = Solution.BBoxLoadWDeco;
if (analysis is AnalysisCasePallet analysisCasePallet)
{
#region Pallet corners
// ### pallet corners : Begin
Corner[] corners = new Corner[4];
if (analysisCasePallet.HasPalletCorners)
{
// positions
Vector3D[] cornerPositions =
{
loadBBox.PtMin
, new Vector3D(loadBBox.PtMax.X, loadBBox.PtMin.Y, loadBBox.PtMin.Z)
, new Vector3D(loadBBox.PtMax.X, loadBBox.PtMax.Y, loadBBox.PtMin.Z)
, new Vector3D(loadBBox.PtMin.X, loadBBox.PtMax.Y, loadBBox.PtMin.Z)
};
// length axes
HalfAxis.HAxis[] lAxes =
{
HalfAxis.HAxis.AXIS_X_P,
HalfAxis.HAxis.AXIS_Y_P,
HalfAxis.HAxis.AXIS_X_N,
HalfAxis.HAxis.AXIS_Y_N
};
// width axes
HalfAxis.HAxis[] wAxes =
{
HalfAxis.HAxis.AXIS_Y_P,
HalfAxis.HAxis.AXIS_X_N,
HalfAxis.HAxis.AXIS_Y_N,
HalfAxis.HAxis.AXIS_X_P
};
for (int i = 0; i < 4; ++i)
{
corners[i] = new Corner(0, analysisCasePallet.PalletCornerProperties)
{
Height = Math.Min(analysisCasePallet.PalletCornerProperties.Length, loadBBox.Height)
};
corners[i].SetPosition(
transform.transform(cornerPositions[i])
, HalfAxis.Transform(lAxes[i], transform), HalfAxis.Transform(wAxes[i], transform)
);
corners[i].DrawBegin(graphics);
}
}
#endregion
#region Top corners
Corner[] cornersTop = new Corner[4];
if (analysisCasePallet.HasPalletCornersTopX || analysisCasePallet.HasPalletCornersTopY)
{
double cornerWidth = analysisCasePallet.PalletCornerTopProperties.Width;
double lengthInLDir = Math.Min(analysisCasePallet.PalletCornerTopProperties.Length, loadBBox.Length - 2.0 * cornerWidth);
double widthInWDir = Math.Min(analysisCasePallet.PalletCornerTopProperties.Length, loadBBox.Width - 2.0 * cornerWidth);
double offsetInLDir = 0.5 * (loadBBox.Length - lengthInLDir);
double offsetInWdir = 0.5 * (loadBBox.Width - widthInWDir);
Transform3D upTranslation = Transform3D.Translation(new Vector3D(0.0, 0.0, -1 != Solution.SelectedLayerIndex ? DistanceAboveSelectedLayer : 0.0));
// positions
Vector3D[] cornerPositions =
{
new Vector3D(loadBBox.PtMin.X + offsetInLDir, loadBBox.PtMin.Y, loadBBox.PtMax.Z)
, new Vector3D(loadBBox.PtMax.X - offsetInLDir, loadBBox.PtMax.Y, loadBBox.PtMax.Z)
, new Vector3D(loadBBox.PtMax.X, loadBBox.PtMin.Y + offsetInWdir, loadBBox.PtMax.Z)
, new Vector3D(loadBBox.PtMin.X, loadBBox.PtMax.Y - offsetInWdir, loadBBox.PtMax.Z)
};
// length axes
HalfAxis.HAxis[] lAxes =
{
HalfAxis.HAxis.AXIS_Z_N,
HalfAxis.HAxis.AXIS_Z_N,
HalfAxis.HAxis.AXIS_Z_N,
HalfAxis.HAxis.AXIS_Z_N,
};
// width axes
HalfAxis.HAxis[] wAxes =
{
HalfAxis.HAxis.AXIS_Y_P,
HalfAxis.HAxis.AXIS_Y_N,
HalfAxis.HAxis.AXIS_X_N,
HalfAxis.HAxis.AXIS_X_P
};
for (int i = 0; i < 4; ++i)
{
cornersTop[i] = new Corner(0, analysisCasePallet.PalletCornerTopProperties)
{
Height = Math.Min(analysisCasePallet.PalletCornerTopProperties.Length, (i < 2 ? loadBBox.Length : loadBBox.Width) - 2.0 * cornerWidth)
};
cornersTop[i].SetPosition(
transform.transform(upTranslation.transform(cornerPositions[i]))
, HalfAxis.Transform(lAxes[i], transform), HalfAxis.Transform(wAxes[i], transform)
);
}
// drawing
if (analysisCasePallet.HasPalletCornersTopX)
{
for (int i = 0; i < 2; ++i)
{
cornersTop[i].DrawBegin(graphics);
}
}
if (analysisCasePallet.HasPalletCornersTopY)
{
for (int i = 2; i < 4; ++i)
{
cornersTop[i].DrawBegin(graphics);
}
}
}
#endregion
#region Pallet film
// ### pallet film
Film film = null;
if (analysisCasePallet.HasPalletFilm && -1 == Solution.SelectedLayerIndex)
{
// instantiate film
PalletFilmProperties palletFilmProperties = analysisCasePallet.PalletFilmProperties;
film = new Film(
palletFilmProperties.Color,
palletFilmProperties.UseTransparency,
palletFilmProperties.UseHatching,
palletFilmProperties.HatchSpacing,
palletFilmProperties.HatchAngle);
film.AddRectangle(new FilmRectangle(transform.transform(loadBBoxWDeco.PtMin)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_X_P, transform), HalfAxis.Transform(HalfAxis.HAxis.AXIS_Z_P, transform)
, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Height), -1.0));
film.AddRectangle(new FilmRectangle(transform.transform(loadBBoxWDeco.PtMin + loadBBoxWDeco.Length * Vector3D.XAxis)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_Y_P, transform), HalfAxis.Transform(HalfAxis.HAxis.AXIS_Z_P, transform)
, new Vector2D(loadBBoxWDeco.Width, loadBBoxWDeco.Height), -1.0));
film.AddRectangle(new FilmRectangle(transform.transform(loadBBoxWDeco.PtMin + loadBBoxWDeco.Length * Vector3D.XAxis + loadBBoxWDeco.Width * Vector3D.YAxis)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_X_N, transform), HalfAxis.Transform(HalfAxis.HAxis.AXIS_Z_P, transform)
, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Height), -1.0));
film.AddRectangle(new FilmRectangle(transform.transform(loadBBoxWDeco.PtMin + loadBBoxWDeco.Width * Vector3D.YAxis)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_Y_N, transform), HalfAxis.Transform(HalfAxis.HAxis.AXIS_Z_P, transform)
, new Vector2D(loadBBoxWDeco.Width, loadBBoxWDeco.Height), -1.0));
film.AddRectangle(new FilmRectangle(transform.transform(loadBBoxWDeco.PtMin + loadBBoxWDeco.Height * Vector3D.ZAxis)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_X_P, transform), HalfAxis.Transform(HalfAxis.HAxis.AXIS_Y_P, transform)
, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Width)
, analysisCasePallet.PalletFilmTopCovering));
film.DrawBegin(graphics);
}
#endregion
#region Pallet corners
// pallet corners : End
if (analysisCasePallet.HasPalletCorners)
{
for (int i = 0; i < 4; ++i)
{
corners[i].DrawEnd(graphics);
}
}
if (analysisCasePallet.HasPalletCornersTopX)
{
for (int i = 0; i < 2; ++i)
{
cornersTop[i].DrawEnd(graphics);
}
}
if (analysisCasePallet.HasPalletCornersTopY)
{
for (int i = 2; i < 4; ++i)
{
cornersTop[i].DrawEnd(graphics);
}
}
#endregion
#region Pallet sleeves
// ### pallet sleeve
if (analysisCasePallet.HasPalletSleeve)
{
var ps = new PalletSleeve(0, loadBBox, analysisCasePallet.PalletSleeveColor);
ps.DrawEnd(graphics);
}
#endregion
#region Pallet Cap
// ### pallet cap
if (analysisCasePallet.HasPalletCap)
{
PalletCapProperties capProperties = analysisCasePallet.PalletCapProperties;
BoxPosition bPosition = new BoxPosition(new Vector3D(
0.5 * (analysisCasePallet.PalletProperties.Length - capProperties.Length),
0.5 * (analysisCasePallet.PalletProperties.Width - capProperties.Width),
loadBBox.PtMax.Z - capProperties.InsideHeight)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_X_P, transform)
, HalfAxis.Transform(HalfAxis.HAxis.AXIS_Y_P, transform)
);
Transform3D upTranslation = Transform3D.Translation(new Vector3D(0.0, 0.0, -1 != Solution.SelectedLayerIndex ? DistanceAboveSelectedLayer : 0.0));
PalletCap cap = new PalletCap(0, capProperties, bPosition.Transform(upTranslation));
cap.DrawEnd(graphics);
}
#endregion
#region Pallet labels
// ### pallet labels
if (null != analysisCasePallet)
{
foreach (var pli in analysisCasePallet.PalletLabels)
{
var pl = new PalletLabel(++pickId, pli.PalletLabelProperties, pli.ToBoxPosition(loadBBox));
pl.DrawEnd(graphics);
}
}
#endregion
#region Strappers
// ### strappers
if (-1 == Solution.SelectedLayerIndex)
{
foreach (var sd in Solution.Strappers)
{
if (null == sd.Points && sd.Points.Count > 0)
{
var strapper = new Strapper(
transform.transform(IntToAxis(sd.Strapper.Axis)),
sd.Strapper.Width,
sd.Strapper.Color,
sd.Points.Select(p => transform.transform(p)).ToList());
strapper.DrawEnd(graphics);
}
}
}
#endregion
#region Pallet film
// pallet film : End
if (analysisCasePallet.HasPalletFilm && null != film)
{
film.DrawEnd(graphics);
}
#endregion
}
else if (analysis is AnalysisPackableTruck analysisPackableTruck2)
{
Truck truck = new Truck(analysisPackableTruck2.TruckProperties);
truck.DrawEnd(graphics);
}
else if (analysis is AnalysisPalletTruck analysisPalletTruck)
{
Truck truck = new Truck(analysisPalletTruck.TruckProperties);
truck.DrawEnd(graphics);
}
// ### dimensions
// dimensions should only be shown when no layer is selected
if (graphics.ShowDimensions && (-1 == Solution.SelectedLayerIndex))
{
graphics.AddDimensions(new DimensionCube(BoundingBoxDim(DimCasePalletSol1), Color.Black, false));
graphics.AddDimensions(new DimensionCube(BoundingBoxDim(DimCasePalletSol2), Color.Red, true));
}
// ###
}
