public ImpositionTool(IEntityContainer container)
        {
            _initialEntities = container;

            using (PicFactory factory = new PicFactory(container))
            {
                // compute lengthes
                PicVisitorDieCutLength visitor = new PicVisitorDieCutLength();
                factory.ProcessVisitor(visitor);
                Dictionary <PicGraphics.LT, double> lengthes = visitor.Lengths;
                _unitLengthCut  = lengthes.ContainsKey(PicGraphics.LT.LT_CUT) ? visitor.Lengths[PicGraphics.LT.LT_CUT] : 0.0;
                _unitLengthFold = lengthes.ContainsKey(PicGraphics.LT.LT_CREASING) ? visitor.Lengths[PicGraphics.LT.LT_CREASING] : 0.0;
                // compute area
                try
                {
                    PicToolArea picToolArea = new PicToolArea();
                    factory.ProcessTool(picToolArea);
                    _unitArea = picToolArea.Area;
                }
                catch (PicToolTooLongException /*ex*/)
                {
                    _unitArea = 0;
                }
            }
        }
예제 #2
0
        public void CreateEntities(PicFactory factory)
        {
            if (!(listBoxSolutions.SelectedItem is ImpositionSolution solution))
            {
                return;
            }
            solution.CreateEntities(factory);

            // insert dimensions
            short grp = 0;

            if (PicCotation.GetBBCotations(solution.Bbox, CotTypeBB, 0.1, out Vector2D pt0, out Vector2D pt1, out Vector2D pt2, out Vector2D pt3, out double delta0, out double delta1))
            {
                PicCotationDistance cotH = factory.AddCotation(PicCotation.CotType.COT_HORIZONTAL, grp, 0, pt0, pt1, delta0, "", 1) as PicCotationDistance;
                cotH.UseShortLines = true;
                cotH.Auto          = true;

                PicCotationDistance cotV = factory.AddCotation(PicCotation.CotType.COT_VERTICAL, grp, 0, pt2, pt3, delta1, "", 1) as PicCotationDistance;
                cotV.UseShortLines = true;
                cotV.Auto          = true;
            }


            if (null != Format && PicCotation.GetBBCotations(new Box2D(solution.CardboardPosition, solution.CardboardDimensions), CotTypeFormat, 0.1, out Vector2D ptf0, out Vector2D ptf1, out Vector2D ptf2, out Vector2D ptf3, out double deltaf0, out double deltaf1))
            {
                PicCotationDistance cotH = factory.AddCotation(PicCotation.CotType.COT_HORIZONTAL, grp, 0, ptf0, ptf1, deltaf0, "", 1) as PicCotationDistance;
                cotH.UseShortLines = true;
                cotH.Auto          = false;

                PicCotationDistance cotV = factory.AddCotation(PicCotation.CotType.COT_VERTICAL, grp, 0, ptf2, ptf3, deltaf1, "", 1) as PicCotationDistance;
                cotV.UseShortLines = true;
                cotV.Auto          = false;
            }
            factory.InsertCardboardFormat(solution.CardboardPosition, solution.CardboardDimensions);
        }
예제 #3
0
        public void Dimensions(ParameterStack stack, out double width, out double height, out double lengthCut, out double lengthFold)
        {
            // build factory
            PicFactory factory = new PicFactory();

            Component.CreateFactoryEntities(factory, stack);
            if (ReflexionX)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
            }
            if (ReflexionY)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
            }
            // get bounding box
            PicVisitorBoundingBox visitorBoundingBox = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitorBoundingBox, ShowCotations ? PicFilter.FilterNone : !PicFilter.FilterCotation);
            Box2D box = visitorBoundingBox.Box;

            width  = box.Width;
            height = box.Height;
            // get length
            PicVisitorDieCutLength visitorLength = new PicVisitorDieCutLength();

            factory.ProcessVisitor(visitorLength, PicFilter.FilterNone);
            lengthCut  = visitorLength.Lengths.ContainsKey(PicGraphics.LT.LT_CUT) ? visitorLength.Lengths[PicGraphics.LT.LT_CUT] : 0.0;
            lengthFold = visitorLength.Lengths.ContainsKey(PicGraphics.LT.LT_CREASING) ? visitorLength.Lengths[PicGraphics.LT.LT_CREASING] : 0.0;
        }
예제 #4
0
        private void LoadDrawing(string filePath, string fileExt)
        {
            factoryViewCtrl.Visible = true;

            PicFactory factory = factoryViewCtrl.Factory;

            if (string.Equals("des", fileExt, StringComparison.CurrentCultureIgnoreCase))
            {
                PicLoaderDes picLoaderDes = new PicLoaderDes(factory);
                using (DES_FileReader fileReader = new DES_FileReader())
                    fileReader.ReadFile(filePath, picLoaderDes);
                // remove existing quotations
                factory.Remove((new PicFilterCode(PicEntity.eCode.PE_COTATIONDISTANCE))
                               | (new PicFilterCode(PicEntity.eCode.PE_COTATIONHORIZONTAL))
                               | (new PicFilterCode(PicEntity.eCode.PE_COTATIONVERTICAL)));
                // build autoquotation
                PicAutoQuotation.BuildQuotation(factory);
            }
            else if (string.Equals("dxf", fileExt, StringComparison.CurrentCultureIgnoreCase))
            {
                using (PicLoaderDxf picLoaderDxf = new PicLoaderDxf(factory))
                {
                    picLoaderDxf.Load(filePath);
                    picLoaderDxf.FillFactory();
                }
            }
            // update factoryViewCtrl
            factoryViewCtrl.FitView();
        }
        public static void Generate(string pluginPath, out Image bmp, Size size, PicFilter filter)
        {
            // instantiate factory
            PicFactory factory = new PicFactory();

            factory.Clear();

            // instantiate plugin
            Pic.Plugin.PluginServices pluginHost = new Pic.Plugin.PluginServices(pluginPath);
            IPlugin plugin = pluginHost.GetFirstPlugin();

            // generate entities
            ParameterStack stack = plugin.Parameters;

            plugin.CreateFactoryEntities(factory, stack);

            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitor);

            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage();

            picImage.ImageSize = size;
            PicBox2D box = visitor.Box;

            box.AddMarginRatio(0.05);
            picImage.DrawingBox = box;
            factory.Draw(picImage, filter);

            bmp = picImage.Bitmap;
        }
예제 #6
0
        public void GenerateImage(Size size, ParameterStack stack, out Image bmp)
        {
            // check if plugin was instantiated
            if (null == Component)
            {
                throw new Exception("No valid plugin instance loaded!");
            }

            // instantiate factory
            PicFactory factory = new PicFactory();

            // generate entities
            Component.CreateFactoryEntities(factory, stack);
            // apply any needed transformation
            if (ReflexionX)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
            }
            if (ReflexionY)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
            }
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, Factory2D.Tools.BoundingBox(factory, 0.05));

            factory.Draw(picImage, ShowCotations ? PicFilter.FilterNone : !PicFilter.FilterCotation);

            bmp = picImage.Bitmap;
        }
예제 #7
0
 public PicLoaderDes(PicFactory factory)
 {
     // initialize data member factory
     _factory = factory;
     // clear factory before loading data
     _factory.Clear();
 }
예제 #8
0
 public void CreateEntities(PicFactory factory)
 {
     ImpositionSolution solution = listBoxSolutions.SelectedItem as ImpositionSolution;
     if (null == solution) return;
     solution.CreateEntities(factory);
     factory.InsertCardboardFormat(solution.CardboardPosition, solution.CardboardDimensions);
 }
예제 #9
0
 public void BuildLayout()
 {
     using (PicFactory factory = new PicFactory())
     {
         // build factory entities
         Component.CreateFactoryEntities(factory, CurrentParameterStack);
         if (ReflectionX)
         {
             factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
         }
         if (ReflectionY)
         {
             factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
         }
         var form = new FormImposition()
         {
             FormatLoader = CardboardFormatLoader,
             Factory      = factory,
             Offset       = Component.ImpositionOffset(CurrentParameterStack)
         };
         if (DialogResult.OK == form.ShowDialog())
         {
         }
     }
 }
예제 #10
0
        private bool LoadDrawing(string filePath)
        {
            try
            {
                // show factory viewer control
                _factoryViewer.Visible = true;
                // get factory reference
                PicFactory factory = _factoryViewer.Factory;
                // clear factory
                factory.Clear();

                string fileExt = System.IO.Path.GetExtension(filePath).ToLower();
                if (string.Equals(".des", fileExt, StringComparison.CurrentCultureIgnoreCase))
                {
                    // load des file
                    DES_FileReader fileReader = new DES_FileReader();
                    PicLoaderDes   picLoader  = new PicLoaderDes(factory);
                    fileReader.ReadFile(filePath, picLoader);
                }
                else if (string.Equals(".dxf", fileExt, StringComparison.CurrentCultureIgnoreCase))
                {
                    // load dxf file
                    PicLoaderDxf picLoader = new PicLoaderDxf(factory);
                    picLoader.Load(filePath);
                    picLoader.FillFactory();
                }
                // fit view to loaded entities
                _factoryViewer.FitView();
            }
            catch (Exception /*ex*/)
            {
            }
            return(true);
        }
예제 #11
0
        public void GenerateImage(Size size, ParameterStack stack, out Image bmp)
        {
            // check if plugin was instantiated
            if (null == _component)
            {
                throw new Exception("No valid plugin instance loaded!");
            }

            // instantiate factory
            PicFactory factory = new PicFactory();

            // generate entities
            _component.CreateFactoryEntities(factory, stack);
            // apply any needed transformation
            if (_reflexionX)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
            }
            if (_reflexionY)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
            }
            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitor);
            Pic.Factory2D.Box2D box = visitor.Box;
            box.AddMarginRatio(0.05);
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, box);

            factory.Draw(picImage, _showCotations ? PicFilter.FilterNone : !PicFilter.FilterCotation);

            bmp = picImage.Bitmap;
        }
예제 #12
0
        public static void GenerateImage(Size size, string filePath, string thumbnailFilePath)
        {
            // load file
            PicFactory factory = new PicFactory();
            string     fileExt = System.IO.Path.GetExtension(filePath);

            if (string.Equals(".des", fileExt, StringComparison.CurrentCultureIgnoreCase))
            {
                PicLoaderDes picLoaderDes = new PicLoaderDes(factory);
                using (DES_FileReader fileReader = new DES_FileReader())
                    fileReader.ReadFile(filePath, picLoaderDes);
            }
            else if (string.Equals(".dxf", fileExt, StringComparison.CurrentCultureIgnoreCase))
            {
                using (PicLoaderDxf picLoaderDxf = new PicLoaderDxf(factory))
                {
                    picLoaderDxf.Load(filePath);
                    picLoaderDxf.FillFactory();
                }
            }
            // draw image
            Image bmp;

            ThumbnailGenerator.GenerateImage(size, factory, false, out bmp);
            bmp.Save(thumbnailFilePath);
        }
예제 #13
0
 public PicLoaderDes(PicFactory factory)
 {
     // initialize data member factory
     Factory = factory;
     // clear factory before loading data
     Factory.Clear();
 }
        public static void Generate(string pluginPath, out Image bmp, Size size, PicFilter filter)
        {
            // instantiate factory
            PicFactory factory = new PicFactory();
            factory.Clear();

            // instantiate plugin
            Pic.Plugin.PluginServices pluginHost = new Pic.Plugin.PluginServices(pluginPath);
            IPlugin plugin = pluginHost.GetFirstPlugin();

            // generate entities
            ParameterStack stack = plugin.Parameters;
            plugin.CreateFactoryEntities(factory, stack);

            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
            factory.ProcessVisitor(visitor);

            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage();
            picImage.ImageSize = size;
            PicBox2D box = visitor.Box;
            box.AddMarginRatio(0.05);
            picImage.DrawingBox = box;
            factory.Draw(picImage, filter);

            bmp = picImage.Bitmap;
        }
예제 #15
0
 public override void Initialize(PicFactory factory)
 {
     _exporter.Initialize();
     // 
     PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
     factory.ProcessVisitor(visitor);
     _exporter.SetBoundingBox(visitor.Box.XMin, visitor.Box.YMin, visitor.Box.XMax, visitor.Box.YMax);
 }
예제 #16
0
 public void CreateEntities(PicFactory factory)
 {
     if (!(listBoxSolutions.SelectedItem is ImpositionSolution solution))
     {
         return;
     }
     solution.CreateEntities(factory);
     factory.InsertCardboardFormat(solution.CardboardPosition, solution.CardboardDimensions);
 }
예제 #17
0
        public override void Initialize(PicFactory factory)
        {
            _exporter.Initialize();
            _exporter.AuthoringTool = _authoringTool;
            // set bounding box
            Box2D bbox = Tools.BoundingBox(factory, 0.0);

            _exporter.SetBoundingBox(bbox.XMin, bbox.YMin, bbox.XMax, bbox.YMax);
        }
예제 #18
0
        public override void Initialize(PicFactory factory)
        {
            _exporter.Initialize();
            //
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitor);
            _exporter.SetBoundingBox(visitor.Box.XMin, visitor.Box.YMin, visitor.Box.XMax, visitor.Box.YMax);
        }
예제 #19
0
        /*
         * internal ImpositionPattern GeneratePattern(int id, Vector2D minDistance, Vector2D impositionOffset, bool orthoImp)
         * {
         *  ImpositionPattern pattern = null;
         *
         *  KeyValuePair<int, bool> kvpIndexOrtho = new KeyValuePair<int, bool>(id, orthoImp);
         *  switch (id)
         *  {
         *      case 0: pattern = new PatternDefault(); break;
         *      case 1: pattern = new PatternRotationInRow(); break;
         *      case 2: pattern = new PatternRotationInColumn(); break;
         *  }
         *  return pattern;
         * }
         */
        #endregion

        #region Public methods
        public bool GenerateEntities(string patternName, bool orthogonalImposition, ref PicFactory factory)
        {
            ImpositionPattern pattern = GetPatternByName(patternName);

            pattern.GeneratePattern(InitialEntities, SpaceBetween, ImpositionOffset, orthogonalImposition);
            ImpositionSolution solution = GenerateSolution(pattern, orthogonalImposition);

            solution.CreateEntities(factory);
            return(true);
        }
