Exemple #1
0
        public void TestBoxInFront()
        {
            Vector3D vCameraPos = new Vector3D(-10000.0, -10000.0, 10000.0);
            Vector3D vTarget = new Vector3D(0.0, 0.0, 0.0);
            Vector3D vDir = vTarget - vCameraPos;

            Box b1 = new Box(1, 100.0, 100.0, 100.0);
            b1.Position = new Vector3D(900.0, 900.0, 0.0);
            Box b2 = new Box(2, 100.0, 100.0, 100.0);
            b2.Position = new Vector3D(800.0, 900.0, 0.0);
            Box b3 = new Box(3, 100.0, 100.0, 100.0);
            b3.Position = new Vector3D(900.0, 800.0, 0.0);
            Box b4 = new Box(3, 100.0, 100.0, 100.0);
            b4.Position = new Vector3D(800.0, 800.0, 0.0);
            Box b5 = new Box(3, 1000.0, 100.0, 100.0);
            b5.Position = new Vector3D(0.0, 900.0, 0.0);
            Box b6 = new Box(3, 100.0, 1000.0, 100.0);
            b6.Position = new Vector3D(900.0, 0.0, 0.0);

            Assert.False(b2.BoxInFront(b1, vDir));
            Assert.False(b3.BoxInFront(b1, vDir));
            Assert.False(b4.BoxInFront(b1, vDir));
            Assert.False(b4.BoxInFront(b2, vDir));
            Assert.False(b4.BoxInFront(b3, vDir));

            Assert.False(b3.BoxInFront(b5, vDir));
            Assert.False(b2.BoxInFront(b6, vDir));
        }
Exemple #2
0
 public void TestIsPointInFront()
 {
     Face f = new Face(0, Vector3D.Zero, new Vector3D(100.0, 0.0, 0.0), new Vector3D(100.0, 0.0, 100.0), new Vector3D(0.0, 0.0, 100.0));
     Vector3D viewDir = new Vector3D(1.0, 1.0, -1.0);
     Assert.False(f.PointIsInFront(new Vector3D(50.0, 100.0, 50.0), viewDir));
     Assert.True(f.PointIsInFront(new Vector3D(50.0, -100.0, 50.0), viewDir));
 }
Exemple #3
0
 public void TestIsPointBehind()
 {
     Box b1 = new Box(1, 100.0, 100.0, 100.0);
     Vector3D viewDir = new Vector3D(1.0, 1.0, -1.0);
     Assert.True(b1.PointBehind(new Vector3D(50.0, 150.0, 50.0), viewDir));            
     Assert.False(b1.PointBehind(new Vector3D(50.0, -150.0, 50.0), viewDir));
 }
Exemple #4
0
        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 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 void TestCompareOrtho()
        {
            Vector3D vCameraPos = new Vector3D(-10000.0, -10000.0, 10000.0);
            Vector3D vTarget = new Vector3D(0.0, 0.0, 0.0);
            BoxComparer comparer = new BoxComparer(vCameraPos, vTarget);

            Box b1 = new Box(1, 100.0, 100.0, 100.0);
            b1.Position = new Vector3D(900.0, 900.0, 0.0);
            Box b2 = new Box(2, 100.0, 100.0, 100.0);
            b2.Position = new Vector3D(800.0, 900.0, 0.0);
            Box b3 = new Box(3, 100.0, 100.0, 100.0);
            b3.Position = new Vector3D(900.0, 800.0, 0.0);
            Box b4 = new Box(4, 100.0, 100.0, 100.0);
            b4.Position = new Vector3D(800.0, 800.0, 0.0);

            Assert.AreEqual(0, comparer.Compare(b1, b1));

            Assert.AreEqual(-1, comparer.Compare(b1, b2));
            Assert.AreEqual(1, comparer.Compare(b2, b1));
            Assert.AreEqual(-1, comparer.Compare(b1, b3));
            Assert.AreEqual(1, comparer.Compare(b3, b1));
            Assert.AreEqual(-1, comparer.Compare(b1, b4));
            Assert.AreEqual(1, comparer.Compare(b4, b1));
            Assert.AreEqual(-1, comparer.Compare(b2, b4));
            Assert.AreEqual(1, comparer.Compare(b4, b2));
            Assert.AreEqual(-1, comparer.Compare(b3, b4));
            Assert.AreEqual(1, comparer.Compare(b4, b3));
        }
