bool ArcNet::Parking_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Parking_Data *parking_ptr;
Parking_File *file = (Parking_File *) fh;
if (First_Record ()) {
arcview_parking.Num_Points (1);
if (!parking_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Parking Points");
}
}
if (Network_Service::Parking_Processing (file)) {
arcview_parking.Copy_Fields (file);
parking_ptr = parking_data.New_Record ();
if (select_time) {
if (!time_range.Span_Range (parking_ptr->Start (), parking_ptr->End ())) return (false);
}
link = parking_ptr->Link ();
dir = parking_ptr->Dir ();
offset = UnRound (parking_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, parking_side);
pt_ptr = points [1];
arcview_parking.points.Set (1, pt_ptr);
if (!arcview_parking.Write_Record ()) {
Error ("Writing ArcView Parking File");
}
//---- save the parking offset data ----
offset_rec.ID (parking_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!parking_offset.Add (&offset_rec)) {
Error ("Saving Parking Offsets");
}
}
return (false);
}
bool ArcPlan::Get_Location_Data (Location_File &file, Location_Data &location_rec)
{
int link, dir, index;
double offset, setback, side;
Point_Map_Stat map_stat;
Link_Data *link_ptr;
if (Data_Service::Get_Location_Data (file, location_rec)) {
link = location_rec.Link ();
dir = location_rec.Dir ();
offset = UnRound (location_rec.Offset ());
setback = UnRound (location_rec.Setback ());
side = location_side;
if (setback > side) side = setback;
link_ptr = &link_array [link];
if (lanes_flag) {
bool dir_flag;
int center, num_lanes;
Dir_Data *dir_ptr;
if (dir == 0) {
index = link_ptr->AB_Dir ();
dir_flag = (link_ptr->BA_Dir () >= 0);
} else {
index = link_ptr->BA_Dir ();
dir_flag = (link_ptr->AB_Dir () >= 0);
}
if (index >= 0) {
dir_ptr = &dir_array [index];
num_lanes = dir_ptr->Lanes () + dir_ptr->Left () + dir_ptr->Right ();
} else {
num_lanes = 0;
}
if (center_flag && !dir_flag) {
center = num_lanes + 1;
} else {
center = 1;
}
side += (2 * num_lanes - center) * lane_width / 2.0;
}
Link_Shape (link_ptr, dir, points, offset, 0.0, side);
//---- save the location point data ----
map_stat = location_pt.insert (Point_Map_Data (location_rec.Location (), points [0]));
if (!map_stat.second) {
Warning ("Duplicate Location Record = ") << location_rec.Location ();
}
return (true);
}
return (false);
}
bool ArcNet::Location_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Location_Data *location_ptr;
Location_File *file = (Location_File *) fh;
if (First_Record ()) {
arcview_location.Num_Points (1);
if (!location_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Location Points");
}
}
if (Network_Service::Location_Processing (file)) {
arcview_location.Copy_Fields (file);
location_ptr = location_data.New_Record ();
link = location_ptr->Link ();
dir = location_ptr->Dir ();
offset = UnRound (location_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, location_side);
pt_ptr = points [1];
arcview_location.points.Set (1, pt_ptr);
if (!arcview_location.Write_Record ()) {
Error ("Writing ArcView Activity Location File");
}
//---- save the location offset data ----
offset_rec.ID (location_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!location_offset.Add (&offset_rec)) {
Error ("Saving Activity Location Offsets");
}
}
return (false);
}
bool ArcPlan::Get_Parking_Data (Parking_File &file, Parking_Data &parking_rec)
{
int link, dir, index;
double offset, side;
Point_Map_Stat map_stat;
Link_Data *link_ptr;
if (Data_Service::Get_Parking_Data (file, parking_rec)) {
if (!file.Nested ()) {
link = parking_rec.Link ();
dir = parking_rec.Dir ();
offset = UnRound (parking_rec.Offset ());
side = parking_side;
link_ptr = &link_array [link];
if (lanes_flag) {
bool dir_flag;
int center, num_lanes;
Dir_Data *dir_ptr;
if (dir == 0) {
index = link_ptr->AB_Dir ();
dir_flag = (link_ptr->BA_Dir () >= 0);
} else {
index = link_ptr->BA_Dir ();
dir_flag = (link_ptr->AB_Dir () >= 0);
}
if (index >= 0) {
dir_ptr = &dir_array [index];
num_lanes = dir_ptr->Lanes () + dir_ptr->Left () + dir_ptr->Right ();
} else {
num_lanes = 0;
}
if (center_flag && !dir_flag) {
center = num_lanes + 1;
} else {
center = 1;
}
side += (2 * num_lanes - center) * lane_width / 2.0;
}
Link_Shape (link_ptr, dir, points, offset, 0.0, side);
//---- save the parking point data ----
map_stat = parking_pt.insert (Point_Map_Data (parking_rec.Parking (), points [0]));
if (!map_stat.second && file.Version () > 40) {
Warning ("Duplicate Parking Record = ") << parking_rec.Parking ();
}
}
return (true);
}
return (false);
}
bool SideFriction::Stop_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Stop_Data *stop_ptr;
Stop_File *file = (Stop_File *) fh;
if (First_Record () && subarea_flag) {
if (!stop_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Transit Stop Points");
}
}
if (Network_Service::Stop_Processing (file)) {
if (subarea_flag) {
stop_ptr = stop_data.New_Record ();
link = stop_ptr->Link ();
dir = stop_ptr->Dir ();
offset = UnRound (stop_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, 2.0);
pt_ptr = points [1];
//---- save the stop offset data ----
offset_rec.ID (stop_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!stop_offset.Add (&offset_rec)) {
Error ("Saving Transit Stop Offsets");
}
}
return (true);
}
return (false);
}
void ArcPlan::Write_Route (Offset_Data *org_ptr, Offset_Data *des_ptr)
{
int i, j, route, num_legs, stop, link_dir, dir;
int start_link_dir, end_link_dir;
double offset, length, link_len, side;
bool offset_flag, board, alight;
Link_Data *link_ptr;
Line_Data *line_ptr;
Driver_Data *driver_ptr;
Offset_Data *stop_ptr;
offset_flag = (route_offset != 0.0);
side = 0.0;
//---- get the route data ----
route = plan_file.Route ();
line_ptr = line_data.Get (route);
if (line_ptr == NULL) {
Warning ("Transit Route %d was Not Found", route);
return;
}
board = alight = false;
//---- create the route shape ----
if (driver_flag) {
//---- get the start and end link offsets ----
start_link_dir = org_ptr->Link_Dir ();
end_link_dir = des_ptr->Link_Dir ();
//---- get the route links ----
driver_ptr = driver_data [line_ptr->Driver ()];
num_legs = driver_ptr->Links ();
//---- create transit legs ----
for (i=1; i <= num_legs; i++) {
dir = driver_ptr->Dir (i);
link_dir = driver_ptr->Link_Dir (i);
link_ptr = link_data.Get (driver_ptr->Link (i));
link_len = UnRound (link_ptr->Length ());
length = link_len - 2 * route_offset;
if (dir == 0) {
offset = route_offset;
} else {
offset = link_len - route_offset;
}
if (!board) {
if (start_link_dir != link_dir) continue;
offset = org_ptr->Offset ();
if (dir == 0) {
length = link_len - offset - route_offset;
} else {
length = offset - route_offset;
}
}
if (end_link_dir == link_dir) {
alight = true;
if (dir == 0) {
length = des_ptr->Offset () - offset;
} else {
length = offset - des_ptr->Offset ();
}
}
if (offset_flag) {
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = route_offset;
} else {
side = 0.0;
}
}
Link_Shape (link_ptr, dir, &points, offset, length, side);
//---- draw the link segment ----
if (side == 0.0 && !board) {
j = 2;
} else {
j = 1;
}
for (; j <= points.Num_Points (); j++) {
if (!arcview_plan.points.Add (points [j])) goto point_error;
}
board = true;
if (alight == true) break;
}
} else {
for (i=1; i <= line_ptr->Stops (); i++) {
stop = line_ptr->Stop (i);
if (!board) {
if (org_ptr->ID () != stop) continue;
board = true;
stop_ptr = org_ptr;
} else {
stop_ptr = stop_offset.Get (stop);
if (stop_ptr == NULL) goto stop_error;
}
link_ptr = link_data.Get (stop_ptr->Link ());
offset = stop_ptr->Offset ();
if (offset_flag) {
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = route_offset;
} else {
side = 0.0;
}
}
Link_Shape (link_ptr, stop_ptr->Dir (), &points, offset, 0.0, side);
if (!arcview_plan.points.Add (points [1])) goto point_error;
if (des_ptr->ID () == stop) {
alight = true;
break;
}
}
}
if (board == false || alight == false) {
Warning ("Stops %d to %d were Not Found on Route %d", org_ptr->ID (), des_ptr->ID (), route);
}
return;
point_error:
Error ("Insufficient Memory for %d Points", arcview_plan.points.Num_Points ());
stop_error:
Warning ("Route %d Stop %d was Not Found in the Stop File", line_ptr->Route (), stop);
}
bool ArcPlan::Get_Problem_Data (Problem_File &file, Problem_Data &problem_rec, int partition)
{
Location_Data *loc_ptr;
Trip_Index trip_index;
if (Data_Service::Get_Problem_Data (file, problem_rec, partition)) {
if (select_problems && !problem_range.In_Range (problem_rec.Problem ())) return (false);
if (select_households && !hhold_range.In_Range (problem_rec.Household ())) return (false);
if (problem_rec.Mode () < MAX_MODE && !select_mode [problem_rec.Mode ()]) return (false);
if (select_purposes && !purpose_range.In_Range (problem_rec.Purpose ())) return (false);
if (select_start_times && !start_range.In_Range (problem_rec.Start ())) return (false);
if (select_end_times && !end_range.In_Range (problem_rec.End ())) return (false);
if (select_origins && !org_range.In_Range (file.Origin ())) return (false);
if (select_destinations && !des_range.In_Range (file.Destination ())) return (false);
if (select_org_zones) {
loc_ptr = &location_array [problem_rec.Origin ()];
if (!org_zone_range.In_Range (loc_ptr->Zone ())) return (false);
}
if (select_des_zones) {
loc_ptr = &location_array [problem_rec.Destination ()];
if (!des_zone_range.In_Range (loc_ptr->Zone ())) return (false);
}
if (select_travelers && !traveler_range.In_Range (problem_rec.Type ())) return (false);
//---- check the selection records ----
if (System_File_Flag (SELECTION)) {
Select_Map_Itr sel_itr;
sel_itr = select_map.Best (problem_rec.Household (), problem_rec.Person (), problem_rec.Tour (), problem_rec.Trip ());
if (sel_itr == select_map.end ()) return (false);
}
//---- draw the problem record ----
if (problem_out) {
XYZ_Point point;
arcview_problem.clear ();
arcview_problem.Copy_Fields (file);
if (problem_method == 3) {
if (file.Link () > 0 && problem_rec.Dir_Index () >= 0) {
int lane, center;
double side;
Dir_Data *dir_ptr = &dir_array [problem_rec.Dir_Index ()];
Link_Data *link_ptr = &link_array [dir_ptr->Link ()];
lane = problem_rec.Lane () + 1;
if (center_flag) {
if (link_ptr->BA_Dir () < 0) {
center = dir_ptr->Left () + dir_ptr->Lanes () + dir_ptr->Right () + 1;
} else if (link_ptr->AB_Dir () < 0) {
center = dir_ptr->Left () + dir_ptr->Lanes () + dir_ptr->Right () + 1;
} else {
center = 1;
}
} else {
center = 1;
}
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, dir_ptr->Dir (), points, UnRound (problem_rec.Offset ()), 0.0, side);
arcview_problem.assign (1, points [0]);
} else {
loc_ptr = &location_array [problem_rec.Origin ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
} else if (problem_method < 2) {
loc_ptr = &location_array [problem_rec.Origin ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
if (problem_method != 1) {
loc_ptr = &location_array [problem_rec.Destination ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
if (!arcview_problem.Write_Record ()) {
Error (String ("Writing %s") % arcview_problem.File_Type ());
}
num_problem++;
}
//---- save the problem index ----
if (plan_flag) {
trip_index.Set (problem_rec.Household (), problem_rec.Person (), problem_rec.Tour (), problem_rec.Trip ());
problem_map.insert (Trip_Map_Data (trip_index, problem_rec.Problem ()));
}
}
return (false);
}
void ArcNet::Draw_Route (void)
{
int i, j, num_legs, stop, stops, link_dir, dir_index, dir, overlap, runs;
int route_field, stops_field, mode_field, type_field, name_field, notes_field;
double offset, length, stop_off, link_len, side, side_offset;
bool offset_flag;
Db_Base *file;
file = System_File_Base (TRANSIT_ROUTE);
route_field = file->Required_Field (ROUTE_FIELD_NAMES);
stops_field = file->Required_Field ("STOPS", "NSTOPS", "NUM_STOPS");
mode_field = file->Required_Field (MODE_FIELD_NAMES);
type_field = file->Optional_Field ("TYPE", "VEHTYPE", "VEH_TYPE");
name_field = file->Optional_Field ("NAME", "ROUTE_NAME", "RTNAME", "DESCRIPTION");
notes_field = file->Optional_Field ("NOTES");
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Link_Itr link_itr;
Line_Itr line_itr;
XYZ_Point point;
Int_Map_Itr map_itr;
Points_Itr pt_itr;
Point_Map_Itr stop_pt_itr;
Line_Stop_Itr stop_itr;
Line_Run_Itr run_itr;
Stop_Data *stop_ptr;
Show_Message ("Draw Transit Route -- Record");
Set_Progress ();
offset_flag = (route_offset != 0.0);
side = 0.0;
stop = 1;
//---- set the overlap count ----
if (!overlap_flag) {
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
link_itr->Aoffset (0);
link_itr->Boffset (0);
}
}
//---- process each transit route ----
for (line_itr = line_array.begin (); line_itr != line_array.end (); line_itr++) {
Show_Progress ();
stops = (int) line_itr->size ();
arcview_route.Put_Field (route_field, line_itr->Route ());
arcview_route.Put_Field (mode_field, line_itr->Mode ());
arcview_route.Put_Field (type_field, line_itr->Type ());
arcview_route.Put_Field (stops_field, stops);
arcview_route.Put_Field (name_field, line_itr->Name ());
arcview_route.Put_Field (notes_field, line_itr->Notes ());
stop_itr = line_itr->begin ();
arcview_route.Put_Field ("NUM_RUNS", (int) stop_itr->size ());
//---- save the number of runs in each period ----
if (schedule_flag) {
for (i=1; i <= sched_breaks.Num_Ranges (); i++) {
runs = 0;
for (run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++) {
if (sched_breaks.In_Index (Resolve (run_itr->Schedule ())) == i) {
runs++;
}
}
arcview_route.Put_Field (run_field + i, runs);
}
}
//---- create the route shape ----
arcview_route.clear ();
if (driver_flag) {
num_legs = (int) line_itr->driver_array.size ();
arcview_route.Put_Field ("NUM_LINKS", num_legs);
//---- find the end index ----
stop_itr = --(line_itr->end ());
stop_ptr = &stop_array [stop_itr->Stop ()];
map_itr = dir_map.find (stop_ptr->Link_Dir ());
dir_index = map_itr->second;
for (i=num_legs - 1; i >= 0; i--) {
if (dir_index == line_itr->driver_array [i]) break;
}
if (i < 0) goto path_error;
num_legs = i;
//---- find the start index ----
stop_itr = line_itr->begin ();
stop_ptr = &stop_array [stop_itr->Stop ()];
map_itr = dir_map.find (stop_ptr->Link_Dir ());
dir_index = map_itr->second;
for (i=0; i <= num_legs; i++) {
if (dir_index == line_itr->driver_array [i]) break;
}
if (i > num_legs) goto path_error;
//---- create transit legs ----
for (j=1; i <= num_legs; i++) {
dir_index = line_itr->driver_array [i];
dir_ptr = &dir_array [dir_index];
dir = dir_ptr->Dir ();
link_dir = dir_ptr->Link_Dir ();
link_ptr = &link_array [dir_ptr->Link ()];
link_len = UnRound (link_ptr->Length ());
side_offset = route_offset;
if (offset_flag) {
if (!overlap_flag) {
if (dir == 0) {
overlap = link_ptr->Aoffset () + 1;
link_ptr->Aoffset (overlap);
} else {
overlap = link_ptr->Boffset () + 1;
link_ptr->Boffset (overlap);
}
side = side_offset *= overlap;
} else if (link_ptr->AB_Dir () >= 0 && link_ptr->BA_Dir () >= 0) {
side = side_offset;
} else {
side = 0.0;
}
}
if (side_offset > link_len / 3.0) {
side_offset = link_len / 3.0;
}
offset = side_offset;
//---- check for stops ----
while (stop_ptr->Link_Dir () == link_dir) {
stop_off = UnRound (stop_ptr->Offset ());
length = stop_off - offset;
Link_Shape (link_ptr, dir, points, offset, length, side);
offset = stop_off;
if (j != 1) {
//---- draw the link to the stop ----
pt_itr = points.begin ();
if (side == 0.0 && pt_itr != points.end ()) {
pt_itr++;
}
for (; pt_itr != points.end (); pt_itr++) {
arcview_route.push_back (*pt_itr);
}
pt_itr = --points.end ();
} else {
pt_itr = points.begin ();
}
stop_pt_itr = stop_pt.find (stop_ptr->Stop ());
if (stop_pt_itr != stop_pt.end ()) {
arcview_route.push_back (stop_pt_itr->second);
}
//---- find the next stop -----
if (++j > stops) break;
arcview_route.push_back (*pt_itr);
stop_itr++;
stop = stop_itr->Stop ();
stop_ptr = &stop_array [stop];
}
//---- complete the link ----
if (i < num_legs) {
length = link_len - offset - side_offset;
Link_Shape (link_ptr, dir, points, offset, length, side);
pt_itr = points.begin ();
if (!offset_flag) {
pt_itr++;
}
for (; pt_itr != points.end (); pt_itr++) {
arcview_route.push_back (*pt_itr);
}
}
}
} else {
for (stop_itr = line_itr->begin (); stop_itr != line_itr->end (); stop_itr++) {
stop_ptr = &stop_array [stop_itr->Stop ()];
stop_pt_itr = stop_pt.find (stop_ptr->Stop ());
if (stop_pt_itr == stop_pt.end ()) goto stop_error;
arcview_route.push_back (stop_pt_itr->second);
}
}
if (!arcview_route.Write_Record ()) {
Error (String ("Writing %s") % arcview_route.File_Type ());
}
}
End_Progress ();
arcview_route.Close ();
return;
stop_error:
Error (String ("Route %d Stop %d was Not Found in the Stop File") % line_itr->Route () % stop);
path_error:
Error (String ("Route %d Stop %d was Not Found on Driver Path") % line_itr->Route () % stop_ptr->Stop ());
}
void ArcPlan::Read_Problem (void)
{
int problem, traveler, hhold, person, link, dir;
double offset;
Link_Data *link_ptr;
Show_Message ("Reading %s -- Record", problem_file.File_Type ());
Set_Progress (10000);
//---- read each problem record ----
while (problem_file.Read ()) {
Show_Progress ();
//---- check the problem type ----
problem = problem_file.Problem ();
if (problem < 1 || problem >= max_problem || !problem_type [problem]) continue;
//---- check the household list ----
if (hhlist_flag) {
hhold = problem_file.Household ();
if (hhold_list.Get (&hhold) == NULL) continue;
}
//---- output the problem details ----
link = problem_file.Link ();
if (problem_out && link != 0) {
arcview_problem.Copy_Fields (&problem_file);
dir = problem_file.Dir ();
if (problem_file.LinkDir_Type () == LINK_SIGN) {
if (link < 0) {
link = -link;
dir = 1;
}
}
link_ptr = link_data.Get (link);
if (link_ptr == NULL) {
Write (1, "Warning: Problem Link %d was Not Found", link);
continue;
}
//---- get the link direction ----
if (problem_file.LinkDir_Type () == LINK_NODE) {
if (dir == link_ptr->Anode ()) {
dir = 1;
} else if (dir == link_ptr->Bnode ()) {
dir = 0;
} else {
Write (1, "Warning: Problem Node %d not on Link %d", dir, link);
continue;
}
}
offset = problem_file.Offset ();
if (dir == 1) {
offset = UnRound (link_ptr->Length ()) - offset;
}
Link_Shape (link_ptr, dir, &points, offset, 0.0, 0.0);
arcview_problem.points.Set (1, points [1]);
//Link_Shape (link_ptr, dir, &points, offset, 6.5, 0.0);
//
//Vehicle_Shape (*(points [1]), *(points [points.Num_Points ()]), 2.0, &arcview_problem.points);
if (!arcview_problem.Write_Record ()) {
Error ("Writing ArcView Problem File");
}
num_problem++;
}
hhold = problem_file.Household ();
person = problem_file.Person ();
traveler = hhold * Traveler_Scale () + person;
if (problem_list.Get_Index (traveler) == 0) {
problem_list.Add (traveler);
}
}
End_Progress ();
problem_file.Close ();
arcview_problem.Close ();
Print (2, "Number of Problem Records Read = %d", Progress_Count ());
Print (1, "Number of Problem Travelers Saved = %d", problem_list.Num_Records ());
}
void ArcPlan::Write_Link_Path (Offset_Data *org_ptr, Offset_Data *des_ptr, bool veh_flag)
{
int i, j, dir, num_links, *link, lnk;
double offset, length, side, end_offset;
bool offset_flag;
Link_Data *link_ptr;
offset_flag = (link_offset != 0.0);
side = 0.0;
//---- get the link list ----
offset = org_ptr->Offset ();
link = plan_file.Path (&num_links);
for (i=1; i <= num_links; i++, link++) {
if (*link < 0) {
lnk = -(*link);
dir = 1;
} else {
lnk = *link;
dir = 0;
}
link_ptr = link_data.Get (lnk);
if (link_ptr == NULL) {
Warning ("Traveler %d Link %d was Not Found", plan_file.Traveler (), lnk);
return;
}
length = UnRound (link_ptr->Length ());
//---- process the origin offset ----
if (i == 1) {
if (org_ptr->Link () != lnk) {
Warning ("Traveler %d Link %d does not match Origin Link %d",
plan_file.Traveler (), lnk, org_ptr->Link ());
return;
}
if (i == num_links) {
if (des_ptr->Link () != lnk) goto des_error;
end_offset = des_ptr->Offset ();
if (dir == 0) {
length = end_offset - offset;
if (length == 0.0) length = 0.1;
} else {
length = offset - end_offset;
}
} else if (dir == 0) {
length = length - offset - link_offset;
} else {
length = offset - link_offset;
}
} else if (i == num_links) {
//---- process the destination offset ----
if (des_ptr->Link () != lnk) goto des_error;
end_offset = des_ptr->Offset ();
if (dir == 0) {
offset = link_offset;
length = end_offset - offset;
} else {
offset = length - link_offset;
length = length - end_offset - link_offset;
}
} else {
if (dir == 0) {
offset = link_offset;
} else {
offset = length - link_offset;
}
length -= 2 * link_offset;
}
//---- collect the points ----
if (offset_flag) {
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = link_offset;
} else {
side = 0.0;
}
}
Link_Shape (link_ptr, dir, &points, offset, length, side);
//---- draw the link segment ----
if (side == 0.0 && i > 1) {
j = 2;
} else {
j = 1;
}
for (; j <= points.Num_Points (); j++) {
if (!arcview_plan.points.Add (points [j])) goto point_error;
}
}
return;
point_error:
Error ("Insufficient Memory for %d Points", arcview_plan.points.Num_Points ());
des_error:
Warning ("Traveler %d Link %d does not match Destination Link %d",
plan_file.Traveler (), lnk, des_ptr->Link ());
}
void ArcPlan::Write_Bandwidth (void)
{
int dir_index, dir, link_field, dir_field, volume_field;
double width, offset, length;
XYZ_Point point;
Int_Itr volume;
Dir_Data *dir_ptr;
Link_Data *link_ptr;
link_field = arcview_width.Field_Number ("LINK");
dir_field = arcview_width.Field_Number ("DIR");
volume_field = arcview_width.Field_Number ("VOLUME");
Show_Message (String ("Writing %s -- Record") % arcview_width.File_Type ());
Set_Progress ();
//---- process each link direction ----
for (dir_index = 0, volume = width_data.begin (); volume != width_data.end (); volume++, dir_index++) {
Show_Progress ();
if (*volume == 0 || *volume < min_value) continue;
//---- write the data fields ----
dir_ptr = &dir_array [dir_index];
link_ptr = &link_array [dir_ptr->Link ()];
arcview_width.Put_Field (link_field, link_ptr->Link ());
arcview_width.Put_Field (dir_field, dir_ptr->Dir ());
arcview_width.Put_Field (volume_field, *volume);
dir = dir_ptr->Dir ();
width = *volume / width_factor;
if (width < min_width) {
width = min_width;
} else if (width > max_width) {
width = max_width;
}
width = -width;
//---- retrieve the link information ----
//length = UnRound (link_ptr->Length ());
//if (dir == 0) {
// offset = 0.0;
//} else {
// offset = length;
//}
offset = length = -1;
//---- get the centerline points ----
arcview_width.clear ();
Link_Shape (link_ptr, dir, points, offset, length, 0.0);
point = points [0];
arcview_width.assign (points.begin (), points.end ());
//---- get the outside points of the band ----
//offset = length - offset;
dir = 1 - dir;
Link_Shape (link_ptr, dir, points, offset, length, width);
if (max_angle > 0 && min_length > 0) {
Smooth_Shape (points, max_angle, min_length);
}
arcview_width.insert (arcview_width.end (), points.begin (), points.end ());
//---- close the polygon ----
arcview_width.push_back (point);
//---- write the shape record ----
if (!arcview_width.Write_Record ()) {
Error (String ("Writing %s") % arcview_width.File_Type ());
}
num_width++;
}
End_Progress ();
arcview_width.Close ();
}
void ArcDelay::Read_Link_Data (void)
{
int i, center, link, lane, num_lanes, num_rec;
double length, side, start, width;
bool offset_flag;
XYZ_Point point, *ptr;
Link_Data *link_ptr;
Node_Data *node_ptr;
Dir_Data *dir_ptr;
offset_flag = (link_offset != 0.0);
Show_Message ("Reading %s -- Record", arcview_link_data.File_Type ());
Set_Progress (1000);
num_rec = 0;
//---- process each link ----
while (link_data_file.Read ()) {
Show_Progress ();
//---- get the link ----
link = link_data_file.Link ();
link_ptr = link_data.Get (link);
if (link_ptr == NULL) continue;
//---- check the subarea polygon ----
if (subarea_flag) {
node_ptr = node_data.Get (link_ptr->Anode ());
if (!In_Polygon (UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()), &select_subarea.points)) {
node_ptr = node_data.Get (link_ptr->Bnode ());
if (!In_Polygon (UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()), &select_subarea.points)) {
continue;
}
}
}
//---- copy the data fields ----
arcview_link_data.Copy_Fields (&link_data_file);
arcview_link_data.parts.Reset ();
arcview_link_data.points.Reset ();
//---- bandwidth processing ----
if (width_flag) {
arcview_link_data.Get_Field (width_field, &width);
if (width == 0.0) continue;
if (width > 0) {
width = width / width_factor;
} else {
width = -width / width_factor;
}
if (width < min_width) {
width = min_width;
} else if (width > max_width) {
width = max_width;
}
width = -width;
length = UnRound (link_ptr->Length ());
//---- get the centerline points ----
Link_Shape (link_ptr, 0, &points, 0.0, length, 0.0);
ptr = points.First ();
point = *ptr;
if (!arcview_link_data.parts.Add (0)) goto mem_error;
for (; ptr; ptr = points.Next ()) {
if (!arcview_link_data.points.Add (ptr)) goto point_error;
}
//---- get the outside points of the band ----
Link_Shape (link_ptr, 1, &points, length, length, width);
if (max_angle > 0 && min_length > 0) {
Smooth_Shape (&points, max_angle, min_length);
}
for (ptr = points.First (); ptr; ptr = points.Next ()) {
if (!arcview_link_data.points.Add (ptr)) goto point_error;
}
//---- close the polygon ----
if (!arcview_link_data.points.Add (&point)) goto point_error;
} else {
//---- draw lanes ----
if (lanes_flag) {
if (link_ptr->AB_Dir () > 0) {
dir_ptr = dir_data [link_ptr->AB_Dir ()];
if (dir_ptr == NULL) continue;
length = UnRound (link_ptr->Length ());
start = UnRound (link_ptr->Aoffset ());
length -= start + UnRound (link_ptr->Boffset ());
lane = dir_ptr->Left ();
num_lanes = dir_ptr->Thru () + lane;
//---- find the center point ----
if (center_flag && link_ptr->BA_Dir () == 0) {
center = num_lanes + dir_ptr->Right () + 1;
} else {
center = 1;
}
for (++lane; lane <= num_lanes; lane++) {
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, 0, &points, start, length, side);
if (!arcview_link_data.parts.Add (arcview_link_data.points.Num_Points ())) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_link_data.points.Add (points [i])) goto mem_error;
}
}
}
if (link_ptr->BA_Dir () > 0) {
dir_ptr = dir_data [link_ptr->BA_Dir ()];
if (dir_ptr == NULL) continue;
length = UnRound (link_ptr->Length ());
start = length - UnRound (link_ptr->Boffset ());
length = start - UnRound (link_ptr->Aoffset ());
lane = dir_ptr->Left ();
num_lanes = dir_ptr->Thru () + lane;
//---- find the center point ----
if (center_flag && link_ptr->AB_Dir () == 0) {
center = num_lanes + dir_ptr->Right () + 1;
} else {
center = 1;
}
for (++lane; lane <= num_lanes; lane++) {
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, 1, &points, start, length, side);
if (!arcview_link_data.parts.Add (arcview_link_data.points.Num_Points ())) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_link_data.points.Add (points [i])) goto mem_error;
}
}
}
} else {
if (offset_flag) {
//---- draw link in AB direction ----
if (link_ptr->AB_Dir () > 0) {
if (center_flag && link_ptr->BA_Dir () == 0) {
side = 0.0;
} else {
side = link_offset;
}
Link_Shape (link_ptr, 0, &points, 0.0, -1.0, side);
if (!arcview_link_data.parts.Add (0)) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_link_data.points.Add (points [i])) goto mem_error;
}
}
//---- draw link in BA direciton ----
if (link_ptr->BA_Dir () > 0) {
if (center_flag && link_ptr->AB_Dir () == 0) {
side = 0.0;
} else {
side = link_offset;
}
Link_Shape (link_ptr, 1, &points, -1.0, -1.0, side);
if (!arcview_link_data.parts.Add (arcview_link_data.points.Num_Points ())) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_link_data.points.Add (points [i])) goto mem_error;
}
}
} else {
//---- draw centerline -----
if (!arcview_link_data.parts.Add (0)) goto mem_error;
Link_Shape (link_ptr, 0, &arcview_link_data.points);
}
}
}
//---- save the link record ----
if (!arcview_link_data.Write_Record ()) {
Error ("Writing %s", arcview_link_data.File_Type ());
}
num_rec++;
}
End_Progress ();
arcview_link_data.Close ();
Print (2, "Number of Arcview Link Data Records = %d", num_rec);
return;
point_error:
Error ("Insufficient Memory for %d Points", arcview_link_data.points.Num_Points ());
mem_error:
Error ("Insufficient Memory for Link Shape Points");
}
void ArcNet::Write_Driver (void)
{
int i, j, dir, overlap;
int route_field, links_field, type_field, subtype_field, notes_field;
double offset, length, side, side_offset;
bool offset_flag, first;
Link_Data *link_ptr;
Driver_Data *driver_ptr;
Db_Base *file;
file = Network_Db_Base (TRANSIT_DRIVER);
route_field = file->Required_Field ("ROUTE");
links_field = file->Required_Field ("LINKS", "NLINKS", "NUM_LINKS");
type_field = file->Optional_Field ("TYPE", "VEHTYPE", "VEH_TYPE");
subtype_field = file->Optional_Field ("SUBTYPE", "SUB_TYPE");
notes_field = file->Optional_Field ("NOTES");
Show_Message ("Writing Transit Driver -- Record");
Set_Progress (1000);
offset_flag = (route_offset != 0.0);
//---- set the overlap count ----
if (!overlap_flag) {
for (link_ptr = link_data.First (); link_ptr; link_ptr = link_data.Next ()) {
link_ptr->Aoffset (0);
link_ptr->Boffset (0);
}
}
//---- process each transit route ----
for (driver_ptr = driver_data.First (); driver_ptr; driver_ptr = driver_data.Next ()) {
Show_Progress ();
arcview_route.Put_Field (route_field, driver_ptr->Route ());
arcview_route.Put_Field (type_field, driver_ptr->Type ());
arcview_route.Put_Field (subtype_field, driver_ptr->Sub_Type ());
arcview_route.Put_Field (links_field, driver_ptr->Links ());
//arcview_route.Put_Field (notes_field, (char *) driver_ptr->Notes ());
arcview_route.points.Reset ();
first = true;
for (i=1; i <= driver_ptr->Links (); i++) {
link_ptr = link_data.Get (driver_ptr->Link (i));
dir = driver_ptr->Dir (i);
offset = length = UnRound (link_ptr->Length ());
side_offset = route_offset;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
if (offset_flag) {
if (!overlap_flag) {
if (dir == 0) {
overlap = link_ptr->Aoffset () + 1;
link_ptr->Aoffset (overlap);
} else {
overlap = link_ptr->Boffset () + 1;
link_ptr->Boffset (overlap);
}
side = side_offset = route_offset * overlap;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
offset -= side_offset;
length -= 2.0 * side_offset;
} else {
offset -= side_offset;
length -= 2.0 * side_offset;
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = side_offset;
} else {
side = 0.0;
}
}
j = 1;
} else if (first) {
j = 1;
first = false;
} else {
j = 2;
}
if (dir == 0) {
Link_Shape (link_ptr, 0, &points, side_offset, length, side);
} else {
Link_Shape (link_ptr, 1, &points, offset, length, side);
}
for (; j <= points.Num_Points (); j++) {
if (!arcview_route.points.Add (points [j])) {
Error ("Insufficient Memory for Transit Driver Shape Points");
}
}
}
if (!arcview_route.Write_Record ()) {
Error ("Writing ArcView Transit Driver File");
}
}
End_Progress ();
arcview_route.Close ();
}
void ArcPerf::Draw_Link (Arcview_File &file, Link_Data *link_ptr, int dir)
{
int lane, center, num_lanes, index;
double length, side, start, width, offset;
bool dir_flag, two_way;
XYZ_Point point;
Dir_Data *dir_ptr;
if (link_ptr->Length () == 0) return;
file.clear ();
file.parts.clear ();
two_way = (dir == 2);
if (two_way) dir = 0;
//---- bandwidth processing ----
if (bandwidth_flag) {
width = file.Get_Double (width_field);
if (width < 0) width = -width;
if (width < min_value || width == 0) return;
width = width / width_factor;
if (width < min_width) {
width = min_width;
} else if (width > max_width) {
width = max_width;
}
width = -width;
offset = length = -1;
//---- get the centerline points ----
side = (two_way) ? (-width / 2.0) : 0.0;
Link_Shape (link_ptr, dir, points, offset, length, side);
point = points [0];
file.parts.push_back ((int) file.size ());
file.assign (points.begin (), points.end ());
//---- get the outside points of the band ----
side = (two_way) ? (width / 2.0) : width;
Link_Shape (link_ptr, 1 - dir, points, offset, length, side);
if (max_angle > 0 && min_length > 0) {
Smooth_Shape (points, max_angle, min_length);
}
file.insert (file.end (), points.begin (), points.end ());
//---- close the polygon ----
file.push_back (point);
} else {
//---- draw lanes ----
if (lanes_flag) {
repeat1:
length = UnRound (link_ptr->Length () - link_ptr->Aoffset () - link_ptr->Boffset ());
width = lane_width / 2.0;
if (dir) {
index = link_ptr->BA_Dir ();
start = UnRound (link_ptr->Boffset ());
dir_flag = (link_ptr->AB_Dir () >= 0);
} else {
index = link_ptr->AB_Dir ();
start = UnRound (link_ptr->Aoffset ());
dir_flag = (link_ptr->BA_Dir () >= 0);
}
if (index >= 0) {
dir_ptr = &dir_array [index];
num_lanes = dir_ptr->Lanes () + dir_ptr->Left ();
if (center_flag && !dir_flag) {
center = num_lanes + dir_ptr->Right () + 1;
} else {
center = 1;
}
for (lane = dir_ptr->Left (); lane < num_lanes; lane++) {
side = (2 + 2 * lane - center) * width;
Link_Shape (link_ptr, dir, points, start, length, side);
file.parts.push_back ((int) file.size ());
if (arrow_flag) Add_Arrow (points);
file.insert (file.end (), points.begin (), points.end ());
}
}
if (two_way && dir == 0) {
dir = 1;
goto repeat1;
}
} else {
if (link_offset != 0.0) {
repeat2:
//---- draw each direction ----
side = link_offset;
if (dir) {
index = link_ptr->BA_Dir ();
if (center_flag && link_ptr->AB_Dir () < 0) side = 0.0;
start = -1.0;
} else {
index = link_ptr->AB_Dir ();
if (center_flag && link_ptr->BA_Dir () < 0) side = 0.0;
start = 0.0;
}
if (index >= 0) {
Link_Shape (link_ptr, dir, points, start, -1.0, side);
file.parts.push_back ((int) file.size ());
if (arrow_flag) Add_Arrow (points);
file.insert (file.end (), points.begin (), points.end ());
}
if (two_way && dir == 0) {
dir = 1;
goto repeat2;
}
} else {
//---- draw centerline -----
file.parts.push_back ((int) file.size ());
if (direction_flag) dir = 0;
Link_Shape (link_ptr, dir, file);
if (arrow_flag) Add_Arrow (file);
}
}
}
//---- write the shape record ----
if (file.size () == 0) return;
if (!file.Write_Record ()) {
Error (String ("Writing %s") % file.File_Type ());
}
}
bool Data_Service::Get_Location_Data (Location_File &file, Location_Data &location_rec)
{
int link, dir, offset;
double setback;
Link_Data *link_ptr;
//---- read and save the data ----
location_rec.Location (file.Location ());
if (location_rec.Location () == 0) return (false);
//---- check/convert the link number and direction ----
link = file.Link ();
dir = file.Dir ();
offset = Round (file.Offset ());
link_ptr = Set_Link_Direction (file, link, dir, offset);
location_rec.Link (link);
location_rec.Dir (dir);
location_rec.Offset (offset);
setback = file.Setback ();
location_rec.Setback (setback);
if (Location_XY_Flag ()) {
Points points;
Link_Shape (link_ptr, dir, points, UnRound (offset), 0.0, setback);
if (points.size () > 0) {
location_rec.X (points [0].x);
location_rec.Y (points [0].y);
} else {
Node_Data *node_ptr = &node_array [link_ptr->Anode ()];
location_rec.X (node_ptr->X ());
location_rec.Y (node_ptr->Y ());
}
}
location_rec.Zone (file.Zone ());
if (location_rec.Zone () > 0 && System_Data_Flag (ZONE)) {
Int_Map_Itr map_itr = zone_map.find (location_rec.Zone ());
if (map_itr == zone_map.end ()) {
Warning (String ("Location %d Zone %d was Not Found") % location_rec.Location () % location_rec.Zone ());
return (false);
}
location_rec.Zone (map_itr->second);
} else if (location_rec.Zone () == 0) {
location_rec.Zone (-1);
//---- delete extra activity location used for transit stops ----
if (file.Version () <= 40) return (false);
}
location_rec.Notes (file.Notes ());
return (true);
}
void ExportNet::New_Links (void)
{
int i, node, link, new_link, count, length, index, park_len, speed, time, dir;
double offset, len, factor;
Int_Map_Itr map_itr;
Link_Data link_data, link_rec;
Split_Itr split_itr, split2_itr;
Link_Split_Itr link_itr;
Points points;
Dir_Data dir_ab, dir_ba, dir_rec;
Shape_Data shape_rec;
Points_Itr pt_itr;
XYZ xyz;
park_len = Round (Internal_Units (20, METERS));
speed = Round (Internal_Units (5, MPS));
time = Round (Internal_Units (20/5, SECONDS));
map_itr = --link_map.end ();
link = map_itr->first;
new_link = ((link + 1) / 100 + 1) * 100;
count = 0;
//---- split links ----
Set_Progress ();
for (link=0, link_itr = link_splits.begin (); link_itr != link_splits.end (); link_itr++, link++) {
if (link_itr->size () == 0) continue;
Show_Progress ();
link_data = link_array [link];
if (link_data.AB_Dir () >= 0) {
dir_ab = dir_array [link_data.AB_Dir ()];
}
if (link_data.BA_Dir () >= 0) {
dir_ba = dir_array [link_data.BA_Dir ()];
}
offset = 0.0;
for (split_itr = split2_itr = link_itr->begin (); split_itr != link_itr->end (); split2_itr = split_itr++) {
link_rec = link_data;
link_rec.Name (link_data.Name ());
index = (int) link_array.size ();
link_rec.Divided (3);
split_itr->link = index;
link_rec.Link (new_link++);
if ((split_itr + 1) != link_itr->end ()) {
link_rec.Bnode (split_itr->node);
length = split_itr->offset;
link_rec.Boffset (0);
} else {
length = link_rec.Length ();
}
if (split_itr != split2_itr) {
link_rec.Anode (split2_itr->node);
length -= split2_itr->offset;
link_rec.Aoffset (0);
offset = UnRound (split2_itr->offset);
}
len = UnRound (length);
link_rec.Length (length);
factor = (double) length / link_data.Length ();
//---- split the link shape ----
if (link_data.Shape () >= 0) {
Link_Shape (&link_data, 0, points, offset, len);
if (points.size () > 2) {
shape_rec.Clear ();
shape_rec.Link (link_rec.Link ());
for (pt_itr = points.begin () + 1; pt_itr != points.end (); pt_itr++) {
xyz.x = Round (pt_itr->x);
xyz.y = Round (pt_itr->y);
xyz.z = Round (pt_itr->z);
shape_rec.push_back (xyz);
}
link_rec.Shape ((int) shape_array.size ());
shape_map.insert (Int_Map_Data (shape_rec.Link (), link_rec.Shape ()));
shape_array.push_back (shape_rec);
} else {
link_rec.Shape (-1);
}
}
//---- process each direction ----
if (link_data.AB_Dir () >= 0) {
dir_rec = dir_ab;
dir_rec.Link (index);
dir_rec.First_Connect_From (-1);
dir_rec.First_Connect_To (-1);
if ((split_itr + 1) != link_itr->end ()) {
dir_rec.First_Pocket (-1);
}
dir_rec.Time0 ((int) (dir_rec.Time0 () * factor + 0.5));
dir = (int) dir_array.size ();
link_rec.AB_Dir (dir);
dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir));
dir_array.push_back (dir_rec);
} else {
link_rec.AB_Dir (-1);
}
if (link_data.BA_Dir () >= 0) {
dir_rec = dir_ba;
dir_rec.Link (index);
dir_rec.First_Connect_From (-1);
dir_rec.First_Connect_To (-1);
if (split_itr != split2_itr) {
dir_rec.First_Pocket (-1);
}
dir_rec.Time0 ((int) (dir_rec.Time0 () * factor + 0.5));
dir = (int) dir_array.size ();
link_rec.BA_Dir (dir);
dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir));
dir_array.push_back (dir_rec);
} else {
link_rec.BA_Dir (-1);
}
//---- insert the link ----
link_map.insert (Int_Map_Data (link_rec.Link (), index));
link_array.push_back (link_rec);
count++;
}
}
//---- add parking connection links ----
Set_Progress ();
for (link=0, link_itr = link_splits.begin (); link_itr != link_splits.end (); link_itr++, link++) {
if (link_itr->size () == 0) continue;
Show_Progress ();
for (split_itr = split2_itr = link_itr->begin (); split_itr != link_itr->end (); split2_itr = split_itr++) {
for (i=0; i < 2; i++) {
index = (int) link_array.size ();
if (i == 0) {
node = split_itr->park_ab;
if (node < 0) continue;
split_itr->link_ab = index;
} else {
node = split_itr->park_ba;
if (node < 0) continue;
split_itr->link_ba = index;
}
link_rec.Clear ();
link_rec.Divided (3);
link_rec.Link (new_link++);
link_rec.Anode (split_itr->node);
link_rec.Bnode (node);
link_rec.Length (park_len);
link_rec.Use (ANY);
link_rec.Type (LOCAL);
link_rec.Name ("Parking");
//---- insert directional data ----
dir_rec.Clear ();
dir_rec.Link (index);
dir_rec.Dir (0);
dir_rec.Lanes (1);
dir_rec.Speed (speed);
dir_rec.Capacity (300);
dir_rec.Time0 (time);
dir_rec.Sign (YIELD_SIGN);
dir = (int) dir_array.size ();
link_rec.AB_Dir (dir);
dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir));
dir_array.push_back (dir_rec);
dir_rec.Dir (1);
dir_rec.Sign (NO_CONTROL);
dir = (int) dir_array.size ();
link_rec.BA_Dir (dir);
dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir));
dir_array.push_back (dir_rec);
//---- insert the link ----
link_map.insert (Int_Map_Data (link_rec.Link (), index));
link_array.push_back (link_rec);
count++;
}
}
}
Print (2, "Number of New Link Records = ") << count;
}
bool ArcNet::Get_Lane_Use_Data (Lane_Use_File &file, Lane_Use_Data &lane_use_rec)
{
int dir, center, lane, lane1, lane2, index, type, pocket;
double length, offset, start, end, side, width, setbacka, setbackb, off, len;
bool dir_flag, left_flag;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Pocket_Data *pocket_ptr;
Points_Itr pt_itr;
if (Data_Service::Get_Lane_Use_Data (file, lane_use_rec)) {
if (arcview_lane_use.Is_Open ()) {
if (time_flag) {
if (lane_use_rec.Start () > time || time > lane_use_rec.End ()) return (false);
}
arcview_lane_use.Copy_Fields (file);
arcview_lane_use.parts.clear ();
arcview_lane_use.clear ();
dir_ptr = &dir_array [lane_use_rec.Dir_Index ()];
dir = dir_ptr->Dir ();
link_ptr = &link_array [dir_ptr->Link ()];
offset = UnRound (lane_use_rec.Offset ());
length = UnRound (lane_use_rec.Length ());
if (offset == 0.0 && length == 0.0) {
offset = 0.0;
length = UnRound (link_ptr->Length ());
}
start = offset;
end = start + length;
length = UnRound (link_ptr->Length ());
if (dir == 0) {
setbacka = UnRound (link_ptr->Aoffset ());
setbackb = UnRound (link_ptr->Boffset ());
dir_flag = (link_ptr->BA_Dir () >= 0);
} else {
setbacka = UnRound (link_ptr->Boffset ());
setbackb = UnRound (link_ptr->Aoffset ());
dir_flag = (link_ptr->AB_Dir () >= 0);
}
if (start < setbacka) start = setbacka;
side = length - setbackb;
if (end > side) end = side;
length = end - start;
offset = start;
//---- draw the lanes ----
if (lanes_flag) {
if (center_flag) {
if (!dir_flag) {
center = dir_ptr->Lanes () + dir_ptr->Left () + dir_ptr->Right () + 1;
} else {
center = 1;
}
} else {
center = 1;
}
//---- set the lane range ----
lane1 = lane_use_rec.Low_Lane ();
lane2 = lane_use_rec.High_Lane ();
width = lane_width / 2.0;
for (lane = lane1; lane <= lane2; lane++) {
side = (2 + 2 * lane - center) * width;
left_flag = (lane < dir_ptr->Left ());
off = offset;
len = length;
if (left_flag || lane >= (dir_ptr->Left () + dir_ptr->Lanes ())) {
for (index = dir_ptr->First_Pocket (); index >= 0; index = pocket_ptr->Next_Index ()) {
pocket_ptr = &pocket_array [index];
type = pocket_ptr->Type ();
pocket = pocket_ptr->Lanes ();
if (type == LEFT_TURN || type == LEFT_MERGE) {
if (!left_flag) continue;
if (lane < (dir_ptr->Left () - pocket)) continue;
} else {
if (left_flag) continue;
if (lane >= dir_ptr->Left () + dir_ptr->Lanes () + pocket) continue;
}
off = UnRound (pocket_ptr->Offset ());
len = UnRound (pocket_ptr->Length ());
if (off > end || (off + len) < start) continue;
len += off;
if (off < start) off = start;
if (len > end) len = end;
len -= off;
if (len < 0) len = 0;
break;
}
if (index < 0) continue;
}
Link_Shape (link_ptr, dir, points, off, len, side);
arcview_lane_use.parts.push_back ((int) arcview_lane_use.size ());
for (pt_itr = points.begin (); pt_itr != points.end (); pt_itr++) {
arcview_lane_use.push_back (*pt_itr);
}
}
} else {
arcview_lane_use.parts.push_back ((int) arcview_lane_use.size ());
Link_Shape (link_ptr, dir, arcview_lane_use, offset, length, 0.0);
}
if (arcview_lane_use.size () > 0) {
if (!arcview_lane_use.Write_Record ()) {
Error (String ("Writing %s") % arcview_lane_use.File_Type ());
}
}
}
}
return (false);
}
void ArcDelay::Write_Turn (void)
{
int i, j, in_dir, vol, period, nperiods, end, time, green, yellow, red;
double length, setback, delay;
char buffer [FIELD_BUFFER], string [STRING_BUFFER];
bool read_flag;
Link_Data *link_ptr;
Connect_Time *connect_ptr;
Range_Data *range_ptr;
Signal_Time *signal_ptr, signal_rec;
Phasing_Data *phase_ptr;
signal_rec.green = 0;
signal_rec.yellow = 0;
signal_rec.red = 0;
//---- process each time period ----
read_flag = false;
nperiods = time_period.Num_Ranges ();
for (period = 1; period <= nperiods; period++) {
range_ptr = time_period [period];
end = range_ptr->High () + 1;
str_cpy (string, sizeof (string), time_period.Range_Format (period));
for (i=j=0; string [i] != '\0'; i++) {
if (string [i] == ':') continue;
if (string [i] == '.' && string [i+1] == '.') {
buffer [j++] = '_';
i++;
} else {
buffer [j++] = string [i];
}
}
buffer [j] = '\0';
//---- create a new shape file ----
str_fmt (string, sizeof (string), "%s_%s.shp", turnname, buffer);
Print (1);
if (!arcview_turn.Open (string)) {
File_Error ("Opening ArcView Turn File", arcview_turn.Shape_Filename ());
}
arcview_turn.Write_Header ();
Show_Message ("Writing %s %s -- Record", arcview_turn.File_Type (), time_period.Format_Time (end));
Set_Progress (1000);
//---- gather phasing times for this time period ----
if (event_flag) {
signal_time.Reset ();
while (read_flag || event_file.Read ()) {
read_flag = false;
time = time_period.Step (event_file.Time ());
if (time < range_ptr->Low ()) continue;
if (time > range_ptr->High ()) break;
if (event_file.Event () != 0) continue;
signal_rec.time = time;
signal_rec.node = event_file.Node ();
signal_rec.plan_phase = (event_file.Plan () << 8);
signal_rec.plan_phase += (event_file.Phase () & 0xFF);
str_cpy (buffer, sizeof (buffer), event_file.Status ());
if (str_cmp (buffer, "Yellow") == 0) {
signal_rec.type = 1;
} else if (str_cmp (buffer, "Red") == 0) {
signal_rec.type = 2;
} else {
signal_rec.type = 0;
}
signal_ptr = (Signal_Time *) signal_time.Get (&signal_rec);
if (signal_ptr == NULL) {
if (!signal_time.Add (&signal_rec)) {
Error ("Adding Signal Timing Record");
}
} else {
time = signal_rec.time - signal_ptr->time;
if (signal_ptr->type == 1) {
signal_ptr->yellow += time;
} else if (signal_ptr->type == 2) {
signal_ptr->red += time;
} else {
signal_ptr->green += time;
}
signal_ptr->type = signal_rec.type;
signal_ptr->time = signal_rec.time;
}
}
read_flag = true;
}
//---- process each connection ----
for (connect_ptr = connect_time.First_Key (); connect_ptr; connect_ptr = connect_time.Next_Key ()) {
Show_Progress ();
if (connect_ptr->Periods () == 0) continue;
link_ptr = link_data.Get (connect_ptr->In_Link ());
in_dir = connect_ptr->In_Dir ();
//---- save the link direction data ----
if (delay_file->LinkDir_Type () == LINK_SIGN) {
if (in_dir == 1) {
delay_file->Link (-link_ptr->Link ());
} else {
delay_file->Link (link_ptr->Link ());
}
} else {
delay_file->Link (link_ptr->Link ());
if (delay_file->LinkDir_Type () == LINK_NODE) {
delay_file->Dir ((in_dir == 1) ? link_ptr->Bnode () : link_ptr->Anode ());
} else {
delay_file->Dir (in_dir);
}
}
//---- get the connection delay ----
vol = connect_ptr->Volume (period);
delay = UnRound (connect_ptr->TTime (period));
if (vol > 0) {
delay /= vol;
}
delay_file->Out_Link (connect_ptr->Out_Link ());
delay_file->Out_Dir (connect_ptr->Out_Dir ());
delay_file->Out_Turn (vol);
delay_file->Out_Time (delay);
//---- save the connection shape ----
delay_file->Nest (false);
arcview_turn.Copy_Fields (delay_file);
delay_file->Nest (true);
arcview_turn.Copy_Fields (delay_file);
if (event_flag) {
green = yellow = red = 0;
for (phase_ptr = phasing_data.First (); phase_ptr; phase_ptr = phasing_data.Next ()) {
if (connect_ptr->In_Link_Dir () == phase_ptr->In_Link_Dir () &&
connect_ptr->Out_Link_Dir () == phase_ptr->Out_Link_Dir ()) {
signal_rec.node = phase_ptr->Node ();
signal_rec.plan_phase = (phase_ptr->Timing () << 8);
signal_rec.plan_phase += (phase_ptr->Phase () & 0xFF);
signal_ptr = (Signal_Time *) signal_time.Get (&signal_rec);
if (signal_ptr != NULL) {
green += signal_ptr->green;
yellow += signal_ptr->yellow;
red += signal_ptr->red;
}
}
}
time = green + yellow + red;
arcview_turn.Put_Field (green_field, green);
arcview_turn.Put_Field (yellow_field, yellow);
arcview_turn.Put_Field (red_field, red);
if (time > 0) {
time = (green * 100 + time / 2) / time;
}
arcview_turn.Put_Field (split_field, time);
}
//---- approach leg ----
arcview_turn.points.Reset ();
if (connect_ptr->In_Dir () == 0) {
length = UnRound (link_ptr->Length ());
setback = UnRound (link_ptr->Boffset ());
Link_Shape (link_ptr, 0, &points, length - setback - 10.0, 10.0, lane_width);
} else {
setback = UnRound (link_ptr->Aoffset ());
Link_Shape (link_ptr, 1, &points, setback + 10.0, 10.0, lane_width);
}
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_turn.points.Add (points [i])) goto mem_error;
}
//---- departure leg ----
link_ptr = link_data.Get (connect_ptr->Out_Link ());
if (connect_ptr->Out_Dir () == 0) {
setback = UnRound (link_ptr->Aoffset ());
Link_Shape (link_ptr, 0, &points, setback, 10.0, lane_width);
} else {
length = UnRound (link_ptr->Length ());
setback = UnRound (link_ptr->Boffset ());
Link_Shape (link_ptr, 1, &points, length - setback, 10.0, lane_width);
}
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_turn.points.Add (points [i])) goto mem_error;
}
//---- save the turn record ----
if (!arcview_turn.Write_Record ()) {
Error ("Writing %s", arcview_turn.File_Type ());
}
}
End_Progress ();
arcview_turn.Close ();
}
return;
mem_error:
Error ("Insufficient Memory for Turn Shape Points");
return;
}
bool ArcNet::Lane_Use_Processing (Db_File *fh)
{
int i, dir, center, lane, num_lanes;
double length, offset, start, end, side;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Lane_Use_Data *lane_use_ptr;
Lane_Use_File *file = (Lane_Use_File *) fh;
if (Network_Service::Lane_Use_Processing (file)) {
arcview_lane_use.Copy_Fields (file);
lane_use_ptr = lane_use_data.New_Record ();
if (select_time) {
if (!time_range.Span_Range (lane_use_ptr->Start (), lane_use_ptr->End ())) return (false);
}
link_ptr = link_data.Get (lane_use_ptr->Link ());
dir = lane_use_ptr->Dir ();
offset = UnRound (lane_use_ptr->Offset ());
length = UnRound (lane_use_ptr->Length ());
if (offset == 0.0 && length == 0.0) {
offset = 0.0;
length = UnRound (link_ptr->Length ());
}
start = offset;
end = start + length;
if (dir == 0) {
side = UnRound (link_ptr->Aoffset ());
if (start < side) start = side;
side = UnRound (link_ptr->Length () - link_ptr->Boffset ());
if (end > side) end = side;
length = end - start;
offset = start;
} else {
side = UnRound (link_ptr->Boffset ());
if (start < side) start = side;
side = UnRound (link_ptr->Length () - link_ptr->Aoffset ());
if (end > side) end = side;
length = end - start;
offset = UnRound (link_ptr->Length ()) - start;
}
if (lanes_flag) {
if (center_flag) {
if (link_ptr->BA_Dir () == 0) {
dir_ptr = dir_data [link_ptr->AB_Dir ()];
center = dir_ptr->Left () + dir_ptr->Thru () + dir_ptr->Right () + 1;
} else if (link_ptr->AB_Dir () == 0) {
dir_ptr = dir_data [link_ptr->BA_Dir ()];
center = dir_ptr->Left () + dir_ptr->Thru () + dir_ptr->Right () + 1;
} else {
center = 1;
}
} else {
center = 1;
}
lane = lane_use_ptr->Lane ();
if (lane == 0) {
if (dir == 0) {
dir_ptr = dir_data [link_ptr->AB_Dir ()];
} else {
dir_ptr = dir_data [link_ptr->BA_Dir ()];
}
lane = dir_ptr->Left ();
num_lanes = lane + dir_ptr->Thru ();
arcview_lane_use.parts.Reset ();
arcview_lane_use.points.Reset ();
for (++lane; lane <= num_lanes; lane++) {
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, dir, &points, offset, length, side);
if (!arcview_lane_use.parts.Add (arcview_lane_use.points.Num_Points ())) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_lane_use.points.Add (points [i])) goto mem_error;
}
}
if (!arcview_lane_use.Write_Record ()) goto write_error;
return (false);
} else {
arcview_lane_use.Num_Parts (1);
side = (2 * lane - center) * lane_width / 2.0;
}
} else {
side = 0.0;
}
if (Link_Shape (link_ptr, dir, &arcview_lane_use.points, offset, length, side)) {
if (!arcview_lane_use.Write_Record ()) goto write_error;
}
}
return (false);
mem_error:
Error ("Insufficient Memory for Lane Use Shape Points");
return (false);
write_error:
Error ("Writing ArcView Lane Use File");
return (false);
}
void Progression::User_Groups (void)
{
int i, num, group, link, dir, node, to_node;
int ttim, ttime, len, length, hrs, hours, volume;
bool first;
Link_Data *in_link_ptr, *out_link_ptr;
TTime_Data *in_dir_ptr, *out_dir_ptr;
Signal_Data *signal_ptr;
Sign_Data *sign_ptr;
Group_Link link_rec;
Group_Data *group_ptr;
Signal_Offset *offset_ptr;
Green_Phase *green_ptr;
Integer_List *list;
Show_Message ("Building Link Groups -- Group");
Set_Progress (1);
for (group = link_equiv.First_Group (); group != 0 ; group = link_equiv.Next_Group ()) {
Show_Progress ();
list = link_equiv.Group_List (group);
if (list == NULL) continue;
group_ptr = new Group_Data (group);
num = group_data.Num_Records () + 1;
in_link_ptr = NULL;
in_dir_ptr = NULL;
node = ttime = length = hours = 0;
first = true;
for (link = list->First (); link != 0; link = list->Next ()) {
if (link < 0) {
link = -link;
dir = 1;
} else {
dir = 0;
}
out_link_ptr = link_data.Get (link);
if (out_link_ptr == NULL) goto link_error;
if (dir == 0) {
to_node = out_link_ptr->Bnode ();
dir = out_link_ptr->AB_Dir ();
} else {
to_node = out_link_ptr->Anode ();
dir = out_link_ptr->BA_Dir ();
}
out_dir_ptr = ttime_data [dir];
if (out_dir_ptr == NULL) goto link_error;
if (in_dir_ptr != NULL) {
//---- get the travel time ----
if (speed_flag) {
ttim = (int) (UnRound (in_link_ptr->Length ()) / progression_speed + 0.5);
} else {
ttim = Resolve (in_dir_ptr->TTime (mid_period));
}
if (ttim < 1) ttim = 1;
len = in_link_ptr->Length ();
volume = in_dir_ptr->Volume (mid_period);
if (volume == 0) volume = 1;
hrs = volume * ttim;
//---- get the node controls ----
signal_ptr = signal_data.Get_LE (node, progression_time);
if (signal_ptr == NULL || signal_ptr->Node () != node) {
sign_ptr = sign_data.Get (in_dir_ptr->Link_Dir ());
if (sign_ptr != NULL && sign_ptr->Sign () == STOP_SIGN) {
Error ("Link %d on Link Group %d has a Stop Sign", in_link_ptr->Link (), group);
}
ttime += ttim;
length += len;
hours += hrs;
} else if (signal_ptr->Type () == ACTUATED) {
Error ("Link %d on Link Group %d has an Actuated Signal", in_link_ptr->Link (), group);
} else {
offset_ptr = signal_offset.Get (signal_data.Record_Index ());
if (offset_ptr == NULL) {
Error ("Signal at Node %d was Not Found", node);
}
if (!offset_ptr->Add_Group (num)) {
Error ("Adding Group to Signal %d", node);
}
//---- get the green phase ----
green_ptr = offset_ptr->Get_Phase (in_dir_ptr->Link_Dir (), out_dir_ptr->Link_Dir ());
if (green_ptr == NULL) {
Error ("A Green Phase between Links %d and %d was Not Found", in_dir_ptr->Link (), out_dir_ptr->Link ());
}
//---- add the link record ----
if (first) {
first = false;
ttime = length = hours = 0;
} else {
ttime += ttim;
length += len;
hours += hrs;
}
link_rec.Node (node);
link_rec.Green (green_ptr->Green_Time ());
link_rec.Offset (green_ptr->Phase_Offset ());
link_rec.Signal (signal_offset.Record_Index ());
link_rec.TTime (ttime);
link_rec.Length (length);
link_rec.VHT (hours);
if (!group_ptr->Add_Link (&link_rec)) {
Error ("Adding Link to Group %d", group);
}
ttime = length = hours = 0;
}
//---- link shape points ----
if (arcview_flag) {
dir = in_dir_ptr->Dir ();
Link_Shape (in_link_ptr, dir, &points, ((dir) ? -1.0 : 0.0), -1.0, link_offset);
for (i=1; i <= points.Num_Points (); i++) {
if (!group_ptr->points.Add (points [i])) {
Error ("Insufficient Memory for Shape Points");
}
}
}
}
in_link_ptr = out_link_ptr;
in_dir_ptr = out_dir_ptr;
node = to_node;
}
//---- draw the last link ----
if (arcview_flag) {
dir = in_dir_ptr->Dir ();
Link_Shape (in_link_ptr, dir, &points, ((dir) ? -1.0 : 0.0), -1.0, link_offset);
for (i=1; i <= points.Num_Points (); i++) {
if (!group_ptr->points.Add (points [i])) {
Error ("Insufficient Memory for Shape Points");
}
}
}
if (!group_data.Add (group_ptr)) {
Error ("Adding Group Data");
}
}
End_Progress ();
return;
link_error:
Error ("Link %d on Link Group %d was Not Found", link, group);
}
void ArcTraveler::Read_Traveler (void)
{
int id_field, veh_field, start_field, end_field, dist_field, ttime_field, speed_field;
int i, traveler, last_traveler, last_spd, last_time, time, nsaved, link, dir, lane, start_time;
double distance, ttime, offset, side, speed;
bool select_flag;
Link_Data *link_ptr;
Point_Data points;
Traveler_Data *data_ptr;
Show_Message ("Reading %s -- Record", traveler_file.File_Type ());
Set_Progress (10000);
select_flag = (travelers.Num_Ranges () > 0);
id_field = arcview_traveler.Field_Number ("TRAVELER");
veh_field = arcview_traveler.Field_Number ("VEHICLE");
start_field = arcview_traveler.Field_Number ("STARTTIME");
end_field = arcview_traveler.Field_Number ("ENDTIME");
dist_field = arcview_traveler.Field_Number ("DISTANCE");
ttime_field = arcview_traveler.Field_Number ("TTIME");
speed_field = arcview_traveler.Field_Number ("SPEED");
if (!traveler_data.Max_Records (MIN (traveler_file.Estimate_Records (), 100000))) goto mem_error;
//---- read and sort the traveler file ----
while (traveler_file.Read ()) {
Show_Progress ();
//---- check the traveler id ----
traveler = traveler_file.Traveler ();
if (select_flag && !travelers.In_Range (traveler)) continue;
//---- check the time ----
time = times.Step (traveler_file.Time ());
if (time_flag && !times.In_Range (time)) continue;
//---- check the location ----
link = traveler_file.Link ();
dir = traveler_file.Dir ();
offset = traveler_file.Offset ();
lane = traveler_file.Lane ();
if (link == 0 || lane == 0) continue;
if (subarea_flag) {
link_ptr = link_data.Get (link);
if (link_ptr == NULL) continue;
if (dir == 0) {
distance = offset;
} else {
distance = UnRound (link_ptr->Length ()) - offset;
}
Link_Shape (link_ptr, dir, &points, distance, 0.0, 0.0);
if (!In_Polygon (points [1]->x, points [1]->y, &select_subarea.points)) continue;
}
//---- save the data record ----
data_ptr = traveler_data.New_Record (true);
if (data_ptr == NULL) goto mem_error;
data_ptr->Traveler (traveler);
data_ptr->Time (time);
data_ptr->Vehicle (traveler_file.Vehicle ());
data_ptr->Link (link);
data_ptr->Dir (dir);
data_ptr->Offset (Round (offset));
data_ptr->Lane (lane);
data_ptr->Distance (Round (traveler_file.Distance ()));
data_ptr->Speed (Round (traveler_file.Speed ()));
if (!traveler_data.Add ()) goto mem_error;
}
End_Progress ();
Print (2, "Number of Traveler Records Read = %d", Progress_Count ());
traveler_file.Close ();
//---- output the selected travelers ----
Show_Message ("Writing %s -- Record", arcview_traveler.File_Type ());
Set_Progress (10000);
last_traveler = last_time = start_time = time = nsaved = 0;
last_spd = 1;
distance = ttime = 0.0;
for (data_ptr = traveler_data.First_Key (); ; data_ptr = traveler_data.Next_Key ()) {
Show_Progress ();
if (data_ptr != NULL) {
traveler = data_ptr->Traveler ();
time = data_ptr->Time ();
}
if (traveler != last_traveler || (last_spd > 0 && (time - last_time) > 1) || data_ptr == NULL) {
if (last_traveler > 0 && last_time > start_time) {
ttime = last_time - start_time;
speed = distance / ttime;
if (speed > 0.01) {
arcview_traveler.Put_Field (end_field, times.Format_Time (last_time));
arcview_traveler.Put_Field (dist_field, distance);
arcview_traveler.Put_Field (ttime_field, ttime);
arcview_traveler.Put_Field (speed_field, distance / ttime);
if (!arcview_traveler.Write_Record ()) {
Error ("Writing ArcView Traveler File");
}
nsaved++;
}
}
if (data_ptr == NULL) break;
last_traveler = traveler;
distance = 0;
arcview_traveler.Put_Field (id_field, traveler);
last_time = start_time = data_ptr->Time ();
last_spd = data_ptr->Speed ();
arcview_traveler.Put_Field (start_field, times.Format_Time (start_time));
arcview_traveler.points.Reset ();
}
if (data_ptr->Vehicle () > 0) {
arcview_traveler.Put_Field (veh_field, data_ptr->Vehicle ());
}
link = data_ptr->Link ();
dir = data_ptr->Dir ();
lane = data_ptr->Lane ();
offset = UnRound (data_ptr->Offset ());
distance += UnRound (data_ptr->Distance ());
last_time = time;
last_spd = data_ptr->Speed ();
link_ptr = link_data.Get (link);
side = (2 * lane - 1) * lane_width / 2.0;
if (dir == 1) offset = UnRound (link_ptr->Length ()) - offset;
Link_Shape (link_ptr, dir, &points, offset, 0.0, side);
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_traveler.points.Add (points [i])) goto mem_error;
}
}
End_Progress ();
arcview_traveler.Close ();
Print (1, "Number of Traveler Records Saved = %d", nsaved);
return;
mem_error:
Error ("Insufficient Memory for Traveler Data");
return;
}
int Data_Service::Put_Link_Data (Link_File &file, Link_Data &data)
{
if (file.Model_Format () == TPPLUS) {
int a, b, count;
double length;
Dir_Data *dir_ptr;
if (data.Length () == 0) return (0);
count = 0;
a = data.Anode ();
b = data.Bnode ();
length = UnRound (data.Length ());
if (System_Data_Flag (NODE)) {
a = node_array [a].Node ();
b = node_array [b].Node ();
}
if (data.AB_Dir () >= 0) {
file.Node_A (a);
file.Node_B (b);
file.Length (length);
file.Type (data.Type ());
dir_ptr = &dir_array [data.AB_Dir ()];
file.Lanes_AB (dir_ptr->Lanes ());
file.Speed_AB (UnRound (dir_ptr->Speed ()));
file.Cap_AB (dir_ptr->Capacity ());
if (file.Dbase_Format () == ARCVIEW) {
Link_Shape (&data, 0, *((Arc_Link_File *) &file));
}
if (!file.Write_Record ()) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
}
if (data.BA_Dir () >= 0) {
file.Node_A (b);
file.Node_B (a);
file.Length (length);
file.Type (data.Type ());
dir_ptr = &dir_array [data.BA_Dir ()];
file.Lanes_AB (dir_ptr->Lanes ());
file.Speed_AB (UnRound (dir_ptr->Speed ()));
file.Cap_AB (dir_ptr->Capacity ());
if (file.Dbase_Format () == ARCVIEW) {
Link_Shape (&data, 1, *((Arc_Link_File *) &file));
}
if (!file.Write_Record ()) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
}
return (count);
}
Dir_Data *dir_ptr;
if (data.Length () == 0) return (0);
file.Link (data.Link ());
file.Name (data.Name ());
file.Node_A (node_array [data.Anode ()].Node ());
file.Node_B (node_array [data.Bnode ()].Node ());
file.Length (UnRound (data.Length ()));
file.Setback_A (UnRound (data.Aoffset ()));
file.Setback_B (UnRound (data.Boffset ()));
file.Type (data.Type ());
file.Divided (data.Divided ());
file.Area_Type (data.Area_Type ());
file.Use (data.Use ());
file.Grade (UnRound (data.Grade ()));
file.Notes (data.Notes ());
if (data.AB_Dir () >= 0) {
dir_ptr = &dir_array [data.AB_Dir ()];
file.Lanes_AB (dir_ptr->Lanes ());
file.Speed_AB (UnRound (dir_ptr->Speed ()));
if (dir_ptr->Time0 () > 0) {
file.Fspd_AB ((double) data.Length () / dir_ptr->Time0 ());
} else {
file.Fspd_AB (UnRound (dir_ptr->Speed ()));
}
if (file.Fspd_AB () > file.Speed_AB () && file.Speed_AB () > 0) {
if ((file.Fspd_AB () - file.Speed_AB ()) > 0.5) {
if (Metric_Flag ()) {
Warning (String ("Link %d Free Flow Speed %.1lf > Maximum Speed %.1lf") % data.Link () % External_Units (file.Fspd_AB (), MPH) %
External_Units (file.Speed_AB (), MPH));
} else {
Warning (String ("Link %d Free Flow Speed %.1lf > Maximum Speed %.1lf") % data.Link () % External_Units (file.Fspd_AB (), MPH) %
External_Units (file.Speed_AB (), MPH));
}
}
file.Fspd_AB (file.Speed_AB ());
}
file.Cap_AB (dir_ptr->Capacity ());
file.Bearing_A (dir_ptr->In_Bearing ());
file.Bearing_B (dir_ptr->Out_Bearing ());
} else {
file.Lanes_AB (0);
file.Speed_AB (0);
file.Fspd_AB (0);
file.Cap_AB (0);
}
if (data.BA_Dir () >= 0) {
dir_ptr = &dir_array [data.BA_Dir ()];
file.Lanes_BA (dir_ptr->Lanes ());
file.Speed_BA (UnRound (dir_ptr->Speed ()));
if (dir_ptr->Time0 () > 0) {
file.Fspd_BA ((double) data.Length () / dir_ptr->Time0 ());
} else {
file.Fspd_BA (UnRound (dir_ptr->Speed ()));
}
if (file.Fspd_BA () > file.Speed_BA () && file.Speed_BA () > 0) {
if ((file.Fspd_BA () - file.Speed_BA ()) > 0.5) {
if (Metric_Flag ()) {
Warning (String ("Link %d Free Flow Speed %.1lf > Maximum Speed %.1lf") % data.Link () % External_Units (file.Fspd_BA (), MPH) %
External_Units (file.Speed_BA (), MPH));
} else {
Warning (String ("Link %d Free Flow Speed %.1lf > Maximum Speed %.1lf") % data.Link () % External_Units (file.Fspd_BA (), MPH) %
External_Units (file.Speed_BA (), MPH));
}
}
file.Fspd_BA (file.Speed_BA ());
}
file.Cap_BA (dir_ptr->Capacity ());
if (data.AB_Dir () < 0) {
file.Bearing_B (compass.Flip (dir_ptr->In_Bearing ()));
file.Bearing_A (compass.Flip (dir_ptr->Out_Bearing ()));
}
} else {
file.Lanes_BA (0);
file.Speed_BA (0);
file.Fspd_BA (0);
file.Cap_BA (0);
}
if (file.Dbase_Format () == ARCVIEW) {
Link_Shape (&data, 0, *((Arc_Link_File *) &file));
}
if (!file.Write_Record ()) {
Error (String ("Writing %s") % file.File_Type ());
}
return (1);
}
void ArcNet::Route_Nodes (void)
{
int i, n, node, node0, route, nroutes, overlap, dir, route_field;
double offset, length, side, side_offset;
bool offset_flag, first;
AB_Data *ab_ptr;
Dir_Data *dir_ptr;
Node_Data *node_ptr;
Link_Data *link_ptr;
Route_Data *route_ptr;
XYZ_Point point;
offset_flag = (route_offset != 0.0);
side = 0.0;
//---- set the overlap count ----
if (!overlap_flag) {
for (link_ptr = link_data.First (); link_ptr; link_ptr = link_data.Next ()) {
link_ptr->Aoffset (0);
link_ptr->Boffset (0);
}
}
//---- write the route file ----
Show_Message ("Writing Transit Routes -- Record");
Set_Progress (100);
nroutes = 0;
route_field = route_header_db.Required_Field ("ROUTE", "LINE");
route_header_db.Rewind ();
while (route_header_db.Read_Record ()) {
Show_Progress ();
arcview_route.points.Reset ();
arcview_route.Copy_Fields (&route_header_db);
route_header_db.Get_Field (route_field, &route);
route_ptr = route_data.Get (route);
if (route_ptr == NULL) continue;
//---- create the path vector ---
node0 = 0;
first = true;
for (n=1; n <= route_ptr->Nodes (); n++) {
node = route_ptr->Node (n);
if (node0 == 0) {
node0 = node;
continue;
}
ab_ptr = ab_key.Get (abs(node0), abs(node));
if (ab_ptr == NULL) {
Warning ("No Link between Nodes %d and %d on Route %d", node0, node, route);
node0 = node;
node_ptr = node_data.Get (abs (node0));
if (node_ptr != NULL) {
point.x = UnRound (node_ptr->X ());
point.y = UnRound (node_ptr->Y ());
point.z = UnRound (node_ptr->Z ());
if (!arcview_route.points.Add (&point)) {
Error ("Insufficient Memory for Route Node Shape Points");
}
}
continue;
}
dir_ptr = dir_data [ab_ptr->dir];
dir = dir_ptr->Dir ();
node0 = node;
link_ptr = link_data.Get (dir_ptr->Link ());
offset = length = UnRound (link_ptr->Length ());
side_offset = route_offset;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
if (offset_flag) {
if (!overlap_flag) {
if (dir == 0) {
overlap = link_ptr->Aoffset () + 1;
link_ptr->Aoffset (overlap);
} else {
overlap = link_ptr->Boffset () + 1;
link_ptr->Boffset (overlap);
}
side = side_offset = route_offset * overlap;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
offset -= side_offset;
length -= 2.0 * side_offset;
} else {
offset -= side_offset;
length -= 2.0 * side_offset;
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = side_offset;
} else {
side = 0.0;
}
}
i = 1;
} else if (first) {
i = 1;
first = false;
} else {
i = 2;
}
if (dir == 0) {
Link_Shape (link_ptr, 0, &points, side_offset, length, side);
} else {
Link_Shape (link_ptr, 1, &points, offset, length, side);
}
for (; i <= points.Num_Points (); i++) {
if (!arcview_route.points.Add (points [i])) {
Error ("Insufficient Memory for Route Node Shape Points");
}
}
}
if (!arcview_route.Write_Record ()) {
Error ("Writing ArcView Route Node File");
}
nroutes++;
}
End_Progress ();
Print (2, "Number of Transit Routes = %d", nroutes);
arcview_route.Close ();
}
bool Turn_Shape (int dir_in, int dir_out, Points &points, double setback, bool curve_flag, double side_in, double side_out, double sub_off, double sub_len)
{
int dir;
double length, offset, max_len, off1, off2;
Dir_Data *dir_ptr;
Link_Data *link_ptr;
Points pts;
Points_Itr pt_itr;
points.clear ();
max_len = 2.0 * setback;
//---- approach leg ----
dir_ptr = &dat->dir_array [dir_in];
dir = dir_ptr->Dir ();
link_ptr = &dat->link_array [dir_ptr->Link ()];
if (dir == 0) {
off1 = dat->UnRound (link_ptr->Boffset ());
off2 = dat->UnRound (link_ptr->Aoffset ());
} else {
off1 = dat->UnRound (link_ptr->Aoffset ());
off2 = dat->UnRound (link_ptr->Boffset ());
}
max_len += off1;
length = dat->UnRound (link_ptr->Length ()) - off1;
offset = length - setback;
if (offset < off2) offset = off2;
length -= offset;
if (length < 0.0) length = 0.0;
Link_Shape (link_ptr, dir, pts, offset, length, side_in);
for (pt_itr = pts.begin (); pt_itr != pts.end (); pt_itr++) {
points.push_back (*pt_itr);
}
//---- departure leg ----
dir_ptr = &dat->dir_array [dir_out];
dir = dir_ptr->Dir ();
link_ptr = &dat->link_array [dir_ptr->Link ()];
length = dat->UnRound (link_ptr->Length () - link_ptr->Aoffset () - link_ptr->Boffset ());
if (length < 0.0) length = 0.0;
if (dir == 0) {
off1 = dat->UnRound (link_ptr->Aoffset ());
} else {
off1 = dat->UnRound (link_ptr->Boffset ());
}
max_len += off1;
offset = off1;
if (length > setback) length = setback;
Link_Shape (link_ptr, dir, pts, offset, length, side_out);
//---- curve connection ----
if (curve_flag) {
Connection_Curve (points, pts);
} else {
for (pt_itr = pts.begin (); pt_itr != pts.end (); pt_itr++) {
points.push_back (*pt_itr);
}
}
//---- extract a subset of points ----
if (sub_off < 0.0) sub_off = 0.0;
if (sub_len < 0.0) sub_len = 0.0;
if (sub_off != 0.0 || sub_len != 0.0) {
return (Sub_Shape (points, sub_off, sub_len, max_len));
} else {
return (true);
}
}
