pgRouting

Navigation

← Previous Changeset
Next Changeset →

Changeset 84

Timestamp:

12/20/07 15:26:53 (1 year ago)

Author:

anton

Message:

--

Files:

sandbox/orkney/algorithm.h (modified) (2 diffs)
sandbox/orkney/astar.h (modified) (1 diff)
sandbox/orkney/dijkstra.h (modified) (3 diffs)
sandbox/orkney/shootingstar.h (modified) (8 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

sandbox/orkney/algorithm.h

r83	r84
32	32	#define MAX_NODES 1000000
33	33
34		#define ID_F~~EATURE~~ "id"
35		#define COST_F~~EATURE~~ "cost"
36		#define WEIGHT_F~~EATURE~~ "weight"
37		#define RC_F~~EATURE~~ "reverse_cost"
	34	#define ID_FIELD "id"
	35	#define COST_FIELD "cost"
	36	#define WEIGHT_FIELD "weight"
	37	#define RC_FIELD "reverse_cost"
38	38
39		#define SOURCE_F~~EATURE~~ "source"
40		#define TARGET_F~~EATURE~~ "target"
	39	#define SOURCE_FIELD "source"
	40	#define TARGET_FIELD "target"
41	41
42		#define TO_COST_F~~EATURE~~ "to_cost"
43		#define RULE_F~~EATURE~~ "rule"
	42	#define TO_COST_FIELD "to_cost"
	43	#define RULE_FIELD "rule"
44	44
45	45	#define EXIT_SUCCESS 0
…	…
124	124	for (unsigned int z = 0; z < count; ++z)
125	125	{
126		if(edges[z]->GetFieldAsInteger(ID_F~~EATURE~~) > e_max_id)
127		e_max_id=edges[z]->GetFieldAsInteger(ID_F~~EATURE~~);
	126	if(edges[z]->GetFieldAsInteger(ID_FIELD) > e_max_id)
	127	e_max_id=edges[z]->GetFieldAsInteger(ID_FIELD);
128	128	}
129	129

sandbox/orkney/astar.h

r83	r84
88	88	bool inserted;
89	89
90		if (edge->GetFieldAsDouble(COST_F~~EATURE~~) < 0) // edges are not inserted in the graph if cost is negative
	90	if (edge->GetFieldAsDouble(COST_FIELD) < 0) // edges are not inserted in the graph if cost is negative
91	91	return false;
92	92
93		tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_F~~EATURE~~),
94		edge->GetFieldAsInteger(TARGET_F~~EATURE~~), graph);
	93	tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_FIELD),
	94	edge->GetFieldAsInteger(TARGET_FIELD), graph);
95	95
96		graph[*e].cost = edge->GetFieldAsDouble(COST_F~~EATURE~~);
97		graph[*e].id = edge->GetFieldAsInteger(ID_F~~EATURE~~);
	96	graph[*e].cost = edge->GetFieldAsDouble(COST_FIELD);
	97	graph[*e].id = edge->GetFieldAsInteger(ID_FIELD);
98	98
99	99	OGRLineString geom = static_cast<OGRLineString>(edge->GetGeometryRef());
100	100
101		vertex_descriptor s = vertex(edge->GetFieldAsInteger(SOURCE_F~~EATURE~~), graph);
102		vertex_descriptor t = vertex(edge->GetFieldAsInteger(TARGET_F~~EATURE~~), graph);
	101	vertex_descriptor s = vertex(edge->GetFieldAsInteger(SOURCE_FIELD), graph);
	102	vertex_descriptor t = vertex(edge->GetFieldAsInteger(TARGET_FIELD), graph);
103	103
104	104	graph[s].x=geom->getX(0);

sandbox/orkney/dijkstra.h

r81	r84
50	50	bool inserted;
51	51
52		tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_F~~EATURE~~),
53		edge->GetFieldAsInteger(TARGET_F~~EATURE~~), graph);
	52	tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_FIELD),
	53	edge->GetFieldAsInteger(TARGET_FIELD), graph);
54	54	return inserted;
55	55	}
…	…
59	59	bool inserted = addEdge(e, edges[j], graph);
60	60
61		graph[*e].cost = edges[j]->GetFieldAsDouble(COST_F~~EATURE~~);//set cost
	61	graph[*e].cost = edges[j]->GetFieldAsDouble(COST_FIELD);//set cost