Exemple #7
0
        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 DimensionCube(Basics.BBox3D bbox, Color color, bool above)
 {
     _position = bbox.PtMin;
     _dim[0] = bbox.Length; _dim[1] = bbox.Width; _dim[2] = bbox.Height;
     _color = color;
     _above = above;
     for (int i = 0; i < 3; ++i) _showArrow[i] = true;
     BuildPoints();
 }
 public DimensionCube(Vector3D position, double length, double width, double height, Color color, bool above)
 {
     _position = position;
     _dim[0] = length; _dim[1] = width; _dim[2] = height;
     _color = color;
     _above = above;
     for (int i = 0; i < 3; ++i) _showArrow[i] = true;
     BuildPoints();
 }
        public PalletCap(uint pickId, PalletCapProperties capProperties, Vector3D position)
        {
            _dim[0] = capProperties.Length;
            _dim[1] = capProperties.Width;
            _dim[2] = capProperties.Height;

            _color = capProperties.Color;

            Position = position;
        }
Exemple #11
0
        //����������ϵ�еĶ������ù����任���ֲ�����ϵ��
        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);
        }
Exemple #12
0
 private PalletData(string name, string description, Vector3D[] lumbers, Position[] positions, Vector3D dimensions, double weight, Color color)
 {
     _name = name;
     _description = description;
     _lumbers = new List<Vector3D>(lumbers);
     _positions = new List<Position>(positions);
     _defaultDimensions = dimensions;
     _weight = weight;
     _color = color;
 }
Exemple #13
0
        public void Extend(Vector3D vec)
        {
            _ptMin.X = Math.Min(_ptMin.X, vec.X);
            _ptMin.Y = Math.Min(_ptMin.Y, vec.Y);
            _ptMin.Z = Math.Min(_ptMin.Z, vec.Z);

            _ptMax.X = Math.Max(_ptMax.X, vec.X);
            _ptMax.Y = Math.Max(_ptMax.Y, vec.Y);
            _ptMax.Z = Math.Max(_ptMax.Z, vec.Z);

        }
Exemple #14
0
 public FilmRectangle(
     Vector3D origin,
     HalfAxis.HAxis axis1, HalfAxis.HAxis axis2,
     Vector2D dimensions,
     double dBorder)
 {
     _origin = origin;
     _axis1 = axis1;
     _axis2 = axis2;
     _dimensions = dimensions;
     _dBorder = dBorder;
 }
Exemple #15
0
        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);
        }
Exemple #16
0
 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 CaseOptimConstraintSet(
     int[] noWalls
     , double wallThickness, double wallSurfaceMass
     , Vector3D caseLimitMin, Vector3D caseLimitMax
     , bool forceVerticalCaseOrientation)
 {
     NoWalls = noWalls;
     _wallThickness = wallThickness;
     _wallSurfaceMass = wallSurfaceMass;
     _caseLimitMin = caseLimitMin;
     _caseLimitMax = caseLimitMax;
     _forceVerticalCaseOrientation = forceVerticalCaseOrientation;
 }
Exemple #18
0
        static void Main(string[] args)
        {
            BoxProperties bProperties = new BoxProperties(null, 1000, 750, 500);
            Box b = new Box(0, bProperties);

            Vector3D vNear = new Vector3D(400.0, 1000.0, 0.0);
            Vector3D vFar = new Vector3D(500.0, -1000.0, 250.0);
            Ray r = new Ray(vNear, vFar);

            Vector3D ptInter;
            if (b.RayIntersect(r, out ptInter))
                Console.WriteLine("Point inter : {0}", ptInter);
            else
                Console.WriteLine("No intersection found");
        }