예제 #20
0
        public static void GenerateImage(Size size, PicFactory factory, bool showCotations, out Image bmp)
        {
            // get bounding box
            Box2D box = Tools.BoundingBox(factory, 0.05);
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, box);

            factory.Draw(picImage, showCotations ? PicFilter.FilterNone : !PicFilter.FilterCotation);

            bmp = picImage.Bitmap;
        }
예제 #21
0
        public static void GenerateImage(Size size, PicFactory factory, bool showCotations, out Image bmp)
        {
            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
            factory.ProcessVisitor(visitor);
            Box2D box = visitor.Box;
            box.AddMarginRatio(0.05);
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, box);
            factory.Draw(picImage, showCotations ? PicFilter.FilterNone : PicFilter.FilterCotation);

            bmp = picImage.Bitmap;            
        }
예제 #22
0
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            double L         = stack.GetDoubleParameterValue("L");
            double H         = stack.GetDoubleParameterValue("H");
            double R         = stack.GetDoubleParameterValue("R");
            bool   Rounding0 = stack.GetBoolParameterValue("Rounding0");
            bool   Rounding1 = stack.GetBoolParameterValue("Rounding1");
            bool   Rounding2 = stack.GetBoolParameterValue("Rounding2");
            bool   Rounding3 = stack.GetBoolParameterValue("Rounding3");
            double Ang       = stack.GetDoubleParameterValue("Angle") * Math.PI / 180.0;

            // segments
            PicFactory       fTemp      = new PicFactory();
            List <PicEntity> entityList = new List <PicEntity>();

            entityList.Add(fTemp.AddSegment(
                               PicGraphics.LT.LT_CUT
                               , new Vector2D(0.0, 0.0)
                               , new Vector2D(L * Math.Cos(Ang), L * Math.Sin(Ang))));
            entityList.Add(fTemp.AddSegment(
                               PicGraphics.LT.LT_CUT
                               , new Vector2D(L * Math.Cos(Ang), L * Math.Sin(Ang))
                               , new Vector2D(L * Math.Cos(Ang) - H * Math.Sin(Ang), L * Math.Sin(Ang) + H * Math.Cos(Ang))));
            entityList.Add(fTemp.AddSegment(
                               PicGraphics.LT.LT_CUT
                               , new Vector2D(L * Math.Cos(Ang) - H * Math.Sin(Ang), L * Math.Sin(Ang) + H * Math.Cos(Ang))
                               , new Vector2D(-H * Math.Sin(Ang), H * Math.Cos(Ang))));
            entityList.Add(fTemp.AddSegment(
                               PicGraphics.LT.LT_CUT
                               , new Vector2D(-H * Math.Sin(Ang), H * Math.Cos(Ang))
                               , new Vector2D(0.0, 0.0)));

            if (Rounding0)
            {
                fTemp.ProcessTool(new PicToolRound(entityList[0], entityList[1], R));
            }
            if (Rounding1)
            {
                fTemp.ProcessTool(new PicToolRound(entityList[1], entityList[2], R));
            }
            if (Rounding2)
            {
                fTemp.ProcessTool(new PicToolRound(entityList[2], entityList[3], R));
            }
            if (Rounding3)
            {
                fTemp.ProcessTool(new PicToolRound(entityList[3], entityList[0], R));
            }

            factory.AddEntities(fTemp, transform);
        }
예제 #23
0
 public void GenerateThumbnail()
 {
     using (PicFactory factory = new PicFactory())
     {
         CreateEntities(factory);
         // insert format
         factory.InsertCardboardFormat(CardboardPosition, CardboardDimensions);
         // draw thumbnail
         PicGraphicsImage picImage = new PicGraphicsImage(new Size(ThumbnailWidth, ThumbnailWidth), Tools.BoundingBox(factory, PicFilter.FilterNone, 0.01));
         factory.Draw(picImage);
         // save thumbnail
         Thumbnail = picImage.Bitmap;
     }
 }
예제 #24
0
        // global quotation
        private void BuildGlobalQuotation(PicFactory factory, short grp, Box2D box)
        {
            if (!box.IsValid)
            {
                return;
            }
            double delta             = 0.1 * Math.Max(box.Width, box.Height);
            PicCotationDistance cotH = factory.AddCotation(PicCotation.CotType.COT_HORIZONTAL, grp, 0, box.PtMin, new Vector2D(box.XMax, box.YMin), -delta, "", 1) as PicCotationDistance;

            cotH.UseShortLines = true;
            PicCotationDistance cotV = factory.AddCotation(PicCotation.CotType.COT_VERTICAL, grp, 0, box.PtMin, new Vector2D(box.XMin, box.YMax), delta, "", 1) as PicCotationDistance;

            cotV.UseShortLines = true;
        }
예제 #25
0
        public static void ProcessEntities(PicFactory factory, Dictionary <PicGraphics.LT, CutTool> dictTool, ref List <PicTypedDrawable> entities)
        {
            if (null == entities)
            {
                entities = new List <PicTypedDrawable>();
            }
            entities.Clear();
            // get factory bounding box
            PicVisitorBoundingBox visitorBBox = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitorBBox, new PicFilterTypedDrawable());
            // translate factory
            PicVisitorTransform visitorTranslation = new PicVisitorTransform(Transform2D.Translation(-visitorBBox.Box.PtMin));

            factory.ProcessVisitor(visitorTranslation, new PicFilter());
            // sort entities by type
            Vector2D currentPt = Vector2D.Zero;

            foreach (PicGraphics.LT lt in dictTool.Keys)
            {
                // get entities with linetype = lt
                PicVisitorCollectTypedDrawables visitorCollect = new PicVisitorCollectTypedDrawables();
                factory.ProcessVisitor(visitorCollect, new PicFilterLineType(lt));
                List <PicTypedDrawable> tempList1 = visitorCollect.Entities;

                // move entities from tempList1 to tempList2 from point to point
                List <PicTypedDrawable> tempList2 = new List <PicTypedDrawable>();

                while (tempList1.Count > 0)
                {
                    int    index   = 0;
                    double minDist = double.MaxValue;
                    for (int i = 0; i < tempList1.Count; ++i)
                    {
                        double dist = DistanceEntityPt(tempList1[i], currentPt);
                        if (dist < minDist)
                        {
                            index   = i;
                            minDist = dist;
                        }
                    }
                    currentPt = OppositePoint(tempList1[index], currentPt);
                    tempList2.Add(tempList1[index]);
                    tempList1.RemoveAt(index);
                }
                // concatenate list
                entities.AddRange(tempList2);
            }
        }
예제 #26
0
        public PicFactory GetFactory()
        {
            PicFactory factory = new PicFactory();

            Component.CreateFactoryEntities(factory, CurrentParameterStack);
            if (_reflectionX)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
            }
            if (_reflectionY)
            {
                factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
            }
            return(factory);
        }
예제 #27
0
        public static void BuildQuotation(PicFactory factory)
        {
            PicAutoQuotation autoQuotation = new PicAutoQuotation();

            for (short grp = 0; grp < 16; ++grp)
            {
                // get min max box grp
                PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
                factory.ProcessVisitor(visitor, new PicFilterGroup(grp));

                autoQuotation.BuildHQuotation(factory, grp, visitor.Box);
                autoQuotation.BuildVQuotation(factory, grp, visitor.Box);
                autoQuotation.BuildGlobalQuotation(factory, grp, visitor.Box);
            }
        }
예제 #28
0
 private void onShowForm(object sender, EventArgs e)
 {
     try
     {
         PicFactory   factory      = new PicFactory();
         PicLoaderDes picLoaderDes = new PicLoaderDes(factory);
         using (DES_FileReader fileReader = new DES_FileReader())
             fileReader.ReadFile(FilePath, picLoaderDes);
         Generator.ShowProcessor(factory, "test");
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
 }
예제 #29
0
        public override void Initialize(PicFactory factory)
		{
			_box.Reset();
            try
            {
                if (null != factory.Format)
                    _box.Extend(factory.Format.Box);
                else if (factory.IsEmpty)
                    _box.Extend(Sharp3D.Math.Core.Vector2D.Zero);
            }
            catch (Exception ex)
            {
                _log.Error(ex.ToString());
            }
		}
예제 #30
0
        private bool LoadDrawing(string filePath)
        {
            try
            {
                // show factory viewer control
                factoryViewer.Visible = true;
                // get factory reference
                PicFactory factory = factoryViewer.Factory;
                // clear factory
                factory.Clear();

                string fileExt = System.IO.Path.GetExtension(filePath).ToLower();
                if (string.Equals(".des", fileExt, StringComparison.CurrentCultureIgnoreCase))
                {
                    // load des file
                    DES_FileReader fileReader = new DES_FileReader();
                    PicLoaderDes   picLoader  = new PicLoaderDes(factory);
                    fileReader.ReadFile(filePath, picLoader);
                }
                else if (string.Equals(".dxf", fileExt, StringComparison.CurrentCultureIgnoreCase))
                {
                    // load dxf file
                    PicLoaderDxf picLoader = new PicLoaderDxf(factory);
                    picLoader.Load(filePath);
                    picLoader.FillFactory();
                }
                else if (string.Equals(".ai", fileExt, StringComparison.CurrentCultureIgnoreCase))
                {
                    // load ai file
                }
                // fit view to loaded entities
                factoryViewer.FitView();

                if (textBoxName.Text.Length == 0)
                {
                    textBoxName.Text = System.IO.Path.GetFileNameWithoutExtension(filePath);
                }
                if (textBoxDescription.Text.Length == 0)
                {
                    textBoxDescription.Text = System.IO.Path.GetFileNameWithoutExtension(filePath);
                }
            }
            catch (Exception ex)
            {
                _log.Error(ex.ToString());
            }
            return(true);
        }
예제 #31
0
        public static Box2D BoundingBox(PicFactory factory, double marginRatio = 0.0, bool takePicBlocsIntoAccount = true)
        {
            var visitor = new PicVisitorBoundingBox()
            {
                TakePicBlocksIntoAccount = takePicBlocsIntoAccount
            };

            factory.ProcessVisitor(visitor, !PicFilter.FilterCotation);
            Box2D box = visitor.Box;

            if (box.IsValid && marginRatio > 0.0)
            {
                box.AddMarginRatio(marginRatio);
            }
            return(box);
        }
예제 #32
0
        public List <Guid> GetDependancies(ParameterStack stack)
        {
            // clear list of dependancies
            _dependancyList.Clear();
            // instanciate handler of ComponentLoader.OnPluginAccessed
            ComponentLoader.PluginAccessed handler = new ComponentLoader.PluginAccessed(OnGuidLoaded);
            ComponentLoader.OnPluginAccessed += handler;
            // instantiate factory
            PicFactory factory = new PicFactory();

            _instance.CreateFactoryEntities(factory, stack, Transform2D.Identity);
            // on plugin accessed
            ComponentLoader.OnPluginAccessed -= handler;
            // dependancy list
            return(_dependancyList);
        }
예제 #33
0
        public static void GenerateImage(Size size, PicFactory factory, bool showCotations, out Image bmp)
        {
            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();

            factory.ProcessVisitor(visitor);
            Box2D box = visitor.Box;

            box.AddMarginRatio(0.05);
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, box);

            factory.Draw(picImage, showCotations ? PicFilter.FilterNone : PicFilter.FilterCotation);

            bmp = picImage.Bitmap;
        }
예제 #34
0
        public static DESQuerier LoadFile(string filePath)
        {
            if (!File.Exists(filePath))
                throw new DESQuerierFileNotFoundException(filePath);
            // instantiate factory
            PicFactory factory = new PicFactory();
            // instantiate loader
            PicLoaderDes picLoader = new PicLoaderDes(factory);
            // load file
            DesLib4NET.DES_FileReader reader = new DES_FileReader();
            reader.ReadFile(filePath, picLoader);
            // test for valid entities

            // return DESQuerier
            return new DESQuerier(factory);
        }
 public void ComputeLengthCutFold()
 {
     if (_lengthCut <= 0)
     {
         _lengthCut = 0.0;
         using (PicFactory factory = new PicFactory())
         {
             // fill factory with entities
             CreateEntities(factory);
             // counting added length only
             PicVisitorComputeLength visitorComputeLength = new PicVisitorComputeLength();
             factory.ProcessVisitor(visitorComputeLength /*, new PicFilterLineType(PicGraphics.LT.LT_CUT)*/);
             // cut length
             _lengthCut = visitorComputeLength.Length;
         }
     }
 }
예제 #36
0
 /// <summary>
 /// Initialize DES_Writer object
 /// </summary>
 /// <param name="factory"></param>
 public override void Initialize(PicFactory factory)
 {
     // save factory
     _factory = factory;
     // build .des file header
     DES_Header header = new DES_Header();
     PicVisitorBoundingBox bbVisitor = new PicVisitorBoundingBox();
     factory.ProcessVisitor(bbVisitor);
     header._xmin = (float)bbVisitor.Box.XMin;
     header._xmax = (float)bbVisitor.Box.XMax;
     header._ymin = (float)bbVisitor.Box.YMin;
     header._ymax = (float)bbVisitor.Box.YMax;
     // initialize des writer
     _desWriter = new DES_WriterMem(header);
     DES_SuperBaseHeader superBaseHeader = new DES_SuperBaseHeader();
     _desWriter.WriteSuperBaseHeader(superBaseHeader);
 }
예제 #37
0
        private void LoadDrawing(string filePath, string fileExt)
        {
            _log.Info($"Loading file {filePath}...");
            if (!System.IO.File.Exists(filePath))
            {
                _log.Error($"File ({filePath}) does not exist.");
                return;
            }
            factoryViewCtrl.Visible = true;
            PicFactory factory = factoryViewCtrl.Factory;

            switch (fileExt.ToLower())
            {
            case "des":
            {
                PicLoaderDes picLoaderDes = new PicLoaderDes(factory);
                using (DES_FileReader fileReader = new DES_FileReader())
                    fileReader.ReadFile(filePath, picLoaderDes);
                // remove existing quotations
                factory.Remove((new PicFilterCode(PicEntity.ECode.PE_COTATIONDISTANCE))
                               | (new PicFilterCode(PicEntity.ECode.PE_COTATIONHORIZONTAL))
                               | (new PicFilterCode(PicEntity.ECode.PE_COTATIONVERTICAL)));
                // build autoquotation
                PicAutoQuotation.BuildQuotation(factory);
            }
            break;

            case "dxf":
            {
                using (PicLoaderDXF picLoaderDxf = new PicLoaderDXF(factory))
                {
                    if (!picLoaderDxf.Load(filePath))
                    {
                        return;
                    }
                }
            }
            break;

            default:
                break;
            }
            // update factoryViewCtrl
            factoryViewCtrl.FitView();
        }
