public void GetMinMaxT(IFillerVertex fillerVertex, MarkupLine line, out float resultT, out float resultMinT, out float resultMaxT) { fillerVertex.GetT(line, out float t); var minT = -1f; var maxT = 2f; foreach (var linePart in LineParts) { linePart.GetFromT(out float fromT); linePart.GetToT(out float toT); if (linePart.Line == line) { Set(fromT, false); Set(toT, false); } else if (Markup.GetIntersect(new MarkupLinePair(line, linePart.Line)) is MarkupLinesIntersect intersect && intersect.IsIntersect) { var linePartT = intersect[linePart.Line]; if ((fromT <= linePartT && linePartT <= toT) || (toT <= linePartT && linePartT <= fromT)) { Set(intersect[line], true); } }
private void RemoveLine(MarkupLine line) { foreach (var intersect in GetExistIntersects(line).ToArray()) { if (intersect.Pair.GetOther(line) is MarkupRegularLine regularLine) { regularLine.RemoveRules(line); } LineIntersects.Remove(intersect.Pair); } foreach (var filler in GetLineFillers(line).ToArray()) { FillersList.Remove(filler); } if (CrosswalksDictionary.ContainsKey(line)) { CrosswalksDictionary.Remove(line); } else { foreach (var crosswalk in GetLinesIsBorder(line)) { crosswalk.RemoveBorder(line); } } LinesDictionary.Remove(line.PointPair.Hash); }
public static bool FromXml(XElement config, Markup makrup, ObjectsMap map, out MarkupLine line, out bool invert) { var lineId = config.GetAttrValue <ulong>(nameof(Id)); if (!MarkupPointPair.FromHash(lineId, makrup, map, out MarkupPointPair pointPair, out invert)) { line = null; return(false); } if (!makrup.TryGetLine(pointPair, out line)) { var type = (LineType)config.GetAttrValue("T", (int)pointPair.DefaultType); switch (type) { case LineType.Regular: line = new MarkupRegularLine(makrup, pointPair); break; case LineType.Stop: line = new MarkupStopLine(makrup, pointPair); break; case LineType.Crosswalk: line = new MarkupCrosswalkLine(makrup, pointPair); break; default: return(false); } } return(true); }
public void FromXml(string version, XElement config, Dictionary <ObjectId, ObjectId> map = null) { if (VersionComparer.Instance.Compare(version, "1.2") < 0) { map = VersionMigration.Befor1_2(this, map); } foreach (var pointConfig in config.Elements(MarkupPoint.XmlName)) { MarkupPoint.FromXml(pointConfig, this, map); } var toInit = new Dictionary <MarkupLine, XElement>(); foreach (var lineConfig in config.Elements(MarkupLine.XmlName)) { if (MarkupLine.FromXml(lineConfig, this, map, out MarkupLine line)) { LinesDictionary[line.Id] = line; toInit[line] = lineConfig; } } foreach (var pair in toInit) { pair.Key.FromXml(pair.Value, map); } foreach (var fillerConfig in config.Elements(MarkupFiller.XmlName)) { if (MarkupFiller.FromXml(fillerConfig, this, map, out MarkupFiller filler)) { FillersList.Add(filler); } } }
public static bool FromXml(XElement config, MarkupLine mainLine, ObjectsMap map, out ILinePartEdge supportPoint) { var type = (SupportType)config.GetAttrValue <int>("T"); switch (type) { case SupportType.EnterPoint when EnterPointEdge.FromXml(config, mainLine.Markup, map, out EnterPointEdge enterPoint): supportPoint = enterPoint; return(true); case SupportType.LinesIntersect when LinesIntersectEdge.FromXml(config, mainLine, map, out LinesIntersectEdge linePoint): supportPoint = linePoint; return(true); case SupportType.CrosswalkBorder when CrosswalkBorderEdge.FromXml(config, mainLine, map, out CrosswalkBorderEdge borderPoint): supportPoint = borderPoint; return(true); default: supportPoint = null; return(false); } }
public override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) { var solidOffset = CenterSolid ? 0 : Invert ? Offset : -Offset; var dashedOffset = (Invert ? -Offset : Offset) * (CenterSolid ? 2 : 1); var borders = line.Borders; var dashes = new List <MarkupStylePart>(); dashes.AddRange(StyleHelper.CalculateSolid(trajectory, lod, CalculateSolidDash)); if (CheckDashedLod(lod, Width, DashLength)) { dashes.AddRange(StyleHelper.CalculateDashed(trajectory, DashLength, SpaceLength, CalculateDashedDash)); } return(new MarkupStyleParts(dashes)); IEnumerable <MarkupStylePart> CalculateSolidDash(ITrajectory lineTrajectory) { if (StyleHelper.CalculateSolidPart(borders, lineTrajectory, solidOffset, Width, Color, out MarkupStylePart dash)) { yield return(dash); } } IEnumerable <MarkupStylePart> CalculateDashedDash(ITrajectory lineTrajectory, float startT, float endT) { if (StyleHelper.CalculateDashedParts(borders, lineTrajectory, startT, endT, DashLength, dashedOffset, Width, Color, out MarkupStylePart dash)) { yield return(dash); } } }
public void Update(MarkupLine line, bool recalculate = false) { line.Update(true); foreach (var intersect in GetExistIntersects(line).ToArray()) { LineIntersects.Remove(intersect.Pair); intersect.Pair.GetOther(line).Update(); } foreach (var filler in GetLineFillers(line)) { filler.Update(); } foreach (var crosswalk in GetLinesIsBorder(line)) { crosswalk.Update(); } if (recalculate) { RecalculateDashes(); } }
public override IEnumerable <MarkupStyleDash> Calculate(MarkupLine line, ILineTrajectory trajectory) { var borders = line.Borders; return(StyleHelper.CalculateSolid(trajectory, GetDashes)); IEnumerable <MarkupStyleDash> GetDashes(ILineTrajectory trajectory) => CalculateDashes(trajectory, borders); }
public override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) { var borders = line.Borders; return(new MarkupStyleParts(StyleHelper.CalculateSolid(trajectory, lod, GetDashes))); IEnumerable <MarkupStylePart> GetDashes(ITrajectory trajectory) => CalculateDashes(trajectory, borders); }
public IEnumerable <MarkupLinesIntersect> GetIntersects(MarkupLine line) { foreach (var otherLine in Lines) { if (otherLine != line) { yield return(GetIntersect(new MarkupLinePair(line, otherLine))); } } }
protected static IEnumerable <ILinePartEdge> GetEdges(XElement config, MarkupLine line, ObjectsMap map) { foreach (var supportConfig in config.Elements(LinePartEdge.XmlName)) { if (LinePartEdge.FromXml(supportConfig, line, map, out ILinePartEdge edge)) { yield return(edge); } } }
public void RemoveRules(MarkupLine intersectLine) { RawRules.RemoveAll(r => Match(r.From) || Match(r.To)); bool Match(ISupportPoint supportPoint) => supportPoint is IntersectSupportPoint lineRuleEdge && lineRuleEdge.LinePair.ContainLine(intersectLine); if (!RawRules.Any()) { AddRule(false); } }
public MarkupLine GetOther(MarkupLine line) { if (!ContainLine(line)) { return(null); } else { return(line == First ? Second : First); } }
public override bool GetT(MarkupLine line, out float t) { if (line is MarkupCrosswalkLine crosswalkLine) { t = crosswalkLine.GetT(Border); return(true); } else { t = -1; return(false); } }
public override bool GetT(MarkupLine line, out float t) { if (line.ContainsPoint(Point)) { t = line.Start == Point ? 0 : 1; return(true); } else { t = -1; return(false); } }
public static bool FromXml(XElement config, MarkupLine line, ObjectsMap map, out CrosswalkBorderEdge borderPoint) { if (line is MarkupCrosswalkLine crosswalkLine) { var border = (config.GetAttrValue("B", (int)BorderPosition.Right) == (int)BorderPosition.Left) ^ map.IsMirror ? BorderPosition.Left : BorderPosition.Right; borderPoint = new CrosswalkBorderEdge(crosswalkLine, border); return(true); } else { borderPoint = null; return(false); } }
public void RemoveRules(MarkupLine intersectLine) { if (!RawRules.Any()) { return; } RawRules.RemoveAll(r => Match(intersectLine, r.From) || Match(intersectLine, r.To)); if (!RawRules.Any()) { AddRule(false, false); } }
public override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) { if (!CheckDashedLod(lod, Width, DashLength)) { return(new MarkupStyleParts()); } var borders = line.Borders; return(new MarkupStyleParts(StyleHelper.CalculateDashed(trajectory, DashLength, SpaceLength, GetDashes))); IEnumerable <MarkupStylePart> GetDashes(ITrajectory trajectory, float startT, float endT) => CalculateDashes(trajectory, startT, endT, borders); }
public static bool FromXml(XElement config, MarkupLine line, Dictionary <ObjectId, ObjectId> map, out CrosswalkBorderEdge borderPoint) { if (line is MarkupCrosswalkLine crosswalkLine) { var border = (BorderPosition)config.GetAttrValue("B", (int)BorderPosition.Right); borderPoint = new CrosswalkBorderEdge(crosswalkLine, border); return(true); } else { borderPoint = null; return(false); } }
private void RemoveLine(MarkupLine line) { foreach (var intersect in GetExistIntersects(line).ToArray()) { intersect.Pair.GetOther(line).RemoveRules(line); LineIntersects.Remove(intersect.Pair); } foreach (var filler in GetLineFillers(line).ToArray()) { FillersList.Remove(filler); } LinesDictionary.Remove(line.PointPair.Hash); }
public MarkupLine ToggleConnection(MarkupPointPair pointPair, Style.StyleType style) { if (LinesDictionary.TryGetValue(pointPair.Hash, out MarkupLine line)) { RemoveConnect(line); return(null); } else { line = MarkupLine.FromStyle(this, pointPair, style); LinesDictionary[pointPair.Hash] = line; NeedRecalculateBatches = true; return(line); } }
public static bool FromXml(XElement config, Markup makrup, Dictionary <ObjectId, ObjectId> map, out MarkupLine line) { var lineId = config.GetAttrValue <ulong>(nameof(Id)); MarkupPointPair.FromHash(lineId, makrup, map, out MarkupPointPair pointPair); if (!makrup.TryGetLine(pointPair.Hash, out line)) { line = new MarkupLine(makrup, pointPair); return(true); } else { return(false); } }
public static bool FromXml(XElement config, MarkupLine mainLine, ObjectsMap map, out LinesIntersectEdge linePoint) { var lineId = config.GetAttrValue <ulong>(MarkupLine.XmlName); if (mainLine.Markup.TryGetLine(lineId, map, out MarkupLine line)) { linePoint = new LinesIntersectEdge(mainLine, line); return(true); } else { linePoint = null; return(false); } }
public override bool GetT(MarkupLine line, out float t) { var intersect = line.Markup.GetIntersect(LinePair); if (intersect.IsIntersect) { t = intersect[line]; return(true); } else { t = -1; return(false); } }
public bool RemoveRules(MarkupLine intersectLine) { if (!RawRules.Any()) { return(false); } var removed = RawRules.RemoveAll(r => Match(intersectLine, r.From) || Match(intersectLine, r.To)); if (!RawRules.Any()) { AddRule(false, false); } return(removed != 0); }
public static bool FromXml(XElement config, MarkupLine mainLine, Dictionary <ObjectId, ObjectId> map, out LinesIntersectEdge linePoint) { var lineId = config.GetAttrValue <ulong>(MarkupLine.XmlName); MarkupPointPair.FromHash(lineId, mainLine.Markup, map, out MarkupPointPair pair); if (mainLine.Markup.TryGetLine(pair.Hash, out MarkupLine line)) { linePoint = new LinesIntersectEdge(mainLine, line); return(true); } else { linePoint = null; return(false); } }
public void FromXml(Version version, XElement config, Dictionary <ObjectId, ObjectId> map = null) { if (version < new Version("1.2")) { map = VersionMigration.Befor1_2(this, map); } foreach (var pointConfig in config.Elements(MarkupPoint.XmlName)) { MarkupPoint.FromXml(pointConfig, this, map); } var toInit = new Dictionary <MarkupLine, XElement>(); foreach (var lineConfig in config.Elements(MarkupLine.XmlName)) { if (MarkupLine.FromXml(lineConfig, this, map, out MarkupLine line)) { LinesDictionary[line.Id] = line; toInit[line] = lineConfig; } } foreach (var pair in toInit) { pair.Key.FromXml(pair.Value, map); } foreach (var fillerConfig in config.Elements(MarkupFiller.XmlName)) { if (MarkupFiller.FromXml(fillerConfig, this, map, out MarkupFiller filler)) { FillersList.Add(filler); } } foreach (var crosswalkConfig in config.Elements(MarkupCrosswalk.XmlName)) { if (MarkupCrosswalk.FromXml(crosswalkConfig, this, map, out MarkupCrosswalk crosswalk)) { CrosswalksDictionary[crosswalk.Line] = crosswalk; } } Update(); }
public override bool GetT(MarkupLine line, out float t) { if (line.IsStart(Point)) { t = 0; return(true); } else if (line.IsEnd(Point)) { t = 1; return(true); } else { t = -1; return(false); } }
public override bool GetT(MarkupLine line, out float t) { if (line is MarkupEnterLine enterLine && line.Start == line.End) { if (enterLine.StartAlignment == Alignment) { t = 0f; return(true); } else if (enterLine.EndAlignment == Alignment) { t = 1f; return(true); } else { t = -1f; return(false); } }
public MarkupLine ToggleConnection(MarkupPointPair pointPair, Style.StyleType style) { if (LinesDictionary.TryGetValue(pointPair.Hash, out MarkupLine line)) { RemoveConnect(line); return(null); } else { if (pointPair.IsNormal && !EarlyAccess.CheckFunctionAccess(Localize.EarlyAccess_Function_PerpendicularLines)) { return(null); } line = MarkupLine.FromStyle(this, pointPair, style); LinesDictionary[pointPair.Hash] = line; NeedRecalculateBatches = true; return(line); } }