Exemple #19
0
 public void TestIsPointBehind()
 {
     Face f = new Face(0, Vector3D.Zero, new Vector3D(100.0, 0.0, 0.0), new Vector3D(100.0, 0.0, 100.0), new Vector3D(0.0, 0.0, 100.0));
     Vector3D viewDir0 = new Vector3D(1.0, 1.0, -1.0);
     Assert.True(f.PointIsBehind(new Vector3D(50.0, 100.0, 50.0), viewDir0));
     Assert.False(f.PointIsBehind(new Vector3D(50.0, -100.0, 50.0), viewDir0));
     Vector3D viewDir1 = new Vector3D(-1.0, 1.0, -1.0);
     Assert.True(f.PointIsBehind(new Vector3D(50.0, 100.0, 50.0), viewDir1));
     Assert.False(f.PointIsBehind(new Vector3D(50.0, -100.0, 50.0), viewDir1));
     Vector3D viewDir2 = new Vector3D(-1.0, -1.0, -1.0);
     Assert.False(f.PointIsBehind(new Vector3D(50.0, 100.0, 50.0), viewDir2));
     Assert.True(f.PointIsBehind(new Vector3D(50.0, -100.0, 50.0), viewDir2));
     Vector3D viewDir3 = new Vector3D(1.0, -1.0, -1.0);
     Assert.False(f.PointIsBehind(new Vector3D(50.0, 100.0, 50.0), viewDir3));
     Assert.True(f.PointIsBehind(new Vector3D(50.0, -100.0, 50.0), viewDir3));
 }
        // static methods
        static public double EstimateWeight(
            BoxProperties boxProperties, PackArrangement arrangement, HalfAxis.HAxis orientation
            , int[] noWalls, double thickness, double surfacicMass)
        {
            double length = 0.0, width = 0.0, height = 0.0;
            PackProperties.GetDimensions(boxProperties, orientation, arrangement, ref length, ref width, ref height);
            Vector3D vDimensions = new Vector3D(
                length + noWalls[0] * thickness
                , width + noWalls[1] * thickness
                , height + noWalls[2] * thickness);

            double area = (noWalls[0] * vDimensions.Y * vDimensions.Z
                + noWalls[1] * vDimensions.X * vDimensions.Z
                + noWalls[2] * vDimensions.X * vDimensions.Y) * UnitsManager.FactorSquareLengthToArea;
            return area * surfacicMass;
        }
Exemple #21
0
 public static HAxis ToHalfAxis(Vector3D v)
 {
     const double eps = 1.0E-03;
     v.Normalize();
     if (Math.Abs(Vector3D.DotProduct(v, -Vector3D.XAxis) - 1) < eps)
         return HAxis.AXIS_X_N;
     else if (Math.Abs(Vector3D.DotProduct(v, Vector3D.XAxis) - 1) < eps)
         return HAxis.AXIS_X_P;
     else if (Math.Abs(Vector3D.DotProduct(v, -Vector3D.YAxis) - 1) < eps)
         return HAxis.AXIS_Y_N;
     else if (Math.Abs(Vector3D.DotProduct(v, Vector3D.YAxis) - 1) < eps)
         return HAxis.AXIS_Y_P;
     else if (Math.Abs(Vector3D.DotProduct(v, -Vector3D.ZAxis) - 1) < eps)
         return HAxis.AXIS_Z_N;
     else
         return HAxis.AXIS_Z_P;
 }
Exemple #22
0
        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);
            }
        }
 public BBox3D BBox(double radius, double length)
 {
     Transform3D t = Transf;
     Vector3D[] pts = new Vector3D[]
         {
             new Vector3D(0.0, -radius, -radius),
             new Vector3D(0.0, -radius, radius),
             new Vector3D(0.0, radius, -radius),
             new Vector3D(0.0, radius, radius),
             new Vector3D(length, -radius, -radius),
             new Vector3D(length, -radius, radius),
             new Vector3D(length, radius, -radius),
             new Vector3D(length, radius, radius)
         };
     BBox3D bbox = new BBox3D();
     foreach (Vector3D pt in pts)
         bbox.Extend(t.transform(pt));
     return bbox;
 }
