CalvinBackup/iD
1
0
Fork 0
mirror of https://github.com/FoggedLens/iD.git synced 2026-05-20 07:25:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

add turn lanes

Browse Source
This commit is contained in:
Kushan Joshi
2016-08-09 00:53:33 +05:30
parent 24592f8b0a
commit 94b40cdfd0
2 changed files with 427 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/core/way.js
+56 -6
View File
@@ -110,7 +110,6 @@ _.extend(Way.prototype, {
direction: direction
};
}
var lanesArray = [];
for (var i = 0; i < metadata.forward; i++) {
lanesArray.push(createLaneItem(i, 'forward'));
}
@@ -123,6 +122,21 @@ _.extend(Way.prototype, {
return lanesArray;
}
function getTurns(str, count) {
var array = str.split('|')
.filter(function(s, i) {
return i < count;
})
.map(function(s) {
if (s === '') s = 'none';
return s.split(';');
});
while (array.length < count) {
array.push(['none']);
}
return array;
}
function safeValue(n) {
if (n < 0) return 0;
if (n > metadata.count - metadata.bothways)
@@ -133,6 +147,7 @@ _.extend(Way.prototype, {
if (!this.tags.highway) return null;
var metadata = {};
var lanesArray = [];
// fill metadata.count with default count
switch (this.tags.highway) {
@@ -147,8 +162,13 @@ _.extend(Way.prototype, {
if (this.tags.lanes) metadata.count = parseInt(this.tags.lanes);
for (var i = 0; i < metadata.count; i++) {
lanesArray.push({ index: i});
}
metadata.oneway = this.isOneWay();
// fill metadata with safe forward, backward, bothways values.
if (parseInt(this.tags.oneway) === -1) {
metadata.forward = 0;
metadata.bothways = 0;
@@ -158,19 +178,20 @@ _.extend(Way.prototype, {
metadata.forward = metadata.count;
metadata.bothways = 0;
metadata.backward = 0;
} else {
}
else {
// bothways is forced to always be either 1 or 0.
metadata.bothways = parseInt(this.tags['lanes:both_ways']) > 0 ? 1 : 0;
metadata.forward = parseInt(this.tags['lanes:forward']);
metadata.backward = parseInt(this.tags['lanes:backward']);
if (_.isNaN(metadata.forward) && _.isNaN(metadata.backward)) {
metadata.forward = parseInt((metadata.count - metadata.bothways) / 2);
metadata.backward = metadata.count - metadata.bothways - metadata.forward;
metadata.backward = parseInt((metadata.count - metadata.bothways) / 2);
metadata.forward = metadata.count - metadata.bothways - metadata.backward;
}
else if (_.isNaN(metadata.forward)) {
metadata.backward = safeValue(metadata.backward);
metadata.forward = metadata.count - metadata.bothways - metadata.backward;
}
else if (_.isNaN(metadata.backward)) {
metadata.forward = safeValue(metadata.forward);
@@ -178,9 +199,38 @@ _.extend(Way.prototype, {
}
}
for (i = 0; i < metadata.count; i++) {
if (i < metadata.forward)
lanesArray[i].direction = 'forward';
else if (i < metadata.forward + metadata.bothways)
lanesArray[i].direction = 'bothways';
else
lanesArray[i].direction = 'backward';
}
// parse turn:lanes:forward/backward first
if (!metadata.oneway && this.tags['turn:lanes:forward'] && this.tags['turn:lanes:backward']) {
metadata.turnLanesForward = getTurns(this.tags['turn:lanes:forward'], metadata.forward);
metadata.turnLanesBackward = getTurns(this.tags['turn:lanes:backward'], metadata.backward);
// set turnLane for each lanesArray item, except for bothways.
metadata.turnLanesForward.forEach(function(l, i) {
lanesArray[i].turnLane = l;
});
metadata.turnLanesBackward.forEach(function(l, i) {
lanesArray[i + metadata.forward + metadata.bothways].turnLane = l;
});
}
else if (this.tags['turn:lanes']) {
metadata.turnLanes = getTurns(this.tags['turn:lanes'], metadata.count);
metadata.turnLanes.forEach(function(l, i) {
lanesArray[i].turnLane = l;
});
}
return {
metadata: metadata,
lanes: makeLanesArray(metadata)
lanes: lanesArray
};
},
test/spec/core/way.js
+371 -32
View File
@@ -756,7 +756,7 @@ describe('iD.Way', function() {
});
describe('oneway tags', function() {
it('correctly returns oneway when tagged as oneway', function() {
it('returns correctlys oneway when tagged as oneway', function() {
expect(iD.Way({tags: { highway: 'residential', oneway: 'yes' }}).lanes().metadata.oneway, 'residential lanes')
.to.be.true;
expect(iD.Way({tags: { highway: 'residential', oneway: 'no' }}).lanes().metadata.oneway, 'residential lanes')
@@ -765,9 +765,9 @@ describe('iD.Way', function() {
});
describe('lane direction', function() {
it('correctly returns the lane:forward and lane:backward count', function() {
it('returns correctlys the lane:forward and lane:backward count', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 2,
oneway: false,
forward: 1,
@@ -775,7 +775,7 @@ describe('iD.Way', function() {
bothways: 0
});
expect(iD.Way({tags: { highway: 'residential', lanes: 4, 'lanes:forward': 3, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 4,
oneway: false,
forward: 3,
@@ -783,9 +783,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns count under total count if erroneous values are supplied', function() {
it('returns correctlys count under total count if erroneous values are supplied', function() {
expect(iD.Way({tags: { highway: 'trunk', lanes: 2, 'lanes:forward': 3 }}).lanes().metadata, 'trunk lanes')
.to.eql({
.to.include({
count: 2,
oneway: false,
forward: 2,
@@ -793,9 +793,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns forward count when oneway=yes', function() {
it('returns correctlys forward count when oneway=yes', function() {
expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes' }}).lanes().metadata, 'trunk lanes')
.to.eql({
.to.include({
count: 2,
oneway: true,
forward: 2,
@@ -803,9 +803,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns backward count the when oneway=-1', function() {
it('returns correctlys backward count the when oneway=-1', function() {
expect(iD.Way({tags: { highway: 'primary', lanes: 4, oneway: '-1' }}).lanes().metadata, 'primary lanes')
.to.eql({
.to.include({
count: 4,
oneway: true,
backward: 4,
@@ -815,7 +815,7 @@ describe('iD.Way', function() {
});
it('skips provided lanes:forward value when oneway=yes', function() {
expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:forward': 1 }}).lanes().metadata, 'trunk lanes')
.to.eql({
.to.include({
count: 2,
oneway: true,
forward: 2,
@@ -825,7 +825,7 @@ describe('iD.Way', function() {
});
it('skips provided lanes:backward value when oneway=yes', function() {
expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:backward': 1 }}).lanes().metadata, 'trunk lanes')
.to.eql({
.to.include({
count: 2,
oneway: true,
forward: 2,
@@ -833,9 +833,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns forward count if only backward is supplied', function() {
it('returns correctlys forward count if only backward is supplied', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 3,
oneway: false,
forward: 2,
@@ -843,7 +843,7 @@ describe('iD.Way', function() {
bothways: 0
});
expect(iD.Way({tags: { highway: 'residential', lanes: 4, 'lanes:backward': 3, }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 4,
oneway: false,
forward: 1,
@@ -851,9 +851,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns backward count if only forward is supplied', function() {
it('returns correctlys backward count if only forward is supplied', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 3,
oneway: false,
forward: 1,
@@ -861,7 +861,7 @@ describe('iD.Way', function() {
bothways: 0
});
expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 2,
oneway: false,
forward: 1,
@@ -869,9 +869,9 @@ describe('iD.Way', function() {
bothways: 0
});
});
it('correctly returns backward count if forward and both_ways are supplied', function() {
it('returns correctlys backward count if forward and both_ways are supplied', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 3,
oneway: false,
forward: 1,
@@ -879,7 +879,7 @@ describe('iD.Way', function() {
bothways: 1
});
expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 5,
oneway: false,
forward: 1,
@@ -887,9 +887,9 @@ describe('iD.Way', function() {
bothways: 1
});
});
it('correctly returns forward count if backward and both_ways are supplied', function() {
it('returns correctlys forward count if backward and both_ways are supplied', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 3,
oneway: false,
forward: 1,
@@ -897,7 +897,7 @@ describe('iD.Way', function() {
bothways: 1
});
expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 5,
oneway: false,
forward: 3,
@@ -906,9 +906,9 @@ describe('iD.Way', function() {
});
});
it('correctly returns the lane:both_ways count as 1', function() {
it('returns correctlys the lane:both_ways count as 1', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 2,
oneway: false,
forward: 1,
@@ -916,9 +916,9 @@ describe('iD.Way', function() {
bothways: 1
});
});
it('correctly returns when lane:both_ways>1', function() {
it('returns correctlys when lane:both_ways>1', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 2, 'lanes:backward': 2 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 5,
oneway: false,
forward: 2,
@@ -926,9 +926,9 @@ describe('iD.Way', function() {
bothways: 1
});
});
it('correctly returns when lane:both_ways is 0 or Not a Number', function() {
it('returns correctlys when lane:both_ways is 0 or Not a Number', function() {
expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 5,
oneway: false,
forward: 2,
@@ -936,7 +936,7 @@ describe('iD.Way', function() {
bothways: 0
});
expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 'none' }}).lanes().metadata, 'residential lanes')
.to.eql({
.to.include({
count: 2,
oneway: false,
forward: 1,
@@ -946,7 +946,7 @@ describe('iD.Way', function() {
});
});
describe.only('lanes array', function() {
describe('lanes array', function() {
it('should have correct number of direction elements', function() {
var lanes = iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().lanes;
var forward = lanes.filter(function(l) {
@@ -979,5 +979,344 @@ describe('iD.Way', function() {
expect(bothways.length).to.eql(1);
});
});
describe.only('turn lanes', function() {
it('returns correctly when oneway=yes', function() {
var metadata = iD.Way({
tags: {
highway: 'trunk',
oneway: 'yes',
'turn:lanes': 'none|slight_right'
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([
['none'], ['slight_right']
]);
});
it('returns correctly when oneway=yes and lanes=2', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
oneway: 'yes',
lanes: '2',
'turn:lanes': 'none|slight_right'
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([
['none'], ['slight_right']
]);
});
it('returns correctly when lanes=5 and both_ways=1', function() {
var metadata = iD.Way({
tags: {
highway: 'residential',
lanes: 5,
'lanes:forward': 1,
'lanes:both_ways': 1,
'turn:lanes:forward': 'slight_left',
'turn:lanes:backward': 'none|through|through;slight_right',
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.deep.equal([
['slight_left']
]);
expect(metadata.turnLanesBackward)
.to.deep.equal([
['none'], ['through'], ['through', 'slight_right']
]);
});
it('returns correctly when multiple values are present in a lane and oneway=yes', function() {
var lanesData = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'yes',
'turn:lanes': 'slight_left;reverse;left|slight_left;left;through|through|none|through;right',
}
}).lanes();
expect(lanesData.metadata.turnLanes)
.to.deep.equal([
['slight_left', 'reverse', 'left'],
['slight_left', 'left', 'through'],
['through'],
['none'],
['through', 'right']
]);
expect(lanesData.lanes.map(function(l) { return l.turnLane; }))
.to.deep.equal([
['slight_left', 'reverse', 'left'],
['slight_left', 'left', 'through'],
['through'],
['none'],
['through', 'right']
]);
});
it('returns correctly when multiple values are present in a lane and oneway=no', function() {
var lanesData = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'no',
'lanes:forward': 3,
'lanes:backward': 2,
'turn:lanes:forward': 'slight_left;reverse;left|slight_left;left;through|through',
'turn:lanes:backward': 'none|through;left'
}
}).lanes();
expect(lanesData.metadata.turnLanesForward)
.to.deep.equal([
['slight_left', 'reverse', 'left'],
['slight_left', 'left', 'through'],
['through']
]);
expect(lanesData.metadata.turnLanesBackward)
.to.deep.equal([
['none'],
['through', 'left']
]);
expect(lanesData.lanes.map(function(l) { return l.turnLane; }))
.to.deep.equal([
['slight_left', 'reverse', 'left'],
['slight_left', 'left', 'through'],
['through'],
['none'],
['through', 'left']
]);
});
it('fills with [\'none\'] when given turn:lanes are less than lanes count', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'yes',
'turn:lanes': 'slight_left',
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([
['slight_left'], ['none'], ['none'], ['none'], ['none']
]);
});
it('fills with [\'none\'] when given turn:lanes:forward are less than lanes forward count', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'no',
'lanes:forward': 3,
'turn:lanes:forward': 'slight_left',
'turn:lanes:backward': 'through',
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.deep.equal([
['slight_left'], ['none'], ['none']
]);
expect(metadata.turnLanesBackward)
.to.deep.equal([
['through'], ['none']
]);
});
it('clips when turn lane information is more than lane count', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 2,
oneway: 'yes',
'turn:lanes': 'through|through;slight_right|slight_right',
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([
['through'], ['through', 'slight_right']
]);
});
it('turnLanes is undefined when not present', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 2,
oneway: 'yes'
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.equal(undefined);
expect(metadata.turnLanesForward)
.to.equal(undefined);
expect(metadata.turnLanesBackward)
.to.equal(undefined);
});
it('turnLanesForward and turnLanesBackward are both undefined when both are not provided', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 2,
oneway: 'yes',
'turn:lanes': 'through|through;slight_right',
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([['through'], ['through', 'slight_right']]);
expect(metadata.turnLanesForward)
.to.equal(undefined);
expect(metadata.turnLanesBackward)
.to.equal(undefined);
});
it('turnLanesForward and turnLanesBackward are both undefined when either is provided', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 2,
'turn:lanes:backward': 'none',
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.equal(undefined);
expect(metadata.turnLanesBackward)
.to.equal(undefined);
});
it('turnLanesForward and turnLanesBackward are both undefined when oneway="yes"', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 2,
oneway: 'yes',
'turn:lanes:forward': 'through',
'turn:lanes:backward': 'none'
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.equal(undefined);
expect(metadata.turnLanesBackward)
.to.equal(undefined);
});
it('parses correctly when turn:lanes= ||x', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 3,
oneway: 'yes',
'turn:lanes': '||through;slight_right',
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([['none'], ['none'], ['through', 'slight_right']]);
});
it('parses correctly when turn:lanes= |x|', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
'turn:lanes': '|through|',
}
}).lanes().metadata;
expect(metadata.turnLanes)
.to.deep.equal([['none'], ['through'], ['none'], ['none'], ['none']]);
});
it('parses correctly when turn:lanes:forward= ||x', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 4,
oneway: 'no',
'lanes:forward': 3,
'lanes:backward': 1,
'turn:lanes:forward': '||through;slight_right',
'turn:lanes:backward': 'none',
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.deep.equal([['none'], ['none'], ['through', 'slight_right']]);
expect(metadata.turnLanesBackward)
.to.deep.equal([['none']]);
});
it('parses correctly when turn:lanes:backward= |', function() {
var metadata = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'no',
'lanes:forward': 3,
'lanes:backward': 2,
'turn:lanes:backward': '|',
'turn:lanes:forward': 'slight_left||',
}
}).lanes().metadata;
expect(metadata.turnLanesForward)
.to.deep.equal([['slight_left'], ['none'], ['none']]);
expect(metadata.turnLanesBackward)
.to.deep.equal([['none'], ['none']]);
});
it('fills turnLane correctly in lanes', function() {
var lanes = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
'lanes:forward': 3,
'lanes:backward': 2,
'turn:lanes:backward': 'none|slight_right',
'turn:lanes:forward': 'slight_left||',
}
}).lanes().lanes;
var turnLanes = lanes.map(function(l) { return l.turnLane; });
expect(turnLanes).to.deep.equal([
['slight_left'], ['none'], ['none'], ['none'], ['slight_right']
]);
});
it('fills turnLane correctly in lanes when lanes:both_ways=1', function() {
var lanes = iD.Way({
tags: {
highway: 'tertiary',
lanes: 5,
oneway: 'no',
'lanes:forward': 3,
'lanes:both_ways': 1,
'lanes:backward': 1,
'turn:lanes:backward': 'slight_right',
'turn:lanes:forward': 'slight_left||',
}
}).lanes().lanes;
var turnLanes = lanes.map(function(l) { return l.turnLane; });
expect(turnLanes).to.deep.equal([
['slight_left'], ['none'], ['none'], undefined, ['slight_right']
]);
});
});
});
});