62	62	graph[*e].id = j;//set id
63	63
…	…
73	73	if (HasReverseCost())
74	74	{
75		graph[*er].cost = edges[j]->GetFieldAsDouble(RC_F~~EATURE~~);//set reverse cost
	75	graph[*er].cost = edges[j]->GetFieldAsDouble(RC_FIELD);//set reverse cost
76	76	}
77	77	else
78	78	{
79		graph[*er].cost = edges[j]->GetFieldAsDouble(COST_F~~EATURE~~);//set cost
	79	graph[*er].cost = edges[j]->GetFieldAsDouble(COST_FIELD);//set cost
80	80	}
81	81	}

sandbox/orkney/shootingstar.h

r81	r84
112	112	bool inserted;
113	113
114		if (edge->GetFieldAsDouble(COST_F~~EATURE~~) < 0) // edges are inserted as unpassable if cost is negative
115		edge->SetField(COST_F~~EATURE~~, MAX_COST);
116
117		tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_F~~EATURE~~),
118		edge->GetFieldAsInteger(TARGET_F~~EATURE~~), graph);
119
120		graph[*e].cost = edge->GetFieldAsDouble(COST_F~~EATURE~~);
121		graph[*e].id = edge->GetFieldAsInteger(ID_F~~EATURE~~);
122
123		graph[*e].source = edge->GetFieldAsInteger(SOURCE_F~~EATURE~~);
124		graph[*e].target = edge->GetFieldAsInteger(TARGET_F~~EATURE~~);
	114	if (edge->GetFieldAsDouble(COST_FIELD) < 0) // edges are inserted as unpassable if cost is negative
	115	edge->SetField(COST_FIELD, MAX_COST);
	116
	117	tie(*e, inserted) = add_edge(edge->GetFieldAsInteger(SOURCE_FIELD),
	118	edge->GetFieldAsInteger(TARGET_FIELD), graph);
	119
	120	graph[*e].cost = edge->GetFieldAsDouble(COST_FIELD);
	121	graph[*e].id = edge->GetFieldAsInteger(ID_FIELD);
	122
	123	graph[*e].source = edge->GetFieldAsInteger(SOURCE_FIELD);
	124	graph[*e].target = edge->GetFieldAsInteger(TARGET_FIELD);
125	125
126	126	graph[*e].adjacent_edges = adjacent_edges;
…	…
131	131	OGRLineString geom = static_cast<OGRLineString>(edge->GetGeometryRef());
132	132
133		vertex_descriptor s = vertex(edge->GetFieldAsInteger(SOURCE_F~~EATURE~~), graph);
134		vertex_descriptor t = vertex(edge->GetFieldAsInteger(TARGET_F~~EATURE~~), graph);
135
136		graph[s].id = edge->GetFieldAsInteger(SOURCE_F~~EATURE~~);
137		graph[t].id = edge->GetFieldAsInteger(TARGET_F~~EATURE~~);
	133	vertex_descriptor s = vertex(edge->GetFieldAsInteger(SOURCE_FIELD), graph);
	134	vertex_descriptor t = vertex(edge->GetFieldAsInteger(TARGET_FIELD), graph);
	135
	136	graph[s].id = edge->GetFieldAsInteger(SOURCE_FIELD);
	137	graph[t].id = edge->GetFieldAsInteger(TARGET_FIELD);
138	138
139	139	graph[s].x=geom->getX(0);
…	…
150	150
151	151	//Vertex ids renumbering moved here
152		src = edges[j]->GetFieldAsInteger(SOURCE_F~~EATURE~~);
153		trg = edges[j]->GetFieldAsInteger(TARGET_F~~EATURE~~);
	152	src = edges[j]->GetFieldAsInteger(SOURCE_FIELD);
	153	trg = edges[j]->GetFieldAsInteger(TARGET_FIELD);
154	154
155	155	if(vertices[src]==0)
…	…
157	157	vertices[src]=j+offset;
158	158	}
159		edges[j]->SetField(SOURCE_F~~EATURE~~, vertices[src]);
	159	edges[j]->SetField(SOURCE_FIELD, vertices[src]);
