public static void GetParts(float width, float offset, MarkupLOD lod, out int count, out float partWidth) { var max = LodMax[lod]; if (width < max || offset != 0f) { count = 1; partWidth = width; } else { var intWidth = (int)(width * 100); var delta = (int)(max * 100); var num = 0; for (var i = (int)(max * 50); i < (int)(max * 100); i += 1) { var iDelta = intWidth - (intWidth / i) * i; if (iDelta < delta) { delta = iDelta; num = i; } } count = intWidth / num; partWidth = num / 100f; } }
protected override IEnumerable <IStyleData> GetStyleData(MarkupLOD lod) { if (Visible) { yield return(Rule.Style.Calculate(this, LineTrajectory, lod)); } }
private List <List <ITrajectory> > GetParts(List <ITrajectory> trajectories, MarkupLOD lod) { var parts = trajectories.Select(t => StyleHelper.CalculateSolid(t, lod, (tr) => tr, MinAngle, MinLength, MaxLength)).ToList(); for (var i = 0; i < parts.Count; i += 1) { var xm = (i - 1 + parts.Count) % parts.Count; var x = i; var y = (i + 1) % parts.Count; var yp = (i + 2) % parts.Count; if (FindIntersects(parts[x], parts[y], true, 1)) { continue; } if (parts.Count > 3 && parts[y].Count == 1 && FindIntersects(parts[x], parts[yp], true, 0)) { parts.RemoveAt(y); continue; } if (FindIntersects(parts[y], parts[x], false, 1)) { continue; } if (parts.Count > 3 && parts[x].Count == 1 && FindIntersects(parts[y], parts[xm], false, 0)) { parts.RemoveAt(x); i -= 1; continue; } } return(parts); }
private static List <Result> CalculateSolid <Result>(ITrajectory trajectory, MarkupLOD lod, float?minAngle, float?minLength, float?maxLength, Action <List <Result>, ITrajectory> addToResult) { var lodScale = LodScale[lod]; var result = new List <Result>(); CalculateSolid(0, trajectory, trajectory.DeltaAngle, (minAngle ?? MinAngleDelta) * lodScale, (minLength ?? MinLength) * lodScale, (maxLength ?? MaxLength) * lodScale, t => addToResult(result, t)); return(result); }
protected Vector3[] GetContourPoints(List <FillerContour.Part> contour, MarkupLOD lod, out int[] groups) { var trajectories = contour.Select(i => i.Trajectory).ToList(); if (trajectories.GetDirection() == TrajectoryHelper.Direction.CounterClockWise) { trajectories = trajectories.Select(t => t.Invert()).Reverse().ToList(); } var parts = GetParts(trajectories, lod); var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray(); groups = parts.Select(g => g.Count).ToArray(); return(points); }
public override IStyleData Calculate(MarkupFiller filler, MarkupLOD lod) { var trajectories = GetTrajectories(filler); var parts = GetParts(trajectories, lod); var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray(); if (points.Length < 3) { return(null); } var triangles = Triangulator.Triangulate(points, PolygonDirection.ClockWise); if (triangles == null) { return(null); } return(new MarkupStylePolygonMesh(filler.Markup.Height, Elevation, parts.Select(g => g.Count).ToArray(), points, triangles, MaterialType)); }
public override IStyleData Calculate(MarkupFiller filler, MarkupLOD lod) { var contour = filler.IsMedian ? SetMedianOffset(filler) : filler.Contour.Trajectories.ToArray(); if (NeedReverse(contour)) { contour = contour.Select(t => t.Invert()).Reverse().ToArray(); } var parts = contour.Select(t => StyleHelper.CalculateSolid(t, lod, (tr) => tr, MinAngle, MinLength, MaxLength)).ToArray(); for (var i = 0; i < parts.Length; i += 1) { var partI = parts[i]; var partJ = parts[(i + 1) % parts.Length]; if (!FindIntersects(partI, partJ, false)) { FindIntersects(partJ, partI, true); } } var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray(); if (points.Length < 3) { return(null); } var polygon = new Polygon(points.Select(p => new PolygonPoint(p.x, p.z))); P2T.Triangulate(polygon); var triangles = polygon.Triangles.SelectMany(t => t.Points.Select(p => polygon.IndexOf(p))).ToArray(); return(new MarkupStylePolygonMesh(filler.Markup.Height, Elevation, parts.Select(g => g.Count).ToArray(), points, triangles, MaterialType)); }
protected abstract IEnumerable <IStyleData> GetStyleData(MarkupLOD lod);
private void RecalculateStyleData(MarkupLOD lod) => StyleData[lod] = GetStyleData(lod).ToArray();
public override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) => new MarkupStyleLineMesh(trajectory, Width, Elevation, MaterialType.Pavement);
public sealed override IEnumerable <IStyleData> Calculate(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod) { yield return(new MarkupStyleParts(CalculateProcess(filler, contours, lod))); }
public sealed override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) => line is MarkupStopLine stopLine?Calculate(stopLine, trajectory, lod) : new MarkupStyleParts();
public abstract IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod);
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) { var middleOffset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore; var deltaOffset = (Width - LineWidth) / 2 / Mathf.Sin(crosswalk.CornerAndNormalAngle); var firstTrajectory = crosswalk.GetTrajectory(middleOffset - deltaOffset); var secondTrajectory = crosswalk.GetTrajectory(middleOffset + deltaOffset); foreach (var dash in StyleHelper.CalculateDashed(firstTrajectory, DashLength, SpaceLength, CalculateDashes)) { yield return(dash); } foreach (var dash in StyleHelper.CalculateDashed(secondTrajectory, DashLength, SpaceLength, CalculateDashes)) { yield return(dash); } IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory dashTrajectory, float startT, float endT) { yield return(StyleHelper.CalculateDashedPart(dashTrajectory, startT, endT, DashLength, 0, LineWidth, Color)); } }
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) { foreach (var dash in base.Calculate(crosswalk, lod)) { yield return(dash); } var offset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore; var direction = crosswalk.CornerDir.Turn90(true); var borders = crosswalk.BorderTrajectories; var width = Width - 2 * LineWidth; var trajectory = crosswalk.GetFullTrajectory(offset, direction); foreach (var dash in StyleHelper.CalculateDashed(trajectory, DashLength, SpaceLength, CalculateDashes)) { yield return(dash); } IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT) => CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength, Color); }
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) => new MarkupStylePart[0];
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) { var middleOffset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore; var deltaOffset = GetLengthCoef((Width + Offset) / 2, crosswalk); var firstOffset = -crosswalk.NormalDir * (middleOffset - deltaOffset); var secondOffset = -crosswalk.NormalDir * (middleOffset + deltaOffset); var coef = Mathf.Sin(crosswalk.CornerAndNormalAngle); var dashLength = Parallel ? DashLength / coef : DashLength; var spaceLength = Parallel ? SpaceLength / coef : SpaceLength; var direction = Parallel ? crosswalk.NormalDir : crosswalk.CornerDir.Turn90(true); var borders = crosswalk.BorderTrajectories; var index = 0; var trajectoryFirst = crosswalk.GetFullTrajectory(middleOffset - deltaOffset, direction); var trajectorySecond = crosswalk.GetFullTrajectory(middleOffset + deltaOffset, direction); foreach (var dash in StyleHelper.CalculateDashed(trajectoryFirst, dashLength, spaceLength, CalculateDashes)) { yield return(dash); } index = 0; foreach (var dash in StyleHelper.CalculateDashed(trajectorySecond, dashLength, spaceLength, CalculateDashes)) { yield return(dash); } IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT) { index += 1; foreach (var part in CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength, GetColor(index))) { yield return(part); } } }
protected override IStyleData Calculate(MarkupRegularLine line, ITrajectory trajectory, MarkupLOD lod) { if (!IsValid) { return(new MarkupStyleParts()); } if (Invert) { trajectory = trajectory.Invert(); } if (Shift != 0) { var startNormal = trajectory.StartDirection.Turn90(!Invert); var endNormal = trajectory.EndDirection.Turn90(Invert); trajectory = new BezierTrajectory(trajectory.StartPosition + startNormal * Shift, trajectory.StartDirection, trajectory.EndPosition + endNormal * Shift, trajectory.EndDirection); } var length = trajectory.Length; if (OffsetBefore + OffsetAfter >= length) { return(new MarkupStyleParts()); } var startT = OffsetBefore == 0f ? 0f : trajectory.Travel(OffsetBefore); var endT = OffsetAfter == 0f ? 1f : 1f - trajectory.Invert().Travel(OffsetAfter); trajectory = trajectory.Cut(startT, endT); var count = Mathf.CeilToInt(trajectory.Length / RepeatDistance); var trajectories = new ITrajectory[count]; if (count == 1) { trajectories[0] = trajectory; } else { for (int i = 0; i < count; i += 1) { trajectories[i] = trajectory.Cut(1f / count * i, 1f / count * (i + 1)); } } return(new MarkupStyleNetwork(Prefab, trajectories, Prefab.Value.m_halfWidth * 2f, Prefab.Value.m_segmentLength, Scale, Elevation)); }
protected override IEnumerable <IStyleData> GetStyleData(MarkupLOD lod) { yield break; }
protected virtual IEnumerable <MarkupStylePart> CalculateProcess(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod) { var originalContour = filler.Contour.TrajectoriesProcessed.ToArray(); var rails = GetRails(filler, originalContour).ToArray(); foreach (var rail in rails) { var partItems = GetItems(rail, lod).ToArray(); foreach (var partItem in partItems) { foreach (var dash in GetDashes(partItem, contours)) { yield return(dash); } } } }
public abstract IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod);
protected override IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod) { var offsetNormal = ((stopLine.Start.Direction + stopLine.End.Direction) / -2).normalized; var offsetLeft = offsetNormal * (Width / 2); var offsetRight = offsetNormal * (Width / 2 + 2 * Offset); return(new MarkupStyleParts(StyleHelper.CalculateSolid(trajectory, lod, CalculateDashes))); IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory dashTrajectory) { yield return(StyleHelper.CalculateSolidPart(dashTrajectory, offsetLeft, offsetLeft, Width, Color)); yield return(StyleHelper.CalculateSolidPart(dashTrajectory, offsetRight, offsetRight, Width, Color)); } }
public abstract IEnumerable <IStyleData> Calculate(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod);
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) { var deltaOffset = GetLengthCoef(SquareSide, crosswalk); var startOffset = deltaOffset / 2 + OffsetBefore; var direction = crosswalk.CornerDir; var normalDirection = direction.Turn90(true); var borders = crosswalk.BorderTrajectories; for (var i = 0; i < LineCount; i += 1) { var trajectory = crosswalk.GetFullTrajectory(startOffset + deltaOffset * i, normalDirection); var trajectoryLength = trajectory.Length; var count = (int)(trajectoryLength / SquareSide); var squareT = SquareSide / trajectoryLength; var startT = (trajectoryLength - SquareSide * count) / trajectoryLength; for (var j = (Invert ? i + 1 : i) % 2; j < count; j += 2) { foreach (var dash in CalculateCroswalkPart(trajectory, startT + squareT * (j - 1), startT + squareT * j, direction, borders, SquareSide, SquareSide, Color)) { yield return(dash); } } } }
protected abstract IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod);
public static List <Result> CalculateSolid <Result>(ITrajectory trajectory, MarkupLOD lod, Func <ITrajectory, IEnumerable <Result> > calculateParts, float?minAngle = null, float?minLength = null, float?maxLength = null) { return(CalculateSolid <Result>(trajectory, lod, minAngle, minLength, maxLength, AddToResult)); void AddToResult(List <Result> result, ITrajectory trajectory) => result.AddRange(calculateParts(trajectory)); }
protected bool CheckDashedLod(MarkupLOD lod, float width, float length) => lod != MarkupLOD.LOD1 || width > LodWidth || length > LodLength;
protected override IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod) { if (!CheckDashedLod(lod, Base, Height)) { return(new MarkupStyleParts()); } var styleData = new MarkupStyleParts(StyleHelper.CalculateDashed(trajectory, Base, Space, CalculateDashes)); foreach (var dash in styleData) { dash.MaterialType = MaterialType.Triangle; } return(styleData); }
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) { StyleHelper.GetParts(Width, 0, lod, out int count, out float partWidth); var partOffset = GetVisibleWidth(crosswalk) / count; var startOffset = partOffset / 2; for (var i = 0; i < count; i += 1) { var trajectory = crosswalk.GetTrajectory(startOffset + partOffset * i + OffsetBefore); yield return(new MarkupStylePart(trajectory.StartPosition, trajectory.EndPosition, trajectory.Direction, partWidth, Color)); } }
public abstract IStyleData Calculate(MarkupFiller filler, MarkupLOD lod);