Exemple #24
0
        bool RayIntersect(Ray ray, out uint id, out uint layerId, out Vector3D v)
        {
            id = 0;
            layerId = 0;
            v = new Vector3D();

            List<PickResult> results = new List<PickResult>();

            foreach (PickItem item in _items)
            {
                Vector3D ptInter;
                if (item.Box.RayIntersect(ray, out ptInter))
                {
                    results.Add(new PickResult());
                }
            }
            results.Sort();

            return results.Count > 0;
        }
        public void AddPosition(CylLoad load, CylPosition pos)
        {
            Matrix4D matRot = Matrix4D.Identity;
            Vector3D vTranslation = Vector3D.Zero;

            if (_swapped)
            {
                matRot = new Matrix4D(
                    0.0, -1.0, 0.0, 0.0
                    , 1.0, 0.0, 0.0, 0.0
                    , 0.0, 0.0, 1.0, 0.0
                    , 0.0, 0.0, 0.0, 1.0
                    );
                vTranslation = new Vector3D(load.PalletLength, 0.0, 0.0);

                matRot.M14 = vTranslation[0];
                matRot.M24 = vTranslation[1];
                matRot.M34 = vTranslation[2];
            }

            load.Add(pos.Transform(new Transform3D(matRot)));
        }
Exemple #26
0
 public static Vector3D ConvertLengthFrom(Vector3D 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));
         StandardMeasure<Length> measureZ = new StandardMeasure<Length>(value.Z, LengthUnitFromUnitSystem(unitSystem));
         return new Vector3D(
             measureX.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
             , measureY.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
             , measureZ.GetAmount(LengthUnitFromUnitSystem(CurrentUnitSystem))
             );
     }
 }
 public BoxPosition(Vector3D vPosition, HalfAxis.HAxis dirLength, HalfAxis.HAxis dirWidth)
 {
     _vPosition = vPosition;
     _axisLength = dirLength;
     _axisWidth = dirWidth;
 }
        private BoxPosition GetPosition(int i, int j, int k, int dim0, int dim1)
        {
            double boxLength = _caseDefinition.BoxLength(_boxProperties);
            double boxWidth = _caseDefinition.BoxWidth(_boxProperties);
            double boxHeight = _caseDefinition.BoxHeight(_boxProperties);
            HalfAxis.HAxis dirLength = HalfAxis.HAxis.AXIS_X_P;
            HalfAxis.HAxis dirWidth = HalfAxis.HAxis.AXIS_Y_P;

            Vector3D vPosition = Vector3D.Zero;
            if (0 == dim0 && 1 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_X_P;
                dirWidth = HalfAxis.HAxis.AXIS_Y_P;
                vPosition = Vector3D.Zero;
            }
            else if (0 == dim0 && 2 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_X_P;
                dirWidth = HalfAxis.HAxis.AXIS_Z_N;
                vPosition = new Vector3D(0.0, 0.0, _boxProperties.Width);
            }
            else if (1 == dim0 && 0 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Y_P;
                dirWidth = HalfAxis.HAxis.AXIS_X_N;
                vPosition = new Vector3D(_boxProperties.Width, 0.0, 0.0);
            }
            else if (1 == dim0 && 2 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Z_N;
                dirWidth = HalfAxis.HAxis.AXIS_X_P;
                vPosition = new Vector3D(0.0, _boxProperties.Height, _boxProperties.Length);
            }
            else if (2 == dim0 && 0 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Y_P;
                dirWidth = HalfAxis.HAxis.AXIS_Z_N;
                vPosition = new Vector3D(_boxProperties.Height, 0.0, _boxProperties.Width);
            }
            else if (2 == dim0 && 1 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Z_P;
                dirWidth = HalfAxis.HAxis.AXIS_Y_P;
                vPosition = new Vector3D(_boxProperties.Height, 0.0, 0.0);
            }
            // add wall thickness
            vPosition += new Vector3D(
                _caseOptimConstraintSet.NoWalls[0] * _caseOptimConstraintSet.WallThickness * 0.5
                , _caseOptimConstraintSet.NoWalls[1] * _caseOptimConstraintSet.WallThickness * 0.5
                , _caseOptimConstraintSet.NoWalls[2] * _caseOptimConstraintSet.WallThickness * 0.5);

            // apply global transformation using _dir0 / _dir1
            return BoxPosition.Transform(
                new BoxPosition(vPosition + new Vector3D(i * boxLength, j * boxWidth, k * boxHeight), dirLength, dirWidth)
                , GlobalTransformation
                );
        }
