/// <summary>
/// Draw layers
/// Images are used during report generation
/// </summary>
public void DrawLayers(Graphics3D graphics, bool showPallet, int layerIndex)
{
if (null == _caseSolution)
{
throw new Exception("No solution defined!");
}
BoxCasePalletAnalysis caseAnalysis = _caseSolution.ParentCaseAnalysis;
// draw solution
uint pickId = 0;
int iLayer = 0, iLayerCount = 0;
while (iLayerCount <= layerIndex && iLayer < _caseSolution.Count)
{
ILayer layer = _caseSolution[iLayer];
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Box(pickId++, caseAnalysis.BoxProperties, bPosition));
}
++iLayerCount;
}
++iLayer;
}
}
public void Draw(Graphics3D graphics)
{
if (null == _caseDefinition || null == _boxProperties)
return;
// get global transformation
Transform3D transf = _globalOrientation.Transformation;
// draw case (back faces)
Case case_ = _caseProperties != null ? new Case(_caseProperties, transf) : null;
if (null != case_)
{
// draw case (inside)
case_.DrawInside(graphics);
}
// add boxes
uint pickId = 0;
for (int i=0; i<_caseDefinition.Arrangement._iLength; ++i)
for (int j=0; j<_caseDefinition.Arrangement._iWidth; ++j)
for (int k = 0; k < _caseDefinition.Arrangement._iHeight; ++k)
graphics.AddBox( new Box(pickId++, _boxProperties, GetPosition(i, j, k, _caseDefinition.Dim0, _caseDefinition.Dim1) ) );
if (_showDimentions)
{
// add external dimensions
Vector3D outerDimensions = _caseDefinition.OuterDimensions(_boxProperties, _caseOptimConstraintSet);
graphics.AddDimensions(DimensionCube.Transform(new DimensionCube(Vector3D.Zero, outerDimensions.X, outerDimensions.Y, outerDimensions.Z, Color.Black, true), transf));
// add inner dimensions
Vector3D innerOffset = _caseDefinition.InnerOffset(_caseOptimConstraintSet);
Vector3D innerDimensions = _caseDefinition.InnerDimensions(_boxProperties);
graphics.AddDimensions(DimensionCube.Transform(new DimensionCube(innerOffset, innerDimensions.X, innerDimensions.Y, innerDimensions.Z, Color.Red, false), transf));
}
}
public override void Draw(Graphics3D graphics)
{
foreach (Face face in Faces)
{
graphics.AddFace(face);
}
}
public override void DrawEnd(Graphics3D graph)
{
foreach (FilmRectangle rectangle in _rectangles)
{
double cosA = System.Math.Abs(Vector3D.DotProduct(rectangle.Normal, graph.ViewDirection));
Color color = Color.FromArgb(
255
, (int)(rectangle.Color.R * cosA)
, (int)(rectangle.Color.G * cosA)
, (int)(rectangle.Color.B * cosA));
if (Vector3D.DotProduct(rectangle.Normal, graph.ViewDirection) < 0)
{
// transparency
if (HasTransparency)
{
foreach (Face face in rectangle.Faces)
graph.AddFace(face);
}
// hatching
if (HasHatching)
{
Segment[] segments = rectangle.Segments;
foreach (Segment s in segments)
{
s.Color = color;
graph.AddSegment(s);
}
}
}
}
}
public override void DrawEnd(Graphics3D graphics)
{
Vector3D viewDir = graphics.ViewDirection;
int[] seg0 = null, seg1 = null, seg2 = null;
if (viewDir.X < 0.0 && viewDir.Y >= 0.0)
{
seg0 = new int[2] {
4, 5
};
seg1 = new int[2] {
5, 6
};
seg2 = new int[2] {
1, 5
};
}
else if (viewDir.X < 0.0 && viewDir.Y < 0.0)
{
seg0 = new int[2] {
5, 6
};
seg1 = new int[2] {
6, 7
};
seg2 = new int[2] {
2, 6
};
}
else if (viewDir.X >= 0.0 && viewDir.Y < 0.0)
{
seg0 = new int[2] {
6, 7
};
seg1 = new int[2] {
7, 4
};
seg2 = new int[2] {
3, 7
};
}
else if (viewDir.X >= 0.0 && viewDir.Y >= 0.0)
{
seg0 = new int[2] {
7, 4
};
seg1 = new int[2] {
4, 5
};
seg2 = new int[2] {
0, 4
};
}
graphics.AddSegment(new Segment(Points[seg0[0]], Points[seg0[1]], _colorPath));
graphics.AddSegment(new Segment(Points[seg1[0]], Points[seg1[1]], _colorPath));
graphics.AddSegment(new Segment(Points[seg2[0]], Points[seg2[1]], _colorPath));
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
TruckProperties truckProp = _sol.ParentTruckAnalysis.TruckProperties;
graphics.AddDimensions(new DimensionCube(_sol.LoadBoundingBox, Color.Red, false));
graphics.AddDimensions(new DimensionCube(Vector3D.Zero, truckProp.Length, truckProp.Width, truckProp.Height, Color.Black, true));
// draw solution
TruckSolutionViewer sv = new TruckSolutionViewer(_sol);
sv.Draw(graphics);
}
/// <summary>
/// Use this method when drawing a solution that belongs an analysis
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _solution)
{
return;
}
// initialize Graphics3D object
if (!graphics.ShowBoxIds)
{
// draw pallet
Pallet pallet = new Pallet(_analysis.PalletProperties);
pallet.Draw(graphics, Transform3D.Identity);
}
// draw solution
uint pickId = 0;
foreach (ILayer layer in _solution)
{
CylinderLayer cylLayer = layer as CylinderLayer;
if (null != cylLayer)
{
foreach (Vector3D pos in cylLayer)
{
graphics.AddCylinder(
new Cylinder(pickId++, _analysis.CylinderProperties, new CylPosition(pos, HalfAxis.HAxis.AXIS_Z_P))
);
}
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
Box box = new Box(pickId++, _analysis.InterlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - _analysis.InterlayerProperties.Length)
, 0.5 * (_analysis.PalletProperties.Width - _analysis.InterlayerProperties.Width)
, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
if (_showDimensions)
{
if (_showDimensions)
{
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol1)
, Color.Black, false));
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol2)
, Color.Red, true));
}
}
}
public void Draw(Graphics3D graphics)
{
int[] arrow0 = null;
int[] arrow1 = null;
int[] arrow2 = null;
ArrowPoints(graphics, out arrow0, out arrow1, out arrow2);
DrawArrow(arrow0, graphics);
DrawArrow(arrow1, graphics);
DrawArrow(arrow2, graphics);
}
public void DrawInside(Graphics3D graphics)
{
Face[] faces = Faces;
for (int i = 0; i < 6; ++i)
{
faces[i].IsSolid = false;
}
foreach (Face face in faces)
{
graphics.AddFace(face);
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
try
{
// instantiate solution viewer
CasePalletSolutionViewer sv = new CasePalletSolutionViewer(CurrentSolution);
sv.Draw(graphics);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
public override void DrawBegin(Graphics3D graph)
{
foreach (FilmRectangle rectangle in _rectangles)
if (Vector3D.DotProduct(rectangle.Normal, graph.ViewDirection) > 0)
{
// hatching
if (HasHatching)
{
Segment[] segments = rectangle.Segments;
foreach (Segment s in segments)
graph.AddSegmentBackgound(s);
}
}
}
/// <summary>
/// Use this method when drawing a solution that belongs an analysis
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _solution)
return;
// initialize Graphics3D object
if (!graphics.ShowBoxIds)
{
// draw pallet
Pallet pallet = new Pallet(_analysis.PalletProperties);
pallet.Draw(graphics, Transform3D.Identity);
}
// draw solution
uint pickId = 0;
foreach (ILayer layer in _solution)
{
CylinderLayer cylLayer = layer as CylinderLayer;
if (null != cylLayer)
{
foreach (Vector3D pos in cylLayer)
graphics.AddCylinder(
new Cylinder(pickId++, _analysis.CylinderProperties, new CylPosition(pos, HalfAxis.HAxis.AXIS_Z_P))
);
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
Box box = new Box(pickId++, _analysis.InterlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - _analysis.InterlayerProperties.Length)
, 0.5 * (_analysis.PalletProperties.Width - _analysis.InterlayerProperties.Width)
, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
if (_showDimensions)
{
if (_showDimensions)
{
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol1)
, Color.Black, false));
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol2)
, Color.Red, true));
}
}
}
public void Draw(Graphics3D graphics)
{
// sanity check
if (null == _solution)
{
return;
}
InterlayerProperties interlayerProperties = _analysis.InterlayerProperties;
// draw pallet
Pallet pallet = new Pallet(_analysis.PalletProperties);
pallet.Draw(graphics, Transform3D.Identity);
// draw solution
uint pickid = 0;
for (int iLayerIndex = 0; iLayerIndex < _solution.LayerCount; ++iLayerIndex)
{
bool hasInterlayer = false;
double zInterlayer = 0.0;
BoxLayer blayer = _solution.GetBoxLayer(iLayerIndex, ref hasInterlayer, ref zInterlayer);
if (hasInterlayer && (null != interlayerProperties))
{
// instantiate box
Box box = new Box(pickid++, interlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - interlayerProperties.Length)
, 0.5 * (_analysis.PalletProperties.Width - interlayerProperties.Width)
, zInterlayer);
// draw
graphics.AddBox(box);
}
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Pack(pickid++, _analysis.PackProperties, bPosition));
}
if (_showDimensions)
{
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol1)
, Color.Black, false));
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol2)
, Color.Red, true));
}
}
}
/// <summary>
/// Use this method when solution does not refer an analysis (e.g. when displaying CaseOptimizer result)
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _boxCaseSolution)
{
throw new Exception("No box/case solution defined!");
}
BoxCaseAnalysis boxCaseAnalysis = _boxCaseSolution.Analysis;
// retrieve case properties
BProperties boxProperties = boxCaseAnalysis.BProperties;
if (null == boxProperties)
{
return;
}
BoxProperties caseProperties = boxCaseAnalysis.CaseProperties;
// draw case (inside)
Case case_ = new Case(caseProperties);
case_.DrawInside(graphics);
// draw solution
uint pickId = 0;
foreach (ILayer layer in _boxCaseSolution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Box(pickId++, boxProperties, bPosition));
}
}
}
// get case analysis
if (_showDimensions)
{
graphics.AddDimensions(new DimensionCube(
Vector3D.Zero
, caseProperties.Length, caseProperties.Width, caseProperties.Height
, System.Drawing.Color.Black
, true));
graphics.AddDimensions(new DimensionCube(
_boxCaseSolution.LoadBoundingBox
, System.Drawing.Color.Red
, false));
}
}
/// <summary>
/// Draw case solution
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _caseSolution)
throw new Exception("No case solution defined!");
// load pallet solution
BoxProperties caseProperties;
CasePalletSolution palletSolution = _caseSolution.PalletSolutionDesc.LoadPalletSolution();
if (null == palletSolution)
caseProperties = new BoxProperties(null, _caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight);
else
{
CasePalletAnalysis palletAnalysis = palletSolution.Analysis;
// retrieve case properties
caseProperties = palletAnalysis.BProperties as BoxProperties;
}
if (null == caseProperties) return;
// draw case (inside)
Case case_ = new Case(caseProperties);
case_.DrawInside(graphics);
// get case analysis
BoxCasePalletAnalysis caseAnalysis = _caseSolution.ParentCaseAnalysis;
// draw solution
uint pickId = 0;
foreach (ILayer layer in _caseSolution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
graphics.AddBox(new Box(pickId++, caseAnalysis.BoxProperties, bPosition));
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
Box box = new Box(pickId++, caseAnalysis.InterlayerProperties);
// set position
box.Position = new Vector3D(0.0, 0.0, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
// get case analysis
if (_showDimensions)
graphics.AddDimensions(new DimensionCube(_caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight));
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (null == _dt)
return;
DataCase dtCase = _dt as DataCase;
if (null != dtCase)
{
Box b = new Box(0, ToCase(dtCase));
graphics.AddBox(b);
graphics.AddDimensions(new DimensionCube(dtCase.OuterDimensions));
}
DataBox dtBox = _dt as DataBox;
if (null != dtBox)
{
Box b = new Box(0, ToBox(dtBox));
graphics.AddBox(b);
graphics.AddDimensions(new DimensionCube(dtBox.Dimensions));
}
DataPallet dtPallet = _dt as DataPallet;
if (null != dtPallet)
{
Pallet pallet = new Pallet(ToPallet(dtPallet));
pallet.Draw(graphics, Sharp3D.Math.Core.Transform3D.Identity);
graphics.AddDimensions(new DimensionCube(dtPallet.Dimensions));
}
DataInterlayer dtInterlayer = _dt as DataInterlayer;
if (null != dtInterlayer)
{
graphics.AddBox(new Box(0, ToInterlayer(dtInterlayer)));
graphics.AddDimensions(new DimensionCube(dtInterlayer.Dimensions));
}
DataPalletCap dtPalletCap = _dt as DataPalletCap;
if (null != dtPalletCap)
{
PalletCap palletCap = new PalletCap(0, ToPalletCap(dtPalletCap), Sharp3D.Math.Core.Vector3D.Zero);
palletCap.Draw(graphics);
graphics.AddDimensions(new DimensionCube(dtPalletCap.Dimensions));
}
DataCylinder dtCylinder = _dt as DataCylinder;
if (null != dtCylinder)
{
Cylinder cyl = new Cylinder(0, ToCylinder(dtCylinder));
graphics.AddCylinder(cyl);
}
}
public override void DrawBegin(Graphics3D graph)
{
foreach (FilmRectangle rectangle in _rectangles)
{
if (Vector3D.DotProduct(rectangle.Normal, graph.ViewDirection) > 0)
{
// hatching
if (HasHatching)
{
Segment[] segments = rectangle.Segments;
foreach (Segment s in segments)
{
graph.AddSegmentBackgound(s);
}
}
}
}
}
public override void DrawEnd(Graphics3D graphics)
{
Face[] faces = Faces;
if (Vector3D.DotProduct(faces[0].Normal, graphics.ViewDirection) <= 0.0)
{
for (int i = 0; i < 4; ++i)
{
graphics.AddFace(faces[i]);
}
}
if (Vector3D.DotProduct(faces[4].Normal, graphics.ViewDirection) <= 0.0)
{
for (int i = 4; i < 8; ++i)
{
graphics.AddFace(faces[i]);
}
}
}
public Vector3D[] DrawingPoints(Graphics3D graphics)
{
int[] arrow0 = null;
int[] arrow1 = null;
int[] arrow2 = null;
ArrowPoints(graphics, out arrow0, out arrow1, out arrow2);
const double exageration = 1.2;
Vector3D[] pts = new Vector3D[6];
pts[0] = _pts[arrow0[0]] + (_pts[arrow0[0]] - _pts[arrow0[2]]) * offsetPerc * exageration;
pts[1] = _pts[arrow0[1]] + (_pts[arrow0[1]] - _pts[arrow0[3]]) * offsetPerc * exageration;
pts[2] = _pts[arrow1[0]] + (_pts[arrow1[0]] - _pts[arrow1[2]]) * offsetPerc * exageration;
pts[3] = _pts[arrow1[1]] + (_pts[arrow1[1]] - _pts[arrow1[3]]) * offsetPerc * exageration;
pts[4] = _pts[arrow2[0]] + (_pts[arrow2[0]] - _pts[arrow2[2]]) * offsetPerc * exageration;
pts[5] = _pts[arrow2[1]] + (_pts[arrow2[1]] - _pts[arrow2[3]]) * offsetPerc * exageration;
return(pts);
}
/// <summary>
/// Use this method when solution does not refer an analysis (e.g. when displaying CaseOptimizer result)
/// </summary>
public static void Draw(Graphics3D graphics
, CasePalletSolution solution
, BoxProperties boxProperties, InterlayerProperties interlayerProperties, PalletProperties palletProperties)
{
// draw pallet
Pallet pallet = new Pallet(palletProperties);
pallet.Draw(graphics, Transform3D.Identity);
// draw solution
uint pickId = 0;
foreach (ILayer layer in solution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Box(pickId++, boxProperties, bPosition));
}
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos && null != interlayerProperties)
{
Box box = new Box(pickId++, interlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (palletProperties.Length - interlayerProperties.Length)
, 0.5 * (palletProperties.Width - interlayerProperties.Width)
, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
// always show dimensions
BoxLayer bLayer = solution[solution.Count - 1] as BoxLayer;
double palletHeight = solution[solution.Count - 1].ZLow + (null != bLayer ? bLayer.Thickness(boxProperties) : 0.0);
// show dimensions
graphics.AddDimensions(new DimensionCube(solution.BoundingBox, Color.Black, false));
graphics.AddDimensions(new DimensionCube(solution.LoadBoundingBox, Color.Red, true));
}
public override void Draw(Graphics3D graphics)
{
// draw tray back faces
if (_packProperties.Wrap.Type == PackWrapper.WType.WT_TRAY)
{
}
// draw inner boxes
if (_packProperties.Wrap.Type == PackWrapper.WType.WT_POLYETHILENE ||
_packProperties.Wrap.Type == PackWrapper.WType.WT_TRAY ||
_forceTransparency)
{
List <Box> boxes = InnerBoxes;
boxes.Sort(new BoxComparerSimplifiedPainterAlgo(graphics.GetWorldToEyeTransformation()));
foreach (Box b in boxes)
{
graphics.Draw(b);
}
}
if (_packProperties.Wrap.Type != PackWrapper.WType.WT_TRAY)
{
// draw front faces
foreach (Face f in Faces)
{
graphics.Draw(
f
, Graphics3D.FaceDir.FRONT
, _packProperties.Wrap.Color
, _packProperties.Wrap.Transparent || _forceTransparency);
}
}
else
{
// draw tray front faces
foreach (Face f in TrayFaces)
{
graphics.Draw(
f
, Graphics3D.FaceDir.FRONT
, _packProperties.Wrap.Color
, _packProperties.Wrap.Transparent);
}
}
}
public void Draw(Graphics3D graphics)
{
if (null == _caseDefinition || null == _boxProperties)
{
return;
}
// get global transformation
Transform3D transf = _globalOrientation.Transformation;
// draw case (back faces)
Case case_ = _caseProperties != null ? new Case(_caseProperties, transf) : null;
if (null != case_)
{
// draw case (inside)
case_.DrawInside(graphics);
}
// add boxes
uint pickId = 0;
for (int i = 0; i < _caseDefinition.Arrangement._iLength; ++i)
{
for (int j = 0; j < _caseDefinition.Arrangement._iWidth; ++j)
{
for (int k = 0; k < _caseDefinition.Arrangement._iHeight; ++k)
{
graphics.AddBox(new Box(pickId++, _boxProperties, GetPosition(i, j, k, _caseDefinition.Dim0, _caseDefinition.Dim1)));
}
}
}
if (_showDimentions)
{
// add external dimensions
Vector3D outerDimensions = _caseDefinition.OuterDimensions(_boxProperties, _caseOptimConstraintSet);
graphics.AddDimensions(DimensionCube.Transform(new DimensionCube(Vector3D.Zero, outerDimensions.X, outerDimensions.Y, outerDimensions.Z, Color.Black, true), transf));
// add inner dimensions
Vector3D innerOffset = _caseDefinition.InnerOffset(_caseOptimConstraintSet);
Vector3D innerDimensions = _caseDefinition.InnerDimensions(_boxProperties);
graphics.AddDimensions(DimensionCube.Transform(new DimensionCube(innerOffset, innerDimensions.X, innerDimensions.Y, innerDimensions.Z, Color.Red, false), transf));
}
}
public void Draw(Graphics3D graphics)
{
// sanity check
if (null == _solution) return;
InterlayerProperties interlayerProperties = _analysis.InterlayerProperties;
// draw pallet
Pallet pallet = new Pallet(_analysis.PalletProperties);
pallet.Draw(graphics, Transform3D.Identity);
// draw solution
uint pickid = 0;
for (int iLayerIndex = 0; iLayerIndex < _solution.LayerCount; ++iLayerIndex)
{
bool hasInterlayer = false;
double zInterlayer = 0.0;
BoxLayer blayer = _solution.GetBoxLayer(iLayerIndex, ref hasInterlayer, ref zInterlayer);
if (hasInterlayer && (null != interlayerProperties))
{
// instantiate box
Box box = new Box(pickid++, interlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - interlayerProperties.Length)
, 0.5 * (_analysis.PalletProperties.Width - interlayerProperties.Width)
, zInterlayer);
// draw
graphics.AddBox(box);
}
foreach (BoxPosition bPosition in blayer)
graphics.AddBox(new Pack(pickid++, _analysis.PackProperties, bPosition));
if (_showDimensions)
{
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol1)
, Color.Black, false));
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol2)
, Color.Red, true));
}
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (ctrl == graphCtrlPallet)
{
// instantiate solution viewer
CasePalletSolutionViewer sv = new CasePalletSolutionViewer(GetCurrentSolution());
sv.Draw(graphics);
}
else if (ctrl == graphCtrlCase)
{
// get case of boxes
CaseOfBoxesProperties caseOfBoxes = _analysis.BProperties as CaseOfBoxesProperties;
// draw
CaseDefinitionViewer cdv = new CaseDefinitionViewer(caseOfBoxes.CaseDefinition, caseOfBoxes.InsideBoxProperties, caseOfBoxes.CaseOptimConstraintSet);
cdv.CaseProperties = caseOfBoxes;
cdv.Orientation = GetCurrentSolution().FirstCaseOrientation;
cdv.Draw(graphics);
}
}
public void DrawLayer(Graphics3D graphics, int layerIndex)
{
// sanity check
if (null == _solution)
{
return;
}
if (_showDimensions)
{
BoxLayer layer = layerIndex % 2 == 0 ? _solution.Layer : _solution.LayerSwapped;
uint pickId = 0;
foreach (BoxPosition bPosition in layer)
{
graphics.AddBox(new Pack(pickId++, _solution.Analysis.PackProperties, bPosition));
}
graphics.AddDimensions(
new DimensionCube(layer.BoundingBox(_solution.Analysis.PackProperties)
, Color.Black, false));
}
}
/// <summary>
/// Use this method when solution does not refer an analysis (e.g. when displaying CaseOptimizer result)
/// </summary>
public static void Draw(Graphics3D graphics
, CasePalletSolution solution
, BoxProperties boxProperties, InterlayerProperties interlayerProperties, PalletProperties palletProperties)
{
// draw pallet
Pallet pallet = new Pallet(palletProperties);
pallet.Draw(graphics, Transform3D.Identity);
// draw solution
uint pickId = 0;
foreach (ILayer layer in solution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
graphics.AddBox(new Box(pickId++, boxProperties, bPosition));
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos && null != interlayerProperties)
{
Box box = new Box(pickId++, interlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (palletProperties.Length - interlayerProperties.Length)
, 0.5 * (palletProperties.Width - interlayerProperties.Width)
, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
// always show dimensions
BoxLayer bLayer = solution[solution.Count - 1] as BoxLayer;
double palletHeight = solution[solution.Count - 1].ZLow + (null != bLayer ? bLayer.Thickness(boxProperties) : 0.0);
// show dimensions
graphics.AddDimensions(new DimensionCube(solution.BoundingBox, Color.Black, false));
graphics.AddDimensions(new DimensionCube(solution.LoadBoundingBox, Color.Red, true));
}
/// <summary>
/// Use this method when solution does not refer an analysis (e.g. when displaying CaseOptimizer result)
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _boxCaseSolution)
throw new Exception("No box/case solution defined!");
BoxCaseAnalysis boxCaseAnalysis = _boxCaseSolution.Analysis;
// retrieve case properties
BProperties boxProperties = boxCaseAnalysis.BProperties;
if (null == boxProperties) return;
BoxProperties caseProperties = boxCaseAnalysis.CaseProperties;
// draw case (inside)
Case case_ = new Case(caseProperties);
case_.DrawInside(graphics);
// draw solution
uint pickId = 0;
foreach (ILayer layer in _boxCaseSolution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
graphics.AddBox(new Box(pickId++, boxProperties, bPosition));
}
}
// get case analysis
if (_showDimensions)
{
graphics.AddDimensions(new DimensionCube(
Vector3D.Zero
, caseProperties.Length, caseProperties.Width, caseProperties.Height
, System.Drawing.Color.Black
, true));
graphics.AddDimensions(new DimensionCube(
_boxCaseSolution.LoadBoundingBox
, System.Drawing.Color.Red
, false));
}
}
private void DrawArrow(int[] arrow, Graphics3D graphics)
{
Vector3D pt0 = _pts[arrow[0]];
Vector3D pt0_ = pt0 + (pt0 - _pts[arrow[2]]) * offsetPerc;
Vector3D pt00_ = pt0 + (pt0 - _pts[arrow[2]]) * offsetPerc * 1.1;
Vector3D pt1 = _pts[arrow[1]];
Vector3D pt1_ = pt1 + (pt1 - _pts[arrow[3]]) * offsetPerc;
Vector3D pt11_ = pt1 + (pt1 - _pts[arrow[3]]) * offsetPerc * 1.1;
if ((pt1 - pt0).GetLengthSquared() < 1.0E-03)
{
return;
}
string text = string.Format("{0:0.0}", (pt1 - pt0).GetLength());
graphics.Draw(text, 0.5 * (pt1_ + pt0_), _color, _fontSize);
graphics.Draw(new Segment(pt0_, pt0_ + (pt1 - pt0) * (2.0 / 5.0), _color));
graphics.Draw(new Segment(pt0_ + (pt1 - pt0) * (3.0 / 5.0), pt1_, _color));
graphics.Draw(new Segment(pt0, pt00_, _color));
graphics.Draw(new Segment(pt1, pt11_, _color));
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (null == CurrentSolution) return;
BoxCaseSolutionViewer sv = new BoxCaseSolutionViewer(CurrentSolution);
sv.Draw(graphics);
}
public override void DrawBegin(Graphics3D graphics)
{
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
BoxProperties boxProperties = new BoxProperties(null, (double)nudLength.Value, (double)nudWidth.Value, (double)nudHeight.Value);
boxProperties.SetAllColors(_faceColors);
boxProperties.TextureList = _textures;
boxProperties.ShowTape = ShowTape;
boxProperties.TapeColor = TapeColor;
boxProperties.TapeWidth = TapeWidth;
Box box = new Box(0, boxProperties);
graphics.AddBox(box);
graphics.AddDimensions(new DimensionCube((double)nudLength.Value, (double)nudWidth.Value, (double)nudHeight.Value));
}
public abstract void Draw(Graphics3D graphics);
public Vector3D[] DrawingPoints(Graphics3D graphics)
{
int[] arrow0 = null;
int[] arrow1 = null;
int[] arrow2 = null;
ArrowPoints(graphics, out arrow0, out arrow1, out arrow2);
const double exageration = 1.2;
Vector3D[] pts = new Vector3D[6];
pts[0] = _pts[arrow0[0]] + (_pts[arrow0[0]] - _pts[arrow0[2]]) * offsetPerc * exageration;
pts[1] = _pts[arrow0[1]] + (_pts[arrow0[1]] - _pts[arrow0[3]]) * offsetPerc * exageration;
pts[2] = _pts[arrow1[0]] + (_pts[arrow1[0]] - _pts[arrow1[2]]) * offsetPerc * exageration;
pts[3] = _pts[arrow1[1]] + (_pts[arrow1[1]] - _pts[arrow1[3]]) * offsetPerc * exageration;
pts[4] = _pts[arrow2[0]] + (_pts[arrow2[0]] - _pts[arrow2[2]]) * offsetPerc * exageration;
pts[5] = _pts[arrow2[1]] + (_pts[arrow2[1]] - _pts[arrow2[3]]) * offsetPerc * exageration;
return pts;
}
private void ArrowPoints(Graphics3D graphics, out int[] arrow0, out int[] arrow1, out int[] arrow2)
{
Vector3D viewDir = graphics.ViewDirection;
arrow0 = null;
arrow1 = null;
arrow2 = null;
if (!_above)
{
if (viewDir.X < 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] { 0, 4, 1, 5 };
arrow1 = new int[4] { 0, 1, 3, 2 };
arrow2 = new int[4] { 1, 2, 0, 3 };
}
else if (viewDir.X < 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] { 1, 5, 2, 6 };
arrow1 = new int[4] { 1, 2, 0, 3 };
arrow2 = new int[4] { 2, 3, 1, 0 };
}
else if (viewDir.X >= 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] { 2, 6, 3, 7 };
arrow1 = new int[4] { 2, 3, 1, 0 };
arrow2 = new int[4] { 3, 0, 2, 1 };
}
else if (viewDir.X >= 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] { 3, 7, 0, 4 };
arrow1 = new int[4] { 3, 0, 2, 1 };
arrow2 = new int[4] { 0, 1, 3, 2 };
}
}
else
{
if (viewDir.X < 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] { 2, 6, 3, 7 };
arrow1 = new int[4] { 7, 6, 4, 5 };
arrow2 = new int[4] { 4, 7, 5, 6 };
}
else if (viewDir.X < 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] { 3, 7, 0, 4 };
arrow1 = new int[4] { 4, 7, 5, 6 };
arrow2 = new int[4] { 4, 5, 7, 6 };
}
else if (viewDir.X >= 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] { 4, 0, 5, 1 };
arrow1 = new int[4] { 4, 5, 7, 6 };
arrow2 = new int[4] { 6, 5, 7, 4 };
}
else if (viewDir.X >= 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] { 1, 5, 2, 6 };
arrow1 = new int[4] { 5, 6, 4, 7 };
arrow2 = new int[4] { 7, 6, 4, 5 };
}
}
}
public override void DrawEnd(Graphics3D graphics)
{
foreach (Face face in Faces)
graphics.AddFace(face);
}
private void DrawArrow(int[] arrow, Graphics3D graphics)
{
Vector3D pt0 = _pts[arrow[0]];
Vector3D pt0_ = pt0 + (pt0 - _pts[arrow[2]]) * offsetPerc;
Vector3D pt00_ = pt0 + (pt0 - _pts[arrow[2]]) * offsetPerc * 1.1;
Vector3D pt1 = _pts[arrow[1]];
Vector3D pt1_ = pt1 + (pt1 - _pts[arrow[3]]) * offsetPerc;
Vector3D pt11_ = pt1 + (pt1 - _pts[arrow[3]]) * offsetPerc * 1.1;
if ((pt1 - pt0).GetLengthSquared() < 1.0E-03)
return;
string text = string.Format("{0:0.0}", (pt1-pt0).GetLength());
graphics.Draw(text, 0.5 * (pt1_ + pt0_), _color, _fontSize);
graphics.Draw(new Segment(pt0_, pt0_ + (pt1 - pt0) * (2.0 / 5.0), _color));
graphics.Draw(new Segment(pt0_ + (pt1 - pt0) * (3.0 / 5.0), pt1_, _color));
graphics.Draw(new Segment(pt0, pt00_, _color));
graphics.Draw(new Segment(pt1, pt11_, _color));
}
public override void Draw(Graphics3D graphics)
{
}
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));
}
public virtual void DrawBegin(Graphics3D graphics)
{
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (TruckLength == 0 || TruckWidth == 0 || TruckHeight == 0)
return;
TruckProperties truckProperties = new TruckProperties(null, TruckLength, TruckWidth, TruckHeight);
truckProperties.Color = TruckColor;
Truck truck = new Truck(truckProperties);
truck.DrawBegin(graphics);
truck.DrawEnd(graphics);
graphics.AddDimensions(new DimensionCube(TruckLength, TruckWidth, TruckHeight));
}
public void Draw(Graphics3D graphics)
{
if (null == _truckSolution)
{
throw new Exception("No trucksolution defined!");
}
// draw truck
Truck truck = new Truck(_truckSolution.ParentTruckAnalysis.TruckProperties);
truck.DrawBegin(graphics);
truck.DrawEnd(graphics);
// get pallet height
CasePalletAnalysis analysis = _truckSolution.ParentTruckAnalysis.ParentAnalysis;
double palletLength = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletLength;
double palletWidth = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletWidth;
double palletHeight = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletHeight;
// get parent pallet solution
CasePalletSolution sol = _truckSolution.ParentTruckAnalysis.ParentSolution;
// draw solution
uint pickIdGlobal = 0;
for (int i = 0; i < _truckSolution.NoLayers; ++i)
{
foreach (BoxPosition bPositionLayer in _truckSolution.Layer)
{
BoxPosition bPalletPosition = new BoxPosition(
new Vector3D(
bPositionLayer.Position.X
, bPositionLayer.Position.Y
, bPositionLayer.Position.Z + palletHeight * i)
, bPositionLayer.DirectionLength
, bPositionLayer.DirectionWidth);
if (_showDetails)
{
// build transformation
Transform3D transformPallet = bPalletPosition.Transformation;
// draw pallet
Pallet pallet = new Pallet(analysis.PalletProperties);
pallet.Draw(graphics, transformPallet);
// draw solution
uint pickId = 0;
foreach (ILayer layer in sol)
{
BoxLayer bLayer = layer as BoxLayer;
if (null != bLayer)
{
foreach (BoxPosition bPosition in bLayer)
{
graphics.AddBox(new Box(pickId++, analysis.BProperties, BoxPosition.Transform(bPosition, transformPallet)));
}
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
BoxPosition iPos = new BoxPosition(new Vector3D(0.0, 0.0, interlayerPos.ZLow), HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
graphics.AddBox(new Box(pickId++, analysis.InterlayerProperties, BoxPosition.Transform(iPos, transformPallet)));
}
}
}
else
{
Box b = new Box(pickIdGlobal++, new BoxProperties(null, palletLength, palletWidth, palletHeight), bPalletPosition);
b.SetAllFacesColor(Color.Chocolate);
graphics.AddBox(b);
}
}
}
// fluch
graphics.UseBoxelOrderer = false; // can not use boxel orderer for full truck view -> too slow...
}
public void DrawLayer(Graphics3D graphics, int layerIndex)
{
// sanity check
if (null == _solution) return;
if (_showDimensions)
{
BoxLayer layer = layerIndex %2 == 0 ? _solution.Layer : _solution.LayerSwapped;
uint pickId = 0;
foreach (BoxPosition bPosition in layer)
graphics.AddBox(new Pack(pickId++, _solution.Analysis.PackProperties, bPosition));
graphics.AddDimensions(
new DimensionCube(layer.BoundingBox(_solution.Analysis.PackProperties)
, Color.Black, false));
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (ctrl == graphCtrlPallet)
{
PalletProperties pp = CurrentPallet;
Pallet pallet = new Pallet(pp);
pallet.Draw(graphics, Transform3D.Identity);
DimensionCube dc = new DimensionCube(pp.Length, pp.Width, pp.Height) { FontSize = 6.0f };
graphics.AddDimensions(dc);
}
else if (ctrl == graphCtrlSolution)
{
if (null == CurrentSolution) return;
CasePalletSolutionViewer sv = new CasePalletSolutionViewer(CurrentSolution);
sv.Draw(graphics);
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
// ### draw pallet
if (graphCtrlPallet == ctrl)
{
PalletProperties pp = SelectedPallet;
Pallet pallet = new Pallet(pp);
pallet.Draw(graphics, Transform3D.Identity);
DimensionCube dc = new DimensionCube(pp.Length, pp.Width, pp.Height) { FontSize = 6.0f };
graphics.AddDimensions(dc);
}
// ### draw case definition
else if (ctrl == graphCtrlBoxesLayout)
{
// ### draw case definition
try
{
// get selected solution
CaseOptimSolution solution = SelectedSolution;
if (null == solution) return;
// instantiate case definition viewer
CaseDefinitionViewer cdv = new CaseDefinitionViewer(SelectedSolution.CaseDefinition, SelectedBox, BuildCaseOptimConstraintSet());
cdv.Orientation = SelectedSolution.PalletSolution.FirstCaseOrientation;
cdv.Draw(graphics);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
// ### draw associated pallet solution
else if (ctrl == graphCtrlPalletLayout)
{
try
{
// get selected solution
CaseOptimSolution solution = SelectedSolution;
// get selected box
BoxProperties boxProperties = SelectedBox;
// get selected pallet
PalletProperties palletProperties = SelectedPallet;
if (null != solution && null != boxProperties && null != palletProperties)
{
Vector3D outerDim = solution.CaseDefinition.OuterDimensions(boxProperties, BuildCaseOptimConstraintSet());
BoxProperties caseProperties = new BoxProperties(null, outerDim.X, outerDim.Y, outerDim.Z);
caseProperties.SetColor(Color.Chocolate);
CasePalletSolutionViewer.Draw(graphics, solution.PalletSolution, caseProperties, null, palletProperties);
}
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
}
public virtual void DrawEnd(Graphics3D graphics)
{
}
/// <summary>
/// Draw case solution
/// </summary>
public void Draw(Graphics3D graphics)
{
if (null == _caseSolution)
{
throw new Exception("No case solution defined!");
}
// load pallet solution
BoxProperties caseProperties;
CasePalletSolution palletSolution = _caseSolution.PalletSolutionDesc.LoadPalletSolution();
if (null == palletSolution)
{
caseProperties = new BoxProperties(null, _caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight);
}
else
{
CasePalletAnalysis palletAnalysis = palletSolution.Analysis;
// retrieve case properties
caseProperties = palletAnalysis.BProperties as BoxProperties;
}
if (null == caseProperties)
{
return;
}
// draw case (inside)
Case case_ = new Case(caseProperties);
case_.DrawInside(graphics);
// get case analysis
BoxCasePalletAnalysis caseAnalysis = _caseSolution.ParentCaseAnalysis;
// draw solution
uint pickId = 0;
foreach (ILayer layer in _caseSolution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Box(pickId++, caseAnalysis.BoxProperties, bPosition));
}
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
Box box = new Box(pickId++, caseAnalysis.InterlayerProperties);
// set position
box.Position = new Vector3D(0.0, 0.0, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
// get case analysis
if (_showDimensions)
{
graphics.AddDimensions(new DimensionCube(_caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight));
}
}
public void Draw(Graphics3D graphics, Transform3D t)
{
if (_length == 0.0 || _width == 0.0 || _height == 0.0)
return;
PalletData palletType = PalletData.GetByName(_typeName);
if (null != palletType)
palletType.Draw(graphics, new Vector3D(_length, _width, _height), _color, t);
}
/// <summary>
/// Use this method when drawing a solution that belongs an analysis
/// </summary>
/// <param name="graphics"></param>
public void Draw(Graphics3D graphics)
{
if (null == _solution)
{
return;
}
// initialize Graphics3D object
if (!graphics.ShowBoxIds)
{
// draw pallet
Pallet pallet = new Pallet(_analysis.PalletProperties);
pallet.Draw(graphics, Transform3D.Identity);
}
// load bounding box
BBox3D loadBBox = _solution.LoadBoundingBox;
BBox3D loadBBoxWDeco = _solution.LoadBoundingBoxWDeco;
#region Pallet film : begin
// draw film
Film film = null;
if (_solution.Analysis.HasPalletFilm)
{
PalletFilmProperties palletFilmProperties = _solution.Analysis.PalletFilmProperties;
film = new Film(
palletFilmProperties.Color,
palletFilmProperties.UseTransparency,
palletFilmProperties.UseHatching,
palletFilmProperties.HatchSpacing,
palletFilmProperties.HatchAngle);
film.AddRectangle(new FilmRectangle(loadBBoxWDeco.PtMin,
HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Z_P, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Height), 0.0));
film.AddRectangle(new FilmRectangle(loadBBoxWDeco.PtMin + loadBBoxWDeco.Length * Vector3D.XAxis,
HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_Z_P, new Vector2D(loadBBoxWDeco.Width, loadBBoxWDeco.Height), 0.0));
film.AddRectangle(new FilmRectangle(loadBBoxWDeco.PtMin + loadBBoxWDeco.Length * Vector3D.XAxis + loadBBoxWDeco.Width * Vector3D.YAxis,
HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Z_P, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Height), 0.0));
film.AddRectangle(new FilmRectangle(loadBBoxWDeco.PtMin + loadBBoxWDeco.Width * Vector3D.YAxis,
HalfAxis.HAxis.AXIS_Y_N, HalfAxis.HAxis.AXIS_Z_P, new Vector2D(loadBBoxWDeco.Width, loadBBoxWDeco.Height), 0.0));
film.AddRectangle(new FilmRectangle(loadBBoxWDeco.PtMin + loadBBoxWDeco.Height * Vector3D.ZAxis,
HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P, new Vector2D(loadBBoxWDeco.Length, loadBBoxWDeco.Width),
UnitsManager.ConvertLengthFrom(200.0, UnitsManager.UnitSystem.UNIT_METRIC1)));
film.DrawBegin(graphics);
}
#endregion
#region Pallet corners
// *** pallet corners
// 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
Corner[] corners = new Corner[4];
if (_solution.Analysis.HasPalletCorners)
{
for (int i = 0; i < 4; ++i)
{
corners[i] = new Corner(0, _solution.Analysis.PalletCornerProperties);
corners[i].Height = Math.Min(_solution.Analysis.PalletCornerProperties.Length, loadBBox.Height);
corners[i].SetPosition(cornerPositions[i], lAxes[i], wAxes[i]);
corners[i].DrawBegin(graphics);
}
}
// *** pallet corners : end
#endregion
// draw solution
uint pickId = 0;
foreach (ILayer layer in _solution)
{
BoxLayer blayer = layer as BoxLayer;
if (null != blayer)
{
foreach (BoxPosition bPosition in blayer)
{
graphics.AddBox(new Box(pickId++, _analysis.BProperties, bPosition));
}
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
InterlayerProperties currInterlayerProperties = (0 == interlayerPos.TypeId)
? _analysis.InterlayerProperties : _analysis.InterlayerPropertiesAntiSlip;
Box box = new Box(pickId++, currInterlayerProperties);
// set position
box.Position = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - currInterlayerProperties.Length)
, 0.5 * (_analysis.PalletProperties.Width - currInterlayerProperties.Width)
, interlayerPos.ZLow);
// draw
graphics.AddBox(box);
}
}
if (_showDimensions)
{
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol1)
, Color.Black, false));
graphics.AddDimensions(
new DimensionCube(BoundingBoxDim(Properties.Settings.Default.DimCasePalletSol2)
, Color.Red, true));
}
// pallet corners
if (_solution.Analysis.HasPalletCorners)
{
for (int i = 0; i < 4; ++i)
{
corners[i].DrawEnd(graphics);
}
}
// pallet cap
if (_solution.HasPalletCap)
{
PalletCapProperties capProperties = _solution.Analysis.PalletCapProperties;
Vector3D pos = new Vector3D(
0.5 * (_analysis.PalletProperties.Length - capProperties.Length),
0.5 * (_analysis.PalletProperties.Width - capProperties.Width),
loadBBox.PtMax.Z - capProperties.InsideHeight);
PalletCap cap = new PalletCap(0, capProperties, pos);
cap.DrawEnd(graphics);
}
// pallet film
if (_solution.Analysis.HasPalletFilm)
{
film.DrawEnd(graphics);
}
graphics.EnableFaceSorting = false;
}
public void Draw(Graphics3D graphics, Vector3D dimensions, Color color, Transform3D t)
{
double coefX = dimensions.X / _defaultDimensions.X;
double coefY = dimensions.Y / _defaultDimensions.Y;
double coefZ = dimensions.Z / _defaultDimensions.Z;
uint pickId = 0;
foreach (Position pos in _positions)
{
double coef0 = coefX, coef1 = coefY, coef2 = coefZ;
if (pos.Axis1 == HalfAxis.HAxis.AXIS_X_P && pos.Axis2 == HalfAxis.HAxis.AXIS_Y_P)
{ coef0 = coefX; coef1 = coefY; }
else if (pos.Axis1 == HalfAxis.HAxis.AXIS_Y_P && pos.Axis2 == HalfAxis.HAxis.AXIS_X_N)
{ coef0 = coefY; coef1 = coefX; }
Vector3D dim = _lumbers[pos.Index];
Box box = new Box(pickId++, dim.X * coef0, dim.Y * coef1, dim.Z * coef2);
box.SetAllFacesColor(color);
box.Position = t.transform(new Vector3D(pos.XYZ.X * coefX, pos.XYZ.Y * coefY, pos.XYZ.Z * coefZ));
box.LengthAxis = Basics.HalfAxis.ToVector3D(HalfAxis.Transform(pos.Axis1, t)); ;
box.WidthAxis = Basics.HalfAxis.ToVector3D(HalfAxis.Transform(pos.Axis2, t)); ;
graphics.AddBox(box);
}
}
private void ArrowPoints(Graphics3D graphics, out int[] arrow0, out int[] arrow1, out int[] arrow2)
{
Vector3D viewDir = graphics.ViewDirection;
arrow0 = null;
arrow1 = null;
arrow2 = null;
if (!_above)
{
if (viewDir.X < 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] {
0, 4, 1, 5
};
arrow1 = new int[4] {
0, 1, 3, 2
};
arrow2 = new int[4] {
1, 2, 0, 3
};
}
else if (viewDir.X < 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] {
1, 5, 2, 6
};
arrow1 = new int[4] {
1, 2, 0, 3
};
arrow2 = new int[4] {
2, 3, 1, 0
};
}
else if (viewDir.X >= 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] {
2, 6, 3, 7
};
arrow1 = new int[4] {
2, 3, 1, 0
};
arrow2 = new int[4] {
3, 0, 2, 1
};
}
else if (viewDir.X >= 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] {
3, 7, 0, 4
};
arrow1 = new int[4] {
3, 0, 2, 1
};
arrow2 = new int[4] {
0, 1, 3, 2
};
}
}
else
{
if (viewDir.X < 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] {
2, 6, 3, 7
};
arrow1 = new int[4] {
7, 6, 4, 5
};
arrow2 = new int[4] {
4, 7, 5, 6
};
}
else if (viewDir.X < 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] {
3, 7, 0, 4
};
arrow1 = new int[4] {
4, 7, 5, 6
};
arrow2 = new int[4] {
4, 5, 7, 6
};
}
else if (viewDir.X >= 0.0 && viewDir.Y < 0.0)
{
arrow0 = new int[4] {
4, 0, 5, 1
};
arrow1 = new int[4] {
4, 5, 7, 6
};
arrow2 = new int[4] {
6, 5, 7, 4
};
}
else if (viewDir.X >= 0.0 && viewDir.Y >= 0.0)
{
arrow0 = new int[4] {
1, 5, 2, 6
};
arrow1 = new int[4] {
5, 6, 4, 7
};
arrow2 = new int[4] {
7, 6, 4, 5
};
}
}
}
public override void Draw(Graphics3D graphics)
{
// draw tray back faces
if (_packProperties.Wrap.Type == PackWrapper.WType.WT_TRAY)
{}
// draw inner boxes
if (_packProperties.Wrap.Type == PackWrapper.WType.WT_POLYETHILENE
|| _packProperties.Wrap.Type == PackWrapper.WType.WT_TRAY
|| _forceTransparency)
{
List<Box> boxes = InnerBoxes;
boxes.Sort( new BoxComparerSimplifiedPainterAlgo(graphics.GetWorldToEyeTransformation()) );
foreach (Box b in boxes)
graphics.Draw(b);
}
if (_packProperties.Wrap.Type != PackWrapper.WType.WT_TRAY)
{
// draw front faces
foreach (Face f in Faces)
{
graphics.Draw(
f
, Graphics3D.FaceDir.FRONT
, _packProperties.Wrap.Color
, _packProperties.Wrap.Transparent || _forceTransparency);
}
}
else
{
// draw tray front faces
foreach (Face f in TrayFaces)
{
graphics.Draw(
f
, Graphics3D.FaceDir.FRONT
, _packProperties.Wrap.Color
, _packProperties.Wrap.Transparent);
}
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (CornerLength > 0 && CornerWidth > 0 && CornerThickness > 0
&& CornerThickness < CornerWidth)
{
// draw
PalletCornerProperties palletCornerProperties = new PalletCornerProperties(
null, ItemName, ItemDescription, CornerLength, CornerWidth, CornerThickness,
CornerWeight, CornerColor);
Corner palletCap = new Corner(0, palletCornerProperties);
palletCap.Draw(graphics);
graphics.AddDimensions(new DimensionCube(CornerWidth, CornerWidth, CornerLength));
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (graphCtrlPallet == ctrl)
{
Pallet pallet = new Pallet(_palletProperties);
pallet.Draw(graphics, Transform3D.Identity);
DimensionCube dc = new DimensionCube(_palletProperties.Length, _palletProperties.Width, _palletProperties.Height) { FontSize = 6.0f };
graphics.AddDimensions(dc);
}
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
// instantiate solution viewer
PackPalletSolutionViewer sv = new PackPalletSolutionViewer(GetCurrentSolution());
sv.Draw(graphics);
}
public void Draw(Graphics3DControl ctrl, Graphics3D graphics)
{
if (graphCtrlCaseSolution == ctrl)
{
// instantiate solution viewer
BoxCasePalletSolutionViewer sv = new BoxCasePalletSolutionViewer(GetCurrentSolution());
sv.Draw(graphics);
}
else if (graphCtrlPalletSolution == ctrl)
{
CasePalletSolution sol = GetCurrentSolution().PalletSolutionDesc.LoadPalletSolution();
// instantial solution viewer
CasePalletSolutionViewer svPallet = new CasePalletSolutionViewer(sol);
svPallet.Draw(graphics);
}
}
