nsresult
nsSVGPathDataParserToDOM::StoreVLineTo(PRBool absCoords, float y)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegLinetoVerticalAbs(y)
: NS_NewSVGPathSegLinetoVerticalRel(y));
}
nsresult
nsSVGPathDataParserToDOM::StoreHLineTo(PRBool absCoords, float x)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegLinetoHorizontalAbs(x)
: NS_NewSVGPathSegLinetoHorizontalRel(x));
}
nsresult
nsSVGPathDataParserToDOM::StoreLineTo(PRBool absCoords, float x, float y)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegLinetoAbs(x, y)
: NS_NewSVGPathSegLinetoRel(x, y));
}
nsresult
nsSVGPathDataParserToDOM::StoreSmoothQuadCurveTo(PRBool absCoords,
float x, float y)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegCurvetoQuadraticSmoothAbs(x, y)
: NS_NewSVGPathSegCurvetoQuadraticSmoothRel(x, y));
}
void DescriptionFactory::SetStartSegment(const PhantomNode &source, const bool traversed_in_reverse)
{
start_phantom = source;
const EdgeWeight segment_duration =
(traversed_in_reverse ? source.reverse_weight : source.forward_weight);
AppendSegment(source.location,
PathData(0, source.name_id, TurnInstruction::HeadOn, segment_duration));
BOOST_ASSERT(path_description.back().duration == segment_duration);
}
nsresult
nsSVGPathDataParserToDOM::StoreQuadCurveTo(PRBool absCoords,
float x, float y,
float x1, float y1)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1)
: NS_NewSVGPathSegCurvetoQuadraticRel(x, y, x1, y1));
}
nsresult
nsSVGPathDataParserToDOM::StoreSmoothCurveTo(PRBool absCoords,
float x, float y,
float x2, float y2)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2)
: NS_NewSVGPathSegCurvetoCubicSmoothRel(x, y, x2, y2));
}
void SegmentList<DataFacadeT>::InitRoute(const PhantomNode &node, const bool traversed_in_reverse)
{
const auto segment_duration =
(traversed_in_reverse ? node.reverse_weight : node.forward_weight);
const auto travel_mode =
(traversed_in_reverse ? node.backward_travel_mode : node.forward_travel_mode);
AppendSegment(node.location, PathData(0, node.name_id, extractor::TurnInstruction::HeadOn,
segment_duration, travel_mode));
}
nsresult
nsSVGPathDataParserToDOM::StoreEllipticalArc(PRBool absCoords,
float x, float y,
float r1, float r2,
float angle,
PRBool largeArcFlag,
PRBool sweepFlag)
{
return AppendSegment(
absCoords ? NS_NewSVGPathSegArcAbs(x, y, r1, r2, angle,
largeArcFlag, sweepFlag)
: NS_NewSVGPathSegArcRel(x, y, r1, r2, angle,
largeArcFlag, sweepFlag));
}
void SegmentList<DataFacadeT>::AddLeg(const std::vector<PathData> &leg_data,
const PhantomNode &target_node,
const bool traversed_in_reverse,
const bool is_via_leg,
const DataFacade *facade)
{
for (const auto &path_data : leg_data)
{
AppendSegment(facade->GetCoordinateOfNode(path_data.node), path_data);
}
const EdgeWeight segment_duration =
(traversed_in_reverse ? target_node.reverse_weight : target_node.forward_weight);
const extractor::TravelMode travel_mode =
(traversed_in_reverse ? target_node.backward_travel_mode : target_node.forward_travel_mode);
const bool constexpr IS_NECESSARY = true;
const bool constexpr IS_VIA_LOCATION = true;
segments.emplace_back(target_node.location, target_node.name_id, segment_duration, 0.f,
is_via_leg ? extractor::TurnInstruction::ReachViaLocation
: extractor::TurnInstruction::NoTurn,
IS_NECESSARY, IS_VIA_LOCATION, travel_mode);
}
void DescriptionFactory::SetStartSegment(const PhantomNode & _startPhantom) {
startPhantom = _startPhantom;
AppendSegment(_startPhantom.location, _PathData(0, _startPhantom.nodeBasedEdgeNameID, 10, _startPhantom.weight1));
}
void DescriptionFactory::SetStartSegment(const PhantomNode &source)
{
start_phantom = source;
AppendSegment(source.location, PathData(0, source.name_id, TurnInstruction::HeadOn, source.forward_weight));
}
SegmentsX *MergeSuperSegments(SegmentsX *segmentsx,SegmentsX *supersegmentsx)
{
index_t i,j;
index_t merged=0,added=0;
SegmentsX *mergedsegmentsx;
mergedsegmentsx=NewSegmentList(0);
if(segmentsx->number==0)
return(mergedsegmentsx);
/* Print the start message */
printf_first("Merging Segments: Segments=0 Super=0 Merged=0 Added=0");
/* Map into memory / open the files */
#if !SLIM
segmentsx->data=MapFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->data=MapFile(supersegmentsx->filename);
#else
segmentsx->fd=ReOpenFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->fd=ReOpenFile(supersegmentsx->filename);
#endif
/* Loop through and create a new list of combined segments */
for(i=0,j=0;i<segmentsx->number;i++)
{
int super=0;
SegmentX *segmentx=LookupSegmentX(segmentsx,i,1);
while(j<supersegmentsx->number)
{
SegmentX *supersegmentx=LookupSegmentX(supersegmentsx,j,1);
if(segmentx->node1 ==supersegmentx->node1 &&
segmentx->node2 ==supersegmentx->node2 &&
segmentx->distance==supersegmentx->distance)
{
merged++;
j++;
/* mark as super-segment and normal segment */
super=1;
break;
}
else if((segmentx->node1==supersegmentx->node1 &&
segmentx->node2==supersegmentx->node2) ||
(segmentx->node1==supersegmentx->node1 &&
segmentx->node2>supersegmentx->node2) ||
(segmentx->node1>supersegmentx->node1))
{
/* mark as super-segment */
AppendSegment(mergedsegmentsx,supersegmentx->way,supersegmentx->node1,supersegmentx->node2,supersegmentx->distance|SEGMENT_SUPER);
added++;
j++;
}
else
{
/* mark as normal segment */
break;
}
}
if(super)
AppendSegment(mergedsegmentsx,segmentx->way,segmentx->node1,segmentx->node2,segmentx->distance|SEGMENT_SUPER|SEGMENT_NORMAL);
else
AppendSegment(mergedsegmentsx,segmentx->way,segmentx->node1,segmentx->node2,segmentx->distance|SEGMENT_NORMAL);
if(!((i+1)%10000))
printf_middle("Merging Segments: Segments=%"Pindex_t" Super=%"Pindex_t" Merged=%"Pindex_t" Added=%"Pindex_t,i+1,j,merged,added);
}
/* Unmap from memory / close the files */
#if !SLIM
segmentsx->data=UnmapFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->data=UnmapFile(supersegmentsx->filename);
#else
segmentsx->fd=CloseFile(segmentsx->fd);
if(supersegmentsx->number>0)
supersegmentsx->fd=CloseFile(supersegmentsx->fd);
#endif
/* Print the final message */
printf_last("Merged Segments: Segments=%"Pindex_t" Super=%"Pindex_t" Merged=%"Pindex_t" Added=%"Pindex_t,segmentsx->number,supersegmentsx->number,merged,added);
return(mergedsegmentsx);
}
SegmentsX *CreateSuperSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
index_t i;
SegmentsX *supersegmentsx;
index_t sn=0,ss=0;
supersegmentsx=NewSegmentList(0);
if(segmentsx->number==0 || waysx->number==0)
return(supersegmentsx);
/* Print the start message */
printf_first("Creating Super-Segments: Super-Nodes=0 Super-Segments=0");
/* Map into memory / open the files */
#if !SLIM
segmentsx->data=MapFile(segmentsx->filename);
waysx->data=MapFile(waysx->filename);
#else
segmentsx->fd=ReOpenFile(segmentsx->filename);
waysx->fd=ReOpenFile(waysx->filename);
#endif
/* Create super-segments for each super-node. */
for(i=0;i<nodesx->number;i++)
{
if(IsBitSet(nodesx->super,i))
{
SegmentX *segmentx;
int count=0,match;
Way prevway[MAX_SEG_PER_NODE];
segmentx=FirstSegmentX(segmentsx,i,1);
while(segmentx)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
/* Check that this type of way hasn't already been routed */
match=0;
if(count>0)
{
int j;
for(j=0;j<count;j++)
if(!WaysCompare(&prevway[j],&wayx->way))
{
match=1;
break;
}
}
assert(count<MAX_SEG_PER_NODE); /* Only a limited amount of history stored. */
prevway[count++]=wayx->way;
/* Route the way and store the super-segments. */
if(!match)
{
Results *results=FindRoutesWay(nodesx,segmentsx,waysx,i,&wayx->way);
Result *result=FirstResult(results);
while(result)
{
if(IsBitSet(nodesx->super,result->node) && result->segment!=NO_SEGMENT)
{
if(wayx->way.type&Way_OneWay && result->node!=i)
AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score)|ONEWAY_1TO2);
else
AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score));
ss++;
}
result=NextResult(results,result);
}
FreeResultsList(results);
}
segmentx=NextSegmentX(segmentsx,segmentx,i);
}
sn++;
if(!(sn%10000))
printf_middle("Creating Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss);
}
}
/* Unmap from memory / close the files */
#if !SLIM
segmentsx->data=UnmapFile(segmentsx->filename);
waysx->data=UnmapFile(waysx->filename);
#else
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Created Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss);
return(supersegmentsx);
}
nsresult
nsSVGPathDataParserToDOM::StoreClosePath()
{
return AppendSegment(NS_NewSVGPathSegClosePath());
}
