internal void Draw(Pack pack)
{
System.Drawing.Graphics g = Graphics;
Vector3D[] points = pack.Points;
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
// build pack
PackProperties packProperties = new PackProperties(null, SelectedBox, Arrangement, BoxOrientation, Wrapper);
if (uCtrlOuterDimensions.Checked)
packProperties.ForceOuterDimensions(
new Vector3D(uCtrlOuterDimensions.X, uCtrlOuterDimensions.Y, uCtrlOuterDimensions.Z) );
Pack pack = new Pack(0, packProperties);
pack.ForceTransparency = true;
graphics.AddBox(pack);
graphics.AddDimensions(new DimensionCube(Vector3D.Zero, pack.Length, pack.Width, pack.Height, Color.Black, true));
if (packProperties.Wrap.Transparent)
graphics.AddDimensions(
new DimensionCube(
packProperties.InnerOffset
, packProperties.InnerLength, packProperties.InnerWidth, packProperties.InnerHeight
, Color.Red, false));
}
internal void Draw(Box box)
{
System.Drawing.Graphics g = Graphics;
if (box is Pack)
{
Pack pack = box as Pack;
pack.Draw(this);
}
else
{
Vector3D[] points = box.Points;
Face[] faces = box.Faces;
for (int i = 0; i < 6; ++i)
{
// Face
Face face = faces[i];
// face normal
Vector3D normal = face.Normal;
// visible ?
if (!faces[i].IsVisible(_vTarget - _vCameraPos))
{
continue;
}
// color
faces[i].ColorFill = box.Colors[i];
double cosA = System.Math.Abs(Vector3D.DotProduct(faces[i].Normal, VLight));
Color color = Color.FromArgb((int)(faces[i].ColorFill.R * cosA), (int)(faces[i].ColorFill.G * cosA), (int)(faces[i].ColorFill.B * cosA));
// points
Vector3D[] points3D = faces[i].Points;
Point[] pt = TransformPoint(GetCurrentTransformation(), points3D);
// draw solid face
Brush brush = new SolidBrush(color);
g.FillPolygon(brush, pt);
// draw textures
if (null != face.Textures && ShowTextures)
{
foreach (Texture texture in face.Textures)
{
Point[] ptsImage = TransformPoint(GetCurrentTransformation(), box.PointsImage(i, texture));
Point[] pts = new Point[3];
pts[0] = ptsImage[3];
pts[1] = ptsImage[2];
pts[2] = ptsImage[0];
g.DrawImage(texture.Bitmap, pts);
}
}
// draw path
Brush brushPath = new SolidBrush(faces[i].ColorPath);
Pen penPathThick = new Pen(brushPath, box.IsBundle ? 2.0f : 1.5f);
int ptCount = pt.Length;
for (int j = 1; j < ptCount; ++j)
{
g.DrawLine(penPathThick, pt[j - 1], pt[j]);
}
g.DrawLine(penPathThick, pt[ptCount - 1], pt[0]);
// draw bundle lines
if (box.IsBundle && i < 4)
{
Pen penPathThin = new Pen(brushPath, 1.5f);
int noSlice = Math.Min(box.BundleFlats, 4);
for (int iSlice = 0; iSlice < noSlice - 1; ++iSlice)
{
Vector3D[] ptSlice = new Vector3D[2];
ptSlice[0] = points3D[0] + ((double)(iSlice + 1) / (double)noSlice) * (points3D[3] - points3D[0]);
ptSlice[1] = points3D[1] + ((double)(iSlice + 1) / (double)noSlice) * (points3D[2] - points3D[1]);
Point[] pt2D = TransformPoint(GetCurrentTransformation(), ptSlice);
g.DrawLine(penPathThin, pt2D[0], pt2D[1]);
}
}
}
// draw box tape
if (box.ShowTape && faces[5].IsVisible(_vTarget - _vCameraPos))
{
// get color
double cosA = System.Math.Abs(Vector3D.DotProduct(faces[5].Normal, VLight));
Color color = Color.FromArgb((int)(box.TapeColor.R * cosA), (int)(box.TapeColor.G * cosA), (int)(box.TapeColor.B * cosA));
// instantiate brush
Brush brushTape = new SolidBrush(color);
// get tape points
Point[] pts = TransformPoint(GetCurrentTransformation(), box.TapePoints);
// fill polygon
g.FillPolygon(brushTape, pts);
// draw path
Brush brushPath = new SolidBrush(faces[5].ColorPath);
Pen penPathThick = new Pen(brushPath, 1.5f);
int ptCount = pts.Length;
for (int j = 1; j < ptCount; ++j)
{
g.DrawLine(penPathThick, pts[j - 1], pts[j]);
}
g.DrawLine(penPathThick, pts[ptCount - 1], pts[0]);
}
}
if (_showBoxIds)
{
// draw box id
Point ptId = TransformPoint(GetCurrentTransformation(), box.TopFace.Center);
g.DrawString(
box.PickId.ToString()
, new Font("Arial", GridFontSize)
, Brushes.Black
, new Rectangle(ptId.X - 15, ptId.Y - 10, 30, 20)
, StringFormat.GenericDefault);
g.DrawString(
_boxDrawingCounter.ToString()
, new Font("Arial", GridFontSize)
, Brushes.Red
, new Rectangle(ptId.X + 5, ptId.Y - 10, 30, 20)
, StringFormat.GenericDefault);
}
++_boxDrawingCounter;
}
internal void Draw(Pack pack)
{
System.Drawing.Graphics g = Graphics;
Vector3D[] points = pack.Points;
}
public override void Draw(Graphics3D graphics, Transform3D transform)
{
// clear list of picking box
ClearPickingBoxes();
if (null == _solution)
{
return;
}
Analysis analysis = _solution.Analysis;
AnalysisCasePallet analysisCasePallet = analysis as AnalysisCasePallet;
AnalysisBoxCase analysisBoxCase = analysis as AnalysisBoxCase;
AnalysisCylinderCase analysisCylinderCase = analysis as AnalysisCylinderCase;
AnalysisCylinderPallet analysisCylinderPallet = analysis as AnalysisCylinderPallet;
AnalysisPalletTruck analysisPalletTruck = analysis as AnalysisPalletTruck;
AnalysisCaseTruck analysisCaseTruck = analysis as AnalysisCaseTruck;
if (null != analysisCasePallet)
{
// ### draw pallet
Pallet pallet = new Pallet(analysisCasePallet.PalletProperties);
pallet.Draw(graphics, transform);
}
else if (null != analysisBoxCase)
{
// draw case (inside)
Case case_ = new Case(analysisBoxCase.CaseProperties);
case_.DrawInside(graphics, transform);
}
else if (null != analysisCylinderCase)
{
// ### draw case (inside)
Case case_ = new Case(analysisCylinderCase.CaseProperties);
case_.DrawInside(graphics, transform);
}
else if (null != analysisCylinderPallet)
{
// ### draw pallet
Pallet pallet = new Pallet(analysisCylinderPallet.PalletProperties);
pallet.Draw(graphics, transform);
}
else if (null != analysisPalletTruck)
{
// ### draw truck
Truck truck = new Truck(analysisPalletTruck.TruckProperties);
truck.DrawBegin(graphics);
}
else if (null != analysisCaseTruck)
{
// ### draw truck
Truck truck = new Truck(analysisCaseTruck.TruckProperties);
truck.DrawBegin(graphics);
}
// ### draw solution
uint layerId = 0, pickId = 0;
List <ILayer> layers = _solution.Layers;
foreach (ILayer layer in layers)
{
BBox3D bbox = new BBox3D();
// ### layer of boxes
Layer3DBox layerBox = layer as Layer3DBox;
if (null != layerBox)
{
if (analysis.Content is LoadedPallet)
{
LoadedPallet loadedPallet = analysis.Content as LoadedPallet;
BBox3D solBBox = loadedPallet.ParentAnalysis.Solution.BBoxGlobal;
foreach (BoxPosition bPosition in layerBox)
{
bool simplified = false;
if (simplified)
{
BoxProperties bProperties = new BoxProperties(null, solBBox.Dimensions);
bProperties.SetColor(Color.Chocolate);
Box b = new Box(pickId++, bProperties, bPosition.Transform(transform));
graphics.AddBox(b);
bbox.Extend(b.BBox);
}
else
{
graphics.AddImage(loadedPallet.ParentAnalysis, solBBox.DimensionsVec, bPosition.Transform(transform));
}
}
}
else
{
bool aboveSelectedLayer = (_solution.SelectedLayerIndex != -1) && (layerId > _solution.SelectedLayerIndex);
Transform3D upTranslation = Transform3D.Translation(new Vector3D(0.0, 0.0, aboveSelectedLayer ? DistanceAboveSelectedLayer : 0.0));
foreach (BoxPosition bPosition in layerBox)
{
BoxPosition boxPositionModified = bPosition.Transform(transform * upTranslation);
Box b = null;
if (analysis.Content is PackProperties)
{
b = new Pack(pickId++, analysis.Content as PackProperties, boxPositionModified);
}
else
{
b = new Box(pickId++, analysis.Content as PackableBrick, boxPositionModified);
}
graphics.AddBox(b);
bbox.Extend(b.BBox);
}
}
}
Layer3DCyl layerCyl = layer as Layer3DCyl;
if (null != layerCyl)
{
foreach (Vector3D vPos in layerCyl)
{
Cylinder c = new Cylinder(pickId++, analysis.Content as CylinderProperties, new CylPosition(transform.transform(vPos), HalfAxis.HAxis.AXIS_Z_P));
graphics.AddCylinder(c);
bbox.Extend(c.BBox);
}
}
if (null != layerBox || null != layerCyl)
{
// add layer BBox
AddPickingBox(bbox, layerId);
// draw bounding box around selected layer
if (layerId == _solution.SelectedLayerIndex)
{
DrawLayerBoundingBox(graphics, bbox);
}
++layerId;
}
// ### interlayer
if (layer is InterlayerPos interlayerPos)
{
InterlayerProperties interlayerProp = _solution.Interlayers[interlayerPos.TypeId];
if (null != interlayerProp)
{
bool aboveSelectedLayer = (_solution.SelectedLayerIndex != -1) && (layerId > _solution.SelectedLayerIndex);
Transform3D upTranslation = Transform3D.Translation(new Vector3D(0.0, 0.0, aboveSelectedLayer ? DistanceAboveSelectedLayer : 0.0));
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);
Box box = new Box(pickId++, interlayerProp, bPosition.Transform(transform * upTranslation));
graphics.AddBox(box);
bbox.Extend(box.BBox);
}
}
}
BBox3D loadBBox = _solution.BBoxLoad;
BBox3D loadBBoxWDeco = _solution.BBoxLoadWDeco;
if (null != 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
};
// corners
if (analysisCasePallet.HasPalletCorners)
{
for (int i = 0; i < 4; ++i)
{
corners[i] = new Corner(0, analysisCasePallet.PalletCornerProperties);
corners[i].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 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), 0.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), 0.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), 0.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), 0.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)
, UnitsManager.ConvertLengthFrom(200.0, UnitsManager.UnitSystem.UNIT_METRIC1)));
film.DrawBegin(graphics);
}
#endregion
#region Pallet corners
// pallet corners : End
if (analysisCasePallet.HasPalletCorners)
{
for (int i = 0; i < 4; ++i)
{
corners[i].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 film
// pallet film : End
if (analysisCasePallet.HasPalletFilm && null != film)
{
film.DrawEnd(graphics);
}
#endregion
}
if (null != analysisPalletTruck)
{
Truck truck = new Truck(analysisPalletTruck.TruckProperties);
truck.DrawEnd(graphics);
}
else if (null != analysisCaseTruck)
{
Truck truck = new Truck(analysisCaseTruck.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));
}
}
private void AppendPackElement(PackProperties packProperties, XmlElement elemPackAnalysis, XmlDocument xmlDoc)
{
string ns = xmlDoc.DocumentElement.NamespaceURI;
// pack element
XmlElement elemPack = CreateElement("pack", null, elemPackAnalysis, xmlDoc, ns);
// name
CreateElement("name", packProperties.Name, elemPack, xmlDoc, ns);
// description
CreateElement("description", packProperties.Description, elemPack, xmlDoc, ns);
// arrangement
PackArrangement arrangement = packProperties.Arrangement;
CreateElement(
"arrangement"
, string.Format("{0} * {1} * {2}", arrangement.Length, arrangement.Width, arrangement.Height)
, elemPack, xmlDoc, ns);
// length / width /height
AppendElementValue(xmlDoc, elemPack, "length", UnitsManager.UnitType.UT_LENGTH, packProperties.Length);
AppendElementValue(xmlDoc, elemPack, "width", UnitsManager.UnitType.UT_LENGTH, packProperties.Width);
AppendElementValue(xmlDoc, elemPack, "height", UnitsManager.UnitType.UT_LENGTH, packProperties.Height);
// weight
AppendElementValue(xmlDoc, elemPack, "netWeight", UnitsManager.UnitType.UT_MASS, packProperties.NetWeight);
AppendElementValue(xmlDoc, elemPack, "wrapperWeight", UnitsManager.UnitType.UT_MASS, packProperties.Wrap.Weight);
AppendElementValue(xmlDoc, elemPack, "weight", UnitsManager.UnitType.UT_MASS, packProperties.Weight);
// --- build image
Graphics3DImage graphics = new Graphics3DImage(new Size(ImageSizeDetail, ImageSizeDetail));
graphics.CameraPosition = Graphics3D.Corner_0;
graphics.Target = Vector3D.Zero;
Pack pack = new Pack(0, packProperties);
pack.ForceTransparency = true;
graphics.AddBox(pack);
DimensionCube dc = new DimensionCube(pack.Length, pack.Width, pack.Height); dc.FontSize = 6.0f;
graphics.AddDimensions(dc);
graphics.Flush();
// view_pack_iso
XmlElement elemImage = xmlDoc.CreateElement("view_pack_iso", ns);
TypeConverter converter = TypeDescriptor.GetConverter(typeof(Bitmap));
elemImage.InnerText = Convert.ToBase64String((byte[])converter.ConvertTo(graphics.Bitmap, typeof(byte[])));
XmlAttribute styleAttribute = xmlDoc.CreateAttribute("style");
styleAttribute.Value = string.Format("width:{0}pt;height:{1}pt", graphics.Bitmap.Width / 4, graphics.Bitmap.Height / 4);
elemImage.Attributes.Append(styleAttribute);
elemPack.AppendChild(elemImage);
// save image
SaveImageAs(graphics.Bitmap, "view_pack_iso.png");
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
try
{
Graphics = new Graphics2DForm(this, e.Graphics);
if (null == Layer)
{
return;
}
Graphics.SetViewport(PtMin, PtMax);
uint pickId = 0;
foreach (var bp in Layer.Positions)
{
Box b;
if (Content is PackProperties pack)
{
b = new Pack(pickId++, pack, bp);
}
else
{
b = new Box(pickId++, Content as PackableBrick, bp);
}
b.Draw(Graphics);
}
Graphics.DrawRectangle(Vector2D.Zero, Layer.DimContainer, Color.OrangeRed);
if (-1 != SelectedIndex)
{
var bp = Layer.Positions[SelectedIndex];
Box boxSelected;
if (Content is PackProperties pack)
{
boxSelected = new Pack((uint)SelectedIndex, pack, bp);
}
else
{
boxSelected = new Box(((uint)SelectedIndex), Content as PackableBrick, bp);
}
Graphics.DrawBoxSelected(boxSelected);
ArrowButtons.Clear();
Vector2D ptCenter = new Vector2D(boxSelected.Center.X, boxSelected.Center.Y);
// draw translation arrows
for (int i = 0; i < 4; ++i)
{
if (Arrows[i])
{
Graphics.DrawArrow(ptCenter, i, 100, 5, 10, Color.Red, out Rectangle rect);
ArrowButtons.Add(i, rect);
}
}
// draw rotation arrows
if (ArrowRotate)
{
Graphics.DrawArcArrow(ptCenter, 75, 10, Color.Red, out _rotateRectangle);
}
// draw position
Graphics.DrawText($"({bp.Position.X:0.##}, {bp.Position.Y:0.##}, {bp.Position.Z:0.##}), {HalfAxis.ToString(bp.DirectionLength)}, {HalfAxis.ToString(bp.DirectionWidth)}", 16);
}
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
