char *name2;
struct item item;
int direction;
- int straight;
int angle_start;
int angle_end;
struct coord c;
static void
navigation_itm_update(struct navigation_itm *itm, struct item *ritem)
{
- struct attr length, time, straight;
+ struct attr length, time;
if (! item_attr_get(ritem, attr_length, &length)) {
dbg(0,"no length\n");
return;
dbg(0,"no time\n");
return;
}
-
- if (item_attr_get(ritem, attr_route_follow_straight, &straight)) {
- itm->straight = straight.u.num;
- } else {
- itm->straight = 0;
- }
-
dbg(1,"length=%d time=%d\n", length.u.num, time.u.num);
itm->length=length.u.num;
itm->time=time.u.num;
navigation_itm_new(struct navigation *this_, struct item *ritem)
{
struct navigation_itm *ret=g_new0(struct navigation_itm, 1);
- int i=0;
+ int l,i=0;
struct item *sitem;
struct attr street_item,direction;
struct map_rect *mr;
if (item_attr_get(sitem, attr_street_name_systematic, &attr))
ret->name2=map_convert_string(sitem->map,attr.u.str);
navigation_itm_update(ret, ritem);
-
+ l=-1;
while (item_coord_get(ritem, &c[i], 1)) {
dbg(1, "coord %d 0x%x 0x%x\n", i, c[i].x ,c[i].y);
-
+ l=i;
if (i < 4)
i++;
else {
c[3]=c[4];
}
}
- dbg(1,"count=%d\n", i);
- i--;
-
+ dbg(1,"count=%d\n", l);
+ if (l == 4)
+ l=3;
ret->angle_start=road_angle(&c[0], &c[1], 0);
- ret->angle_end=road_angle(&c[i-1], &c[i], 0);
-
+ ret->angle_end=road_angle(&c[l-1], &c[l], 0);
ret->c=c[0];
dbg(1,"i=%d start %d end %d '%s' '%s'\n", i, ret->angle_start, ret->angle_end, ret->name1, ret->name2);
map_rect_destroy(mr);
return ret;
}
-/**
- * @brief Calculates distance and time to the destination
- *
- * This function calculates the distance and the time to the destination of a
- * navigation. If incr is set, this is only calculated for the first navigation
- * item, which is a lot faster than re-calculation the whole destination, but works
- * only if the rest of the navigation already has been calculated.
- *
- * @param this_ The navigation whose destination / time should be calculated
- * @param incr Set this to true to only calculate the first item. See description.
- */
static void
calculate_dest_distance(struct navigation *this_, int incr)
{
dbg(1,"len %d time %d\n", len, time);
}
-/**
- * @brief Checks if two navigation items are on the same street
- *
- * This function checks if two navigation items are on the same street. It returns
- * true if either their name or their "systematic name" (e.g. "A6" or "B256") are the
- * same.
- *
- * @param old The first item to be checked
- * @param new The second item to be checked
- * @return True if both old and new are on the same street
- */
static int
is_same_street2(struct navigation_itm *old, struct navigation_itm *new)
{
return 0;
}
-/**
- * @brief Checks if two navigation items are on the same street
- *
- * This function checks if two navigation items are on the same street. It returns
- * true if the first part of their "systematic name" is equal. If the "systematic name" is
- * for example "A352/E3" (a german highway which at the same time is part of the international
- * E-road network), it would only search for "A352" in the second item's systematic name.
- *
- * @param old The first item to be checked
- * @param new The second item to be checked
- * @return True if the "systematic name" of both items matches. See description.
- */
static int
is_same_street_systematic(struct navigation_itm *old, struct navigation_itm *new)
{
return 1;
}
-/**
- * @brief Checks if navit has to create a maneuver to drive from old to new
- *
- * This function checks if it has to create a "maneuver" - i.e. guide the user - to drive
- * from "old" to "new".
- *
- * @param old The old navigation item, where we're coming from
- * @param new The new navigation item, where we're going to
- * @param delta The angle the user has to steer to navigate from old to new
- * @return True if navit should guide the user, false otherwise
- */
static int
maneuver_required2(struct navigation_itm *old, struct navigation_itm *new, int *delta)
{
return 1;
}
if (*delta < 20 && *delta >-20) {
- if (! new->straight) { /* We're not entering this item straight, so have a maneuver */
- return 1;
- }
-
- dbg(1, "maneuver_required: delta(%d) < 20: no\n", *delta);
+ dbg(1, "maneuver_required: delta(%d) < 20: no\n", *delta);
return 0;
}
dbg(1, "maneuver_required: delta=%d: yes\n", *delta);
if(next->item.type == type_ramp)
return NULL;
if(itm->item.type == type_highway_city || itm->item.type == type_highway_land )
- return g_strdup_printf("%s%s",prefix,_("exit")); /* %FIXME Can this even be reached? */
+ return g_strdup_printf("%s%s",prefix,_("exit"));
else
return g_strdup_printf("%s%s",prefix,_("ramp"));
{
struct map *map;
struct map_rect *mr;
- struct item *ritem; /* Holds an item from the route map */
- struct item *sitem; /* Holds the corresponding item from the actual map */
+ struct item *ritem,*sitem;
struct attr street_item,street_direction;
struct navigation_itm *itm;
int incr=0;
* coordinate of the segment is the first coordinate of the item", <=0
* means reverse. */
unsigned ncoords; /**< How many coordinates does this segment have? */
- struct attr **attrs; /**< Attributes of this route path segment */
struct coord c[0]; /**< Pointer to the ncoords coordinates of this segment */
- /* WARNING: There will be coordinates following here, so do not create new fields after c! */
};
/**
* @param len Length of the item to be added
* @param offset Offset of rgs within the item it represents
* @param dir Order in which to add the coordinates. See route_path_add_item()
- * @param straight Indicates if this segment is being entered "straight". See route_check_straight().
*/
static void
route_path_add_item_from_graph(struct route_path *this, struct route_path *oldpath,
- struct route_graph_segment *rgs, int len, int offset, int dir, int straight)
+ struct route_graph_segment *rgs, int len, int offset, int dir)
{
struct route_path_segment *segment;
int i,ccnt = 0;
struct coord ca[2048];
- struct attr straight_attr;
if (oldpath) {
ccnt = (int)item_hash_lookup(oldpath->path_hash, &rgs->item);
if (ccnt) {
segment = route_extract_segment_from_path(oldpath,
&rgs->item, offset);
-
if (segment)
goto linkold;
}
segment->length=len;
segment->next=NULL;
item_hash_insert(this->path_hash, &rgs->item, (void *)ccnt);
-
- straight_attr.type = attr_route_follow_straight;
- straight_attr.u.num = straight;
-
- segment->attrs = attr_generic_set_attr(segment->attrs, &straight_attr);
-
route_path_add_segment(this, segment);
}
}
/**
- * @brief Calculates of two coordinates' connection
- *
- * This function calculates the angle between coordinates, with north = 0
- * and east = 90.
- *
- * %FIXME This is a duplicate of road_angle() in navigation.c - combine them?
- *
- * @param c1 Coordinate 1
- * @param c2 Coordinate 2
- * @param dir Set to true if c1 is the prior, and c2 the later coordinate.
- * @return The angle of the coordinate's connection
- */
-static int
-route_road_angle(struct coord *c1, struct coord *c2, int dir)
-{
- int ret=transform_get_angle_delta(c1, c2, dir);
- dbg(1, "road_angle(0x%x,0x%x - 0x%x,0x%x)=%d\n", c1->x, c1->y, c2->x, c2->y, ret);
- return ret;
-}
-
-/**
- * @brief Checks if entering one segment from another is a "straight" road
- *
- * This checks if one can enter seg_to from seg_from by driving "straight" - i.e.
- * if seg_to is the segment you can drive to from seg_from by steering less than
- * all to all other segments.
- *
- * This function returns true on failure, so we don't create maneuvers on every error.
- *
- * @param seg_from Segment we are driving from
- * @param seg_to Segment we are driving to
- * @param dir Set to true to indicate that seg_from is left throught its "start" instead through its "end"
- * @return True if driving from seg_from to seg_to is "straight", false otherwise
- */
-static int
-route_check_straight(struct route_graph_segment *seg_from, struct route_graph_segment *seg_to, int dir)
-{
- struct route_graph_segment *curr;
- struct route_graph_point *conn;
- int from_angle, to_angle, curr_angle, angle_diff;
- int ccnt;
- struct coord ca[2048];
-
- if (!dir) {
- if ((seg_from->end != seg_to->start) && (seg_from->end != seg_to->end)) {
- // Not connected!
- return 0;
- }
-
- ccnt = get_item_seg_coords(&seg_from->item, ca, 2047, &seg_from->start->c, &seg_from->end->c);
- from_angle = route_road_angle(&ca[ccnt-2], &ca[ccnt-1],1);
-
- conn = seg_from->end;
- } else {
- if ((seg_from->start != seg_to->start) && (seg_from->start != seg_to->end)) {
- // Not connected!
- return 0;
- }
-
- ccnt = get_item_seg_coords(&seg_from->item, ca, 2, &seg_from->start->c, &seg_from->end->c);
- from_angle = route_road_angle(&ca[1], &ca[0],1);
-
- conn = seg_from->start;
- }
-
- if (seg_to->end == conn) {
- ccnt = get_item_seg_coords(&seg_to->item, ca, 2047, &seg_to->start->c, &seg_to->end->c);
- to_angle = route_road_angle(&ca[ccnt-1], &ca[ccnt-2],1);
- } else {
- ccnt = get_item_seg_coords(&seg_to->item, ca, 2, &seg_to->start->c, &seg_to->end->c);
- to_angle = route_road_angle(&ca[0], &ca[1],1);
- }
-
-
- angle_diff = from_angle - to_angle;
- if (angle_diff < 0) {
- angle_diff *= -1;
- }
-
-
- curr = conn->start;
- while (curr != NULL) {
- if (curr==seg_to) {
- curr = curr->start_next;
- continue;
- }
-
- ccnt = get_item_seg_coords(&curr->item, ca, 2, &curr->start->c, &curr->end->c);
- curr_angle = route_road_angle(&ca[0], &ca[1], 1);
-
- curr_angle = from_angle - curr_angle;
-
- if (curr_angle < 0) {
- curr_angle *= -1;
- }
-
-
- if (curr_angle <= angle_diff) {
- return 0;
- }
-
- curr = curr->start_next;
- }
-
- curr = conn->end;
- while (curr != NULL) {
- if (curr==seg_to) {
- curr = curr->end_next;
- continue;
- }
-
- ccnt = get_item_seg_coords(&curr->item, ca, 2047, &curr->start->c, &curr->end->c);
- curr_angle = route_road_angle(&ca[ccnt-1], &ca[ccnt-2], 1);
-
- curr_angle = from_angle - curr_angle;
-
- if (curr_angle < 0) {
- curr_angle *= -1;
- }
-
- if (curr_angle <= angle_diff) {
- return 0;
- }
-
- curr = curr->end_next;
- }
-
- return 1;
-}
-
-/**
* @brief Creates a new route path
*
* This creates a new non-trivial route. It therefore needs the routing information created by route_graph_flood, so
{
struct route_graph_point *start1=NULL,*start2=NULL,*start;
struct route_graph_segment *s=NULL;
- struct route_graph_segment *lastseg = NULL;
- int is_straight;
int len=0,segs=0;
int seg_len;
#if 0
#endif
seg_len=s->len;
len+=seg_len;
-
- if (lastseg) {
- is_straight = route_check_straight(lastseg,s,(s->end == start));
- } else {
- is_straight = 0;
- }
-
- if (s->start == start) {
- route_path_add_item_from_graph(ret, oldpath, s, seg_len, s->offset, 1, is_straight);
+ if (s->start == start) {
+ route_path_add_item_from_graph(ret, oldpath, s, seg_len, s->offset, 1);
start=s->end;
} else {
- route_path_add_item_from_graph(ret, oldpath, s, seg_len, s->offset, -1, is_straight);
+ route_path_add_item_from_graph(ret, oldpath, s, seg_len, s->offset, -1);
start=s->start;
}
-
- lastseg = s;
}
sd=dst->street;
dbg(1,"start->value=%d 0x%x,0x%x\n", start->value, start->c.x, start->c.y);
}
return 0;
case attr_street_item:
- mr->attr_next=attr_route_follow_straight;
+ mr->attr_next=attr_direction;
if (seg && seg->item.map)
attr->u.item=&seg->item;
else
return 0;
return 1;
- case attr_route_follow_straight:
- mr->attr_next=attr_direction;
- if (seg) {
- return attr_generic_get_attr(seg->attrs,NULL,attr_route_follow_straight,attr,NULL);
- }
- return 0;
case attr_direction:
mr->attr_next=attr_length;
if (seg)
projects / navit-package / commitdiff