예제 #38
0
        /// <summary>
        /// Initialize DES_Writer object
        /// </summary>
        /// <param name="factory"></param>
        public override void Initialize(PicFactory factory)
        {
            // save factory
            _factory = factory;
            // build .des file header
            DES_Header header = new DES_Header();
            Box2D      bbox   = Tools.BoundingBox(factory, 0.0);

            header._xmin = (float)bbox.XMin;
            header._xmax = (float)bbox.XMax;
            header._ymin = (float)bbox.YMin;
            header._ymax = (float)bbox.YMax;
            // initialize des writer
            _desWriter = new DES_WriterMem(header);
            DES_SuperBaseHeader superBaseHeader = new DES_SuperBaseHeader();

            _desWriter.WriteSuperBaseHeader(superBaseHeader);
        }
예제 #39
0
 public static void GenerateImage(Size size, string filePath, string thumbnailFilePath)
 {
     // load file
     PicFactory factory = new PicFactory();
     string fileExt = System.IO.Path.GetExtension(filePath);
     if (string.Equals(".des", fileExt, StringComparison.CurrentCultureIgnoreCase))
     {
         PicLoaderDes picLoaderDes = new PicLoaderDes(factory);
         using (DES_FileReader fileReader = new DES_FileReader())
             fileReader.ReadFile(filePath, picLoaderDes);
     }
     else if (string.Equals(".dxf", fileExt, StringComparison.CurrentCultureIgnoreCase))
     {
         using (PicLoaderDxf picLoaderDxf = new PicLoaderDxf(factory))
         {
             picLoaderDxf.Load(filePath);
             picLoaderDxf.FillFactory();
         }                
     }
     // draw image
     Image bmp;
     ThumbnailGenerator.GenerateImage(size, factory, false, out bmp);
     bmp.Save(thumbnailFilePath);
 }
예제 #40
0
        public void CreateEntities(PicFactory factory)
        {
            PicGraphics.LT ltCut = PicGraphics.LT.LT_CUT;
            PicGraphics.LT ltFold = PicGraphics.LT.LT_CREASING;
            // free variables
            double B = this.ParamB;
            double H = this.ParamH;
            double L = this.ParamL;
            double ep = this.ParamEp;
            double hpr = this.ParamHpr;
            double hr = this.ParamHr;
            double lp = this.ParamLp;

            // formulas
            double b1 = B / 2;
            double b2 = L / 4;
            double l2 = L / 2;
            double Rp = hpr - 1;
            double Re = (hr / 2) - 3;

            SortedList<uint, PicEntity> entities = new SortedList<uint, PicEntity>();

            // segments
            double x0 = 0.0, y0 = 0.0, x1 = 0.0, y1 = 0.0;

            // 3 : (478.344, 543.631) <-> (465.844, 556.131)
            x0 = 425.844 + lp + 12.5;
            y0 = 296.131 + hr + b1 - 12.5;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1;
            entities.Add(3, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 4 : (478.344, 543.631) <-> (478.344, 296.131)
            x0 = 425.844 + lp + 12.5;
            y0 = 296.131 + hr + b1 - 12.5;
            x1 = 425.844 + lp + 12.5;
            y1 = 296.131;
            entities.Add(4, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 5 : (478.344, 296.131) <-> (615.844, 296.131)
            x0 = 425.844 + lp + 12.5;
            y0 = 296.131;
            x1 = 425.844 + lp + b2;
            y1 = 296.131;
            entities.Add(5, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 6 : (615.844, 296.131) <-> (615.844, 356.131)
            x0 = 425.844 + lp + b2;
            y0 = 296.131;
            x1 = 425.844 + lp + b2;
            y1 = 296.131 + hr;
            entities.Add(6, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 7 : (615.844, 356.131) <-> (915.844, 356.131)
            x0 = 425.844 + lp + b2;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + b2 + l2;
            y1 = 296.131 + hr;
            entities.Add(7, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 8 : (915.844, 356.131) <-> (915.844, 296.131)
            x0 = 425.844 + lp + b2 + l2;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + b2 + l2;
            y1 = 296.131;
            entities.Add(8, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 9 : (915.844, 296.131) <-> (1053.34, 296.131)
            x0 = 425.844 + lp + b2 + l2;
            y0 = 296.131;
            x1 = 425.844 + lp + L - 12.5;
            y1 = 296.131;
            entities.Add(9, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 10 : (1053.34, 296.131) <-> (1053.34, 543.631)
            x0 = 425.844 + lp + L - 12.5;
            y0 = 296.131;
            x1 = 425.844 + lp + L - 12.5;
            y1 = 296.131 + hr + b1 - 12.5;
            entities.Add(10, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 11 : (1053.34, 543.631) <-> (1065.84, 556.131)
            x0 = 425.844 + lp + L - 12.5;
            y0 = 296.131 + hr + b1 - 12.5;
            x1 = 425.844 + lp + L;
            y1 = 296.131 + hr + b1;
            entities.Add(11, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 12 : (1065.84, 556.131) <-> (1265.84, 356.131)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + b1;
            y1 = 296.131 + hr;
            entities.Add(12, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 13 : (1265.84, 356.131) <-> (1244.5, 328.303)
            x0 = 425.844 + lp + L + b1;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + L + b1 - 21.3455;
            y1 = 296.131 + hr - 27.8274;
            entities.Add(13, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 14 : (1260.37, 296.131) <-> (1453.34, 296.131)
            x0 = 425.844 + lp + L + b1 - 5.47632;
            y0 = 296.131;
            x1 = 425.844 + lp + L + B - 12.5007;
            y1 = 296.131;
            entities.Add(14, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 15 : (1453.34, 296.131) <-> (1453.34, 543.631)
            x0 = 425.844 + lp + L + B - 12.5007;
            y0 = 296.131;
            x1 = 425.844 + lp + L + B - 12.5007;
            y1 = 296.131 + hr + b1 - 12.5;
            entities.Add(15, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 16 : (1453.34, 543.631) <-> (1465.84, 556.131)
            x0 = 425.844 + lp + L + B - 12.5007;
            y0 = 296.131 + hr + b1 - 12.5;
            x1 = 425.844 + lp + L + B;
            y1 = 296.131 + hr + b1;
            entities.Add(16, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 17 : (1465.84, 556.131) <-> (1615.84, 356.131)
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + b2;
            y1 = 296.131 + hr;
            entities.Add(17, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 18 : (1615.84, 356.131) <-> (1615.84, 296.131)
            x0 = 425.844 + lp + L + B + b2;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + L + B + b2;
            y1 = 296.131;
            entities.Add(18, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 19 : (1615.84, 296.131) <-> (1915.84, 296.131)
            x0 = 425.844 + lp + L + B + b2;
            y0 = 296.131;
            x1 = 425.844 + lp + L + B + b2 + l2;
            y1 = 296.131;
            entities.Add(19, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 20 : (1915.84, 296.131) <-> (1915.84, 356.131)
            x0 = 425.844 + lp + L + B + b2 + l2;
            y0 = 296.131;
            x1 = 425.844 + lp + L + B + b2 + l2;
            y1 = 296.131 + hr;
            entities.Add(20, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 21 : (1915.84, 356.131) <-> (2065.84, 556.131)
            x0 = 425.844 + lp + L + B + b2 + l2;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + L + B + L;
            y1 = 296.131 + hr + b1;
            entities.Add(21, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 22 : (2065.85, 556.131) <-> (2078.35, 543.631)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L + 12.5024;
            y1 = 296.131 + hr + b1 - 12.5;
            entities.Add(22, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 23 : (2078.35, 543.631) <-> (2078.35, 296.131)
            x0 = 425.844 + lp + L + B + L + 12.5024;
            y0 = 296.131 + hr + b1 - 12.5;
            x1 = 425.844 + lp + L + B + L + 12.5024;
            y1 = 296.131;
            entities.Add(23, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 24 : (2078.35, 296.131) <-> (2271.32, 296.131)
            x0 = 425.844 + lp + L + B + L + 12.5022;
            y0 = 296.131;
            x1 = 425.844 + lp + L + B + L + b1 + 5.47681;
            y1 = 296.131;
            entities.Add(24, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 25 : (2287.19, 328.304) <-> (2265.84, 356.131)
            x0 = 425.844 + lp + L + B + L + b1 + 21.3457;
            y0 = 296.131 + hr - 27.8272;
            x1 = 425.844 + lp + L + B + L + b1;
            y1 = 296.131 + hr;
            entities.Add(25, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 26 : (2265.84, 356.131) <-> (2465.84, 556.131)
            x0 = 425.844 + lp + L + B + L + b1;
            y0 = 296.131 + hr;
            x1 = 425.844 + lp + L + B + L + B;
            y1 = 296.131 + hr + b1;
            entities.Add(26, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 27 : (1065.84, 846.131) <-> (1465.84, 846.131)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(27, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 28 : (2065.84, 846.131) <-> (2465.84, 846.131)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + L + B;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(28, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 29 : (1065.84, 846.131) <-> (1078.34, 856.131)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(29, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 30 : (1065.84, 556.131) <-> (1065.84, 846.131)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(30, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 31 : (465.844, 556.131) <-> (465.844, 856.131)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(31, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 32 : (465.844, 856.131) <-> (1078.34, 856.131)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(32, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 33 : (1465.84, 846.131) <-> (1453.34, 856.131)
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B - 12.5007;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(33, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 34 : (2065.84, 846.131) <-> (2078.34, 856.131)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + L + 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(34, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 35 : (1465.84, 556.131) <-> (1465.84, 846.131)
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(35, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 36 : (2065.84, 556.131) <-> (2065.84, 846.131)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(36, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 37 : (465.844, 856.131) <-> (453.344, 868.631)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp - 12.5;
            y1 = 296.131 + hr + b1 + H + 12.5;
            entities.Add(37, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 38 : (465.844, 556.131) <-> (425.844, 556.131)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1;
            x1 = 425.844;
            y1 = 296.131 + hr + b1;
            entities.Add(38, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 39 : (425.844, 556.131) <-> (425.844, 856.131)
            x0 = 425.844;
            y0 = 296.131 + hr + b1;
            x1 = 425.844;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(39, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 40 : (425.844, 856.131) <-> (465.844, 856.131)
            x0 = 425.844;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(40, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 41 : (2465.84, 556.131) <-> (2465.84, 846.131)
            x0 = 425.844 + lp + L + B + L + B;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L + B;
            y1 = 296.131 + hr + b1 + H - ep;
            entities.Add(41, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 42 : (2465.84, 846.131) <-> (2453.34, 856.131)
            x0 = 425.844 + lp + L + B + L + B;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + L + B - 12.5024;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(42, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 43 : (453.344, 868.631) <-> (453.344, 1256.13)
            x0 = 425.844 + lp - 12.5;
            y0 = 296.131 + hr + b1 + H + 12.5;
            x1 = 425.844 + lp - 12.5;
            y1 = 296.131 + hr + b1 + H + B;
            entities.Add(43, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 44 : (453.344, 1256.13) <-> (465.844, 1256.13)
            x0 = 425.844 + lp - 12.5;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1 + H + B;
            entities.Add(44, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 45 : (1465.84, 846.131) <-> (1478.34, 856.131)
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + 12.4993;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(45, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 46 : (2065.84, 846.131) <-> (2053.34, 856.131)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + L - 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(46, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 47 : (1478.34, 856.131) <-> (2053.34, 856.131)
            x0 = 425.844 + lp + L + B + 12.4995;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + L + B + L - 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(47, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 48 : (2453.34, 856.131) <-> (2453.34, 1046.13)
            x0 = 425.844 + lp + L + B + L + B - 12.5024;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + L + B + L + B - 12.5024;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(48, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 49 : (2078.34, 856.131) <-> (2078.34, 1046.13)
            x0 = 425.844 + lp + L + B + L + 12.5;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + L + B + L + 12.5;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(49, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 50 : (2078.34, 1046.13) <-> (2453.34, 1046.13)
            x0 = 425.844 + lp + L + B + L + 12.5;
            y0 = 296.131 + hr + b1 + H - ep + b1;
            x1 = 425.844 + lp + L + B + L + B - 12.5024;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(50, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 51 : (1453.34, 856.131) <-> (1453.34, 1046.13)
            x0 = 425.844 + lp + L + B - 12.5007;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + L + B - 12.5007;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(51, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 52 : (1453.34, 1046.13) <-> (1078.34, 1046.13)
            x0 = 425.844 + lp + L + B - 12.5007;
            y0 = 296.131 + hr + b1 + H - ep + b1;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(52, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 53 : (465.844, 1256.13) <-> (465.844, 1276.13)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1 + H + B + 20;
            entities.Add(53, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 54 : (505.844, 1316.13) <-> (1025.84, 1316.13)
            x0 = 425.844 + lp + 40;
            y0 = 296.131 + hr + b1 + H + B + hpr;
            x1 = 425.844 + lp + L - 40;
            y1 = 296.131 + hr + b1 + H + B + hpr;
            entities.Add(54, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 55 : (1065.84, 1276.13) <-> (1065.84, 1256.13)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + H + B + 20;
            x1 = 425.844 + lp + L;
            y1 = 296.131 + hr + b1 + H + B;
            entities.Add(55, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 56 : (1065.84, 1256.13) <-> (1078.34, 1256.13)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H + B;
            entities.Add(56, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 57 : (1065.84, 1256.13) <-> (465.844, 1256.13)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp;
            y1 = 296.131 + hr + b1 + H + B;
            entities.Add(57, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 79 : (465.844, 556.131) <-> (1065.84, 556.131)
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L;
            y1 = 296.131 + hr + b1;
            entities.Add(79, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 80 : (1065.84, 556.131) <-> (1265.84, 556.131)
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + b1;
            y1 = 296.131 + hr + b1;
            entities.Add(80, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 81 : (1265.84, 556.131) <-> (1465.84, 556.131)
            x0 = 425.844 + lp + L + b1;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B;
            y1 = 296.131 + hr + b1;
            entities.Add(81, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 82 : (1465.84, 556.131) <-> (2065.84, 556.131)
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L;
            y1 = 296.131 + hr + b1;
            entities.Add(82, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 83 : (2065.85, 556.131) <-> (2265.84, 556.131)
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L + b1;
            y1 = 296.131 + hr + b1;
            entities.Add(83, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 84 : (2265.84, 556.131) <-> (2465.84, 556.131)
            x0 = 425.844 + lp + L + B + L + b1;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + L + B + L + B;
            y1 = 296.131 + hr + b1;
            entities.Add(84, factory.AddSegment(ltFold, 0, 1,
                x0, y0, x1, y1));

            // 85 : (1078.34, 1046.13) <-> (1078.34, 856.131)
            x0 = 425.844 + lp + L + 12.5;
            y0 = 296.131 + hr + b1 + H - ep + b1;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H;
            entities.Add(85, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 86 : (1078.34, 1256.13) <-> (1078.34, 1046.13)
            x0 = 425.844 + lp + L + 12.5;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp + L + 12.5;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            entities.Add(86, factory.AddSegment(ltCut, 0, 1,
                x0, y0, x1, y1));

            // 58 : radius = 40  s0 = 54  s1 = 55
            factory.ProcessTool(new PicToolRound(
                  entities[54]
                , entities[55]
                , Rp						// radius
                ));

            // 59 : radius = 40  s0 = 53  s1 = 54
            factory.ProcessTool(new PicToolRound(
                  entities[53]
                , entities[54]
                , Rp						// radius
                ));

            // 89 : radius = 20  s0 = 13  s1 = 14
            factory.ProcessTool(new PicToolRound(
                  entities[13]
                , entities[14]
                , Re						// radius
                ));

            // 90 : radius = 20  s0 = 24  s1 = 25
            factory.ProcessTool(new PicToolRound(
                  entities[24]
                , entities[25]
                , Re						// radius
                ));
            // cotations
            double offset = 0.0;

            // 60: Pt0 = ( 2257.61, 846.131) Pt1 = ( 2257.61, 1046.13) offset = -8.7301
            x0 = 425.844 + lp + L + B + L + b1 - 8.23413;
            y0 = 296.131 + hr + b1 + H - ep;
            x1 = 425.844 + lp + L + B + L + b1 - 8.23413;
            y1 = 296.131 + hr + b1 + H - ep + b1;
            offset = -8.7301;
            entities.Add(60, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                5, 1, x0, y0, x1, y1, offset, ""));

            // 61: Pt0 = ( 856.89, 556.131) Pt1 = ( 856.89, 356.131) offset = -21.0876
            x0 = 425.844 + lp + b2 + l2 - 58.9536;
            y0 = 296.131 + hr + b1;
            x1 = 425.844 + lp + b2 + l2 - 58.9536;
            y1 = 296.131 + hr;
            offset = -21.0876;
            entities.Add(61, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 62: Pt0 = ( 669.711, 1256.13) Pt1 = ( 669.711, 856.131) offset = -48.2816
            x0 = 425.844 + lp + b2 + 53.8672;
            y0 = 296.131 + hr + b1 + H + B;
            x1 = 425.844 + lp + b2 + 53.8672;
            y1 = 296.131 + hr + b1 + H;
            offset = -48.2816;
            entities.Add(62, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 93: Pt0 = ( 465.844, 593.295) Pt1 = ( 1065.84, 593.295) offset = 2.71844
            x0 = 425.844 + lp;
            y0 = 296.131 + hr + b1 + 37.1644;
            x1 = 425.844 + lp + L;
            y1 = 296.131 + hr + b1 + 37.1644;
            offset = 2.71844;
            entities.Add(93, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 94: Pt0 = ( 1065.84, 598.732) Pt1 = ( 1465.84, 598.732) offset = -2.71851
            x0 = 425.844 + lp + L;
            y0 = 296.131 + hr + b1 + 42.6013;
            x1 = 425.844 + lp + L + B;
            y1 = 296.131 + hr + b1 + 42.6013;
            offset = -2.71851;
            entities.Add(94, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 95: Pt0 = ( 1465.84, 590.577) Pt1 = ( 2065.84, 590.577) offset = 2.71851
            x0 = 425.844 + lp + L + B;
            y0 = 296.131 + hr + b1 + 34.4459;
            x1 = 425.844 + lp + L + B + L;
            y1 = 296.131 + hr + b1 + 34.4459;
            offset = 2.71851;
            entities.Add(95, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 96: Pt0 = ( 2065.84, 596.014) Pt1 = ( 2465.84, 596.014) offset = 0
            x0 = 425.844 + lp + L + B + L;
            y0 = 296.131 + hr + b1 + 39.8828;
            x1 = 425.844 + lp + L + B + L + B;
            y1 = 296.131 + hr + b1 + 39.8828;
            offset = 0;
            entities.Add(96, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));

            // 97: Pt0 = ( 628.84, 856.131) Pt1 = ( 628.84, 556.131) offset = -3.36783
            x0 = 425.844 + lp + b2 + 12.996;
            y0 = 296.131 + hr + b1 + H;
            x1 = 425.844 + lp + b2 + 12.996;
            y1 = 296.131 + hr + b1;
            offset = -3.36783;
            entities.Add(97, factory.AddCotation(PicCotation.CotType.COT_DISTANCE,
                1, 1, x0, y0, x1, y1, offset, ""));
        }
예제 #41
0
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            double L = stack.GetDoubleParameterValue("L");
            double H = stack.GetDoubleParameterValue("H");
            double R = stack.GetDoubleParameterValue("R");
            bool Rounding0 = stack.GetBoolParameterValue("Rounding0");
            bool Rounding1 = stack.GetBoolParameterValue("Rounding1");
            bool Rounding2 = stack.GetBoolParameterValue("Rounding2");
            bool Rounding3 = stack.GetBoolParameterValue("Rounding3");
            double Ang = stack.GetDoubleParameterValue("Angle") * Math.PI / 180.0;

            // segments
            PicFactory fTemp = new PicFactory();
            List<PicEntity> entityList = new List<PicEntity>();
            entityList.Add(fTemp.AddSegment(
                PicGraphics.LT.LT_CUT
                , new Vector2D(0.0, 0.0)
                , new Vector2D(L * Math.Cos(Ang), L * Math.Sin(Ang))));
            entityList.Add(fTemp.AddSegment(
                PicGraphics.LT.LT_CUT
                , new Vector2D(L * Math.Cos(Ang), L * Math.Sin(Ang))
                , new Vector2D(L * Math.Cos(Ang) - H * Math.Sin(Ang), L * Math.Sin(Ang) + H * Math.Cos(Ang))));
            entityList.Add(fTemp.AddSegment(
                PicGraphics.LT.LT_CUT
                , new Vector2D(L * Math.Cos(Ang) - H * Math.Sin(Ang), L * Math.Sin(Ang) + H * Math.Cos(Ang))
                , new Vector2D(-H * Math.Sin(Ang), H * Math.Cos(Ang))));
            entityList.Add(fTemp.AddSegment(
                PicGraphics.LT.LT_CUT
                , new Vector2D(-H * Math.Sin(Ang), H * Math.Cos(Ang))
                , new Vector2D(0.0, 0.0)));

            if (Rounding0) fTemp.ProcessTool(new PicToolRound(entityList[0], entityList[1], R));
            if (Rounding1) fTemp.ProcessTool(new PicToolRound(entityList[1], entityList[2], R));
            if (Rounding2) fTemp.ProcessTool(new PicToolRound(entityList[2], entityList[3], R));
            if (Rounding3) fTemp.ProcessTool(new PicToolRound(entityList[3], entityList[0], R));

            factory.AddEntities(fTemp, transform);
        }
예제 #42
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="factory"></param>
        public override void ProcessFactory(PicFactory factory)
        {
            // will only work with 2 segments
            if (null == _picSeg0 || null == _picSeg1)
                throw new NotImplementedException("Only segment entities are supported");

            // get inner segments
            Segment seg0 = new Segment(_picSeg0.Pt0, _picSeg0.Pt1);
            Segment seg1 = new Segment(_picSeg1.Pt0, _picSeg1.Pt1);

            // find line intersection and extend segments so that they intersect
            Intersection2D interobj;
            if (!IntersectMethods.IntersectLines(seg0, seg1, out interobj) || interobj == null || interobj.Type != Intersection2D.IntersectionType.I2D_POINT)  return;
            Vector2D ptExt = (Vector2D)interobj.Result;
            seg0 = extendSegment(seg0, ptExt);
            seg1 = extendSegment(seg1, ptExt);

            // create parallel segments
            Segment seg00, seg01;
            getParalleleSegments(seg0, _radius, out seg00, out seg01);
            Segment seg10, seg11;
            getParalleleSegments(seg1, _radius, out seg10, out seg11);

            // compute intersection
            if (IntersectMethods.Intersect(seg00, seg10, out interobj)) { }
            else if (IntersectMethods.Intersect(seg00, seg11, out interobj)) { }
            else if (IntersectMethods.Intersect(seg01, seg10, out interobj)) { }
            else if (IntersectMethods.Intersect(seg01, seg11, out interobj)) { }

            if (interobj == null || interobj.Type != Intersection2D.IntersectionType.I2D_POINT) return;
            Vector2D ptCenter = (Vector2D)interobj.Result;

            // get intersection of normal with seg0
            if (IntersectMethods.Intersect(seg0, new Segment(ptCenter, ptCenter + new Vector2D(-(seg0.P1 - seg0.P0).Y, (seg0.P1 - seg0.P0).X)), out interobj)) { }
            else if (IntersectMethods.Intersect(seg0, new Segment(ptCenter, ptCenter + new Vector2D((seg0.P1 - seg0.P0).Y, -(seg0.P1 - seg0.P0).X)), out interobj)) { }
            else return;
            if (interobj == null && interobj.Type != Intersection2D.IntersectionType.I2D_POINT) return;
            Vector2D pt0 = (Vector2D)interobj.Result;

            if (IntersectMethods.Intersect(seg1, new Segment(ptCenter, ptCenter + new Vector2D(-(seg1.P1 - seg1.P0).Y, (seg1.P1 - seg1.P0).X)), out interobj)) { }
            else if (IntersectMethods.Intersect(seg1, new Segment(ptCenter, ptCenter + new Vector2D((seg1.P1 - seg1.P0).Y, -(seg1.P1 - seg1.P0).X)), out interobj)) { }
            else return;
            if (interobj == null && interobj.Type != Intersection2D.IntersectionType.I2D_POINT) return;
            Vector2D pt1 = (Vector2D)interobj.Result;

            // intersection of 2D segments
            if (!IntersectMethods.Intersect(seg0, seg1, out interobj)) return;
            if (interobj == null && interobj.Type != Intersection2D.IntersectionType.I2D_POINT) return;
            Vector2D ptInter = (Vector2D)interobj.Result;

            // modify segments
            if ((seg0.P0 - ptInter).GetLength() < (seg0.P1 - ptInter).GetLength())
            {
                _picSeg0.Pt0 = pt0;
                _picSeg0.Pt1 = seg0.P1;
            }
            else
            {
                _picSeg0.Pt0 = pt0;
                _picSeg0.Pt1 = seg0.P0;
            }

            if ((seg1.P0 - ptInter).GetLength() < (seg1.P1 - ptInter).GetLength())
            {
                _picSeg1.Pt0 = pt1;
                _picSeg1.Pt1 = seg1.P1;
            }
            else
            {
                _picSeg1.Pt0 = pt1;
                _picSeg1.Pt1 = seg1.P0;
            }

            // create new arc of circle
            if (Vector2D.KrossProduct(pt0 - ptCenter, pt1 - ptCenter) > 0) // go from pt0 to pt1
                factory.AddArc(_picSeg0.LineType, _picSeg0.Group, _picSeg0.Layer, ptCenter, pt0, pt1);
            else // from pt1 to pt0
                factory.AddArc(_picSeg0.LineType, _picSeg0.Group, _picSeg0.Layer, ptCenter, pt1, pt0);
        }
예제 #43
0
        static public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            PicFactory fTemp = new PicFactory();
            const PicGraphics.LT ltCut = PicGraphics.LT.LT_CUT;
            const PicGraphics.LT ltFold = PicGraphics.LT.LT_CREASING;

            // free variables
            double A = stack.GetDoubleParameterValue("A");
            double B = stack.GetDoubleParameterValue("B");
            double H = stack.GetDoubleParameterValue("H");
            double e = stack.GetDoubleParameterValue("e");
            double g = stack.GetDoubleParameterValue("g");
            double hc = stack.GetDoubleParameterValue("hc");
            double pr = stack.GetDoubleParameterValue("pr");

            // formulas
            double hp = B / 2 - e;
            double v9 = g * Tand(15);
            double v1 = 8;
            double v2 = 8;
            double v3 = hp * Tand(15);
            double r = pr / 4;
            SortedList<uint, PicEntity> entities = new SortedList<uint, PicEntity>();

            // segments
            double x0 = 0.0, y0 = 0.0, x1 = 0.0, y1 = 0.0;

            // 3 : (481.462, 303.394) <-> (481.462, 467.206)
            x0 = 69.6211 + g + A + B + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(3, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 4 : (223.218, 468.17) <-> (352.341, 468.17)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            entities.Add(4, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 5 : (352.341, 467.206) <-> (480.017, 467.206)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(5, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 6 : (352.34, 302.431) <-> (223.218, 302.431)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            entities.Add(6, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 7 : (352.34, 303.394) <-> (480.017, 303.394)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(7, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 8 : (223.218, 240.761) <-> (101.323, 240.761)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(8, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 9 : (223.218, 211.853) <-> (101.323, 211.853)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(9, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 10 : (352.34, 211.853) <-> (474.235, 211.853)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(10, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 11 : (352.34, 240.761) <-> (474.235, 240.761)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(11, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 12 : (352.341, 530.804) <-> (461.326, 530.804)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            x1 = 69.6211 + g + A + B + A - e - v3;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(12, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 13 : (94.0963, 467.206) <-> (69.6211, 462.388)
            x0 = 69.6211 + g;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H - v9;
            entities.Add(13, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 14 : (69.6211, 308.213) <-> (69.6211, 462.388)
            x0 = 69.6211;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + v9;
            x1 = 69.6211;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H - v9;
            entities.Add(14, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 15 : (94.0963, 303.395) <-> (69.621, 308.213)
            x0 = 69.6211 + g;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + v9;
            entities.Add(15, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 16 : (223.218, 303.394) <-> (95.542, 303.394)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(16, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 17 : (223.218, 467.206) <-> (95.5415, 467.206)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(17, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 18 : (352.34, 149.701) <-> (474.235, 149.701)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g;
            entities.Add(18, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 19 : (466.489, 120.793) <-> (360.086, 120.793)
            x0 = 69.6211 + g + A + B + A - e - v2 - v9;
            y0 = 120.793;
            x1 = 69.6211 + g + A + B + v9;
            y1 = 120.793;
            entities.Add(19, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 20 : (480.017, 467.206) <-> (480.017, 476.842)
            x0 = 69.6211 + g + A + B + A - e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5;
            entities.Add(20, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 21 : (474.235, 482.623) <-> (480.017, 476.842)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5 + v2;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5;
            entities.Add(21, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 22 : (474.235, 482.623) <-> (461.326, 530.804)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5 + v2;
            x1 = 69.6211 + g + A + B + A - e - v3;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(22, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 23 : (223.218, 530.804) <-> (114.233, 530.804)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            x1 = 69.6211 + g + e + v3;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(23, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 24 : (95.5415, 467.206) <-> (95.5415, 476.842)
            x0 = 69.6211 + g + e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5;
            entities.Add(24, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 25 : (101.323, 482.624) <-> (95.5415, 476.842)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5 + v2;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5;
            entities.Add(25, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 26 : (101.323, 482.624) <-> (114.233, 530.804)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + hp / 5 + v2;
            x1 = 69.6211 + g + e + v3;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(26, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 27 : (223.218, 149.701) <-> (101.323, 149.701)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g;
            entities.Add(27, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 28 : (215.473, 120.793) <-> (109.069, 120.793)
            x0 = 69.6211 + g + A - v9;
            y0 = 120.793;
            x1 = 69.6211 + g + e + v2 + v9;
            y1 = 120.793;
            entities.Add(28, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 29 : (480.017, 303.394) <-> (480.017, 293.759)
            x0 = 69.6211 + g + A + B + A - e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5;
            entities.Add(29, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 30 : (474.235, 287.977) <-> (480.017, 293.759)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5 - v2;
            x1 = 69.6211 + g + A + B + A - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5;
            entities.Add(30, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 31 : (95.542, 303.394) <-> (95.542, 293.759)
            x0 = 69.6211 + g + e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5;
            entities.Add(31, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 32 : (101.323, 287.978) <-> (95.542, 293.759)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5 - v2;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5;
            entities.Add(32, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 33 : (101.323, 149.701) <-> (109.069, 120.793)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + e + v2 + v9;
            y1 = 120.793;
            entities.Add(33, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 34 : (223.218, 149.701) <-> (215.473, 120.793)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A - v9;
            y1 = 120.793;
            entities.Add(34, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 35 : (352.34, 149.699) <-> (360.086, 120.793)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A + B + v9;
            y1 = 120.793;
            entities.Add(35, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 36 : (474.235, 149.701) <-> (466.489, 120.793)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A + B + A - e - v2 - v9;
            y1 = 120.793;
            entities.Add(36, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 37 : (609.621, 303.394) <-> (609.621, 467.206)
            x0 = 69.6211 + g + A + B + A + B - e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A + B - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(37, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 38 : (94.0963, 467.206) <-> (95.5415, 467.206)
            x0 = 69.6211 + g;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(38, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 39 : (94.0963, 303.394) <-> (95.542, 303.394)
            x0 = 69.6211 + g;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(39, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 40 : (94.0963, 303.394) <-> (94.0963, 467.206)
            x0 = 69.6211 + g;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(40, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 41 : (236.709, 594.401) <-> (338.85, 594.401)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            x1 = 69.6211 + g + A + B - 2 * e - v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            entities.Add(41, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 42 : (340.524, 625.236) <-> (235.034, 625.236)
            x0 = 69.6211 + g + A + B - 2 * e - v1 + 1.6741;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + pr;
            x1 = 69.6211 + g + A + 2 * e + v1 - 1.67455;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + pr;
            entities.Add(42, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 43 : (348.524, 617.236) <-> (348.524, 596.328)
            x0 = 69.6211 + g + A + B - 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + pr - 8.00006;
            x1 = 69.6211 + g + A + B - 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(43, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 59 : (227.034, 617.236) <-> (227.034, 596.328)
            x0 = 69.6211 + g + A + 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + pr - 8;
            x1 = 69.6211 + g + A + 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(59, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 69 : (338.85, 176.2) <-> (236.709, 176.2)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            x1 = 69.6211 + g + A + 2 * e + v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            entities.Add(69, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 70 : (235.035, 145.365) <-> (339.525, 145.364)
            x0 = 69.6211 + g + A + 2 * e + v1 - 1.67406;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - pr;
            x1 = 69.6211 + g + A + B - 2 * e - v1 + 0.674561;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - pr;
            entities.Add(70, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 71 : (227.035, 153.365) <-> (227.035, 174.272)
            x0 = 69.6211 + g + A + 2 * e;
            y0 = 120.793 + g + 3.66388;
            x1 = 69.6211 + g + A + 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(71, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 73 : (348.525, 174.272) <-> (348.525, 154.364)
            x0 = 69.6211 + g + A + B - 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + B - 2 * e;
            y1 = 120.793 + g + 4.66336;
            entities.Add(73, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 98 : (227.034, 596.328) <-> (223.218, 596.328)
            x0 = 69.6211 + g + A + 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(98, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 99 : (236.709, 596.328) <-> (227.034, 596.328)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A + 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(99, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 100 : (352.341, 303.394) <-> (352.341, 467.206)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(100, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 101 : (352.341, 467.206) <-> (352.341, 467.399)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(101, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 102 : (223.218, 303.394) <-> (223.218, 467.206)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(102, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 103 : (223.218, 467.206) <-> (223.218, 467.399)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(103, fTemp.AddSegment(ltFold, 1, 1, x0, y0, x1, y1));

            // 104 : (480.017, 467.206) <-> (481.462, 467.206)
            x0 = 69.6211 + g + A + B + A - e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A + B + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(104, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 105 : (481.462, 467.206) <-> (609.621, 467.206)
            x0 = 69.6211 + g + A + B + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A + B + A + B - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(105, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 106 : (480.017, 303.394) <-> (481.462, 303.394)
            x0 = 69.6211 + g + A + B + A - e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(106, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 107 : (481.462, 303.394) <-> (609.621, 303.394)
            x0 = 69.6211 + g + A + B + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            x1 = 69.6211 + g + A + B + A + B - e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(107, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 108 : (352.341, 468.17) <-> (352.341, 467.399)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            entities.Add(108, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 109 : (352.341, 530.804) <-> (352.341, 468.17)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            entities.Add(109, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 110 : (352.341, 596.328) <-> (352.341, 530.804)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(110, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 111 : (223.218, 467.399) <-> (223.218, 468.17)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            entities.Add(111, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 112 : (223.218, 468.17) <-> (223.218, 530.804)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            entities.Add(112, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 113 : (223.218, 530.804) <-> (223.218, 596.328)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + B / 2 - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(113, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 114 : (474.235, 149.701) <-> (474.235, 211.853)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(114, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 115 : (474.235, 211.853) <-> (474.235, 240.761)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(115, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 116 : (474.235, 240.761) <-> (474.235, 287.977)
            x0 = 69.6211 + g + A + B + A - e - v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + A + B + A - e - v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5 - v2;
            entities.Add(116, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 117 : (101.323, 149.701) <-> (101.323, 211.853)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(117, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 118 : (101.323, 211.853) <-> (101.323, 240.761)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(118, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 119 : (101.323, 240.761) <-> (101.323, 287.978)
            x0 = 69.6211 + g + e + v2;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + e + v2;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - hp / 5 - v2;
            entities.Add(119, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 120 : (223.218, 149.701) <-> (223.218, 174.272)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(120, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 121 : (223.218, 174.272) <-> (223.218, 211.853)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(121, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 122 : (223.218, 211.853) <-> (223.218, 240.761)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(122, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 123 : (223.218, 240.761) <-> (223.218, 302.431)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            entities.Add(123, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 124 : (223.218, 302.431) <-> (223.218, 303.394)
            x0 = 69.6211 + g + A;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(124, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 125 : (352.34, 149.701) <-> (352.34, 174.272)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(125, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 126 : (352.34, 174.272) <-> (352.34, 211.853)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e;
            entities.Add(126, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 127 : (352.34, 211.853) <-> (352.34, 240.761)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc;
            entities.Add(127, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 128 : (352.34, 240.761) <-> (352.34, 302.431)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            entities.Add(128, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 129 : (352.34, 302.431) <-> (352.34, 303.394)
            x0 = 69.6211 + g + A + B;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e;
            entities.Add(129, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 130 : (338.85, 596.328) <-> (348.524, 596.328)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A + B - 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(130, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 131 : (348.524, 596.328) <-> (352.341, 596.328)
            x0 = 69.6211 + g + A + B - 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(131, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 132 : (338.85, 592.474) <-> (338.85, 594.401)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A - e;
            x1 = 69.6211 + g + A + B - 2 * e - v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            entities.Add(132, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 133 : (338.85, 594.401) <-> (338.85, 596.328)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            x1 = 69.6211 + g + A + B - 2 * e - v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            entities.Add(133, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 134 : (236.709, 594.401) <-> (236.709, 592.474)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            x1 = 69.6211 + g + A + 2 * e + v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A - e;
            entities.Add(134, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 135 : (236.709, 596.328) <-> (236.709, 594.401)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A + e;
            x1 = 69.6211 + g + A + 2 * e + v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e + H + e + A;
            entities.Add(135, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 136 : (338.85, 174.272) <-> (348.525, 174.272)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + B - 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(136, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 137 : (348.525, 174.272) <-> (352.341, 174.272)
            x0 = 69.6211 + g + A + B - 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + B;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(137, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 138 : (227.035, 174.272) <-> (223.218, 174.272)
            x0 = 69.6211 + g + A + 2 * e;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(138, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 139 : (236.709, 174.272) <-> (227.035, 174.272)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + 2 * e;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(139, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 140 : (236.709, 176.2) <-> (236.709, 174.272)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            x1 = 69.6211 + g + A + 2 * e + v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            entities.Add(140, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 141 : (236.709, 178.127) <-> (236.709, 176.2)
            x0 = 69.6211 + g + A + 2 * e + v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A + e;
            x1 = 69.6211 + g + A + 2 * e + v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            entities.Add(141, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 142 : (338.85, 174.272) <-> (338.85, 176.2)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A - e;
            x1 = 69.6211 + g + A + B - 2 * e - v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            entities.Add(142, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // 143 : (338.85, 176.2) <-> (338.85, 178.127)
            x0 = 69.6211 + g + A + B - 2 * e - v1;
            y0 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A;
            x1 = 69.6211 + g + A + B - 2 * e - v1;
            y1 = 120.793 + g + B / 2 - 2 * e + hc + B / 2 - e - e - A + e;
            entities.Add(143, fTemp.AddSegment(ltCut, 1, 1, x0, y0, x1, y1));

            // arcs
            // 44 : radius = 8  s0 = 42  s1 = 43
            fTemp.ProcessTool(new PicToolRound(
                  entities[42]
                , entities[43]
                , r						// radius
                ));
            // 60 : radius = 8  s0 = 42  s1 = 59
            fTemp.ProcessTool(new PicToolRound(
                  entities[42]
                , entities[59]
                , r						// radius
                ));
            // 72 : radius = 8  s0 = 70  s1 = 71
            fTemp.ProcessTool(new PicToolRound(
                  entities[70]
                , entities[71]
                , r						// radius
                ));
            // 144 : radius = 9  s0 = 70  s1 = 73
            fTemp.ProcessTool(new PicToolRound(
                  entities[70]
                , entities[73]
                , r						// radius
                ));

            factory.AddEntities(fTemp, transform);
        }
예제 #44
0
        static void Main(string[] args)
        {
            // set up a simple configuration that logs on the console.
            XmlConfigurator.Configure();

            string assemblyName = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;
            try
            {
                _log.Info(assemblyName + " starting...");

                const PicGraphics.LT ltCut = PicGraphics.LT.LT_CUT;

                // instantiate factory
                PicFactory initialFactory = new PicFactory();

                ParameterStack stack = Program.Parameters;
                Program.CreateFactoryEntities(initialFactory, stack, Transform2D.Identity);
                // imposition
                double width = 1000.0, height = 1000.0;
                ImpositionTool impositionTool = new ImpositionToolCardboardFormat(initialFactory, new CardboardFormat(0, "Format1", "Format1", width, height));
                impositionTool.SpaceBetween = new Vector2D(0.0, 0.0);
                impositionTool.Margin = new Vector2D(0.0, 0.0);

                List<ImpositionSolution> solutions;
                impositionTool.GenerateSortedSolutionList(null, out solutions);
                _log.Info(string.Format("{0} : Solutions", solutions.Count));
                if (solutions.Count <= 0)
                    return;

                foreach (ImpositionSolution chosenSolution in solutions)
                {
                    _log.Info(string.Format("NoRows={0}, NoCols={1}", chosenSolution.Rows, chosenSolution.Cols));

                    PicFactory factoryOut = new PicFactory();
                    chosenSolution.CreateEntities(factoryOut);
                    factoryOut.AddSegment(ltCut, new Vector2D(0.0, 0.0), new Vector2D(width, 0.0));
                    factoryOut.AddSegment(ltCut, new Vector2D(width, 0.0), new Vector2D(width, height));
                    factoryOut.AddSegment(ltCut, new Vector2D(width, height), new Vector2D(0.0, height));
                    factoryOut.AddSegment(ltCut, new Vector2D(0.0, height), new Vector2D(0.0, 0.0));

                    // get bounding box
                    Box2D box = new Box2D();
                    using (PicVisitorBoundingBox visitor = new PicVisitorBoundingBox())
                    {
                        factoryOut.ProcessVisitor(visitor);
                        box = visitor.Box;
                    }

                    string filePath = Path.Combine(Path.GetTempPath(), "Imposition.bmp");
                    PicGraphicsImage picImage = new PicGraphicsImage();
                    picImage.ImageSize = new System.Drawing.Size(4096, 4096);
                    box.AddMargin(1.0);
                    picImage.DrawingBox = box;
                    factoryOut.Draw(picImage);
                    picImage.SaveAs(filePath);

                    System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), filePath);

                    _log.Info(assemblyName + " ending...");
                }
             }
            catch (Exception ex)
            {
                _log.Error(ex.ToString());
            }
             
        }
예제 #45
0
        static void Main(string[] args)
        {
            XmlConfigurator.Configure();

            try
            {
                // instantiate factory
                PicFactory factory = new PicFactory();
                
                // load plugins
                PluginPathData configData = ConfigurationManager.GetSection("PluginSettings") as PluginPathData;
                if (null == configData)
                    throw new Exception("Failed to load valid PluinPathData object!");
                if (!Directory.Exists(configData.Path))
                    throw new Exception(string.Format("Directory \"{0}\" does not exist.", configData.Path));

                ComponentLoader loader = new ComponentLoader();
                DirectoryInfo dir = new DirectoryInfo(configData.Path);
                foreach (FileInfo fileInfo in dir.GetFiles())
                {
					try
					{
                        Component component = loader.LoadComponent(fileInfo.FullName);
                        if (null == component)
                            continue;
                        System.Console.WriteLine("Name = " + component.Name);
                        System.Console.WriteLine("Description = " + component.Description);
                        System.Console.WriteLine("Author = " + component.Author);
                        System.Console.WriteLine("Source code = " + component.SourceCode);
                        System.Console.WriteLine("------------");
                        // get thumbnail
                        if (component.HasEmbeddedThumbnail)
                        {
                            string thumbPath = Path.Combine(Path.GetTempPath(), component.Name + "_thumbnail.bmp");
                            System.Drawing.Bitmap thumbnail = component.Thumbnail;
                            thumbnail.Save(thumbPath);
                            if (launchPaint)
                                System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), "\"" + thumbPath + "\"");
                        }

                        // generate entities
                        ParameterStack stack = component.BuildParameterStack(null);
						factory.Clear();
						component.CreateFactoryEntities(factory, stack);

						// get bounding box
						PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
						factory.ProcessVisitor(visitor);

						// save
						string filePath = Path.Combine(Path.GetTempPath(), component.Name + ".jpeg");
						PicGraphicsImage picImage = new PicGraphicsImage();
						picImage.ImageSize = new System.Drawing.Size(512, 512);
						Box2D box = visitor.Box;
						box.AddMargin(5);
						picImage.DrawingBox = box;
						factory.Draw(picImage);
						picImage.SaveAs(filePath);

                        if (launchPaint)
						    System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), "\"" + filePath + "\"");
					}
					catch (System.Exception ex)
					{
                        _log.Debug(ex.Message);
					}
                }
            }
            catch (System.Exception ex)
            {
                _log.Error(ex.ToString());
            }
        }
예제 #46
0
 // private constructor
 private DESQuerier(PicFactory factory)
 {
     _factory = factory;
 }
예제 #47
0
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            PicFactory fTemp = new PicFactory();
            // free variables
            double a0 = stack.GetDoubleParameterValue("a0");
            double a1 = stack.GetDoubleParameterValue("a1");
            bool bbox = stack.GetBoolParameterValue("bbox");
            bool arcDefault = stack.GetBoolParameterValue("Arc default");
            bool arcReflX = stack.GetBoolParameterValue("Arc Refl X");
            bool arcReflY = stack.GetBoolParameterValue("Arc Refl Y");
            bool arcReflXY = stack.GetBoolParameterValue("Arc Refl XY");
            bool arcComplement = stack.GetBoolParameterValue("Complement");

            if (arcDefault)
            {
                PicArc arc0 = fTemp.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(0.0, 0.0), 100.0, a0, a1);
                arc0.Transform(Transform2D.Identity);

                if (bbox)
                {
                    Box2D box = arc0.Box;
                    fTemp.AddSegment(PicGraphics.LT.LT_CUT, 0, 0
                        , box.PtMin.X	// x0
                        , box.PtMin.Y	// y0
                        , box.PtMax.X	// x1
                        , box.PtMin.Y	// y1
                        );
                    fTemp.AddSegment(PicGraphics.LT.LT_CUT, 0, 0
                        , box.PtMax.X	// x0
                        , box.PtMin.Y	// y0
                        , box.PtMax.X	// x1
                        , box.PtMax.Y	// y1
                        );
                    fTemp.AddSegment(PicGraphics.LT.LT_CUT, 0, 0
                        , box.PtMin.X	// x0
                        , box.PtMax.Y	// y0
                        , box.PtMax.X	// x1
                        , box.PtMax.Y	// y1
                        );
                    fTemp.AddSegment(PicGraphics.LT.LT_CUT, 0, 0
                        , box.PtMin.X	// x0
                        , box.PtMin.Y	// y0
                        , box.PtMin.X	// x1
                        , box.PtMax.Y	// y1
                        );
                }
            }
            if (arcReflY)
            {
                PicArc arc1 = fTemp.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(0.0, 0.0), 100.0, a0, a1);
                arc1.Transform(Transform2D.ReflectionY);
            }
            if (arcReflX)
            {
                PicArc arc2 = fTemp.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(0.0, 0.0), 100.0, a0, a1);
                arc2.Transform(Transform2D.ReflectionX);
            }
            if (arcReflXY)
            {
                PicArc arc3 = fTemp.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(0.0, 0.0), 100.0, a0, a1);
                arc3.Transform(Transform2D.ReflectionX * Transform2D.ReflectionY);
            }
            if (arcComplement)
            {
                PicArc arc4 = fTemp.AddArc(PicGraphics.LT.LT_COTATION, new Vector2D(0.0, 0.0), 100.0, a0, a1);
                arc4.Complement();
            }
            
            // end
            factory.AddEntities(fTemp, transform);
        }
예제 #48
0
 public List<Guid> GetDependancies(ParameterStack stack)
 {
     // clear list of dependancies
     _dependancyList.Clear();
     // instanciate handler of ComponentLoader.OnPluginAccessed
     ComponentLoader.PluginAccessed handler = new ComponentLoader.PluginAccessed(OnGuidLoaded);
     ComponentLoader.OnPluginAccessed += handler;
     // instantiate factory
     PicFactory factory = new PicFactory();
     _instance.CreateFactoryEntities(factory, stack, Transform2D.Identity);
     // on plugin accessed
     ComponentLoader.OnPluginAccessed -= handler; 
     // dependancy list
     return _dependancyList;
 }
예제 #49
0
		public override void Initialize(PicFactory factory)
		{
            _dictionnaryLength.Clear();
		}
예제 #50
0
 public override void Initialize(PicFactory factory) { }
예제 #51
0
        /// <summary>
        /// Create factory entities
        /// </summary>
        /// <param name="factory"></param>
        /// <param name="stack"></param>
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {

            // get parameter values
            double ParamX1 = stack.GetDoubleParameterValue("ParamX1");
            double L1 = stack.GetDoubleParameterValue("L1");
            double B1 = stack.GetDoubleParameterValue("B1");
            double L2 = stack.GetDoubleParameterValue("L2");
            double B2 = stack.GetDoubleParameterValue("B2");
            double H1 = stack.GetDoubleParameterValue("H1");
            double RL = stack.GetDoubleParameterValue("RL");
            double RB = stack.GetDoubleParameterValue("RB");
            double Xo = stack.GetDoubleParameterValue("Xo");
            double Yo = stack.GetDoubleParameterValue("Yo");
            double Diro = stack.GetDoubleParameterValue("Diro");
            bool Symy = stack.GetBoolParameterValue("Symy");

            double m15 = stack.GetDoubleParameterValue("m15");
            double m16 = stack.GetDoubleParameterValue("m16");
            double decalenc = stack.GetDoubleParameterValue("decalenc");
            double encoche = stack.GetDoubleParameterValue("encoche");

            int PoignsurTete = stack.GetIntParameterValue("PoignsurTete");

            bool caisse_en_2 = stack.GetBoolParameterValue("caisse_en_2");
            int caisse_en_4 = stack.GetIntParameterValue("caisse_en_4");

            double lgPatte = stack.GetDoubleParameterValue("lgPatte");

            IPlugin DemiPatteCol = stack.GetPluginParameterValue("DemiPatteCol");
            IPlugin Poignee = stack.GetPluginParameterValue("Poignee");


            double HY = 0.0;

            double ec1 = 0.0, ec2 = 0.0;
            CalEncoche(ref ec1, ref ec2, m15, m16, decalenc, encoche);

            if (caisse_en_2 || caisse_en_4 > 0)
            {
                B1 = B2;
                L2 = 0.0;
                B2 = 0.0;
            }
            if (caisse_en_4 == 1 || caisse_en_4 == 3)
            {
                B1 = 0.0;
                RB = RL;
                L2 = 0.0;
                B2 = 0.0;
            }
            if (caisse_en_4 == 2 || caisse_en_4 == 4)
            {
                L1 = B1;
                RL = RB;
                B1 = 0.0;
                L2 = 0.0;
                B2 = 0.0;
            }

            double PX1 = lgPatte;
            double PX2 = L1;
            double PX3 = B1;
            double PX4 = L2;
            double PX5 = B2;

            double RBY1 = 0.0, RBY2 = 0.0, RBY3 = 0.0, RBY4 = 0.0, RBY5 = 0.0;
            double RHY1 = 0.0, RHY2 = 0.0, RHY3 = 0.0, RHY4 = 0.0, RHY5 = 0.0;
            double patProlong = 0.0;
            if (Symy)
            {
                RBY1 = patProlong;
                RBY2 = RL;
                RBY3 = RB;
                RBY4 = RL;
                RBY5 = RB;
            }
            else
            {
                RHY1 = patProlong;
                RHY2 = RL;
                RHY3 = RB;
                RHY4 = RL;
                RHY5 = RB;
            }
            HY = HY + H1;

            if (caisse_en_2 || caisse_en_4 > 0)
            {
                if (PX5 != 0)
                    PX3 = PX5;
                PX4 = 0;
                PX5 = 0;
                RHY4 = 0;
                RHY5 = 0;
                RBY4 = 0;
                RBY5 = 0;
            }

            double V0 = 0.0;
            double v1 = V0 + lgPatte;
            double v2 = v1 + L1;
            double v3 = v2 + B1;
            double v4 = v3 + L2;
            double V5 = v4 + B2;
            double V6 = H1;
            double w0 = 0.0;
            double w1 = V6 + RL;
            double w2 = V6 + RB;
            double w3 = V6 + RL;
            double w4 = V6 + RB;

            SortedList<uint, PicEntity> entities = new SortedList<uint, PicEntity>();
            PicFactory fTemp = new PicFactory();

            // segments
            double x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
            uint index = 0;
            const PicGraphics.LT ltCut = PicGraphics.LT.LT_CUT;
            const PicGraphics.LT ltFold = PicGraphics.LT.LT_CREASING;

            if (3 == caisse_en_4)
            {
                x1 = v1;
                y1 = V6;
                x2 = v2;
                y2 = y1;
                entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));

                x1 = v1;
                y1 = w0;
                x2 = x1;
                y2 = w2;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                x1 = x2;
                y1 = y2;
                x2 = v2;
                y2 = y1;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                x1 = x2;
                y1 = y2;
                x2 = x1;
                y2 = w0;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
            }
            else
            {
                x1 = v1;
                y1 = w0;
                x2 = x1;
                y2 = V6;
                entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));

                x1 = v2;
                y1 = w0;
                x2 = x1;
                y2 = V6;

                if (!caisse_en_2 && 0 == caisse_en_4)
                {
                    entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));

                    x1 = v3;
                    y1 = w0;
                    x2 = x1;
                    y2 = V6;
                    entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));

                    x1 = v4;
                    y1 = w0;
                    x2 = x1;
                    y2 = V6;
                }
                if (0 == caisse_en_4)
                {
                    entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));
                    x1 = v1 + ec2;
                    y1 = V6;
                    x2 = v2 - ec2;
                }
                else
                {
                    x1 = v1 + ec2;
                    y1 = V6;
                    if (caisse_en_4 == 4)
                        x2 = v2 - ec2;
                    else
                        x2 = v2;
                }
                y2 = y1;
                entities.Add(++index, fTemp.AddSegment(ltFold, 1, 1, x1, y1, x2, y2));

                if (caisse_en_4 == 4)
                {
                    x1 = x2;
                    y1 = y2;
                    x2 = x1 + ec1;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                }
                x1 = v2 + ec1;
                y1 = V6;
                if (!caisse_en_2 && caisse_en_4 == 0)
                    x2 = v3 - ec1;
                else
                    x2 = v3;
                y2 = y1;
                if (caisse_en_4 == 0)
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                if (!caisse_en_2 && caisse_en_4 == 0)
                {
                    // 9
                    x1 = v3 + ec2;
                    y1 = V6;
                    x2 = v4 - ec2;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 10
                    x1 = v4 + ec1;
                    y1 = V6;
                    x2 = V5;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                }


                // 11
                if (!caisse_en_2 && caisse_en_4 == 0)
                    x1 = V5;
                else
                {
                    if (caisse_en_4 == 0)
                        x1 = v3;
                    else
                        x1 = v2;
                }
                y1 = w0;
                x2 = x1;
                if (caisse_en_4 == 4)
                    y2 = V6;
                else
                    y2 = w4;
                entities.Add(++index, fTemp.AddSegment(caisse_en_4 == 4 ? ltFold : ltCut, 1, 1, x1, y1, x2, y2));

                if (caisse_en_4 == 4)
                {
                    x1 = x1 - ec1;
                    x2 = x1;
                    y1 = y2;
                    y2 = w4;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                }

                if (!caisse_en_2 && caisse_en_4 == 0)
                {
                    // 12
                    x1 = x2;
                    y1 = y2;
                    x2 = v4 + ec1;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 13
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = V6;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 14
                    x1 = x2;
                    y1 = y2;
                    x2 = v4 - ec2;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 15
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = w3;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 16
                    x1 = x2;
                    y1 = y2;
                    x2 = v3 + ec2;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 17
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = V6;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 18
                    x1 = x2;
                    y1 = y2;
                    x2 = v3 - ec1;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                    // 19
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = w2;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                }

                // 20
                x1 = x2;
                y1 = y2;
                y2 = y1;
                if (caisse_en_4 == 0)
                {
                    x2 = v2 + ec1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                    // 21
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = V6;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                    // 22
                    x1 = x2;
                    y1 = y2;
                    x2 = v2 - ec2;
                    y2 = y1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                    // 23
                    x1 = x2;
                    y1 = y2;
                    x2 = x1;
                    y2 = w1;
                    entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));
                    // 24
                }
                else
                {
                    if (caisse_en_4 != 4)
                        x2 = v2;
                }

                x1 = x2;
                y1 = y2;
                x2 = v1 + ec2;
                y2 = y1;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                // 25
                x1 = x2;
                y1 = y2;
                x2 = x1;
                y2 = V6;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                // 26
                x1 = x2;
                y1 = y2;
                x2 = v1;
                y2 = y1;
                entities.Add(++index, fTemp.AddSegment(ltCut, 1, 1, x1, y1, x2, y2));

                // Patte de Collage
                ParameterStack stackDemiPatteCol = DemiPatteCol.Parameters;
                if (caisse_en_4 != 3)
                {

                    //Call DemiPatteCol(ParamX1, lgPatte, H1, ec1, anglPc, patProlong, 0#, 0#, 0#, False)
                    DemiPatteCol.CreateFactoryEntities(fTemp, stackDemiPatteCol, transform);
                }
                if (caisse_en_4 == 4)
                {
                    // Call DemiPatteCol(ParamX1, lgPatte, H1, ec1, anglPc, patProlong, L1 + 2 * lgPatte, 0#, 180, True)
                    DemiPatteCol.CreateFactoryEntities(fTemp, stackDemiPatteCol, transform);
                }
            }

            if ((!Symy && PoignsurTete > 0) && caisse_en_4 == 0)
            {
                if (L1 < B1)
                {
                    v1 = lgPatte + L1 / 2.0;
                    v2 = lgPatte + L1 + B1 + L2 / 2.0;
                }
                else
                {
                    v1 = lgPatte + L1 + B1 / 2.0;
                    v2 = lgPatte + L1 + B1 + L2 + B2 / 2.0;
                }
                // ParamX1, v1, H1, 0, False
                ParameterStack stackPoignee = Poignee.Parameters;
                stackPoignee.SetDoubleParameter("", v1);
                stackPoignee.SetDoubleParameter("", H1);
                stackPoignee.SetDoubleParameter("", 0);
                stackPoignee.SetBoolParameter("", false);
                Poignee.CreateFactoryEntities(fTemp, stackPoignee, transform);

                //(ParamX1, v2, H1, 0, False)
                if (!caisse_en_2)
                    Poignee.CreateFactoryEntities(fTemp, stackPoignee, transform);
            }

            factory.AddEntities(fTemp, transform);
/*
            int hom = 0;
            if (Symy)
                hom = -1;
            else
                hom = 1;
            //ParamX1.Tranf2d Index(index1), Index(idxcour), Xo, Yo, Diro, hom
*/ 
        }
예제 #52
0
 /// <summary>
 /// Initialize string builder with initial sections + line types
 /// Instantiate DL_Dxf class and DL_Writer class
 /// </summary>
 /// <param name="factory"></param>
 public override void Initialize(PicFactory factory)
 {
     DL_Codes.dxfversion version = DL_Codes.dxfversion.AC1012;
     dw = new DL_Writer(version);
     dxf = new DL_Dxf();
     dxf.writeHeader(dw);
     dw.sectionEnd();
     // opening the table section
     dw.sectionTables();
     // writing viewports
     dxf.writeVPort(dw);
     // writing line types
     dw.tableLineTypes(25);
     dxf.writeLineType(dw, new DL_LineTypeData("BYBLOCK", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("BYLAYER", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("CONTINUOUS", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("ACAD_ISO02W100", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("ACAD_ISO03W100", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("ACAD_ISO04W100", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("ACAD_ISO05W100", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("BORDER", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("BORDER2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("BORDERX2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("CENTER", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("CENTER2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("CENTERX2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHDOT", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHDOT2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHDOTX2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHED", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHED2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DASHEDX2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DIVIDE", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DIVIDE2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DIVIDEX2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DOT", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DOT2", 0));
     dxf.writeLineType(dw, new DL_LineTypeData("DOTX2", 0));
     dw.tableEnd();
     // writing the layers
     int numberOfLayers = 3;
     dw.tableLayers(numberOfLayers);
     // CUT
     dxf.writeLayer(dw, new DL_LayerData("L5-113", 0),
         new DL_Attributes("",                       // leave empty
             (int)DL_Codes.dxfcolor.red,             // default color
             100,                                    // default width
             "CONTINUOUS"));                         // default line style
     // FOLD
     dxf.writeLayer(dw, new DL_LayerData("L8-123", 0),
         new DL_Attributes("",                       // leave empty
             (int)DL_Codes.dxfcolor.blue,            // default color
             100,                                    // default width
             "CONTINUOUS"));                         // default line style
     // COTATION
     dxf.writeLayer(dw, new DL_LayerData("LDM-4", 0),
         new DL_Attributes("",                       // leave empty
             (int)DL_Codes.dxfcolor.green,           // default color
             100,                                    // default width
             "CONTINUOUS"));                         // default line style
     dw.tableEnd();
     dw.sectionEnd();
     // write all entities
     dw.sectionEntities();
 }
예제 #53
0
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            PicFactory fTemp = new PicFactory();
            const PicGraphics.LT ltCut = PicGraphics.LT.LT_CUT;
            const PicGraphics.LT ltFold = PicGraphics.LT.LT_CREASING;

            // get parameter values
            double L = stack.GetDoubleParameterValue("L");
            double H = stack.GetDoubleParameterValue("H");
            double E = stack.GetDoubleParameterValue("E");
            int PoignsurTete = stack.GetMultiParameterValue("PoignsurTete");

            short layer = 1;
            short grp = 1;
            PicGraphics.LT lt = ltCut;
            if (PoignsurTete >= 2)
            {
                lt = ltFold;
                layer = 2;
            }
            double x1 = (L-H)/2.0;
            double y1 = 0.0;
            double x2 = x1 - (L - H);
            double y2 = y1;
            fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

            lt = ltCut;
            double ry = H / 2.0;
            double xc = x2;
            double yc = - H / 2.0;
            fTemp.AddArc(lt, grp, layer, xc, yc, ry, 90.0, 270.0);

            x1 = xc;
            y1 = -H;
            x2 = x1 + (L - H);
            y2 = y1;
            fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

            ry = H / 2.0;
            xc = x2;
            yc = -H / 2.0;
            fTemp.AddArc(lt, grp, layer, xc, yc, ry, -90.0, 90.0);

            if (PoignsurTete == 3)
            {
                lt = ltCut;
                x1 = (L - H) / 2.0;
                y1 = 0.0;
                x2 = x1;
                y2 = y1 + E;
                fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

                x1 = x2;
                y1 = y2;
                x2 = x1 + E;
                y2 = y1;
                fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

                x1 = -(L - H) / 2.0;
                y1 = 0.0;
                x2 = x1;
                y2 = y1 + E;
                fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

                x1 = x2;
                y1 = y2;
                x2 = x1 - E;
                y2 = y1;
                fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);

                lt = ltFold;
                x2 = x1 + (L - H);
                y2 = y1;
                fTemp.AddSegment(lt, grp, layer, x1, y1, x2, y2);
            }

            factory.AddEntities(fTemp, transform);
        }
예제 #54
0
        public void CreateFactoryEntities(PicFactory factory, ParameterStack stack, Transform2D transform)
        {
            PicFactory fTemp = new PicFactory();

            // free variables
            double a = stack.GetDoubleParameterValue("a");
            double b = stack.GetDoubleParameterValue("b");
            double h = stack.GetDoubleParameterValue("h");
            double e = stack.GetDoubleParameterValue("e");
            double g = stack.GetDoubleParameterValue("g");

            int iTop = stack.GetMultiParameterValue("TOP");
            int iBot = stack.GetMultiParameterValue("BOTTOM");

            double gg = 15.0;

            // formulas
            SortedList<uint, PicEntity> entities = new SortedList<uint, PicEntity>();

            if (g < 5)
            { // Glue_flap
                IPlugin pluginIn = Host.GetPluginByGuid("729625f4-921d-4f72-af43-4248835a59f3");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                gg = stackIn.GetDoubleParameterValue("g");
            }
            else
                gg = g;
            //---------- TOP Architecture ---------------------
            if (iTop == 0)
            { // Sleeve
                IPlugin pluginIn = Host.GetPluginByGuid("da290efa-83a5-4ccd-808c-9a5eec81f36b");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("H", h / 2);		// H
                stackIn.SetDoubleParameter("g", gg);		// g
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iTop == 1)
            { // Tuck_end
                int iTuck = stack.GetMultiParameterValue("TUCK");

                IPlugin pluginIn = Host.GetPluginByGuid("818567a3-ce01-45f5-b328-04031713c12c");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// A
                stackIn.SetDoubleParameter("b", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// H
                stackIn.SetDoubleParameter("e", e);		// t
                stackIn.SetDoubleParameter("g", g);		// g
                if (2 == iTuck)
                {
                    int iHole = stack.GetMultiParameterValue("HOLE");
                    stackIn.SetMultiParameter("HOLE", iHole);		// Hanging Hole			
                }
                stackIn.SetDoubleParameter("bp", iTuck);
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iTop == 2)
            { // Inverted_Tuck_end
                int iTuck = stack.GetMultiParameterValue("TUCK");

                IPlugin pluginIn = Host.GetPluginByGuid("66e5437d-a8a8-404d-951c-e7bf944d2342");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// A
                stackIn.SetDoubleParameter("b", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// H
                stackIn.SetDoubleParameter("e", e);		// t
                stackIn.SetDoubleParameter("g", g);		// g
                stackIn.SetDoubleParameter("bp", iTuck);
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iTop == 3)
            { // Edge_Lock
                int iEdge = stack.GetMultiParameterValue("Edge");

                IPlugin pluginIn = Host.GetPluginByGuid("827b4625-ccad-41f8-823a-c165852ca8f4");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("g", gg);		// g
                stackIn.SetMultiParameter("Edge", iEdge);		// Edge Lock
                stackIn.SetDoubleParameter("A1", b);			// A1
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iTop == 4)
            { // Seal_End
                int iSeal = stack.GetMultiParameterValue("Seal");

                IPlugin pluginIn = Host.GetPluginByGuid("af7fb901-90de-4034-9a27-c21d51f826d2");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("g", gg);		// g
                stackIn.SetMultiParameter("Seal", iSeal);		// Seal End
                stackIn.SetDoubleParameter("e", e);		// e
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }


            //---------- BOTTOM Architecture ---------------------
            if (iBot == 0)
            { // Sleeve
                IPlugin pluginIn = Host.GetPluginByGuid("da290efa-83a5-4ccd-808c-9a5eec81f36b");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("H", h / 2);		// H
                stackIn.SetDoubleParameter("g", gg);		// g
                bool reflectionX = true, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 1)
            { // Tuck_end
                int iBTuck = stack.GetMultiParameterValue("BTUCK");
                IPlugin pluginIn = Host.GetPluginByGuid("818567a3-ce01-45f5-b328-04031713c12c");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// A
                stackIn.SetDoubleParameter("b", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// H
                stackIn.SetDoubleParameter("e", e);		// t
                stackIn.SetDoubleParameter("g", g);		// g
                stackIn.SetDoubleParameter("bp", 0.0);
                if (iBTuck == 2)
                    stackIn.SetDoubleParameter("bp", 0);
                else
                    stackIn.SetDoubleParameter("bp", iBTuck);
                bool reflectionX = true, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 2)
            { // Inverted_Tuck_end
                int iBTuck = stack.GetMultiParameterValue("BTUCK");

                IPlugin pluginIn = Host.GetPluginByGuid("66e5437d-a8a8-404d-951c-e7bf944d2342");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// A
                stackIn.SetDoubleParameter("b", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// H
                stackIn.SetDoubleParameter("e", e);		// t
                stackIn.SetDoubleParameter("g", g);		// g
                stackIn.SetDoubleParameter("bp", 0.0);
                if (iBTuck == 2)
                    stackIn.SetDoubleParameter("bp", 0);
                else
                    stackIn.SetDoubleParameter("bp", iBTuck);
                bool reflectionX = true, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 3)
            { // Snap_lock_base
                IPlugin pluginIn = Host.GetPluginByGuid("2c366e1f-35d1-4e72-ba2b-7786e699f94c");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// a
                stackIn.SetDoubleParameter("b", b);		// b
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("g", g);		// g
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 4)
            { // Crash_lock_base
                IPlugin pluginIn = Host.GetPluginByGuid("2015adce-a857-49c8-b051-b6891b90b941");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("a", a);		// a
                stackIn.SetDoubleParameter("b", b);		// b
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("d", e);		// d
                stackIn.SetDoubleParameter("g", g);		// g
                bool reflectionX = false, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(0.0, -h / 2))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 5)
            { // Edge_Lock
                int iBEdge = stack.GetMultiParameterValue("BEdge");

                IPlugin pluginIn = Host.GetPluginByGuid("827b4625-ccad-41f8-823a-c165852ca8f4");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("e", e);		// e
                stackIn.SetDoubleParameter("g", gg);		// g
                stackIn.SetMultiParameter("Edge", iBEdge);		// Edge Lock
                stackIn.SetDoubleParameter("A1", b);			// A1
                bool reflectionX = true, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }
            else if (iBot == 6)
            { // Seal_End
                int iBSeal = stack.GetMultiParameterValue("BSeal");

                IPlugin pluginIn = Host.GetPluginByGuid("af7fb901-90de-4034-9a27-c21d51f826d2");
                ParameterStack stackIn = Host.GetInitializedParameterStack(pluginIn);
                stackIn.SetDoubleParameter("A", a);		// A
                stackIn.SetDoubleParameter("B", b);		// B
                stackIn.SetDoubleParameter("h", h / 2);		// h
                stackIn.SetDoubleParameter("g", gg);		// g
                stackIn.SetMultiParameter("Seal", iBSeal);		// Seal End
                stackIn.SetDoubleParameter("e", e);		// e
                bool reflectionX = true, reflectionY = false;
                Transform2D transfReflect = (reflectionY ? Transform2D.ReflectionY : Transform2D.Identity) * (reflectionX ? Transform2D.ReflectionX : Transform2D.Identity);
                pluginIn.CreateFactoryEntities(fTemp, stackIn,
                     Transform2D.Translation(new Vector2D(gg, 0.0))
                     * Transform2D.Rotation(0.0)
                     * transfReflect);
            }

            factory.AddEntities(fTemp, transform);
        }
예제 #55
0
        public void GenerateImage(Size size, ParameterStack stack, out Image bmp)
        {
            // check if plugin was instantiated
            if (null == _component)
                throw new Exception("No valid plugin instance loaded!");

            // instantiate factory
            PicFactory factory = new PicFactory();
            // generate entities
            _component.CreateFactoryEntities(factory, stack);
            // apply any needed transformation
            if (_reflexionX) factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
            if (_reflexionY) factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
            // get bounding box
            PicVisitorBoundingBox visitor = new PicVisitorBoundingBox();
            factory.ProcessVisitor(visitor);
            Pic.Factory2D.Box2D box = visitor.Box;
            box.AddMarginRatio(0.05);
            // draw image
            PicGraphicsImage picImage = new PicGraphicsImage(size, box);
            factory.Draw(picImage, _showCotations ? PicFilter.FilterNone : PicFilter.FilterCotation);

            bmp = picImage.Bitmap;
        }
예제 #56
0
        public override void ProcessFactory(PicFactory factory)
        {
            // initialization
            _segList.Clear();
            _box = new Box2D();
            _area = 0.0;

            // build list of segments with entities that belongs to group
            factory.ProcessToolAllEntities(this);
            _box.AddMarginRatio(0.2);

            // exit if no of segments exceeds MAXSEG
            int maxSeg = Pic.Factory2D.Properties.Settings.Default.AreaMaxNoSegments;
            if (_segList.Count > maxSeg)
                throw new PicToolTooLongException(string.Format("No of segments exceeds {0}", maxSeg));

            // compute actual step size
            uint iNoStep = (uint)(_box.Width / _stepSize);
            iNoStep = Math.Min(iNoStep, _iNoStepMax);
            double stepDefault = _box.Width / iNoStep;

            // compute area
            for (int i = 0; i < iNoStep; ++i)
            {
                double xh = _box.XMin + i * stepDefault;
                int nby = 1;
                double stepCurrent = stepDefault;
                List<double> tabyh = new List<double>();

                tabyh.Add(double.MaxValue);

                bool bAgain = false;
                do
                {
                    bAgain = false;
                    stepCurrent = stepDefault;

                    foreach (Segment segTemp in _segList)
                    {
                        Segment seg;
                        if (segTemp.P0.X <= segTemp.P1.X)
                            seg = segTemp;
                        else
                            seg = new Segment(segTemp.P1, segTemp.P0);

                        if (xh >= seg.P0.X && xh <= seg.P1.X)
                        {
                            // cas intersections confondues
                            if ((Math.Abs(xh - seg.P0.X) < 0.001) || (Math.Abs(seg.P1.X - xh) < 0.001))
                            {
                                // restart loop from the beginning
                                nby = 1;
                                tabyh[0] = double.MaxValue;
                                stepCurrent = 0.9 * stepDefault;
                                xh -= stepDefault * 0.1;
                                bAgain = true;
                                break;
                            }
                            else
                            {
                                double yh = seg.P0.Y + (xh - seg.P0.X) * ((seg.P1.Y - seg.P0.Y) / (seg.P1.X - seg.P0.X));
                                tabyh.Add(yh);
                            }
                        }
                    }
                }
                while (bAgain);

                tabyh.Sort();
                nby = tabyh.Count;

                // increment area
                if (nby > 1 && (nby % 2 != 0))
                {
                    for (int l = 0; l < nby - 1; l += 2)
                    {
                        _area = _area + stepCurrent * (tabyh[l + 1] - tabyh[l]);
                    }
                }
            }
        }
예제 #57
0
        public void BuildLayout()
        {
            Pic.Factory2D.Control.FormImpositionSettings formSettings = new Pic.Factory2D.Control.FormImpositionSettings();
            if (null != _cardboardFormatLoader)
                formSettings.FormatLoader = _cardboardFormatLoader;

            // get offset
            Vector2D impositionOffset = Component.ImpositionOffset(CurrentParameterStack);
            // initialize form with offsets
            formSettings.OffsetX = impositionOffset.X;
            formSettings.OffsetY = impositionOffset.Y;

            if (DialogResult.OK == formSettings.ShowDialog())
            {
                using (PicFactory factory = new PicFactory())
                {
                    // build factory entities
                    Component.CreateFactoryEntities(factory, CurrentParameterStack);
                    if (_reflectionX) factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionX));
                    if (_reflectionY) factory.ProcessVisitor(new PicVisitorTransform(Transform2D.ReflectionY));
                    // build imposition solutions
                    if (formSettings.Mode == 0)
                        _impositionTool = new ImpositionToolCardboardFormat(factory, formSettings.CardboardFormat);
                    else
                        _impositionTool = new ImpositionToolXY(factory, formSettings.NumberDirX, formSettings.NumberDirY);
                    // -> margins
                    _impositionTool.HorizontalAlignment = formSettings.HorizontalAlignment;
                    _impositionTool.VerticalAlignment = formSettings.VerticalAlignment;
                    _impositionTool.SpaceBetween = new Vector2D(formSettings.ImpSpaceX, formSettings.ImpSpaceY);
                    _impositionTool.Margin = new Vector2D(formSettings.ImpMarginLeftRight, formSettings.ImpMarginBottomTop);
                    _impositionTool.MinMargin = new Vector2D(formSettings.ImpRemainingMarginLeftRight, formSettings.ImpRemainingMarginBottomTop);
                    // -> allowed patterns
                    _impositionTool.AllowRotationInColumnDirection = formSettings.AllowColumnRotation;
                    _impositionTool.AllowRotationInRowDirection = formSettings.AllowRowRotation;
                    // -> offsets
                    _impositionTool.ImpositionOffset = new Vector2D(formSettings.OffsetX, formSettings.OffsetY);
                    // instantiate ProgressWindow and launch process
                    ProgressWindow progress = new ProgressWindow();
                    System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(GenerateImpositionSolutions), progress);
                    progress.ShowDialog();
                    // show dialog
                    if (null != _solutions && _solutions.Count > 0)
                    {
                        Pic.Factory2D.Control.FormImposition form = new Pic.Factory2D.Control.FormImposition();
                        form.Solutions = _solutions;
                        form.Format = formSettings.CardboardFormat;
                        if (DialogResult.OK == form.ShowDialog(this))
                        {
                        }
                    }
                }
            }            
        }
예제 #58
0
        static void Main(string[] args)
        {
            // set up a simple configuration that logs on the console.
            XmlConfigurator.Configure();

            try
            {
                _log.Info("Pic.Factory2D.Test.exe starting...");
                // testing Sharp3D.Math.Core.Matrix3D
                Transform2D transf0 = Transform2D.Translation(new Vector2D(10.0, 10.0)) * Transform2D.Rotation(45.0);
                Vector2D pt0 = transf0.transform(new Vector2D(100.0, 100.0));
                _log.Info(pt0.ToString());
                Transform2D transf1 = transf0.Inverse();
                Vector2D pt1 = transf1.transform(pt0);
                _log.Info(pt1.ToString());

                // instantiate factory1
                PicFactory factory0 = new PicFactory();
                factory0.AddPoint(PicGraphics.LT.LT_CUT, new Vector2D(0.0, 0.0));
                factory0.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(50.0, 50.0), new Vector2D(100.0, 100.0));
                factory0.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(-100.0, 100.0), new Vector2D(100.0, -100.0));
                factory0.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(50.0, 50.0), 50.0 * Math.Sqrt(2.0), 0.0, 360.0);
                factory0.AddArc(PicGraphics.LT.LT_CUT, new Vector2D(75.0, 75.0), 25.0 * Math.Sqrt(2.0), 0.0, 360.0);
                factory0.AddNurb(PicGraphics.LT.LT_CUT);
                _log.Debug(factory0.ToString());

                // get bounding box + draw
                using (PicVisitorBoundingBox visitor = new PicVisitorBoundingBox())
                {
                    factory0.ProcessVisitor(visitor);
                    _log.Info(visitor.Box.ToString());

                    // save as image
                    string filePath = Path.Combine(Path.GetTempPath(), "PicImage0.jpeg");
                    PicGraphicsImage picImage = new PicGraphicsImage();
                    picImage.ImageSize = new System.Drawing.Size(512, 512);
                    Box2D box = visitor.Box;
                    box.AddMargin(5);
                    picImage.DrawingBox = box;
                    factory0.Draw(picImage);
                    picImage.SaveAs(filePath);
                    _log.Debug("File path = " + filePath);
                    _log.Debug("Path = " + Path.Combine(Environment.SystemDirectory, "mspaint.exe"));
                    System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), filePath);
                }

                // output to dxf file
                Pic.Factory2D.PicVisitorDxfOutput dxfOutputVisitor = new Pic.Factory2D.PicVisitorDxfOutput();
                factory0.ProcessVisitor(dxfOutputVisitor);

                // load dxf file
                PicFactory factory1 = new PicFactory();
                PicLoaderDxf loaderDxf = new PicLoaderDxf(factory1);
                loaderDxf.Load(@"K:\Codesion\PicSharp\Samples\F1034.EV.DXF");
                loaderDxf.FillFactory();
                // save as image
                // get bounding box + draw
                using (PicVisitorBoundingBox visitor1 = new PicVisitorBoundingBox())
                {
                    factory1.ProcessVisitor(visitor1);
                    _log.Info(visitor1.Box.ToString());
                    string filePath1 = Path.Combine(Path.GetTempPath(), "PicImage1.jpeg");
                    PicGraphicsImage picImage1 = new PicGraphicsImage();
                    picImage1.ImageSize = new System.Drawing.Size(512, 512);
                    Box2D box1 = visitor1.Box;
                    box1.AddMargin(5);
                    picImage1.DrawingBox = box1;
                    factory1.Draw(picImage1);
                    picImage1.SaveAs(filePath1);
                    _log.Debug("File path = " + filePath1);
                    _log.Debug("Path = " + Path.Combine(Environment.SystemDirectory, "mspaint.exe"));
                    System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), filePath1);
                }

                // instantiate factory2
                PicFactory factory2 = new PicFactory();
                PicBlock block = factory2.AddBlock(factory0);
                factory2.AddBlockRef(block, new Vector2D(0.0, 0.0), 0.0);
                factory2.AddBlockRef(block, new Vector2D(400.0, 0.0), 0.0);
                factory2.AddBlockRef(block, new Vector2D(0.0, 400.0), 0.0);
                factory2.AddBlockRef(block, new Vector2D(400.0, 400.0), 45.0);

                // get bounding box of factory2
                using (PicVisitorBoundingBox visitor = new PicVisitorBoundingBox())
                {
                    factory2.ProcessVisitor(visitor);
                    _log.Info(visitor.Box.ToString());

                    // save as image
                    string filePath = Path.Combine(Path.GetTempPath(), "PicImage2.jpeg");
                    PicGraphicsImage picImage = new PicGraphicsImage();
                    picImage.ImageSize = new System.Drawing.Size(512, 512);
                    Box2D box = visitor.Box;
                    box.AddMargin(5);
                    picImage.DrawingBox = box;
                    factory2.Draw(picImage);
                    picImage.SaveAs(filePath);
                    _log.Debug("File path = " + filePath);
                    _log.Debug("Path = " + Path.Combine(Environment.SystemDirectory, "mspaint.exe"));
                    System.Diagnostics.Process.Start(Path.Combine(Environment.SystemDirectory, "mspaint.exe"), filePath);
                }

                // compute area
                PicFactory factory3 = new PicFactory();
                factory3.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(-100.0, -100.0), new Vector2D(100.0, -100.0));
                factory3.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(100.0, -100.0), new Vector2D(100.0, 100.0));
                factory3.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(100.0, 100.0), new Vector2D(-100.0, 100.0));
                factory3.AddSegment(PicGraphics.LT.LT_CUT, new Vector2D(-100.0, 100.0), new Vector2D(-100.0, -100.0));

                PicToolArea picToolArea = new PicToolArea();
                factory3.ProcessTool(picToolArea);
                _log.Info(string.Format("Area of factory3 is {0}", picToolArea.Area));

                _log.Info("Pic.Factory2D.Test.exe finishing...");
            }
            catch (Exception ex)
            {
                _log.Error(ex.ToString());
            }
        }
예제 #59
0
 /// <summary>
 /// Creates factory entities (mostly segment, arcs, cotations...) in <see cref="PicFactory"/> class instance passed as first argument
 /// </summary>
 /// <param name="factory">Instance of class <see cref="PicFactory"/> to be populated with entities</param>
 /// <param name="stack">Array of <see cref="Paramerter"/> to apply while generating entities</param>
 public void CreateFactoryEntities(PicFactory factory, ParameterStack stack)
 {
     _instance.CreateFactoryEntities(factory, stack, Transform2D.Identity);
 }
예제 #60
0
			public abstract void Initialize(PicFactory factory);