Exemple #29
0
        private Point[] TransformPoint(Vector3D[] points3d)
        {
            float aspectRatio = (float)Size.Width / ((float)Size.Height * _numberOfViews);
            float viewportRatio = (_viewport[2] - _viewport[0]) / (_viewport[3] - _viewport[1]);
            float margin = 0.1f * (_viewport[2] - _viewport[0]);

            Point[] points = new Point[points3d.Length];
            int i=0;
            foreach (Vector3D v in points3d)
            {
                if (viewportRatio > aspectRatio)
                {
                    points[i].X = (int)
                        (
                        (float)(Size.Width / _numberOfViews)
                        * (_iIndexView + (v.X - _viewport[0] + margin) / (_viewport[2] - _viewport[0] + 2.0f * margin))
                        );
                    points[i].Y = (int)
                        (
                        Size.Height * aspectRatio / viewportRatio * (v.Y - _viewport[1] + margin) / (_viewport[3] - _viewport[1] + 2.0f * margin)
                        );
                }
                else
                {
                    points[i].X = (int)
                        (
                        (float)(Size.Width / _numberOfViews)
                        * (_iIndexView + (viewportRatio / aspectRatio) * (v.X - _viewport[0] + margin) / (_viewport[2] - _viewport[0] + 2.0f * margin))
                        );
                    points[i].Y = (int)
                        (
                        Size.Height * (v.Y - _viewport[1] + margin) / (_viewport[3] - _viewport[1] + 2.0f * margin)
                        );
                }
                ++i;
            }
            return points;
        }
Exemple #30
0
        BoxPosition GetPosition(int i, int j, int k, int dim0, int dim1)
        {
            BoxProperties boxProperties = _packProperties.Box;
            double boxLength = boxProperties.Dim(dim0);
            double boxWidth =  boxProperties.Dim(dim1);
            double boxHeight =  boxProperties.Dim(3 - dim0 - dim1);
            HalfAxis.HAxis dirLength = HalfAxis.HAxis.AXIS_X_P;
            HalfAxis.HAxis dirWidth = HalfAxis.HAxis.AXIS_Y_P;
            Vector3D vPosition = Vector3D.Zero;
            if (0 == dim0 && 1 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_X_P;
                dirWidth = HalfAxis.HAxis.AXIS_Y_P;
                vPosition = Vector3D.Zero;
            }
            else if (0 == dim0 && 2 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_X_P;
                dirWidth = HalfAxis.HAxis.AXIS_Z_N;
                vPosition = new Vector3D(0.0, 0.0, boxProperties.Width);
            }
            else if (1 == dim0 && 0 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Y_P;
                dirWidth = HalfAxis.HAxis.AXIS_X_N;
                vPosition = new Vector3D(boxProperties.Width, 0.0, 0.0);
            }
            else if (1 == dim0 && 2 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Z_N;
                dirWidth = HalfAxis.HAxis.AXIS_X_P;
                vPosition = new Vector3D(0.0, boxProperties.Height, boxProperties.Length);
            }
            else if (2 == dim0 && 0 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Y_P;
                dirWidth = HalfAxis.HAxis.AXIS_Z_N;
                vPosition = new Vector3D(boxProperties.Height, 0.0, boxProperties.Width);
            }
            else if (2 == dim0 && 1 == dim1)
            {
                dirLength = HalfAxis.HAxis.AXIS_Z_P;
                dirWidth = HalfAxis.HAxis.AXIS_Y_P;
                vPosition = new Vector3D(boxProperties.Height, 0.0, 0.0);
            }
            // add offset
            vPosition += Vector3D.Zero;

            Vector3D vOffset = new Vector3D(
                0.5 * (_packProperties.Length - _packProperties.InnerLength)
                , 0.5 * (_packProperties.Width - _packProperties.InnerWidth)
                , 0.5 * (_packProperties.Height - _packProperties.InnerHeight)
                );

            // apply global transformation using _dir0 / _dir1
            return BoxPosition.Transform(
                new BoxPosition(
                    vPosition + vOffset + new Vector3D(i * boxLength, j * boxWidth, k * boxHeight)
                    , dirLength
                    , dirWidth)
                , GlobalTransformation
                );
        }