/// <summary>
/// Performs a Depth-First traversal over the cached segment geometry structure. At each
/// traversed segment, the given `visitor` is notified. It then can update the current `state`.
/// </summary>
/// <param name="initialSegmentGeometry">Specifies the segment at which the traversal
/// should start.</param>
/// <param name="nextNodeIsStartNode">Specifies if the next node to traverse is the start
/// node of the initial segment.</param>
/// <param name="direction">Specifies if traffic should be able to flow towards the initial
/// segment (Incoming) or should be able to flow from the initial segment (Outgoing) or
/// in both directions (Both).</param>
/// <param name="maximumDepth">Specifies the maximum depth to explore. At a depth of 0, no
/// segment will be traversed (event the initial segment will be omitted).</param>
/// <param name="visitorFun">Specifies the stateful visitor that should be notified as soon as
/// a traversable segment (which has not been traversed before) is found.</param>
public static IEnumerable <ushort> Traverse(ushort initialSegmentId,
TraverseDirection direction,
TraverseSide side,
SegmentStopCriterion stopCrit,
SegmentVisitor visitorFun)
{
ExtSegment initialSeg = Constants.ManagerFactory.ExtSegmentManager.ExtSegments[initialSegmentId];
if (!initialSeg.valid)
{
return(null);
}
// Log._Debug($"SegmentTraverser: Traversing initial segment {initialSegmentId}");
if (!visitorFun(
new SegmentVisitData(
ref initialSeg,
ref initialSeg,
false,
false,
true)))
{
return(null);
}
HashSet <ushort> visitedSegmentIds = new HashSet <ushort>();
visitedSegmentIds.Add(initialSegmentId);
IExtSegmentEndManager extSegEndMan = Constants.ManagerFactory.ExtSegmentEndManager;
ref NetSegment initialSegment = ref initialSegmentId.ToSegment();
/// <summary>
/// Performs a Depth-First traversal over the cached segment geometry structure. At each
/// traversed segment, the given `visitor` is notified. It then can update the current `state`.
/// </summary>
/// <param name="initialSegmentGeometry">Specifies the segment at which the traversal
/// should start.</param>
/// <param name="nextNodeIsStartNode">Specifies if the next node to traverse is the start
/// node of the initial segment.</param>
/// <param name="direction">Specifies if traffic should be able to flow towards the initial
/// segment (Incoming) or should be able to flow from the initial segment (Outgoing) or
/// in both directions (Both).</param>
/// <param name="maximumDepth">Specifies the maximum depth to explore. At a depth of 0, no
/// segment will be traversed (event the initial segment will be omitted).</param>
/// <param name="visitorFun">Specifies the stateful visitor that should be notified as soon as
/// a traversable segment (which has not been traversed before) is found.</param>
public static IEnumerable <ushort> Traverse(ushort initialSegmentId,
TraverseDirection direction,
TraverseSide side,
SegmentStopCriterion stopCrit,
SegmentVisitor visitorFun)
{
ExtSegment initialSeg = Constants.ManagerFactory.ExtSegmentManager.ExtSegments[initialSegmentId];
if (!initialSeg.valid)
{
return(null);
}
// Log._Debug($"SegmentTraverser: Traversing initial segment {initialSegmentId}");
if (!visitorFun(
new SegmentVisitData(
ref initialSeg,
ref initialSeg,
false,
false,
true)))
{
return(null);
}
HashSet <ushort> visitedSegmentIds = new HashSet <ushort>();
visitedSegmentIds.Add(initialSegmentId);
IExtSegmentEndManager extSegEndMan = Constants.ManagerFactory.ExtSegmentEndManager;
ushort startNodeId = Constants.ServiceFactory.NetService.GetSegmentNodeId(initialSegmentId, true);
TraverseRec(
ref initialSeg,
ref extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(initialSegmentId, true)],
ref startNodeId.ToNode(),
true,
direction,
side,
stopCrit,
visitorFun,
visitedSegmentIds);
ushort endNodeId = Constants.ServiceFactory.NetService.GetSegmentNodeId(initialSegmentId, false);
TraverseRec(
ref initialSeg,
ref extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(initialSegmentId, false)],
ref endNodeId.ToNode(),
false,
direction,
side,
stopCrit,
visitorFun,
visitedSegmentIds);
// Log._Debug($"SegmentTraverser: Traversal finished.");
return(visitedSegmentIds);
}
protected override void Initialize()
{
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_projectsController = SdlTradosStudio.Application.GetController <ProjectsController>();
_studioVersionService = new StudioVersionService();
var commonService = new ProjectFileService();
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
var sdlxliffMerger = new SdlxliffMerger();
var segmentBuilder = new SegmentBuilder();
var segmentVisitor = new SegmentVisitor();
var paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService);
var sdlxliffExporter = new SdlxliffExporter(segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
var displayFilter = new DisplayFilter();
var model = new StudioViewsEditorViewModel(_editorController, filterItemService,
commonService, sdlxliffMerger, sdlxliffExporter, sdlXliffReader, paragraphUnitProvider, displayFilter);
_control = new StudioViewsEditorView {
DataContext = model
};
}
public ParagraphUnitProviderTests()
{
var segmentBuilder = new SegmentBuilder();
_paragraphUnitHelper = new ParagraphUnitHelper(segmentBuilder);
var analysisBands = new List <AnalysisBand>
{
new AnalysisBand {
MaximumMatchValue = 74, MinimumMatchValue = 50
},
new AnalysisBand {
MaximumMatchValue = 84, MinimumMatchValue = 75
},
new AnalysisBand {
MaximumMatchValue = 94, MinimumMatchValue = 85
},
new AnalysisBand {
MaximumMatchValue = 99, MinimumMatchValue = 95
}
};
var filterItemService = new FilterItemService(analysisBands);
var segmentVisitor = new SegmentVisitor();
_paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService);
}
private void Run(IReadOnlyCollection <SystemFileInfo> importFiles, Language language)
{
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
var commonService = new ProjectFileService();
var segmentVisitor = new SegmentVisitor();
var segmentBuilder = new SegmentBuilder();
var paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService, segmentBuilder);
var sdlxliffImporter = new SdlxliffImporter(commonService, filterItemService, paragraphUnitProvider, segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
_window = new StudioViewsFilesImportView();
var model = new StudioViewsFilesImportViewModel(_window, _filesController, language, commonService, filterItemService, sdlxliffImporter, sdlXliffReader);
_window.DataContext = model;
if (importFiles != null)
{
model.AddFiles(importFiles);
}
_window.ShowDialog();
if (model.DialogResult != DialogResult.OK)
{
return;
}
OpenMessageWindow(model);
}
private bool IsActiveSegmentText(string text, ILanguage source)
{
if (text == null || source == null)
{
return(false);
}
var selectedSegmentPair = _editorController?.ActiveDocument?.GetActiveSegmentPair();
if (selectedSegmentPair?.Source == null)
{
return(true);
}
var regex = new Regex(@"[\s\t]+", RegexOptions.None);
var searchText = regex.Replace(text, string.Empty);
var segment = new Segment(source.Locale);
var segmentVisitor = new SegmentVisitor(segment, true);
segmentVisitor.VisitSegment(selectedSegmentPair.Source);
var sourceText = regex.Replace(segmentVisitor.Segment.ToPlain(), string.Empty);
return(string.Compare(searchText, sourceText, StringComparison.InvariantCultureIgnoreCase) == 0);
}
private static SegmentVisitor SegmentVisitor(ISegment seg, CultureInfo culture)
{
var segment = new Segment(culture);
var visitor = new SegmentVisitor(segment, false);
visitor.VisitSegment(seg);
return(visitor);
}
public DsiViewerViewModel()
{
_segmentVisitor = new SegmentVisitor(false);
_comments = new List <IComment>();
_documentStructureInformation = new List <DsiModel>();
_editorController = DsiViewerInitializer.EditorController;
_editorController.ActiveDocumentChanged += EditorController_ActiveDocumentChanged;
SetActiveDocument(_editorController.ActiveDocument);
}
public override long GetIndexToKeep(Segments segments)
{
SegmentVisitor visitor = new SegmentVisitor(this);
segments.VisitBackwards(visitor);
if (visitor.VisitedCount == 0)
{
_log.warn("No log files found during the prune operation. This state should resolve on its own, but" + " if this warning continues, you may want to look for other errors in the user log.");
}
return(visitor.PrevIndex);
}
///<summary>
/// Determines the <see cref="Location"/> of a point in an areal <see cref="IGeometry"/>.
///</summary>
/// <param name="p">The point to test</param>
/// <returns>The location of the point in the geometry
/// </returns>
public Location Locate(Coordinate p)
{
var rcc = new RayCrossingCounter(p);
var visitor = new SegmentVisitor(rcc);
_index.Query(p.Y, p.Y, visitor);
/*
* // MD - slightly slower alternative
* List segs = index.query(p.y, p.y);
* countSegs(rcc, segs);
*/
return(rcc.Location);
}
public void VisitSegments()
{
JliffDocument jlb = new JliffBuilder("en-US", "it-IT")
.AddFile(new XlfEventArgs("f1"))
.AddUnit(new XlfEventArgs("u1"))
.EndSubFiles()
.AddSegment(new XlfEventArgs("s1"))
.EndSubUnits()
.AddSource("Hello")
.AddSmElement("mrk1", true)
.AddSource("there")
.AddEmElement("", true)
.AddTarget("Buongiorno")
.MoreSubUnits()
.AddSegment(new XlfEventArgs("s2"))
.EndSubUnits()
.AddSource("Congratulations")
.MoreSubUnits()
.AddSegment(new XlfEventArgs("s3"))
.EndSubUnits()
.AddSource("Goodbye")
.AddTarget("Arrivederci")
.Build();
SegmentVisitor sv = new SegmentVisitor();
jlb.Files[0].Process(sv);
Assert.AreEqual <int>(3, sv.Segments.Count);
sv.Segments[2].Target = new List <IElement>
{
new TextElement("So long")
};
Unit u = jlb.Files[0].Subfiles[0] as Unit;
Segment s = u.Subunits[2] as Segment;
TextElement t = s.Target[0] as TextElement;
Assert.AreEqual <string>("So long", t.Text);
}
/// <summary>
/// Determines the <see cref="Location"/> of a point in an areal <see cref="Geometry"/>.
/// </summary>
/// <param name="p">The point to test</param>
/// <returns>The location of the point in the geometry
/// </returns>
public Location Locate(Coordinate p)
{
// avoid calling synchronized method improves performance
if (_index == null)
{
CreateIndex();
}
var rcc = new RayCrossingCounter(p);
var visitor = new SegmentVisitor(rcc);
_index.Query(p.Y, p.Y, visitor);
/*
* // MD - slightly slower alternative
* List segs = index.query(p.y, p.y);
* countSegs(rcc, segs);
*/
return(rcc.Location);
}
/// <summary>
/// Determines the <see cref="Location"/> of a point in an areal <see cref="Geometry"/>.
/// </summary>
/// <param name="p">The point to test</param>
/// <returns>The location of the point in the geometry
/// </returns>
public Location Locate(Coordinate p)
{
if (_index == null)
{
_index = new IntervalIndexedGeometry(_geom);
// no need to hold onto geom
_geom = null;
}
var rcc = new RayCrossingCounter(p);
var visitor = new SegmentVisitor(rcc);
_index.Query(p.Y, p.Y, visitor);
/*
* // MD - slightly slower alternative
* List segs = index.query(p.y, p.y);
* countSegs(rcc, segs);
*/
return(rcc.Location);
}
public static void Traverse(List <ushort> segmentList, SegmentVisitor visitorFun)
{
if (segmentList == null)
{
return;
}
ushort prevSegId = 0;
ExtSegment[] extSegment_buffer = Constants.ManagerFactory.ExtSegmentManager.ExtSegments;
NetSegment[] segment_buffer = Singleton <NetManager> .instance.m_segments.m_buffer;
foreach (var segId in segmentList)
{
SegmentTraverser.SegmentVisitData data;
if (prevSegId == 0)
{
data = new SegmentVisitData(
ref extSegment_buffer[segId],
ref extSegment_buffer[segId],
false,
false,
true);
}
else
{
data = new SegmentVisitData(
ref extSegment_buffer[prevSegId],
ref extSegment_buffer[segId],
true,
segment_buffer[prevSegId].m_endNode == segment_buffer[segId].m_startNode,
false);
}
if (!visitorFun(data))
{
break;
}
prevSegId = segId;
}
}
/// <summary>
/// Performs a Depth-First traversal over the cached segment geometry structure. At each traversed segment, the given `visitor` is notified. It then can update the current `state`.
/// </summary>
/// <param name="initialSegmentGeometry">Specifies the segment at which the traversal should start.</param>
/// <param name="nextNodeIsStartNode">Specifies if the next node to traverse is the start node of the initial segment.</param>
/// <param name="direction">Specifies if traffic should be able to flow towards the initial segment (Incoming) or should be able to flow from the initial segment (Outgoing) or in both directions (Both).</param>
/// <param name="maximumDepth">Specifies the maximum depth to explore. At a depth of 0, no segment will be traversed (event the initial segment will be omitted).</param>
/// <param name="visitor">Specifies the stateful visitor that should be notified as soon as a traversable segment (which has not been traversed before) is found.</param>
public static void Traverse(ushort initialSegmentId, TraverseDirection direction, TraverseSide side, SegmentStopCriterion stopCrit, SegmentVisitor visitor)
{
SegmentGeometry initialSegGeometry = SegmentGeometry.Get(initialSegmentId);
if (initialSegGeometry == null)
{
return;
}
Log._Debug($"SegmentTraverser: Traversing initial segment {initialSegGeometry.SegmentId}");
if (visitor(new SegmentVisitData(initialSegGeometry, initialSegGeometry, false, false, true)))
{
HashSet <ushort> visitedSegmentIds = new HashSet <ushort>();
visitedSegmentIds.Add(initialSegmentId);
TraverseRec(initialSegGeometry, true, true, direction, side, stopCrit, visitor, visitedSegmentIds);
TraverseRec(initialSegGeometry, false, false, direction, side, stopCrit, visitor, visitedSegmentIds);
}
Log._Debug($"SegmentTraverser: Traversal finished.");
}
private static void TraverseRec(SegmentGeometry prevSegGeometry, bool exploreStartNode, bool viaInitialStartNode, TraverseDirection direction, TraverseSide side, SegmentStopCriterion stopCrit, SegmentVisitor visitor, HashSet <ushort> visitedSegmentIds)
{
Log._Debug($"SegmentTraverser: Traversing segment {prevSegGeometry.SegmentId}");
// collect next segment ids to traverse
if (direction == TraverseDirection.None)
{
throw new ArgumentException($"Invalid direction {direction} given.");
}
if (side == TraverseSide.None)
{
throw new ArgumentException($"Invalid side {side} given.");
}
HashSet <ushort> nextSegmentIds = new HashSet <ushort>();
switch (direction)
{
case TraverseDirection.AnyDirection:
default:
if (side == TraverseSide.AnySide)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetConnectedSegments(exploreStartNode));
}
else
{
if ((side & TraverseSide.Left) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetLeftSegments(exploreStartNode));
}
if ((side & TraverseSide.Straight) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetStraightSegments(exploreStartNode));
}
if ((side & TraverseSide.Right) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetRightSegments(exploreStartNode));
}
}
break;
case TraverseDirection.Incoming:
if (side == TraverseSide.AnySide)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetIncomingSegments(exploreStartNode));
}
else
{
if ((side & TraverseSide.Left) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetIncomingLeftSegments(exploreStartNode));
}
if ((side & TraverseSide.Straight) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetIncomingStraightSegments(exploreStartNode));
}
if ((side & TraverseSide.Right) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetIncomingRightSegments(exploreStartNode));
}
}
break;
case TraverseDirection.Outgoing:
if (side == TraverseSide.AnySide)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetOutgoingSegments(exploreStartNode));
}
else
{
if ((side & TraverseSide.Left) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetOutgoingLeftSegments(exploreStartNode));
}
if ((side & TraverseSide.Straight) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetOutgoingStraightSegments(exploreStartNode));
}
if ((side & TraverseSide.Right) != TraverseSide.None)
{
nextSegmentIds.UnionWith(prevSegGeometry.GetOutgoingRightSegments(exploreStartNode));
}
}
break;
}
nextSegmentIds.Remove(0);
Log._Debug($"SegmentTraverser: Fetched next segments to traverse: {nextSegmentIds.CollectionToString()}");
if (nextSegmentIds.Count >= 2 && (stopCrit & SegmentStopCriterion.Junction) != SegmentStopCriterion.None)
{
Log._Debug($"SegmentTraverser: Stop criterion reached @ {prevSegGeometry.SegmentId}: {nextSegmentIds.Count} connected segments");
return;
}
ushort prevNodeId = prevSegGeometry.GetNodeId(exploreStartNode);
// explore next segments
foreach (ushort nextSegmentId in nextSegmentIds)
{
if (nextSegmentId == 0 || visitedSegmentIds.Contains(nextSegmentId))
{
continue;
}
visitedSegmentIds.Add(nextSegmentId);
SegmentGeometry nextSegGeometry = SegmentGeometry.Get(nextSegmentId);
if (nextSegGeometry != null)
{
Log._Debug($"SegmentTraverser: Traversing segment {nextSegGeometry.SegmentId}");
if (visitor(new SegmentVisitData(prevSegGeometry, nextSegGeometry, viaInitialStartNode, prevNodeId == nextSegGeometry.StartNodeId(), false)))
{
bool nextNodeIsStartNode = nextSegGeometry.StartNodeId() != prevNodeId;
TraverseRec(nextSegGeometry, nextNodeIsStartNode, viaInitialStartNode, direction, side, stopCrit, visitor, visitedSegmentIds);
}
}
}
}
public ParagraphUnitProvider(SegmentVisitor segmentVisitor, FilterItemService filterItemService, SegmentBuilder segmentBuilder)
{
_segmentVisitor = segmentVisitor;
_filterItemService = filterItemService;
_segmentBuilder = segmentBuilder;
}
private static void TraverseRec(ref ExtSegment prevSeg,
ref ExtSegmentEnd prevSegEnd,
ref NetNode node,
bool viaInitialStartNode,
TraverseDirection direction,
TraverseSide side,
SegmentStopCriterion stopCrit,
SegmentVisitor visitorFun,
HashSet <ushort> visitedSegmentIds)
{
// Log._Debug($"SegmentTraverser: Traversing segment {prevSegEnd.segmentId}");
// collect next segment ids to traverse
if (direction == TraverseDirection.None)
{
throw new ArgumentException($"Invalid direction {direction} given.");
}
if (side == TraverseSide.None)
{
throw new ArgumentException($"Invalid side {side} given.");
}
IExtSegmentManager extSegMan = Constants.ManagerFactory.ExtSegmentManager;
IExtSegmentEndManager extSegEndMan = Constants.ManagerFactory.ExtSegmentEndManager;
HashSet <ushort> nextSegmentIds = new HashSet <ushort>();
for (int i = 0; i < 8; ++i)
{
ushort nextSegmentId = node.GetSegment(i);
if (nextSegmentId == 0 || nextSegmentId == prevSegEnd.segmentId)
{
continue;
}
bool nextIsStartNode =
(bool)Constants.ServiceFactory.NetService.IsStartNode(
nextSegmentId,
prevSegEnd.nodeId);
ExtSegmentEnd nextSegEnd =
extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(nextSegmentId, nextIsStartNode)];
if (direction == TraverseDirection.AnyDirection ||
(direction == TraverseDirection.Incoming && nextSegEnd.incoming) ||
(direction == TraverseDirection.Outgoing && nextSegEnd.outgoing))
{
if (side == TraverseSide.AnySide)
{
nextSegmentIds.Add(nextSegmentId);
}
else
{
ArrowDirection dir = extSegEndMan.GetDirection(
ref prevSegEnd,
nextSegmentId);
if (((side & TraverseSide.Left) != TraverseSide.None &&
dir == ArrowDirection.Left) ||
((side & TraverseSide.Straight) != TraverseSide.None &&
dir == ArrowDirection.Forward) ||
((side & TraverseSide.Right) != TraverseSide.None &&
dir == ArrowDirection.Right))
{
nextSegmentIds.Add(nextSegmentId);
}
}
}
}
nextSegmentIds.Remove(0);
// Log._Debug($"SegmentTraverser: Fetched next segments to traverse:
// {nextSegmentIds.CollectionToString()}");
if (nextSegmentIds.Count >= 2 && (stopCrit & SegmentStopCriterion.Junction) !=
SegmentStopCriterion.None)
{
// Log._Debug($"SegmentTraverser: Stop criterion reached @ {prevSegEnd.segmentId}:
// {nextSegmentIds.Count} connected segments");
return;
}
// explore next segments
foreach (ushort nextSegmentId in nextSegmentIds)
{
if (visitedSegmentIds.Contains(nextSegmentId))
{
continue;
}
visitedSegmentIds.Add(nextSegmentId);
// Log._Debug($"SegmentTraverser: Traversing segment {nextSegmentId}");
ushort nextStartNodeId =
Constants.ServiceFactory.NetService.GetSegmentNodeId(nextSegmentId, true);
if (!visitorFun(
new SegmentVisitData(
ref prevSeg,
ref extSegMan.ExtSegments[nextSegmentId],
viaInitialStartNode,
prevSegEnd.nodeId == nextStartNodeId,
false)))
{
continue;
}
bool nextNodeIsStartNode = nextStartNodeId != prevSegEnd.nodeId;
ExtSegmentEnd nextSegEnd
= extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(nextSegmentId, nextNodeIsStartNode)];
Constants.ServiceFactory.NetService.ProcessNode(
nextSegEnd.nodeId,
(ushort nId, ref NetNode nextNode) => {
TraverseRec(
ref extSegMan.ExtSegments[nextSegmentId],
ref nextSegEnd,
ref nextNode,
viaInitialStartNode,
direction,
side,
stopCrit,
visitorFun,
visitedSegmentIds);
return(true);
});
} // end foreach
}
private static void TraverseRec(SegmentGeometry prevSegGeometry, bool exploreStartNode, bool viaInitialStartNode, TraverseDirection direction, SegmentStopCriterion stopCrit, SegmentVisitor visitor, HashSet <ushort> visitedSegmentIds)
{
// collect next segment ids to traverse
ushort[] nextSegmentIds;
int numConnectedSegments;
switch (direction)
{
case TraverseDirection.Both:
default:
nextSegmentIds = prevSegGeometry.GetConnectedSegments(exploreStartNode);
numConnectedSegments = prevSegGeometry.CountOtherSegments(exploreStartNode);
break;
case TraverseDirection.Incoming:
nextSegmentIds = prevSegGeometry.GetIncomingSegments(exploreStartNode);
numConnectedSegments = prevSegGeometry.CountIncomingSegments(exploreStartNode);
break;
case TraverseDirection.Outgoing:
nextSegmentIds = prevSegGeometry.GetOutgoingSegments(exploreStartNode);
numConnectedSegments = prevSegGeometry.CountOutgoingSegments(exploreStartNode);
break;
}
if (numConnectedSegments >= 2 && (stopCrit & SegmentStopCriterion.Junction) != SegmentStopCriterion.None)
{
Log._Debug($"SegmentTraverser: Stop criterion reached @ {prevSegGeometry.SegmentId}: {numConnectedSegments} connected segments");
return;
}
ushort prevNodeId = prevSegGeometry.GetNodeId(exploreStartNode);
// explore next segments
foreach (ushort nextSegmentId in nextSegmentIds)
{
if (nextSegmentId == 0 || visitedSegmentIds.Contains(nextSegmentId))
{
continue;
}
visitedSegmentIds.Add(nextSegmentId);
SegmentGeometry nextSegGeometry = SegmentGeometry.Get(nextSegmentId);
if (nextSegGeometry != null)
{
Log._Debug($"SegmentTraverser: Traversing segment {nextSegGeometry.SegmentId}");
if (visitor(new SegmentVisitData(prevSegGeometry, nextSegGeometry, viaInitialStartNode, prevNodeId == nextSegGeometry.StartNodeId(), false)))
{
bool nextNodeIsStartNode = nextSegGeometry.StartNodeId() != prevNodeId;
TraverseRec(nextSegGeometry, nextNodeIsStartNode, viaInitialStartNode, direction, stopCrit, visitor, visitedSegmentIds);
}
}
}
}
/// <summary>
/// Performs a Depth-First traversal over the cached segment geometry structure. At each traversed segment, the given `visitor` is notified. It then can update the current `state`.
/// </summary>
/// <param name="initialSegmentGeometry">Specifies the segment at which the traversal should start.</param>
/// <param name="nextNodeIsStartNode">Specifies if the next node to traverse is the start node of the initial segment.</param>
/// <param name="direction">Specifies if traffic should be able to flow towards the initial segment (Incoming) or should be able to flow from the initial segment (Outgoing) or in both directions (Both).</param>
/// <param name="maximumDepth">Specifies the maximum depth to explore. At a depth of 0, no segment will be traversed (event the initial segment will be omitted).</param>
/// <param name="visitor">Specifies the stateful visitor that should be notified as soon as a traversable segment (which has not been traversed before) is found.</param>
public static void Traverse(ushort initialSegmentId, TraverseDirection direction, TraverseSide side, SegmentStopCriterion stopCrit, SegmentVisitor visitor)
{
ExtSegment initialSeg = Constants.ManagerFactory.ExtSegmentManager.ExtSegments[initialSegmentId];
if (!initialSeg.valid)
{
return;
}
//Log._Debug($"SegmentTraverser: Traversing initial segment {initialSegmentId}");
if (visitor(new SegmentVisitData(ref initialSeg, ref initialSeg, false, false, true)))
{
HashSet <ushort> visitedSegmentIds = new HashSet <ushort>();
visitedSegmentIds.Add(initialSegmentId);
IExtSegmentEndManager extSegEndMan = Constants.ManagerFactory.ExtSegmentEndManager;
ushort startNodeId = Constants.ServiceFactory.NetService.GetSegmentNodeId(initialSegmentId, true);
Constants.ServiceFactory.NetService.ProcessNode(startNodeId, delegate(ushort nId, ref NetNode node) {
TraverseRec(ref initialSeg, ref extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(initialSegmentId, true)], ref node, true, direction, side, stopCrit, visitor, visitedSegmentIds);
return(true);
});
ushort endNodeId = Constants.ServiceFactory.NetService.GetSegmentNodeId(initialSegmentId, false);
Constants.ServiceFactory.NetService.ProcessNode(endNodeId, delegate(ushort nId, ref NetNode node) {
TraverseRec(ref initialSeg, ref extSegEndMan.ExtSegmentEnds[extSegEndMan.GetIndex(initialSegmentId, false)], ref node, false, direction, side, stopCrit, visitor, visitedSegmentIds);
return(true);
});
}
//Log._Debug($"SegmentTraverser: Traversal finished.");
}
