public void DrawRectangle(Vector2D vMin, Vector2D vMax, Color penColor)
{
Point[] pt = TransformPoint(new Vector2D[] { vMin, vMax });
System.Drawing.Graphics g = Graphics;
Pen penRect = new Pen(penColor);
g.DrawRectangle(penRect, pt[0].X, pt[0].Y, pt[1].X-pt[0].X, pt[1].Y-pt[0].Y);
}
public static bool PointToAboveSegment(Vector2D p, Segment seg, ref double distance)
{
double xMin = System.Math.Min(seg.P0.X, seg.P1.X);
double xMax = System.Math.Max(seg.P0.X, seg.P1.X);
if (p.X < xMin - MathFunctions.EpsilonF || p.X > xMax + MathFunctions.EpsilonF)
return false;
else
{
double yMin = System.Math.Min(seg.P0.Y, seg.P1.Y);
double yMax = System.Math.Max(seg.P0.Y, seg.P1.Y);
if (System.Math.Abs(seg.P1.X - seg.P0.X) < MathFunctions.EpsilonF)
{
if (p.Y < yMin)
distance = yMin - p.Y;
else if (p.Y > yMax)
distance = yMax - p.Y;
else
distance = 0.0f;
}
else
distance = seg.P0.Y + (p.X - seg.P0.X) * (seg.P1.Y - seg.P0.Y) / (seg.P1.X - seg.P0.X) - p.Y;
return true;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Arc"/> class.
/// </summary>
/// <param name="arc">A <see cref="Arc"/> instance.</param>
public Arc(Arc arc)
{
_pCenter = arc._pCenter;
_radius = arc._radius;
_angle0 = arc._angle0;
_angle1 = arc._angle1;
}
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));
}
protected PicCotationDistance(uint id, Vector2D pt0, Vector2D pt1, double offset, short noDecimals)
: base(id, noDecimals)
{
_pt0 = pt0;
_pt1 = pt1;
_offset = offset;
}
public void DrawLine(Vector2D v1, Vector2D v2, Color penColor)
{
Point[] pt = TransformPoint(new Vector2D[] { v1, v2 });
System.Drawing.Graphics g = Graphics;
Pen pen = new Pen(penColor);
g.DrawLines(pen, pt);
}
/// <summary>
/// Initializes a new instance of the <see cref="Arc"/> class.
/// </summary>
/// <param name="pCenter">A <see cref="Vector2D"/> instance marking the <see cref="Arc"/>'s center point.</param>
/// <param name="radius">The <see cref="Arc"/>'s radius.</param>
/// <param name="angle0">The <see cref="Arc"/>'s starting angle.</param>
/// <param name="angle1">The <see cref="Arc"/>'s ending angle.</param>
public Arc(Vector2D pCenter, float radius, float angle0, float angle1)
{
_pCenter = pCenter;
_radius = radius;
_angle0 = angle0;
_angle1 = angle1;
}
public static PicSegment CreateNewSegment(uint id, PicGraphics.LT lType, Vector2D pt0, Vector2D pt1)
{
PicSegment segment = new PicSegment(id, lType);
segment._pt0 = pt0;
segment._pt1 = pt1;
return segment;
}
static void Main(string[] args)
{
bool bestLayersOnly = true;
Vector3D dimBox = new Vector3D(400.0, 300.0, 150.0);
Vector2D dimContainer = new Vector2D(1200.0, 1000.0);
ConstraintSetCasePallet constraintSet = new ConstraintSetCasePallet();
constraintSet.SetMaxHeight(1200.0);
try
{
LayerSolver solver = new LayerSolver();
List<Layer2D> layers = solver.BuildLayers(dimBox, dimContainer, constraintSet, bestLayersOnly);
int solIndex = 0;
foreach (Layer2D layer in layers)
{
string fileName = string.Format("{0}_{1}.bmp", layer.Name, solIndex++);
string filePath = Path.Combine(Path.GetTempPath(), fileName);
Console.WriteLine(string.Format("Generating {0}...", filePath));
Graphics2DImage graphics = new Graphics2DImage( new Size(150, 150) );
SolutionViewerLayer solViewer = new SolutionViewerLayer(layer);
BoxProperties bProperties = new BoxProperties(null, 400.0, 300.0, 150.0);
bProperties.SetColor(Color.Brown);
solViewer.Draw(graphics, bProperties, 1500.0);
graphics.SaveAs(filePath);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public Bone(string name)
{
m_refPosition = new Vector2D(0.0, 0.0);
m_mat = Matrix3D.Identity.Clone();
m_totalMat = Matrix3D.Identity.Clone();
m_name = name;
}
protected virtual bool IsMiddleQuotation(Vector2D pt2, Vector2D pt3, double textWidth, double textHeight)
{
double length = (pt3 - pt2).GetLength();
if (Math.Abs(pt3.Y - pt2.Y) < (textHeight / textWidth) * Math.Abs(pt3.X - pt2.X))
return Math.Abs((pt3 - pt2).X) > textWidth * _globalCotationProperties._lengthCoef;
else
return Math.Abs((pt3 - pt2).Y) > textHeight * _globalCotationProperties._lengthCoef;
}
public List<Layer2D> BuildLayers(Vector3D dimBox, Vector2D dimContainer, ConstraintSetAbstract constraintSet, bool keepOnlyBest)
{
// instantiate list of layers
List<Layer2D> listLayers0 = new List<Layer2D>();
// loop through all patterns
foreach (LayerPattern pattern in LayerPattern.All)
{
// loop through all orientation
foreach (HalfAxis.HAxis axisOrtho in HalfAxis.All)
{
// is orientation allowed
if ( !constraintSet.AllowOrientation(axisOrtho) )
continue;
// not swapped vs swapped pattern
for (int iSwapped = 0; iSwapped < 1; ++iSwapped)
{
// does swapping makes sense for this layer pattern ?
if (!pattern.CanBeSwapped && (iSwapped == 1))
continue;
// instantiate layer
Layer2D layer = new Layer2D(dimBox, dimContainer, axisOrtho, iSwapped == 1);
layer.PatternName = pattern.Name;
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
continue;
pattern.GenerateLayer(layer, actualLength, actualWidth);
if (0 == layer.Count)
continue;
listLayers0.Add(layer);
}
}
}
// keep only best layers
if (keepOnlyBest)
{
// 1. get best count
int bestCount = 0;
foreach (Layer2D layer in listLayers0)
bestCount = Math.Max(layer.CountInHeight(constraintSet.OptMaxHeight.Value), bestCount);
// 2. remove any layer that does not match the best count given its orientation
List<Layer2D> listLayers1 = new List<Layer2D>();
foreach (Layer2D layer in listLayers0)
{
if (layer.CountInHeight(constraintSet.OptMaxHeight.Value) >= bestCount)
listLayers1.Add(layer);
}
// 3. copy back in original list
listLayers0.Clear();
listLayers0.AddRange(listLayers1);
}
if (constraintSet.OptMaxHeight.Activated)
listLayers0.Sort(new LayerComparerCount(constraintSet.OptMaxHeight.Value));
return listLayers0;
}
public override void DrawLine(LT lineType, Vector2D ptBeg, Vector2D ptEnd)
{
_cb.SetLineWidth(0.0f);
_cb.SetColorStroke(LineTypeToBaseColor(lineType));
_cb.MoveTo(DX(ptBeg.X), DY(ptBeg.Y));
_cb.LineTo(DX(ptEnd.X), DY(ptEnd.Y));
_cb.Stroke();
}
public static PicArc CreateNewArc(uint id, PicGraphics.LT lType, Vector2D center, double radius, double angleBeg, double angleEnd)
{
PicArc arc = new PicArc(id, lType);
arc._center = center;
arc._radius = radius;
arc._angleBeg = angleBeg;
arc._angleEnd = angleEnd;
return arc;
}
protected virtual void GetOffsetPoints(out Vector2D pt2, out Vector2D pt3)
{
// build normal
Vector2D vI = (_pt1 - _pt0); vI.Normalize();
Vector2D vJ = new Vector2D(vI.Y, -vI.X);
double delta = -_globalCotationProperties._hrap;
pt2 = new Vector2D(_pt0 + vJ * _offset + Math.Sign(_offset) * delta * vJ);
pt3 = new Vector2D(_pt1 + vJ * _offset + Math.Sign(_offset) * delta * vJ);
}
public static void DrawPoint(Graphics g, Vector2D vec, int width, int height)
{
Pen p = new Pen(Color.Red, 1);
g.DrawEllipse(
p,
(float)(width * vec.X - 1.0),
(float)(height * vec.Y - 1.0),
3,
3);
}
//����������ϵ�еĶ������ù����任���ֲ�����ϵ��
public Vector2D TransformPosition(Vector2D refPos)
{
//�����������ϵ�е�����
Vector2D relPos = GetRelPositon(refPos);
Vector3D homoPos = new Vector3D(relPos.X, relPos.Y, 1.0);
//�ӹ�������ϵ�任���ֲ�����ϵ
Vector3D TransformedPos = Matrix3D.Transform(m_totalMat, homoPos);
return new Vector2D(TransformedPos.X, TransformedPos.Y);
}
public override void DrawArc(PicGraphics.LT lineType, Vector2D ptCenter, double radius, double angle0, double angle1)
{
if (radius > 0.0)
_gdiGraphics.DrawArc(ToPen(lineType)
, X(ptCenter.X) - DX(radius)
, Y(ptCenter.Y) - DY(radius)
, (float)(2.0*DX(radius)) // width
, (float)(2.0*DY(radius)) // height
, -(float)angle0 // start angle
, -(float)(angle1-angle0)); // sweep angle
}
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);
}
public FilmRectangle(
Vector3D origin,
HalfAxis.HAxis axis1, HalfAxis.HAxis axis2,
Vector2D dimensions,
double dBorder)
{
_origin = origin;
_axis1 = axis1;
_axis2 = axis2;
_dimensions = dimensions;
_dBorder = dBorder;
}
public override void DrawArc(LT lineType, Vector2D ptCenter, double radius, double angleBeg, double angleEnd)
{
_cb.SetLineWidth(0.0f);
_cb.SetColorStroke(LineTypeToBaseColor(lineType));
_cb.Arc(
DX(ptCenter.X-radius), DY(ptCenter.Y-radius) // Bottom Left(x,y)
, DX(ptCenter.X + radius), DY(ptCenter.Y + radius) // Top Right(x,y)
, -(float)angleBeg // Start Angle
, -(float)(angleEnd - angleBeg) // Extent
);
_cb.Stroke();
}
public Layer2D BuildLayer(Vector3D dimBox, Vector2D dimContainer, LayerDesc layerDesc)
{
// instantiate layer
Layer2D layer = new Layer2D(dimBox, dimContainer, layerDesc.AxisOrtho, false);
// get layer pattern
LayerPattern pattern = LayerPattern.GetByName(layerDesc.PatternName);
// dimensions
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
return null;
pattern.GenerateLayer(layer, actualLength, actualWidth);
return layer;
}
public static bool PointToAboveArc(Vector2D p, Arc arc, ref double distance)
{
bool success = false;
distance = double.MaxValue;
IList<Segment> list = arc.Explode(20);
foreach (Segment seg in list)
{
double dist = 0.0f;
if (PointToAboveSegment(p, seg, ref dist) && dist > 0)
{
distance = System.Math.Min(dist, distance);
success = true;
}
}
return success;
}
public void MinMax(double boxLength, double boxWidth, out Vector2D vMin, out Vector2D vMax)
{
Vector3D[] pts = new Vector3D[4];
pts[0] = new Vector3D(_position.X, _position.Y, 0.0);
pts[1] = new Vector3D(_position.X, _position.Y, 0.0) + HalfAxis.ToVector3D(_lengthAxis) * boxLength;
pts[2] = new Vector3D(_position.X, _position.Y, 0.0) + HalfAxis.ToVector3D(_widthAxis) * boxWidth;
pts[3] = new Vector3D(_position.X, _position.Y, 0.0) + HalfAxis.ToVector3D(_lengthAxis) * boxLength + HalfAxis.ToVector3D(_widthAxis) * boxWidth;
vMin = new Vector2D(double.MaxValue, double.MaxValue);
vMax = new Vector2D(double.MinValue, double.MinValue);
foreach (Vector3D v in pts)
{
vMin.X = Math.Min(v.X, vMin.X);
vMin.Y = Math.Min(v.Y, vMin.Y);
vMax.X = Math.Max(v.X, vMax.X);
vMax.Y = Math.Max(v.Y, vMax.Y);
}
}
protected override void DrawArrowLine(PicGraphics graphics, Vector2D pt2, Vector2D pt3, double textWidth, double textHeight, out Vector2D ptText, out bool middle)
{
double length = (pt3 - pt2).GetLength();
middle = length > textHeight * _globalCotationProperties._lengthCoef;
double textX = (TextDirection == 270.0f) ? textHeight : textWidth;
double textY = (TextDirection == 270.0f) ? textWidth : textHeight;
if (middle)
{
ptText = 0.5 * (pt2 + pt3);
graphics.DrawLine(LineType, pt2, pt2 + (pt3 - pt2) * 0.5 * (length - textY) / length);
graphics.DrawLine(LineType, pt2 + (pt3 - pt2) * 0.5 * (length + textY) / length, pt3);
}
else
{
// text is on top
graphics.DrawLine(LineType, pt2, pt2 + (pt3 - pt2) * _globalCotationProperties._lengthCoef);
ptText = pt2 + (pt3 - pt2) * ((_globalCotationProperties._lengthCoef * length + 0.5 * textX) / length);
}
}
protected override void DrawArrowLine(PicGraphics graphics, Vector2D pt2, Vector2D pt3, double textWidth, double textHeight, out Vector2D ptText, out bool middle)
{
double length = (pt3 - pt2).GetLength();
middle = length > textWidth * _globalCotationProperties._lengthCoef;
if (middle)
{
ptText = 0.5 * (pt2 + pt3);
graphics.DrawLine(LineType, pt2, pt2 + (pt3 - pt2) * 0.5 * (length - textWidth) / length);
graphics.DrawLine(LineType, pt2 + (pt3 - pt2) * 0.5 * (length + textWidth) / length, pt3);
}
else
{
// text is on the right
Vector2D ptLeft = new Vector2D(pt2.X < pt3.X ? pt2 : pt3);
Vector2D ptRight = new Vector2D(pt2.X < pt3.X ? pt3 : pt2);
graphics.DrawLine(LineType, pt2, pt2 + (pt3 - pt2) * _globalCotationProperties._lengthCoef);
ptText = pt2 + (pt3 - pt2) * ((_globalCotationProperties._lengthCoef*length + 0.5*textWidth) / length);
}
}
/// <summary>
/// Calculates the squared distance between a point and a segment.
/// </summary>
/// <param name="point">A <see cref="Vector2D"/> instance.</param>
/// <param name="segment">A <see cref="Segment"/> instance.</param>
/// <returns>The squared distance between the point and the segment.</returns>
public static double SquaredDistance(Vector2D point, Segment segment)
{
Vector2D D = segment.P1 - segment.P0;
Vector2D diffPointP0 = point - segment.P0;
double t = Vector2D.DotProduct(D, diffPointP0);
if (t <= 0)
{
// segment.P0 is the closest to point.
return Vector2D.DotProduct(diffPointP0, diffPointP0);
}
double DdD = Vector2D.DotProduct(D, D);
if (t >= DdD)
{
// segment.P1 is the closest to point.
Vector2D diffPointP1 = point - segment.P1;
return Vector2D.DotProduct(diffPointP1, diffPointP1);
}
// Closest point is inside the segment.
return Vector2D.DotProduct(diffPointP0, diffPointP0) - t * t / DdD;
}
public bool GetReferencePointAndThickness(ref Vector2D v, ref double thickness)
{
if (!Component.IsSupportingAutomaticFolding)
return false;
ParameterStack stack = CurrentParameterStack;
thickness = stack.GetDoubleParameterValue("th1");
v = Component.ReferencePoint(stack);
return true;
}
private void Panel1_MouseMove(object sender, MouseEventArgs e)
{
Panel1.Focus();
try
{
if (e.Button == MouseButtons.Left)
{
Point ptDiff = new Point(e.Location.X - _mousePositionPrev.X, e.Location.Y - _mousePositionPrev.Y);
double aspectRatio = 1.0;
Box2D box = _picGraphics.DrawingBox;
Vector2D centerScreen = new Vector2D(
box.Center.X - (double)ptDiff.X * box.Width / (double)Panel1.ClientSize.Width
, box.Center.Y + (double)ptDiff.Y * box.Height / ((double)Panel1.ClientSize.Height * aspectRatio));
box.Center = centerScreen;
_picGraphics.DrawingBox = box;
Panel1.Invalidate();
}
_mousePositionPrev = e.Location;
}
catch (InvalidBoxException /*ex*/)
{
_computeBbox = true;
}
catch (Exception ex)
{
_log.Debug(ex.ToString());
}
finally
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Matrix2D"/> structure with the specified values.
/// </summary>
/// <param name="column1">A <see cref="Vector2D"/> instance holding values for the first column.</param>
/// <param name="column2">A <see cref="Vector2D"/> instance holding values for the second column.</param>
public Matrix2D(Vector2D column1, Vector2D column2)
{
_m11 = column1.X; _m12 = column2.X;
_m21 = column1.Y; _m22 = column2.Y;
}
/// <summary>
/// Transforms a given vector by a matrix and put the result in a vector.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2D"/> instance.</param>
/// <param name="vector">A <see cref="Vector2D"/> instance.</param>
/// <param name="result">A <see cref="Vector2D"/> instance to hold the result.</param>
public static void Transform(Matrix2D matrix, Vector2D vector, ref Vector2D result)
{
result.X = (matrix.M11 * vector.X) + (matrix.M12 * vector.Y);
result.Y = (matrix.M21 * vector.X) + (matrix.M22 * vector.Y);
}
public static Vector2D ConvertLengthFrom(Vector2D value, UnitsManager.UnitSystem unitSystem)
{
if (unitSystem == CurrentUnitSystem)
return value;
else
{
StandardMeasure<Length> measureX = new StandardMeasure<Length>(value.X, LengthUnitFromUnitSystem(unitSystem));
StandardMeasure<Length> measureY = new StandardMeasure<Length>(value.Y, LengthUnitFromUnitSystem(unitSystem));
return new Vector2D(
measureX.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
, measureY.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
);
}
}
/// <summary>
/// Transforms a given vector by a matrix.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2D"/> instance.</param>
/// <param name="vector">A <see cref="Vector2D"/> instance.</param>
/// <returns>A new <see cref="Vector2D"/> instance containing the result.</returns>
public static Vector2D Transform(Matrix2D matrix, Vector2D vector)
{
return new Vector2D(
(matrix.M11 * vector.X) + (matrix.M12 * vector.Y),
(matrix.M21 * vector.X) + (matrix.M22 * vector.Y));
}
