private static List <SvgMeshData> GetSvgMeshDatas(SvgFile svg, bool normalize = true)
{
var meshesData = new List <SvgMeshData>();
var svgStyle = default(Style);
foreach (var item in svg.GraphicElements)
{
if (item is CoreSvg.Models.Group)
{
meshesData.AddRange(GetMeshesData((CoreSvg.Models.Group)item, null, svg.Definitions));
}
else
{
meshesData.Add(GetMesh(item, null, svg.Definitions));
}
}
meshesData.ForEach(data =>
{
if (!string.IsNullOrWhiteSpace(svg.ViewBox))
{
var viewBox = svg.ViewBox.Split(" ", StringSplitOptions.RemoveEmptyEntries).Select(a => float.Parse(a.FixDecimalPoint())).ToList();
data.MinPosition = new float[] { viewBox[0], viewBox[1] };
data.Size = new float[] { viewBox[2], viewBox[3] };
}
ApplyTransforms(data);
});
return(meshesData);
}
public string CreateCircularGCodeFile()
{
try
{
svgFile = new SvgFile(svgFileName);
gcodeFile = new GcodeFile(svgFile.FileName, safeZHeight, cutFeedRate, plungeFeedRate, depthPerPass, finalDepth, bitsize);
using (StreamReader svgReader = new StreamReader($"{Constants.INPUTOUTPUT_FOLDER_RELATIVE_PATH}{svgFile.FullFileName}"))
{
using (StreamWriter gcodeWriter = new StreamWriter($"{Constants.INPUTOUTPUT_FOLDER_RELATIVE_PATH}{gcodeFile.FullFileName}"))
{
gcodeWriter.WriteLine(gcodeFile.FileHeader);
while (svgReader.ReadLine() != null)
{
string line = svgReader.ReadLine();
if (line.Contains("circle"))
{
var CxCyR = new List <double>();
CxCyR = SVGParser.ParseCircleSVGLine(line);
gcodeWriter.WriteLine(MillCircle(gcodeFile, CxCyR));
}
}
gcodeWriter.WriteLine(gcodeFile.FileFooter);
return($"The file {gcodeFile.FullFileName} has been created successfully");
}
}
}
catch (Exception e)
{
return($"couldn't open file {svgFile.FileName}. {e.Message}");
}
}
//returns the number of lines in the svgFile which contains the word circle
private int GetSvgFileCircleLineCount(SvgFile svgFile)
{
try
{
// 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}"))
{
string line;
var lineCount = 0;
// Read and display lines from the file until the end of
// the file is reached.
while ((line = svgReader.ReadLine()) != null)
{
if (line.Contains("circle"))
{
lineCount++;
}
}
return(lineCount);
}
}
catch (Exception e)
{
Console.WriteLine($"The file {filepath}{svgFile.FullFileName} could not be opened");
Console.Write(e.Message);
return(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();
}
public static List <SvgInstancedMesh> GetInstancedMeshes(SvgFile svg)
{
var meshesData = GetSvgMeshDatas(svg);
//var boundingBox = ResetOrigin(meshesData);
return(meshesData.Select(data => new SvgInstancedMesh(GetGeometryData(data, true))
{
Size = data.Size,
MinPosition = data.MinPosition
}).ToList());
}
public string ReorderSVGAccordingtoTSPsol(string tspSolFile, string FileToReorder)
{
var tspSolfile = new TspSolFile(tspSolFile);
var oldSvgFile = new SvgFile(FileToReorder);
try
{
using (StreamReader oldSvgReader = new StreamReader($"{Constants.INPUTOUTPUT_FOLDER_RELATIVE_PATH}{oldSvgFile.FullFileName}"))
{
var reorderedSvgFile = new SvgFile($"Reordered{oldSvgFile.FullFileName}");
using (StreamWriter reorderedSvgWriter = new StreamWriter($"{Constants.INPUTOUTPUT_FOLDER_RELATIVE_PATH}{reorderedSvgFile.FullFileName}"))
{
List <int> tspSolOrder = GetTspSolLineOrder(tspSolfile);
if (tspSolOrder.Count > 1)
{
int numberOfCities = tspSolOrder[0];
tspSolOrder.RemoveAt(0);
string line;
var lineorder = currentLineOrder(oldSvgFile);
var count = 0;
while ((line = oldSvgReader.ReadLine()) != null)
{
if (!line.Contains("circle"))
{
reorderedSvgWriter.WriteLine(line);
}
else
{
var correctOrder = tspSolOrder[count];
reorderedSvgWriter.WriteLine(lineorder[correctOrder]);
count++;
}
}
return($"{Constants.SUCCESS}-The file {reorderedSvgFile.FullFileName} has been created.");
}
return(Constants.FAILURE);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return($"{Constants.FAILURE}- {e.Message}");
}
}
public string CallStippler(string pngFileName, int stipples, double sizingFactor)
{
pngFileName = FileNameParser.RemoveDotFileExtensionInFileName(pngFileName);
var pngFile = new PngFile(pngFileName);
var svgFile = new SvgFile(pngFile.FileName);
try
{
var command = GetConsoleCommand(pngFile.FullFileName, svgFile.FullFileName, stipples, sizingFactor);
var startInfo = new ProcessStartInfo(Constants.VORONOI_RELATIVE_PATH, command);
var p = Process.Start(startInfo);
p.WaitForExit();
return($"The file {pngFile.FullFileName} has been successfully created!");
}
catch (Exception e)
{
return(e.Message);
}
}
private static Dictionary <int, string> currentLineOrder(SvgFile svgFile)
{
var lineOrder = new Dictionary <int, string>();
using (StreamReader SvgReader = new StreamReader($"{Constants.INPUTOUTPUT_FOLDER_RELATIVE_PATH}{svgFile.FullFileName}"))
{
var count = 0;
string line;
while ((line = SvgReader.ReadLine()) != null)
{
if (line.Contains("circle"))
{
lineOrder.Add(count, line);
count++;
}
}
}
return(lineOrder);
}
public static List <SvgMesh> GetMeshes(SvgFile svg)
{
var meshesData = GetSvgMeshDatas(svg);
return(meshesData.Select(data => new SvgMesh(GetGeometryData(data, false))).ToList());
}
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");
}
}