160	160
161	161	if(vertices[trg]==0)
…	…
164	164	vertices[trg]=j+offset;
165	165	}
166		edges[j]->SetField(TARGET_F~~EATURE~~, vertices[trg]);
	166	edges[j]->SetField(TARGET_FIELD, vertices[trg]);
167	167
168	168	int *rule_cnt;
169	169	const int *rule_list;
170	170
171		rule_list = edges[j]->GetFieldAsIntegerList(RULE_F~~EATURE~~, rule_cnt);
	171	rule_list = edges[j]->GetFieldAsIntegerList(RULE_FIELD, rule_cnt);
172	172
173	173	for(int z=0; z< *rule_cnt;++z)
…	…
179	179	}
180	180
181		if(edges[j]->GetFieldAsDouble(TO_COST_F~~EATURE~~) > 0)
182		{
183		adjacent_edges[edges[j]->GetFieldAsInteger(ID_F~~EATURE~~)].push_back(
184		std::pair<double, vector<int> > (edges[j]->GetFieldAsDouble(TO_COST_F~~EATURE~~), rule) );
	181	if(edges[j]->GetFieldAsDouble(TO_COST_FIELD) > 0)
	182	{
	183	adjacent_edges[edges[j]->GetFieldAsInteger(ID_FIELD)].push_back(
	184	std::pair<double, vector<int> > (edges[j]->GetFieldAsDouble(TO_COST_FIELD), rule) );
185	185	rule.clear();
186	186	}
187	187
188		if((j < count-1 && edges[j]->GetFieldAsInteger(ID_F~~EATURE) != edges[j+1]->GetFieldAsInteger(ID_FEATURE~~))\|\|(j==count-1))
	188	if((j < count-1 && edges[j]->GetFieldAsInteger(ID_FIELD) != edges[j+1]->GetFieldAsInteger(ID_FIELD))\|\|(j==count-1))
189	189	{
190	190
191	191	bool inserted = addEdge(e, edges[j], graph);
192	192
193		graph[*e].cost = edges[j]->GetFieldAsDouble(COST_F~~EATURE~~);//set cost
	193	graph[*e].cost = edges[j]->GetFieldAsDouble(COST_FIELD);//set cost
194	194	graph[*e].id = j;//set id
195	195
…	…
198	198	{
199	199
200		if(adjacent_edges[edges[j]->GetFieldAsInteger(ID_F~~EATURE~~)].size() > 0)
	200	if(adjacent_edges[edges[j]->GetFieldAsInteger(ID_FIELD)].size() > 0)
201	201	{
202		adjacent_edges[edges[j]->GetFieldAsInteger(ID_F~~EATURE~~)+e_max_id].assign(
203		adjacent_edges[edges[j]->GetFieldAsInteger(ID_F~~EATURE~~)].begin(),
204		adjacent_edges[edges[j]->GetFieldAsInteger(ID_F~~EATURE~~)].end() );
205		adjacent_edges.erase(edges[j]->GetFieldAsInteger(ID_F~~EATURE~~));
	202	adjacent_edges[edges[j]->GetFieldAsInteger(ID_FIELD)+e_max_id].assign(
	203	adjacent_edges[edges[j]->GetFieldAsInteger(ID_FIELD)].begin(),
	204	adjacent_edges[edges[j]->GetFieldAsInteger(ID_FIELD)].end() );
	205	adjacent_edges.erase(edges[j]->GetFieldAsInteger(ID_FIELD));
206	206	}
207	207
…	…
214	214	if (HasReverseCost())
215	215	{
216		graph[*er].cost = edges[j]->GetFieldAsDouble(RC_F~~EATURE~~);//set reverse cost
	216	graph[*er].cost = edges[j]->GetFieldAsDouble(RC_FIELD);//set reverse cost
217	217	}
218	218	else
219	219	{
220		graph[*er].cost = edges[j]->GetFieldAsDouble(COST_F~~EATURE~~);//set cost
	220	graph[*er].cost = edges[j]->GetFieldAsDouble(COST_FIELD);//set cost
221	221	}
222	222

Download in other formats: