private void EnsureNetFxPath() { var dotnetPath = GetNetFxPath(); var paths = new Paths(Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine)); var userPaths = new Paths(Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.User)); if (!paths.Contains(dotnetPath) && !userPaths.Contains(dotnetPath)) { userPaths.Add(dotnetPath); Environment.SetEnvironmentVariable("PATH", userPaths.ToString(), EnvironmentVariableTarget.User); Environment.SetEnvironmentVariable("PATH", userPaths.ToString(), EnvironmentVariableTarget.Process); } }
private void RefreshTimerOnElapsed(object sender, ElapsedEventArgs elapsedEventArgs) { var p = Process.GetCurrentProcess(); this.PrivateMemory = Readable(p.PrivateMemorySize64); this.WorkingMemory = Readable(p.WorkingSet64); this.VirtualMemory = Readable(p.VirtualMemorySize64); this.PagedMemory = Readable(p.PagedMemorySize64); this.ProcessPercent = pcounter.NextValue() + "%"; this.ProcessTime = p.TotalProcessorTime.ToString(); this.FPS = lastFrameRate.ToString(CultureInfo.InvariantCulture); LatestVersion = UpdateManager.Instance.LatestVersion.Version; var pathList = Library.Config.Instance.Paths .GetType() .GetProperties() .Where(x => x.PropertyType == typeof(string)) .Select(x => new Tuple <string, string>(x.Name, x.GetValue(Config.Instance.Paths, null) as string)) .ToArray(); Dispatcher.Invoke(new Action(() => { Paths.Clear(); foreach (var path in pathList) { Paths.Add(path); } })); //Process.GetCurrentProcess().UserProcessorTime }
public void StepTrace(int currStep, int prev, MapCordinate point, List <MappedCordinate> trace) { try { int value = this.Map[point.y][point.x]; currStep++; if (value < prev) { trace.Add(new MappedCordinate(currStep, prev, value, point.y, point.x)); this.StepTrace(currStep, value, new MapCordinate(point.y - 1, point.x), new List <MappedCordinate>(trace)); this.StepTrace(currStep, value, new MapCordinate(point.y, point.x + 1), new List <MappedCordinate>(trace)); this.StepTrace(currStep, value, new MapCordinate(point.y + 1, point.x), new List <MappedCordinate>(trace)); this.StepTrace(currStep, value, new MapCordinate(point.y, point.x - 1), new List <MappedCordinate>(trace)); } else if (trace.Count >= _lastLength) { _lastLength = trace.Count; if (!Paths.Any(x => x.SequenceEqual(trace))) { Paths.Add(trace.ToArray()); } } } catch // Out of Bounds { // Trace End } }
private void InitPaths(BinaryReader br) { int loop = 0; do { sbyte nodes = br.ReadSByte(); br.BaseStream.Position += 3; SegmentAddress address = br.ReadBigInt32(); if (nodes > 0 && loop < 20 && (address.Offset < 0x2F_FFFF) && //assuming an address range of 0200 0000 to 022F FFFF, quite larger than expected address.Segment == 0x02) { var seekback = br.BaseStream.Position; Path_MQJson path = new Path_MQJson(); br.BaseStream.Position = address.Offset; for (int i = 0; i < nodes; i++) { var point = new short[] { br.ReadBigInt16(), br.ReadBigInt16(), br.ReadBigInt16() }; path.Points.Add(point); } Paths.Add(path); br.BaseStream.Position = seekback; loop++; } else { break; } }while (true); }
public void AddPath(FileInfo file) { if (!Paths.Contains(file.FullName)) { Paths.Add(file.FullName); } }
public MarkGeometriesWrapper(IMarkGeometry[] geometries) { foreach (var geometry in geometries) { if (geometry is MarkGeometryPoint point) { Points.Add(point); } else if (geometry is MarkGeometryLine line) { Lines.Add(line); } else if (geometry is MarkGeometryPath path) { Paths.Add(path); } else if (geometry is MarkGeometryArc arc) { Arcs.Add(arc); } else if (geometry is MarkGeometryCircle circle) { Circles.Add(circle); } } Update(); }
public virtual void MoveFile(string src, string destination) { src = NormalizePath(src); destination = NormalizePath(destination); Paths.Add(destination, Paths[src]); Paths.Remove(src); }
private static void SortStates() { for (int i = Ciphers.Count - 1; i >= 0; i--) { if (DKAEndNodes.Contains(Ciphers[i])) { Ciphers.Remove(Ciphers[i]); Paths.Remove(Paths[i]); } } string tempCipher; List <string> tempPath; for (int i = 0; i < Ciphers.Count; i++) { for (int j = i + 1; j < Ciphers.Count; j++) { if (Convert.ToInt32(Ciphers[i].Split(',')[0]) > Convert.ToInt32(Ciphers[j].Split(',')[0])) { tempCipher = Ciphers[i]; Ciphers[i] = Ciphers[j]; Ciphers[j] = tempCipher; tempPath = Paths[i]; Paths[i] = Paths[j]; Paths[j] = tempPath; } } } for (int i = 0; i < DKAEndNodes.Count; i++) { for (int j = i + 1; j < DKAEndNodes.Count; j++) { if (Convert.ToInt32(DKAEndNodes[i]) > Convert.ToInt32(DKAEndNodes[j])) { string tempNode = DKAEndNodes[i]; DKAEndNodes[i] = DKAEndNodes[j]; DKAEndNodes[j] = tempNode; } } } DKAEndNodes.Add(DKAEndNodes[0]); DKAEndNodes.RemoveAt(0); Ciphers.AddRange(DKAEndNodes); for (int i = 0; i < DKAEndNodes.Count; i++) { Paths.Add(new List <string>()); for (int k = 0; k < Labels.Length; k++) { Paths[Paths.Count - 1].Add("$"); } } }
//行进行先后合并 public static Paths PathsMergeByOrder(Paths pgs, float m_dis_threshold) { Paths outPathsList = new Paths(); //输出合并结果 Paths tempMergePath = new Paths(); //存储每次hebing输出结果 Path eachPath = new Path(); //存储每一条独立路径 bool unistate = false; //合并状态 for (int i = 0; i < pgs.Count; i++) { if (pgs[i].Count == 0) //融合是碰到pg(i)为空 { if (eachPath.Count > 0) //如果eachPath内有数据,此条合并结束,重置eachPath { outPathsList.Add(eachPath); eachPath = new Path(); } } else if (eachPath.Count == 0) //eachPath为空,需要为eachPath赋值一条数据,并退出此次循环 { eachPath = pgs[i]; continue; } else //均非空,则考虑合并 { tempMergePath = PathMergeAlong(eachPath, pgs[i], m_dis_threshold, out unistate); if (unistate) { //eachPath.AddRange(tempMergePath[0]); //如果可以合并肯定就一条路径 eachPath = tempMergePath[0]; } else //如果不能合并,切断融合,开始下一条融合 { outPathsList.Add(eachPath); eachPath = new Path(); eachPath.AddRange(pgs[i]); //插入下一条进行初始化 } } } if (eachPath.Count > 0) //跳出循环后如果eachPath非空则插入 { outPathsList.Add(eachPath); } return(outPathsList); }
/// <summary> /// Adds the specified relative path. /// </summary> /// <param name="relativePath">The relative path.</param> /// <param name="file">The file.</param> protected virtual void Add(string relativePath, FileInfo file) { ApacheRuleSet rule = new ApacheRuleSet(relativePath, file); Paths.Add(relativePath, rule); // start monitoring the rule set AddRuleSetMonitoring(relativePath, file.FullName); }
static Program() { HomePath = (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) ? Environment.GetEnvironmentVariable("HOME") : Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%"); Paths.Add(Path.Combine(HomePath, "Google Drive", "Schule", "CSharp")); }
public void Init() { if (Load()) { return; } Paths.Add("Assets"); }
public void ProcessArc(ShxGlyphCommandFractionalArc a) { var arc = FromArcCommand(a, ref _lastPoint); if (_isDrawing) { Paths.Add(arc); } }
void InitializePaths(List <Landmark> landmarks, int nmbrOfLandmarks) { for (int i = 0; i < this.NmbrOfPaths; i++) { Path tmp = new Path(nmbrOfLandmarks, landmarks); tmp.InitializePath(); Paths.Add(tmp); } }
/// <inheritdoc /> public Task AddPathAsync(string path) { if (!Paths.Contains(path)) { Paths.Add(path); } return(Task.CompletedTask); }
private void AddBtn_Click(object sender, RoutedEventArgs e) { string selectedPath = FilesManager.OpenFolderDialog(); PathElement newPath = new PathElement { FullPath = selectedPath }; Paths.Add(newPath); }
public RelativeValueStoragePath(string path) { if (path is null) { throw new ArgumentNullException(nameof(path)); } Paths.Add(path); }
public void AppendPath(params string[] paths) { if (paths == null || paths.Length == 0) { return; } var domainAssemblies = Domain.GetAssemblies(); var basePath = Domain.BaseDirectory; var localAssembliesInfo = new ConcurrentBag <AssemblyInfo>(); foreach (var path in paths) { lock (_lock) { if (Paths.Contains(path, StringComparer.OrdinalIgnoreCase)) { continue; } Paths.Add(path); } var localPath = Path.Combine(basePath, path?.Trim()); var localExeFiles = Directory.EnumerateFiles(localPath, "*.exe", SearchOption.AllDirectories); var localDllFiles = Directory.EnumerateFiles(localPath, "*.dll", SearchOption.AllDirectories); var localFiles = localExeFiles.Concat(localDllFiles); Parallel.ForEach(localFiles, file => { var fileName = Path.GetFileName(file); lock (_lock) if (!_ignoreFileNames.Add(fileName)) { return; } try { var name = AssemblyName.GetAssemblyName(file); if (IsExcludedAssembly(name.Name)) { return; } if (domainAssemblies.All((l, fullName) => l.FullName != fullName, name.FullName) && !Assemblies.Contains(name.FullName)) { localAssembliesInfo.Add(new AssemblyInfo(file, name)); } } catch (BadImageFormatException) { // } catch (Exception ex) { Core.Log.Write(ex); } }); } Assemblies.AddRange(localAssembliesInfo); Parallel.ForEach(Assemblies, asm => asm.Preload()); }
public void RegisterPath(IPath path) { if (!PathIsAlreadyRegistered(path)) { LOGGER.Info($"Adding path '{path.Fullname}'"); Paths.Add(path); } }
public void AddPath(string path) { if (Paths.Contains(path)) { return; } Paths.Add(path); }
internal static Paths Copy(Paths src) { var dst = new Paths(src.Capacity); foreach (var path in src) { dst.Add(new Path(path)); } return(dst); }
// An infinite region would cover the entire device region which is the same as // not having a clipping region. Note that this is not the same as having an // empty region, which when clipping to it has the effect of excluding the entire // device region. public Region() { // We set the default region to a very large regionObject = infinite; var path = RectangleToPath(infinite); solution.Add(path); regionList.Add(new RegionEntry(RegionType.Infinity, infinite, path)); regionPath = new CGPath(); regionPath.MoveToPoint(infinite.Left, infinite.Top); regionPath.AddLineToPoint(infinite.Right, infinite.Top); regionPath.AddLineToPoint(infinite.Right, infinite.Bottom); regionPath.AddLineToPoint(infinite.Left, infinite.Bottom); regionBounds = infinite; }
/// <summary> /// Adds the value to the <see cref="Paths"/> collection property and /// returns this <see cref="ForgetCommand"/> instance. /// </summary> /// <param name="value"> /// The value to add to the <see cref="Paths"/> collection property. /// </param> /// <returns> /// This <see cref="ForgetCommand"/> instance. /// </returns> /// <remarks> /// This method is part of the fluent interface. /// </remarks> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="value"/> is <c>null</c> or empty.</para> /// </exception> public CommitCommand WithPath(string value) { if (StringEx.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException("value"); } Paths.Add(value.Trim()); return(this); }
public B002MMTPCFileSystem() { Paths.Add("settingsPath", "C:\\Users\\Equipe\\Documents\\EDMSuiteData\\Settings"); Paths.Add("scanMasterDataPath", "C:\\Users\\Equipe\\Documents\\EDMSuiteData\\Data"); Paths.Add("fakeData", "C:\\Users\\Equipe\\Documents\\EDMSuiteData\\Fakedata"); DataSearchPaths.Add(Paths["scanMasterDataPath"]); SortDataByDate = true; }
public PHRHENDRIC02FileSystem() { Paths.Add("settingsPath", "d:\\scanmaster\\settings\\"); Paths.Add("scanMasterDataPath", "d:\\data\\"); Paths.Add("fakeData", "d:\\scanmaster\\examples\\"); DataSearchPaths.Add(Paths["scanMasterDataPath"]); SortDataByDate = false; }
//------------------------------------------------------------------------------ private void AddPolygon(Point pt1, Point pt2, Point pt3) { Path p = new Path(); p.Capacity = 3; p.Add(pt3); p.Add(pt2); p.Add(pt1); triangles.Add(p); }
public static Paths ClipperPaths(this Polygon this_, float scale) { Paths paths = new Paths(); this_.EnumeratePolygons((Polygon eachPolygon) => { paths.Add(eachPolygon.ClipperPath(scale)); }); return(paths); }
private void PictureBox_MouseDown(object sender, MouseEventArgs e) { if (e.Buttons != MouseButtons.Primary || control.Image == null) { return; } isDrawing = true; Paths.Add(new Path(Pen.Clone(), control.ZoomFactor)); }
public void AddingNonNormalizedPathWillNormalizeAndAddItToList() { var pathStr = @"c:\whatever;d:\omg"; var path = new Paths(pathStr); path.Add("E:/Wtf").Should().Be(@"e:\wtf\"); path.Should().Have.SameSequenceAs( @"c:\whatever", @"d:\omg", @"e:\wtf\"); }
public RagnarokFileSystem() { //Paths.Add("mathPath", "c:\\Program Files\\Wolfram Research\\Mathematica\\7.0\\mathkernel.exe"); Paths.Add("settingsPath", "d:\\Data\\Settings\\"); Paths.Add("scanMasterDataPath", "d:\\Data\\CH"); Paths.Add("fakeData", "d:\\Data\\Examples\\"); DataSearchPaths.Add(Paths["scanMasterDataPath"]); SortDataByDate = false; }
/// <summary> /// 将list<>list xyz 转化为 intpoint list<>list /// </summary> public static Paths Paths_xyzToPaths(Paths_xyz _Paths_xyz) { Paths _Paths = new Paths(); foreach (Path_xyz _Path_xyz in _Paths_xyz) { Path _Path = Path_xyzToPath(_Path_xyz); _Paths.Add(_Path); } return(_Paths); }
public CarmeliteFileSystem() { Paths.Add("settingsPath", "c:\\experiment control\\"); Paths.Add("scanMasterDataPath", "c:\\data\\"); Paths.Add("mathPath", "c:/program files/wolfram research/mathematica/5.1/mathkernel.exe"); Paths.Add("fakeData", "c:\\data\\examples\\"); DataSearchPaths.Add(Paths["scanMasterDataPath"]); SortDataByDate = false; }
//------------------------------------------------------------------------------ internal static Paths Minkowki(Path poly, Path path, bool IsSum, bool IsClosed) { int delta = (IsClosed ? 1 : 0); int polyCnt = poly.Count; int pathCnt = path.Count; Paths result = new Paths(pathCnt); if (IsSum) for (int i = 0; i < pathCnt; i++) { Path p = new Path(polyCnt); foreach (IntPoint ip in poly) p.Add(new IntPoint(path[i].X + ip.X, path[i].Y + ip.Y)); result.Add(p); } else for (int i = 0; i < pathCnt; i++) { Path p = new Path(polyCnt); foreach (IntPoint ip in poly) p.Add(new IntPoint(path[i].X - ip.X, path[i].Y - ip.Y)); result.Add(p); } Paths quads = new Paths((pathCnt + delta) * (polyCnt + 1)); for (int i = 0; i <= pathCnt - 2 + delta; i++) for (int j = 0; j <= polyCnt - 1; j++) { Path quad = new Path(4); quad.Add(result[i % pathCnt][j % polyCnt]); quad.Add(result[(i + 1) % pathCnt][j % polyCnt]); quad.Add(result[(i + 1) % pathCnt][(j + 1) % polyCnt]); quad.Add(result[i % pathCnt][(j + 1) % polyCnt]); if (!Orientation(quad)) quad.Reverse(); quads.Add(quad); } Clipper c = new Clipper(); c.AddPaths(quads, PolyType.ptSubject, true); c.Execute(ClipType.ctUnion, result, PolyFillType.pftNonZero, PolyFillType.pftNonZero); return result; }
//------------------------------------------------------------------------------ private void BuildResult(Paths polyg) { polyg.Clear(); polyg.Capacity = m_PolyOuts.Count; for (int i = 0; i < m_PolyOuts.Count; i++) { OutRec outRec = m_PolyOuts[i]; if (outRec.Pts == null) continue; OutPt p = outRec.Pts; int cnt = PointCount(p); if (cnt < 2) continue; Path pg = new Path(cnt); for (int j = 0; j < cnt; j++) { pg.Add(p.Pt); p = p.Prev; } polyg.Add(pg); } }
void calculateRegionPath(ClipType clipType) { Clipper c = new Clipper(); var subjects = solution; //subjects.Add (solution); var clips = new Paths (); foreach (var path in regionList [regionList.Count - 1].regionPath) clips.Add (path); c.AddPolygons(subjects, PolyType.ptSubject); c.AddPolygons(clips, PolyType.ptClip); solution.Clear(); bool succeeded = c.Execute(clipType, solution, SUBJ_FILL_TYPE, CLIP_FILL_TYPE); if (succeeded) { PathsToInternalPath (solution); // Not sure what this is returning // var bounds = c.GetBounds (); // regionBounds.X = bounds.left / scale; // regionBounds.Y = bounds.top / scale; // regionBounds.Width = (bounds.right - bounds.left) / scale; // regionBounds.Height = (bounds.bottom - bounds.top) / scale; if (regionPath.IsEmpty) regionBounds = RectangleF.Empty; else regionBounds = regionPath.BoundingBox; } }
//////////////////////////////////////////////// static bool LoadFromFile(string filename, Paths ppg, int dec_places, int xOffset = 0, int yOffset = 0) { double scaling; scaling = Math.Pow(10, dec_places); ppg.Clear(); if (!File.Exists(filename)) return false; StreamReader sr = new StreamReader(filename); if (sr == null) return false; string line; if ((line = sr.ReadLine()) == null) return false; int polyCnt, vertCnt; if (!Int32.TryParse(line, out polyCnt) || polyCnt < 0) return false; ppg.Capacity = polyCnt; for (int i = 0; i < polyCnt; i++) { if ((line = sr.ReadLine()) == null) return false; if (!Int32.TryParse(line, out vertCnt) || vertCnt < 0) return false; Path pg = new Path(vertCnt); ppg.Add(pg); if (scaling > 0.999 & scaling < 1.001) for (int j = 0; j < vertCnt; j++) { Int64 x, y; if ((line = sr.ReadLine()) == null) return false; char[] delimiters = new char[] { ',', ' ' }; string[] vals = line.Split(delimiters); if (vals.Length < 2) return false; if (!Int64.TryParse(vals[0], out x)) return false; if (!Int64.TryParse(vals[1], out y)) if (vals.Length < 2 || !Int64.TryParse(vals[2], out y)) return false; x = x + xOffset; y = y + yOffset; pg.Add(new IntPoint(x, y)); } else for (int j = 0; j < vertCnt; j++) { double x, y; if ((line = sr.ReadLine()) == null) return false; char[] delimiters = new char[] { ',', ' ' }; string[] vals = line.Split(delimiters); if (vals.Length < 2) return false; if (!double.TryParse(vals[0], out x)) return false; if (!double.TryParse(vals[1], out y)) if (vals.Length < 2 || !double.TryParse(vals[2], out y)) return false; x = x * scaling + xOffset; y = y * scaling + yOffset; pg.Add(new IntPoint((Int64)Math.Round(x), (Int64)Math.Round(y))); } } return true; }
static void WidenPath(GraphicsPath path, Pen pen, out List<PointF> widePoints, out List<byte> wideTypes) { widePoints = new List<PointF> (); wideTypes = new List<byte> (); var pathData = path.PathData; var iterator = new GraphicsPathIterator(path); var subPaths = iterator.SubpathCount; int startIndex = 0; int endIndex = 0; bool isClosed = false; var flattenedSubpath = new Paths(); var offsetPaths = new Paths(); var width = (pen.Width / 2) * scale; var miterLimit = pen.MiterLimit * scale; var joinType = JoinType.jtMiter; switch (pen.LineJoin) { case LineJoin.Round: joinType = JoinType.jtRound; break; case LineJoin.Bevel: joinType = JoinType.jtSquare; break; } for (int sp = 0; sp < subPaths; sp++) { var numOfPoints = iterator.NextSubpath(out startIndex, out endIndex, out isClosed); //Console.WriteLine("subPath {0} - from {1} to {2} closed {3}", sp+1, startIndex, endIndex, isClosed); var subPoints = pathData.Points.Skip(startIndex).Take(numOfPoints).ToArray(); //for (int pp = startIndex; pp <= endIndex; pp++) //{ // Console.WriteLine(" {0} - {1}", pathData.Points[pp], (PathPointType)pathData.Types[pp]); //} // Load our Figure Subpath flattenedSubpath.Clear(); flattenedSubpath.Add(Region.PointFArrayToIntArray(subPoints, scale)); // Calculate the outter offset region var outerOffsets = Clipper.OffsetPaths(flattenedSubpath, width, joinType, EndType.etClosed, miterLimit); // Calculate the inner offset region var innerOffsets = Clipper.OffsetPaths(flattenedSubpath, -width, joinType, EndType.etClosed, miterLimit); // Add the offsets to our paths offsetPaths.AddRange(outerOffsets); // revers our innerOffsets so that they create a hole when filling Clipper.ReversePaths (innerOffsets); offsetPaths.AddRange(innerOffsets); } foreach (var offPath in offsetPaths) { if (offPath.Count < 1) continue; var pointArray = Region.PathToPointFArray(offPath, scale); var type = (byte)PathPointType.Start; widePoints.Add (pointArray [0]); wideTypes.Add (type); type = (byte)PathPointType.Line; for (int i = 1; i < offPath.Count; i++) { widePoints.Add (pointArray [i]); wideTypes.Add (type); } if (widePoints.Count > 0) wideTypes [wideTypes.Count-1] = (byte) (wideTypes [wideTypes.Count-1] | (byte) PathPointType.CloseSubpath); } }
//------------------------------------------------------------------------------ public static Paths OffsetPaths(Paths polys, double delta, JoinType jointype, EndType endtype, double MiterLimit) { Paths out_polys = new Paths(polys.Count); IntPoint botPt = new IntPoint(); IntPoint pt; int botIdx = -1; for (int i = 0; i < polys.Count; ++i) { out_polys.Add(new Path()); if (StripDupsAndGetBotPt(polys[i], out_polys[i], endtype == EndType.etClosed, out pt)) if (botIdx < 0 || pt.Y > botPt.Y || (pt.Y == botPt.Y && pt.X < botPt.X)) { botPt = pt; botIdx = i; } } if (endtype == EndType.etClosed && botIdx >= 0 && !Orientation(out_polys[botIdx])) ReversePaths(out_polys); Paths result; new PolyOffsetBuilder(out_polys, out result, delta, jointype, endtype, MiterLimit); return result; }
//------------------------------------------------------------------------------ internal static void AddPolyNodeToPaths(PolyNode polynode, NodeType nt, Paths paths) { bool match = true; switch (nt) { case NodeType.ntOpen: return; case NodeType.ntClosed: match = !polynode.IsOpen; break; default: break; } if (polynode.Contour.Count > 0 && match) paths.Add(polynode.Contour); foreach (PolyNode pn in polynode.Childs) AddPolyNodeToPaths(pn, nt, paths); }
//------------------------------------------------------------------------------ public static Paths OpenPathsFromPolyTree(PolyTree polytree) { Paths result = new Paths(); result.Capacity = polytree.ChildCount; for (int i = 0; i < polytree.ChildCount; i++) if (polytree.Childs[i].IsOpen) result.Add(polytree.Childs[i].Contour); return result; }
public void CanGetPathStringFromPathList() { var path = new Paths(""); path.Add(@"c:\a"); path.Add(@"d:\b"); path.Add(@"e:/C"); path.ToString().Should().Be(@"c:\a\;d:\b\;e:\c\"); }
//------------------------------------------------------------------------------ public static Paths CleanPolygons(Paths polys, double distance = 1.415) { Paths result = new Paths(polys.Count); for (int i = 0; i < polys.Count; i++) result.Add(CleanPolygon(polys[i], distance)); return result; }