public void AddPosition(LayerCyl layer, Vector2D vPosition)
{
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(layer.PalletLength, 0.0, 0.0);
}
Transform3D transfRot = new Transform3D(matRot);
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
Transform3D transfRotTranslation = new Transform3D(matRot);
Vector3D vPositionSwapped = transfRotTranslation.transform(new Vector3D(vPosition.X, vPosition.Y, 0.0));
if (!layer.IsValidPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y)))
{
_log.Warn(string.Format("Attempt to add an invalid position in pattern = {0}, Swapped = true", this.Name));
return;
}
layer.Add(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y));
}
public CylPosition Transform(Transform3D transf)
{
return new CylPosition(
transf.transform(_vPosition),
HalfAxis.ToHalfAxis(transf.transformRot(HalfAxis.ToVector3D(_axis)))
);
}
public static CylPosition Transform(CylPosition cylPosition, Transform3D transform)
{
return new CylPosition(
transform.transform(cylPosition._vPosition),
HalfAxis.ToHalfAxis(
transform.transformRot(HalfAxis.ToVector3D(cylPosition._axis))
)
);
}
public static BoxPosition Transform(BoxPosition boxPosition, Transform3D transform)
{
if (!boxPosition.IsValid)
throw new Exception("Invalid box position : can not transform");
return new BoxPosition(
transform.transform(boxPosition.Position)
, HalfAxis.Transform(boxPosition.DirectionLength, transform)
, HalfAxis.Transform(boxPosition.DirectionWidth, transform)
);
}
public Case(BoxProperties boxProperties, Transform3D transf)
{
_length = boxProperties.Length;
_width = boxProperties.Width;
_height = boxProperties.Height;
_insideLength = boxProperties.InsideLength;
_insideWidth = boxProperties.InsideWidth;
_insideHeight = boxProperties.InsideHeight;
_colors = boxProperties.Colors;
_colorPath = Color.Black;
_transf = transf;
}
LayerPosition ApplyReflection(LayerPosition layerPos, Matrix4D matRot, Vector3D vTranslation)
{
Vector3D dimensions = Analysis.ContentDimensions;
Transform3D transfRot = new Transform3D(matRot);
HalfAxis.HAxis axisLength = HalfAxis.ToHalfAxis(transfRot.transform(HalfAxis.ToVector3D(layerPos.LengthAxis)));
HalfAxis.HAxis axisWidth = HalfAxis.ToHalfAxis(transfRot.transform(HalfAxis.ToVector3D(layerPos.WidthAxis)));
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
Transform3D transfRotTranslation = new Transform3D(matRot);
Vector3D transPos = transfRotTranslation.transform( new Vector3D(layerPos.Position.X, layerPos.Position.Y, layerPos.Position.Z) );
return new LayerPosition(
new Vector3D(transPos.X, transPos.Y, transPos.Z)
- dimensions.Z * Vector3D.CrossProduct(HalfAxis.ToVector3D(axisLength), HalfAxis.ToVector3D(axisWidth))
, axisLength
, axisWidth);
}
public static HAxis Transform(HAxis axis, Transform3D transform)
{
return HalfAxis.ToHalfAxis(transform.transformRot(HalfAxis.ToVector3D(axis)));
}
public void AddPosition(Layer layer, Vector2D vPosition, HalfAxis.HAxis lengthAxis, HalfAxis.HAxis widthAxis)
{
Matrix4D matRot = Matrix4D.Identity;
Vector3D vTranslation = Vector3D.Zero;
if (_swapped && !layer.Inversed)
{
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(layer.PalletLength, 0.0, 0.0);
}
else if (!_swapped && layer.Inversed)
{
matRot = new Matrix4D(
-1.0, 0.0, 0.0, 0.0
, 0.0, -1.0, 0.0, 0.0
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0
);
vTranslation = new Vector3D(layer.PalletLength, layer.PalletWidth, 0.0);
}
else if (_swapped && layer.Inversed)
{
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(0.0, layer.PalletWidth, 0.0);
}
Transform3D transfRot = new Transform3D(matRot);
HalfAxis.HAxis lengthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(lengthAxis)));
HalfAxis.HAxis widthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(widthAxis)));
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
Transform3D transfRotTranslation = new Transform3D(matRot);
Vector3D vPositionSwapped = transfRotTranslation.transform(new Vector3D(vPosition.X, vPosition.Y, 0.0));
if (!layer.IsValidPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped))
{
_log.Warn(string.Format("Attempt to add an invalid position in pattern = {0}, Variant = {1}, Swapped = true", this.Name, _variantIndex));
return;
}
layer.AddPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped);
}
/// <summary>
/// Draw all entities stored in buffer
/// </summary>
public void Flush()
{
// initialize
Vector3D vLight = _vCameraPos - _vTarget; vLight.Normalize();
_boxDrawingCounter = 0;
_currentTransf = null;
System.Drawing.Graphics g = Graphics;
g.Clear(_backgroundColor);
if (EnableFaceSorting)
{
// sort face list
FaceComparison faceComparer = new FaceComparison(GetWorldToEyeTransformation());
_faces.Sort(faceComparer);
}
// draw background segments
foreach (Segment s in _segmentsBackground)
Draw(s);
// draw background faces
foreach (Face face in _facesBackground)
Draw(face, FaceDir.FRONT);
// draw all faces using solid / transparency depending on
foreach (Face face in _faces)
Draw(face, FaceDir.BACK);
// sort box list
if (_useBoxelOrderer)
{
BoxelOrderer boxelOrderer = new BoxelOrderer(_boxes);
boxelOrderer.Direction = _vTarget - _vCameraPos;
_boxes = boxelOrderer.GetSortedList();
}
else
_boxes.Sort(new BoxComparerSimplifiedPainterAlgo(GetWorldToEyeTransformation()));
// sort cylinder list
_cylinders.Sort(new CylinderComparerSimplifiedPainterAlgo(GetWorldToEyeTransformation()));
if (_cylinders.Count > 0)
{
// sort by Z
List<Drawable> drawableList = new List<Drawable>();
drawableList.AddRange(_boxes);
drawableList.AddRange(_cylinders);
drawableList.Sort(new DrawableComparerSimplifiedPainterAlgo());
List<Box> boxes = new List<Box>();
List<Cylinder> cylinders = new List<Cylinder>();
bool processingBox = drawableList[0] is Box;
foreach (Drawable drawable in drawableList)
{
Box b = drawable as Box;
Cylinder c = drawable as Cylinder;
if ((null != b) && processingBox)
boxes.Add(b);
else if ((null == b) && !processingBox)
cylinders.Add(c);
else
{
if (boxes.Count > 0)
{
BoxelOrderer boxelOrderer = new BoxelOrderer(boxes);
boxelOrderer.Direction = _vTarget - _vCameraPos;
boxes = boxelOrderer.GetSortedList();
// draw boxes
foreach (Box bb in boxes)
Draw(bb);
// clear
boxes.Clear();
}
if (cylinders.Count > 0)
{
cylinders.Sort(new CylinderComparerSimplifiedPainterAlgo(GetWorldToEyeTransformation()));
// draw cylinders
foreach (Cylinder cc in cylinders)
Draw(cc);
// clear
cylinders.Clear();
}
if (null != b)
{
boxes.Add(b);
processingBox = true;
}
else
{
cylinders.Add(c);
processingBox = false;
}
}
}
// remaining boxes
BoxelOrderer boxelOrdererRem = new BoxelOrderer(boxes);
boxelOrdererRem.Direction = _vTarget - _vCameraPos;
boxes = boxelOrdererRem.GetSortedList();
// draw boxes
foreach (Box bb in boxes)
Draw(bb);
// remaining cylinders
cylinders.Sort(new CylinderComparerSimplifiedPainterAlgo(GetWorldToEyeTransformation()));
// draw cylinders
foreach (Cylinder cc in cylinders)
Draw(cc);
// clear
boxes.Clear();
}
else
{
// draw all boxes
foreach (Box box in _boxes)
Draw(box);
}
// draw faces : end
foreach (Face face in _faces)
Draw(face, FaceDir.FRONT);
// draw segment list (e.g. hatching)
foreach (Segment seg in _segments)
Draw(seg);
// draw cotation cubes
foreach (DimensionCube qc in _dimensions)
qc.Draw(this);
}
public BoxLayer GetBoxLayer(int iLayerIndex, ref bool hasInterlayer, ref double zInterlayer)
{
if (null == _parentAnalysis)
throw new Exception("_parentAnalysis not set.");
double interlayerThickness = (null != _parentAnalysis.InterlayerProperties) ? _parentAnalysis.InterlayerProperties.Thickness : 0.0;
double packHeight = _parentAnalysis.PackProperties.Height;
double zLow = _parentAnalysis.PalletProperties.Height;
int i = 0;
while (i <= iLayerIndex-1)
{
LayerDescriptor desc = _listLayers[i];
zLow += (desc.HasInterlayer ? interlayerThickness : 0.0) + packHeight;
++i;
}
zInterlayer = zLow;
hasInterlayer = _listLayers[iLayerIndex].HasInterlayer;
zLow += hasInterlayer ? interlayerThickness : 0.0;
Transform3D swapTransform = Transform3D.Identity;
if (_listLayers[iLayerIndex].Swapped)
{
Matrix4D matRot = new Matrix4D(
-1.0, 0.0, 0.0, _parentAnalysis.PalletProperties.Length
, 0.0, -1.0, 0.0, _parentAnalysis.PalletProperties.Width
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0);
swapTransform = new Transform3D(matRot);
}
// build BoxLayer
BoxLayer layer = new BoxLayer(zLow + (hasInterlayer ? interlayerThickness : 0.0), 0);
foreach (BoxPosition b in _layer)
{
layer.Add(
new BoxPosition(
swapTransform.transform(b.Position + zLow * Vector3D.ZAxis)
, HalfAxis.Transform(b.DirectionLength, swapTransform)
, HalfAxis.Transform(b.DirectionWidth, swapTransform) )
);
}
return layer;
}
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);
}
}
// list of boxes
public List<Box> BuildListOfBoxes(Vector3D dimensions, Color color, Transform3D t)
{
List<Box> listPalletLumbers = new List<Box>();
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)); ;
listPalletLumbers.Add(box);
}
return listPalletLumbers;
}
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);
}
private Transform3D GetCurrentTransformation()
{
if (null == _currentTransf)
{
// get transformations
Transform3D world2eye = GetWorldToEyeTransformation();
Transform3D orthographicProj = GetOrthographicProjection(
new Vector3D(_viewport[0], _viewport[1], -10000)
, new Vector3D(_viewport[2], _viewport[3], 10000));
// build automatic viewport
if (_autoViewport)
{
Vector3D vecMin = new Vector3D(double.MaxValue, double.MaxValue, double.MaxValue);
Vector3D vecMax = new Vector3D(double.MinValue, double.MinValue, double.MinValue);
// boxes
foreach (Box box in _boxes)
foreach (Vector3D pt in box.Points)
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
// cylinders
foreach (Cylinder cyl in _cylinders)
{
foreach (Vector3D pt in cyl.BottomPoints)
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
foreach (Vector3D pt in cyl.TopPoints)
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
}
// faces
foreach (Face face in _faces)
foreach (Vector3D pt in face.Points)
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
// segments
foreach (Segment seg in _segments)
foreach (Vector3D pt in seg.Points)
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
// cube dimensions
foreach (DimensionCube dimCube in _dimensions)
foreach (Vector3D pt in dimCube.DrawingPoints(this))
{
Vector3D ptT = world2eye.transform(pt);
vecMin.X = Math.Min(vecMin.X, ptT.X);
vecMin.Y = Math.Min(vecMin.Y, ptT.Y);
vecMin.Z = Math.Min(vecMin.Z, ptT.Z);
vecMax.X = Math.Max(vecMax.X, ptT.X);
vecMax.Y = Math.Max(vecMax.Y, ptT.Y);
vecMax.Z = Math.Max(vecMax.Z, ptT.Z);
}
Vector3D vecMin1 = vecMin, vecMax1 = vecMax;
// adjust width/height
if ((vecMax.Y - vecMin.Y) / Size.Height > (vecMax.X - vecMin.X) / Size.Width)
{
double actualWidth = (vecMax.Y - vecMin.Y) * Size.Width / Size.Height;
vecMin1.X = 0.5 * (vecMin.X + vecMax.X) - 0.5 * actualWidth;
vecMax1.X = 0.5 * (vecMin.X + vecMax.X) + 0.5 * actualWidth;
}
else
{
double actualHeight = (vecMax.X - vecMin.X) * Size.Height / Size.Width;
vecMin1.Y = 0.5 * (vecMin.Y + vecMax.Y) - 0.5 * actualHeight;
vecMax1.Y = 0.5 * (vecMin.Y + vecMax.Y) + 0.5 * actualHeight;
}
// set margins
double width = vecMax1.X - vecMin1.X;
vecMin1.X -= _margin * width;
vecMax1.X += _margin * width;
double height = vecMax1.Y - vecMin1.Y;
vecMin1.Y -= _margin * height;
vecMax1.Y += _margin * height;
orthographicProj = GetOrthographicProjection(vecMin1, vecMax1);
}
_currentTransf = orthographicProj * world2eye;
}
return _currentTransf;
}
public static DimensionCube Transform(DimensionCube dimCube, Transform3D transform)
{
Vector3D pos = transform.transform(dimCube._position);
Vector3D dim = transform.transformRot(new Vector3D(dimCube._dim) );
if (dim.X < 0) { pos.X += dim.X; dim.X = -dim.X; }
if (dim.Y < 0) { pos.Y += dim.Y; dim.Y = -dim.Y; }
if (dim.Z < 0) { pos.Z += dim.Z; dim.Z = -dim.Z; }
return new DimensionCube(pos, dim.X, dim.Y, dim.Z, dimCube.Color, dimCube._above);
}
public Transform3D(Transform3D transf)
{
_mat = transf._mat.Clone();
}
private Point TransformPoint(Transform3D transform, Vector3D point3d)
{
Vector3D vt = transform.transform(point3d);
return new Point((int)vt.X, (int)vt.Y);
}
private Point[] TransformPoint(Transform3D transform, Vector3D[] points3d)
{
Point[] points = new Point[points3d.Length];
int i = 0;
foreach (Vector3D v in points3d)
{
Vector3D vt = transform.transform(v);
points[i] = new Point((int)vt.X, (int)vt.Y);
++i;
}
return points;
}