Beispiel #1
0
        private static void RunCalculation(string file, string timeStamp)
        {
            TspFile tspfile = TspFile.Load(file);
            CapacitatedVehicleRoutingProblem problem = CapacitatedVehicleRoutingProblem.FromFile(file);
            Graph Graph = new Graph(_maxDemand: tspfile.Capacity);
            var   nodes = problem.NodeProvider.GetNodes();

            for (int i = 0; i < nodes.Count; i++)
            {
                TspLibNet.Graph.Nodes.Node2D node = (TspLibNet.Graph.Nodes.Node2D)nodes[i];
                double  demand = problem.DemandProvider.GetDemand(nodes[i]);
                Vertice v      = new Vertice();
                v.X      = node.X;
                v.Y      = node.Y;
                v.Demand = demand;
                Graph.Vertices.Add(v);
            }
            Graph.RecalculateVertices();
            var maxDistance = Graph.Edges.SelectMany(x => x).Max(x => x.Weigth) * 200;

            Graph.maxDistance = maxDistance;
            var    solution  = Graph.FindDVRPSolution();
            double usage     = Graph.CalculateUsage(solution);
            string paramsCSV = file + "," + Graph.GetParamsCSV() + ",\"" + tspfile.Comment + "\"," + usage + "\n";

            System.IO.File.AppendAllText(@"Benchmarks" + timeStamp + ".csv", paramsCSV);
        }
        // TODO: no opt tours for SOP, VRP, ATSP with known distance for validation

        private static void AssertTourDistance(FileType problemType, string problemFileName, string tourFileName, int expectedDistance)
        {
            var problemTspFile = Path.Combine(RootDir, problemFileName);
            var tourTspFile    = TspFile.Load(Path.Combine(RootDir, tourFileName));

            Assert.IsNotNull(problemTspFile);
            Assert.IsNotNull(tourTspFile);

            IProblem problem = null;

            switch (problemType)
            {
            case FileType.TSP:
            case FileType.ATSP:
                problem = TravelingSalesmanProblem.FromFile(problemTspFile);
                break;

            case FileType.CVRP:
                problem = CapacitatedVehicleRoutingProblem.FromFile(problemTspFile);
                break;

            case FileType.SOP:
                problem = SequentialOrderingProblem.FromFile(problemTspFile);
                break;
            }

            Assert.IsNotNull(problem);

            ITour tour = Tour.FromTspFile(tourTspFile);

            Assert.IsNotNull(tour);
            Assert.AreEqual(expectedDistance, problem.TourDistance(tour));
        }
Beispiel #3
0
        static void Main(string[] args)
        {
            //Dependency injection setup beigns
            // create service collection
            var serviceCollection = new ServiceCollection();

            ConfigureServices(serviceCollection);
            // create service provider
            var serviceProvider = serviceCollection.BuildServiceProvider();
            //Dependency injection setup ends

            var filename = "ColorTattooPNGFile";
            var png      = new PngFile(filename);
            var svg      = new SvgFile("S1000Z0point8NoOverlapColorTattooPNGFile");
            var tsp      = new TspFile(filename);
            var tspSol   = new TspSolFile("S1000Z0point8NoOverlapColorTattooPNGFile");

            tsp.Dimension = 1000;

            //var stipplerServices = serviceProvider.GetRequiredService<IStippler>();
            //Console.WriteLine(stipplerServices.CallStippler(png, 1000, 0.8));

            var tspServices = serviceProvider.GetRequiredService <IGcodeCreator>();

            //Console.WriteLine(tspServices.ConvertCircleSVGtoTSP(svg));

            //Console.WriteLine(tspServices.ReorderSVGAccordingtoTSPsol(svg, tspSol, tsp));

            Console.Read();
        }
Beispiel #4
0
        public TSP(string fileName)
        {
            if (fileName == null)
            {
                fileName = "bays29";
            }

            var rootDirectory = ConfigurationManager.AppSettings["RootDirectory"];

            FileName = fileName;

            var problemTspFile = Path.Combine(rootDirectory, FileName + ".tsp");
            var tourTspFile    = TspFile.Load(Path.Combine(rootDirectory, FileName + ".opt.tour"));

            TheProblem = TravelingSalesmanProblem.FromFile(problemTspFile);
            TheTour    = Tour.FromTspFile(tourTspFile);
            TotalNodes = TheProblem.NodeProvider.CountNodes();

            var dim = new int[TotalNodes];

            for (var i = 0; i < TotalNodes; i++)
            {
                dim[i] = (TheTour.Nodes[i]) - 1;
            }
            OptimalKnown = Evaluate(dim);
        }
Beispiel #5
0
        /// <summary>
        /// Create tour from TSP file
        /// </summary>
        /// <param name="tspFile">tsp file to load from</param>
        /// <returns>Tour read from tsp file</returns>
        public static Tour FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != TSP.Defines.FileType.TOUR)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            return(new Tour(tspFile.Name, tspFile.Comment, tspFile.Dimension, tspFile.Tour));
        }
Beispiel #6
0
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static HamiltonianCycleProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.HCP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider        = extractor.MakeNodeProvider();
            var nodes               = nodeProvider.GetNodes();
            var edgeProvider        = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = new NodeAdjacencyBasedWeightProvider(edgeProvider, 1, 2);
            var fixedEdgesProvider  = extractor.MakeFixedEdgesProvider(nodes);

            return(new HamiltonianCycleProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider));
        }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static TravelingSalesmanProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.TSP && tspFile.Type != FileType.ATSP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider        = extractor.MakeNodeProvider();
            var nodes               = nodeProvider.GetNodes();
            var edgeProvider        = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider  = extractor.MakeFixedEdgesProvider(nodes);
            var type = (tspFile.Type == FileType.TSP) ? ProblemType.TSP : ProblemType.ATSP;

            return(new TravelingSalesmanProblem(tspFile.Name, tspFile.Comment, type, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider));
        }
        private static void AssertHCPTourDistance(string problemFileName, string tourFileName)
        {
            var problemTspFile = Path.Combine(RootDir, problemFileName);
            var tourTspFile    = TspFile.Load(Path.Combine(RootDir, tourFileName));

            Assert.IsNotNull(problemTspFile);
            Assert.IsNotNull(tourTspFile);

            var problem = HamiltonianCycleProblem.FromFile(problemTspFile);

            Assert.IsNotNull(problem);

            ITour tour = Tour.FromTspFile(tourTspFile);

            Assert.IsNotNull(tour);
            Assert.AreEqual(problem.OptimalTourDistance, problem.TourDistance(tour));
        }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static CapacitatedVehicleRoutingProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.CVRP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider        = extractor.MakeNodeProvider();
            var nodes               = nodeProvider.GetNodes();
            var edgeProvider        = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider  = extractor.MakeFixedEdgesProvider(nodes);
            var depots              = extractor.MakeDepotsProvider(nodes);
            var demand              = extractor.MakeDemandProvider(nodes);

            return(new CapacitatedVehicleRoutingProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider, depots, demand));
        }
Beispiel #10
0
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static SequentialOrderingProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.SOP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            double weight = tspFile.EdgeWeights[0];

            tspFile.EdgeWeights.RemoveAt(0);

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider        = extractor.MakeNodeProvider();
            var nodes               = nodeProvider.GetNodes();
            var edgeProvider        = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider  = extractor.MakeFixedEdgesProvider(nodes);

            tspFile.EdgeWeights.Insert(0, weight);

            return(new SequentialOrderingProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider));
        }
Beispiel #11
0
 public static TravelingSalesmanProblem FromString(string content)
 {
     return(FromTspFile(TspFile.LoadFromString(content)));
 }
        public string ConvertCircleSVGtoTSP(string svgFileName)
        {
            svgFileName = FileNameParser.RemoveDotFileExtensionInFileName(svgFileName);

            var svgFile = new SvgFile(svgFileName);
            var tspFile = new TspFile(svgFile.FileName)
            {
                Dimension = GetSvgFileCircleLineCount(svgFile)//TSP file must contain information regarding how many circles that there are in the svgfile
            };

            int XwordStart, XwordEnd, YwordStart, YwordEnd;

            if (tspFile.Dimension != 0)
            {
                try
                {
                    tspFile.SvgFileName = svgFile.FullFileName;
                    // Create an instance of StreamReader to read from a file.
                    // The using statement also closes the StreamReader.
                    using (StreamReader svgReader = new StreamReader($"{filepath}{svgFile.FullFileName}"))
                    {
                        using (StreamWriter tspWriter = new StreamWriter($"{filepath}{tspFile.FullFileName}"))
                        {
                            //populate tspfile header
                            tspWriter.WriteLine(TspFile.GetFileHeader(tspFile));

                            var count = 1;

                            string line;
                            // Read and display lines from the file until the end of
                            // the file is reached.
                            while ((line = svgReader.ReadLine()) != null)
                            {
                                if (line.Contains("circle"))
                                {
                                    tspWriter.Write(count + " ");
                                    XwordStart = line.IndexOf(CX) + CX.Length + 2;
                                    XwordEnd   = line.IndexOf(CY, XwordStart);

                                    tspWriter.Write(line.Substring(XwordStart, XwordEnd - XwordStart - 2) + " ");

                                    YwordStart = line.IndexOf(CY) + CY.Length + 2;
                                    YwordEnd   = line.IndexOf(R, YwordStart);

                                    tspWriter.WriteLine(line.Substring(YwordStart, YwordEnd - YwordStart - 2));
                                    //Console.WriteLine($"Xcoord: {svg.xCoord}, Ycoord: {svg.yCoord}");

                                    count++;
                                }
                            }
                            tspWriter.WriteLine(tspFile.EndofFile);
                            return($"The TSP Problem file {filepath}{tspFile.FullFileName} has been created");
                        }
                    }
                }
                catch (Exception e)
                {
                    // Let the user know what went wrong.
                    return($"The file {filepath}{svgFile.FullFileName} could not be read. {e.Message}");
                }
            }
            else
            {
                return($"The file {filepath}{svgFile.FullFileName} does not have a dimension value");
            }
        }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static SequentialOrderingProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.SOP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            double weight = tspFile.EdgeWeights[0];
            tspFile.EdgeWeights.RemoveAt(0);

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider = extractor.MakeNodeProvider();
            var nodes = nodeProvider.GetNodes();
            var edgeProvider = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider = extractor.MakeFixedEdgesProvider(nodes);

            tspFile.EdgeWeights.Insert(0, weight);

            return new SequentialOrderingProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider);
        }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static HamiltonianCycleProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.HCP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider = extractor.MakeNodeProvider();
            var nodes = nodeProvider.GetNodes();
            var edgeProvider = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = new NodeAdjacencyBasedWeightProvider(edgeProvider, 1, 2);
            var fixedEdgesProvider = extractor.MakeFixedEdgesProvider(nodes);
            return new HamiltonianCycleProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider);
        }
 /// <summary>
 /// Load problem from TSP file
 /// </summary>
 /// <param name="fileName">name of the file</param>
 /// <returns>Loaded problem</returns>
 public static TravelingSalesmanProblem FromFile(string fileName)
 {
     return(FromTspFile(TspFile.Load(fileName)));
 }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static CapacitatedVehicleRoutingProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.CVRP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider = extractor.MakeNodeProvider();
            var nodes = nodeProvider.GetNodes();
            var edgeProvider = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider = extractor.MakeFixedEdgesProvider(nodes);
            var depots = extractor.MakeDepotsProvider(nodes);
            var demand = extractor.MakeDemandProvider(nodes);
            return new CapacitatedVehicleRoutingProblem(tspFile.Name, tspFile.Comment, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider, depots, demand);
        }
Beispiel #17
0
 /// <summary>
 /// Load tour from TSP file
 /// </summary>
 /// <param name="fileName">name of the file</param>
 /// <returns>Loaded tour</returns>
 public static Tour FromFile(string fileName)
 {
     return(FromTspFile(TspFile.Load(fileName)));
 }
Beispiel #18
0
 /// <summary>
 /// Load problem from TSP file
 /// </summary>
 /// <param name="fileName">name of the file</param>
 /// <returns>Loaded problem</returns>
 public static HamiltonianCycleProblem FromFile(string fileName)
 {
     return(FromTspFile(TspFile.Load(fileName)));
 }
 /// <summary>
 /// Load problem from TSP file
 /// </summary>
 /// <param name="fileName">name of the file</param>
 /// <returns>Loaded problem</returns>
 public static CapacitatedVehicleRoutingProblem FromFile(string fileName)
 {
     return(FromTspFile(TspFile.Load(fileName)));
 }
Beispiel #20
0
 /// <summary>
 /// Load problem from TSP file
 /// </summary>
 /// <param name="fileName">name of the file</param>
 /// <returns>Loaded problem</returns>
 public static SequentialOrderingProblem FromFile(string fileName)
 {
     return(FromTspFile(TspFile.Load(fileName)));
 }
Beispiel #21
0
 public void LoadFile(string filePath)
 {
     _tspFile  = TspFile.Load(filePath);
     Dimension = _tspFile.Dimension;
 }
        /// <summary>
        /// Load problem from TSP file
        /// </summary>
        /// <param name="tspFile">TSP file instance</param>
        /// <returns>Loaded problem</returns>
        private static TravelingSalesmanProblem FromTspFile(TspFile tspFile)
        {
            if (tspFile.Type != FileType.TSP && tspFile.Type != FileType.ATSP)
            {
                throw new ArgumentOutOfRangeException("tspFile");
            }

            TspFileDataExtractor extractor = new TspFileDataExtractor(tspFile);
            var nodeProvider = extractor.MakeNodeProvider();
            var nodes = nodeProvider.GetNodes();
            var edgeProvider = extractor.MakeEdgeProvider(nodes);
            var edgeWeightsProvider = extractor.MakeEdgeWeightsProvider();
            var fixedEdgesProvider = extractor.MakeFixedEdgesProvider(nodes);
            var type = (tspFile.Type == FileType.TSP) ? ProblemType.TSP : ProblemType.ATSP;
            return new TravelingSalesmanProblem(tspFile.Name, tspFile.Comment, type, nodeProvider, edgeProvider, edgeWeightsProvider, fixedEdgesProvider);
        }